[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_254":255,"_256":257},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":-7,"_18":19,"_17":-7,"_191":-5,"_20":192,"_22":193,"_194":195,"_196":197,"_26":198,"_24":199,"_200":-5,"_201":-5,"_202":57,"_203":204,"_205":48,"_206":-5,"_207":-5,"_208":209},"routes/_app.x.$handle.$name.code.$",{"_11":12,"_13":14,"_15":16,"_17":-7,"_18":19,"_20":21,"_22":23,"_24":25,"_26":27,"_28":-5,"_29":-5,"_30":-5,"_31":-5,"_32":-5},"handle","postpostscript","name","custom-registry","branchName","main","version","path","src","project",{"_36":137,"_13":14,"_49":138,"_139":-5,"_140":57,"_141":142,"_143":142,"_144":145,"_146":-5,"_147":148,"_149":99,"_150":48,"_151":48,"_152":-5,"_153":79,"_154":155,"_156":-5,"_157":-5,"_158":-5,"_159":-5,"_160":161,"_162":161,"_163":164,"_165":164,"_166":164,"_167":161,"_168":161,"_169":170,"_171":172,"_173":174,"_175":57},"tree",[82,83,84,85,86],"file",{"_36":76,"_13":19,"_39":42,"_41":-5,"_43":44,"_45":77,"_47":48,"_49":78,"_17":79,"_52":80,"_54":-5,"_56":57,"_58":-5,"_18":81},"contents",[33,34,35],"upstream","pull","ahead","behind","envVars",{"_36":68,"_13":69,"_39":70,"_41":42,"_43":44,"_45":71,"_47":48,"_49":72,"_17":73,"_52":53,"_54":74,"_56":57,"_58":-5,"_18":75},{"_36":60,"_13":61,"_39":62,"_41":42,"_43":44,"_45":63,"_47":48,"_49":64,"_17":65,"_52":53,"_54":66,"_56":57,"_58":-5,"_18":67},{"_36":37,"_13":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":48,"_49":50,"_17":51,"_52":53,"_54":55,"_56":57,"_58":-5,"_18":59},"id","9060955c-573d-11f0-a346-f69ea79377d9","x-registry.ts","fileId","cf744ba2-56fd-11f0-a4a3-f69ea79377d9","parentId","aeb97d2e-56fd-11f0-a9af-f69ea79377d9","branchId","76698042-56f1-11f0-a160-f69ea79377d9","branchVersion",197,"latest",true,"createdAt",["D",1751458237524],21,"fileType","script","content","import { CustomCustomElementRegistry } from \"./custom-element-registry.ts\";\n\nexport class XRegistry extends HTMLElement {\n static globalObservedAttributesByName = new Map>();\n\n registry: CustomElementRegistry = new CustomCustomElementRegistry();\n\n define(\n name: string,\n constructor: CustomElementConstructor,\n _options?: ElementDefinitionOptions\n ): void {\n this.registry.define(name, constructor);\n\n const newObservedAttributes: string[] | undefined = Reflect.get(\n constructor,\n \"observedAttributes\"\n );\n if (newObservedAttributes) {\n const observedAttributes =\n XRegistry.globalObservedAttributesByName.get(name) ?? new Set();\n\n XRegistry.globalObservedAttributesByName.set(name, observedAttributes);\n\n for (const attrName of newObservedAttributes) {\n observedAttributes.add(attrName);\n }\n }\n\n customElements.define(\n name,\n class {\n constructor() {\n const instance = Reflect.construct(HTMLElement, [], this.constructor);\n Reflect.setPrototypeOf(instance, HTMLElement.prototype);\n\n const registry = (instance.closest(\"x-registry\") satisfies XRegistry)\n ?.registry;\n if (registry) {\n registry.upgrade(instance);\n } else {\n console.warn(instance, \"has no parent x-registry element\");\n }\n return instance;\n }\n\n static get observedAttributes() {\n return Array.from(\n XRegistry.globalObservedAttributesByName.get(name) ?? []\n );\n }\n\n connectedCallback() {\n if (!this.connectedCallback) return;\n Reflect.apply(this.connectedCallback, this, arguments);\n }\n disconnectedCallback() {\n if (!this.disconnectedCallback) return;\n return Reflect.apply(this.disconnectedCallback, this, arguments);\n }\n attributeChangedCallback() {\n if (!this.attributeChangedCallback) return;\n return Reflect.apply(this.attributeChangedCallback, this, arguments);\n }\n }\n );\n }\n}\n","deleted",false,"label",[19,38],"29ab7fe8-5742-11f0-ba4f-f69ea79377d9","scoped-custom-element-registry.ts","4e69050e-573c-11f0-b48d-f69ea79377d9",246,["D",1751460212693],10,"/**\n * @license\n * Copyright (c) 2020 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\n * The complete set of authors may be found at\n * http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at\n * http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at\n * http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * Note: this file is a script, not a module, so toplevel\n * interfaces are global. This is relevent because those named\n * after existing global TypeScript types actually add to those\n * types, as though they were declared in a `declare global` in a module.\n */\n\ndeclare interface PolyfillWindow {\n CustomElementRegistryPolyfill: {\n formAssociated: Set;\n };\n}\n\nconst polyfillWindow = window as unknown as PolyfillWindow;\n\n/**\n * Polyfill helper object. This is global and distinct from\n * `CustomElementRegistry`because the polyfill does not use modules and\n * so that it is clearly polyfill-specific and not related to the native\n * feature.\n *\n * The `formAssociated` setting cannot be properly scoped and can only be set\n * once per name. This is determined by how it is set on the first defined\n * tag name. However, adding the name to\n * `CustomElementsRegistryPolyfill.add(tagName)` reserves the given tag\n * so it's always formAssociated.\n */\nif (\n polyfillWindow[\"CustomElementRegistryPolyfill\"]?.[\"formAssociated\"] ===\n undefined\n) {\n polyfillWindow[\"CustomElementRegistryPolyfill\"] = {\n [\"formAssociated\"]: new Set(),\n };\n}\n\ninterface CustomElementConstructor {\n observedAttributes?: Array;\n formAssociated?: boolean;\n\n new (...params: unknown[]): CustomHTMLElement;\n}\n\ninterface CustomHTMLElement {\n connectedCallback?(): void;\n disconnectedCallback?(): void;\n adoptedCallback?(): void;\n attributeChangedCallback?(\n name: string,\n oldValue?: string | null,\n newValue?: string | null,\n namespace?: string | null\n ): void;\n formAssociatedCallback?(form: HTMLFormElement | null): void;\n formDisabledCallback?(disabled: boolean): void;\n formResetCallback?(): void;\n formStateRestoreCallback?(\n state: File | string | FormData | null,\n mode: string\n ): void;\n}\n\ninterface CustomElementRegistry {\n _getDefinition(tagName: string): CustomElementDefinition | undefined;\n}\n\ninterface CustomElementDefinition {\n elementClass: CustomElementConstructor;\n tagName: string;\n /**\n * We hold onto the versions of callbacks at registration time, because\n * that's the specc'd behavior.\n */\n connectedCallback?: CustomHTMLElement[\"connectedCallback\"];\n disconnectedCallback?: CustomHTMLElement[\"disconnectedCallback\"];\n adoptedCallback?: CustomHTMLElement[\"adoptedCallback\"];\n attributeChangedCallback?: CustomHTMLElement[\"attributeChangedCallback\"];\n formAssociated?: boolean;\n formAssociatedCallback?: CustomHTMLElement[\"formAssociatedCallback\"];\n formDisabledCallback?: CustomHTMLElement[\"formDisabledCallback\"];\n formResetCallback?: CustomHTMLElement[\"formResetCallback\"];\n formStateRestoreCallback?: CustomHTMLElement[\"formStateRestoreCallback\"];\n observedAttributes: Set;\n /**\n * The class that's registered on the global custom element registry for this\n * element definition. Only present if this definition is registered on the\n * global registry, though all definitions do have a standin.\n */\n standInClass?: CustomElementConstructor;\n}\n\n// Note, `registry` matches proposal but `customElements` was previously\n// proposed. It's supported for back compat.\ninterface ShadowRootWithSettableCustomElements extends ShadowRoot {\n registry?: CustomElementRegistry;\n customElements?: CustomElementRegistry;\n}\n\ninterface ShadowRootInitWithSettableCustomElements extends ShadowRootInit {\n registry?: CustomElementRegistry;\n customElements?: CustomElementRegistry;\n}\n\ntype ParametersOf<\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n T extends ((...args: any) => any) | undefined\n> = T extends Function ? Parameters : never;\n\nconst NativeHTMLElement = window.HTMLElement;\nconst nativeDefine = window.customElements.define;\nconst nativeGet = window.customElements.get;\nconst nativeRegistry = window.customElements;\n\nconst definitionForElement = new WeakMap<\n HTMLElement,\n CustomElementDefinition\n>();\nconst pendingRegistryForElement = new WeakMap<\n HTMLElement,\n ShimmedCustomElementsRegistry\n>();\nconst globalDefinitionForConstructor = new WeakMap<\n CustomElementConstructor,\n CustomElementDefinition\n>();\n// TBD: This part of the spec proposal is unclear:\n// > Another option for looking up registries is to store an element's\n// > originating registry with the element. The Chrome DOM team was concerned\n// > about the small additional memory overhead on all elements. Looking up the\n// > root avoids this.\nconst scopeForElement = new WeakMap();\n\nclass AsyncInfo {\n readonly promise: Promise;\n readonly resolve: (val: T) => void;\n constructor() {\n let resolve: (val: T) => void;\n this.promise = new Promise((r) => {\n resolve = r;\n });\n this.resolve = resolve!;\n }\n}\n\n// Constructable CE registry class, which uses the native CE registry to\n// register stand-in elements that can delegate out to CE classes registered\n// in scoped registries\nclass ShimmedCustomElementsRegistry implements CustomElementRegistry {\n private readonly _definitionsByTag = new Map<\n string,\n CustomElementDefinition\n >();\n private readonly _definitionsByClass = new Map<\n CustomElementConstructor,\n CustomElementDefinition\n >();\n private readonly _whenDefinedPromises = new Map<\n string,\n AsyncInfo\n >();\n private readonly _awaitingUpgrade = new Map>();\n\n define(tagName: string, elementClass: CustomElementConstructor) {\n tagName = tagName.toLowerCase();\n if (this._getDefinition(tagName) !== undefined) {\n throw new DOMException(\n `Failed to execute 'define' on 'CustomElementRegistry': the name \"${tagName}\" has already been used with this registry`\n );\n }\n if (this._definitionsByClass.get(elementClass) !== undefined) {\n throw new DOMException(\n `Failed to execute 'define' on 'CustomElementRegistry': this constructor has already been used with this registry`\n );\n }\n // Since observedAttributes can't change, we approximate it by patching\n // set/remove/toggleAttribute on the user's class\n const attributeChangedCallback =\n elementClass.prototype.attributeChangedCallback;\n const observedAttributes = new Set(\n elementClass.observedAttributes || []\n );\n patchAttributes(elementClass, observedAttributes, attributeChangedCallback);\n // Register a stand-in class which will handle the registry lookup & delegation\n let standInClass = nativeGet.call(nativeRegistry, tagName);\n // `formAssociated` cannot be scoped so it's set to true if\n // the first defined element sets it or it's reserved in\n // `CustomElementRegistryPolyfill.formAssociated`.\n const formAssociated =\n standInClass?.formAssociated ??\n (elementClass[\"formAssociated\"] ||\n polyfillWindow[\"CustomElementRegistryPolyfill\"][\"formAssociated\"].has(\n tagName\n ));\n if (formAssociated) {\n polyfillWindow[\"CustomElementRegistryPolyfill\"][\"formAssociated\"].add(\n tagName\n );\n }\n // Sync the class value to the definition value for easier debuggability\n if (formAssociated != elementClass[\"formAssociated\"]) {\n try {\n elementClass[\"formAssociated\"] = formAssociated;\n } catch (e) {\n // squelch\n }\n }\n // Register the definition\n const definition: CustomElementDefinition = {\n tagName,\n elementClass,\n connectedCallback: elementClass.prototype.connectedCallback,\n disconnectedCallback: elementClass.prototype.disconnectedCallback,\n adoptedCallback: elementClass.prototype.adoptedCallback,\n attributeChangedCallback,\n formAssociated: formAssociated,\n formAssociatedCallback: elementClass.prototype[\"formAssociatedCallback\"],\n formDisabledCallback: elementClass.prototype[\"formDisabledCallback\"],\n formResetCallback: elementClass.prototype[\"formResetCallback\"],\n formStateRestoreCallback:\n elementClass.prototype[\"formStateRestoreCallback\"],\n observedAttributes,\n };\n this._definitionsByTag.set(tagName, definition);\n this._definitionsByClass.set(elementClass, definition);\n\n if (!standInClass) {\n standInClass = createStandInElement(tagName);\n nativeDefine.call(nativeRegistry, tagName, standInClass);\n }\n if (this === window.customElements) {\n globalDefinitionForConstructor.set(elementClass, definition);\n definition.standInClass = standInClass;\n }\n // Upgrade any elements created in this scope before define was called\n const awaiting = this._awaitingUpgrade.get(tagName);\n if (awaiting) {\n this._awaitingUpgrade.delete(tagName);\n for (const element of awaiting) {\n pendingRegistryForElement.delete(element);\n customize(element, definition, true);\n }\n }\n // Flush whenDefined callbacks\n const info = this._whenDefinedPromises.get(tagName);\n if (info !== undefined) {\n info.resolve(elementClass);\n this._whenDefinedPromises.delete(tagName);\n }\n return elementClass;\n }\n\n upgrade(...args: Parameters) {\n creationContext.push(this);\n nativeRegistry.upgrade(...args);\n creationContext.pop();\n }\n\n get(tagName: string) {\n const definition = this._definitionsByTag.get(tagName);\n return definition?.elementClass;\n }\n\n getName(elementClass: CustomElementConstructor) {\n const definition = this._definitionsByClass.get(elementClass);\n return definition?.tagName ?? null;\n }\n\n _getDefinition(tagName: string) {\n return this._definitionsByTag.get(tagName);\n }\n\n [\"whenDefined\"](tagName: string) {\n const definition = this._getDefinition(tagName);\n if (definition !== undefined) {\n return Promise.resolve(definition.elementClass);\n }\n let info = this._whenDefinedPromises.get(tagName);\n if (info === undefined) {\n info = new AsyncInfo();\n this._whenDefinedPromises.set(tagName, info);\n }\n return info.promise;\n }\n\n _upgradeWhenDefined(\n element: HTMLElement,\n tagName: string,\n shouldUpgrade: boolean\n ) {\n let awaiting = this._awaitingUpgrade.get(tagName);\n if (!awaiting) {\n this._awaitingUpgrade.set(tagName, (awaiting = new Set()));\n }\n if (shouldUpgrade) {\n awaiting.add(element);\n } else {\n awaiting.delete(element);\n }\n }\n}\n\n// User extends this HTMLElement, which returns the CE being upgraded\nlet upgradingInstance: HTMLElement | undefined;\nwindow.HTMLElement = function HTMLElement(this: HTMLElement) {\n // Upgrading case: the StandInElement constructor was run by the browser's\n // native custom elements and we're in the process of running the\n // \"constructor-call trick\" on the natively constructed instance, so just\n // return that here\n let instance = upgradingInstance;\n if (instance) {\n upgradingInstance = undefined;\n return instance;\n }\n // Construction case: we need to construct the StandInElement and return\n // it; note the current spec proposal only allows new'ing the constructor\n // of elements registered with the global registry\n const definition = globalDefinitionForConstructor.get(\n this.constructor as CustomElementConstructor\n );\n if (!definition) {\n throw new TypeError(\n \"Illegal constructor (custom element class must be registered with global customElements registry to be newable)\"\n );\n }\n instance = Reflect.construct(NativeHTMLElement, [], definition.standInClass);\n Object.setPrototypeOf(instance, this.constructor.prototype);\n definitionForElement.set(instance!, definition);\n return instance;\n} as unknown as typeof HTMLElement;\nwindow.HTMLElement.prototype = NativeHTMLElement.prototype;\n\n// Helpers to return the scope for a node where its registry would be located\nconst isValidScope = (node: Node) =>\n node === document || node instanceof ShadowRoot;\nconst registryForNode = (node: Node): ShimmedCustomElementsRegistry | null => {\n return;\n // TODO: the algorithm for finding the scope is a bit up in the air; assigning\n // a one-time scope at creation time would require walking every tree ever\n // created, which is avoided for now\n let scope = node.getRootNode();\n // If we're not attached to the document (i.e. in a disconnected tree or\n // fragment), we need to get the scope from the creation context; that should\n // be a Document or ShadowRoot, unless it was created via innerHTML\n if (!isValidScope(scope)) {\n const context = creationContext[creationContext.length - 1];\n console.log({ context });\n // When upgrading via registry.upgrade(), the registry itself is put on the\n // creationContext stack\n if (context instanceof CustomElementRegistry) {\n return context as ShimmedCustomElementsRegistry;\n }\n // Otherwise, get the root node of the element this was created from\n scope = context.getRootNode();\n // The creation context wasn't a Document or ShadowRoot or in one; this\n // means we're being innerHTML'ed into a disconnected element; for now, we\n // hope that root node was created imperatively, where we stash _its_\n // scopeForElement. Beyond that, we'd need more costly tracking.\n if (!isValidScope(scope)) {\n scope = scopeForElement.get(scope)?.getRootNode() || document;\n }\n }\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return (scope as any)[\"registry\"] as ShimmedCustomElementsRegistry | null;\n};\n\n// Helper to create stand-in element for each tagName registered that delegates\n// out to the registry for the given element\nconst createStandInElement = (tagName: string): CustomElementConstructor => {\n return class ScopedCustomElementBase {\n // Note, this cannot be scoped so it's set based on a polyfill config\n // option. When this config option isn't specified, it is set\n // if the first defining element is formAssociated.\n static get [\"formAssociated\"]() {\n return polyfillWindow[\"CustomElementRegistryPolyfill\"][\n \"formAssociated\"\n ].has(tagName);\n }\n constructor() {\n // Create a raw HTMLElement first\n const instance = Reflect.construct(\n NativeHTMLElement,\n [],\n this.constructor\n );\n // We need to install the minimum HTMLElement prototype so that\n // scopeForNode can use DOM API to determine our construction scope;\n // upgrade will eventually install the full CE prototype\n Object.setPrototypeOf(instance, HTMLElement.prototype);\n // Get the node's scope, and its registry (falls back to global registry)\n const registry =\n registryForNode(instance) ||\n (window.customElements as ShimmedCustomElementsRegistry);\n const definition = registry._getDefinition(tagName);\n if (definition) {\n customize(instance, definition);\n } else {\n pendingRegistryForElement.set(instance, registry);\n }\n return instance;\n }\n\n connectedCallback(\n this: HTMLElement,\n ...args: ParametersOf\n ) {\n ensureAttributesCustomized(this);\n const definition = definitionForElement.get(this);\n if (definition) {\n // Delegate out to user callback\n definition.connectedCallback &&\n definition.connectedCallback.apply(this, args);\n } else {\n // Register for upgrade when defined (only when connected, so we don't leak)\n pendingRegistryForElement\n .get(this)!\n ._upgradeWhenDefined(this, tagName, true);\n }\n }\n\n disconnectedCallback(\n this: HTMLElement,\n ...args: ParametersOf\n ) {\n const definition = definitionForElement.get(this);\n if (definition) {\n // Delegate out to user callback\n definition.disconnectedCallback &&\n definition.disconnectedCallback.apply(this, args);\n } else {\n // Un-register for upgrade when defined (so we don't leak)\n pendingRegistryForElement\n .get(this)!\n ._upgradeWhenDefined(this, tagName, false);\n }\n }\n\n adoptedCallback(\n this: HTMLElement,\n ...args: ParametersOf\n ) {\n const definition = definitionForElement.get(this);\n definition?.adoptedCallback?.apply(this, args);\n }\n\n // Form-associated custom elements lifecycle methods\n [\"formAssociatedCallback\"](\n this: HTMLElement,\n ...args: ParametersOf\n ) {\n const definition = definitionForElement.get(this);\n if (definition?.[\"formAssociated\"]) {\n definition?.[\"formAssociatedCallback\"]?.apply(this, args);\n }\n }\n\n [\"formDisabledCallback\"](\n this: HTMLElement,\n ...args: ParametersOf\n ) {\n const definition = definitionForElement.get(this);\n if (definition?.[\"formAssociated\"]) {\n definition?.[\"formDisabledCallback\"]?.apply(this, args);\n }\n }\n\n [\"formResetCallback\"](\n this: HTMLElement,\n ...args: ParametersOf\n ) {\n const definition = definitionForElement.get(this);\n if (definition?.[\"formAssociated\"]) {\n definition?.[\"formResetCallback\"]?.apply(this, args);\n }\n }\n\n [\"formStateRestoreCallback\"](\n this: HTMLElement,\n ...args: ParametersOf\n ) {\n const definition = definitionForElement.get(this);\n if (definition?.[\"formAssociated\"]) {\n definition?.[\"formStateRestoreCallback\"]?.apply(this, args);\n }\n }\n\n // no attributeChangedCallback or observedAttributes since these\n // are simulated via setAttribute/removeAttribute patches\n } as unknown as CustomElementConstructor;\n};\nwindow.CustomElementRegistry = ShimmedCustomElementsRegistry;\n\n// Helper to patch CE class setAttribute/getAttribute/toggleAttribute to\n// implement attributeChangedCallback\nconst patchAttributes = (\n elementClass: CustomElementConstructor,\n observedAttributes: Set,\n attributeChangedCallback?: CustomHTMLElement[\"attributeChangedCallback\"]\n) => {\n if (observedAttributes.size === 0 || attributeChangedCallback === undefined) {\n return;\n }\n const setAttribute = elementClass.prototype.setAttribute;\n if (setAttribute) {\n elementClass.prototype.setAttribute = function (n: string, value: string) {\n ensureAttributesCustomized(this);\n const name = n.toLowerCase();\n if (observedAttributes.has(name)) {\n const old = this.getAttribute(name);\n setAttribute.call(this, name, value);\n attributeChangedCallback.call(this, name, old, value);\n } else {\n setAttribute.call(this, name, value);\n }\n };\n }\n const removeAttribute = elementClass.prototype.removeAttribute;\n if (removeAttribute) {\n elementClass.prototype.removeAttribute = function (n: string) {\n ensureAttributesCustomized(this);\n const name = n.toLowerCase();\n if (observedAttributes.has(name)) {\n const old = this.getAttribute(name);\n removeAttribute.call(this, name);\n attributeChangedCallback.call(this, name, old, null);\n } else {\n removeAttribute.call(this, name);\n }\n };\n }\n const toggleAttribute = elementClass.prototype.toggleAttribute;\n if (toggleAttribute) {\n elementClass.prototype.toggleAttribute = function (\n n: string,\n force?: boolean\n ) {\n ensureAttributesCustomized(this);\n const name = n.toLowerCase();\n if (observedAttributes.has(name)) {\n const old = this.getAttribute(name);\n toggleAttribute.call(this, name, force);\n const newValue = this.getAttribute(name);\n if (old !== newValue) {\n attributeChangedCallback.call(this, name, old, newValue);\n }\n } else {\n toggleAttribute.call(this, name, force);\n }\n };\n }\n};\n\n// Helper to defer initial attribute processing for parser generated\n// custom elements. These elements are created without attributes\n// so attributes cannot be processed in the constructor. Instead,\n// these elements are customized at the first opportunity:\n// 1. when the element is connected\n// 2. when any attribute API is first used\n// 3. when the document becomes readyState === interactive (the parser is done)\nlet elementsPendingAttributes: Set | undefined;\nif (document.readyState === \"loading\") {\n elementsPendingAttributes = new Set();\n document.addEventListener(\n \"readystatechange\",\n () => {\n elementsPendingAttributes!.forEach((instance) =>\n customizeAttributes(instance, definitionForElement.get(instance)!)\n );\n },\n { once: true }\n );\n}\n\nconst ensureAttributesCustomized = (\n instance: CustomHTMLElement & HTMLElement\n) => {\n if (!elementsPendingAttributes?.has(instance)) {\n return;\n }\n customizeAttributes(instance, definitionForElement.get(instance)!);\n};\n\n// Approximate observedAttributes from the user class, since the stand-in element had none\nconst customizeAttributes = (\n instance: CustomHTMLElement & HTMLElement,\n definition: CustomElementDefinition\n) => {\n elementsPendingAttributes?.delete(instance);\n if (!definition.attributeChangedCallback) {\n return;\n }\n definition.observedAttributes.forEach((attr: string) => {\n if (!instance.hasAttribute(attr)) {\n return;\n }\n definition.attributeChangedCallback!.call(\n instance,\n attr,\n null,\n instance.getAttribute(attr)\n );\n });\n};\n\n// Helper to patch CE class hierarchy changing those CE classes created before applying the polyfill\n// to make them work with the new patched CustomElementsRegistry\nconst patchHTMLElement = (elementClass: CustomElementConstructor): unknown => {\n console.log(\"patch\", elementClass);\n const parentClass = Object.getPrototypeOf(elementClass);\n\n if (parentClass !== window.HTMLElement) {\n if (parentClass === NativeHTMLElement) {\n return Object.setPrototypeOf(elementClass, window.HTMLElement);\n }\n\n return patchHTMLElement(parentClass);\n }\n return;\n};\n\n// Helper to upgrade an instance with a CE definition using \"constructor call trick\"\nconst customize = (\n instance: HTMLElement,\n definition: CustomElementDefinition,\n isUpgrade = false\n) => {\n console.log(\"customize\", instance, definition, isUpgrade);\n Object.setPrototypeOf(instance, definition.elementClass.prototype);\n definitionForElement.set(instance, definition);\n upgradingInstance = instance;\n try {\n console.log(definition.elementClass);\n new definition.elementClass();\n } catch (_) {\n patchHTMLElement(definition.elementClass);\n new definition.elementClass();\n }\n if (definition.attributeChangedCallback) {\n // Note, these checks determine if the element is being parser created.\n // and has no attributes when created. In this case, it may have attributes\n // in HTML that are immediately processed. To handle this, the instance\n // is added to a set and its attributes are customized at first\n // opportunity (e.g. when connected or when the parser completes and the\n // document becomes interactive).\n if (elementsPendingAttributes !== undefined && !instance.hasAttributes()) {\n elementsPendingAttributes.add(instance);\n } else {\n customizeAttributes(instance, definition);\n }\n }\n if (isUpgrade && definition.connectedCallback && instance.isConnected) {\n definition.connectedCallback.call(instance);\n }\n};\n\n// Patch attachShadow to set customElements on shadowRoot when provided\nconst nativeAttachShadow = Element.prototype.attachShadow;\nElement.prototype.attachShadow = function (\n init: ShadowRootInitWithSettableCustomElements,\n ...args: Array\n) {\n // Note, We must remove `registry` from the init object to avoid passing it to\n // the native implementation. Use string keys to avoid renaming in Closure.\n const {\n customElements: customElements,\n registry: registry = customElements,\n ...nativeInit\n } = init;\n const shadowRoot = nativeAttachShadow.call(\n this,\n nativeInit,\n ...(args as [])\n ) as ShadowRootWithSettableCustomElements;\n if (registry !== undefined) {\n const descriptor = {\n value: registry,\n configurable: true,\n writable: true,\n };\n Object.defineProperty(shadowRoot, \"customElements\", descriptor);\n Object.defineProperty(shadowRoot, \"registry\", descriptor);\n }\n return shadowRoot;\n};\n\n// Install scoped creation API on Element & ShadowRoot\nconst creationContext: Array<\n Document | CustomElementRegistry | Element | ShadowRoot\n> = [document];\nconst installScopedCreationMethod = (\n ctor: Function,\n method: string,\n from?: Document\n) => {\n const native = (from ? Object.getPrototypeOf(from) : ctor.prototype)[method];\n ctor.prototype[method] = function (\n this: Element | ShadowRoot,\n ...args: Array\n ) {\n creationContext.push(this);\n const ret = native.apply(from || this, args);\n // For disconnected elements, note their creation scope so that e.g.\n // innerHTML into them will use the correct scope; note that\n // insertAdjacentHTML doesn't return an element, but that's fine since\n // it will have a parent that should have a scope\n if (ret !== undefined) {\n scopeForElement.set(ret, this);\n }\n creationContext.pop();\n return ret;\n };\n};\ninstallScopedCreationMethod(ShadowRoot, \"createElement\", document);\ninstallScopedCreationMethod(ShadowRoot, \"createElementNS\", document);\ninstallScopedCreationMethod(ShadowRoot, \"importNode\", document);\ninstallScopedCreationMethod(Element, \"insertAdjacentHTML\");\n\n// Install scoped innerHTML on Element & ShadowRoot\nconst installScopedCreationSetter = (ctor: Function, name: string) => {\n const descriptor = Object.getOwnPropertyDescriptor(ctor.prototype, name)!;\n Object.defineProperty(ctor.prototype, name, {\n ...descriptor,\n set(value) {\n creationContext.push(this);\n descriptor.set!.call(this, value);\n creationContext.pop();\n },\n });\n};\ninstallScopedCreationSetter(Element, \"innerHTML\");\ninstallScopedCreationSetter(ShadowRoot, \"innerHTML\");\n\n// Install global registry\nObject.defineProperty(window, \"customElements\", {\n value: new CustomElementRegistry(),\n configurable: true,\n writable: true,\n});\n\nif (\n !!window[\"ElementInternals\"] &&\n !!window[\"ElementInternals\"].prototype[\"setFormValue\"]\n) {\n const internalsToHostMap = new WeakMap();\n const attachInternals = HTMLElement.prototype[\"attachInternals\"];\n const methods: Array = [\n \"setFormValue\",\n \"setValidity\",\n \"checkValidity\",\n \"reportValidity\",\n ];\n\n HTMLElement.prototype[\"attachInternals\"] = function (...args) {\n const internals = attachInternals.call(this, ...args);\n internalsToHostMap.set(internals, this);\n return internals;\n };\n\n methods.forEach((method) => {\n const proto = window[\"ElementInternals\"].prototype;\n const originalMethod = proto[method] as Function;\n\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n (proto as any)[method] = function (...args: Array) {\n const host = internalsToHostMap.get(this);\n const definition = definitionForElement.get(host!);\n if (\n (definition as { formAssociated?: boolean })[\"formAssociated\"] === true\n ) {\n return originalMethod?.call(this, ...args);\n } else {\n throw new DOMException(\n `Failed to execute ${originalMethod} on 'ElementInternals': The target element is not a form-associated custom element.`\n );\n }\n };\n });\n\n // Emulate the native RadioNodeList object\n const RadioNodeList = class\n extends Array\n implements Omit\n {\n private _elements: Array;\n\n constructor(elements: Array) {\n super(...elements);\n this._elements = elements;\n }\n [index: number]: Node;\n\n item(index: number): Node | null {\n return this[index];\n }\n\n get [\"value\"]() {\n return (\n this._elements.find((element) => element[\"checked\"] === true)?.value ||\n \"\"\n );\n }\n } as unknown as { new (elements: Array): RadioNodeList };\n\n // Emulate the native HTMLFormControlsCollection object\n const HTMLFormControlsCollection = class\n implements HTMLFormControlsCollection\n {\n length: number;\n\n constructor(elements: Array) {\n const entries = new Map();\n elements.forEach((element, index) => {\n const name = element.getAttribute(\"name\");\n const nameReference = entries.get(name) || [];\n this[+index] = element;\n nameReference.push(element);\n entries.set(name, nameReference);\n });\n this[\"length\"] = elements.length;\n entries.forEach((value, name) => {\n if (!value) return;\n if (name === \"length\" || name === \"item\" || name === \"namedItem\")\n return;\n if (value.length === 1) {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n (this as any)[name!] = value[0];\n } else {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n (this as any)[name!] = new RadioNodeList(value as HTMLInputElement[]);\n }\n });\n }\n\n [index: number]: Element;\n\n [\"item\"](index: number): Element | null {\n return this[index] ?? null;\n }\n\n [Symbol.iterator](): IterableIterator {\n throw new Error(\"Method not implemented.\");\n }\n\n [\"namedItem\"](key: string): RadioNodeList | Element | null {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return (this as any)[key] ?? null;\n }\n };\n\n // Override the built-in HTMLFormElements.prototype.elements getter\n const formElementsDescriptor = Object.getOwnPropertyDescriptor(\n HTMLFormElement.prototype,\n \"elements\"\n )!;\n\n Object.defineProperty(HTMLFormElement.prototype, \"elements\", {\n get: function () {\n const nativeElements = formElementsDescriptor.get!.call(this);\n\n const include: Array = [];\n\n for (const element of nativeElements) {\n const definition = definitionForElement.get(element);\n\n // Only purposefully formAssociated elements or built-ins will feature in elements\n if (!definition || definition[\"formAssociated\"] === true) {\n include.push(element);\n }\n }\n\n return new HTMLFormControlsCollection(include);\n },\n });\n}\n",[19,61],"d540eb66-573f-11f0-81be-f69ea79377d9","custom-element-registry.ts","ba6fbf48-56fd-11f0-b60c-f69ea79377d9",225,["D",1751459212071],3,"export class CustomCustomElementRegistry implements CustomElementRegistry {\n constructorByName = new Map();\n promiseByName = new Map<\n string,\n PromiseWithResolvers\n >();\n nameByConstructor = new WeakMap();\n\n define(\n name: string,\n constructor: CustomElementConstructor,\n _options?: ElementDefinitionOptions\n ): void {\n this.constructorByName.set(name, constructor);\n this.nameByConstructor.set(constructor, name);\n this.promiseByName.get(name)?.resolve(constructor);\n }\n\n get(name: string): CustomElementConstructor | undefined {\n return this.constructorByName.get(name);\n }\n\n getName(constructor: CustomElementConstructor): string | null {\n return this.nameByConstructor.get(constructor);\n }\n\n upgrade(root: Node): void {\n const tag = root.nodeName.toLowerCase();\n const _super = this.get(tag);\n if (!_super) {\n console.warn(this, `has not defined \"${tag}\"`);\n return;\n }\n\n Reflect.setPrototypeOf(root, _super.prototype);\n }\n\n whenDefined(name: string): Promise {\n if (!this.promiseByName.has(name)) {\n this.promiseByName.set(name, Promise.withResolvers());\n }\n return this.promiseByName.get(name).promise;\n }\n}\n",[19,69],"aeb97c16-56fd-11f0-a9af-f69ea79377d9",134,["D",1751430800654],0,"directory",[19],{"_36":76,"_13":19,"_39":42,"_41":-5,"_43":44,"_45":77,"_47":48,"_49":122,"_17":79,"_52":80,"_54":-5,"_56":57,"_58":-5,"_94":123,"_18":124},{"_36":115,"_13":116,"_39":117,"_41":-5,"_43":44,"_45":102,"_47":48,"_49":118,"_17":79,"_52":24,"_54":119,"_56":57,"_58":-5,"_94":120,"_18":121},{"_36":107,"_13":108,"_39":109,"_41":-5,"_43":44,"_45":110,"_47":48,"_49":111,"_17":79,"_52":24,"_54":112,"_56":57,"_58":-5,"_94":113,"_18":114},{"_36":97,"_13":98,"_39":99,"_41":-5,"_43":44,"_45":100,"_47":48,"_49":101,"_17":102,"_52":103,"_54":104,"_56":57,"_58":-5,"_94":105,"_18":106},{"_36":87,"_13":88,"_39":89,"_41":-5,"_43":44,"_45":90,"_47":48,"_49":91,"_17":92,"_52":24,"_54":93,"_56":57,"_58":-5,"_94":95,"_18":96},"313d69ce-5742-11f0-8efe-f69ea79377d9","index.html","eca57144-56f1-11f0-80a5-f69ea79377d9",247,["D",1751460225391],77,"\n\n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n\n","children",[],[88],"f0a41372-56f1-11f0-8a9e-f69ea79377d9","http.ts","c2ee23c8-56f1-11f0-a52f-f69ea79377d9",13,["D",1751425757277],2,"http","import { staticHTTPServer } from \"https://esm.town/v/std/utils@105-main/index.ts\";\nexport default staticHTTPServer(import.meta.url);\n",[],[98],"87a7e04c-56f1-11f0-ba5f-f69ea79377d9","deno.json","87a7e114-56f1-11f0-ba5f-f69ea79377d9",1,["D",1751425581146],"{\n \"$schema\": \"https://raw.githubusercontent.com/denoland/deno/348900b8b79f4a434cab4c74b3bc8d4d2fa8ee74/cli/schemas/config-file.v1.json\",\n \"lock\": false,\n \"compilerOptions\": {\n \"noImplicitAny\": false,\n \"strict\": false,\n \"types\": [\n \"https://www.val.town/types/valtown.d.ts\"\n ],\n \"lib\": [\n \"dom\",\n \"dom.iterable\",\n \"dom.asynciterable\",\n \"deno.ns\",\n \"deno.unstable\"\n ]\n },\n \"lint\": {\n \"files\": {\n \"include\": [\n \"deno:/https/esm.town/**/*\"\n ]\n },\n \"rules\": {\n \"exclude\": [\n \"no-explicit-any\"\n ]\n }\n },\n \"node_modules_dir\": false,\n \"experimental\": {\n \"unstable-node-globals\": true,\n \"unstable-temporal\": true,\n \"unstable-worker-options\": true,\n \"unstable-sloppy-imports\": true\n }\n}",[],[108],"87ad690e-56f1-11f0-81d6-f69ea79377d9",".vtignore","87ad69d6-56f1-11f0-81d6-f69ea79377d9",["D",1751425581146],".git\n.vscode\n.cursorrules\n.DS_Store\nnode_modules\nvendor",[],[116],["D",1751430800654],[125,126,127],[19],{"_36":68,"_13":69,"_39":70,"_41":42,"_43":44,"_45":71,"_47":48,"_49":134,"_17":73,"_52":53,"_54":74,"_56":57,"_58":-5,"_94":135,"_18":136},{"_36":60,"_13":61,"_39":62,"_41":42,"_43":44,"_45":63,"_47":48,"_49":131,"_17":65,"_52":53,"_54":66,"_56":57,"_58":-5,"_94":132,"_18":133},{"_36":37,"_13":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":48,"_49":128,"_17":51,"_52":53,"_54":55,"_56":57,"_58":-5,"_94":129,"_18":130},["D",1751458237524],[],[19,38],["D",1751460212693],[],[19,61],["D",1751459212071],[],[19,69],"76691c60-56f1-11f0-a160-f69ea79377d9",["D",1751425552216],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","","imageUrl","userId","4bfb99a9-2008-40e0-bacb-7c7d84227cee","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount","orgId","1073b191-f665-405d-9530-545465c93575","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_11":12,"_190":186},"org",{"_11":12,"_184":-5,"_185":186,"_147":148,"_187":188,"_189":57},"branch",{"_17":90,"_13":16,"_36":44,"_176":137,"_177":-5,"_178":-5,"_179":-5,"_180":-5,"_181":-5,"_182":14,"_183":12},"isOwned","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","avatar","https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvdXBsb2FkZWQvaW1nXzJjdlhaRXl0WXVNSlhZcWU0ckI2c1BOMjNhQSJ9","tier","free","canRestrictVals","profileImageUrl","adoptOrgId",{"_36":137,"_13":14,"_49":250,"_139":-5,"_140":57,"_141":142,"_143":142,"_144":145,"_146":-5,"_147":148,"_149":99,"_150":48,"_151":48,"_152":-5,"_153":79,"_154":155,"_156":-5,"_157":-5,"_158":-5,"_159":-5,"_160":161,"_162":161,"_163":164,"_165":164,"_166":164,"_167":161,"_168":161,"_169":251,"_171":252,"_173":253,"_175":57},[226,230,231,232,233],"files",[226,227,228,229,230,231,232,233],"counts",{"_217":79,"_218":110,"_219":79,"_32":220,"_221":222},[211,212,213],{"_36":76,"_13":19,"_39":42,"_41":-5,"_43":44,"_45":77,"_47":48,"_49":78,"_17":79,"_52":80,"_54":-5,"_56":57,"_58":-5,"_18":210},"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},[19],{"_36":68,"_13":69,"_39":70,"_41":42,"_43":44,"_45":71,"_47":48,"_49":72,"_17":73,"_52":53,"_54":74,"_56":57,"_58":-5,"_18":216},{"_36":60,"_13":61,"_39":62,"_41":42,"_43":44,"_45":63,"_47":48,"_49":64,"_17":65,"_52":53,"_54":66,"_56":57,"_58":-5,"_18":215},{"_36":37,"_13":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":48,"_49":50,"_17":51,"_52":53,"_54":55,"_56":57,"_58":-5,"_18":214},[19,38],[19,61],[19,69],"pulls","branches","forks",{"_223":79,"_225":79},"connections",{"_223":79,"_224":79},"count","unfilledCount","emptyCount",{"_36":76,"_13":19,"_39":42,"_41":-5,"_43":44,"_45":77,"_47":48,"_49":122,"_17":79,"_52":80,"_54":-5,"_56":57,"_58":-5,"_94":248,"_18":249},{"_36":68,"_13":69,"_39":70,"_41":42,"_43":44,"_45":71,"_47":48,"_49":134,"_17":73,"_52":53,"_54":74,"_56":57,"_58":-5,"_94":246,"_18":247},{"_36":60,"_13":61,"_39":62,"_41":42,"_43":44,"_45":63,"_47":48,"_49":131,"_17":65,"_52":53,"_54":66,"_56":57,"_58":-5,"_94":244,"_18":245},{"_36":37,"_13":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":48,"_49":128,"_17":51,"_52":53,"_54":55,"_56":57,"_58":-5,"_94":242,"_18":243},{"_36":115,"_13":116,"_39":117,"_41":-5,"_43":44,"_45":102,"_47":48,"_49":118,"_17":79,"_52":24,"_54":119,"_56":57,"_58":-5,"_94":240,"_18":241},{"_36":107,"_13":108,"_39":109,"_41":-5,"_43":44,"_45":110,"_47":48,"_49":111,"_17":79,"_52":24,"_54":112,"_56":57,"_58":-5,"_94":238,"_18":239},{"_36":97,"_13":98,"_39":99,"_41":-5,"_43":44,"_45":100,"_47":48,"_49":101,"_17":102,"_52":103,"_54":104,"_56":57,"_58":-5,"_94":236,"_18":237},{"_36":87,"_13":88,"_39":89,"_41":-5,"_43":44,"_45":90,"_47":48,"_49":91,"_17":92,"_52":24,"_54":93,"_56":57,"_58":-5,"_94":234,"_18":235},[],[88],[],[98],[],[108],[],[116],[],[19,38],[],[19,61],[],[19,69],[227,228,229],[19],["D",1751425552216],{"_11":12,"_190":186},{"_11":12,"_184":-5,"_185":186,"_147":148,"_187":188,"_189":57},{"_17":90,"_13":16,"_36":44,"_176":137,"_177":-5,"_178":-5,"_179":-5,"_180":-5,"_181":-5,"_182":14,"_183":12},"ctx",{"_169":-5,"_207":287,"_288":289,"_290":291,"_292":57,"_293":57,"_294":57,"_295":48,"_296":-5,"_297":-7,"_298":-7,"_299":79,"_300":57,"_301":57,"_302":-5,"_303":57,"_304":57,"_305":57,"_306":-5},"ENV",{"_258":259,"_260":261,"_262":16,"_263":264,"_265":266,"_267":268,"_269":270,"_271":272,"_273":274,"_275":276,"_277":278,"_279":280,"_281":282,"_283":284,"_285":286},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]