• Version 2.8.0
  • Published
  • 3.56 MB
  • No dependencies
  • BSD-3-Clause license


npm i @webcomponents/webcomponentsjs
yarn add @webcomponents/webcomponentsjs
pnpm add @webcomponents/webcomponentsjs


Web Components Polyfills



namespace global

namespace global {}

    variable ShadyCSS

    var ShadyCSS: ShadyCSSInterface;

      variable ShadyDOM

      var ShadyDOM: ShadyDOMInterface;

        variable WebComponents

        var WebComponents: {};

          interface CustomElementRegistry

          interface CustomElementRegistry {}

            property forcePolyfill

            forcePolyfill?: boolean;

              property noDocumentConstructionObserver

              noDocumentConstructionObserver?: boolean;

                property shadyDomFastWalk

                shadyDomFastWalk?: boolean;

                  method polyfillWrapFlushCallback

                  polyfillWrapFlushCallback: (outer: (fn: () => void) => void) => void;

                    interface HTMLTemplateElementConstructor

                    interface HTMLTemplateElementConstructor {}

                      method bootstrap

                      bootstrap: () => void;

                        interface ShadyCSSInterface

                        interface ShadyCSSInterface {}

                          property ApplyShim

                          ApplyShim?: Object;

                            property cssBuild

                            cssBuild?: string;

                              property CustomStyleInterface

                              CustomStyleInterface?: Object;

                                property disableRuntime

                                disableRuntime: boolean;

                                  property nativeCss

                                  nativeCss: boolean;

                                    property nativeShadow

                                    nativeShadow: boolean;

                                      property ScopingShim

                                      ScopingShim?: {
                                      cssTextArray: Array<string>,
                                      elementName: string
                                      ): void;
                                      flush(): void;

                                        method flushCustomStyles

                                        flushCustomStyles: () => void;

                                          method getComputedStyleValue

                                          getComputedStyleValue: (element: Element, property: string) => string;

                                            method prepareTemplate

                                            prepareTemplate: (
                                            template: HTMLTemplateElement,
                                            elementName: string,
                                            elementExtends?: string
                                            ) => void;

                                              method prepareTemplateDom

                                              prepareTemplateDom: (template: HTMLTemplateElement, elementName: string) => void;

                                                method prepareTemplateStyles

                                                prepareTemplateStyles: (
                                                template: HTMLTemplateElement,
                                                elementName: string,
                                                elementExtends?: string
                                                ) => void;

                                                  method styleDocument

                                                  styleDocument: (properties?: { [name: string]: string }) => void;

                                                    method styleElement

                                                    styleElement: (element: HTMLElement) => void;

                                                      method styleSubtree

                                                      styleSubtree: (
                                                      element: HTMLElement,
                                                      properties?: { [name: string]: string }
                                                      ) => void;

                                                        interface ShadyCSSOptions

                                                        interface ShadyCSSOptions {}

                                                          property cssBuild

                                                          cssBuild?: boolean;

                                                            property disableRuntime

                                                            disableRuntime?: boolean;

                                                              property shimcssproperties

                                                              shimcssproperties?: boolean;

                                                                property shimshadow

                                                                shimshadow?: boolean;

                                                                  interface ShadyDOMInterface

                                                                  interface ShadyDOMInterface {}

                                                                    property flush

                                                                    flush: () => void;

                                                                      property inUse

                                                                      inUse: boolean;

                                                                        property nativeMethods

                                                                        nativeMethods: {
                                                                        querySelectorAll: typeof document.querySelectorAll;

                                                                          property noPatch

                                                                          noPatch: boolean | string;

                                                                            property patchElementProto

                                                                            patchElementProto: (node: Object) => void;

                                                                              property querySelectorImplementation

                                                                              querySelectorImplementation?: 'native' | 'selectorEngine';

                                                                                property wrap

                                                                                wrap: (node: Node) => Node;

                                                                                  type ShadyCSS

                                                                                  type ShadyCSS = ShadyCSSInterface;

                                                                                    type ShadyDOM

                                                                                    type ShadyDOM = ShadyDOMInterface;

                                                                                      Package Files (1)

                                                                                      Dependencies (0)

                                                                                      No dependencies.

                                                                                      Dev Dependencies (9)

                                                                                      Peer Dependencies (0)

                                                                                      No peer dependencies.


                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@webcomponents/webcomponentsjs.

                                                                                      • Markdown
                                                                                      • HTML
                                                                                        <a href="https://www.jsdocs.io/package/@webcomponents/webcomponentsjs"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>