@lwc/synthetic-shadow 2.45.2 → 2.45.3

package/dist/3rdparty/polymer/inner-html.d.ts

@@ -0,0 +1,10 @@
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+export declare function getInnerHTML(node: Node): string;

package/dist/3rdparty/polymer/outer-html.d.ts

@@ -0,0 +1,10 @@
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+export declare function getOuterHTML(node: Node): string;

package/dist/3rdparty/polymer/path-composer.d.ts

@@ -0,0 +1 @@
+export declare function pathComposer(startNode: EventTarget, composed: boolean): EventTarget[];

package/dist/3rdparty/polymer/retarget.d.ts

@@ -0,0 +1,10 @@
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+export declare function retarget(refNode: EventTarget | null, path: EventTarget[]): EventTarget | null;

package/dist/3rdparty/polymer/text-content.d.ts

@@ -0,0 +1,10 @@
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+export declare function getTextContent(node: Node): string;

package/dist/env/document.d.ts

@@ -0,0 +1,24 @@
+declare const DocumentPrototypeActiveElement: (this: Document) => Element | null;
+declare const elementFromPoint: (x: number, y: number) => Element | null;
+declare const elementsFromPoint: (x: number, y: number) => Element[];
+declare const defaultViewGetter: (this: Document) => Window | null;
+declare const createComment: (data: string) => Comment, querySelectorAll: {
+    <K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+    <K_1 extends keyof SVGElementTagNameMap>(selectors: K_1): NodeListOf<SVGElementTagNameMap[K_1]>;
+    <K_2 extends keyof MathMLElementTagNameMap>(selectors: K_2): NodeListOf<MathMLElementTagNameMap[K_2]>;
+    <K_3 extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K_3): NodeListOf<HTMLElementDeprecatedTagNameMap[K_3]>;
+    <E extends Element = Element>(selectors: string): NodeListOf<E>;
+}, getElementById: (elementId: string) => HTMLElement | null, getElementsByClassName: (classNames: string) => HTMLCollectionOf<Element>, getElementsByTagName: {
+    <K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+    <K_1 extends keyof SVGElementTagNameMap>(qualifiedName: K_1): HTMLCollectionOf<SVGElementTagNameMap[K_1]>;
+    <K_2 extends keyof MathMLElementTagNameMap>(qualifiedName: K_2): HTMLCollectionOf<MathMLElementTagNameMap[K_2]>;
+    <K_3 extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K_3): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K_3]>;
+    (qualifiedName: string): HTMLCollectionOf<Element>;
+}, getElementsByTagNameNS: {
+    (namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+    (namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+    (namespaceURI: "http://www.w3.org/1998/Math/MathML", localName: string): HTMLCollectionOf<MathMLElement>;
+    (namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+};
+declare const getElementsByName: (elementName: string) => NodeListOf<HTMLElement>;
+export { elementFromPoint, elementsFromPoint, createComment, DocumentPrototypeActiveElement, querySelectorAll, getElementById, getElementsByClassName, getElementsByName, getElementsByTagName, getElementsByTagNameNS, defaultViewGetter, };

package/dist/env/dom.d.ts

@@ -0,0 +1,5 @@
+declare const eventTargetGetter: (this: Event) => EventTarget;
+declare const eventCurrentTargetGetter: (this: Event) => EventTarget | null;
+declare const focusEventRelatedTargetGetter: (this: FocusEvent) => EventTarget | null;
+declare const composedPath: () => EventTarget[];
+export { composedPath, eventTargetGetter, eventCurrentTargetGetter, focusEventRelatedTargetGetter };

package/dist/env/element.d.ts

@@ -0,0 +1,45 @@
+declare const getAttribute: (qualifiedName: string) => string | null, getBoundingClientRect: () => DOMRect, getElementsByTagName: {
+    <K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+    <K_1 extends keyof SVGElementTagNameMap>(qualifiedName: K_1): HTMLCollectionOf<SVGElementTagNameMap[K_1]>;
+    <K_2 extends keyof MathMLElementTagNameMap>(qualifiedName: K_2): HTMLCollectionOf<MathMLElementTagNameMap[K_2]>;
+    <K_3 extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K_3): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K_3]>;
+    (qualifiedName: string): HTMLCollectionOf<Element>;
+}, getElementsByTagNameNS: {
+    (namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+    (namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+    (namespaceURI: "http://www.w3.org/1998/Math/MathML", localName: string): HTMLCollectionOf<MathMLElement>;
+    (namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+}, hasAttribute: (qualifiedName: string) => boolean, querySelector: {
+    <K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+    <K_1 extends keyof SVGElementTagNameMap>(selectors: K_1): SVGElementTagNameMap[K_1] | null;
+    <K_2 extends keyof MathMLElementTagNameMap>(selectors: K_2): MathMLElementTagNameMap[K_2] | null;
+    <K_3 extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K_3): HTMLElementDeprecatedTagNameMap[K_3] | null;
+    <E extends Element = Element>(selectors: string): E | null;
+}, querySelectorAll: {
+    <K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+    <K_1 extends keyof SVGElementTagNameMap>(selectors: K_1): NodeListOf<SVGElementTagNameMap[K_1]>;
+    <K_2 extends keyof MathMLElementTagNameMap>(selectors: K_2): NodeListOf<MathMLElementTagNameMap[K_2]>;
+    <K_3 extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K_3): NodeListOf<HTMLElementDeprecatedTagNameMap[K_3]>;
+    <E extends Element = Element>(selectors: string): NodeListOf<E>;
+}, removeAttribute: (qualifiedName: string) => void, setAttribute: (qualifiedName: string, value: string) => void;
+declare const attachShadow: (init: ShadowRootInit) => ShadowRoot;
+declare const childElementCountGetter: (this: ParentNode) => number;
+declare const firstElementChildGetter: (this: ParentNode) => Element | null;
+declare const lastElementChildGetter: (this: ParentNode) => Element | null;
+declare const innerTextGetter: ((this: Element) => string) | null;
+declare const innerTextSetter: ((this: Element, s: string) => void) | null;
+declare const outerTextGetter: ((this: Element) => string) | null;
+declare const outerTextSetter: ((this: Element, s: string) => void) | null;
+declare const innerHTMLGetter: (this: Element) => string;
+declare const innerHTMLSetter: (this: Element, s: string) => void;
+declare const outerHTMLGetter: (this: Element) => string;
+declare const outerHTMLSetter: (this: Element, s: string) => void;
+declare const tagNameGetter: (this: Element) => string;
+declare const tabIndexGetter: (this: HTMLElement) => number;
+declare const tabIndexSetter: (this: HTMLElement, v: any) => void;
+declare const matches: (this: Element, selector: string) => boolean;
+declare const childrenGetter: (this: ParentNode) => HTMLCollectionOf<Element>;
+declare const getElementsByClassName: (classNames: string) => HTMLCollectionOf<Element>;
+declare const shadowRootGetter: (this: Element) => ShadowRoot | null;
+declare const assignedSlotGetter: (this: Element) => HTMLSlotElement | null;
+export { attachShadow, childrenGetter, childElementCountGetter, firstElementChildGetter, getAttribute, getBoundingClientRect, getElementsByClassName, getElementsByTagName, getElementsByTagNameNS, hasAttribute, innerHTMLGetter, innerHTMLSetter, innerTextGetter, innerTextSetter, lastElementChildGetter, matches, outerHTMLGetter, outerHTMLSetter, outerTextGetter, outerTextSetter, querySelector, querySelectorAll, removeAttribute, setAttribute, shadowRootGetter, tagNameGetter, tabIndexGetter, tabIndexSetter, assignedSlotGetter, };

package/dist/env/event-target.d.ts

@@ -0,0 +1,3 @@
+export declare const eventTargetPrototype: EventTarget;
+declare const addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void, dispatchEvent: (event: Event) => boolean, removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+export { addEventListener, dispatchEvent, removeEventListener };

package/dist/env/mutation-observer.d.ts

@@ -0,0 +1,6 @@
+declare const MO: {
+    new (callback: MutationCallback): MutationObserver;
+    prototype: MutationObserver;
+};
+declare const MutationObserverObserve: (target: Node, options?: MutationObserverInit | undefined) => void;
+export { MO as MutationObserver, MutationObserverObserve };

package/dist/env/node.d.ts

@@ -0,0 +1,35 @@
+declare const _Node: {
+    new (): Node;
+    prototype: Node;
+    readonly ELEMENT_NODE: 1;
+    readonly ATTRIBUTE_NODE: 2;
+    readonly TEXT_NODE: 3;
+    readonly CDATA_SECTION_NODE: 4;
+    readonly ENTITY_REFERENCE_NODE: 5;
+    readonly ENTITY_NODE: 6;
+    readonly PROCESSING_INSTRUCTION_NODE: 7;
+    readonly COMMENT_NODE: 8;
+    readonly DOCUMENT_NODE: 9;
+    readonly DOCUMENT_TYPE_NODE: 10;
+    readonly DOCUMENT_FRAGMENT_NODE: 11;
+    readonly NOTATION_NODE: 12;
+    readonly DOCUMENT_POSITION_DISCONNECTED: 1;
+    readonly DOCUMENT_POSITION_PRECEDING: 2;
+    readonly DOCUMENT_POSITION_FOLLOWING: 4;
+    readonly DOCUMENT_POSITION_CONTAINS: 8;
+    readonly DOCUMENT_POSITION_CONTAINED_BY: 16;
+    readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
+};
+declare const DOCUMENT_POSITION_CONTAINED_BY: 16, DOCUMENT_POSITION_CONTAINS: 8, DOCUMENT_POSITION_PRECEDING: 2, DOCUMENT_POSITION_FOLLOWING: 4, ELEMENT_NODE: 1, TEXT_NODE: 3, CDATA_SECTION_NODE: 4, PROCESSING_INSTRUCTION_NODE: 7, COMMENT_NODE: 8, DOCUMENT_FRAGMENT_NODE: 11;
+declare const appendChild: <T extends Node>(node: T) => T, cloneNode: (deep?: boolean | undefined) => Node, compareDocumentPosition: (other: Node) => number, insertBefore: <T extends Node>(node: T, child: Node | null) => T, removeChild: <T extends Node>(child: T) => T, replaceChild: <T extends Node>(node: Node, child: T) => T, hasChildNodes: () => boolean;
+declare const contains: (other: Node | null) => boolean;
+declare const firstChildGetter: (this: Node) => ChildNode | null;
+declare const lastChildGetter: (this: Node) => ChildNode | null;
+declare const textContentGetter: (this: Node) => string;
+declare const parentNodeGetter: (this: Node) => (Node & ParentNode) | null;
+declare const ownerDocumentGetter: (this: Node) => Document | null;
+declare const parentElementGetter: (this: Node) => Element | null;
+declare const textContextSetter: (this: Node, s: string) => void;
+declare const childNodesGetter: (this: Node) => NodeListOf<Node & Element>;
+declare const isConnected: () => any;
+export { _Node as Node, appendChild, childNodesGetter, cloneNode, compareDocumentPosition, insertBefore, isConnected, parentElementGetter, parentNodeGetter, removeChild, replaceChild, textContextSetter, ownerDocumentGetter, hasChildNodes, contains, firstChildGetter, lastChildGetter, textContentGetter, DOCUMENT_POSITION_CONTAINS, DOCUMENT_POSITION_CONTAINED_BY, DOCUMENT_POSITION_PRECEDING, DOCUMENT_POSITION_FOLLOWING, ELEMENT_NODE, TEXT_NODE, CDATA_SECTION_NODE, PROCESSING_INSTRUCTION_NODE, COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, };

package/dist/env/shadow-root.d.ts

@@ -0,0 +1,2 @@
+export declare const isNativeShadowRootDefined: boolean;
+export declare const isInstanceOfNativeShadowRoot: (node: any) => boolean;

package/dist/env/slot.d.ts

@@ -0,0 +1,2 @@
+declare let assignedNodes: (options?: AssignedNodesOptions) => Node[], assignedElements: (options?: AssignedNodesOptions) => Element[];
+export { assignedNodes, assignedElements };

package/dist/env/text.d.ts

@@ -0,0 +1 @@
+export declare const assignedSlotGetter: (this: Text) => HTMLSlotElement | null;

package/dist/env/window.d.ts

@@ -0,0 +1,8 @@
+declare const windowAddEventListener: {
+    <K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+} & typeof addEventListener, windowRemoveEventListener: {
+    <K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+} & typeof removeEventListener, windowGetComputedStyle: ((elt: Element, pseudoElt?: string | null | undefined) => CSSStyleDeclaration) & typeof getComputedStyle, windowGetSelection: (() => Selection | null) & typeof getSelection;
+export { windowAddEventListener, windowGetComputedStyle, windowGetSelection, windowRemoveEventListener, };

package/dist/faux-shadow/element.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/faux-shadow/events.d.ts

@@ -0,0 +1,16 @@
+export declare const enum EventListenerContext {
+    CUSTOM_ELEMENT_LISTENER = 0,
+    SHADOW_ROOT_LISTENER = 1,
+    UNKNOWN_LISTENER = 2
+}
+export declare const eventToContextMap: WeakMap<Event, EventListenerContext>;
+/**
+ * Events dispatched on shadow roots actually end up being dispatched on their hosts. This means that the event.target
+ * property of events dispatched on shadow roots always resolve to their host. This function understands this
+ * abstraction and properly returns a reference to the shadow root when appropriate.
+ */
+export declare function getActualTarget(event: Event): EventTarget;
+export declare function addCustomElementEventListener(this: Element, type: string, listener: unknown, _options?: boolean | AddEventListenerOptions): void;
+export declare function removeCustomElementEventListener(this: Element, type: string, listener: unknown, _options?: boolean | AddEventListenerOptions): void;
+export declare function addShadowRootEventListener(sr: ShadowRoot, type: string, listener: unknown, _options?: boolean | AddEventListenerOptions): void;
+export declare function removeShadowRootEventListener(sr: ShadowRoot, type: string, listener: unknown, _options?: boolean | AddEventListenerOptions): void;

package/dist/faux-shadow/focus.d.ts

@@ -0,0 +1,9 @@
+export declare function hostElementFocus(this: HTMLElement): void;
+export declare function getActiveElement(host: HTMLElement): Element | null;
+export declare function disableKeyboardFocusNavigationRoutines(): void;
+export declare function enableKeyboardFocusNavigationRoutines(): void;
+export declare function isKeyboardFocusNavigationRoutineEnabled(): boolean;
+export declare function handleFocus(elm: HTMLElement): void;
+export declare function ignoreFocus(elm: HTMLElement): void;
+export declare function handleFocusIn(elm: HTMLElement): void;
+export declare function ignoreFocusIn(elm: HTMLElement): void;

package/dist/faux-shadow/html-element.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/faux-shadow/no-patch-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This methods filters out elements that are not in the same shadow root of context.
+ * It does not enforce shadow dom semantics if $context is not managed by LWC
+ */
+export declare function getNonPatchedFilteredArrayOfNodes<T extends Node>(context: Element, unfilteredNodes: Array<T>): Array<T>;

package/dist/faux-shadow/node.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This method checks whether or not the content of the node is computed
+ * based on the light-dom slotting mechanism. This applies to synthetic slot elements
+ * and elements with shadow dom attached to them. It doesn't apply to native slot elements
+ * because we don't want to patch the children getters for those elements.
+ */
+export declare function hasMountedChildren(node: Node): boolean;
+/**
+ * These 2 methods are providing a machinery to understand who is accessing the
+ * .childNodes member property of a node. If it is used from inside the synthetic shadow
+ * or from an external invoker. This helps to produce the right output in one very peculiar
+ * case, the IE11 debugging comment for shadowRoot representation on the devtool.
+ */
+export declare function isExternalChildNodeAccessorFlagOn(): boolean;
+export declare const getInternalChildNodes: (node: Node) => NodeListOf<ChildNode>;

package/dist/faux-shadow/portal.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/faux-shadow/shadow-root.d.ts

@@ -0,0 +1,22 @@
+export declare function hasInternalSlot(root: unknown): boolean;
+export type ShadowRootResolver = () => ShadowRoot;
+export declare function getShadowRootResolver(node: Node): undefined | ShadowRootResolver;
+export declare function setShadowRootResolver(node: Node, fn: ShadowRootResolver | undefined): void;
+export declare function isDelegatingFocus(host: HTMLElement): boolean;
+export declare function getHost(root: ShadowRoot): Element;
+export declare function getShadowRoot(elm: Element): ShadowRoot;
+export declare function isSyntheticShadowHost(node: unknown): node is HTMLElement;
+export declare function isSyntheticShadowRoot(node: unknown): node is ShadowRoot;
+export declare function attachShadow(elm: Element, options: ShadowRootInit): ShadowRoot;
+export declare const eventToShadowRootMap: WeakMap<Event, ShadowRoot>;
+export declare function SyntheticShadowRoot(): void;
+export declare namespace SyntheticShadowRoot {
+    var prototype: any;
+}
+/**
+ * This method is only intended to be used in non-production mode in IE11
+ * and its role is to produce a 1-1 mapping between a shadowRoot instance
+ * and a comment node that is intended to use to trick the IE11 DevTools
+ * to show the content of the shadowRoot in the DOM Explorer.
+ */
+export declare function getIE11FakeShadowRootPlaceholder(host: Element): Comment;

package/dist/faux-shadow/shadow-token.d.ts

@@ -0,0 +1,2 @@
+export declare function getShadowToken(node: Node): string | undefined;
+export declare function setShadowToken(node: Node, shadowToken: string | undefined): void;

package/dist/faux-shadow/slot.d.ts

@@ -0,0 +1 @@
+export declare function assignedSlotGetterPatched(this: Element | Text): HTMLSlotElement | null;

package/dist/faux-shadow/text.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/faux-shadow/traverse.d.ts

@@ -0,0 +1,13 @@
+export declare function getNodeOwner(node: Node): HTMLElement | null;
+export declare function isSyntheticSlotElement(node: Node): node is HTMLSlotElement;
+export declare function isSlotElement(node: Node): node is HTMLSlotElement;
+export declare function isNodeOwnedBy(owner: Element, node: Node): boolean;
+export declare function shadowRootChildNodes(root: ShadowRoot): Array<Element & Node>;
+export declare function getAllSlottedMatches<T extends Node>(host: Element, nodeList: NodeList | Node[]): T[];
+export declare function getFirstSlottedMatch(host: Element, nodeList: Element[]): Element | null;
+export declare function getAllMatches<T extends Node>(owner: Element, nodeList: Node[]): T[];
+export declare function getFirstMatch(owner: Element, nodeList: Element[]): Element | null;
+export declare function shadowRootQuerySelector(root: ShadowRoot, selector: string): Element | null;
+export declare function shadowRootQuerySelectorAll(root: ShadowRoot, selector: string): Element[];
+export declare function getFilteredChildNodes(node: Node): Element[];
+export declare function getFilteredSlotAssignedNodes(slot: HTMLElement): Node[];