{"version":3,"file":"pinchZoom.48fb8d.js","mappings":"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","sources":["webpack://frontend/ts_src/Patch/Native.ts","webpack://frontend/ts_src/Utilities.ts","webpack://frontend/ts_src/CustomElementInternals.ts","webpack://frontend/ts_src/custom-elements.ts","webpack://frontend/ts_src/CustomElementState.ts","webpack://frontend/ts_src/Deferred.ts","webpack://frontend/ts_src/DocumentConstructionObserver.ts","webpack://frontend/ts_src/CustomElementRegistry.ts","webpack://frontend/ts_src/Patch/Interface/ParentNode.ts","webpack://frontend/ts_src/Patch/Element.ts","webpack://frontend/ts_src/Patch/Interface/ChildNode.ts","webpack://frontend/ts_src/AlreadyConstructedMarker.ts","webpack://frontend/ts_src/Patch/HTMLElement.ts","webpack://frontend/ts_src/Patch/Document.ts","webpack://frontend/ts_src/Patch/DocumentFragment.ts","webpack://frontend/ts_src/Patch/Node.ts","webpack://frontend/webpack/bootstrap","webpack://frontend/webpack/runtime/compat get default export","webpack://frontend/webpack/runtime/define property getters","webpack://frontend/webpack/runtime/hasOwnProperty shorthand","webpack://frontend/./src/pinch-touch.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nexport const Document_createElement = window.Document.prototype.createElement;\nexport const Document_createElementNS =\n  window.Document.prototype.createElementNS;\nexport const Document_importNode = window.Document.prototype.importNode;\n\nexport const Document_prepend = window.Document.prototype['prepend'];\nexport const Document_append = window.Document.prototype['append'];\nexport const DocumentFragment_prepend =\n  window.DocumentFragment.prototype['prepend'];\nexport const DocumentFragment_append =\n  window.DocumentFragment.prototype['append'];\nexport const Node_cloneNode = window.Node.prototype.cloneNode;\nexport const Node_appendChild = window.Node.prototype.appendChild;\nexport const Node_insertBefore = window.Node.prototype.insertBefore;\nexport const Node_removeChild = window.Node.prototype.removeChild;\nexport const Node_replaceChild = window.Node.prototype.replaceChild;\nexport const Node_textContent = Object.getOwnPropertyDescriptor(\n  window.Node.prototype,\n  'textContent'\n);\nexport const Element_attachShadow = window.Element.prototype['attachShadow'];\nexport const Element_innerHTML = Object.getOwnPropertyDescriptor(\n  window.Element.prototype,\n  'innerHTML'\n);\nexport const Element_getAttribute = window.Element.prototype.getAttribute;\nexport const Element_setAttribute = window.Element.prototype.setAttribute;\nexport const Element_removeAttribute = window.Element.prototype.removeAttribute;\nexport const Element_toggleAttribute = window.Element.prototype.toggleAttribute;\nexport const Element_getAttributeNS = window.Element.prototype.getAttributeNS;\nexport const Element_setAttributeNS = window.Element.prototype.setAttributeNS;\nexport const Element_removeAttributeNS =\n  window.Element.prototype.removeAttributeNS;\nexport const Element_insertAdjacentElement =\n  window.Element.prototype['insertAdjacentElement'];\nexport const Element_insertAdjacentHTML =\n  window.Element.prototype['insertAdjacentHTML'];\nexport const Element_prepend = window.Element.prototype['prepend'];\nexport const Element_append = window.Element.prototype['append'];\nexport const Element_before = window.Element.prototype['before'];\nexport const Element_after = window.Element.prototype['after'];\nexport const Element_replaceWith = window.Element.prototype['replaceWith'];\nexport const Element_remove = window.Element.prototype['remove'];\nexport const HTMLElement = window.HTMLElement;\nexport const HTMLElement_innerHTML = Object.getOwnPropertyDescriptor(\n  window.HTMLElement.prototype,\n  'innerHTML'\n);\nexport const HTMLElement_insertAdjacentElement =\n  window.HTMLElement.prototype['insertAdjacentElement'];\nexport const HTMLElement_insertAdjacentHTML =\n  window.HTMLElement.prototype['insertAdjacentHTML'];\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nconst reservedElementNameSet = new Set<string>();\n// IE11 does not support constructing a set using an iterable.\n[\n  'annotation-xml',\n  'color-profile',\n  'font-face',\n  'font-face-src',\n  'font-face-uri',\n  'font-face-format',\n  'font-face-name',\n  'missing-glyph',\n].forEach((item) => reservedElementNameSet.add(item));\n\nexport function isValidCustomElementName(localName: string) {\n  const reserved = reservedElementNameSet.has(localName);\n  const validForm = /^[a-z][.0-9_a-z]*-[-.0-9_a-z]*$/.test(localName);\n  return !reserved && validForm;\n}\n\n// Note, IE11 doesn't have `document.contains`.\nconst nativeContains = document.contains\n  ? document.contains.bind(document)\n  : document.documentElement.contains.bind(document.documentElement);\n\nexport function isConnected(node: Node) {\n  // Use `Node#isConnected`, if defined.\n  const nativeValue = node.isConnected;\n  if (nativeValue !== undefined) {\n    return nativeValue;\n  }\n  // Optimization: It's significantly faster here to try to use `contains`,\n  // especially on Edge/IE/\n  if (nativeContains(node)) {\n    return true;\n  }\n\n  let current: Node | undefined = node;\n  while (\n    current &&\n    !(current.__CE_isImportDocument || current instanceof Document)\n  ) {\n    current =\n      current.parentNode ||\n      (window.ShadowRoot && current instanceof ShadowRoot\n        ? current.host\n        : undefined);\n  }\n  return !!(\n    current &&\n    (current.__CE_isImportDocument || current instanceof Document)\n  );\n}\n\nexport function childrenFromFragment(\n  fragment: DocumentFragment\n): Array<Element> {\n  // Note, IE doesn't have `children` on document fragments.\n  const nativeChildren = fragment.children;\n  if (nativeChildren) {\n    return Array.prototype.slice.call(nativeChildren);\n  }\n  const children: Array<Element> = [];\n  for (let n = fragment.firstChild; n; n = n.nextSibling) {\n    if (n.nodeType === Node.ELEMENT_NODE) {\n      children.push(n as Element);\n    }\n  }\n  return children;\n}\n\nfunction nextSiblingOrAncestorSibling(root: Node, start: Node) {\n  let node: Node | null = start;\n  while (node && node !== root && !node.nextSibling) {\n    node = node.parentNode;\n  }\n  return !node || node === root ? null : node.nextSibling;\n}\n\nfunction nextNode(root: Node, start: Node) {\n  return start.firstChild\n    ? start.firstChild\n    : nextSiblingOrAncestorSibling(root, start);\n}\n\nexport function walkDeepDescendantElements(\n  root: Node,\n  callback: (elem: Element) => void,\n  visitedImports?: Set<Node>\n) {\n  let node: Node | null = root;\n  while (node) {\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      const element = node as Element;\n\n      callback(element);\n\n      const localName = element.localName;\n      if (localName === 'link' && element.getAttribute('rel') === 'import') {\n        // If this import (polyfilled or not) has its root node available,\n        // walk it.\n        const importNode = (element as HTMLLinkElement).import;\n        if (visitedImports === undefined) {\n          visitedImports = new Set();\n        }\n        if (importNode instanceof Node && !visitedImports.has(importNode)) {\n          // Prevent multiple walks of the same import root.\n          visitedImports.add(importNode);\n\n          for (\n            let child = importNode.firstChild;\n            child;\n            child = child.nextSibling\n          ) {\n            walkDeepDescendantElements(child, callback, visitedImports);\n          }\n        }\n\n        // Ignore descendants of import links to prevent attempting to walk the\n        // elements created by the HTML Imports polyfill that we just walked\n        // above.\n        node = nextSiblingOrAncestorSibling(root, element);\n        continue;\n      } else if (localName === 'template') {\n        // Ignore descendants of templates. There shouldn't be any descendants\n        // because they will be moved into `.content` during construction in\n        // browsers that support template but, in case they exist and are still\n        // waiting to be moved by a polyfill, they will be ignored.\n        node = nextSiblingOrAncestorSibling(root, element);\n        continue;\n      }\n\n      // Walk shadow roots.\n      const shadowRoot = element.__CE_shadowRoot;\n      if (shadowRoot) {\n        for (\n          let child = shadowRoot.firstChild;\n          child;\n          child = child.nextSibling\n        ) {\n          walkDeepDescendantElements(child, callback, visitedImports);\n        }\n      }\n    }\n\n    node = nextNode(root, node);\n  }\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementRegistry from './CustomElementRegistry.js';\nimport {CustomElementState as CEState} from './CustomElementState.js';\nimport * as Native from './Patch/Native.js';\nimport * as Utilities from './Utilities.js';\n\nconst NS_HTML = 'http://www.w3.org/1999/xhtml';\n\nexport default class CustomElementInternals {\n  private readonly _patchesNode: Array<(node: Node) => void> = [];\n  private readonly _patchesElement: Array<(elem: Element) => void> = [];\n  private _hasPatches = false;\n  public readonly shadyDomFastWalk: boolean;\n  public readonly useDocumentConstructionObserver: boolean;\n\n  constructor(options: {\n    shadyDomFastWalk: boolean;\n    noDocumentConstructionObserver: boolean;\n  }) {\n    this.shadyDomFastWalk = options.shadyDomFastWalk;\n    this.useDocumentConstructionObserver = !options.noDocumentConstructionObserver;\n  }\n\n  forEachElement(\n    node: Node,\n    callback: (elem: Element) => void,\n    visitedImports?: Set<Node>\n  ) {\n    const sd = window['ShadyDOM'];\n    if (this.shadyDomFastWalk && sd && sd['inUse']) {\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        const element = node as Element;\n        callback(element);\n      }\n      // most easily gets to document, element, documentFragment\n      if ((node as Element).querySelectorAll!) {\n        const elements = sd['nativeMethods'].querySelectorAll.call(node, '*');\n        for (let i = 0; i < elements.length; i++) {\n          callback(elements[i]);\n        }\n      }\n    } else {\n      Utilities.walkDeepDescendantElements(node, callback, visitedImports);\n    }\n  }\n\n  addNodePatch(patch: (node: Node) => void) {\n    this._hasPatches = true;\n    this._patchesNode.push(patch);\n  }\n\n  addElementPatch(patch: (element: Element) => void) {\n    this._hasPatches = true;\n    this._patchesElement.push(patch);\n  }\n\n  patchTree(node: Node) {\n    if (!this._hasPatches) {\n      return;\n    }\n\n    this.forEachElement(node, (element) => this.patchElement(element));\n  }\n\n  patchNode(node: Node) {\n    if (!this._hasPatches) {\n      return;\n    }\n\n    if (node.__CE_patched) {\n      return;\n    }\n    node.__CE_patched = true;\n\n    for (let i = 0; i < this._patchesNode.length; i++) {\n      this._patchesNode[i](node);\n    }\n  }\n\n  patchElement(element: Element) {\n    if (!this._hasPatches) {\n      return;\n    }\n\n    if (element.__CE_patched) {\n      return;\n    }\n    element.__CE_patched = true;\n\n    for (let i = 0; i < this._patchesNode.length; i++) {\n      this._patchesNode[i](element);\n    }\n\n    for (let i = 0; i < this._patchesElement.length; i++) {\n      this._patchesElement[i](element);\n    }\n  }\n\n  connectTree(root: Node) {\n    const elements: Array<Element> = [];\n\n    this.forEachElement(root, (element) => elements.push(element));\n\n    for (let i = 0; i < elements.length; i++) {\n      const element = elements[i];\n      if (element.__CE_state === CEState.custom) {\n        this.connectedCallback(element);\n      } else {\n        this.upgradeReaction(element as HTMLElement);\n      }\n    }\n  }\n\n  disconnectTree(root: Node) {\n    const elements: Array<Element> = [];\n\n    this.forEachElement(root, (element) => elements.push(element));\n\n    for (let i = 0; i < elements.length; i++) {\n      const element = elements[i];\n      if (element.__CE_state === CEState.custom) {\n        this.disconnectedCallback(element);\n      }\n    }\n  }\n\n  /**\n   * Upgrades all uncustomized custom elements at and below a root node for\n   * which there is a definition. When custom element reaction callbacks are\n   * assumed to be called synchronously (which, by the current DOM / HTML spec\n   * definitions, they are *not*), callbacks for both elements customized\n   * synchronously by the parser and elements being upgraded occur in the same\n   * relative order.\n   *\n   * NOTE: This function, when used to simulate the construction of a tree\n   * that is already created but not customized (i.e. by the parser), does\n   * *not* prevent the element from reading the 'final' (true) state of the\n   * tree. For example, the element, during truly synchronous parsing /\n   * construction would see that it contains no children as they have not yet\n   * been inserted. However, this function does not modify the tree, the\n   * element will (incorrectly) have children. Additionally, self-modification\n   * restrictions for custom element constructors imposed by the DOM spec are\n   * *not* enforced.\n   *\n   *\n   * The following nested list shows the steps extending down from the HTML\n   * spec's parsing section that cause elements to be synchronously created\n   * and upgraded:\n   *\n   * The \"in body\" insertion mode:\n   * https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody\n   * - Switch on token:\n   *   .. other cases ..\n   *   -> Any other start tag\n   *      - [Insert an HTML element](below) for the token.\n   *\n   * Insert an HTML element:\n   * https://html.spec.whatwg.org/multipage/syntax.html#insert-an-html-element\n   * - Insert a foreign element for the token in the HTML namespace:\n   *   https://html.spec.whatwg.org/multipage/syntax.html#insert-a-foreign-element\n   *   - Create an element for a token:\n   *     https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token\n   *     - Will execute script flag is true?\n   *       - (Element queue pushed to the custom element reactions stack.)\n   *     - Create an element:\n   *       https://dom.spec.whatwg.org/#concept-create-element\n   *       - Sync CE flag is true?\n   *         - Constructor called.\n   *         - Self-modification restrictions enforced.\n   *       - Sync CE flag is false?\n   *         - (Upgrade reaction enqueued.)\n   *     - Attributes appended to element.\n   *       (`attributeChangedCallback` reactions enqueued.)\n   *     - Will execute script flag is true?\n   *       - (Element queue popped from the custom element reactions stack.\n   *         Reactions in the popped stack are invoked.)\n   *   - (Element queue pushed to the custom element reactions stack.)\n   *   - Insert the element:\n   *     https://dom.spec.whatwg.org/#concept-node-insert\n   *     - Shadow-including descendants are connected. During parsing\n   *       construction, there are no shadow-*excluding* descendants.\n   *       However, the constructor may have validly attached a shadow\n   *       tree to itself and added descendants to that shadow tree.\n   *       (`connectedCallback` reactions enqueued.)\n   *   - (Element queue popped from the custom element reactions stack.\n   *     Reactions in the popped stack are invoked.)\n   */\n  patchAndUpgradeTree(\n    root: Node,\n    options: {\n      visitedImports?: Set<Node>;\n      upgrade?: (elem: HTMLElement) => void;\n    } = {}\n  ) {\n    const visitedImports = options.visitedImports;\n    const upgrade =\n      options.upgrade || ((element) => this.upgradeReaction(element));\n\n    const elements: Array<Element> = [];\n\n    const gatherElements = (element: Element) => {\n      if (this._hasPatches) {\n        this.patchElement(element);\n      }\n      if (\n        element.localName === 'link' &&\n        element.getAttribute('rel') === 'import'\n      ) {\n        const importElem = element as HTMLLinkElement;\n        // The HTML Imports polyfill sets a descendant element of the link to\n        // the `import` property, specifically this is *not* a Document.\n        const importNode = importElem.import;\n\n        if (importNode instanceof Node) {\n          importNode.__CE_isImportDocument = true;\n          // Connected links are associated with the global registry.\n          importNode.__CE_registry = document.__CE_registry;\n        }\n\n        if (importNode && importNode.readyState === 'complete') {\n          importNode.__CE_documentLoadHandled = true;\n        } else {\n          // If this link's import root is not available, its contents can't\n          // be walked. Wait for 'load' and walk it when it's ready.\n          element.addEventListener('load', () => {\n            const importNode = importElem.import!;\n\n            if (importNode.__CE_documentLoadHandled) {\n              return;\n            }\n            importNode.__CE_documentLoadHandled = true;\n\n            // Clone the `visitedImports` set that was populated sync during\n            // the `patchAndUpgradeTree` call that caused this 'load' handler\n            // to be added. Then, remove *this* link's import node so that we\n            // can walk that import again, even if it was partially walked\n            // later during the same `patchAndUpgradeTree` call.\n            const clonedVisitedImports = new Set<Node>();\n            if (visitedImports) {\n              // IE11 does not support constructing a set using an iterable.\n              visitedImports.forEach((item) => clonedVisitedImports.add(item));\n              clonedVisitedImports.delete(importNode);\n            }\n            this.patchAndUpgradeTree(importNode, {\n              visitedImports: clonedVisitedImports,\n              upgrade,\n            });\n          });\n        }\n      } else {\n        elements.push(element);\n      }\n    };\n\n    // `forEachElement` populates (and internally checks against)\n    // `visitedImports` when traversing a loaded import.\n    this.forEachElement(root, gatherElements, visitedImports);\n\n    for (let i = 0; i < elements.length; i++) {\n      upgrade(elements[i] as HTMLElement);\n    }\n  }\n\n  upgradeReaction(element: HTMLElement) {\n    try {\n      const definition = this._lookupACustomElementDefinition(\n        element.ownerDocument!,\n        element.localName\n      );\n      if (definition) {\n        this._upgradeAnElement(element, definition);\n      }\n    } catch (e: unknown) {\n      this.reportTheException(e);\n    }\n  }\n\n  /**\n   * @see https://html.spec.whatwg.org/multipage/custom-elements.html#concept-upgrade-an-element\n   */\n  private _upgradeAnElement(\n    element: HTMLElement,\n    definition: CustomElementDefinition\n  ) {\n    const currentState = element.__CE_state;\n    if (currentState !== undefined) {\n      return;\n    }\n\n    definition.constructionStack.push(element);\n\n    try {\n      try {\n        const result = new definition.constructorFunction();\n        if (result !== element) {\n          throw new Error(\n            'The custom element constructor did not produce the element being upgraded.'\n          );\n        }\n      } finally {\n        definition.constructionStack.pop();\n      }\n    } catch (e) {\n      element.__CE_state = CEState.failed;\n      throw e;\n    }\n\n    element.__CE_state = CEState.custom;\n    element.__CE_definition = definition;\n\n    // Check `hasAttributes` here to avoid iterating when it's not necessary.\n    if (definition.attributeChangedCallback && element.hasAttributes()) {\n      const observedAttributes = definition.observedAttributes;\n      for (let i = 0; i < observedAttributes.length; i++) {\n        const name = observedAttributes[i];\n        const value = element.getAttribute(name);\n        if (value !== null) {\n          this.attributeChangedCallback(element, name, null, value, null);\n        }\n      }\n    }\n\n    if (Utilities.isConnected(element)) {\n      this.connectedCallback(element);\n    }\n  }\n\n  connectedCallback(element: Element) {\n    const definition = element.__CE_definition!;\n    if (definition.connectedCallback) {\n      try {\n        definition.connectedCallback.call(element);\n      } catch (e: unknown) {\n        this.reportTheException(e);\n      }\n    }\n  }\n\n  disconnectedCallback(element: Element) {\n    const definition = element.__CE_definition!;\n    if (definition.disconnectedCallback) {\n      try {\n        definition.disconnectedCallback.call(element);\n      } catch (e: unknown) {\n        this.reportTheException(e);\n      }\n    }\n  }\n\n  attributeChangedCallback(\n    element: Element,\n    name: string,\n    oldValue?: string | null,\n    newValue?: string | null,\n    namespace?: string | null\n  ) {\n    const definition = element.__CE_definition!;\n    if (\n      definition.attributeChangedCallback &&\n      definition.observedAttributes.indexOf(name) > -1\n    ) {\n      try {\n        definition.attributeChangedCallback.call(\n          element,\n          name,\n          oldValue,\n          newValue,\n          namespace\n        );\n      } catch (e: unknown) {\n        this.reportTheException(e);\n      }\n    }\n  }\n\n  /**\n   * Runs HTML's 'look up a custom element definition', excluding the namespace\n   * check.\n   *\n   * @see https://html.spec.whatwg.org/multipage/custom-elements.html#look-up-a-custom-element-definition\n   */\n  private _lookupACustomElementDefinition(\n    doc: Document,\n    localName: string\n  ): CustomElementDefinition | undefined {\n    // The document must be associated with a registry.\n    const registry = doc.__CE_registry;\n    if (!registry) {\n      return;\n    }\n\n    // Prevent elements created in documents without a browsing context from\n    // upgrading.\n    //\n    // https://html.spec.whatwg.org/multipage/custom-elements.html#look-up-a-custom-element-definition\n    //   \"If document does not have a browsing context, return null.\"\n    //\n    // https://html.spec.whatwg.org/multipage/window-object.html#dom-document-defaultview\n    //   \"The defaultView IDL attribute of the Document interface, on getting,\n    //   must return this Document's browsing context's WindowProxy object, if\n    //   this Document has an associated browsing context, or null otherwise.\"\n    if (!doc.defaultView && !doc.__CE_isImportDocument) {\n      return;\n    }\n\n    return registry.internal_localNameToDefinition(localName);\n  }\n\n  /**\n   * Runs the DOM's 'create an element'. If namespace is not null, then the\n   * native `createElementNS` is used. Otherwise, `createElement` is used.\n   *\n   * Note, the template polyfill only wraps `createElement`, preventing this\n   * function from using `createElementNS` in all cases.\n   *\n   * @see https://dom.spec.whatwg.org/#concept-create-element\n   */\n  createAnElement(\n    doc: Document,\n    localName: string,\n    namespace: string | null\n  ): Element {\n    const registry = doc.__CE_registry;\n    // Only create custom elements if the document is associated with a\n    // registry.\n    if (registry && (namespace === null || namespace === NS_HTML)) {\n      const definition = ((registry as unknown) as CustomElementRegistry).internal_localNameToDefinition(\n        localName\n      );\n      if (definition) {\n        try {\n          const result = new definition.constructorFunction();\n\n          // These conformance checks can't be performed when the user calls\n          // the element's constructor themselves. However, this also true in\n          // native implementations.\n\n          if (\n            result.__CE_state === undefined ||\n            result.__CE_definition === undefined\n          ) {\n            throw new Error(\n              `Failed to construct '${localName}': ` +\n                'The returned value was not constructed with the HTMLElement ' +\n                'constructor.'\n            );\n          }\n\n          if (result.namespaceURI !== NS_HTML) {\n            throw new Error(\n              `Failed to construct '${localName}': ` +\n                \"The constructed element's namespace must be the HTML \" +\n                'namespace.'\n            );\n          }\n\n          // The following Errors should be DOMExceptions but DOMException\n          // isn't constructible in all browsers.\n\n          if (result.hasAttributes()) {\n            throw new Error(\n              `Failed to construct '${localName}': ` +\n                'The constructed element must not have any attributes.'\n            );\n          }\n\n          // ShadyDOM doesn't wrap `#hasChildNodes`, so we check `#firstChild`\n          // instead.\n          if (result.firstChild !== null) {\n            throw new Error(\n              `Failed to construct '${localName}': ` +\n                'The constructed element must not have any children.'\n            );\n          }\n\n          if (result.parentNode !== null) {\n            throw new Error(\n              `Failed to construct '${localName}': ` +\n                'The constructed element must not have a parent node.'\n            );\n          }\n\n          if (result.ownerDocument !== doc) {\n            throw new Error(\n              `Failed to construct '${localName}': ` +\n                \"The constructed element's owner document is incorrect.\"\n            );\n          }\n\n          if (result.localName !== localName) {\n            throw new Error(\n              `Failed to construct '${localName}': ` +\n                \"The constructed element's local name is incorrect.\"\n            );\n          }\n\n          return result;\n        } catch (e: unknown) {\n          this.reportTheException(e);\n\n          // When construction fails, a new HTMLUnknownElement is produced.\n          // However, there's no direct way to create one, so we create a\n          // regular HTMLElement and replace its prototype.\n          const result =\n            namespace === null\n              ? Native.Document_createElement.call(doc, localName)\n              : Native.Document_createElementNS.call(doc, namespace, localName);\n          Object.setPrototypeOf(result, HTMLUnknownElement.prototype);\n          result.__CE_state = CEState.failed;\n          result.__CE_definition = undefined;\n          this.patchElement(result);\n          return result;\n        }\n      }\n    }\n\n    const result =\n      namespace === null\n        ? Native.Document_createElement.call(doc, localName)\n        : Native.Document_createElementNS.call(doc, namespace, localName);\n    this.patchElement(result);\n    return result;\n  }\n\n  /**\n   * Runs the DOM's 'report the exception' algorithm.\n   *\n   * @see https://html.spec.whatwg.org/multipage/webappapis.html#report-the-exception\n   */\n  reportTheException(arg: unknown) {\n    interface ExtendedError extends Error {\n      // Non-standard Safari properties.\n      sourceURL?: string;\n      line?: number;\n      column?: number;\n\n      // Non-standard Firefox properties.\n      fileName?: string;\n      lineNumber?: number;\n      columnNumber?: number;\n    }\n\n    let message = '';\n    let filename = '';\n    let lineno = 0;\n    let colno = 0;\n\n    if (arg instanceof Error) {\n      const error = arg as ExtendedError;\n      message = error.message;\n      filename = error.sourceURL || error.fileName || '';\n      lineno = error.line || error.lineNumber || 0;\n      colno = error.column || error.columnNumber || 0;\n    } else {\n      message = `Uncaught ${String(arg)}`;\n    }\n\n    let event: ErrorEvent | undefined = undefined;\n    if (ErrorEvent.prototype.initErrorEvent === undefined) {\n      event = new ErrorEvent('error', {\n        cancelable: true,\n        message,\n        filename,\n        lineno,\n        colno,\n        error: arg,\n      });\n    } else {\n      event = document.createEvent('ErrorEvent') as ErrorEvent;\n      // initErrorEvent(type, bubbles, cancelable, message, filename, line)\n      event.initErrorEvent!('error', false, true, message, filename, lineno);\n      // Hack for IE, where ErrorEvent#preventDefault does not set\n      // #defaultPrevented to true.\n      event.preventDefault = function (this: ErrorEvent) {\n        Object.defineProperty(this, 'defaultPrevented', {\n          configurable: true,\n          get: function (this: ErrorEvent) {\n            return true;\n          },\n        });\n      };\n    }\n\n    if (event.error === undefined) {\n      Object.defineProperty(event, 'error', {\n        configurable: true,\n        enumerable: true,\n        get: function () {\n          return arg;\n        },\n      });\n    }\n\n    window.dispatchEvent(event);\n    if (!event.defaultPrevented) {\n      // In 'report the exception', UAs may optionally write errors to the\n      // console if their associated ErrorEvent isn't handled during dispatch\n      // (indicated by calling `preventDefault`). In practice, these errors are\n      // always displayed.\n      console.error(arg);\n    }\n  }\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from './CustomElementInternals.js';\nimport CustomElementRegistry from './CustomElementRegistry.js';\nimport PatchDocument from './Patch/Document.js';\nimport PatchDocumentFragment from './Patch/DocumentFragment.js';\nimport PatchElement from './Patch/Element.js';\nimport PatchHTMLElement from './Patch/HTMLElement.js';\nimport PatchNode from './Patch/Node.js';\n\nconst priorCustomElements = window['customElements'];\n\nfunction installPolyfill() {\n  const noDocumentConstructionObserver = !!priorCustomElements?.[\n    'noDocumentConstructionObserver'\n  ];\n  const shadyDomFastWalk = !!priorCustomElements?.['shadyDomFastWalk'];\n\n  const internals = new CustomElementInternals({\n    noDocumentConstructionObserver,\n    shadyDomFastWalk,\n  });\n\n  PatchHTMLElement(internals);\n  PatchDocument(internals);\n  PatchDocumentFragment(internals);\n  PatchNode(internals);\n  PatchElement(internals);\n\n  window[\n    'CustomElementRegistry'\n  ] = (CustomElementRegistry as unknown) as typeof window['CustomElementRegistry'];\n\n  const customElements = new CustomElementRegistry(internals);\n\n  // The main document is associated with the global registry.\n  document.__CE_registry = customElements;\n\n  Object.defineProperty(window, 'customElements', {\n    configurable: true,\n    enumerable: true,\n    value: customElements,\n  });\n}\n\nif (\n  !priorCustomElements ||\n  priorCustomElements['forcePolyfill'] ||\n  typeof priorCustomElements['define'] != 'function' ||\n  typeof priorCustomElements['get'] != 'function'\n) {\n  installPolyfill();\n}\n\n// This is NOT public API and is only meant to work around a GC bug in older\n// versions of Safari that randomly removes the polyfill during tests.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n(window as any)['__CE_installPolyfill'] = installPolyfill;\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nexport const CustomElementState = {\n  custom: 1,\n  failed: 2,\n} as const;\nexport type CustomElementState =\n  | typeof CustomElementState.custom\n  | typeof CustomElementState.failed;\n\nexport default CustomElementState;\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nexport default class Deferred<T> {\n  private _value: T | undefined = undefined;\n\n  private _resolve!: (val: T) => void;\n\n  private readonly _promise: Promise<T>;\n  constructor() {\n    this._promise = new Promise((resolve) => {\n      this._resolve = resolve;\n    });\n  }\n\n  resolve(value: T) {\n    if (this._value) {\n      throw new Error('Already resolved.');\n    }\n\n    this._value = value;\n    this._resolve(value);\n  }\n\n  toPromise() {\n    return this._promise;\n  }\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from './CustomElementInternals.js';\n\nexport default class DocumentConstructionObserver {\n  private readonly _internals: CustomElementInternals;\n  private readonly _document: Document;\n  private _observer: MutationObserver | undefined = undefined;\n  constructor(internals: CustomElementInternals, doc: Document) {\n    this._internals = internals;\n    this._document = doc;\n\n    // Simulate tree construction for all currently accessible nodes in the\n    // document.\n    this._internals.patchAndUpgradeTree(this._document);\n\n    if (this._document.readyState === 'loading') {\n      this._observer = new MutationObserver(this._handleMutations.bind(this));\n\n      // Nodes created by the parser are given to the observer *before* the next\n      // task runs. Inline scripts are run in a new task. This means that the\n      // observer will be able to handle the newly parsed nodes before the\n      // inline script is run.\n      this._observer.observe(this._document, {\n        childList: true,\n        subtree: true,\n      });\n    }\n  }\n\n  disconnect() {\n    if (this._observer) {\n      this._observer.disconnect();\n    }\n  }\n\n  private _handleMutations(mutations: ReadonlyArray<MutationRecord>) {\n    // Once the document's `readyState` is 'interactive' or 'complete', all new\n    // nodes created within that document will be the result of script and\n    // should be handled by patching.\n    const readyState = this._document.readyState;\n    if (readyState === 'interactive' || readyState === 'complete') {\n      this.disconnect();\n    }\n\n    for (let i = 0; i < mutations.length; i++) {\n      const addedNodes = mutations[i].addedNodes;\n      for (let j = 0; j < addedNodes.length; j++) {\n        const node = addedNodes[j];\n        this._internals.patchAndUpgradeTree(node);\n      }\n    }\n  }\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport {AlreadyConstructedMarkerType} from './AlreadyConstructedMarker.js';\nimport CustomElementInternals from './CustomElementInternals.js';\nimport Deferred from './Deferred.js';\nimport DocumentConstructionObserver from './DocumentConstructionObserver.js';\nimport * as Utilities from './Utilities.js';\n\ninterface ElementConstructor {\n  new (): HTMLElement;\n  observedAttributes?: Array<string>;\n}\ntype ConstructorGetter = () => ElementConstructor;\n\n/**\n * @unrestricted\n */\nexport default class CustomElementRegistry {\n  private readonly _localNameToConstructorGetter = new Map<\n    string,\n    ConstructorGetter\n  >();\n  private readonly _localNameToDefinition = new Map<\n    string,\n    CustomElementDefinition\n  >();\n  private readonly _constructorToDefinition = new Map<\n    ElementConstructor,\n    CustomElementDefinition\n  >();\n  private _elementDefinitionIsRunning = false;\n  private readonly _internals: CustomElementInternals;\n  private readonly _whenDefinedDeferred = new Map<\n    string,\n    Deferred<undefined>\n  >();\n\n  /**\n   * The default flush callback triggers the document walk synchronously.\n   */\n  private _flushCallback: (fn: () => void) => void = (fn) => fn();\n  private _flushPending = false;\n\n  /**\n   * A map from `localName`s of definitions that were defined *after* the\n   * last flush to unupgraded elements matching that definition, in document\n   * order. Entries are added to this map when a definition is registered,\n   * but the list of elements is only populated during a flush after which\n   * all of the entries are removed. DO NOT edit outside of `#_flush`.\n   */\n  private readonly _unflushedLocalNames: Array<string> = [];\n\n  private readonly _documentConstructionObserver:\n    | DocumentConstructionObserver\n    | undefined;\n\n  constructor(internals: CustomElementInternals) {\n    this._internals = internals;\n    this._documentConstructionObserver = internals.useDocumentConstructionObserver\n      ? new DocumentConstructionObserver(internals, document)\n      : undefined;\n  }\n\n  polyfillDefineLazy(localName: string, constructorGetter: ConstructorGetter) {\n    if (!(constructorGetter instanceof Function)) {\n      throw new TypeError(\n        'Custom element constructor getters must be functions.'\n      );\n    }\n    this.internal_assertCanDefineLocalName(localName);\n    this._localNameToConstructorGetter.set(localName, constructorGetter);\n    this._unflushedLocalNames.push(localName);\n    // If we've already called the flush callback and it hasn't called back\n    // yet, don't call it again.\n    if (!this._flushPending) {\n      this._flushPending = true;\n      this._flushCallback(() => this._flush());\n    }\n  }\n\n  define(localName: string, constructor: Function) {\n    if (!(constructor instanceof Function)) {\n      throw new TypeError('Custom element constructors must be functions.');\n    }\n\n    this.internal_assertCanDefineLocalName(localName);\n\n    this.internal_reifyDefinition(localName, constructor as ElementConstructor);\n    this._unflushedLocalNames.push(localName);\n    // If we've already called the flush callback and it hasn't called back\n    // yet, don't call it again.\n    if (!this._flushPending) {\n      this._flushPending = true;\n      this._flushCallback(() => this._flush());\n    }\n  }\n\n  internal_assertCanDefineLocalName(localName: string) {\n    if (!Utilities.isValidCustomElementName(localName)) {\n      throw new SyntaxError(`The element name '${localName}' is not valid.`);\n    }\n\n    if (this.internal_localNameToDefinition(localName)) {\n      throw new Error(\n        `A custom element with name ` +\n          `'${localName}' has already been defined.`\n      );\n    }\n\n    if (this._elementDefinitionIsRunning) {\n      throw new Error('A custom element is already being defined.');\n    }\n  }\n\n  internal_reifyDefinition(localName: string, constructor: ElementConstructor) {\n    this._elementDefinitionIsRunning = true;\n\n    let connectedCallback: CustomElementDefinition['connectedCallback'];\n    let disconnectedCallback: CustomElementDefinition['disconnectedCallback'];\n    let adoptedCallback: CustomElementDefinition['adoptedCallback'];\n    let attributeChangedCallback: CustomElementDefinition['attributeChangedCallback'];\n    let observedAttributes: CustomElementDefinition['observedAttributes'];\n    try {\n      const prototype = constructor.prototype;\n      if (!(prototype instanceof Object)) {\n        throw new TypeError(\n          \"The custom element constructor's prototype is not an object.\"\n        );\n      }\n\n      type CEReactionCallback =\n        | 'connectedCallback'\n        | 'disconnectedCallback'\n        | 'adoptedCallback'\n        | 'attributeChangedCallback';\n      const getCallback = function getCallback(name: CEReactionCallback) {\n        const callbackValue = prototype[name];\n        if (\n          callbackValue !== undefined &&\n          !(callbackValue instanceof Function)\n        ) {\n          throw new Error(`The '${name}' callback must be a function.`);\n        }\n        return callbackValue;\n      };\n\n      connectedCallback = getCallback('connectedCallback');\n      disconnectedCallback = getCallback('disconnectedCallback');\n      adoptedCallback = getCallback('adoptedCallback');\n      attributeChangedCallback = getCallback('attributeChangedCallback');\n      // `observedAttributes` should not be read unless an\n      // `attributesChangedCallback` exists\n      observedAttributes =\n        (attributeChangedCallback && constructor['observedAttributes']) || [];\n      // eslint-disable-next-line no-useless-catch\n    } catch (e) {\n      throw e;\n    } finally {\n      this._elementDefinitionIsRunning = false;\n    }\n\n    const definition = {\n      localName,\n      constructorFunction: constructor,\n      connectedCallback,\n      disconnectedCallback,\n      adoptedCallback,\n      attributeChangedCallback,\n      observedAttributes,\n      constructionStack: [] as Array<\n        HTMLElement | AlreadyConstructedMarkerType\n      >,\n    };\n\n    this._localNameToDefinition.set(localName, definition);\n    this._constructorToDefinition.set(\n      definition.constructorFunction,\n      definition\n    );\n\n    return definition;\n  }\n\n  upgrade(node: Node): void {\n    this._internals.patchAndUpgradeTree(node);\n  }\n\n  private _flush() {\n    // If no new definitions were defined, don't attempt to flush. This could\n    // happen if a flush callback keeps the function it is given and calls it\n    // multiple times.\n    if (this._flushPending === false) {\n      return;\n    }\n    this._flushPending = false;\n\n    /**\n     * Unupgraded elements with definitions that were defined *before* the last\n     * flush, in document order.\n     */\n    const elementsWithStableDefinitions: Array<HTMLElement> = [];\n\n    const unflushedLocalNames = this._unflushedLocalNames;\n    const elementsWithPendingDefinitions = new Map<\n      string,\n      Array<HTMLElement>\n    >();\n    for (let i = 0; i < unflushedLocalNames.length; i++) {\n      elementsWithPendingDefinitions.set(unflushedLocalNames[i], []);\n    }\n\n    this._internals.patchAndUpgradeTree(document, {\n      upgrade: (element) => {\n        // Ignore the element if it has already upgraded or failed to upgrade.\n        if (element.__CE_state !== undefined) {\n          return;\n        }\n\n        const localName = element.localName;\n\n        // If there is an applicable pending definition for the element, add the\n        // element to the list of elements to be upgraded with that definition.\n        const pendingElements = elementsWithPendingDefinitions.get(localName);\n        if (pendingElements) {\n          pendingElements.push(element);\n          // If there is *any other* applicable definition for the element, add\n          // it to the list of elements with stable definitions that need to be\n          // upgraded.\n        } else if (this._localNameToDefinition.has(localName)) {\n          elementsWithStableDefinitions.push(element);\n        }\n      },\n    });\n\n    // Upgrade elements with 'stable' definitions first.\n    for (let i = 0; i < elementsWithStableDefinitions.length; i++) {\n      this._internals.upgradeReaction(elementsWithStableDefinitions[i]);\n    }\n\n    // Upgrade elements with 'pending' definitions in the order they were\n    // defined.\n    for (let i = 0; i < unflushedLocalNames.length; i++) {\n      const localName = unflushedLocalNames[i];\n      const pendingUpgradableElements = elementsWithPendingDefinitions.get(\n        localName\n      )!;\n\n      // Attempt to upgrade all applicable elements.\n      for (let i = 0; i < pendingUpgradableElements.length; i++) {\n        this._internals.upgradeReaction(pendingUpgradableElements[i]);\n      }\n\n      // Resolve any promises created by `whenDefined` for the definition.\n      const deferred = this._whenDefinedDeferred.get(localName);\n      if (deferred) {\n        deferred.resolve(undefined);\n      }\n    }\n\n    unflushedLocalNames.length = 0;\n  }\n\n  get(localName: string): undefined | {new (): HTMLElement} {\n    const definition = this.internal_localNameToDefinition(localName);\n    if (definition) {\n      return definition.constructorFunction;\n    }\n\n    return undefined;\n  }\n\n  whenDefined(localName: string): Promise<void> {\n    if (!Utilities.isValidCustomElementName(localName)) {\n      return Promise.reject(\n        new SyntaxError(`'${localName}' is not a valid custom element name.`)\n      );\n    }\n\n    const prior = this._whenDefinedDeferred.get(localName);\n    if (prior) {\n      return prior.toPromise();\n    }\n\n    const deferred = new Deferred<undefined>();\n    this._whenDefinedDeferred.set(localName, deferred);\n\n    // Resolve immediately if the given local name has a regular or lazy\n    // definition *and* the full document walk to upgrade elements with that\n    // local name has already happened.\n    //\n    // The behavior of the returned promise differs between the lazy and the\n    // non-lazy cases if the definition fails. Normally, the definition would\n    // fail synchronously and no pending promises would resolve. However, if\n    // the definition is lazy but has not yet been reified, the promise is\n    // resolved early here even though it might fail later when reified.\n    const anyDefinitionExists =\n      this._localNameToDefinition.has(localName) ||\n      this._localNameToConstructorGetter.has(localName);\n    const definitionHasFlushed =\n      this._unflushedLocalNames.indexOf(localName) === -1;\n    if (anyDefinitionExists && definitionHasFlushed) {\n      deferred.resolve(undefined);\n    }\n\n    return deferred.toPromise();\n  }\n\n  polyfillWrapFlushCallback(outer: (fn: () => void) => void) {\n    if (this._documentConstructionObserver) {\n      this._documentConstructionObserver.disconnect();\n    }\n    const inner = this._flushCallback;\n    this._flushCallback = (flush) => outer(() => inner(flush));\n  }\n\n  internal_localNameToDefinition(\n    localName: string\n  ): CustomElementDefinition | undefined {\n    const existingDefinition = this._localNameToDefinition.get(localName);\n    if (existingDefinition) {\n      return existingDefinition;\n    }\n\n    const constructorGetter = this._localNameToConstructorGetter.get(localName);\n    if (constructorGetter) {\n      this._localNameToConstructorGetter.delete(localName);\n      try {\n        return this.internal_reifyDefinition(localName, constructorGetter());\n      } catch (e: unknown) {\n        this._internals.reportTheException(e);\n      }\n    }\n\n    return undefined;\n  }\n\n  internal_constructorToDefinition(\n    constructor: ElementConstructor\n  ): CustomElementDefinition | undefined {\n    return this._constructorToDefinition.get(constructor);\n  }\n}\n\n// Closure compiler exports.\n/* eslint-disable no-self-assign */\nCustomElementRegistry.prototype['define'] =\n  CustomElementRegistry.prototype.define;\nCustomElementRegistry.prototype['upgrade'] =\n  CustomElementRegistry.prototype.upgrade;\nCustomElementRegistry.prototype['get'] = CustomElementRegistry.prototype.get;\nCustomElementRegistry.prototype['whenDefined'] =\n  CustomElementRegistry.prototype.whenDefined;\nCustomElementRegistry.prototype['polyfillDefineLazy'] =\n  CustomElementRegistry.prototype.polyfillDefineLazy;\nCustomElementRegistry.prototype['polyfillWrapFlushCallback'] =\n  CustomElementRegistry.prototype.polyfillWrapFlushCallback;\n/* eslint-enable no-self-assign */\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\ntype NativeMethod = (this: Node, ...args: Array<Node | string>) => void;\n\ninterface ParentNodeNativeMethods {\n  prepend: NativeMethod;\n  append: NativeMethod;\n}\n\nexport default function (\n  internals: CustomElementInternals,\n  destination: ParentNode,\n  builtIn: ParentNodeNativeMethods\n) {\n  function appendPrependPatch(builtInMethod: NativeMethod): NativeMethod {\n    return function (this: Node, ...nodes) {\n      /**\n       * A copy of `nodes`, with any DocumentFragment replaced by its children.\n       */\n      const flattenedNodes: Array<Node | string> = [];\n\n      /**\n       * Elements in `nodes` that were connected before this call.\n       */\n      const connectedElements: Array<Node> = [];\n\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n\n        if (node instanceof Element && Utilities.isConnected(node)) {\n          connectedElements.push(node);\n        }\n\n        if (node instanceof DocumentFragment) {\n          for (let child = node.firstChild; child; child = child.nextSibling) {\n            flattenedNodes.push(child);\n          }\n        } else {\n          flattenedNodes.push(node);\n        }\n      }\n\n      builtInMethod.apply(this, nodes);\n\n      for (let i = 0; i < connectedElements.length; i++) {\n        internals.disconnectTree(connectedElements[i]);\n      }\n\n      if (Utilities.isConnected(this)) {\n        for (let i = 0; i < flattenedNodes.length; i++) {\n          const node = flattenedNodes[i];\n          if (node instanceof Element) {\n            internals.connectTree(node);\n          }\n        }\n      }\n    };\n  }\n\n  if (builtIn.prepend !== undefined) {\n    destination.prepend = appendPrependPatch(builtIn.prepend);\n  }\n\n  if (builtIn.append !== undefined) {\n    destination.append = appendPrependPatch(builtIn.append);\n  }\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport * as Utilities from '../Utilities.js';\n\nimport PatchChildNode from './Interface/ChildNode.js';\nimport PatchParentNode from './Interface/ParentNode.js';\nimport * as Native from './Native.js';\n\nexport default function (internals: CustomElementInternals) {\n  if (Native.Element_attachShadow) {\n    Element.prototype.attachShadow = function (\n      this: Element,\n      init: ShadowRootInit\n    ) {\n      const shadowRoot = Native.Element_attachShadow.call(this, init);\n      internals.patchNode(shadowRoot);\n      this.__CE_shadowRoot = shadowRoot;\n      return shadowRoot;\n    };\n  }\n\n  function patch_innerHTML(\n    destination: Element,\n    baseDescriptor: PropertyDescriptor\n  ) {\n    Object.defineProperty(destination, 'innerHTML', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: function (this: Element, htmlString) {\n        const isConnected = Utilities.isConnected(this);\n\n        // NOTE: In IE11, when using the native `innerHTML` setter, all nodes\n        // that were previously descendants of the context element have all of\n        // their children removed as part of the set - the entire subtree is\n        // 'disassembled'. This work around walks the subtree *before* using the\n        // native setter.\n        let removedElements: undefined | Array<Element> = undefined;\n        if (isConnected) {\n          removedElements = [];\n          internals.forEachElement(this, (element) => {\n            if (element !== this) {\n              removedElements!.push(element);\n            }\n          });\n        }\n\n        baseDescriptor.set!.call(this, htmlString);\n\n        if (removedElements) {\n          for (let i = 0; i < removedElements.length; i++) {\n            const element = removedElements[i];\n            if (element.__CE_state === CEState.custom) {\n              internals.disconnectedCallback(element);\n            }\n          }\n        }\n\n        // Only create custom elements if this element's owner document is\n        // associated with the registry.\n        if (!this.ownerDocument!.__CE_registry) {\n          internals.patchTree(this);\n        } else {\n          internals.patchAndUpgradeTree(this);\n        }\n        return htmlString;\n      },\n    });\n  }\n\n  if (Native.Element_innerHTML && Native.Element_innerHTML.get) {\n    patch_innerHTML(Element.prototype, Native.Element_innerHTML);\n  } else if (Native.HTMLElement_innerHTML && Native.HTMLElement_innerHTML.get) {\n    patch_innerHTML(HTMLElement.prototype, Native.HTMLElement_innerHTML);\n  } else {\n    internals.addElementPatch(function (element) {\n      patch_innerHTML(element, {\n        enumerable: true,\n        configurable: true,\n        // Implements getting `innerHTML` by performing an unpatched `cloneNode`\n        // of the element and returning the resulting element's `innerHTML`.\n        // TODO: Is this too expensive?\n        get: function (this: Element) {\n          return (Native.Node_cloneNode.call(this, true) as Element).innerHTML;\n        },\n        // Implements setting `innerHTML` by creating an unpatched element,\n        // setting `innerHTML` of that element and replacing the target\n        // element's children with those of the unpatched element.\n        set: function (this: Element, assignedValue) {\n          // NOTE: re-route to `content` for `template` elements.\n          // We need to do this because `template.appendChild` does not\n          // route into `template.content`.\n          const isTemplate = this.localName === 'template';\n          const content = isTemplate\n            ? (this as HTMLTemplateElement).content\n            : this;\n          const rawElement = Native.Document_createElementNS.call(\n            document,\n            this.namespaceURI,\n            this.localName\n          );\n          rawElement.innerHTML = assignedValue;\n\n          while (content.childNodes.length > 0) {\n            Native.Node_removeChild.call(content, content.childNodes[0]);\n          }\n          const container = isTemplate\n            ? (rawElement as HTMLTemplateElement).content\n            : rawElement;\n          while (container.childNodes.length > 0) {\n            Native.Node_appendChild.call(content, container.childNodes[0]);\n          }\n        },\n      });\n    });\n  }\n\n  Element.prototype.setAttribute = function (this: Element, name, newValue) {\n    // Fast path for non-custom elements.\n    if (this.__CE_state !== CEState.custom) {\n      return Native.Element_setAttribute.call(this, name, newValue);\n    }\n\n    const oldValue = Native.Element_getAttribute.call(this, name);\n    Native.Element_setAttribute.call(this, name, newValue);\n    newValue = Native.Element_getAttribute.call(this, name)!;\n    internals.attributeChangedCallback(this, name, oldValue, newValue, null);\n  };\n\n  Element.prototype.setAttributeNS = function (\n    this: Element,\n    namespace,\n    name,\n    newValue\n  ) {\n    // Fast path for non-custom elements.\n    if (this.__CE_state !== CEState.custom) {\n      return Native.Element_setAttributeNS.call(\n        this,\n        namespace,\n        name,\n        newValue\n      );\n    }\n\n    const oldValue = Native.Element_getAttributeNS.call(this, namespace, name);\n    Native.Element_setAttributeNS.call(this, namespace, name, newValue);\n    newValue = Native.Element_getAttributeNS.call(this, namespace, name)!;\n    internals.attributeChangedCallback(\n      this,\n      name,\n      oldValue,\n      newValue,\n      namespace\n    );\n  };\n\n  Element.prototype.removeAttribute = function (this: Element, name) {\n    // Fast path for non-custom elements.\n    if (this.__CE_state !== CEState.custom) {\n      return Native.Element_removeAttribute.call(this, name);\n    }\n\n    const oldValue = Native.Element_getAttribute.call(this, name);\n    Native.Element_removeAttribute.call(this, name);\n    if (oldValue !== null) {\n      internals.attributeChangedCallback(this, name, oldValue, null, null);\n    }\n  };\n\n  if (Native.Element_toggleAttribute) {\n    Element.prototype.toggleAttribute = function (\n      this: Element,\n      name,\n      force?: boolean | undefined\n    ) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_toggleAttribute.call(this, name, force);\n      }\n\n      const oldValue = Native.Element_getAttribute.call(this, name);\n      const hadAttribute = oldValue !== null;\n      const hasAttribute = Native.Element_toggleAttribute.call(\n        this,\n        name,\n        force\n      );\n      if (hadAttribute !== hasAttribute) {\n        internals.attributeChangedCallback(\n          this,\n          name,\n          oldValue,\n          hasAttribute ? '' : null,\n          null\n        );\n      }\n      return hasAttribute;\n    };\n  }\n\n  Element.prototype.removeAttributeNS = function (\n    this: Element,\n    namespace,\n    name\n  ) {\n    // Fast path for non-custom elements.\n    if (this.__CE_state !== CEState.custom) {\n      return Native.Element_removeAttributeNS.call(this, namespace, name);\n    }\n\n    const oldValue = Native.Element_getAttributeNS.call(this, namespace, name);\n    Native.Element_removeAttributeNS.call(this, namespace, name);\n    // In older browsers, `Element#getAttributeNS` may return the empty string\n    // instead of null if the attribute does not exist. For details, see;\n    // https://developer.mozilla.org/en-US/docs/Web/API/Element/getAttributeNS#Notes\n    const newValue = Native.Element_getAttributeNS.call(this, namespace, name);\n    if (oldValue !== newValue) {\n      internals.attributeChangedCallback(\n        this,\n        name,\n        oldValue,\n        newValue,\n        namespace\n      );\n    }\n  };\n\n  function patch_insertAdjacentElement(\n    destination: Element,\n    baseMethod: Element['insertAdjacentElement']\n  ) {\n    destination.insertAdjacentElement = function (\n      this: Element,\n      position,\n      element\n    ) {\n      const wasConnected = Utilities.isConnected(element);\n      const insertedElement = baseMethod.call(this, position, element)!;\n\n      if (wasConnected) {\n        internals.disconnectTree(element);\n      }\n\n      if (Utilities.isConnected(insertedElement)) {\n        internals.connectTree(element);\n      }\n      return insertedElement;\n    };\n  }\n\n  if (Native.HTMLElement_insertAdjacentElement) {\n    patch_insertAdjacentElement(\n      HTMLElement.prototype,\n      Native.HTMLElement_insertAdjacentElement\n    );\n  } else if (Native.Element_insertAdjacentElement) {\n    patch_insertAdjacentElement(\n      Element.prototype,\n      Native.Element_insertAdjacentElement\n    );\n  }\n\n  function patch_insertAdjacentHTML(\n    destination: Element,\n    baseMethod: Element['insertAdjacentHTML']\n  ) {\n    /**\n     * Patches and upgrades all nodes which are siblings between `start`\n     * (inclusive) and `end` (exclusive). If `end` is `null`, then all siblings\n     * following `start` will be patched and upgraded.\n     */\n    function upgradeNodesInRange(start: Node, end: Node | null) {\n      const nodes = [];\n      for (let node: Node = start; node !== end; node = node.nextSibling!) {\n        nodes.push(node);\n      }\n      for (let i = 0; i < nodes.length; i++) {\n        internals.patchAndUpgradeTree(nodes[i]);\n      }\n    }\n\n    destination.insertAdjacentHTML = function (this: Element, position, text) {\n      const strPosition = position.toLowerCase();\n\n      if (strPosition === 'beforebegin') {\n        const marker = this.previousSibling;\n        baseMethod.call(this, strPosition, text);\n        upgradeNodesInRange(marker || this.parentNode!.firstChild!, this);\n      } else if (strPosition === 'afterbegin') {\n        const marker = this.firstChild;\n        baseMethod.call(this, strPosition, text);\n        upgradeNodesInRange(this.firstChild!, marker);\n      } else if (strPosition === 'beforeend') {\n        const marker = this.lastChild;\n        baseMethod.call(this, strPosition, text);\n        upgradeNodesInRange(marker || this.firstChild!, null);\n      } else if (strPosition === 'afterend') {\n        const marker = this.nextSibling;\n        baseMethod.call(this, strPosition, text);\n        upgradeNodesInRange(this.nextSibling!, marker);\n      } else {\n        throw new SyntaxError(\n          `The value provided (${String(strPosition)}) is ` +\n            \"not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'.\"\n        );\n      }\n    };\n  }\n\n  if (Native.HTMLElement_insertAdjacentHTML) {\n    patch_insertAdjacentHTML(\n      HTMLElement.prototype,\n      Native.HTMLElement_insertAdjacentHTML\n    );\n  } else if (Native.Element_insertAdjacentHTML) {\n    patch_insertAdjacentHTML(\n      Element.prototype,\n      Native.Element_insertAdjacentHTML\n    );\n  }\n\n  PatchParentNode(internals, Element.prototype, {\n    prepend: Native.Element_prepend,\n    append: Native.Element_append,\n  });\n\n  PatchChildNode(internals, Element.prototype, {\n    before: Native.Element_before,\n    after: Native.Element_after,\n    replaceWith: Native.Element_replaceWith,\n    remove: Native.Element_remove,\n  });\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\ntype NativeMethod = (this: ChildNode, ...args: Array<Node | string>) => void;\n\ninterface ChildNodeNativeMethods {\n  before: NativeMethod;\n  after: NativeMethod;\n  replaceWith: NativeMethod;\n  remove: (this: ChildNode) => void;\n}\n\nexport default function (\n  internals: CustomElementInternals,\n  destination: ChildNode,\n  builtIn: ChildNodeNativeMethods\n) {\n  function beforeAfterPatch(builtInMethod: NativeMethod): NativeMethod {\n    return function (this: ChildNode, ...nodes) {\n      const flattenedNodes: Array<string | Node> = [];\n      const connectedElements: Array<Node> = [];\n\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n\n        if (node instanceof Element && Utilities.isConnected(node)) {\n          connectedElements.push(node);\n        }\n\n        if (node instanceof DocumentFragment) {\n          for (let child = node.firstChild; child; child = child.nextSibling) {\n            flattenedNodes.push(child);\n          }\n        } else {\n          flattenedNodes.push(node);\n        }\n      }\n\n      builtInMethod.apply(this, nodes);\n\n      for (let i = 0; i < connectedElements.length; i++) {\n        internals.disconnectTree(connectedElements[i]);\n      }\n\n      if (Utilities.isConnected(this)) {\n        for (let i = 0; i < flattenedNodes.length; i++) {\n          const node = flattenedNodes[i];\n          if (node instanceof Element) {\n            internals.connectTree(node);\n          }\n        }\n      }\n    };\n  }\n\n  if (builtIn.before !== undefined) {\n    destination.before = beforeAfterPatch(builtIn.before);\n  }\n\n  if (builtIn.after !== undefined) {\n    destination.after = beforeAfterPatch(builtIn.after);\n  }\n\n  if (builtIn.replaceWith !== undefined) {\n    destination.replaceWith = function (\n      this: ChildNode,\n      ...nodes: Array<Node | string>\n    ) {\n      /**\n       * A copy of `nodes`, with any DocumentFragment replaced by its children.\n       */\n      const flattenedNodes: Array<Node | string> = [];\n\n      /**\n       * Elements in `nodes` that were connected before this call.\n       */\n      const connectedElements: Array<Node> = [];\n\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n\n        if (node instanceof Element && Utilities.isConnected(node)) {\n          connectedElements.push(node);\n        }\n\n        if (node instanceof DocumentFragment) {\n          for (let child = node.firstChild; child; child = child.nextSibling) {\n            flattenedNodes.push(child);\n          }\n        } else {\n          flattenedNodes.push(node);\n        }\n      }\n\n      const wasConnected = Utilities.isConnected(this);\n\n      builtIn.replaceWith.apply(this, nodes);\n\n      for (let i = 0; i < connectedElements.length; i++) {\n        internals.disconnectTree(connectedElements[i]);\n      }\n\n      if (wasConnected) {\n        internals.disconnectTree(this);\n        for (let i = 0; i < flattenedNodes.length; i++) {\n          const node = flattenedNodes[i];\n          if (node instanceof Element) {\n            internals.connectTree(node);\n          }\n        }\n      }\n    };\n  }\n\n  if (builtIn.remove !== undefined) {\n    destination.remove = function (this: ChildNode) {\n      const wasConnected = Utilities.isConnected(this);\n\n      builtIn.remove.call(this);\n\n      if (wasConnected) {\n        internals.disconnectTree(this);\n      }\n    };\n  }\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * Represents the 'already constructed marker' used in custom\n * element construction stacks.\n *\n * https://html.spec.whatwg.org/#concept-already-constructed-marker\n */\nconst alreadyConstructedMarker = {} as {_alreadyConstructedMarker: never};\n\nexport default alreadyConstructedMarker;\nexport type AlreadyConstructedMarkerType = typeof alreadyConstructedMarker;\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport AlreadyConstructedMarker from '../AlreadyConstructedMarker.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport * as Native from './Native.js';\n\nexport default function (internals: CustomElementInternals) {\n  const PatchedHTMLElement = function HTMLElement(this: HTMLElement) {\n    // This should really be `new.target` but `new.target` can't be\n    // emulated in ES5. Assuming the user keeps the default value of the\n    // constructor's prototype's `constructor` property, this is\n    // equivalent.\n    const constructor = this.constructor as {new (): HTMLElement};\n\n    // Always look up the definition from the global registry.\n    const registry = document.__CE_registry!;\n    const definition = registry.internal_constructorToDefinition(constructor);\n    if (!definition) {\n      throw new Error(\n        'Failed to construct a custom element: ' +\n          'The constructor was not registered with `customElements`.'\n      );\n    }\n\n    const constructionStack = definition.constructionStack;\n\n    if (constructionStack.length === 0) {\n      const element = Native.Document_createElement.call(\n        document,\n        definition.localName\n      ) as HTMLElement;\n      Object.setPrototypeOf(element, constructor.prototype as typeof element);\n      element.__CE_state = CEState.custom;\n      element.__CE_definition = definition;\n      internals.patchElement(element);\n      return element;\n    }\n\n    const lastIndex = constructionStack.length - 1;\n    const element = constructionStack[lastIndex];\n    if (element === AlreadyConstructedMarker) {\n      const localName = definition.localName;\n      throw new Error(\n        `Failed to construct '${localName}': ` +\n          'This element was already constructed.'\n      );\n    }\n    const toConstructElement = element as HTMLElement;\n    constructionStack[lastIndex] = AlreadyConstructedMarker;\n\n    Object.setPrototypeOf(\n      toConstructElement,\n      constructor.prototype as typeof toConstructElement\n    );\n    internals.patchElement(toConstructElement);\n\n    return toConstructElement;\n  };\n\n  PatchedHTMLElement.prototype = Native.HTMLElement.prototype;\n  // Safari 9 has `writable: false` on the propertyDescriptor\n  // Make it writable so that TypeScript can patch up the\n  // constructor in the ES5 compiled code.\n  Object.defineProperty(HTMLElement.prototype, 'constructor', {\n    writable: true,\n    configurable: true,\n    enumerable: false,\n    value: PatchedHTMLElement,\n  });\n\n  window['HTMLElement'] = (PatchedHTMLElement as unknown) as typeof HTMLElement;\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../CustomElementInternals.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\nimport * as Native from './Native.js';\n\nexport default function (internals: CustomElementInternals) {\n  Document.prototype.createElement = function (\n    this: Document,\n    localName: string\n  ) {\n    return internals.createAnElement(this, localName, null);\n  } as typeof Document.prototype.createElement;\n\n  Document.prototype.importNode = function <T extends Node>(\n    this: Document,\n    node: T,\n    deep?: boolean\n  ): T {\n    const clone = Native.Document_importNode.call(this, node, !!deep) as T;\n    // Only create custom elements if this document is associated with the\n    // registry.\n    if (!this.__CE_registry) {\n      internals.patchTree(clone);\n    } else {\n      internals.patchAndUpgradeTree(clone);\n    }\n    return clone;\n  };\n\n  Document.prototype.createElementNS = function (\n    this: Document,\n    namespace: string | null,\n    localName: string\n  ) {\n    return internals.createAnElement(this, localName, namespace);\n  } as typeof Document.prototype.createElementNS;\n\n  PatchParentNode(internals, Document.prototype, {\n    prepend: Native.Document_prepend,\n    append: Native.Document_append,\n  });\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../CustomElementInternals.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\nimport * as Native from './Native.js';\n\nexport default function (internals: CustomElementInternals) {\n  PatchParentNode(internals, DocumentFragment.prototype, {\n    prepend: Native.DocumentFragment_prepend,\n    append: Native.DocumentFragment_append,\n  });\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport * as Utilities from '../Utilities.js';\n\nimport * as Native from './Native.js';\n\nexport default function (internals: CustomElementInternals) {\n  // `Node#nodeValue` is implemented on `Attr`.\n  // `Node#textContent` is implemented on `Attr`, `Element`.\n\n  Node.prototype.insertBefore = function <T extends Node>(\n    this: Node,\n    node: T,\n    refNode: Node | null\n  ) {\n    if (node instanceof DocumentFragment) {\n      const insertedNodes = Utilities.childrenFromFragment(node);\n      const nativeResult = Native.Node_insertBefore.call(this, node, refNode);\n\n      // DocumentFragments can't be connected, so `disconnectTree` will never\n      // need to be called on a DocumentFragment's children after inserting it.\n\n      if (Utilities.isConnected(this)) {\n        for (let i = 0; i < insertedNodes.length; i++) {\n          internals.connectTree(insertedNodes[i]);\n        }\n      }\n\n      return nativeResult as T;\n    }\n\n    const nodeWasConnectedElement =\n      node instanceof Element && Utilities.isConnected(node);\n    const nativeResult = Native.Node_insertBefore.call(\n      this,\n      node,\n      refNode\n    ) as T;\n\n    if (nodeWasConnectedElement) {\n      internals.disconnectTree(node);\n    }\n\n    if (Utilities.isConnected(this)) {\n      internals.connectTree(node);\n    }\n\n    return nativeResult;\n  };\n\n  Node.prototype.appendChild = function <T extends Node>(this: Node, node: T) {\n    if (node instanceof DocumentFragment) {\n      const insertedNodes = Utilities.childrenFromFragment(node);\n      const nativeResult = Native.Node_appendChild.call(this, node) as T;\n\n      // DocumentFragments can't be connected, so `disconnectTree` will never\n      // need to be called on a DocumentFragment's children after inserting it.\n\n      if (Utilities.isConnected(this)) {\n        for (let i = 0; i < insertedNodes.length; i++) {\n          internals.connectTree(insertedNodes[i]);\n        }\n      }\n\n      return nativeResult;\n    }\n\n    const nodeWasConnectedElement =\n      node instanceof Element && Utilities.isConnected(node);\n    const nativeResult = Native.Node_appendChild.call(this, node) as T;\n\n    if (nodeWasConnectedElement) {\n      internals.disconnectTree(node);\n    }\n\n    if (Utilities.isConnected(this)) {\n      internals.connectTree(node);\n    }\n\n    return nativeResult;\n  };\n\n  Node.prototype.cloneNode = function (this: Node, deep) {\n    const clone = Native.Node_cloneNode.call(this, !!deep);\n    // Only create custom elements if this element's owner document is\n    // associated with the registry.\n    if (!this.ownerDocument!.__CE_registry) {\n      internals.patchTree(clone);\n    } else {\n      internals.patchAndUpgradeTree(clone);\n    }\n    return clone;\n  };\n\n  Node.prototype.removeChild = function <T extends Node>(this: Node, node: T) {\n    const nodeWasConnectedElement =\n      node instanceof Element && Utilities.isConnected(node);\n    const nativeResult = Native.Node_removeChild.call(this, node) as T;\n\n    if (nodeWasConnectedElement) {\n      internals.disconnectTree(node);\n    }\n\n    return nativeResult;\n  };\n\n  Node.prototype.replaceChild = function <T extends Node>(\n    this: Node,\n    nodeToInsert: Node,\n    nodeToRemove: T\n  ) {\n    if (nodeToInsert instanceof DocumentFragment) {\n      const insertedNodes = Utilities.childrenFromFragment(nodeToInsert);\n      const nativeResult = Native.Node_replaceChild.call(\n        this,\n        nodeToInsert,\n        nodeToRemove\n      ) as T;\n\n      // DocumentFragments can't be connected, so `disconnectTree` will never\n      // need to be called on a DocumentFragment's children after inserting it.\n\n      if (Utilities.isConnected(this)) {\n        internals.disconnectTree(nodeToRemove);\n        for (let i = 0; i < insertedNodes.length; i++) {\n          internals.connectTree(insertedNodes[i]);\n        }\n      }\n\n      return nativeResult;\n    }\n\n    const nodeToInsertWasConnectedElement =\n      nodeToInsert instanceof Element && Utilities.isConnected(nodeToInsert);\n    const nativeResult = Native.Node_replaceChild.call(\n      this,\n      nodeToInsert,\n      nodeToRemove\n    ) as T;\n    const thisIsConnected = Utilities.isConnected(this);\n\n    if (thisIsConnected) {\n      internals.disconnectTree(nodeToRemove);\n    }\n\n    if (nodeToInsertWasConnectedElement) {\n      internals.disconnectTree(nodeToInsert);\n    }\n\n    if (thisIsConnected) {\n      internals.connectTree(nodeToInsert);\n    }\n\n    return nativeResult;\n  };\n\n  function patch_textContent(\n    destination: Node,\n    baseDescriptor: PropertyDescriptor\n  ) {\n    Object.defineProperty(destination, 'textContent', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: function (this: Node, assignedValue) {\n        // If this is a text node then there are no nodes to disconnect.\n        if (this.nodeType === Node.TEXT_NODE) {\n          baseDescriptor.set!.call(this, assignedValue);\n          return;\n        }\n\n        let removedNodes = undefined;\n        // Checking for `firstChild` is faster than reading `childNodes.length`\n        // to compare with 0.\n        if (this.firstChild) {\n          // Using `childNodes` is faster than `children`, even though we only\n          // care about elements.\n          const childNodes = this.childNodes;\n          const childNodesLength = childNodes.length;\n          if (childNodesLength > 0 && Utilities.isConnected(this)) {\n            // Copying an array by iterating is faster than using slice.\n            removedNodes = new Array(childNodesLength);\n            for (let i = 0; i < childNodesLength; i++) {\n              removedNodes[i] = childNodes[i];\n            }\n          }\n        }\n\n        baseDescriptor.set!.call(this, assignedValue);\n\n        if (removedNodes) {\n          for (let i = 0; i < removedNodes.length; i++) {\n            internals.disconnectTree(removedNodes[i]);\n          }\n        }\n      },\n    });\n  }\n\n  if (Native.Node_textContent && Native.Node_textContent.get) {\n    patch_textContent(Node.prototype, Native.Node_textContent);\n  } else {\n    internals.addNodePatch(function (element) {\n      patch_textContent(element, {\n        enumerable: true,\n        configurable: true,\n        // NOTE: This implementation of the `textContent` getter assumes that\n        // text nodes' `textContent` getter will not be patched.\n        get: function (this: Node) {\n          const parts: Array<string | null> = [];\n\n          for (let n = this.firstChild; n; n = n.nextSibling) {\n            if (n.nodeType === Node.COMMENT_NODE) {\n              continue;\n            }\n            parts.push(n.textContent);\n          }\n\n          return parts.join('');\n        },\n        set: function (this: Node, assignedValue) {\n          while (this.firstChild) {\n            Native.Node_removeChild.call(this, this.firstChild);\n          }\n          // `textContent = null | undefined | ''` does not result in\n          // a TextNode childNode\n          if (assignedValue != null && assignedValue !== '') {\n            Native.Node_appendChild.call(\n              this,\n              document.createTextNode(assignedValue)\n            );\n          }\n        },\n      });\n    });\n  }\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","/* eslint-disable no-nested-ternary, accessor-pairs, no-underscore-dangle, max-statements, id-length, max-classes-per-file, import/no-unassigned-import */\nimport '@webcomponents/custom-elements';\n\nconst clamp = (min: number, max: number, value: number): number =>\n  value < min ? min : value > max ? max : value;\n\nconst getMidpoint = (a: Point, b: Point): Point => new Point((a.x + b.x) / 2, (a.y + b.y) / 2);\n\nconst getDistance = (a: Point, b: Point): number => Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);\n\nclass Point {\n  x: number;\n  y: number;\n\n  constructor(x: number, y: number) {\n    this.x = x;\n    this.y = y;\n  }\n}\n\nclass PinchTouch extends HTMLElement {\n  currentZoom: number;\n  zoomStrength: number;\n  previousPosition: Point;\n  prevDistance: number;\n  previousTouches: TouchList | null;\n  pointerDown: boolean;\n  disableTouchMove: boolean;\n  currentTransformation: Point;\n  maxZoom: number;\n  doubleClickDelay: number;\n  firstClickTime: number;\n  lastZoomTime: number;\n  disableZoomTimeout: NodeJS.Timeout;\n  lastZoomClickPosition: Point;\n  singlePageMode: string;\n  currentPageView: string;\n  positioningEl: HTMLElement;\n\n  constructor() {\n    super();\n    this.currentZoom = 1;\n    this.zoomStrength = 0.03;\n    this.previousPosition = new Point(0, 0);\n    this.prevDistance = 0;\n    this.previousTouches = null;\n    this.pointerDown = false;\n    this.disableTouchMove = false;\n    this.currentTransformation = new Point(0, 0);\n    this.maxZoom = 2;\n    this.doubleClickDelay = 400;\n    this.firstClickTime = 0;\n    this.lastZoomTime = 0;\n    this.disableZoomTimeout = null;\n    this.lastZoomClickPosition = new Point(0, 0);\n    this.singlePageMode = '';\n    this.currentPageView = '';\n  }\n\n  static get observedAttributes() {\n    return ['page-view', 'single-page-mode', 'zoom'];\n  }\n\n  connectedCallback() {\n    this._setupListeners();\n    this.positioningEl = <HTMLElement>this.firstElementChild;\n  }\n\n  disconnectedCallback() {\n    this._removeListeners();\n  }\n\n  _setupListeners() {\n    this.addEventListener('click', this._handleDoubleClick);\n    this.addEventListener('pointerdown', this._pointerDown);\n    this.addEventListener('pointerup', this._pointerUp);\n    this.addEventListener('pointermove', this._pointerMove);\n    this.addEventListener('touchstart', this._handleTouchStart, { passive: true });\n    this.addEventListener('touchend', this._handleTouchEnd);\n    this.addEventListener('touchmove', this._handleTouchMove);\n    this.addEventListener('wheel', this._handleWheel);\n\n    // Stop IE9 from breaking. temp fix.\n    document.body.classList.add('mod-contain');\n    document.body.classList.add('mod-zoom-enabled');\n\n    const zoomEl = document.querySelector('#divPtiContainer_zoom');\n\n    if (zoomEl) {\n      zoomEl.classList.add('mod-zoom-in');\n    }\n  }\n\n  _removeListeners() {\n    this.removeEventListener('click', this._handleDoubleClick);\n    this.removeEventListener('pointerdown', this._pointerDown);\n    this.removeEventListener('pointerup', this._pointerUp);\n    this.removeEventListener('pointermove', this._pointerMove);\n    this.removeEventListener('touchstart', this._handleTouchStart);\n    this.removeEventListener('touchend', this._handleTouchEnd);\n    this.removeEventListener('touchmove', this._handleTouchMove);\n    this.removeEventListener('wheel', this._handleWheel);\n\n    if (document.body) {\n      document.body.classList.remove('mod-contain');\n      document.body.classList.remove('mod-zoom-enabled');\n\n      const zoomEl = document.querySelector('#divPtiContainer_zoom');\n\n      if (zoomEl) {\n        zoomEl.classList.remove('mod-zoom-in');\n      }\n    }\n  }\n\n  /**\n   *\n   * @param {'page-view'|'zoom'|'single-page-mode'} name\n   * @param {string} oldValue\n   * @param {string} newValue\n   * @returns {void}\n   */\n  attributeChangedCallback(\n    name: 'page-view' | 'zoom' | 'single-page-mode',\n    _oldValue: string,\n    newValue: string\n  ): void {\n    switch (name) {\n      case 'page-view': {\n        this.currentPageView = newValue;\n        const isZoomEnabled =\n          this.currentPageView === 'double' || this.singlePageMode === 'width and height';\n\n        if (isZoomEnabled) {\n          this._setupListeners();\n        } else {\n          this._removeListeners();\n        }\n\n        return;\n      }\n\n      case 'zoom':\n        this._setZoom(parseInt(newValue));\n\n        return;\n\n      case 'single-page-mode':\n        this.singlePageMode = newValue;\n    }\n  }\n\n  /**\n   * @param {PointerEvent} e\n   */\n  _pointerDown(e: PointerEvent) {\n    this.previousPosition = new Point(e.clientX, e.clientY);\n    this.pointerDown = true;\n  }\n\n  _pointerUp() {\n    this.pointerDown = false;\n  }\n\n  /**\n   * @param {PointerEvent} e\n   */\n  _pointerMove(e: PointerEvent) {\n    e.preventDefault();\n    const { clientX, clientY } = e;\n    const { currentTransformation, disableTouchMove, pointerDown, currentZoom } = this;\n\n    if (disableTouchMove) {\n      return;\n    }\n\n    if (pointerDown && currentZoom > 1) {\n      const deltaX = this.previousPosition.x - e.clientX;\n      const deltaY = this.previousPosition.y - e.clientY;\n      const newX = Math.floor(currentTransformation.x + deltaX);\n      const newY = Math.floor(currentTransformation.y + deltaY);\n\n      this.previousPosition = new Point(clientX, clientY);\n      this._setTransformOrigin(new Point(newX, newY));\n    }\n  }\n\n  /**\n   * @param {MouseEvent} e\n   */\n  _handleDoubleClick(e: MouseEvent) {\n    const distanceThreshold = 30;\n    const now = performance.now();\n    const isInZoomCoolDown = now - this.lastZoomTime < this.doubleClickDelay;\n    const doubleClickedFastEnough = now - this.firstClickTime < this.doubleClickDelay;\n    const positionClicked = new Point(e.clientX, e.clientY);\n    const diffX = Math.abs(this.lastZoomClickPosition.x - e.clientX);\n    const diffY = Math.abs(this.lastZoomClickPosition.y - e.clientY);\n    const clicksCloseEnough = diffX < distanceThreshold || diffY < distanceThreshold;\n\n    this.lastZoomClickPosition = positionClicked;\n\n    if (doubleClickedFastEnough && !isInZoomCoolDown && clicksCloseEnough) {\n      this._setTransformOrigin(positionClicked);\n      this._setZoom(this.currentZoom === 1 ? 2 : 1, true);\n      this.firstClickTime = 0;\n      this.lastZoomTime = now;\n    } else {\n      this.firstClickTime = now;\n    }\n  }\n\n  /**\n   * @param {WheelEvent} e\n   */\n  _handleWheel(e: WheelEvent) {\n    e.preventDefault();\n    e.stopPropagation();\n\n    const { deltaY } = e;\n    const zoom =\n      deltaY < 0\n        ? (this.currentZoom = this.currentZoom + this.currentZoom * this.zoomStrength)\n        : (this.currentZoom = this.currentZoom - this.currentZoom * this.zoomStrength);\n\n    this._setTransformOrigin(new Point(e.clientX, e.clientY));\n    this._setZoom(zoom);\n  }\n\n  /**\n   * @param {TouchEvent} e\n   */\n  _handleTouchStart(e: TouchEvent) {\n    this.disableTouchMove = e.touches.length > 1;\n\n    if (!e.touches || e.touches.length !== 2) {\n      return;\n    }\n\n    if (!this.previousTouches) {\n      const [touchOne, touchTwo] = e.touches;\n      const newMidpoint = getMidpoint(\n        new Point(touchOne.clientX, touchOne.clientY),\n        new Point(touchTwo.clientX, touchTwo.clientY)\n      );\n\n      this._setTransformOrigin(newMidpoint);\n    }\n\n    this.previousTouches = e.touches;\n  }\n\n  /**\n   * @param {TouchEvent} e\n   */\n  _handleTouchMove(e: TouchEvent) {\n    e.preventDefault();\n    e.stopPropagation();\n    e.stopImmediatePropagation();\n    this.disableTouchMove = e.touches.length > 1;\n\n    if (!e.touches || (e.touches.length !== 2 && this.positioningEl)) {\n      return;\n    }\n\n    const [touchOne, touchTwo] = e.touches;\n    const [previousTouchOne, previousTouchTwo] = this.previousTouches ?? e.touches;\n\n    // For calculating panning movement\n    const prevMidpoint = getMidpoint(\n      new Point(previousTouchOne.clientX, previousTouchOne.clientY),\n      new Point(previousTouchTwo.clientX, previousTouchTwo.clientY)\n    );\n    const newMidpoint = getMidpoint(\n      new Point(touchOne.clientX, touchOne.clientY),\n      new Point(touchTwo.clientX, touchTwo.clientY)\n    );\n\n    // Calculate the desired change in scale\n    const prevDistance = getDistance(\n      new Point(previousTouchOne.clientX, previousTouchOne.clientY),\n      new Point(previousTouchTwo.clientX, previousTouchTwo.clientY)\n    );\n    const newDistance = getDistance(\n      new Point(touchOne.clientX, touchOne.clientY),\n      new Point(touchTwo.clientX, touchTwo.clientY)\n    );\n\n    const scaleDiff = newDistance / prevDistance;\n    const newScale = this.currentZoom * scaleDiff;\n\n    const deltaX = prevMidpoint.x - newMidpoint.x;\n    const deltaY = prevMidpoint.y - newMidpoint.y;\n\n    this._setTransformOrigin(\n      new Point(this.currentTransformation.x + deltaX, this.currentTransformation.y + deltaY)\n    );\n\n    this._setZoom(newScale);\n    this.previousTouches = e.touches;\n  }\n\n  /**\n   * @param {TouchEvent} e\n   */\n  _handleTouchEnd(e: TouchEvent) {\n    this.disableTouchMove = e.touches.length !== 0;\n  }\n\n  /**\n   * @param {number} zoom\n   * @param {boolean} [transition]\n   * @returns {void}\n   */\n  _setZoom(zoom: number, transition: boolean = false): void {\n    const zoomClasses = ['mod-zoom-in', 'mod-zoom-out'];\n    const [zoomClassAdd, zoomClassRemove] = zoom > 1 ? zoomClasses.reverse() : zoomClasses;\n\n    this.currentZoom = clamp(1, this.maxZoom, zoom);\n\n    if (this.positioningEl) {\n      this.positioningEl.style.transition = transition ? 'transform 0.25s' : '';\n      this.positioningEl.style.transform = `scale(${this.currentZoom})`;\n\n      if (this.singlePageMode !== 'width and height' && this.currentPageView === 'single') {\n        this.positioningEl.classList.remove(zoomClassAdd);\n        this.positioningEl.classList.remove(zoomClassRemove);\n\n        return;\n      }\n\n      this.positioningEl.classList.add(zoomClassAdd);\n      this.positioningEl.classList.remove(zoomClassRemove);\n\n      // Prevent the page from swiping to the next / prev page when we've just zoomed out\n      if (this.currentZoom === 1) {\n        if (this.disableZoomTimeout === null) {\n          window.disableSwipe = true;\n\n          this.disableZoomTimeout = setTimeout(() => {\n            window.disableSwipe = false;\n            this.disableZoomTimeout = null;\n          }, 400);\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {Point} point\n   * @returns {void}\n   */\n  _setTransformOrigin({ x, y }: Point): void {\n    if (this.positioningEl) {\n      const boundingRect = this.positioningEl.getBoundingClientRect();\n      const { height } = boundingRect;\n      const { width } = boundingRect;\n      const clampedWidth = clamp(0, width, x);\n      const clampedHeight = clamp(0, height, y);\n\n      this.positioningEl.style.transformOrigin = `${clampedWidth}px ${clampedHeight}px`;\n      this.currentTransformation = new Point(x, y);\n    }\n  }\n}\n\nwindow.customElements.define('pinch-touch', PinchTouch);\n"],"names":["n","window","Document","prototype","createElement","p","createElementNS","aa","importNode","ba","prepend","ca","append","da","DocumentFragment","ea","q","Node","cloneNode","r","appendChild","t","insertBefore","u","removeChild","v","replaceChild","w","Object","getOwnPropertyDescriptor","y","Element","attachShadow","z","A","getAttribute","B","setAttribute","C","removeAttribute","D","toggleAttribute","E","getAttributeNS","F","setAttributeNS","G","removeAttributeNS","H","insertAdjacentElement","fa","insertAdjacentHTML","ha","ia","ja","before","ka","after","la","replaceWith","ma","remove","na","HTMLElement","I","oa","pa","qa","Set","ra","a","b","has","test","split","forEach","add","sa","document","contains","bind","documentElement","J","isConnected","__CE_isImportDocument","parentNode","ShadowRoot","host","K","children","Array","slice","call","firstChild","nextSibling","nodeType","ELEMENT_NODE","push","L","M","d","f","c","e","localName","import","__CE_shadowRoot","N","O","noDocumentConstructionObserver","shadyDomFastWalk","m","g","j","this","P","ShadyDOM","inUse","querySelectorAll","nativeMethods","length","Q","R","__CE_patched","S","__CE_state","connectedCallback","T","U","disconnectedCallback","V","upgrade","h","__CE_registry","readyState","__CE_documentLoadHandled","addEventListener","k","l","delete","ownerDocument","defaultView","W","constructionStack","constructorFunction","Error","pop","__CE_definition","attributeChangedCallback","hasAttributes","observedAttributes","X","va","namespaceURI","setPrototypeOf","HTMLUnknownElement","message","sourceURL","fileName","line","lineNumber","column","columnNumber","String","ErrorEvent","initErrorEvent","cancelable","filename","lineno","colno","error","createEvent","preventDefault","defineProperty","configurable","get","enumerable","dispatchEvent","defaultPrevented","console","wa","Promise","xa","MutationObserver","observe","childList","subtree","ya","disconnect","Y","s","Map","o","i","za","SyntaxError","Ba","TypeError","x","Function","adoptedCallback","set","Aa","resolve","Z","arguments","apply","Ea","toLowerCase","previousSibling","lastChild","ua","innerHTML","content","childNodes","Da","indexOf","addedNodes","define","whenDefined","reject","polyfillWrapFlushCallback","polyfillDefineLazy","Fa","customElements","Ia","constructor","writable","value","Ga","Ca","TEXT_NODE","ta","COMMENT_NODE","textContent","join","createTextNode","Ha","CustomElementRegistry","forcePolyfill","__CE_installPolyfill","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","exports","module","__webpack_modules__","getter","__esModule","definition","key","obj","prop","hasOwnProperty","clamp","min","max","getMidpoint","Point","getDistance","Math","sqrt","pow","_createClass","_classCallCheck","PinchTouch","_HTMLElement","_this","_callSuper","currentZoom","zoomStrength","previousPosition","prevDistance","previousTouches","pointerDown","disableTouchMove","currentTransformation","maxZoom","doubleClickDelay","firstClickTime","lastZoomTime","disableZoomTimeout","lastZoomClickPosition","singlePageMode","currentPageView","_inherits","_setupListeners","positioningEl","firstElementChild","_removeListeners","_handleDoubleClick","_pointerDown","_pointerUp","_pointerMove","_handleTouchStart","passive","_handleTouchEnd","_handleTouchMove","_handleWheel","body","classList","zoomEl","querySelector","removeEventListener","name","_oldValue","newValue","_setZoom","parseInt","clientX","clientY","deltaX","deltaY","newX","floor","newY","_setTransformOrigin","now","performance","isInZoomCoolDown","doubleClickedFastEnough","positionClicked","diffX","abs","diffY","clicksCloseEnough","stopPropagation","zoom","touches","_e$touches","_slicedToArray","touchOne","touchTwo","newMidpoint","_this$previousTouches","stopImmediatePropagation","_e$touches2","_ref2","previousTouchOne","previousTouchTwo","prevMidpoint","scaleDiff","newScale","_this2","transition","zoomClasses","_ref4","reverse","zoomClassAdd","zoomClassRemove","style","transform","concat","disableSwipe","setTimeout","_ref5","boundingRect","getBoundingClientRect","height","width","clampedWidth","clampedHeight","transformOrigin","_wrapNativeSuper"],"sourceRoot":""}