From 6e29765fe15a4441295aef636d1f78e7a0cd8003 Mon Sep 17 00:00:00 2001 From: Matt Date: Tue, 16 Jul 2024 14:30:58 +0100 Subject: [PATCH] Fix case where element ID is changed, making ID cache invalid. Weakly reference cached elements --- module/dist/ai-ui.cjs | 9 +++++---- module/dist/ai-ui.js | 9 +++++---- module/dist/ai-ui.min.cjs | 16 ++++++++-------- module/dist/ai-ui.min.js | 16 ++++++++-------- module/dist/ai-ui.min.mjs | 14 +++++++------- module/dist/ai-ui.mjs | 9 +++++---- module/esm/ai-ui.js | 9 ++++++--- module/package.json | 2 +- module/src/ai-ui.ts | 11 +++++++---- 9 files changed, 52 insertions(+), 43 deletions(-) diff --git a/module/dist/ai-ui.cjs b/module/dist/ai-ui.cjs index 97e4f67..63d5154 100644 --- a/module/dist/ai-ui.cjs +++ b/module/dist/ai-ui.cjs @@ -1059,8 +1059,9 @@ var tag = function(_1, _2, _3) { get: (target, p, receiver) => { if (typeof p === "string") { if (p in target) { - if (this.contains(target[p])) - return target[p]; + const ref = target[p].deref(); + if (ref && ref.id === p && this.contains(ref)) + return ref; delete target[p]; } let e; @@ -1079,7 +1080,7 @@ var tag = function(_1, _2, _3) { } else { e = this.querySelector("#" + CSS.escape(p)) ?? void 0; } - if (e) target[p] = e; + if (e) target[p] = new WeakRef(e); return e; } } @@ -1562,4 +1563,4 @@ function mutationTracker(root, track, enableOnRemovedFromDOM) { return tracked.has(node); }; } -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/ai-ui.ts", "../src/debug.ts", "../src/deferred.ts", "../src/iterators.ts", "../src/when.ts"],
  "sourcesContent": ["import { isPromiseLike } from './deferred.js';\nimport { Ignore, asyncIterator, defineIterableProperty, isAsyncIter, isAsyncIterator } from './iterators.js';\nimport { WhenParameters, WhenReturn, when } from './when.js';\nimport { DEBUG, console, timeOutWarn } from './debug.js';\nimport type { ChildTags, Constructed, Instance, Overrides, TagCreationOptions, TagCreator, TagCreatorFunction } from './tags.js';\n\n/* Export useful stuff for users of the bundled code */\nexport { when } from './when.js';\nexport type { ChildTags, Instance, TagCreator, TagCreatorFunction } from './tags.js'\nexport * as Iterators from './iterators.js';\n\nexport const UniqueID = Symbol(\"Unique ID\");\n\nconst logNode = DEBUG ? ((n: Node) => `\"${'innerHTML' in n ? n.innerHTML : n.textContent}\"`) : (n: Node) => undefined;\n\n/* A holder for commonProperties specified when `tag(...p)` is invoked, which are always\n  applied (mixed in) when an element is created */\ntype TagFunctionOptions<OtherMembers extends Record<string | symbol, any> = {}> = {\n  commonProperties?: OtherMembers\n  document?: Document\n  /** @deprecated - legacy support */\n  enableOnRemovedFromDOM?: boolean\n}\n\n/* Members applied to EVERY tag created, even base tags */\ninterface PoElementMethods {\n  get ids(): {}\n  when<T extends Element & PoElementMethods, S extends WhenParameters<Exclude<keyof T['ids'], number | symbol>>>(this: T, ...what: S): WhenReturn<S>;\n  // This is a very incomplete type. In practice, set(attrs) requires a deeply partial set of\n  // attributes, in exactly the same way as a TagFunction's first object parameter\n  set attributes(attrs: object);\n  get attributes(): NamedNodeMap\n}\n\n// Support for https://www.npmjs.com/package/htm (or import htm from 'https://cdn.jsdelivr.net/npm/htm/dist/htm.module.js')\n// Note: same signature as React.createElement\nexport interface CreateElement {\n  // Support for htm, JSX, etc\n  createElement(\n    // \"name\" can a HTML tag string, an existing node (just returns itself), or a tag function\n    name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n    // The attributes used to initialise the node (if a string or function - ignore if it's already a node)\n    attrs: any,\n    // The children\n    ...children: ChildTags[]): Node;\n}\n\n/* The interface that creates a set of TagCreators for the specified DOM tags */\nexport interface TagLoader {\n  nodes(...c: ChildTags[]): (Node | (/*P &*/ (Element & PoElementMethods)))[];\n  UniqueID: typeof UniqueID\n\n  /*\n   Signatures for the tag loader. All params are optional in any combination,\n   but must be in order:\n      tag(\n          ?nameSpace?: string,  // absent nameSpace implies HTML\n          ?tags?: string[],     // absent tags defaults to all common HTML tags\n          ?commonProperties?: CommonPropertiesConstraint // absent implies none are defined\n      )\n\n      eg:\n        tags()  // returns TagCreators for all HTML tags\n        tags(['div','button'], { myThing() {} })\n        tags('http://namespace',['Foreign'], { isForeign: true })\n  */\n\n  <Tags extends keyof HTMLElementTagNameMap>(): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap>(tags: Tags[]): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(tags: Tags[], options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: null | undefined | '', tags: Tags[], options?: TagFunctionOptions<Q>): { [k in Tags]: TagCreator<Q & PoElementMethods & HTMLElement> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: string, tags: Tags[], options?: TagFunctionOptions<Q>): Record<string, TagCreator<Q & PoElementMethods & Element>> & CreateElement\n}\n\nlet idCount = 0;\nconst standandTags = [\n  \"a\", \"abbr\", \"address\", \"area\", \"article\", \"aside\", \"audio\", \"b\", \"base\", \"bdi\", \"bdo\", \"blockquote\", \"body\", \"br\", \"button\",\n  \"canvas\", \"caption\", \"cite\", \"code\", \"col\", \"colgroup\", \"data\", \"datalist\", \"dd\", \"del\", \"details\", \"dfn\", \"dialog\", \"div\",\n  \"dl\", \"dt\", \"em\", \"embed\", \"fieldset\", \"figcaption\", \"figure\", \"footer\", \"form\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\",\n  \"header\", \"hgroup\", \"hr\", \"html\", \"i\", \"iframe\", \"img\", \"input\", \"ins\", \"kbd\", \"label\", \"legend\", \"li\", \"link\", \"main\", \"map\",\n  \"mark\", \"menu\", \"meta\", \"meter\", \"nav\", \"noscript\", \"object\", \"ol\", \"optgroup\", \"option\", \"output\", \"p\", \"picture\", \"pre\",\n  \"progress\", \"q\", \"rp\", \"rt\", \"ruby\", \"s\", \"samp\", \"script\", \"search\", \"section\", \"select\", \"slot\", \"small\", \"source\", \"span\",\n  \"strong\", \"style\", \"sub\", \"summary\", \"sup\", \"table\", \"tbody\", \"td\", \"template\", \"textarea\", \"tfoot\", \"th\", \"thead\", \"time\",\n  \"title\", \"tr\", \"track\", \"u\", \"ul\", \"var\", \"video\", \"wbr\"\n] as const;\n\nfunction idsInaccessible(): never {\n  throw new Error(\"<elt>.ids is a read-only map of Elements\")\n}\n\nfunction isChildTag(x: any): x is ChildTags {\n  return typeof x === 'string'\n    || typeof x === 'number'\n    || typeof x === 'boolean'\n    || x instanceof Node\n    || x instanceof NodeList\n    || x instanceof HTMLCollection\n    || x === null\n    || x === undefined\n    // Can't actually test for the contained type, so we assume it's a ChildTag and let it fail at runtime\n    || Array.isArray(x)\n    || isPromiseLike(x)\n    || isAsyncIter(x)\n    || (typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function');\n}\n\n/* tag */\nconst callStackSymbol = Symbol('callStack');\n\nexport const tag = <TagLoader>function <Tags extends string,\n  T1 extends (string | Tags[] | TagFunctionOptions<Q>),\n  T2 extends (Tags[] | TagFunctionOptions<Q>),\n  Q extends {}\n>(\n  _1: T1,\n  _2: T2,\n  _3?: TagFunctionOptions<Q>\n): Record<string, TagCreator<Q & Element>> {\n  type NamespacedElementBase = T1 extends string ? T1 extends '' ? HTMLElement : Element : HTMLElement;\n\n  /* Work out which parameter is which. There are 6 variations:\n    tag()                                           []\n    tag(commonProperties)                           [object]\n    tag(tags[])                                     [string[]]\n    tag(tags[], commonProperties)                   [string[], object]\n    tag(namespace | null, tags[])                   [string | null, string[]]\n    tag(namespace | null, tags[], commonProperties) [string | null, string[], object]\n  */\n  const [nameSpace, tags, options] = (typeof _1 === 'string') || _1 === null\n    ? [_1, _2 as Tags[], _3 as TagFunctionOptions<Q>]\n    : Array.isArray(_1)\n      ? [null, _1 as Tags[], _2 as TagFunctionOptions<Q>]\n      : [null, standandTags, _1 as TagFunctionOptions<Q>];\n\n  const commonProperties = options?.commonProperties;\n  const thisDoc = options?.document ?? globalThis.document;\n\n  const removedNodes = mutationTracker(thisDoc, 'removedNodes', options?.enableOnRemovedFromDOM);\n\n  function DomPromiseContainer() {\n    return thisDoc.createComment(DEBUG\n      ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\"\n      : \"promise\")\n  }\n\n  function DyamicElementError({ error }: { error: Error | IteratorResult<Error> }) {\n    return thisDoc.createComment(error instanceof Error ? error.toString() : 'Error:\\n' + JSON.stringify(error, null, 2));\n  }\n  const poStyleElt = thisDoc.createElement(\"STYLE\");\n  poStyleElt.id = \"--ai-ui-extended-tag-styles-\";\n\n  /* Properties applied to every tag which can be implemented by reference, similar to prototypes */\n  const warned = new Set<string>();\n  const tagPrototypes: PoElementMethods = Object.create(\n    null,\n    {\n      when: {\n        writable: false,\n        configurable: true,\n        enumerable: false,\n        value: function (...what: WhenParameters) {\n          return when(this, ...what)\n        }\n      },\n      attributes: {\n        ...Object.getOwnPropertyDescriptor(Element.prototype, 'attributes'),\n        set(this: Element, a: object) {\n          if (isAsyncIter(a)) {\n            const ai = isAsyncIterator(a) ? a : a[Symbol.asyncIterator]();\n            const step = () => ai.next().then(\n              ({ done, value }) => { assignProps(this, value); done || step() },\n              ex => console.warn(ex));\n            step();\n          }\n          else assignProps(this, a);\n        }\n      },\n      ids: {\n        // .ids is a getter that when invoked for the first time\n        // lazily creates a Proxy that provides live access to children by id\n        configurable: true,\n        enumerable: true,\n        set: idsInaccessible,\n        get(this: Element) {\n          // Now we've been accessed, create the proxy\n          const idProxy = new Proxy(Object.create(null), {\n            apply: idsInaccessible,\n            construct: idsInaccessible,\n            defineProperty: idsInaccessible,\n            deleteProperty: idsInaccessible,\n            set: idsInaccessible,\n            setPrototypeOf: idsInaccessible,\n            getPrototypeOf() { return null },\n            isExtensible() { return false },\n            preventExtensions() { return true },\n            getOwnPropertyDescriptor(target, p) {\n              if (this.get!(target, p, null))\n                return Reflect.getOwnPropertyDescriptor(target, p);\n            },\n            has(target, p) {\n              const r = this.get!(target, p, null);\n              return Boolean(r);\n            },\n            ownKeys: (target) => {\n              const ids = [...this.querySelectorAll(`[id]`)].map(e => e.id);\n              const unique = [...new Set(ids)];\n              if (DEBUG && ids.length !== unique.length)\n                console.log(`Element contains multiple, shadowed decendant ids`, unique);\n              return unique;\n            },\n            get: (target, p, receiver) => {\n              if (typeof p === 'string') {\n                if (p in target) {\n                  if (this.contains(target[p]))\n                    return target[p];\n                  delete target[p];\n                }\n                let e: Element | undefined;\n                if (DEBUG) {\n                  const nl = this.querySelectorAll('#' + CSS.escape(p));\n                  if (nl.length > 1) {\n                    if (!warned.has(p)) {\n                      warned.add(p);\n                      console.log(`Element contains multiple, shadowed decendants with ID \"${p}\"`/*,`\\n\\t${logNode(this)}`*/);\n                    }\n                  }\n                  e = nl[0];\n                } else {\n                  e = this.querySelector('#' + CSS.escape(p)) ?? undefined;\n                }\n                if (e) target[p] = e;\n                return e;\n              }\n            }\n          });\n          // ..and replace the getter with the Proxy\n          Object.defineProperty(this, 'ids', {\n            configurable: true,\n            enumerable: true,\n            set: idsInaccessible,\n            get() { return idProxy }\n          });\n          // ...and return that from the getter, so subsequent property\n          // accesses go via the Proxy\n          return idProxy;\n        }\n      }\n    }\n  );\n\n  /* Add any user supplied prototypes */\n  if (commonProperties)\n    deepDefine(tagPrototypes, commonProperties);\n\n  function nodes(...c: ChildTags[]) {\n    const appended: Node[] = [];\n    (function children(c: ChildTags): void {\n      if (c === undefined || c === null || c === Ignore)\n        return;\n      if (isPromiseLike(c)) {\n        const g: ChildNode = DomPromiseContainer();\n        appended.push(g);\n        c.then(r => g.replaceWith(...nodes(r)),\n          (x: any) => {\n            console.warn(x, logNode(g));\n            g.replaceWith(DyamicElementError({ error: x }));\n          }\n        );\n        return;\n      }\n      if (c instanceof Node) {\n        appended.push(c);\n        return;\n      }\n\n      // We have an interesting case here where an iterable String is an object with both Symbol.iterator\n      // (inherited from the String prototype) and Symbol.asyncIterator (as it's been augmented by boxed())\n      // but we're only interested in cases like HTMLCollection, NodeList, array, etc., not the fukny ones\n      // It used to be after the isAsyncIter() test, but a non-AsyncIterator *may* also be a sync iterable\n      // For now, we exclude (Symbol.asyncIterator in c) in this case.\n      if (c && typeof c === 'object' && Symbol.iterator in c && !(Symbol.asyncIterator in c) && c[Symbol.iterator]) {\n        for (const d of c) children(d);\n        return;\n      }\n\n      if (isAsyncIter<ChildTags>(c)) {\n        const insertionStack = DEBUG ? ('\\n' + new Error().stack?.replace(/^Error: /, \"Insertion :\")) : '';\n        const ap = isAsyncIterator(c) ? c : c[Symbol.asyncIterator]();\n        // It's possible that this async iterator is a boxed object that also holds a value\n        const unboxed = c.valueOf();\n        const dpm = (unboxed === undefined || unboxed === c) ? [DomPromiseContainer()] : nodes(unboxed as ChildTags)\n\n        let t = dpm.length ? dpm : [DomPromiseContainer()];\n        appended.push(...t);\n        let notYetMounted = true;\n        // DEBUG support\n        let createdAt = Date.now() + timeOutWarn;\n        const createdBy = DEBUG && new Error(\"Created by\").stack;\n\n        const error = (errorValue: any) => {\n          const n = t.filter(n => Boolean(n?.parentNode)) as ChildNode[];\n          if (n.length) {\n            t = [DyamicElementError({ error: errorValue })];\n            n[0].replaceWith(...t);\n            n.slice(1).forEach(e => e?.parentNode!.removeChild(e));\n          }\n          else console.warn(\"Can't report error\", errorValue, createdBy, t.map(logNode));\n          t = [];\n          ap.return?.(errorValue);\n        }\n\n        const update = (es: IteratorResult<ChildTags>) => {\n          if (!es.done) {\n            try {\n              // ChildNode[], since we tested .parentNode\n              const mounted = t.filter(e => e?.parentNode && e.isConnected);\n              const n = notYetMounted ? t : mounted;\n              if (mounted.length) notYetMounted = false;\n\n              if (!n.length || t.every(e => removedNodes(e))) {\n                // We're done - terminate the source quietly (ie this is not an exception as it's expected, but we're done)\n                t = [];\n                const msg = \"Element(s) have been removed from the document: \" + insertionStack;\n                ap.return?.(new Error(msg));\n                return;\n              }\n\n              if (DEBUG && notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Async element not mounted after 5 seconds. If it is never mounted, it will leak.`, createdBy, t.map(logNode));\n              }\n              t = nodes(unbox(es.value) as ChildTags);\n              // If the iterated expression yields no nodes, stuff in a DomPromiseContainer for the next iteration\n              if (!t.length) t.push(DomPromiseContainer());\n              (n[0] as ChildNode).replaceWith(...t);\n              n.slice(1).forEach(e => !t.includes(e) && e.parentNode?.removeChild(e));\n              ap.next().then(update).catch(error);\n            } catch (ex) {\n              // Something went wrong. Terminate the iterator source\n              t = [];\n              ap.return?.(ex);\n            }\n          }\n        }\n        ap.next().then(update).catch(error);\n        return;\n      }\n      appended.push(thisDoc.createTextNode(c.toString()));\n    })(c);\n    return appended;\n  }\n\n  if (!nameSpace) {\n    Object.assign(tag, {\n      nodes,    // Build DOM Node[] from ChildTags\n      UniqueID\n    });\n  }\n\n  /** Just deep copy an object */\n  const plainObjectPrototype = Object.getPrototypeOf({});\n  /** Routine to *define* properties on a dest object from a src object **/\n  function deepDefine(d: Record<string | symbol | number, any>, s: any, declaration?: true): void {\n    if (s === null || s === undefined || typeof s !== 'object' || s === d)\n      return;\n\n    for (const [k, srcDesc] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      try {\n        if ('value' in srcDesc) {\n          const value = srcDesc.value;\n\n          if (value && isAsyncIter<unknown>(value)) {\n            Object.defineProperty(d, k, srcDesc);\n          } else {\n            // This has a real value, which might be an object, so we'll deepDefine it unless it's a\n            // Promise or a function, in which case we just assign it\n            if (value && typeof value === 'object' && !isPromiseLike(value)) {\n              if (!(k in d)) {\n                // If this is a new value in the destination, just define it to be the same value as the source\n                // If the source value is an object, and we're declaring it (therefore it should be a new one), take\n                // a copy so as to not re-use the reference and pollute the declaration. Note: this is probably\n                // a better default for any \"objects\" in a declaration that are plain and not some class type\n                // which can't be copied\n                if (declaration) {\n                  if (Object.getPrototypeOf(value) === plainObjectPrototype || !Object.getPrototypeOf(value)) {\n                    // A plain object can be deep-copied by field\n                    deepDefine(srcDesc.value = {}, value);\n                  } else if (Array.isArray(value)) {\n                    // An array can be deep copied by index\n                    deepDefine(srcDesc.value = [], value);\n                  } else {\n                    // Other object like things (regexps, dates, classes, etc) can't be deep-copied reliably\n                    console.warn(`Declared propety '${k}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`, d, value);\n                  }\n                }\n                Object.defineProperty(d, k, srcDesc);\n              } else {\n                if (value instanceof Node) {\n                  console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child\", k, logNode(value));\n                  d[k] = value;\n                } else {\n                  if (d[k] !== value) {\n                    // Note - if we're copying to an array of different length\n                    // we're decoupling common object references, so we need a clean object to\n                    // assign into\n                    if (Array.isArray(d[k]) && d[k].length !== value.length) {\n                      if (value.constructor === Object || value.constructor === Array) {\n                        deepDefine(d[k] = new (value.constructor), value);\n                      } else {\n                        // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                        d[k] = value;\n                      }\n                    } else {\n                      // This is just a regular object, so we deepDefine recursively\n                      deepDefine(d[k], value);\n                    }\n                  }\n                }\n              }\n            } else {\n              // This is just a primitive value, or a Promise\n              if (s[k] !== undefined)\n                d[k] = s[k];\n            }\n          }\n        } else {\n          // Copy the definition of the getter/setter\n          Object.defineProperty(d, k, srcDesc);\n        }\n      } catch (ex: unknown) {\n        console.warn(\"deepAssign\", k, s[k], ex);\n        throw ex;\n      }\n    }\n  }\n\n  function unbox(a: unknown): unknown {\n    const v = a?.valueOf();\n    return Array.isArray(v) ? Array.prototype.map.call(v, unbox) : v;\n  }\n\n  function assignProps(base: Node, props: Record<string, any>) {\n    // Copy prop hierarchy onto the element via the asssignment operator in order to run setters\n    if (!(callStackSymbol in props)) {\n      (function assign(d: any, s: any): void {\n        if (s === null || s === undefined || typeof s !== 'object')\n          return;\n        // static props before getters/setters\n        const sourceEntries = Object.entries(Object.getOwnPropertyDescriptors(s));\n        if (!Array.isArray(s)) {\n          sourceEntries.sort(a => {\n            const desc = Object.getOwnPropertyDescriptor(d, a[0]);\n            if (desc) {\n              if ('value' in desc) return -1;\n              if ('set' in desc) return 1;\n              if ('get' in desc) return 1;\n            }\n            return 0;\n          });\n        }\n        for (const [k, srcDesc] of sourceEntries) {\n          try {\n            if ('value' in srcDesc) {\n              const value = srcDesc.value;\n              if (isAsyncIter<unknown>(value)) {\n                assignIterable(value, k);\n              } else if (isPromiseLike(value)) {\n                value.then(v => {\n                  if (v && typeof v === 'object') {\n                    // Special case: this promise resolved to an async iterator\n                    if (isAsyncIter<unknown>(v)) {\n                      assignIterable(v, k);\n                    } else {\n                      assignObject(v, k);\n                    }\n                  } else {\n                    if (s[k] !== undefined)\n                      d[k] = v;\n                  }\n                }, error => console.log(\"Failed to set attribute\", error));\n              } else if (!isAsyncIter<unknown>(value)) {\n                // This has a real value, which might be an object\n                if (value && typeof value === 'object' && !isPromiseLike(value))\n                  assignObject(value, k);\n                else {\n                  if (s[k] !== undefined)\n                    d[k] = s[k];\n                }\n              }\n            } else {\n              // Copy the definition of the getter/setter\n              Object.defineProperty(d, k, srcDesc);\n            }\n          } catch (ex: unknown) {\n            console.warn(\"assignProps\", k, s[k], ex);\n            throw ex;\n          }\n        }\n\n        function assignIterable(value: AsyncIterable<unknown> | AsyncIterator<unknown, any, undefined>, k: string) {\n          const ap = asyncIterator(value);\n          let notYetMounted = true;\n          // DEBUG support\n          let createdAt = Date.now() + timeOutWarn;\n          const createdBy = DEBUG && new Error(\"Created by\").stack;\n          const update = (es: IteratorResult<unknown>) => {\n            if (!es.done) {\n              const value = unbox(es.value);\n              if (typeof value === 'object' && value !== null) {\n                /*\n              THIS IS JUST A HACK: `style` has to be set member by member, eg:\n                e.style.color = 'blue'        --- works\n                e.style = { color: 'blue' }   --- doesn't work\n              whereas in general when assigning to property we let the receiver\n              do any work necessary to parse the object. This might be better handled\n              by having a setter for `style` in the PoElementMethods that is sensitive\n              to the type (string|object) being passed so we can just do a straight\n              assignment all the time, or making the decsion based on the location of the\n              property in the prototype chain and assuming anything below \"PO\" must be\n              a primitive\n              */\n                const destDesc = Object.getOwnPropertyDescriptor(d, k);\n                if (k === 'style' || !destDesc?.set)\n                  assign(d[k], value);\n                else\n                  d[k] = value;\n              } else {\n                // Src is not an object (or is null) - just assign it, unless it's undefined\n                if (value !== undefined)\n                  d[k] = value;\n              }\n              const mounted = base.isConnected;\n              // If we have been mounted before, bit aren't now, remove the consumer\n              if (removedNodes(base) || (!notYetMounted && !mounted)) {\n                console.info(`Element does not exist in document when setting async attribute '${k}' to:\\n${logNode(base)}`);\n                ap.return?.();\n                return;\n              }\n              if (mounted) notYetMounted = false;\n              if (notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Element with async attribute '${k}' not mounted after 5 seconds. If it is never mounted, it will leak.\\nElement contains: ${logNode(base)}\\n${createdBy}`);\n              }\n\n              ap.next().then(update).catch(error);\n            }\n          }\n          const error = (errorValue: any) => {\n            console.warn(\"Dynamic attribute error\", errorValue, k, d, createdBy, logNode(base));\n            ap.return?.(errorValue);\n            base.appendChild(DyamicElementError({ error: errorValue }));\n          }\n          const unboxed = value.valueOf();\n          if (unboxed !== undefined && unboxed !== value && !isAsyncIter(unboxed))\n            update({ done: false, value: unboxed });\n          else\n            ap.next().then(update).catch(error);\n        }\n\n        function assignObject(value: any, k: string) {\n          if (value instanceof Node) {\n            console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes\", k, logNode(value));\n            d[k] = value;\n          } else {\n            // Note - if we're copying to ourself (or an array of different length),\n            // we're decoupling common object references, so we need a clean object to\n            // assign into\n            if (!(k in d) || d[k] === value || (Array.isArray(d[k]) && d[k].length !== value.length)) {\n              if (value.constructor === Object || value.constructor === Array) {\n                const copy = new (value.constructor);\n                assign(copy, value);\n                d[k] = copy;\n                //assign(d[k], value);\n              } else {\n                // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                d[k] = value;\n              }\n            } else {\n              if (Object.getOwnPropertyDescriptor(d, k)?.set)\n                d[k] = value;\n\n              else\n                assign(d[k], value);\n            }\n          }\n        }\n      })(base, props);\n    }\n  }\n\n  /*\n  Extend a component class with create a new component class factory:\n      const NewDiv = Div.extended({ overrides })\n          ...or...\n      const NewDic = Div.extended((instance:{ arbitrary-type }) => ({ overrides }))\n         ...later...\n      const eltNewDiv = NewDiv({attrs},...children)\n  */\n\n  type ExtendTagFunction = (attrs: TagCreationOptions & {\n    [callStackSymbol]?: Overrides[];\n    [k: string]: unknown;\n  } | ChildTags, ...children: ChildTags[]) => Element\n\n  interface ExtendTagFunctionInstance extends ExtendTagFunction {\n    super: TagCreator<Element>;\n    definition: Overrides;\n    valueOf: () => string;\n    extended: (this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) => ExtendTagFunctionInstance;\n  }\n\n  function tagHasInstance(this: ExtendTagFunctionInstance, e: any) {\n    for (let c = e.constructor; c; c = c.super) {\n      if (c === this)\n        return true;\n    }\n    return false;\n  }\n\n  function extended(this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) {\n    const instanceDefinition = (typeof _overrides !== 'function')\n      ? (instance: Instance) => Object.assign({}, _overrides, instance)\n      : _overrides\n\n    const uniqueTagID = Date.now().toString(36) + (idCount++).toString(36) + Math.random().toString(36).slice(2);\n    let staticExtensions: Overrides = instanceDefinition({ [UniqueID]: uniqueTagID });\n    /* \"Statically\" create any styles required by this widget */\n    if (staticExtensions.styles) {\n      poStyleElt.appendChild(thisDoc.createTextNode(staticExtensions.styles + '\\n'));\n      if (!thisDoc.head.contains(poStyleElt)) {\n        thisDoc.head.appendChild(poStyleElt);\n      }\n    }\n\n    // \"this\" is the tag we're being extended from, as it's always called as: `(this).extended`\n    // Here's where we actually create the tag, by accumulating all the base attributes and\n    // (finally) assigning those specified by the instantiation\n    const extendTagFn: ExtendTagFunction = (attrs, ...children) => {\n      const noAttrs = isChildTag(attrs);\n      const newCallStack: (Constructed & Overrides)[] = [];\n      const combinedAttrs = { [callStackSymbol]: (noAttrs ? newCallStack : attrs[callStackSymbol]) ?? newCallStack }\n      const e = noAttrs ? this(combinedAttrs, attrs, ...children) : this(combinedAttrs, ...children);\n      e.constructor = extendTag;\n      const tagDefinition = instanceDefinition({ [UniqueID]: uniqueTagID });\n      combinedAttrs[callStackSymbol].push(tagDefinition);\n      if (DEBUG) {\n        // Validate declare and override\n        function isAncestral(creator: TagCreator<Element>, d: string) {\n          for (let f = creator; f; f = f.super)\n            if (f.definition?.declare && d in f.definition.declare) return true;\n          return false;\n        }\n        if (tagDefinition.declare) {\n          const clash = Object.keys(tagDefinition.declare).filter(d => (d in e) || isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Declared keys '${clash}' in ${extendTag.name} already exist in base '${this.valueOf()}'`);\n          }\n        }\n        if (tagDefinition.override) {\n          const clash = Object.keys(tagDefinition.override).filter(d => !(d in e) && !(commonProperties && d in commonProperties) && !isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Overridden keys '${clash}' in ${extendTag.name} do not exist in base '${this.valueOf()}'`);\n          }\n        }\n      }\n      deepDefine(e, tagDefinition.declare, true);\n      deepDefine(e, tagDefinition.override);\n      const reAssign = new Set<string>();\n      tagDefinition.iterable && Object.keys(tagDefinition.iterable).forEach(k => {\n        if (k in e) {\n          console.log(`Ignoring attempt to re-define iterable property \"${k}\" as it could already have consumers`);\n          reAssign.add(k);\n        } else {\n          defineIterableProperty(e, k, tagDefinition.iterable![k as keyof typeof tagDefinition.iterable])\n        }\n      });\n      if (combinedAttrs[callStackSymbol] === newCallStack) {\n        if (!noAttrs)\n          assignProps(e, attrs);\n        for (const base of newCallStack) {\n          const children = base?.constructed?.call(e);\n          if (isChildTag(children)) // technically not necessary, since \"void\" is going to be undefined in 99.9% of cases.\n            e.append(...nodes(children));\n        }\n        // Once the full tree of augmented DOM elements has been constructed, fire all the iterable propeerties\n        // so the full hierarchy gets to consume the initial state, unless they have been assigned\n        // by assignProps from a future\n        const combinedInitialIterableValues = {};\n        let hasInitialValues = false;\n        for (const base of newCallStack) {\n          if (base.iterable) for (const k of Object.keys(base.iterable)) {\n            // We don't self-assign iterables that have themselves been assigned with futures\n            const attrExists = !noAttrs && k in attrs;\n            if ((reAssign.has(k) && attrExists) || !(attrExists && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e]?.valueOf();\n              if (value !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                combinedInitialIterableValues[k] = value;\n                hasInitialValues = true;\n              }\n            }\n          }\n        }\n        if (hasInitialValues)\n          Object.assign(e, combinedInitialIterableValues);\n      }\n      return e;\n    }\n\n    const extendTag: ExtendTagFunctionInstance = Object.assign(extendTagFn, {\n      super: this,\n      definition: Object.assign(staticExtensions, { [UniqueID]: uniqueTagID }),\n      extended,\n      valueOf: () => {\n        const keys = [...Object.keys(staticExtensions.declare || {}), ...Object.keys(staticExtensions.iterable || {})];\n        return `${extendTag.name}: {${keys.join(', ')}}\\n \\u21AA ${this.valueOf()}`\n      }\n    });\n    Object.defineProperty(extendTag, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    const fullProto = {};\n    (function walkProto(creator: TagCreator<Element>) {\n      if (creator?.super)\n        walkProto(creator.super);\n\n      const proto = creator.definition;\n      if (proto) {\n        deepDefine(fullProto, proto?.override);\n        deepDefine(fullProto, proto?.declare);\n      }\n    })(this);\n    deepDefine(fullProto, staticExtensions.override);\n    deepDefine(fullProto, staticExtensions.declare);\n    Object.defineProperties(extendTag, Object.getOwnPropertyDescriptors(fullProto));\n\n    // Attempt to make up a meaningfu;l name for this extended tag\n    const creatorName = fullProto\n      && 'className' in fullProto\n      && typeof fullProto.className === 'string'\n      ? fullProto.className\n      : uniqueTagID;\n    const callSite = DEBUG ? (new Error().stack?.split('\\n')[2] ?? '') : '';\n\n    Object.defineProperty(extendTag, \"name\", {\n      value: \"<ai-\" + creatorName.replace(/\\s+/g, '-') + callSite + \">\"\n    });\n\n    if (DEBUG) {\n      const extraUnknownProps = Object.keys(staticExtensions).filter(k => !['styles', 'ids', 'constructed', 'declare', 'override', 'iterable'].includes(k));\n      if (extraUnknownProps.length) {\n        console.log(`${extendTag.name} defines extraneous keys '${extraUnknownProps}', which are unknown`);\n      }\n    }\n    return extendTag;\n  }\n\n  // @ts-ignore\n  const baseTagCreators: CreateElement & {\n    [K in keyof HTMLElementTagNameMap]?: TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>\n  } & {\n    [n: string]: TagCreator<Q & Element & PoElementMethods>\n  } = {\n    createElement(\n      name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n      attrs: any,\n      ...children: ChildTags[]): Node {\n      return (name === baseTagCreators.createElement ? nodes(...children)\n        : typeof name === 'function' ? name(attrs, children)\n        : typeof name === 'string' && name in baseTagCreators ?\n        // @ts-ignore: Expression produces a union type that is too complex to represent.ts(2590)\n            baseTagCreators[name](attrs, children)\n        : name instanceof Node ? name\n        : DyamicElementError({ error: new Error(\"Illegal type in createElement:\" + name) })) as Node\n    }\n  }\n\n  function createTag<K extends keyof HTMLElementTagNameMap>(k: K): TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>;\n  function createTag<E extends Element>(k: string): TagCreator<Q & E & PoElementMethods>;\n  function createTag(k: string): TagCreator<Q & NamespacedElementBase & PoElementMethods> {\n    if (baseTagCreators[k])\n      // @ts-ignore\n      return baseTagCreators[k];\n\n    const tagCreator = (attrs: Q & PoElementMethods & TagCreationOptions | ChildTags, ...children: ChildTags[]) => {\n      if (isChildTag(attrs)) {\n        children.unshift(attrs);\n        attrs = {} as any;\n      }\n\n      // This test is always true, but narrows the type of attrs to avoid further errors\n      if (!isChildTag(attrs)) {\n        if (attrs.debugger) {\n          debugger;\n          delete attrs.debugger;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? thisDoc.createElementNS(nameSpace as string, k.toLowerCase())\n          : thisDoc.createElement(k);\n        e.constructor = tagCreator;\n\n        deepDefine(e, tagPrototypes);\n        assignProps(e, attrs);\n\n        // Append any children\n        e.append(...nodes(...children));\n        return e;\n      }\n    }\n\n    const includingExtender = <TagCreator<Element>><unknown>Object.assign(tagCreator, {\n      super: () => { throw new Error(\"Can't invoke native elemenet constructors directly. Use document.createElement().\") },\n      extended, // How to extend this (base) tag\n      valueOf() { return `TagCreator: <${nameSpace || ''}${nameSpace ? '::' : ''}${k}>` }\n    });\n\n    Object.defineProperty(tagCreator, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    Object.defineProperty(tagCreator, \"name\", { value: '<' + k + '>' });\n    // @ts-ignore\n    return baseTagCreators[k] = includingExtender;\n  }\n\n  tags.forEach(createTag);\n\n  // @ts-ignore\n  return baseTagCreators;\n}\n\n/* DOM node removal logic */\ntype PickByType<T, Value> = {\n  [P in keyof T as T[P] extends Value | undefined ? P : never]: T[P]\n}\nfunction mutationTracker(root: Node, track: keyof PickByType<MutationRecord, NodeList>, enableOnRemovedFromDOM?: boolean) {\n  const tracked = new WeakSet<Node>();\n  function walk(nodes: NodeList) {\n    for (const node of nodes) {\n      // In case it's be re-added/moved\n      if ((track === 'addedNodes') === node.isConnected) {\n        walk(node.childNodes);\n        tracked.add(node);\n        // Legacy onRemovedFromDOM support\n        if (enableOnRemovedFromDOM && 'onRemovedFromDOM' in node && typeof node.onRemovedFromDOM === 'function') node.onRemovedFromDOM();\n      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m[track].length) {\n        walk(m[track])\n      }\n    });\n  }).observe(root, { subtree: true, childList: true });\n\n  return function (node: Node) {\n    return tracked.has(node);\n  }\n}\n", "// @ts-ignore\nexport const DEBUG = globalThis.DEBUG == '*' || globalThis.DEBUG == true || globalThis.DEBUG?.match(/(^|\\W)AI-UI(\\W|$)/) || false;\nexport { _console as console };\nexport const timeOutWarn = 5000;\n\nconst _console = {\n  log(...args: any) {\n    if (DEBUG) console.log('(AI-UI) LOG:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  info(...args: any) {\n    if (DEBUG) console.trace('(AI-UI) INFO:', ...args)\n  }\n}\n\n", "import { DEBUG, console } from \"./debug.js\";\n\n// Create a deferred Promise, which can be asynchronously/externally resolved or rejected.\nexport type DeferredPromise<T> = Promise<T> & {\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (value: any) => void;\n}\n\n// Used to suppress TS error about use before initialisation\nconst nothing = (v: any)=>{};\n\nexport function deferred<T>(): DeferredPromise<T> {\n  let resolve: (value: T | PromiseLike<T>) => void = nothing;\n  let reject: (value: any) => void = nothing;\n  const promise = new Promise<T>((...r) => [resolve, reject] = r) as DeferredPromise<T>;\n  promise.resolve = resolve;\n  promise.reject = reject;\n  if (DEBUG) {\n    const initLocation = new Error().stack;\n    promise.catch(ex => (ex instanceof Error || ex?.value instanceof Error) ? console.log(\"Deferred rejection\", ex, \"allocated at \", initLocation) : undefined);\n  }\n  return promise;\n}\n\n// True if `expr in x` is valid\nexport function isObjectLike(x: any): x is Function | {} {\n  return x && typeof x === 'object' || typeof x === 'function'\n}\n\nexport function isPromiseLike<T>(x: any): x is PromiseLike<T> {\n  return isObjectLike(x) && ('then' in x) && typeof x.then === 'function';\n}\n", "import { DEBUG, console } from \"./debug.js\"\nimport { DeferredPromise, deferred, isObjectLike, isPromiseLike } from \"./deferred.js\"\n\n/* IterableProperties can't be correctly typed in TS right now, either the declaratiion\n  works for retrieval (the getter), or it works for assignments (the setter), but there's\n  no TS syntax that permits correct type-checking at present.\n\n  Ideally, it would be:\n\n  type IterableProperties<IP> = {\n    get [K in keyof IP](): AsyncExtraIterable<IP[K]> & IP[K]\n    set [K in keyof IP](v: IP[K])\n  }\n  See https://github.com/microsoft/TypeScript/issues/43826\n\n  We choose the following type description to avoid the issues above. Because the AsyncExtraIterable\n  is Partial it can be omitted from assignments:\n    this.prop = value;  // Valid, as long as valus has the same type as the prop\n  ...and when retrieved it will be the value type, and optionally the async iterator:\n    Div(this.prop) ; // the value\n    this.prop.map!(....)  // the iterator (note the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts which *accepts* a Partial<AsyncIterator>\n  but casts it to a AsyncIterator before use.\n\n  The iterability of propertys of an object is determined by the presence and value of the `Iterability` symbol.\n  By default, the current implementation does a deep mapping, so an iterable property 'obj' is itself\n  iterable, as are it's members. The only defined value at present is \"shallow\", in which case 'obj' remains\n  iterable, but it's membetrs are just POJS values.\n*/\n\n// Base types that can be made defined as iterable: basically anything, _except_ a function\nexport type IterablePropertyPrimitive = (string | number | bigint | boolean | undefined | null);\n// We should exclude AsyncIterable from the types that can be assigned to iterables (and therefore passed to defineIterableProperty)\nexport type IterablePropertyValue = IterablePropertyPrimitive | IterablePropertyValue[] | { [k: string | symbol | number]: IterablePropertyValue };\n\nexport const Iterability = Symbol(\"Iterability\");\nexport type Iterability<Depth extends 'shallow' = 'shallow'> = { [Iterability]: Depth };\nexport type IterableType<T> = T & Partial<AsyncExtraIterable<T>>;\n\ndeclare global {\n  // This is patch to the std lib definition of Array<T>. I don't know why it's absent,\n  // as this is the implementation in all JavaScript engines. It is probably a result\n  // of its absence in https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values,\n  // which inherits from the Object.prototype, which makes no claim for the return type\n  // since it could be overriddem. However, in that case, a TS defn should also override\n  // it, like Number, String, Boolean etc do.\n  interface Array<T> {\n    valueOf(): Array<T>;\n  }\n  // As above, the return type could be T rather than Object, since this is the default impl,\n  // but it's not, for some reason.\n  interface Object {\n    valueOf<T>(this: T): T extends IterableType<infer Z> ? Z : Object;\n  }\n}\n\nexport type IterableProperties<IP> = IP extends Iterability<'shallow'> ? {\n  [K in keyof Omit<IP, typeof Iterability>]: IterableType<IP[K]>\n} : ({\n  [K in keyof IP]: (\n    IP[K] extends Array<infer E>\n    ? (IterableProperties<E>[] | IterableProperties<E[]>)\n    : ((\n      IP[K] extends object\n      ? IterableProperties<IP[K]>\n      : IP[K]\n    ) & IterableType<IP[K]>)\n  )\n})\n\n/* Things to suppliement the JS base AsyncIterable */\nexport interface QueueIteratableIterator<T> extends AsyncIterableIterator<T>, AsyncIterableHelpers {\n  push(value: T): boolean;\n  readonly length: number;\n}\n\nexport interface AsyncExtraIterable<T> extends AsyncIterable<T>, AsyncIterableHelpers { }\n\n// NB: This also (incorrectly) passes sync iterators, as the protocol names are the same\nexport function isAsyncIterator<T = unknown>(o: any | AsyncIterator<T>): o is AsyncIterator<T> {\n  return isObjectLike(o) && 'next' in o && typeof o?.next === 'function'\n}\nexport function isAsyncIterable<T = unknown>(o: any | AsyncIterable<T>): o is AsyncIterable<T> {\n  return isObjectLike(o) && (Symbol.asyncIterator in o) && typeof o[Symbol.asyncIterator] === 'function'\n}\nexport function isAsyncIter<T = unknown>(o: any | AsyncIterable<T> | AsyncIterator<T>): o is AsyncIterable<T> | AsyncIterator<T> {\n  return isAsyncIterable(o) || isAsyncIterator(o)\n}\n\nexport type AsyncProvider<T> = AsyncIterator<T> | AsyncIterable<T>\n\nexport function asyncIterator<T>(o: AsyncProvider<T>) {\n  if (isAsyncIterator(o)) return o;\n  if (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  throw new Error(\"Not an async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nexport const asyncExtras = {\n  filterMap<U extends PartialIterable, R>(this: U,\n    fn: (o: HelperAsyncIterable<U>, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>,\n    initialValue: R | typeof Ignore = Ignore\n  ) {\n    return filterMap(this, fn, initialValue)\n  },\n  map,\n  filter,\n  unique,\n  waitFor,\n  multi,\n  initially,\n  consume,\n  merge<T, A extends Partial<AsyncIterable<any>>[]>(this: PartialIterable<T>, ...m: A) {\n    return merge(this, ...m);\n  },\n  combine<T, S extends CombinedIterable>(this: PartialIterable<T>, others: S) {\n    return combine(Object.assign({ '_this': this }, others));\n  }\n};\n\nconst extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)] as (keyof typeof asyncExtras)[];\n\n// Like Object.assign, but the assigned properties are not enumerable\nfunction assignHidden<D extends {}, S extends {}>(d: D, s: S) {\n  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];\n  for (const k of keys) {\n    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });\n  }\n  return d as D & S;\n}\n\nconst _pending = Symbol('pending');\nconst _items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [_items]: [] as IteratorResult<T>[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[_items]?.length) {\n        return Promise.resolve(q[_items].shift()!);\n      }\n\n      if (!q[_pending])\n        return Promise.resolve({ done: true as const, value: undefined });\n\n      const value = deferred<IteratorResult<T>>();\n      // We install a catch handler as the promise might be legitimately reject before anything waits for it,\n      // and this suppresses the uncaught exception warning.\n      value.catch(ex => { });\n      q[_pending].unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.resolve(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.resolve(value);\n    },\n\n    throw(...args: any[]) {\n      const value = { done: true as const, value: args[0] };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.reject(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[_items]) return -1; // The queue has no consumers and has terminated.\n      return q[_items].length;\n    },\n\n    push(value: T) {\n      if (!q[_pending])\n        return false;\n\n      if (q[_pending].length) {\n        q[_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[_items].push({ done: false, value })\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst _inflight = Symbol('inflight');\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [_inflight]: Set<T> };\n  q[_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[_pending])\n      return false;\n\n    // Debounce\n    if (q[_inflight].has(value))\n      return true;\n\n    if (q[_pending].length) {\n      q[_inflight].add(value);\n      const p = q[_pending].pop()!;\n      p.finally(() => q[_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[_items].find(v => v.value === value)) {\n        q[_items].push({ done: false, value });\n      }\n    }\n    return true;\n  }\n  return q;\n}\n\n// Re-export to hide the internals\nexport const queueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalQueueIteratableIterator;\nexport const debounceQueueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalDebounceQueueIteratableIterator;\n\ndeclare global {\n  interface ObjectConstructor {\n    defineProperties<T, M extends { [K: string | symbol]: TypedPropertyDescriptor<any> }>(o: T, properties: M & ThisType<any>): T & {\n      [K in keyof M]: M[K] extends TypedPropertyDescriptor<infer T> ? T : never\n    };\n  }\n}\n\n/* Define a \"iterable property\" on `obj`.\n   This is a property that holds a boxed (within an Object() call) value, and is also an AsyncIterableIterator. which\n   yields when the property is set.\n   This routine creates the getter/setter for the specified property, and manages the aassociated async iterator.\n*/\n\nconst _proxiedAsyncIterator = Symbol('_proxiedAsyncIterator');\nexport function defineIterableProperty<T extends {}, const N extends string | symbol, V extends IterablePropertyValue>(obj: T, name: N, v: V): T & IterableProperties<{ [k in N]: V }> {\n  // Make `a` an AsyncExtraIterable. We don't do this until a consumer actually tries to\n  // access the iterator methods to prevent leaks where an iterable is created, but\n  // never referenced, and therefore cannot be consumed and ultimately closed\n  let initIterator = () => {\n    initIterator = () => b;\n    const bi = debounceQueueIteratableIterator<V>();\n    const mi = bi.multi();\n    const b = mi[Symbol.asyncIterator]();\n    extras[Symbol.asyncIterator] = mi[Symbol.asyncIterator];\n    push = bi.push;\n    extraKeys.forEach(k => // @ts-ignore\n      extras[k] = b[k as keyof typeof b]);\n    if (!(_proxiedAsyncIterator in a))\n      assignHidden(a, extras);\n    return b;\n  }\n\n  // Create stubs that lazily create the AsyncExtraIterable interface when invoked\n  function lazyAsyncMethod<M extends keyof typeof asyncExtras>(method: M) {\n    return {\n      [method]: function (this: unknown, ...args: any[]) {\n        initIterator();\n        // @ts-ignore - Fix\n        return a[method].apply(this, args);\n      } as (typeof asyncExtras)[M]\n    }[method];\n  }\n\n  type HelperDescriptors<T> = {\n    [K in keyof AsyncExtraIterable<T>]: TypedPropertyDescriptor<AsyncExtraIterable<T>[K]>\n  } & {\n    [Iterability]?: TypedPropertyDescriptor<'shallow'>\n  };\n\n  const extras = { [Symbol.asyncIterator]: initIterator } as AsyncExtraIterable<V> & { [Iterability]?: 'shallow' };\n  extraKeys.forEach((k) => // @ts-ignore\n    extras[k] = lazyAsyncMethod(k))\n  if (typeof v === 'object' && v && Iterability in v && v[Iterability] === 'shallow') {\n    extras[Iterability] = v[Iterability];\n  }\n\n  // Lazily initialize `push`\n  let push: QueueIteratableIterator<V>['push'] = (v: V) => {\n    initIterator(); // Updates `push` to reference the multi-queue\n    return push(v);\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<V> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: V | AsyncExtraIterable<V>) {\n      if (v !== a) {\n        if (isAsyncIterable(v)) {\n          // Assigning multiple async iterators to a single iterable is probably a\n          // bad idea from a reasoning point of view, and multiple implementations\n          // are possible:\n          //  * merge?\n          //  * ignore subsequent assignments?\n          //  * terminate the first then consume the second?\n          // The solution here (one of many possibilities) is the letter: only to allow\n          // most recent assignment to work, terminating any preceeding iterator when it next\n          // yields and finds this consumer has been re-assigned.\n\n          // If the iterator has been reassigned with no change, just ignore it, as we're already consuming it\n          if (piped === v)\n            return;\n\n          piped = v;\n          let stack = DEBUG ? new Error() : undefined;\n          if (DEBUG)\n            console.info(new Error(`Iterable \"${name.toString()}\" has been assigned to consume another iterator. Did you mean to declare it?`));\n          consume.call(v, y => {\n            if (v !== piped) {\n              // We're being piped from something else. We want to stop that one and get piped from this one\n              throw new Error(`Piped iterable \"${name.toString()}\" has been replaced by another iterator`, { cause: stack });\n            }\n            push(y?.valueOf() as V)\n          })\n            .catch(ex => console.info(ex))\n            .finally(() => (v === piped) && (piped = undefined));\n\n          // Early return as we're going to pipe values in later\n          return;\n        } else {\n          if (piped && DEBUG) {\n            console.log(`Iterable \"${name.toString()}\" is already piped from another iterator, and might be overrwitten later`);\n          }\n          a = box(v, extras);\n        }\n      }\n      push(v?.valueOf() as V);\n    },\n    enumerable: true\n  });\n  return obj as any;\n\n  function box<V>(a: V, pds: AsyncExtraIterable<V>): V & AsyncExtraIterable<V> {\n    if (a === null || a === undefined) {\n      return assignHidden(Object.create(null, {\n        valueOf: { value() { return a }, writable: true, configurable: true },\n        toJSON: { value() { return a }, writable: true, configurable: true }\n      }), pds);\n    }\n    switch (typeof a) {\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return assignHidden(Object(a), Object.assign(pds, {\n          toJSON() { return a.valueOf() }\n        }));\n      case 'object':\n        // We box objects by creating a Proxy for the object that pushes on get/set/delete, and maps the supplied async iterator to push the specified key\n        // The proxies are recursive, so that if an object contains objects, they too are proxied. Objects containing primitives remain proxied to\n        // handle the get/set/selete in place of the usual primitive boxing via Object(primitiveValue)\n        // @ts-ignore\n        return boxObject(a, pds);\n\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n\n  type WithPath = { [_proxiedAsyncIterator]: { a: V, path: string | null } };\n  type PossiblyWithPath = V | WithPath;\n  function isProxiedAsyncIterator(o: PossiblyWithPath): o is WithPath {\n    return isObjectLike(o) && _proxiedAsyncIterator in o;\n  }\n  function destructure(o: any, path: string) {\n    const fields = path.split('.').slice(1);\n    for (let i = 0; i < fields.length && ((o = o?.[fields[i]]) !== undefined); i++);\n    return o;\n  }\n  function boxObject(a: V, pds: AsyncExtraIterable<PossiblyWithPath>) {\n    let withPath: AsyncExtraIterable<WithPath[typeof _proxiedAsyncIterator]>;\n    let withoutPath: AsyncExtraIterable<V>;\n    return new Proxy(a as object, handler()) as V & AsyncExtraIterable<V>;\n\n    function handler(path = ''): ProxyHandler<object> {\n      return {\n        // A boxed object has its own keys, and the keys of an AsyncExtraIterable\n        has(target, key) {\n          return key === _proxiedAsyncIterator || key === Symbol.toPrimitive || key in target || key in pds;\n        },\n        // When a key is set in the target, push the change\n        set(target, key, value, receiver) {\n          if (Object.hasOwn(pds, key)) {\n            throw new Error(`Cannot set ${name.toString()}${path}.${key.toString()} as it is part of asyncIterator`);\n          }\n          if (Reflect.get(target, key, receiver) !== value) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n          }\n          return Reflect.set(target, key, value, receiver);\n        },\n        deleteProperty(target, key) {\n          if (Reflect.deleteProperty(target, key)) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n            return true;\n          }\n          return false;\n        },\n        // When getting the value of a boxed object member, prefer asyncExtraIterable over target keys\n        get(target, key, receiver) {\n          // If the key is an asyncExtraIterable member, create the mapped queue to generate it\n          if (Object.hasOwn(pds, key)) {\n            if (!path.length) {\n              withoutPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator].a : o);\n              return withoutPath[key as keyof typeof pds];\n            } else {\n              withPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator] : { a: o, path: null });\n\n              let ai = filterMap(withPath, (o, p) => {\n                const v = destructure(o.a, path);\n                return p !== v || o.path === null || o.path.startsWith(path) ? v : Ignore;\n              }, Ignore, destructure(a, path));\n              return ai[key as keyof typeof ai];\n            }\n          }\n\n          // If the key is a target property, create the proxy to handle it\n          if (key === 'valueOf') return () => destructure(a, path);\n          if (key === Symbol.toPrimitive) {\n            // Special case, since Symbol.toPrimitive is in ha(), we need to implement it\n            return function (hint?: 'string' | 'number' | 'default') {\n              if (Reflect.has(target, key))\n                return Reflect.get(target, key, target).call(target, hint);\n              if (hint === 'string') return target.toString();\n              if (hint === 'number') return Number(target);\n              return target.valueOf();\n            }\n          }\n          if (typeof key === 'string') {\n            if ((!(key in target) || Object.hasOwn(target, key)) && !(Iterability in target && target[Iterability] === 'shallow')) {\n              const field = Reflect.get(target, key, receiver);\n              return (typeof field === 'function') || isAsyncIter(field)\n                ? field\n                : new Proxy(Object(field), handler(path + '.' + key));\n            }\n          }\n          // This is a symbolic entry, or a prototypical value (since it's in the target, but not a target property)\n          return Reflect.get(target, key, receiver);\n        }\n      }\n    }\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\nconst forever = new Promise<any>(() => { });\n\n/* Merge asyncIterables into a single asyncIterable */\n\n/* TS hack to expose the return AsyncGenerator a generator of the union of the merged types */\ntype CollapseIterableType<T> = T[] extends Partial<AsyncIterable<infer U>>[] ? U : never;\ntype CollapseIterableTypes<T> = AsyncIterable<CollapseIterableType<T>>;\n\nexport const merge = <A extends Partial<AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>>[], TYield, TReturn, TNext>(...ai: A) => {\n  const it: (undefined | AsyncIterator<any>)[] = new Array(ai.length);\n  const promises: Promise<{ idx: number, result: IteratorResult<any> }>[] = new Array(ai.length);\n\n  let init = () => {\n    init = () => { }\n    for (let n = 0; n < ai.length; n++) {\n      const a = ai[n] as AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>;\n      promises[n] = (it[n] = Symbol.asyncIterator in a\n        ? a[Symbol.asyncIterator]()\n        : a as AsyncIterator<any>)\n        .next()\n        .then(result => ({ idx: n, result }));\n    }\n  }\n\n  const results: (TYield | TReturn)[] = [];\n  let count = promises.length;\n\n  const merged: AsyncIterableIterator<A[number]> = {\n    [Symbol.asyncIterator]() { return merged },\n    next() {\n      init();\n      return count\n        ? Promise.race(promises).then(({ idx, result }) => {\n          if (result.done) {\n            count--;\n            promises[idx] = forever;\n            results[idx] = result.value;\n            // We don't yield intermediate return values, we just keep them in results\n            // return { done: count === 0, value: result.value }\n            return merged.next();\n          } else {\n            // `ex` is the underlying async iteration exception\n            promises[idx] = it[idx]\n              ? it[idx]!.next().then(result => ({ idx, result })).catch(ex => ({ idx, result: { done: true, value: ex } }))\n              : Promise.resolve({ idx, result: { done: true, value: undefined } })\n            return result;\n          }\n        }).catch(ex => {\n          return merged.throw?.(ex) ?? Promise.reject({ done: true as const, value: new Error(\"Iterator merge exception\") });\n        })\n        : Promise.resolve({ done: true as const, value: results });\n    },\n    async return(r) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.return?.({ done: true, value: r }).then(v => v.value, ex => ex);\n        }\n      }\n      return { done: true, value: results };\n    },\n    async throw(ex: any) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.throw?.(ex).then(v => v.value, ex => ex);\n        }\n      }\n      // Because we've passed the exception on to all the sources, we're now done\n      // previously: return Promise.reject(ex);\n      return { done: true, value: results };\n    }\n  };\n  return iterableHelpers(merged as unknown as CollapseIterableTypes<A[number]>);\n}\n\ntype CombinedIterable = { [k: string | number | symbol]: PartialIterable };\ntype CombinedIterableType<S extends CombinedIterable> = {\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n};\ntype CombinedIterableResult<S extends CombinedIterable> = AsyncExtraIterable<{\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n}>;\n\nexport interface CombineOptions {\n  ignorePartial?: boolean; // Set to avoid yielding if some sources are absent\n}\n\nexport const combine = <S extends CombinedIterable>(src: S, opts: CombineOptions = {}): CombinedIterableResult<S> => {\n  const accumulated: CombinedIterableType<S> = {};\n  let pc: Promise<{ idx: number, k: string, ir: IteratorResult<any> }>[];\n  let si: AsyncIterator<any>[] = [];\n  let active: number = 0;\n  const ci = {\n    [Symbol.asyncIterator]() { return ci },\n    next(): Promise<IteratorResult<CombinedIterableType<S>>> {\n      if (pc === undefined) {\n        pc = Object.entries(src).map(([k, sit], idx) => {\n          active += 1;\n          si[idx] = sit[Symbol.asyncIterator]!();\n          return si[idx].next().then(ir => ({ si, idx, k, ir }));\n        });\n      }\n\n      return (function step(): Promise<IteratorResult<CombinedIterableType<S>>> {\n        return Promise.race(pc).then(({ idx, k, ir }) => {\n          if (ir.done) {\n            pc[idx] = forever;\n            active -= 1;\n            if (!active)\n              return { done: true, value: undefined };\n            return step();\n          } else {\n            // @ts-ignore\n            accumulated[k] = ir.value;\n            pc[idx] = si[idx].next().then(ir => ({ idx, k, ir }));\n          }\n          if (opts.ignorePartial) {\n            if (Object.keys(accumulated).length < Object.keys(src).length)\n              return step();\n          }\n          return { done: false, value: accumulated };\n        })\n      })();\n    },\n    return(v?: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].return?.(v)\n        }\n      });\n      return Promise.resolve({ done: true, value: v });\n    },\n    throw(ex: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].throw?.(ex)\n        }\n      });\n      return Promise.reject({ done: true, value: ex });\n    }\n  }\n  return iterableHelpers(ci);\n}\n\n\nfunction isExtraIterable<T>(i: any): i is AsyncExtraIterable<T> {\n  return isAsyncIterable(i)\n    && extraKeys.every(k => (k in i) && (i as any)[k] === asyncExtras[k]);\n}\n\n// Attach the pre-defined helpers onto an AsyncIterable and return the modified object correctly typed\nexport function iterableHelpers<A extends AsyncIterable<any>>(ai: A): A & AsyncExtraIterable<A extends AsyncIterable<infer T> ? T : unknown> {\n  if (!isExtraIterable(ai)) {\n    assignHidden(ai, asyncExtras);\n  }\n  return ai as A extends AsyncIterable<infer T> ? AsyncExtraIterable<T> & A : never\n}\n\nexport function generatorHelpers<G extends (...args: any[]) => R, R extends AsyncGenerator>(g: G) {\n  return function (...args: Parameters<G>): ReturnType<G> {\n    const ai = g(...args);\n    return iterableHelpers(ai) as ReturnType<G>;\n  } as (...args: Parameters<G>) => ReturnType<G> & AsyncExtraIterable<ReturnType<G> extends AsyncGenerator<infer T> ? T : unknown>\n}\n\n/* AsyncIterable helpers, which can be attached to an AsyncIterator with `withHelpers(ai)`, and invoked directly for foreign asyncIterators */\n\n/* types that accept Partials as potentiallu async iterators, since we permit this IN TYPING so\n  iterable properties don't complain on every access as they are declared as V & Partial<AsyncIterable<V>>\n  due to the setters and getters having different types, but undeclarable in TS due to syntax limitations */\ntype HelperAsyncIterable<Q extends Partial<AsyncIterable<any>>> = HelperAsyncIterator<Required<Q>[typeof Symbol.asyncIterator]>;\ntype HelperAsyncIterator<F> =\n  F extends () => AsyncIterator<infer T>\n  ? T : never;\n\nasync function consume<U extends Partial<AsyncIterable<any>>>(this: U, f?: (u: HelperAsyncIterable<U>) => void | PromiseLike<void>): Promise<void> {\n  let last: undefined | void | PromiseLike<void> = undefined;\n  for await (const u of this as AsyncIterable<HelperAsyncIterable<U>>) {\n    last = f?.(u);\n  }\n  await last;\n}\n\ntype Mapper<U, R> = ((o: U, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>);\ntype MaybePromised<T> = PromiseLike<T> | T;\n\n/* A general filter & mapper that can handle exceptions & returns */\nexport const Ignore = Symbol(\"Ignore\");\n\ntype PartialIterable<T = any> = Partial<AsyncIterable<T>>;\n\nfunction resolveSync<Z, R>(v: MaybePromised<Z>, then: (v: Z) => R, except: (x: any) => any): MaybePromised<R> {\n  if (isPromiseLike(v))\n    return v.then(then, except);\n  try { return then(v) } catch (ex) { return except(ex) }\n}\n\nexport function filterMap<U extends PartialIterable, R>(source: U,\n  fn: Mapper<HelperAsyncIterable<U>, R>,\n  initialValue: R | typeof Ignore = Ignore,\n  prev: R | typeof Ignore = Ignore\n): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  const fai: AsyncIterableIterator<R> = {\n    [Symbol.asyncIterator]() {\n      return fai;\n    },\n\n    next(...args: [] | [undefined]) {\n      if (initialValue !== Ignore) {\n        const init = Promise.resolve({ done: false, value: initialValue });\n        initialValue = Ignore;\n        return init;\n      }\n\n      return new Promise<IteratorResult<R>>(function step(resolve, reject) {\n        if (!ai)\n          ai = source[Symbol.asyncIterator]!();\n        ai.next(...args).then(\n          p => p.done\n            ? resolve(p)\n            : resolveSync(fn(p.value, prev),\n              f => f === Ignore\n                ? step(resolve, reject)\n                : resolve({ done: false, value: prev = f }),\n              ex => {\n                // The filter function failed...\n                ai.throw ? ai.throw(ex) : ai.return?.(ex) // Terminate the source - for now we ignore the result of the termination\n                reject({ done: true, value: ex }); // Terminate the consumer\n              }\n            ),\n\n          ex =>\n            // The source threw. Tell the consumer\n            reject({ done: true, value: ex })\n        ).catch(ex => {\n          // The callback threw\n          ai.throw ? ai.throw(ex) : ai.return?.(ex); // Terminate the source - for now we ignore the result of the termination\n          reject({ done: true, value: ex })\n        })\n      })\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(fai)\n}\n\nfunction map<U extends PartialIterable, R>(this: U, mapper: Mapper<HelperAsyncIterable<U>, R>): AsyncExtraIterable<R> {\n  return filterMap(this, mapper);\n}\n\nfunction filter<U extends PartialIterable>(this: U, fn: (o: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, async o => (await fn(o) ? o : Ignore));\n}\n\nfunction unique<U extends PartialIterable>(this: U, fn?: (next: HelperAsyncIterable<U>, prev: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return fn\n    ? filterMap(this, async (o, p) => (p === Ignore || await fn(o, p)) ? o : Ignore)\n    : filterMap(this, (o, p) => o === p ? Ignore : o);\n}\n\nfunction initially<U extends PartialIterable, I = HelperAsyncIterable<U>>(this: U, initValue: I): AsyncExtraIterable<HelperAsyncIterable<U> | I> {\n  return filterMap(this, o => o, initValue);\n}\n\nfunction waitFor<U extends PartialIterable>(this: U, cb: (done: (value: void | PromiseLike<void>) => void) => void): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, o => new Promise<HelperAsyncIterable<U>>(resolve => { cb(() => resolve(o)); return o }));\n}\n\nfunction multi<U extends PartialIterable>(this: U): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  type T = HelperAsyncIterable<U>;\n  const source = this;\n  let consumers = 0;\n  let current: DeferredPromise<IteratorResult<T, any>>;\n  let ai: AsyncIterator<T, any, undefined> | undefined = undefined;\n\n  // The source has produced a new result\n  function step(it?: IteratorResult<T, any>) {\n    if (it) current.resolve(it);\n    if (!it?.done) {\n      current = deferred<IteratorResult<T>>();\n      ai!.next()\n        .then(step)\n        .catch(error => current.reject({ done: true, value: error }));\n    }\n  }\n\n  const mai: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      consumers += 1;\n      return mai;\n    },\n\n    next() {\n      if (!ai) {\n        ai = source[Symbol.asyncIterator]!();\n        step();\n      }\n      return current//.then(zalgo => zalgo);\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source if we're the final one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: ex });\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source if we're the only one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: v });\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(mai);\n}\n\nexport function augmentGlobalAsyncGenerators() {\n  let g = (async function* () { })();\n  while (g) {\n    const desc = Object.getOwnPropertyDescriptor(g, Symbol.asyncIterator);\n    if (desc) {\n      iterableHelpers(g);\n      break;\n    }\n    g = Object.getPrototypeOf(g);\n  }\n  if (!g) {\n    console.warn(\"Failed to augment the prototype of `(async function*())()`\");\n  }\n}\n\n", "import { DEBUG, console, timeOutWarn } from './debug.js';\nimport { isPromiseLike } from './deferred.js';\nimport { iterableHelpers, merge, AsyncExtraIterable, queueIteratableIterator } from \"./iterators.js\";\n\n/*\n  `when(....)` is both an AsyncIterable of the events it can generate by observation,\n  and a function that can map those events to a specified type, eg:\n\n  this.when('keyup:#elemet') => AsyncIterable<KeyboardEvent>\n  this.when('#elemet')(e => e.target) => AsyncIterable<EventTarget>\n*/\n// Varargs type passed to \"when\"\nexport type WhenParameters<IDS extends string = string> = ReadonlyArray<\n  AsyncIterable<any>\n  | ValidWhenSelector<IDS>\n  | Element /* Implies \"change\" event */\n  | Promise<any> /* Just gets wrapped in a single `yield` */\n>;\n\n// The Iterated type generated by \"when\", based on the parameters\ntype WhenIteratedType<S extends WhenParameters> =\n  (Extract<S[number], AsyncIterable<any>> extends AsyncIterable<infer I> ? unknown extends I ? never : I : never)\n  | ExtractEvents<Extract<S[number], string>>\n  | (Extract<S[number], Element> extends never ? never : Event)\n\ntype MappableIterable<A extends AsyncIterable<any>> =\n  A extends AsyncIterable<infer T> ?\n    A & AsyncExtraIterable<T> &\n    (<R>(mapper: (value: A extends AsyncIterable<infer T> ? T : never) => R) => (AsyncExtraIterable<Awaited<R>>))\n  : never;\n\n// The extended iterator that supports async iterator mapping, chaining, etc\nexport type WhenReturn<S extends WhenParameters> =\n  MappableIterable<\n    AsyncExtraIterable<\n      WhenIteratedType<S>>>;\n\ntype EmptyObject = Record<string | symbol | number, never>;\n\ntype SpecialWhenEvents = {\n  \"@start\": EmptyObject,  // Always fires when referenced\n  \"@ready\": EmptyObject   // Fires when all Element specified sources are mounted in the DOM\n};\ntype WhenEvents = GlobalEventHandlersEventMap & SpecialWhenEvents;\ntype EventNameList<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : `${S},${EventNameList<R>}`\n  : never;\n\ntype EventNameUnion<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : S | EventNameList<R>\n  : never;\n\n\ntype EventAttribute = `${keyof GlobalEventHandlersEventMap}`\ntype CSSIdentifier<IDS extends string = string> = `#${IDS}` |`.${string}` | `[${string}]`\n\n/* ValidWhenSelectors are:\n    @start\n    @ready\n    event:selector\n    event           \"this\" element, event type='event'\n    selector        specificed selectors, implies \"change\" event\n*/\n\nexport type ValidWhenSelector<IDS extends string = string> = `${keyof SpecialWhenEvents}`\n  | `${EventAttribute}:${CSSIdentifier<IDS>}`\n  | EventAttribute\n  | CSSIdentifier<IDS>;\n\ntype IsValidWhenSelector<S>\n  = S extends ValidWhenSelector ? S : never;\n\ntype ExtractEventNames<S>\n  = S extends keyof SpecialWhenEvents ? S\n  : S extends `${infer V}:${infer L extends CSSIdentifier}`\n  ? EventNameUnion<V> extends never ? never : EventNameUnion<V>\n  : S extends `${infer L extends CSSIdentifier}`\n  ? 'change'\n  : never;\n\ntype ExtractEvents<S> = WhenEvents[ExtractEventNames<S>];\n\n/** when **/\ntype EventObservation<EventName extends keyof GlobalEventHandlersEventMap> = {\n  push: (ev: GlobalEventHandlersEventMap[EventName])=>void;\n  terminate: (ex: Error)=>void;\n  container: Element\n  selector: string | null\n};\nconst eventObservations = new WeakMap<Document, Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  if (!eventObservations.has(this))\n    eventObservations.set(this, new Map());\n\n  const observations = eventObservations.get(this)!.get(ev.type as keyof GlobalEventHandlersEventMap);\n  if (observations) {\n    for (const o of observations) {\n      try {\n        const { push, terminate, container, selector } = o;\n        if (!container.isConnected) {\n          const msg = \"Container `#\" + container.id + \">\" + (selector || '') + \"` removed from DOM. Removing subscription\";\n          observations.delete(o);\n          terminate(new Error(msg));\n        } else {\n          if (ev.target instanceof Node) {\n            if (selector) {\n              const nodes = container.querySelectorAll(selector);\n              for (const n of nodes) {\n                if ((ev.target === n || n.contains(ev.target)) && container.contains(n))\n                  push(ev)\n              }\n            } else {\n              if ((ev.target === container || container.contains(ev.target)))\n                push(ev)\n            }\n          }\n        }\n      } catch (ex) {\n        console.warn('docEventHandler', ex);\n      }\n    }\n  }\n}\n\nfunction isCSSSelector(s: string): s is CSSIdentifier {\n  return Boolean(s && (s.startsWith('#') || s.startsWith('.') || (s.startsWith('[') && s.endsWith(']'))));\n}\n\nfunction parseWhenSelector<EventName extends string>(what: IsValidWhenSelector<EventName>): undefined | [CSSIdentifier | null, keyof GlobalEventHandlersEventMap] {\n  const parts = what.split(':');\n  if (parts.length === 1) {\n    if (isCSSSelector(parts[0]))\n      return [parts[0],\"change\"];\n    return [null, parts[0] as keyof GlobalEventHandlersEventMap];\n  }\n  if (parts.length === 2) {\n    if (isCSSSelector(parts[1]) && !isCSSSelector(parts[0]))\n    return [parts[1], parts[0] as keyof GlobalEventHandlersEventMap]\n  }\n  return undefined;\n}\n\nfunction doThrow(message: string):never {\n  throw new Error(message);\n}\n\nfunction whenEvent<EventName extends string>(container: Element, what: IsValidWhenSelector<EventName>) {\n  const [selector, eventName] = parseWhenSelector(what) ?? doThrow(\"Invalid WhenSelector: \"+what);\n\n  if (!eventObservations.has(container.ownerDocument))\n    eventObservations.set(container.ownerDocument, new Map());\n\n  if (!eventObservations.get(container.ownerDocument)!.has(eventName)) {\n    container.ownerDocument.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.get(container.ownerDocument)!.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.get(container.ownerDocument)?.get(eventName)?.delete(details));\n\n  const details: EventObservation<keyof GlobalEventHandlersEventMap> /*EventObservation<Exclude<ExtractEventNames<EventName>, keyof SpecialWhenEvents>>*/ = {\n    push: queue.push,\n    terminate(ex: Error) { queue.return?.(ex)},\n    container,\n    selector: selector || null\n  };\n\n  containerAndSelectorsMounted(container, selector ? [selector] : undefined)\n    .then(_ => eventObservations.get(container.ownerDocument)?.get(eventName)!.add(details));\n\n  return queue.multi() ;\n}\n\nasync function* neverGonnaHappen<Z>(): AsyncIterableIterator<Z> {\n  await new Promise(() => {});\n  yield undefined as Z; // Never should be executed\n}\n\n/* Syntactic sugar: chainAsync decorates the specified iterator so it can be mapped by\n  a following function, or used directly as an iterable */\nfunction chainAsync<A extends AsyncExtraIterable<X>, X>(src: A): MappableIterable<A> {\n  function mappableAsyncIterable(mapper: Parameters<typeof src.map>[0]) {\n    return src.map(mapper);\n  }\n\n  return Object.assign(iterableHelpers(mappableAsyncIterable as unknown as AsyncIterable<A>), {\n    [Symbol.asyncIterator]: () => src[Symbol.asyncIterator]()\n  }) as MappableIterable<A>;\n}\n\nfunction isValidWhenSelector(what: WhenParameters[number]): what is ValidWhenSelector {\n  if (!what)\n    throw new Error('Falsy async source will never be ready\\n\\n' + JSON.stringify(what));\n  return typeof what === 'string' && what[0] !== '@' && Boolean(parseWhenSelector(what));\n}\n\nasync function* once<T>(p: Promise<T>) {\n  yield p;\n}\n\nexport function when<S extends WhenParameters>(container: Element, ...sources: S): WhenReturn<S> {\n  if (!sources || sources.length === 0) {\n    return chainAsync(whenEvent(container, \"change\")) as unknown as WhenReturn<S>;\n  }\n\n  const iterators = sources.filter(what => typeof what !== 'string' || what[0] !== '@').map(what => typeof what === 'string'\n    ? whenEvent(container, what)\n    : what instanceof Element\n      ? whenEvent(what, \"change\")\n      : isPromiseLike(what)\n        ? once(what)\n        : what);\n\n  if (sources.includes('@start')) {\n    const start: AsyncIterableIterator<{}> = {\n      [Symbol.asyncIterator]: () => start,\n      next() {\n        start.next = () => Promise.resolve({ done: true, value: undefined })\n        return Promise.resolve({ done: false, value: {} })\n      }\n    };\n    iterators.push(start);\n  }\n\n  if (sources.includes('@ready')) {\n    const watchSelectors = sources.filter(isValidWhenSelector).map(what => parseWhenSelector(what)?.[0]);\n\n    function isMissing(sel: CSSIdentifier | null | undefined): sel is CSSIdentifier {\n      return Boolean(typeof sel === 'string' && !container.querySelector(sel));\n    }\n\n    const missing = watchSelectors.filter(isMissing);\n\n    let events: AsyncIterator<any, any, undefined> | undefined = undefined;\n    const ai: AsyncIterableIterator<any> = {\n      [Symbol.asyncIterator]() { return ai },\n      throw(ex: any) {\n        if (events?.throw) return events.throw(ex);\n        return Promise.resolve({ done: true, value: ex });\n      },\n      return(v?: any) {\n        if (events?.return) return events.return(v);\n        return Promise.resolve({ done: true, value: v });\n      },\n      next() {\n        if (events) return events.next();\n\n        return containerAndSelectorsMounted(container, missing).then(() => {\n          const merged = (iterators.length > 1)\n          ? merge(...iterators)\n          : iterators.length === 1\n            ? iterators[0]\n            : (neverGonnaHappen<WhenIteratedType<S>>());\n\n          // Now everything is ready, we simply delegate all async ops to the underlying\n          // merged asyncIterator \"events\"\n          events = merged[Symbol.asyncIterator]();\n          if (!events)\n            return { done: true, value: undefined };\n\n          return { done: false, value: {} };\n        });\n      }\n    };\n    return chainAsync(iterableHelpers(ai));\n  }\n\n  const merged = (iterators.length > 1)\n    ? merge(...iterators)\n    : iterators.length === 1\n      ? iterators[0]\n      : (neverGonnaHappen<WhenIteratedType<S>>());\n\n  return chainAsync(iterableHelpers(merged));\n}\n\nfunction elementIsInDOM(elt: Element): Promise<void> {\n  if (elt.isConnected)\n    return Promise.resolve();\n\n  return new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (elt.isConnected) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(elt.ownerDocument.body, {\n    subtree: true,\n    childList: true\n  }));\n}\n\nfunction containerAndSelectorsMounted(container: Element, selectors?: string[]) {\n  if (selectors?.length)\n    return Promise.all([\n      allSelectorsPresent(container, selectors),\n      elementIsInDOM(container)\n    ]);\n  return elementIsInDOM(container);\n}\n\nfunction allSelectorsPresent(container: Element, missing: string[]): Promise<void> {\n  missing = missing.filter(sel => !container.querySelector(sel))\n  if (!missing.length) {\n    return Promise.resolve(); // Nothing is missing\n  }\n\n  const promise = new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (missing.every(sel => container.querySelector(sel))) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(container, {\n    subtree: true,\n    childList: true\n  }));\n\n  /* debugging help: warn if waiting a long time for a selectors to be ready */\n  if (DEBUG) {\n    const stack = new Error().stack?.replace(/^Error/, \"Missing selectors after 5 seconds:\");\n    const warnTimer = setTimeout(() => {\n      console.warn(stack, missing);\n    }, timeOutWarn);\n\n    promise.finally(() => clearTimeout(warnTimer))\n  }\n\n  return promise;\n}\n"],
  "mappings": "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",
  "names": ["v", "a", "result", "ex", "ir", "isMissing", "merged", "unique", "c", "n", "value", "isAncestral", "children"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/ai-ui.ts", "../src/debug.ts", "../src/deferred.ts", "../src/iterators.ts", "../src/when.ts"],
  "sourcesContent": ["import { isPromiseLike } from './deferred.js';\nimport { Ignore, asyncIterator, defineIterableProperty, isAsyncIter, isAsyncIterator } from './iterators.js';\nimport { WhenParameters, WhenReturn, when } from './when.js';\nimport { DEBUG, console, timeOutWarn } from './debug.js';\nimport type { ChildTags, Constructed, Instance, Overrides, TagCreationOptions, TagCreator, TagCreatorFunction } from './tags.js';\n\n/* Export useful stuff for users of the bundled code */\nexport { when } from './when.js';\nexport type { ChildTags, Instance, TagCreator, TagCreatorFunction } from './tags.js'\nexport * as Iterators from './iterators.js';\n\nexport const UniqueID = Symbol(\"Unique ID\");\n\nconst logNode = DEBUG ? ((n: Node) => `\"${'innerHTML' in n ? n.innerHTML : n.textContent}\"`) : (n: Node) => undefined;\n\n/* A holder for commonProperties specified when `tag(...p)` is invoked, which are always\n  applied (mixed in) when an element is created */\ntype TagFunctionOptions<OtherMembers extends Record<string | symbol, any> = {}> = {\n  commonProperties?: OtherMembers\n  document?: Document\n  /** @deprecated - legacy support */\n  enableOnRemovedFromDOM?: boolean\n}\n\n/* Members applied to EVERY tag created, even base tags */\ninterface PoElementMethods {\n  get ids(): {}\n  when<T extends Element & PoElementMethods, S extends WhenParameters<Exclude<keyof T['ids'], number | symbol>>>(this: T, ...what: S): WhenReturn<S>;\n  // This is a very incomplete type. In practice, set(attrs) requires a deeply partial set of\n  // attributes, in exactly the same way as a TagFunction's first object parameter\n  set attributes(attrs: object);\n  get attributes(): NamedNodeMap\n}\n\n// Support for https://www.npmjs.com/package/htm (or import htm from 'https://cdn.jsdelivr.net/npm/htm/dist/htm.module.js')\n// Note: same signature as React.createElement\nexport interface CreateElement {\n  // Support for htm, JSX, etc\n  createElement(\n    // \"name\" can a HTML tag string, an existing node (just returns itself), or a tag function\n    name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n    // The attributes used to initialise the node (if a string or function - ignore if it's already a node)\n    attrs: any,\n    // The children\n    ...children: ChildTags[]): Node;\n}\n\n/* The interface that creates a set of TagCreators for the specified DOM tags */\nexport interface TagLoader {\n  nodes(...c: ChildTags[]): (Node | (/*P &*/ (Element & PoElementMethods)))[];\n  UniqueID: typeof UniqueID\n\n  /*\n   Signatures for the tag loader. All params are optional in any combination,\n   but must be in order:\n      tag(\n          ?nameSpace?: string,  // absent nameSpace implies HTML\n          ?tags?: string[],     // absent tags defaults to all common HTML tags\n          ?commonProperties?: CommonPropertiesConstraint // absent implies none are defined\n      )\n\n      eg:\n        tags()  // returns TagCreators for all HTML tags\n        tags(['div','button'], { myThing() {} })\n        tags('http://namespace',['Foreign'], { isForeign: true })\n  */\n\n  <Tags extends keyof HTMLElementTagNameMap>(): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap>(tags: Tags[]): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(tags: Tags[], options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: null | undefined | '', tags: Tags[], options?: TagFunctionOptions<Q>): { [k in Tags]: TagCreator<Q & PoElementMethods & HTMLElement> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: string, tags: Tags[], options?: TagFunctionOptions<Q>): Record<string, TagCreator<Q & PoElementMethods & Element>> & CreateElement\n}\n\nlet idCount = 0;\nconst standandTags = [\n  \"a\", \"abbr\", \"address\", \"area\", \"article\", \"aside\", \"audio\", \"b\", \"base\", \"bdi\", \"bdo\", \"blockquote\", \"body\", \"br\", \"button\",\n  \"canvas\", \"caption\", \"cite\", \"code\", \"col\", \"colgroup\", \"data\", \"datalist\", \"dd\", \"del\", \"details\", \"dfn\", \"dialog\", \"div\",\n  \"dl\", \"dt\", \"em\", \"embed\", \"fieldset\", \"figcaption\", \"figure\", \"footer\", \"form\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\",\n  \"header\", \"hgroup\", \"hr\", \"html\", \"i\", \"iframe\", \"img\", \"input\", \"ins\", \"kbd\", \"label\", \"legend\", \"li\", \"link\", \"main\", \"map\",\n  \"mark\", \"menu\", \"meta\", \"meter\", \"nav\", \"noscript\", \"object\", \"ol\", \"optgroup\", \"option\", \"output\", \"p\", \"picture\", \"pre\",\n  \"progress\", \"q\", \"rp\", \"rt\", \"ruby\", \"s\", \"samp\", \"script\", \"search\", \"section\", \"select\", \"slot\", \"small\", \"source\", \"span\",\n  \"strong\", \"style\", \"sub\", \"summary\", \"sup\", \"table\", \"tbody\", \"td\", \"template\", \"textarea\", \"tfoot\", \"th\", \"thead\", \"time\",\n  \"title\", \"tr\", \"track\", \"u\", \"ul\", \"var\", \"video\", \"wbr\"\n] as const;\n\nfunction idsInaccessible(): never {\n  throw new Error(\"<elt>.ids is a read-only map of Elements\")\n}\n\nfunction isChildTag(x: any): x is ChildTags {\n  return typeof x === 'string'\n    || typeof x === 'number'\n    || typeof x === 'boolean'\n    || x instanceof Node\n    || x instanceof NodeList\n    || x instanceof HTMLCollection\n    || x === null\n    || x === undefined\n    // Can't actually test for the contained type, so we assume it's a ChildTag and let it fail at runtime\n    || Array.isArray(x)\n    || isPromiseLike(x)\n    || isAsyncIter(x)\n    || (typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function');\n}\n\n/* tag */\nconst callStackSymbol = Symbol('callStack');\n\nexport const tag = <TagLoader>function <Tags extends string,\n  T1 extends (string | Tags[] | TagFunctionOptions<Q>),\n  T2 extends (Tags[] | TagFunctionOptions<Q>),\n  Q extends {}\n>(\n  _1: T1,\n  _2: T2,\n  _3?: TagFunctionOptions<Q>\n): Record<string, TagCreator<Q & Element>> {\n  type NamespacedElementBase = T1 extends string ? T1 extends '' ? HTMLElement : Element : HTMLElement;\n\n  /* Work out which parameter is which. There are 6 variations:\n    tag()                                           []\n    tag(commonProperties)                           [object]\n    tag(tags[])                                     [string[]]\n    tag(tags[], commonProperties)                   [string[], object]\n    tag(namespace | null, tags[])                   [string | null, string[]]\n    tag(namespace | null, tags[], commonProperties) [string | null, string[], object]\n  */\n  const [nameSpace, tags, options] = (typeof _1 === 'string') || _1 === null\n    ? [_1, _2 as Tags[], _3 as TagFunctionOptions<Q>]\n    : Array.isArray(_1)\n      ? [null, _1 as Tags[], _2 as TagFunctionOptions<Q>]\n      : [null, standandTags, _1 as TagFunctionOptions<Q>];\n\n  const commonProperties = options?.commonProperties;\n  const thisDoc = options?.document ?? globalThis.document;\n\n  const removedNodes = mutationTracker(thisDoc, 'removedNodes', options?.enableOnRemovedFromDOM);\n\n  function DomPromiseContainer() {\n    return thisDoc.createComment(DEBUG\n      ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\"\n      : \"promise\")\n  }\n\n  function DyamicElementError({ error }: { error: Error | IteratorResult<Error> }) {\n    return thisDoc.createComment(error instanceof Error ? error.toString() : 'Error:\\n' + JSON.stringify(error, null, 2));\n  }\n  const poStyleElt = thisDoc.createElement(\"STYLE\");\n  poStyleElt.id = \"--ai-ui-extended-tag-styles-\";\n\n  /* Properties applied to every tag which can be implemented by reference, similar to prototypes */\n  const warned = new Set<string>();\n  const tagPrototypes: PoElementMethods = Object.create(\n    null,\n    {\n      when: {\n        writable: false,\n        configurable: true,\n        enumerable: false,\n        value: function (...what: WhenParameters) {\n          return when(this, ...what)\n        }\n      },\n      attributes: {\n        ...Object.getOwnPropertyDescriptor(Element.prototype, 'attributes'),\n        set(this: Element, a: object) {\n          if (isAsyncIter(a)) {\n            const ai = isAsyncIterator(a) ? a : a[Symbol.asyncIterator]();\n            const step = () => ai.next().then(\n              ({ done, value }) => { assignProps(this, value); done || step() },\n              ex => console.warn(ex));\n            step();\n          }\n          else assignProps(this, a);\n        }\n      },\n      ids: {\n        // .ids is a getter that when invoked for the first time\n        // lazily creates a Proxy that provides live access to children by id\n        configurable: true,\n        enumerable: true,\n        set: idsInaccessible,\n        get(this: Element) {\n          // Now we've been accessed, create the proxy\n          const idProxy = new Proxy(Object.create(null) as Record<string, WeakRef<Element>>, {\n            apply: idsInaccessible,\n            construct: idsInaccessible,\n            defineProperty: idsInaccessible,\n            deleteProperty: idsInaccessible,\n            set: idsInaccessible,\n            setPrototypeOf: idsInaccessible,\n            getPrototypeOf() { return null },\n            isExtensible() { return false },\n            preventExtensions() { return true },\n            getOwnPropertyDescriptor(target, p) {\n              if (this.get!(target, p, null))\n                return Reflect.getOwnPropertyDescriptor(target, p);\n            },\n            has(target, p) {\n              const r = this.get!(target, p, null);\n              return Boolean(r);\n            },\n            ownKeys: (target) => {\n              const ids = [...this.querySelectorAll(`[id]`)].map(e => e.id);\n              const unique = [...new Set(ids)];\n              if (DEBUG && ids.length !== unique.length)\n                console.log(`Element contains multiple, shadowed decendant ids`, unique);\n              return unique;\n            },\n            get: (target, p, receiver) => {\n              if (typeof p === 'string') {\n                // Check if we've cached this ID already\n                if (p in target) {\n                  // Check the element is still contained within this element with the same ID\n                  const ref = target[p].deref();\n                  if (ref && ref.id === p && this.contains(ref))\n                    return ref;\n                  delete target[p];\n                }\n                let e: Element | undefined;\n                if (DEBUG) {\n                  const nl = this.querySelectorAll('#' + CSS.escape(p));\n                  if (nl.length > 1) {\n                    if (!warned.has(p)) {\n                      warned.add(p);\n                      console.log(`Element contains multiple, shadowed decendants with ID \"${p}\"`/*,`\\n\\t${logNode(this)}`*/);\n                    }\n                  }\n                  e = nl[0];\n                } else {\n                  e = this.querySelector('#' + CSS.escape(p)) ?? undefined;\n                }\n                if (e) target[p] = new WeakRef(e);\n                return e;\n              }\n            }\n          });\n          // ..and replace the getter with the Proxy\n          Object.defineProperty(this, 'ids', {\n            configurable: true,\n            enumerable: true,\n            set: idsInaccessible,\n            get() { return idProxy }\n          });\n          // ...and return that from the getter, so subsequent property\n          // accesses go via the Proxy\n          return idProxy;\n        }\n      }\n    }\n  );\n\n  /* Add any user supplied prototypes */\n  if (commonProperties)\n    deepDefine(tagPrototypes, commonProperties);\n\n  function nodes(...c: ChildTags[]) {\n    const appended: Node[] = [];\n    (function children(c: ChildTags): void {\n      if (c === undefined || c === null || c === Ignore)\n        return;\n      if (isPromiseLike(c)) {\n        const g: ChildNode = DomPromiseContainer();\n        appended.push(g);\n        c.then(r => g.replaceWith(...nodes(r)),\n          (x: any) => {\n            console.warn(x, logNode(g));\n            g.replaceWith(DyamicElementError({ error: x }));\n          }\n        );\n        return;\n      }\n      if (c instanceof Node) {\n        appended.push(c);\n        return;\n      }\n\n      // We have an interesting case here where an iterable String is an object with both Symbol.iterator\n      // (inherited from the String prototype) and Symbol.asyncIterator (as it's been augmented by boxed())\n      // but we're only interested in cases like HTMLCollection, NodeList, array, etc., not the fukny ones\n      // It used to be after the isAsyncIter() test, but a non-AsyncIterator *may* also be a sync iterable\n      // For now, we exclude (Symbol.asyncIterator in c) in this case.\n      if (c && typeof c === 'object' && Symbol.iterator in c && !(Symbol.asyncIterator in c) && c[Symbol.iterator]) {\n        for (const d of c) children(d);\n        return;\n      }\n\n      if (isAsyncIter<ChildTags>(c)) {\n        const insertionStack = DEBUG ? ('\\n' + new Error().stack?.replace(/^Error: /, \"Insertion :\")) : '';\n        const ap = isAsyncIterator(c) ? c : c[Symbol.asyncIterator]();\n        // It's possible that this async iterator is a boxed object that also holds a value\n        const unboxed = c.valueOf();\n        const dpm = (unboxed === undefined || unboxed === c) ? [DomPromiseContainer()] : nodes(unboxed as ChildTags)\n\n        let t = dpm.length ? dpm : [DomPromiseContainer()];\n        appended.push(...t);\n        let notYetMounted = true;\n        // DEBUG support\n        let createdAt = Date.now() + timeOutWarn;\n        const createdBy = DEBUG && new Error(\"Created by\").stack;\n\n        const error = (errorValue: any) => {\n          const n = t.filter(n => Boolean(n?.parentNode)) as ChildNode[];\n          if (n.length) {\n            t = [DyamicElementError({ error: errorValue })];\n            n[0].replaceWith(...t);\n            n.slice(1).forEach(e => e?.parentNode!.removeChild(e));\n          }\n          else console.warn(\"Can't report error\", errorValue, createdBy, t.map(logNode));\n          t = [];\n          ap.return?.(errorValue);\n        }\n\n        const update = (es: IteratorResult<ChildTags>) => {\n          if (!es.done) {\n            try {\n              // ChildNode[], since we tested .parentNode\n              const mounted = t.filter(e => e?.parentNode && e.isConnected);\n              const n = notYetMounted ? t : mounted;\n              if (mounted.length) notYetMounted = false;\n\n              if (!n.length || t.every(e => removedNodes(e))) {\n                // We're done - terminate the source quietly (ie this is not an exception as it's expected, but we're done)\n                t = [];\n                const msg = \"Element(s) have been removed from the document: \" + insertionStack;\n                ap.return?.(new Error(msg));\n                return;\n              }\n\n              if (DEBUG && notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Async element not mounted after 5 seconds. If it is never mounted, it will leak.`, createdBy, t.map(logNode));\n              }\n              t = nodes(unbox(es.value) as ChildTags);\n              // If the iterated expression yields no nodes, stuff in a DomPromiseContainer for the next iteration\n              if (!t.length) t.push(DomPromiseContainer());\n              (n[0] as ChildNode).replaceWith(...t);\n              n.slice(1).forEach(e => !t.includes(e) && e.parentNode?.removeChild(e));\n              ap.next().then(update).catch(error);\n            } catch (ex) {\n              // Something went wrong. Terminate the iterator source\n              t = [];\n              ap.return?.(ex);\n            }\n          }\n        }\n        ap.next().then(update).catch(error);\n        return;\n      }\n      appended.push(thisDoc.createTextNode(c.toString()));\n    })(c);\n    return appended;\n  }\n\n  if (!nameSpace) {\n    Object.assign(tag, {\n      nodes,    // Build DOM Node[] from ChildTags\n      UniqueID\n    });\n  }\n\n  /** Just deep copy an object */\n  const plainObjectPrototype = Object.getPrototypeOf({});\n  /** Routine to *define* properties on a dest object from a src object **/\n  function deepDefine(d: Record<string | symbol | number, any>, s: any, declaration?: true): void {\n    if (s === null || s === undefined || typeof s !== 'object' || s === d)\n      return;\n\n    for (const [k, srcDesc] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      try {\n        if ('value' in srcDesc) {\n          const value = srcDesc.value;\n\n          if (value && isAsyncIter<unknown>(value)) {\n            Object.defineProperty(d, k, srcDesc);\n          } else {\n            // This has a real value, which might be an object, so we'll deepDefine it unless it's a\n            // Promise or a function, in which case we just assign it\n            if (value && typeof value === 'object' && !isPromiseLike(value)) {\n              if (!(k in d)) {\n                // If this is a new value in the destination, just define it to be the same value as the source\n                // If the source value is an object, and we're declaring it (therefore it should be a new one), take\n                // a copy so as to not re-use the reference and pollute the declaration. Note: this is probably\n                // a better default for any \"objects\" in a declaration that are plain and not some class type\n                // which can't be copied\n                if (declaration) {\n                  if (Object.getPrototypeOf(value) === plainObjectPrototype || !Object.getPrototypeOf(value)) {\n                    // A plain object can be deep-copied by field\n                    deepDefine(srcDesc.value = {}, value);\n                  } else if (Array.isArray(value)) {\n                    // An array can be deep copied by index\n                    deepDefine(srcDesc.value = [], value);\n                  } else {\n                    // Other object like things (regexps, dates, classes, etc) can't be deep-copied reliably\n                    console.warn(`Declared propety '${k}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`, d, value);\n                  }\n                }\n                Object.defineProperty(d, k, srcDesc);\n              } else {\n                if (value instanceof Node) {\n                  console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child\", k, logNode(value));\n                  d[k] = value;\n                } else {\n                  if (d[k] !== value) {\n                    // Note - if we're copying to an array of different length\n                    // we're decoupling common object references, so we need a clean object to\n                    // assign into\n                    if (Array.isArray(d[k]) && d[k].length !== value.length) {\n                      if (value.constructor === Object || value.constructor === Array) {\n                        deepDefine(d[k] = new (value.constructor), value);\n                      } else {\n                        // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                        d[k] = value;\n                      }\n                    } else {\n                      // This is just a regular object, so we deepDefine recursively\n                      deepDefine(d[k], value);\n                    }\n                  }\n                }\n              }\n            } else {\n              // This is just a primitive value, or a Promise\n              if (s[k] !== undefined)\n                d[k] = s[k];\n            }\n          }\n        } else {\n          // Copy the definition of the getter/setter\n          Object.defineProperty(d, k, srcDesc);\n        }\n      } catch (ex: unknown) {\n        console.warn(\"deepAssign\", k, s[k], ex);\n        throw ex;\n      }\n    }\n  }\n\n  function unbox(a: unknown): unknown {\n    const v = a?.valueOf();\n    return Array.isArray(v) ? Array.prototype.map.call(v, unbox) : v;\n  }\n\n  function assignProps(base: Node, props: Record<string, any>) {\n    // Copy prop hierarchy onto the element via the asssignment operator in order to run setters\n    if (!(callStackSymbol in props)) {\n      (function assign(d: any, s: any): void {\n        if (s === null || s === undefined || typeof s !== 'object')\n          return;\n        // static props before getters/setters\n        const sourceEntries = Object.entries(Object.getOwnPropertyDescriptors(s));\n        if (!Array.isArray(s)) {\n          sourceEntries.sort(a => {\n            const desc = Object.getOwnPropertyDescriptor(d, a[0]);\n            if (desc) {\n              if ('value' in desc) return -1;\n              if ('set' in desc) return 1;\n              if ('get' in desc) return 1;\n            }\n            return 0;\n          });\n        }\n        for (const [k, srcDesc] of sourceEntries) {\n          try {\n            if ('value' in srcDesc) {\n              const value = srcDesc.value;\n              if (isAsyncIter<unknown>(value)) {\n                assignIterable(value, k);\n              } else if (isPromiseLike(value)) {\n                value.then(v => {\n                  if (v && typeof v === 'object') {\n                    // Special case: this promise resolved to an async iterator\n                    if (isAsyncIter<unknown>(v)) {\n                      assignIterable(v, k);\n                    } else {\n                      assignObject(v, k);\n                    }\n                  } else {\n                    if (s[k] !== undefined)\n                      d[k] = v;\n                  }\n                }, error => console.log(\"Failed to set attribute\", error));\n              } else if (!isAsyncIter<unknown>(value)) {\n                // This has a real value, which might be an object\n                if (value && typeof value === 'object' && !isPromiseLike(value))\n                  assignObject(value, k);\n                else {\n                  if (s[k] !== undefined)\n                    d[k] = s[k];\n                }\n              }\n            } else {\n              // Copy the definition of the getter/setter\n              Object.defineProperty(d, k, srcDesc);\n            }\n          } catch (ex: unknown) {\n            console.warn(\"assignProps\", k, s[k], ex);\n            throw ex;\n          }\n        }\n\n        function assignIterable(value: AsyncIterable<unknown> | AsyncIterator<unknown, any, undefined>, k: string) {\n          const ap = asyncIterator(value);\n          let notYetMounted = true;\n          // DEBUG support\n          let createdAt = Date.now() + timeOutWarn;\n          const createdBy = DEBUG && new Error(\"Created by\").stack;\n          const update = (es: IteratorResult<unknown>) => {\n            if (!es.done) {\n              const value = unbox(es.value);\n              if (typeof value === 'object' && value !== null) {\n                /*\n              THIS IS JUST A HACK: `style` has to be set member by member, eg:\n                e.style.color = 'blue'        --- works\n                e.style = { color: 'blue' }   --- doesn't work\n              whereas in general when assigning to property we let the receiver\n              do any work necessary to parse the object. This might be better handled\n              by having a setter for `style` in the PoElementMethods that is sensitive\n              to the type (string|object) being passed so we can just do a straight\n              assignment all the time, or making the decsion based on the location of the\n              property in the prototype chain and assuming anything below \"PO\" must be\n              a primitive\n              */\n                const destDesc = Object.getOwnPropertyDescriptor(d, k);\n                if (k === 'style' || !destDesc?.set)\n                  assign(d[k], value);\n                else\n                  d[k] = value;\n              } else {\n                // Src is not an object (or is null) - just assign it, unless it's undefined\n                if (value !== undefined)\n                  d[k] = value;\n              }\n              const mounted = base.isConnected;\n              // If we have been mounted before, bit aren't now, remove the consumer\n              if (removedNodes(base) || (!notYetMounted && !mounted)) {\n                console.info(`Element does not exist in document when setting async attribute '${k}' to:\\n${logNode(base)}`);\n                ap.return?.();\n                return;\n              }\n              if (mounted) notYetMounted = false;\n              if (notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Element with async attribute '${k}' not mounted after 5 seconds. If it is never mounted, it will leak.\\nElement contains: ${logNode(base)}\\n${createdBy}`);\n              }\n\n              ap.next().then(update).catch(error);\n            }\n          }\n          const error = (errorValue: any) => {\n            console.warn(\"Dynamic attribute error\", errorValue, k, d, createdBy, logNode(base));\n            ap.return?.(errorValue);\n            base.appendChild(DyamicElementError({ error: errorValue }));\n          }\n          const unboxed = value.valueOf();\n          if (unboxed !== undefined && unboxed !== value && !isAsyncIter(unboxed))\n            update({ done: false, value: unboxed });\n          else\n            ap.next().then(update).catch(error);\n        }\n\n        function assignObject(value: any, k: string) {\n          if (value instanceof Node) {\n            console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes\", k, logNode(value));\n            d[k] = value;\n          } else {\n            // Note - if we're copying to ourself (or an array of different length),\n            // we're decoupling common object references, so we need a clean object to\n            // assign into\n            if (!(k in d) || d[k] === value || (Array.isArray(d[k]) && d[k].length !== value.length)) {\n              if (value.constructor === Object || value.constructor === Array) {\n                const copy = new (value.constructor);\n                assign(copy, value);\n                d[k] = copy;\n                //assign(d[k], value);\n              } else {\n                // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                d[k] = value;\n              }\n            } else {\n              if (Object.getOwnPropertyDescriptor(d, k)?.set)\n                d[k] = value;\n\n              else\n                assign(d[k], value);\n            }\n          }\n        }\n      })(base, props);\n    }\n  }\n\n  /*\n  Extend a component class with create a new component class factory:\n      const NewDiv = Div.extended({ overrides })\n          ...or...\n      const NewDic = Div.extended((instance:{ arbitrary-type }) => ({ overrides }))\n         ...later...\n      const eltNewDiv = NewDiv({attrs},...children)\n  */\n\n  type ExtendTagFunction = (attrs: TagCreationOptions & {\n    [callStackSymbol]?: Overrides[];\n    [k: string]: unknown;\n  } | ChildTags, ...children: ChildTags[]) => Element\n\n  interface ExtendTagFunctionInstance extends ExtendTagFunction {\n    super: TagCreator<Element>;\n    definition: Overrides;\n    valueOf: () => string;\n    extended: (this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) => ExtendTagFunctionInstance;\n  }\n\n  function tagHasInstance(this: ExtendTagFunctionInstance, e: any) {\n    for (let c = e.constructor; c; c = c.super) {\n      if (c === this)\n        return true;\n    }\n    return false;\n  }\n\n  function extended(this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) {\n    const instanceDefinition = (typeof _overrides !== 'function')\n      ? (instance: Instance) => Object.assign({}, _overrides, instance)\n      : _overrides\n\n    const uniqueTagID = Date.now().toString(36) + (idCount++).toString(36) + Math.random().toString(36).slice(2);\n    let staticExtensions: Overrides = instanceDefinition({ [UniqueID]: uniqueTagID });\n    /* \"Statically\" create any styles required by this widget */\n    if (staticExtensions.styles) {\n      poStyleElt.appendChild(thisDoc.createTextNode(staticExtensions.styles + '\\n'));\n      if (!thisDoc.head.contains(poStyleElt)) {\n        thisDoc.head.appendChild(poStyleElt);\n      }\n    }\n\n    // \"this\" is the tag we're being extended from, as it's always called as: `(this).extended`\n    // Here's where we actually create the tag, by accumulating all the base attributes and\n    // (finally) assigning those specified by the instantiation\n    const extendTagFn: ExtendTagFunction = (attrs, ...children) => {\n      const noAttrs = isChildTag(attrs);\n      const newCallStack: (Constructed & Overrides)[] = [];\n      const combinedAttrs = { [callStackSymbol]: (noAttrs ? newCallStack : attrs[callStackSymbol]) ?? newCallStack }\n      const e = noAttrs ? this(combinedAttrs, attrs, ...children) : this(combinedAttrs, ...children);\n      e.constructor = extendTag;\n      const tagDefinition = instanceDefinition({ [UniqueID]: uniqueTagID });\n      combinedAttrs[callStackSymbol].push(tagDefinition);\n      if (DEBUG) {\n        // Validate declare and override\n        function isAncestral(creator: TagCreator<Element>, d: string) {\n          for (let f = creator; f; f = f.super)\n            if (f.definition?.declare && d in f.definition.declare) return true;\n          return false;\n        }\n        if (tagDefinition.declare) {\n          const clash = Object.keys(tagDefinition.declare).filter(d => (d in e) || isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Declared keys '${clash}' in ${extendTag.name} already exist in base '${this.valueOf()}'`);\n          }\n        }\n        if (tagDefinition.override) {\n          const clash = Object.keys(tagDefinition.override).filter(d => !(d in e) && !(commonProperties && d in commonProperties) && !isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Overridden keys '${clash}' in ${extendTag.name} do not exist in base '${this.valueOf()}'`);\n          }\n        }\n      }\n      deepDefine(e, tagDefinition.declare, true);\n      deepDefine(e, tagDefinition.override);\n      const reAssign = new Set<string>();\n      tagDefinition.iterable && Object.keys(tagDefinition.iterable).forEach(k => {\n        if (k in e) {\n          console.log(`Ignoring attempt to re-define iterable property \"${k}\" as it could already have consumers`);\n          reAssign.add(k);\n        } else {\n          defineIterableProperty(e, k, tagDefinition.iterable![k as keyof typeof tagDefinition.iterable])\n        }\n      });\n      if (combinedAttrs[callStackSymbol] === newCallStack) {\n        if (!noAttrs)\n          assignProps(e, attrs);\n        for (const base of newCallStack) {\n          const children = base?.constructed?.call(e);\n          if (isChildTag(children)) // technically not necessary, since \"void\" is going to be undefined in 99.9% of cases.\n            e.append(...nodes(children));\n        }\n        // Once the full tree of augmented DOM elements has been constructed, fire all the iterable propeerties\n        // so the full hierarchy gets to consume the initial state, unless they have been assigned\n        // by assignProps from a future\n        const combinedInitialIterableValues = {};\n        let hasInitialValues = false;\n        for (const base of newCallStack) {\n          if (base.iterable) for (const k of Object.keys(base.iterable)) {\n            // We don't self-assign iterables that have themselves been assigned with futures\n            const attrExists = !noAttrs && k in attrs;\n            if ((reAssign.has(k) && attrExists) || !(attrExists && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e]?.valueOf();\n              if (value !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                combinedInitialIterableValues[k] = value;\n                hasInitialValues = true;\n              }\n            }\n          }\n        }\n        if (hasInitialValues)\n          Object.assign(e, combinedInitialIterableValues);\n      }\n      return e;\n    }\n\n    const extendTag: ExtendTagFunctionInstance = Object.assign(extendTagFn, {\n      super: this,\n      definition: Object.assign(staticExtensions, { [UniqueID]: uniqueTagID }),\n      extended,\n      valueOf: () => {\n        const keys = [...Object.keys(staticExtensions.declare || {}), ...Object.keys(staticExtensions.iterable || {})];\n        return `${extendTag.name}: {${keys.join(', ')}}\\n \\u21AA ${this.valueOf()}`\n      }\n    });\n    Object.defineProperty(extendTag, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    const fullProto = {};\n    (function walkProto(creator: TagCreator<Element>) {\n      if (creator?.super)\n        walkProto(creator.super);\n\n      const proto = creator.definition;\n      if (proto) {\n        deepDefine(fullProto, proto?.override);\n        deepDefine(fullProto, proto?.declare);\n      }\n    })(this);\n    deepDefine(fullProto, staticExtensions.override);\n    deepDefine(fullProto, staticExtensions.declare);\n    Object.defineProperties(extendTag, Object.getOwnPropertyDescriptors(fullProto));\n\n    // Attempt to make up a meaningfu;l name for this extended tag\n    const creatorName = fullProto\n      && 'className' in fullProto\n      && typeof fullProto.className === 'string'\n      ? fullProto.className\n      : uniqueTagID;\n    const callSite = DEBUG ? (new Error().stack?.split('\\n')[2] ?? '') : '';\n\n    Object.defineProperty(extendTag, \"name\", {\n      value: \"<ai-\" + creatorName.replace(/\\s+/g, '-') + callSite + \">\"\n    });\n\n    if (DEBUG) {\n      const extraUnknownProps = Object.keys(staticExtensions).filter(k => !['styles', 'ids', 'constructed', 'declare', 'override', 'iterable'].includes(k));\n      if (extraUnknownProps.length) {\n        console.log(`${extendTag.name} defines extraneous keys '${extraUnknownProps}', which are unknown`);\n      }\n    }\n    return extendTag;\n  }\n\n  // @ts-ignore\n  const baseTagCreators: CreateElement & {\n    [K in keyof HTMLElementTagNameMap]?: TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>\n  } & {\n    [n: string]: TagCreator<Q & Element & PoElementMethods>\n  } = {\n    createElement(\n      name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n      attrs: any,\n      ...children: ChildTags[]): Node {\n      return (name === baseTagCreators.createElement ? nodes(...children)\n        : typeof name === 'function' ? name(attrs, children)\n        : typeof name === 'string' && name in baseTagCreators ?\n        // @ts-ignore: Expression produces a union type that is too complex to represent.ts(2590)\n            baseTagCreators[name](attrs, children)\n        : name instanceof Node ? name\n        : DyamicElementError({ error: new Error(\"Illegal type in createElement:\" + name) })) as Node\n    }\n  }\n\n  function createTag<K extends keyof HTMLElementTagNameMap>(k: K): TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>;\n  function createTag<E extends Element>(k: string): TagCreator<Q & E & PoElementMethods>;\n  function createTag(k: string): TagCreator<Q & NamespacedElementBase & PoElementMethods> {\n    if (baseTagCreators[k])\n      // @ts-ignore\n      return baseTagCreators[k];\n\n    const tagCreator = (attrs: Q & PoElementMethods & TagCreationOptions | ChildTags, ...children: ChildTags[]) => {\n      if (isChildTag(attrs)) {\n        children.unshift(attrs);\n        attrs = {} as any;\n      }\n\n      // This test is always true, but narrows the type of attrs to avoid further errors\n      if (!isChildTag(attrs)) {\n        if (attrs.debugger) {\n          debugger;\n          delete attrs.debugger;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? thisDoc.createElementNS(nameSpace as string, k.toLowerCase())\n          : thisDoc.createElement(k);\n        e.constructor = tagCreator;\n\n        deepDefine(e, tagPrototypes);\n        assignProps(e, attrs);\n\n        // Append any children\n        e.append(...nodes(...children));\n        return e;\n      }\n    }\n\n    const includingExtender = <TagCreator<Element>><unknown>Object.assign(tagCreator, {\n      super: () => { throw new Error(\"Can't invoke native elemenet constructors directly. Use document.createElement().\") },\n      extended, // How to extend this (base) tag\n      valueOf() { return `TagCreator: <${nameSpace || ''}${nameSpace ? '::' : ''}${k}>` }\n    });\n\n    Object.defineProperty(tagCreator, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    Object.defineProperty(tagCreator, \"name\", { value: '<' + k + '>' });\n    // @ts-ignore\n    return baseTagCreators[k] = includingExtender;\n  }\n\n  tags.forEach(createTag);\n\n  // @ts-ignore\n  return baseTagCreators;\n}\n\n/* DOM node removal logic */\ntype PickByType<T, Value> = {\n  [P in keyof T as T[P] extends Value | undefined ? P : never]: T[P]\n}\nfunction mutationTracker(root: Node, track: keyof PickByType<MutationRecord, NodeList>, enableOnRemovedFromDOM?: boolean) {\n  const tracked = new WeakSet<Node>();\n  function walk(nodes: NodeList) {\n    for (const node of nodes) {\n      // In case it's be re-added/moved\n      if ((track === 'addedNodes') === node.isConnected) {\n        walk(node.childNodes);\n        tracked.add(node);\n        // Legacy onRemovedFromDOM support\n        if (enableOnRemovedFromDOM && 'onRemovedFromDOM' in node && typeof node.onRemovedFromDOM === 'function') node.onRemovedFromDOM();\n      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m[track].length) {\n        walk(m[track])\n      }\n    });\n  }).observe(root, { subtree: true, childList: true });\n\n  return function (node: Node) {\n    return tracked.has(node);\n  }\n}\n", "// @ts-ignore\nexport const DEBUG = globalThis.DEBUG == '*' || globalThis.DEBUG == true || globalThis.DEBUG?.match(/(^|\\W)AI-UI(\\W|$)/) || false;\nexport { _console as console };\nexport const timeOutWarn = 5000;\n\nconst _console = {\n  log(...args: any) {\n    if (DEBUG) console.log('(AI-UI) LOG:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  info(...args: any) {\n    if (DEBUG) console.trace('(AI-UI) INFO:', ...args)\n  }\n}\n\n", "import { DEBUG, console } from \"./debug.js\";\n\n// Create a deferred Promise, which can be asynchronously/externally resolved or rejected.\nexport type DeferredPromise<T> = Promise<T> & {\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (value: any) => void;\n}\n\n// Used to suppress TS error about use before initialisation\nconst nothing = (v: any)=>{};\n\nexport function deferred<T>(): DeferredPromise<T> {\n  let resolve: (value: T | PromiseLike<T>) => void = nothing;\n  let reject: (value: any) => void = nothing;\n  const promise = new Promise<T>((...r) => [resolve, reject] = r) as DeferredPromise<T>;\n  promise.resolve = resolve;\n  promise.reject = reject;\n  if (DEBUG) {\n    const initLocation = new Error().stack;\n    promise.catch(ex => (ex instanceof Error || ex?.value instanceof Error) ? console.log(\"Deferred rejection\", ex, \"allocated at \", initLocation) : undefined);\n  }\n  return promise;\n}\n\n// True if `expr in x` is valid\nexport function isObjectLike(x: any): x is Function | {} {\n  return x && typeof x === 'object' || typeof x === 'function'\n}\n\nexport function isPromiseLike<T>(x: any): x is PromiseLike<T> {\n  return isObjectLike(x) && ('then' in x) && typeof x.then === 'function';\n}\n", "import { DEBUG, console } from \"./debug.js\"\nimport { DeferredPromise, deferred, isObjectLike, isPromiseLike } from \"./deferred.js\"\n\n/* IterableProperties can't be correctly typed in TS right now, either the declaratiion\n  works for retrieval (the getter), or it works for assignments (the setter), but there's\n  no TS syntax that permits correct type-checking at present.\n\n  Ideally, it would be:\n\n  type IterableProperties<IP> = {\n    get [K in keyof IP](): AsyncExtraIterable<IP[K]> & IP[K]\n    set [K in keyof IP](v: IP[K])\n  }\n  See https://github.com/microsoft/TypeScript/issues/43826\n\n  We choose the following type description to avoid the issues above. Because the AsyncExtraIterable\n  is Partial it can be omitted from assignments:\n    this.prop = value;  // Valid, as long as valus has the same type as the prop\n  ...and when retrieved it will be the value type, and optionally the async iterator:\n    Div(this.prop) ; // the value\n    this.prop.map!(....)  // the iterator (note the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts which *accepts* a Partial<AsyncIterator>\n  but casts it to a AsyncIterator before use.\n\n  The iterability of propertys of an object is determined by the presence and value of the `Iterability` symbol.\n  By default, the current implementation does a deep mapping, so an iterable property 'obj' is itself\n  iterable, as are it's members. The only defined value at present is \"shallow\", in which case 'obj' remains\n  iterable, but it's membetrs are just POJS values.\n*/\n\n// Base types that can be made defined as iterable: basically anything, _except_ a function\nexport type IterablePropertyPrimitive = (string | number | bigint | boolean | undefined | null);\n// We should exclude AsyncIterable from the types that can be assigned to iterables (and therefore passed to defineIterableProperty)\nexport type IterablePropertyValue = IterablePropertyPrimitive | IterablePropertyValue[] | { [k: string | symbol | number]: IterablePropertyValue };\n\nexport const Iterability = Symbol(\"Iterability\");\nexport type Iterability<Depth extends 'shallow' = 'shallow'> = { [Iterability]: Depth };\nexport type IterableType<T> = T & Partial<AsyncExtraIterable<T>>;\n\ndeclare global {\n  // This is patch to the std lib definition of Array<T>. I don't know why it's absent,\n  // as this is the implementation in all JavaScript engines. It is probably a result\n  // of its absence in https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values,\n  // which inherits from the Object.prototype, which makes no claim for the return type\n  // since it could be overriddem. However, in that case, a TS defn should also override\n  // it, like Number, String, Boolean etc do.\n  interface Array<T> {\n    valueOf(): Array<T>;\n  }\n  // As above, the return type could be T rather than Object, since this is the default impl,\n  // but it's not, for some reason.\n  interface Object {\n    valueOf<T>(this: T): T extends IterableType<infer Z> ? Z : Object;\n  }\n}\n\nexport type IterableProperties<IP> = IP extends Iterability<'shallow'> ? {\n  [K in keyof Omit<IP, typeof Iterability>]: IterableType<IP[K]>\n} : ({\n  [K in keyof IP]: (\n    IP[K] extends Array<infer E>\n    ? (IterableProperties<E>[] | IterableProperties<E[]>)\n    : ((\n      IP[K] extends object\n      ? IterableProperties<IP[K]>\n      : IP[K]\n    ) & IterableType<IP[K]>)\n  )\n})\n\n/* Things to suppliement the JS base AsyncIterable */\nexport interface QueueIteratableIterator<T> extends AsyncIterableIterator<T>, AsyncIterableHelpers {\n  push(value: T): boolean;\n  readonly length: number;\n}\n\nexport interface AsyncExtraIterable<T> extends AsyncIterable<T>, AsyncIterableHelpers { }\n\n// NB: This also (incorrectly) passes sync iterators, as the protocol names are the same\nexport function isAsyncIterator<T = unknown>(o: any | AsyncIterator<T>): o is AsyncIterator<T> {\n  return isObjectLike(o) && 'next' in o && typeof o?.next === 'function'\n}\nexport function isAsyncIterable<T = unknown>(o: any | AsyncIterable<T>): o is AsyncIterable<T> {\n  return isObjectLike(o) && (Symbol.asyncIterator in o) && typeof o[Symbol.asyncIterator] === 'function'\n}\nexport function isAsyncIter<T = unknown>(o: any | AsyncIterable<T> | AsyncIterator<T>): o is AsyncIterable<T> | AsyncIterator<T> {\n  return isAsyncIterable(o) || isAsyncIterator(o)\n}\n\nexport type AsyncProvider<T> = AsyncIterator<T> | AsyncIterable<T>\n\nexport function asyncIterator<T>(o: AsyncProvider<T>) {\n  if (isAsyncIterator(o)) return o;\n  if (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  throw new Error(\"Not an async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nexport const asyncExtras = {\n  filterMap<U extends PartialIterable, R>(this: U,\n    fn: (o: HelperAsyncIterable<U>, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>,\n    initialValue: R | typeof Ignore = Ignore\n  ) {\n    return filterMap(this, fn, initialValue)\n  },\n  map,\n  filter,\n  unique,\n  waitFor,\n  multi,\n  initially,\n  consume,\n  merge<T, A extends Partial<AsyncIterable<any>>[]>(this: PartialIterable<T>, ...m: A) {\n    return merge(this, ...m);\n  },\n  combine<T, S extends CombinedIterable>(this: PartialIterable<T>, others: S) {\n    return combine(Object.assign({ '_this': this }, others));\n  }\n};\n\nconst extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)] as (keyof typeof asyncExtras)[];\n\n// Like Object.assign, but the assigned properties are not enumerable\nfunction assignHidden<D extends {}, S extends {}>(d: D, s: S) {\n  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];\n  for (const k of keys) {\n    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });\n  }\n  return d as D & S;\n}\n\nconst _pending = Symbol('pending');\nconst _items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [_items]: [] as IteratorResult<T>[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[_items]?.length) {\n        return Promise.resolve(q[_items].shift()!);\n      }\n\n      if (!q[_pending])\n        return Promise.resolve({ done: true as const, value: undefined });\n\n      const value = deferred<IteratorResult<T>>();\n      // We install a catch handler as the promise might be legitimately reject before anything waits for it,\n      // and this suppresses the uncaught exception warning.\n      value.catch(ex => { });\n      q[_pending].unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.resolve(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.resolve(value);\n    },\n\n    throw(...args: any[]) {\n      const value = { done: true as const, value: args[0] };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.reject(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[_items]) return -1; // The queue has no consumers and has terminated.\n      return q[_items].length;\n    },\n\n    push(value: T) {\n      if (!q[_pending])\n        return false;\n\n      if (q[_pending].length) {\n        q[_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[_items].push({ done: false, value })\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst _inflight = Symbol('inflight');\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [_inflight]: Set<T> };\n  q[_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[_pending])\n      return false;\n\n    // Debounce\n    if (q[_inflight].has(value))\n      return true;\n\n    if (q[_pending].length) {\n      q[_inflight].add(value);\n      const p = q[_pending].pop()!;\n      p.finally(() => q[_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[_items].find(v => v.value === value)) {\n        q[_items].push({ done: false, value });\n      }\n    }\n    return true;\n  }\n  return q;\n}\n\n// Re-export to hide the internals\nexport const queueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalQueueIteratableIterator;\nexport const debounceQueueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalDebounceQueueIteratableIterator;\n\ndeclare global {\n  interface ObjectConstructor {\n    defineProperties<T, M extends { [K: string | symbol]: TypedPropertyDescriptor<any> }>(o: T, properties: M & ThisType<any>): T & {\n      [K in keyof M]: M[K] extends TypedPropertyDescriptor<infer T> ? T : never\n    };\n  }\n}\n\n/* Define a \"iterable property\" on `obj`.\n   This is a property that holds a boxed (within an Object() call) value, and is also an AsyncIterableIterator. which\n   yields when the property is set.\n   This routine creates the getter/setter for the specified property, and manages the aassociated async iterator.\n*/\n\nconst _proxiedAsyncIterator = Symbol('_proxiedAsyncIterator');\nexport function defineIterableProperty<T extends {}, const N extends string | symbol, V extends IterablePropertyValue>(obj: T, name: N, v: V): T & IterableProperties<{ [k in N]: V }> {\n  // Make `a` an AsyncExtraIterable. We don't do this until a consumer actually tries to\n  // access the iterator methods to prevent leaks where an iterable is created, but\n  // never referenced, and therefore cannot be consumed and ultimately closed\n  let initIterator = () => {\n    initIterator = () => b;\n    const bi = debounceQueueIteratableIterator<V>();\n    const mi = bi.multi();\n    const b = mi[Symbol.asyncIterator]();\n    extras[Symbol.asyncIterator] = mi[Symbol.asyncIterator];\n    push = bi.push;\n    extraKeys.forEach(k => // @ts-ignore\n      extras[k] = b[k as keyof typeof b]);\n    if (!(_proxiedAsyncIterator in a))\n      assignHidden(a, extras);\n    return b;\n  }\n\n  // Create stubs that lazily create the AsyncExtraIterable interface when invoked\n  function lazyAsyncMethod<M extends keyof typeof asyncExtras>(method: M) {\n    return {\n      [method]: function (this: unknown, ...args: any[]) {\n        initIterator();\n        // @ts-ignore - Fix\n        return a[method].apply(this, args);\n      } as (typeof asyncExtras)[M]\n    }[method];\n  }\n\n  type HelperDescriptors<T> = {\n    [K in keyof AsyncExtraIterable<T>]: TypedPropertyDescriptor<AsyncExtraIterable<T>[K]>\n  } & {\n    [Iterability]?: TypedPropertyDescriptor<'shallow'>\n  };\n\n  const extras = { [Symbol.asyncIterator]: initIterator } as AsyncExtraIterable<V> & { [Iterability]?: 'shallow' };\n  extraKeys.forEach((k) => // @ts-ignore\n    extras[k] = lazyAsyncMethod(k))\n  if (typeof v === 'object' && v && Iterability in v && v[Iterability] === 'shallow') {\n    extras[Iterability] = v[Iterability];\n  }\n\n  // Lazily initialize `push`\n  let push: QueueIteratableIterator<V>['push'] = (v: V) => {\n    initIterator(); // Updates `push` to reference the multi-queue\n    return push(v);\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<V> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: V | AsyncExtraIterable<V>) {\n      if (v !== a) {\n        if (isAsyncIterable(v)) {\n          // Assigning multiple async iterators to a single iterable is probably a\n          // bad idea from a reasoning point of view, and multiple implementations\n          // are possible:\n          //  * merge?\n          //  * ignore subsequent assignments?\n          //  * terminate the first then consume the second?\n          // The solution here (one of many possibilities) is the letter: only to allow\n          // most recent assignment to work, terminating any preceeding iterator when it next\n          // yields and finds this consumer has been re-assigned.\n\n          // If the iterator has been reassigned with no change, just ignore it, as we're already consuming it\n          if (piped === v)\n            return;\n\n          piped = v;\n          let stack = DEBUG ? new Error() : undefined;\n          if (DEBUG)\n            console.info(new Error(`Iterable \"${name.toString()}\" has been assigned to consume another iterator. Did you mean to declare it?`));\n          consume.call(v, y => {\n            if (v !== piped) {\n              // We're being piped from something else. We want to stop that one and get piped from this one\n              throw new Error(`Piped iterable \"${name.toString()}\" has been replaced by another iterator`, { cause: stack });\n            }\n            push(y?.valueOf() as V)\n          })\n            .catch(ex => console.info(ex))\n            .finally(() => (v === piped) && (piped = undefined));\n\n          // Early return as we're going to pipe values in later\n          return;\n        } else {\n          if (piped && DEBUG) {\n            console.log(`Iterable \"${name.toString()}\" is already piped from another iterator, and might be overrwitten later`);\n          }\n          a = box(v, extras);\n        }\n      }\n      push(v?.valueOf() as V);\n    },\n    enumerable: true\n  });\n  return obj as any;\n\n  function box<V>(a: V, pds: AsyncExtraIterable<V>): V & AsyncExtraIterable<V> {\n    if (a === null || a === undefined) {\n      return assignHidden(Object.create(null, {\n        valueOf: { value() { return a }, writable: true, configurable: true },\n        toJSON: { value() { return a }, writable: true, configurable: true }\n      }), pds);\n    }\n    switch (typeof a) {\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return assignHidden(Object(a), Object.assign(pds, {\n          toJSON() { return a.valueOf() }\n        }));\n      case 'object':\n        // We box objects by creating a Proxy for the object that pushes on get/set/delete, and maps the supplied async iterator to push the specified key\n        // The proxies are recursive, so that if an object contains objects, they too are proxied. Objects containing primitives remain proxied to\n        // handle the get/set/selete in place of the usual primitive boxing via Object(primitiveValue)\n        // @ts-ignore\n        return boxObject(a, pds);\n\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n\n  type WithPath = { [_proxiedAsyncIterator]: { a: V, path: string | null } };\n  type PossiblyWithPath = V | WithPath;\n  function isProxiedAsyncIterator(o: PossiblyWithPath): o is WithPath {\n    return isObjectLike(o) && _proxiedAsyncIterator in o;\n  }\n  function destructure(o: any, path: string) {\n    const fields = path.split('.').slice(1);\n    for (let i = 0; i < fields.length && ((o = o?.[fields[i]]) !== undefined); i++);\n    return o;\n  }\n  function boxObject(a: V, pds: AsyncExtraIterable<PossiblyWithPath>) {\n    let withPath: AsyncExtraIterable<WithPath[typeof _proxiedAsyncIterator]>;\n    let withoutPath: AsyncExtraIterable<V>;\n    return new Proxy(a as object, handler()) as V & AsyncExtraIterable<V>;\n\n    function handler(path = ''): ProxyHandler<object> {\n      return {\n        // A boxed object has its own keys, and the keys of an AsyncExtraIterable\n        has(target, key) {\n          return key === _proxiedAsyncIterator || key === Symbol.toPrimitive || key in target || key in pds;\n        },\n        // When a key is set in the target, push the change\n        set(target, key, value, receiver) {\n          if (Object.hasOwn(pds, key)) {\n            throw new Error(`Cannot set ${name.toString()}${path}.${key.toString()} as it is part of asyncIterator`);\n          }\n          if (Reflect.get(target, key, receiver) !== value) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n          }\n          return Reflect.set(target, key, value, receiver);\n        },\n        deleteProperty(target, key) {\n          if (Reflect.deleteProperty(target, key)) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n            return true;\n          }\n          return false;\n        },\n        // When getting the value of a boxed object member, prefer asyncExtraIterable over target keys\n        get(target, key, receiver) {\n          // If the key is an asyncExtraIterable member, create the mapped queue to generate it\n          if (Object.hasOwn(pds, key)) {\n            if (!path.length) {\n              withoutPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator].a : o);\n              return withoutPath[key as keyof typeof pds];\n            } else {\n              withPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator] : { a: o, path: null });\n\n              let ai = filterMap(withPath, (o, p) => {\n                const v = destructure(o.a, path);\n                return p !== v || o.path === null || o.path.startsWith(path) ? v : Ignore;\n              }, Ignore, destructure(a, path));\n              return ai[key as keyof typeof ai];\n            }\n          }\n\n          // If the key is a target property, create the proxy to handle it\n          if (key === 'valueOf') return () => destructure(a, path);\n          if (key === Symbol.toPrimitive) {\n            // Special case, since Symbol.toPrimitive is in ha(), we need to implement it\n            return function (hint?: 'string' | 'number' | 'default') {\n              if (Reflect.has(target, key))\n                return Reflect.get(target, key, target).call(target, hint);\n              if (hint === 'string') return target.toString();\n              if (hint === 'number') return Number(target);\n              return target.valueOf();\n            }\n          }\n          if (typeof key === 'string') {\n            if ((!(key in target) || Object.hasOwn(target, key)) && !(Iterability in target && target[Iterability] === 'shallow')) {\n              const field = Reflect.get(target, key, receiver);\n              return (typeof field === 'function') || isAsyncIter(field)\n                ? field\n                : new Proxy(Object(field), handler(path + '.' + key));\n            }\n          }\n          // This is a symbolic entry, or a prototypical value (since it's in the target, but not a target property)\n          return Reflect.get(target, key, receiver);\n        }\n      }\n    }\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\nconst forever = new Promise<any>(() => { });\n\n/* Merge asyncIterables into a single asyncIterable */\n\n/* TS hack to expose the return AsyncGenerator a generator of the union of the merged types */\ntype CollapseIterableType<T> = T[] extends Partial<AsyncIterable<infer U>>[] ? U : never;\ntype CollapseIterableTypes<T> = AsyncIterable<CollapseIterableType<T>>;\n\nexport const merge = <A extends Partial<AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>>[], TYield, TReturn, TNext>(...ai: A) => {\n  const it: (undefined | AsyncIterator<any>)[] = new Array(ai.length);\n  const promises: Promise<{ idx: number, result: IteratorResult<any> }>[] = new Array(ai.length);\n\n  let init = () => {\n    init = () => { }\n    for (let n = 0; n < ai.length; n++) {\n      const a = ai[n] as AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>;\n      promises[n] = (it[n] = Symbol.asyncIterator in a\n        ? a[Symbol.asyncIterator]()\n        : a as AsyncIterator<any>)\n        .next()\n        .then(result => ({ idx: n, result }));\n    }\n  }\n\n  const results: (TYield | TReturn)[] = [];\n  let count = promises.length;\n\n  const merged: AsyncIterableIterator<A[number]> = {\n    [Symbol.asyncIterator]() { return merged },\n    next() {\n      init();\n      return count\n        ? Promise.race(promises).then(({ idx, result }) => {\n          if (result.done) {\n            count--;\n            promises[idx] = forever;\n            results[idx] = result.value;\n            // We don't yield intermediate return values, we just keep them in results\n            // return { done: count === 0, value: result.value }\n            return merged.next();\n          } else {\n            // `ex` is the underlying async iteration exception\n            promises[idx] = it[idx]\n              ? it[idx]!.next().then(result => ({ idx, result })).catch(ex => ({ idx, result: { done: true, value: ex } }))\n              : Promise.resolve({ idx, result: { done: true, value: undefined } })\n            return result;\n          }\n        }).catch(ex => {\n          return merged.throw?.(ex) ?? Promise.reject({ done: true as const, value: new Error(\"Iterator merge exception\") });\n        })\n        : Promise.resolve({ done: true as const, value: results });\n    },\n    async return(r) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.return?.({ done: true, value: r }).then(v => v.value, ex => ex);\n        }\n      }\n      return { done: true, value: results };\n    },\n    async throw(ex: any) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.throw?.(ex).then(v => v.value, ex => ex);\n        }\n      }\n      // Because we've passed the exception on to all the sources, we're now done\n      // previously: return Promise.reject(ex);\n      return { done: true, value: results };\n    }\n  };\n  return iterableHelpers(merged as unknown as CollapseIterableTypes<A[number]>);\n}\n\ntype CombinedIterable = { [k: string | number | symbol]: PartialIterable };\ntype CombinedIterableType<S extends CombinedIterable> = {\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n};\ntype CombinedIterableResult<S extends CombinedIterable> = AsyncExtraIterable<{\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n}>;\n\nexport interface CombineOptions {\n  ignorePartial?: boolean; // Set to avoid yielding if some sources are absent\n}\n\nexport const combine = <S extends CombinedIterable>(src: S, opts: CombineOptions = {}): CombinedIterableResult<S> => {\n  const accumulated: CombinedIterableType<S> = {};\n  let pc: Promise<{ idx: number, k: string, ir: IteratorResult<any> }>[];\n  let si: AsyncIterator<any>[] = [];\n  let active: number = 0;\n  const ci = {\n    [Symbol.asyncIterator]() { return ci },\n    next(): Promise<IteratorResult<CombinedIterableType<S>>> {\n      if (pc === undefined) {\n        pc = Object.entries(src).map(([k, sit], idx) => {\n          active += 1;\n          si[idx] = sit[Symbol.asyncIterator]!();\n          return si[idx].next().then(ir => ({ si, idx, k, ir }));\n        });\n      }\n\n      return (function step(): Promise<IteratorResult<CombinedIterableType<S>>> {\n        return Promise.race(pc).then(({ idx, k, ir }) => {\n          if (ir.done) {\n            pc[idx] = forever;\n            active -= 1;\n            if (!active)\n              return { done: true, value: undefined };\n            return step();\n          } else {\n            // @ts-ignore\n            accumulated[k] = ir.value;\n            pc[idx] = si[idx].next().then(ir => ({ idx, k, ir }));\n          }\n          if (opts.ignorePartial) {\n            if (Object.keys(accumulated).length < Object.keys(src).length)\n              return step();\n          }\n          return { done: false, value: accumulated };\n        })\n      })();\n    },\n    return(v?: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].return?.(v)\n        }\n      });\n      return Promise.resolve({ done: true, value: v });\n    },\n    throw(ex: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].throw?.(ex)\n        }\n      });\n      return Promise.reject({ done: true, value: ex });\n    }\n  }\n  return iterableHelpers(ci);\n}\n\n\nfunction isExtraIterable<T>(i: any): i is AsyncExtraIterable<T> {\n  return isAsyncIterable(i)\n    && extraKeys.every(k => (k in i) && (i as any)[k] === asyncExtras[k]);\n}\n\n// Attach the pre-defined helpers onto an AsyncIterable and return the modified object correctly typed\nexport function iterableHelpers<A extends AsyncIterable<any>>(ai: A): A & AsyncExtraIterable<A extends AsyncIterable<infer T> ? T : unknown> {\n  if (!isExtraIterable(ai)) {\n    assignHidden(ai, asyncExtras);\n  }\n  return ai as A extends AsyncIterable<infer T> ? AsyncExtraIterable<T> & A : never\n}\n\nexport function generatorHelpers<G extends (...args: any[]) => R, R extends AsyncGenerator>(g: G) {\n  return function (...args: Parameters<G>): ReturnType<G> {\n    const ai = g(...args);\n    return iterableHelpers(ai) as ReturnType<G>;\n  } as (...args: Parameters<G>) => ReturnType<G> & AsyncExtraIterable<ReturnType<G> extends AsyncGenerator<infer T> ? T : unknown>\n}\n\n/* AsyncIterable helpers, which can be attached to an AsyncIterator with `withHelpers(ai)`, and invoked directly for foreign asyncIterators */\n\n/* types that accept Partials as potentiallu async iterators, since we permit this IN TYPING so\n  iterable properties don't complain on every access as they are declared as V & Partial<AsyncIterable<V>>\n  due to the setters and getters having different types, but undeclarable in TS due to syntax limitations */\ntype HelperAsyncIterable<Q extends Partial<AsyncIterable<any>>> = HelperAsyncIterator<Required<Q>[typeof Symbol.asyncIterator]>;\ntype HelperAsyncIterator<F> =\n  F extends () => AsyncIterator<infer T>\n  ? T : never;\n\nasync function consume<U extends Partial<AsyncIterable<any>>>(this: U, f?: (u: HelperAsyncIterable<U>) => void | PromiseLike<void>): Promise<void> {\n  let last: undefined | void | PromiseLike<void> = undefined;\n  for await (const u of this as AsyncIterable<HelperAsyncIterable<U>>) {\n    last = f?.(u);\n  }\n  await last;\n}\n\ntype Mapper<U, R> = ((o: U, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>);\ntype MaybePromised<T> = PromiseLike<T> | T;\n\n/* A general filter & mapper that can handle exceptions & returns */\nexport const Ignore = Symbol(\"Ignore\");\n\ntype PartialIterable<T = any> = Partial<AsyncIterable<T>>;\n\nfunction resolveSync<Z, R>(v: MaybePromised<Z>, then: (v: Z) => R, except: (x: any) => any): MaybePromised<R> {\n  if (isPromiseLike(v))\n    return v.then(then, except);\n  try { return then(v) } catch (ex) { return except(ex) }\n}\n\nexport function filterMap<U extends PartialIterable, R>(source: U,\n  fn: Mapper<HelperAsyncIterable<U>, R>,\n  initialValue: R | typeof Ignore = Ignore,\n  prev: R | typeof Ignore = Ignore\n): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  const fai: AsyncIterableIterator<R> = {\n    [Symbol.asyncIterator]() {\n      return fai;\n    },\n\n    next(...args: [] | [undefined]) {\n      if (initialValue !== Ignore) {\n        const init = Promise.resolve({ done: false, value: initialValue });\n        initialValue = Ignore;\n        return init;\n      }\n\n      return new Promise<IteratorResult<R>>(function step(resolve, reject) {\n        if (!ai)\n          ai = source[Symbol.asyncIterator]!();\n        ai.next(...args).then(\n          p => p.done\n            ? resolve(p)\n            : resolveSync(fn(p.value, prev),\n              f => f === Ignore\n                ? step(resolve, reject)\n                : resolve({ done: false, value: prev = f }),\n              ex => {\n                // The filter function failed...\n                ai.throw ? ai.throw(ex) : ai.return?.(ex) // Terminate the source - for now we ignore the result of the termination\n                reject({ done: true, value: ex }); // Terminate the consumer\n              }\n            ),\n\n          ex =>\n            // The source threw. Tell the consumer\n            reject({ done: true, value: ex })\n        ).catch(ex => {\n          // The callback threw\n          ai.throw ? ai.throw(ex) : ai.return?.(ex); // Terminate the source - for now we ignore the result of the termination\n          reject({ done: true, value: ex })\n        })\n      })\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(fai)\n}\n\nfunction map<U extends PartialIterable, R>(this: U, mapper: Mapper<HelperAsyncIterable<U>, R>): AsyncExtraIterable<R> {\n  return filterMap(this, mapper);\n}\n\nfunction filter<U extends PartialIterable>(this: U, fn: (o: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, async o => (await fn(o) ? o : Ignore));\n}\n\nfunction unique<U extends PartialIterable>(this: U, fn?: (next: HelperAsyncIterable<U>, prev: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return fn\n    ? filterMap(this, async (o, p) => (p === Ignore || await fn(o, p)) ? o : Ignore)\n    : filterMap(this, (o, p) => o === p ? Ignore : o);\n}\n\nfunction initially<U extends PartialIterable, I = HelperAsyncIterable<U>>(this: U, initValue: I): AsyncExtraIterable<HelperAsyncIterable<U> | I> {\n  return filterMap(this, o => o, initValue);\n}\n\nfunction waitFor<U extends PartialIterable>(this: U, cb: (done: (value: void | PromiseLike<void>) => void) => void): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, o => new Promise<HelperAsyncIterable<U>>(resolve => { cb(() => resolve(o)); return o }));\n}\n\nfunction multi<U extends PartialIterable>(this: U): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  type T = HelperAsyncIterable<U>;\n  const source = this;\n  let consumers = 0;\n  let current: DeferredPromise<IteratorResult<T, any>>;\n  let ai: AsyncIterator<T, any, undefined> | undefined = undefined;\n\n  // The source has produced a new result\n  function step(it?: IteratorResult<T, any>) {\n    if (it) current.resolve(it);\n    if (!it?.done) {\n      current = deferred<IteratorResult<T>>();\n      ai!.next()\n        .then(step)\n        .catch(error => current.reject({ done: true, value: error }));\n    }\n  }\n\n  const mai: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      consumers += 1;\n      return mai;\n    },\n\n    next() {\n      if (!ai) {\n        ai = source[Symbol.asyncIterator]!();\n        step();\n      }\n      return current//.then(zalgo => zalgo);\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source if we're the final one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: ex });\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source if we're the only one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: v });\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(mai);\n}\n\nexport function augmentGlobalAsyncGenerators() {\n  let g = (async function* () { })();\n  while (g) {\n    const desc = Object.getOwnPropertyDescriptor(g, Symbol.asyncIterator);\n    if (desc) {\n      iterableHelpers(g);\n      break;\n    }\n    g = Object.getPrototypeOf(g);\n  }\n  if (!g) {\n    console.warn(\"Failed to augment the prototype of `(async function*())()`\");\n  }\n}\n\n", "import { DEBUG, console, timeOutWarn } from './debug.js';\nimport { isPromiseLike } from './deferred.js';\nimport { iterableHelpers, merge, AsyncExtraIterable, queueIteratableIterator } from \"./iterators.js\";\n\n/*\n  `when(....)` is both an AsyncIterable of the events it can generate by observation,\n  and a function that can map those events to a specified type, eg:\n\n  this.when('keyup:#elemet') => AsyncIterable<KeyboardEvent>\n  this.when('#elemet')(e => e.target) => AsyncIterable<EventTarget>\n*/\n// Varargs type passed to \"when\"\nexport type WhenParameters<IDS extends string = string> = ReadonlyArray<\n  AsyncIterable<any>\n  | ValidWhenSelector<IDS>\n  | Element /* Implies \"change\" event */\n  | Promise<any> /* Just gets wrapped in a single `yield` */\n>;\n\n// The Iterated type generated by \"when\", based on the parameters\ntype WhenIteratedType<S extends WhenParameters> =\n  (Extract<S[number], AsyncIterable<any>> extends AsyncIterable<infer I> ? unknown extends I ? never : I : never)\n  | ExtractEvents<Extract<S[number], string>>\n  | (Extract<S[number], Element> extends never ? never : Event)\n\ntype MappableIterable<A extends AsyncIterable<any>> =\n  A extends AsyncIterable<infer T> ?\n    A & AsyncExtraIterable<T> &\n    (<R>(mapper: (value: A extends AsyncIterable<infer T> ? T : never) => R) => (AsyncExtraIterable<Awaited<R>>))\n  : never;\n\n// The extended iterator that supports async iterator mapping, chaining, etc\nexport type WhenReturn<S extends WhenParameters> =\n  MappableIterable<\n    AsyncExtraIterable<\n      WhenIteratedType<S>>>;\n\ntype EmptyObject = Record<string | symbol | number, never>;\n\ntype SpecialWhenEvents = {\n  \"@start\": EmptyObject,  // Always fires when referenced\n  \"@ready\": EmptyObject   // Fires when all Element specified sources are mounted in the DOM\n};\ntype WhenEvents = GlobalEventHandlersEventMap & SpecialWhenEvents;\ntype EventNameList<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : `${S},${EventNameList<R>}`\n  : never;\n\ntype EventNameUnion<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : S | EventNameList<R>\n  : never;\n\n\ntype EventAttribute = `${keyof GlobalEventHandlersEventMap}`\ntype CSSIdentifier<IDS extends string = string> = `#${IDS}` |`.${string}` | `[${string}]`\n\n/* ValidWhenSelectors are:\n    @start\n    @ready\n    event:selector\n    event           \"this\" element, event type='event'\n    selector        specificed selectors, implies \"change\" event\n*/\n\nexport type ValidWhenSelector<IDS extends string = string> = `${keyof SpecialWhenEvents}`\n  | `${EventAttribute}:${CSSIdentifier<IDS>}`\n  | EventAttribute\n  | CSSIdentifier<IDS>;\n\ntype IsValidWhenSelector<S>\n  = S extends ValidWhenSelector ? S : never;\n\ntype ExtractEventNames<S>\n  = S extends keyof SpecialWhenEvents ? S\n  : S extends `${infer V}:${infer L extends CSSIdentifier}`\n  ? EventNameUnion<V> extends never ? never : EventNameUnion<V>\n  : S extends `${infer L extends CSSIdentifier}`\n  ? 'change'\n  : never;\n\ntype ExtractEvents<S> = WhenEvents[ExtractEventNames<S>];\n\n/** when **/\ntype EventObservation<EventName extends keyof GlobalEventHandlersEventMap> = {\n  push: (ev: GlobalEventHandlersEventMap[EventName])=>void;\n  terminate: (ex: Error)=>void;\n  container: Element\n  selector: string | null\n};\nconst eventObservations = new WeakMap<Document, Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  if (!eventObservations.has(this))\n    eventObservations.set(this, new Map());\n\n  const observations = eventObservations.get(this)!.get(ev.type as keyof GlobalEventHandlersEventMap);\n  if (observations) {\n    for (const o of observations) {\n      try {\n        const { push, terminate, container, selector } = o;\n        if (!container.isConnected) {\n          const msg = \"Container `#\" + container.id + \">\" + (selector || '') + \"` removed from DOM. Removing subscription\";\n          observations.delete(o);\n          terminate(new Error(msg));\n        } else {\n          if (ev.target instanceof Node) {\n            if (selector) {\n              const nodes = container.querySelectorAll(selector);\n              for (const n of nodes) {\n                if ((ev.target === n || n.contains(ev.target)) && container.contains(n))\n                  push(ev)\n              }\n            } else {\n              if ((ev.target === container || container.contains(ev.target)))\n                push(ev)\n            }\n          }\n        }\n      } catch (ex) {\n        console.warn('docEventHandler', ex);\n      }\n    }\n  }\n}\n\nfunction isCSSSelector(s: string): s is CSSIdentifier {\n  return Boolean(s && (s.startsWith('#') || s.startsWith('.') || (s.startsWith('[') && s.endsWith(']'))));\n}\n\nfunction parseWhenSelector<EventName extends string>(what: IsValidWhenSelector<EventName>): undefined | [CSSIdentifier | null, keyof GlobalEventHandlersEventMap] {\n  const parts = what.split(':');\n  if (parts.length === 1) {\n    if (isCSSSelector(parts[0]))\n      return [parts[0],\"change\"];\n    return [null, parts[0] as keyof GlobalEventHandlersEventMap];\n  }\n  if (parts.length === 2) {\n    if (isCSSSelector(parts[1]) && !isCSSSelector(parts[0]))\n    return [parts[1], parts[0] as keyof GlobalEventHandlersEventMap]\n  }\n  return undefined;\n}\n\nfunction doThrow(message: string):never {\n  throw new Error(message);\n}\n\nfunction whenEvent<EventName extends string>(container: Element, what: IsValidWhenSelector<EventName>) {\n  const [selector, eventName] = parseWhenSelector(what) ?? doThrow(\"Invalid WhenSelector: \"+what);\n\n  if (!eventObservations.has(container.ownerDocument))\n    eventObservations.set(container.ownerDocument, new Map());\n\n  if (!eventObservations.get(container.ownerDocument)!.has(eventName)) {\n    container.ownerDocument.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.get(container.ownerDocument)!.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.get(container.ownerDocument)?.get(eventName)?.delete(details));\n\n  const details: EventObservation<keyof GlobalEventHandlersEventMap> /*EventObservation<Exclude<ExtractEventNames<EventName>, keyof SpecialWhenEvents>>*/ = {\n    push: queue.push,\n    terminate(ex: Error) { queue.return?.(ex)},\n    container,\n    selector: selector || null\n  };\n\n  containerAndSelectorsMounted(container, selector ? [selector] : undefined)\n    .then(_ => eventObservations.get(container.ownerDocument)?.get(eventName)!.add(details));\n\n  return queue.multi() ;\n}\n\nasync function* neverGonnaHappen<Z>(): AsyncIterableIterator<Z> {\n  await new Promise(() => {});\n  yield undefined as Z; // Never should be executed\n}\n\n/* Syntactic sugar: chainAsync decorates the specified iterator so it can be mapped by\n  a following function, or used directly as an iterable */\nfunction chainAsync<A extends AsyncExtraIterable<X>, X>(src: A): MappableIterable<A> {\n  function mappableAsyncIterable(mapper: Parameters<typeof src.map>[0]) {\n    return src.map(mapper);\n  }\n\n  return Object.assign(iterableHelpers(mappableAsyncIterable as unknown as AsyncIterable<A>), {\n    [Symbol.asyncIterator]: () => src[Symbol.asyncIterator]()\n  }) as MappableIterable<A>;\n}\n\nfunction isValidWhenSelector(what: WhenParameters[number]): what is ValidWhenSelector {\n  if (!what)\n    throw new Error('Falsy async source will never be ready\\n\\n' + JSON.stringify(what));\n  return typeof what === 'string' && what[0] !== '@' && Boolean(parseWhenSelector(what));\n}\n\nasync function* once<T>(p: Promise<T>) {\n  yield p;\n}\n\nexport function when<S extends WhenParameters>(container: Element, ...sources: S): WhenReturn<S> {\n  if (!sources || sources.length === 0) {\n    return chainAsync(whenEvent(container, \"change\")) as unknown as WhenReturn<S>;\n  }\n\n  const iterators = sources.filter(what => typeof what !== 'string' || what[0] !== '@').map(what => typeof what === 'string'\n    ? whenEvent(container, what)\n    : what instanceof Element\n      ? whenEvent(what, \"change\")\n      : isPromiseLike(what)\n        ? once(what)\n        : what);\n\n  if (sources.includes('@start')) {\n    const start: AsyncIterableIterator<{}> = {\n      [Symbol.asyncIterator]: () => start,\n      next() {\n        start.next = () => Promise.resolve({ done: true, value: undefined })\n        return Promise.resolve({ done: false, value: {} })\n      }\n    };\n    iterators.push(start);\n  }\n\n  if (sources.includes('@ready')) {\n    const watchSelectors = sources.filter(isValidWhenSelector).map(what => parseWhenSelector(what)?.[0]);\n\n    function isMissing(sel: CSSIdentifier | null | undefined): sel is CSSIdentifier {\n      return Boolean(typeof sel === 'string' && !container.querySelector(sel));\n    }\n\n    const missing = watchSelectors.filter(isMissing);\n\n    let events: AsyncIterator<any, any, undefined> | undefined = undefined;\n    const ai: AsyncIterableIterator<any> = {\n      [Symbol.asyncIterator]() { return ai },\n      throw(ex: any) {\n        if (events?.throw) return events.throw(ex);\n        return Promise.resolve({ done: true, value: ex });\n      },\n      return(v?: any) {\n        if (events?.return) return events.return(v);\n        return Promise.resolve({ done: true, value: v });\n      },\n      next() {\n        if (events) return events.next();\n\n        return containerAndSelectorsMounted(container, missing).then(() => {\n          const merged = (iterators.length > 1)\n          ? merge(...iterators)\n          : iterators.length === 1\n            ? iterators[0]\n            : (neverGonnaHappen<WhenIteratedType<S>>());\n\n          // Now everything is ready, we simply delegate all async ops to the underlying\n          // merged asyncIterator \"events\"\n          events = merged[Symbol.asyncIterator]();\n          if (!events)\n            return { done: true, value: undefined };\n\n          return { done: false, value: {} };\n        });\n      }\n    };\n    return chainAsync(iterableHelpers(ai));\n  }\n\n  const merged = (iterators.length > 1)\n    ? merge(...iterators)\n    : iterators.length === 1\n      ? iterators[0]\n      : (neverGonnaHappen<WhenIteratedType<S>>());\n\n  return chainAsync(iterableHelpers(merged));\n}\n\nfunction elementIsInDOM(elt: Element): Promise<void> {\n  if (elt.isConnected)\n    return Promise.resolve();\n\n  return new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (elt.isConnected) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(elt.ownerDocument.body, {\n    subtree: true,\n    childList: true\n  }));\n}\n\nfunction containerAndSelectorsMounted(container: Element, selectors?: string[]) {\n  if (selectors?.length)\n    return Promise.all([\n      allSelectorsPresent(container, selectors),\n      elementIsInDOM(container)\n    ]);\n  return elementIsInDOM(container);\n}\n\nfunction allSelectorsPresent(container: Element, missing: string[]): Promise<void> {\n  missing = missing.filter(sel => !container.querySelector(sel))\n  if (!missing.length) {\n    return Promise.resolve(); // Nothing is missing\n  }\n\n  const promise = new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (missing.every(sel => container.querySelector(sel))) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(container, {\n    subtree: true,\n    childList: true\n  }));\n\n  /* debugging help: warn if waiting a long time for a selectors to be ready */\n  if (DEBUG) {\n    const stack = new Error().stack?.replace(/^Error/, \"Missing selectors after 5 seconds:\");\n    const warnTimer = setTimeout(() => {\n      console.warn(stack, missing);\n    }, timeOutWarn);\n\n    promise.finally(() => clearTimeout(warnTimer))\n  }\n\n  return promise;\n}\n"],
  "mappings": "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",
  "names": ["v", "a", "result", "ex", "ir", "isMissing", "merged", "unique", "c", "n", "value", "isAncestral", "children"]
}
 diff --git a/module/dist/ai-ui.js b/module/dist/ai-ui.js index 95e59e1..8eeea3e 100644 --- a/module/dist/ai-ui.js +++ b/module/dist/ai-ui.js @@ -1059,8 +1059,9 @@ var AIUI = (() => { get: (target, p, receiver) => { if (typeof p === "string") { if (p in target) { - if (this.contains(target[p])) - return target[p]; + const ref = target[p].deref(); + if (ref && ref.id === p && this.contains(ref)) + return ref; delete target[p]; } let e; @@ -1079,7 +1080,7 @@ var AIUI = (() => { } else { e = this.querySelector("#" + CSS.escape(p)) ?? void 0; } - if (e) target[p] = e; + if (e) target[p] = new WeakRef(e); return e; } } @@ -1564,4 +1565,4 @@ ${createdBy}`); } return __toCommonJS(ai_ui_exports); })(); -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/ai-ui.ts", "../src/debug.ts", "../src/deferred.ts", "../src/iterators.ts", "../src/when.ts"],
  "sourcesContent": ["import { isPromiseLike } from './deferred.js';\nimport { Ignore, asyncIterator, defineIterableProperty, isAsyncIter, isAsyncIterator } from './iterators.js';\nimport { WhenParameters, WhenReturn, when } from './when.js';\nimport { DEBUG, console, timeOutWarn } from './debug.js';\nimport type { ChildTags, Constructed, Instance, Overrides, TagCreationOptions, TagCreator, TagCreatorFunction } from './tags.js';\n\n/* Export useful stuff for users of the bundled code */\nexport { when } from './when.js';\nexport type { ChildTags, Instance, TagCreator, TagCreatorFunction } from './tags.js'\nexport * as Iterators from './iterators.js';\n\nexport const UniqueID = Symbol(\"Unique ID\");\n\nconst logNode = DEBUG ? ((n: Node) => `\"${'innerHTML' in n ? n.innerHTML : n.textContent}\"`) : (n: Node) => undefined;\n\n/* A holder for commonProperties specified when `tag(...p)` is invoked, which are always\n  applied (mixed in) when an element is created */\ntype TagFunctionOptions<OtherMembers extends Record<string | symbol, any> = {}> = {\n  commonProperties?: OtherMembers\n  document?: Document\n  /** @deprecated - legacy support */\n  enableOnRemovedFromDOM?: boolean\n}\n\n/* Members applied to EVERY tag created, even base tags */\ninterface PoElementMethods {\n  get ids(): {}\n  when<T extends Element & PoElementMethods, S extends WhenParameters<Exclude<keyof T['ids'], number | symbol>>>(this: T, ...what: S): WhenReturn<S>;\n  // This is a very incomplete type. In practice, set(attrs) requires a deeply partial set of\n  // attributes, in exactly the same way as a TagFunction's first object parameter\n  set attributes(attrs: object);\n  get attributes(): NamedNodeMap\n}\n\n// Support for https://www.npmjs.com/package/htm (or import htm from 'https://cdn.jsdelivr.net/npm/htm/dist/htm.module.js')\n// Note: same signature as React.createElement\nexport interface CreateElement {\n  // Support for htm, JSX, etc\n  createElement(\n    // \"name\" can a HTML tag string, an existing node (just returns itself), or a tag function\n    name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n    // The attributes used to initialise the node (if a string or function - ignore if it's already a node)\n    attrs: any,\n    // The children\n    ...children: ChildTags[]): Node;\n}\n\n/* The interface that creates a set of TagCreators for the specified DOM tags */\nexport interface TagLoader {\n  nodes(...c: ChildTags[]): (Node | (/*P &*/ (Element & PoElementMethods)))[];\n  UniqueID: typeof UniqueID\n\n  /*\n   Signatures for the tag loader. All params are optional in any combination,\n   but must be in order:\n      tag(\n          ?nameSpace?: string,  // absent nameSpace implies HTML\n          ?tags?: string[],     // absent tags defaults to all common HTML tags\n          ?commonProperties?: CommonPropertiesConstraint // absent implies none are defined\n      )\n\n      eg:\n        tags()  // returns TagCreators for all HTML tags\n        tags(['div','button'], { myThing() {} })\n        tags('http://namespace',['Foreign'], { isForeign: true })\n  */\n\n  <Tags extends keyof HTMLElementTagNameMap>(): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap>(tags: Tags[]): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(tags: Tags[], options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: null | undefined | '', tags: Tags[], options?: TagFunctionOptions<Q>): { [k in Tags]: TagCreator<Q & PoElementMethods & HTMLElement> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: string, tags: Tags[], options?: TagFunctionOptions<Q>): Record<string, TagCreator<Q & PoElementMethods & Element>> & CreateElement\n}\n\nlet idCount = 0;\nconst standandTags = [\n  \"a\", \"abbr\", \"address\", \"area\", \"article\", \"aside\", \"audio\", \"b\", \"base\", \"bdi\", \"bdo\", \"blockquote\", \"body\", \"br\", \"button\",\n  \"canvas\", \"caption\", \"cite\", \"code\", \"col\", \"colgroup\", \"data\", \"datalist\", \"dd\", \"del\", \"details\", \"dfn\", \"dialog\", \"div\",\n  \"dl\", \"dt\", \"em\", \"embed\", \"fieldset\", \"figcaption\", \"figure\", \"footer\", \"form\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\",\n  \"header\", \"hgroup\", \"hr\", \"html\", \"i\", \"iframe\", \"img\", \"input\", \"ins\", \"kbd\", \"label\", \"legend\", \"li\", \"link\", \"main\", \"map\",\n  \"mark\", \"menu\", \"meta\", \"meter\", \"nav\", \"noscript\", \"object\", \"ol\", \"optgroup\", \"option\", \"output\", \"p\", \"picture\", \"pre\",\n  \"progress\", \"q\", \"rp\", \"rt\", \"ruby\", \"s\", \"samp\", \"script\", \"search\", \"section\", \"select\", \"slot\", \"small\", \"source\", \"span\",\n  \"strong\", \"style\", \"sub\", \"summary\", \"sup\", \"table\", \"tbody\", \"td\", \"template\", \"textarea\", \"tfoot\", \"th\", \"thead\", \"time\",\n  \"title\", \"tr\", \"track\", \"u\", \"ul\", \"var\", \"video\", \"wbr\"\n] as const;\n\nfunction idsInaccessible(): never {\n  throw new Error(\"<elt>.ids is a read-only map of Elements\")\n}\n\nfunction isChildTag(x: any): x is ChildTags {\n  return typeof x === 'string'\n    || typeof x === 'number'\n    || typeof x === 'boolean'\n    || x instanceof Node\n    || x instanceof NodeList\n    || x instanceof HTMLCollection\n    || x === null\n    || x === undefined\n    // Can't actually test for the contained type, so we assume it's a ChildTag and let it fail at runtime\n    || Array.isArray(x)\n    || isPromiseLike(x)\n    || isAsyncIter(x)\n    || (typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function');\n}\n\n/* tag */\nconst callStackSymbol = Symbol('callStack');\n\nexport const tag = <TagLoader>function <Tags extends string,\n  T1 extends (string | Tags[] | TagFunctionOptions<Q>),\n  T2 extends (Tags[] | TagFunctionOptions<Q>),\n  Q extends {}\n>(\n  _1: T1,\n  _2: T2,\n  _3?: TagFunctionOptions<Q>\n): Record<string, TagCreator<Q & Element>> {\n  type NamespacedElementBase = T1 extends string ? T1 extends '' ? HTMLElement : Element : HTMLElement;\n\n  /* Work out which parameter is which. There are 6 variations:\n    tag()                                           []\n    tag(commonProperties)                           [object]\n    tag(tags[])                                     [string[]]\n    tag(tags[], commonProperties)                   [string[], object]\n    tag(namespace | null, tags[])                   [string | null, string[]]\n    tag(namespace | null, tags[], commonProperties) [string | null, string[], object]\n  */\n  const [nameSpace, tags, options] = (typeof _1 === 'string') || _1 === null\n    ? [_1, _2 as Tags[], _3 as TagFunctionOptions<Q>]\n    : Array.isArray(_1)\n      ? [null, _1 as Tags[], _2 as TagFunctionOptions<Q>]\n      : [null, standandTags, _1 as TagFunctionOptions<Q>];\n\n  const commonProperties = options?.commonProperties;\n  const thisDoc = options?.document ?? globalThis.document;\n\n  const removedNodes = mutationTracker(thisDoc, 'removedNodes', options?.enableOnRemovedFromDOM);\n\n  function DomPromiseContainer() {\n    return thisDoc.createComment(DEBUG\n      ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\"\n      : \"promise\")\n  }\n\n  function DyamicElementError({ error }: { error: Error | IteratorResult<Error> }) {\n    return thisDoc.createComment(error instanceof Error ? error.toString() : 'Error:\\n' + JSON.stringify(error, null, 2));\n  }\n  const poStyleElt = thisDoc.createElement(\"STYLE\");\n  poStyleElt.id = \"--ai-ui-extended-tag-styles-\";\n\n  /* Properties applied to every tag which can be implemented by reference, similar to prototypes */\n  const warned = new Set<string>();\n  const tagPrototypes: PoElementMethods = Object.create(\n    null,\n    {\n      when: {\n        writable: false,\n        configurable: true,\n        enumerable: false,\n        value: function (...what: WhenParameters) {\n          return when(this, ...what)\n        }\n      },\n      attributes: {\n        ...Object.getOwnPropertyDescriptor(Element.prototype, 'attributes'),\n        set(this: Element, a: object) {\n          if (isAsyncIter(a)) {\n            const ai = isAsyncIterator(a) ? a : a[Symbol.asyncIterator]();\n            const step = () => ai.next().then(\n              ({ done, value }) => { assignProps(this, value); done || step() },\n              ex => console.warn(ex));\n            step();\n          }\n          else assignProps(this, a);\n        }\n      },\n      ids: {\n        // .ids is a getter that when invoked for the first time\n        // lazily creates a Proxy that provides live access to children by id\n        configurable: true,\n        enumerable: true,\n        set: idsInaccessible,\n        get(this: Element) {\n          // Now we've been accessed, create the proxy\n          const idProxy = new Proxy(Object.create(null), {\n            apply: idsInaccessible,\n            construct: idsInaccessible,\n            defineProperty: idsInaccessible,\n            deleteProperty: idsInaccessible,\n            set: idsInaccessible,\n            setPrototypeOf: idsInaccessible,\n            getPrototypeOf() { return null },\n            isExtensible() { return false },\n            preventExtensions() { return true },\n            getOwnPropertyDescriptor(target, p) {\n              if (this.get!(target, p, null))\n                return Reflect.getOwnPropertyDescriptor(target, p);\n            },\n            has(target, p) {\n              const r = this.get!(target, p, null);\n              return Boolean(r);\n            },\n            ownKeys: (target) => {\n              const ids = [...this.querySelectorAll(`[id]`)].map(e => e.id);\n              const unique = [...new Set(ids)];\n              if (DEBUG && ids.length !== unique.length)\n                console.log(`Element contains multiple, shadowed decendant ids`, unique);\n              return unique;\n            },\n            get: (target, p, receiver) => {\n              if (typeof p === 'string') {\n                if (p in target) {\n                  if (this.contains(target[p]))\n                    return target[p];\n                  delete target[p];\n                }\n                let e: Element | undefined;\n                if (DEBUG) {\n                  const nl = this.querySelectorAll('#' + CSS.escape(p));\n                  if (nl.length > 1) {\n                    if (!warned.has(p)) {\n                      warned.add(p);\n                      console.log(`Element contains multiple, shadowed decendants with ID \"${p}\"`/*,`\\n\\t${logNode(this)}`*/);\n                    }\n                  }\n                  e = nl[0];\n                } else {\n                  e = this.querySelector('#' + CSS.escape(p)) ?? undefined;\n                }\n                if (e) target[p] = e;\n                return e;\n              }\n            }\n          });\n          // ..and replace the getter with the Proxy\n          Object.defineProperty(this, 'ids', {\n            configurable: true,\n            enumerable: true,\n            set: idsInaccessible,\n            get() { return idProxy }\n          });\n          // ...and return that from the getter, so subsequent property\n          // accesses go via the Proxy\n          return idProxy;\n        }\n      }\n    }\n  );\n\n  /* Add any user supplied prototypes */\n  if (commonProperties)\n    deepDefine(tagPrototypes, commonProperties);\n\n  function nodes(...c: ChildTags[]) {\n    const appended: Node[] = [];\n    (function children(c: ChildTags): void {\n      if (c === undefined || c === null || c === Ignore)\n        return;\n      if (isPromiseLike(c)) {\n        const g: ChildNode = DomPromiseContainer();\n        appended.push(g);\n        c.then(r => g.replaceWith(...nodes(r)),\n          (x: any) => {\n            console.warn(x, logNode(g));\n            g.replaceWith(DyamicElementError({ error: x }));\n          }\n        );\n        return;\n      }\n      if (c instanceof Node) {\n        appended.push(c);\n        return;\n      }\n\n      // We have an interesting case here where an iterable String is an object with both Symbol.iterator\n      // (inherited from the String prototype) and Symbol.asyncIterator (as it's been augmented by boxed())\n      // but we're only interested in cases like HTMLCollection, NodeList, array, etc., not the fukny ones\n      // It used to be after the isAsyncIter() test, but a non-AsyncIterator *may* also be a sync iterable\n      // For now, we exclude (Symbol.asyncIterator in c) in this case.\n      if (c && typeof c === 'object' && Symbol.iterator in c && !(Symbol.asyncIterator in c) && c[Symbol.iterator]) {\n        for (const d of c) children(d);\n        return;\n      }\n\n      if (isAsyncIter<ChildTags>(c)) {\n        const insertionStack = DEBUG ? ('\\n' + new Error().stack?.replace(/^Error: /, \"Insertion :\")) : '';\n        const ap = isAsyncIterator(c) ? c : c[Symbol.asyncIterator]();\n        // It's possible that this async iterator is a boxed object that also holds a value\n        const unboxed = c.valueOf();\n        const dpm = (unboxed === undefined || unboxed === c) ? [DomPromiseContainer()] : nodes(unboxed as ChildTags)\n\n        let t = dpm.length ? dpm : [DomPromiseContainer()];\n        appended.push(...t);\n        let notYetMounted = true;\n        // DEBUG support\n        let createdAt = Date.now() + timeOutWarn;\n        const createdBy = DEBUG && new Error(\"Created by\").stack;\n\n        const error = (errorValue: any) => {\n          const n = t.filter(n => Boolean(n?.parentNode)) as ChildNode[];\n          if (n.length) {\n            t = [DyamicElementError({ error: errorValue })];\n            n[0].replaceWith(...t);\n            n.slice(1).forEach(e => e?.parentNode!.removeChild(e));\n          }\n          else console.warn(\"Can't report error\", errorValue, createdBy, t.map(logNode));\n          t = [];\n          ap.return?.(errorValue);\n        }\n\n        const update = (es: IteratorResult<ChildTags>) => {\n          if (!es.done) {\n            try {\n              // ChildNode[], since we tested .parentNode\n              const mounted = t.filter(e => e?.parentNode && e.isConnected);\n              const n = notYetMounted ? t : mounted;\n              if (mounted.length) notYetMounted = false;\n\n              if (!n.length || t.every(e => removedNodes(e))) {\n                // We're done - terminate the source quietly (ie this is not an exception as it's expected, but we're done)\n                t = [];\n                const msg = \"Element(s) have been removed from the document: \" + insertionStack;\n                ap.return?.(new Error(msg));\n                return;\n              }\n\n              if (DEBUG && notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Async element not mounted after 5 seconds. If it is never mounted, it will leak.`, createdBy, t.map(logNode));\n              }\n              t = nodes(unbox(es.value) as ChildTags);\n              // If the iterated expression yields no nodes, stuff in a DomPromiseContainer for the next iteration\n              if (!t.length) t.push(DomPromiseContainer());\n              (n[0] as ChildNode).replaceWith(...t);\n              n.slice(1).forEach(e => !t.includes(e) && e.parentNode?.removeChild(e));\n              ap.next().then(update).catch(error);\n            } catch (ex) {\n              // Something went wrong. Terminate the iterator source\n              t = [];\n              ap.return?.(ex);\n            }\n          }\n        }\n        ap.next().then(update).catch(error);\n        return;\n      }\n      appended.push(thisDoc.createTextNode(c.toString()));\n    })(c);\n    return appended;\n  }\n\n  if (!nameSpace) {\n    Object.assign(tag, {\n      nodes,    // Build DOM Node[] from ChildTags\n      UniqueID\n    });\n  }\n\n  /** Just deep copy an object */\n  const plainObjectPrototype = Object.getPrototypeOf({});\n  /** Routine to *define* properties on a dest object from a src object **/\n  function deepDefine(d: Record<string | symbol | number, any>, s: any, declaration?: true): void {\n    if (s === null || s === undefined || typeof s !== 'object' || s === d)\n      return;\n\n    for (const [k, srcDesc] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      try {\n        if ('value' in srcDesc) {\n          const value = srcDesc.value;\n\n          if (value && isAsyncIter<unknown>(value)) {\n            Object.defineProperty(d, k, srcDesc);\n          } else {\n            // This has a real value, which might be an object, so we'll deepDefine it unless it's a\n            // Promise or a function, in which case we just assign it\n            if (value && typeof value === 'object' && !isPromiseLike(value)) {\n              if (!(k in d)) {\n                // If this is a new value in the destination, just define it to be the same value as the source\n                // If the source value is an object, and we're declaring it (therefore it should be a new one), take\n                // a copy so as to not re-use the reference and pollute the declaration. Note: this is probably\n                // a better default for any \"objects\" in a declaration that are plain and not some class type\n                // which can't be copied\n                if (declaration) {\n                  if (Object.getPrototypeOf(value) === plainObjectPrototype || !Object.getPrototypeOf(value)) {\n                    // A plain object can be deep-copied by field\n                    deepDefine(srcDesc.value = {}, value);\n                  } else if (Array.isArray(value)) {\n                    // An array can be deep copied by index\n                    deepDefine(srcDesc.value = [], value);\n                  } else {\n                    // Other object like things (regexps, dates, classes, etc) can't be deep-copied reliably\n                    console.warn(`Declared propety '${k}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`, d, value);\n                  }\n                }\n                Object.defineProperty(d, k, srcDesc);\n              } else {\n                if (value instanceof Node) {\n                  console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child\", k, logNode(value));\n                  d[k] = value;\n                } else {\n                  if (d[k] !== value) {\n                    // Note - if we're copying to an array of different length\n                    // we're decoupling common object references, so we need a clean object to\n                    // assign into\n                    if (Array.isArray(d[k]) && d[k].length !== value.length) {\n                      if (value.constructor === Object || value.constructor === Array) {\n                        deepDefine(d[k] = new (value.constructor), value);\n                      } else {\n                        // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                        d[k] = value;\n                      }\n                    } else {\n                      // This is just a regular object, so we deepDefine recursively\n                      deepDefine(d[k], value);\n                    }\n                  }\n                }\n              }\n            } else {\n              // This is just a primitive value, or a Promise\n              if (s[k] !== undefined)\n                d[k] = s[k];\n            }\n          }\n        } else {\n          // Copy the definition of the getter/setter\n          Object.defineProperty(d, k, srcDesc);\n        }\n      } catch (ex: unknown) {\n        console.warn(\"deepAssign\", k, s[k], ex);\n        throw ex;\n      }\n    }\n  }\n\n  function unbox(a: unknown): unknown {\n    const v = a?.valueOf();\n    return Array.isArray(v) ? Array.prototype.map.call(v, unbox) : v;\n  }\n\n  function assignProps(base: Node, props: Record<string, any>) {\n    // Copy prop hierarchy onto the element via the asssignment operator in order to run setters\n    if (!(callStackSymbol in props)) {\n      (function assign(d: any, s: any): void {\n        if (s === null || s === undefined || typeof s !== 'object')\n          return;\n        // static props before getters/setters\n        const sourceEntries = Object.entries(Object.getOwnPropertyDescriptors(s));\n        if (!Array.isArray(s)) {\n          sourceEntries.sort(a => {\n            const desc = Object.getOwnPropertyDescriptor(d, a[0]);\n            if (desc) {\n              if ('value' in desc) return -1;\n              if ('set' in desc) return 1;\n              if ('get' in desc) return 1;\n            }\n            return 0;\n          });\n        }\n        for (const [k, srcDesc] of sourceEntries) {\n          try {\n            if ('value' in srcDesc) {\n              const value = srcDesc.value;\n              if (isAsyncIter<unknown>(value)) {\n                assignIterable(value, k);\n              } else if (isPromiseLike(value)) {\n                value.then(v => {\n                  if (v && typeof v === 'object') {\n                    // Special case: this promise resolved to an async iterator\n                    if (isAsyncIter<unknown>(v)) {\n                      assignIterable(v, k);\n                    } else {\n                      assignObject(v, k);\n                    }\n                  } else {\n                    if (s[k] !== undefined)\n                      d[k] = v;\n                  }\n                }, error => console.log(\"Failed to set attribute\", error));\n              } else if (!isAsyncIter<unknown>(value)) {\n                // This has a real value, which might be an object\n                if (value && typeof value === 'object' && !isPromiseLike(value))\n                  assignObject(value, k);\n                else {\n                  if (s[k] !== undefined)\n                    d[k] = s[k];\n                }\n              }\n            } else {\n              // Copy the definition of the getter/setter\n              Object.defineProperty(d, k, srcDesc);\n            }\n          } catch (ex: unknown) {\n            console.warn(\"assignProps\", k, s[k], ex);\n            throw ex;\n          }\n        }\n\n        function assignIterable(value: AsyncIterable<unknown> | AsyncIterator<unknown, any, undefined>, k: string) {\n          const ap = asyncIterator(value);\n          let notYetMounted = true;\n          // DEBUG support\n          let createdAt = Date.now() + timeOutWarn;\n          const createdBy = DEBUG && new Error(\"Created by\").stack;\n          const update = (es: IteratorResult<unknown>) => {\n            if (!es.done) {\n              const value = unbox(es.value);\n              if (typeof value === 'object' && value !== null) {\n                /*\n              THIS IS JUST A HACK: `style` has to be set member by member, eg:\n                e.style.color = 'blue'        --- works\n                e.style = { color: 'blue' }   --- doesn't work\n              whereas in general when assigning to property we let the receiver\n              do any work necessary to parse the object. This might be better handled\n              by having a setter for `style` in the PoElementMethods that is sensitive\n              to the type (string|object) being passed so we can just do a straight\n              assignment all the time, or making the decsion based on the location of the\n              property in the prototype chain and assuming anything below \"PO\" must be\n              a primitive\n              */\n                const destDesc = Object.getOwnPropertyDescriptor(d, k);\n                if (k === 'style' || !destDesc?.set)\n                  assign(d[k], value);\n                else\n                  d[k] = value;\n              } else {\n                // Src is not an object (or is null) - just assign it, unless it's undefined\n                if (value !== undefined)\n                  d[k] = value;\n              }\n              const mounted = base.isConnected;\n              // If we have been mounted before, bit aren't now, remove the consumer\n              if (removedNodes(base) || (!notYetMounted && !mounted)) {\n                console.info(`Element does not exist in document when setting async attribute '${k}' to:\\n${logNode(base)}`);\n                ap.return?.();\n                return;\n              }\n              if (mounted) notYetMounted = false;\n              if (notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Element with async attribute '${k}' not mounted after 5 seconds. If it is never mounted, it will leak.\\nElement contains: ${logNode(base)}\\n${createdBy}`);\n              }\n\n              ap.next().then(update).catch(error);\n            }\n          }\n          const error = (errorValue: any) => {\n            console.warn(\"Dynamic attribute error\", errorValue, k, d, createdBy, logNode(base));\n            ap.return?.(errorValue);\n            base.appendChild(DyamicElementError({ error: errorValue }));\n          }\n          const unboxed = value.valueOf();\n          if (unboxed !== undefined && unboxed !== value && !isAsyncIter(unboxed))\n            update({ done: false, value: unboxed });\n          else\n            ap.next().then(update).catch(error);\n        }\n\n        function assignObject(value: any, k: string) {\n          if (value instanceof Node) {\n            console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes\", k, logNode(value));\n            d[k] = value;\n          } else {\n            // Note - if we're copying to ourself (or an array of different length),\n            // we're decoupling common object references, so we need a clean object to\n            // assign into\n            if (!(k in d) || d[k] === value || (Array.isArray(d[k]) && d[k].length !== value.length)) {\n              if (value.constructor === Object || value.constructor === Array) {\n                const copy = new (value.constructor);\n                assign(copy, value);\n                d[k] = copy;\n                //assign(d[k], value);\n              } else {\n                // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                d[k] = value;\n              }\n            } else {\n              if (Object.getOwnPropertyDescriptor(d, k)?.set)\n                d[k] = value;\n\n              else\n                assign(d[k], value);\n            }\n          }\n        }\n      })(base, props);\n    }\n  }\n\n  /*\n  Extend a component class with create a new component class factory:\n      const NewDiv = Div.extended({ overrides })\n          ...or...\n      const NewDic = Div.extended((instance:{ arbitrary-type }) => ({ overrides }))\n         ...later...\n      const eltNewDiv = NewDiv({attrs},...children)\n  */\n\n  type ExtendTagFunction = (attrs: TagCreationOptions & {\n    [callStackSymbol]?: Overrides[];\n    [k: string]: unknown;\n  } | ChildTags, ...children: ChildTags[]) => Element\n\n  interface ExtendTagFunctionInstance extends ExtendTagFunction {\n    super: TagCreator<Element>;\n    definition: Overrides;\n    valueOf: () => string;\n    extended: (this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) => ExtendTagFunctionInstance;\n  }\n\n  function tagHasInstance(this: ExtendTagFunctionInstance, e: any) {\n    for (let c = e.constructor; c; c = c.super) {\n      if (c === this)\n        return true;\n    }\n    return false;\n  }\n\n  function extended(this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) {\n    const instanceDefinition = (typeof _overrides !== 'function')\n      ? (instance: Instance) => Object.assign({}, _overrides, instance)\n      : _overrides\n\n    const uniqueTagID = Date.now().toString(36) + (idCount++).toString(36) + Math.random().toString(36).slice(2);\n    let staticExtensions: Overrides = instanceDefinition({ [UniqueID]: uniqueTagID });\n    /* \"Statically\" create any styles required by this widget */\n    if (staticExtensions.styles) {\n      poStyleElt.appendChild(thisDoc.createTextNode(staticExtensions.styles + '\\n'));\n      if (!thisDoc.head.contains(poStyleElt)) {\n        thisDoc.head.appendChild(poStyleElt);\n      }\n    }\n\n    // \"this\" is the tag we're being extended from, as it's always called as: `(this).extended`\n    // Here's where we actually create the tag, by accumulating all the base attributes and\n    // (finally) assigning those specified by the instantiation\n    const extendTagFn: ExtendTagFunction = (attrs, ...children) => {\n      const noAttrs = isChildTag(attrs);\n      const newCallStack: (Constructed & Overrides)[] = [];\n      const combinedAttrs = { [callStackSymbol]: (noAttrs ? newCallStack : attrs[callStackSymbol]) ?? newCallStack }\n      const e = noAttrs ? this(combinedAttrs, attrs, ...children) : this(combinedAttrs, ...children);\n      e.constructor = extendTag;\n      const tagDefinition = instanceDefinition({ [UniqueID]: uniqueTagID });\n      combinedAttrs[callStackSymbol].push(tagDefinition);\n      if (DEBUG) {\n        // Validate declare and override\n        function isAncestral(creator: TagCreator<Element>, d: string) {\n          for (let f = creator; f; f = f.super)\n            if (f.definition?.declare && d in f.definition.declare) return true;\n          return false;\n        }\n        if (tagDefinition.declare) {\n          const clash = Object.keys(tagDefinition.declare).filter(d => (d in e) || isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Declared keys '${clash}' in ${extendTag.name} already exist in base '${this.valueOf()}'`);\n          }\n        }\n        if (tagDefinition.override) {\n          const clash = Object.keys(tagDefinition.override).filter(d => !(d in e) && !(commonProperties && d in commonProperties) && !isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Overridden keys '${clash}' in ${extendTag.name} do not exist in base '${this.valueOf()}'`);\n          }\n        }\n      }\n      deepDefine(e, tagDefinition.declare, true);\n      deepDefine(e, tagDefinition.override);\n      const reAssign = new Set<string>();\n      tagDefinition.iterable && Object.keys(tagDefinition.iterable).forEach(k => {\n        if (k in e) {\n          console.log(`Ignoring attempt to re-define iterable property \"${k}\" as it could already have consumers`);\n          reAssign.add(k);\n        } else {\n          defineIterableProperty(e, k, tagDefinition.iterable![k as keyof typeof tagDefinition.iterable])\n        }\n      });\n      if (combinedAttrs[callStackSymbol] === newCallStack) {\n        if (!noAttrs)\n          assignProps(e, attrs);\n        for (const base of newCallStack) {\n          const children = base?.constructed?.call(e);\n          if (isChildTag(children)) // technically not necessary, since \"void\" is going to be undefined in 99.9% of cases.\n            e.append(...nodes(children));\n        }\n        // Once the full tree of augmented DOM elements has been constructed, fire all the iterable propeerties\n        // so the full hierarchy gets to consume the initial state, unless they have been assigned\n        // by assignProps from a future\n        const combinedInitialIterableValues = {};\n        let hasInitialValues = false;\n        for (const base of newCallStack) {\n          if (base.iterable) for (const k of Object.keys(base.iterable)) {\n            // We don't self-assign iterables that have themselves been assigned with futures\n            const attrExists = !noAttrs && k in attrs;\n            if ((reAssign.has(k) && attrExists) || !(attrExists && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e]?.valueOf();\n              if (value !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                combinedInitialIterableValues[k] = value;\n                hasInitialValues = true;\n              }\n            }\n          }\n        }\n        if (hasInitialValues)\n          Object.assign(e, combinedInitialIterableValues);\n      }\n      return e;\n    }\n\n    const extendTag: ExtendTagFunctionInstance = Object.assign(extendTagFn, {\n      super: this,\n      definition: Object.assign(staticExtensions, { [UniqueID]: uniqueTagID }),\n      extended,\n      valueOf: () => {\n        const keys = [...Object.keys(staticExtensions.declare || {}), ...Object.keys(staticExtensions.iterable || {})];\n        return `${extendTag.name}: {${keys.join(', ')}}\\n \\u21AA ${this.valueOf()}`\n      }\n    });\n    Object.defineProperty(extendTag, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    const fullProto = {};\n    (function walkProto(creator: TagCreator<Element>) {\n      if (creator?.super)\n        walkProto(creator.super);\n\n      const proto = creator.definition;\n      if (proto) {\n        deepDefine(fullProto, proto?.override);\n        deepDefine(fullProto, proto?.declare);\n      }\n    })(this);\n    deepDefine(fullProto, staticExtensions.override);\n    deepDefine(fullProto, staticExtensions.declare);\n    Object.defineProperties(extendTag, Object.getOwnPropertyDescriptors(fullProto));\n\n    // Attempt to make up a meaningfu;l name for this extended tag\n    const creatorName = fullProto\n      && 'className' in fullProto\n      && typeof fullProto.className === 'string'\n      ? fullProto.className\n      : uniqueTagID;\n    const callSite = DEBUG ? (new Error().stack?.split('\\n')[2] ?? '') : '';\n\n    Object.defineProperty(extendTag, \"name\", {\n      value: \"<ai-\" + creatorName.replace(/\\s+/g, '-') + callSite + \">\"\n    });\n\n    if (DEBUG) {\n      const extraUnknownProps = Object.keys(staticExtensions).filter(k => !['styles', 'ids', 'constructed', 'declare', 'override', 'iterable'].includes(k));\n      if (extraUnknownProps.length) {\n        console.log(`${extendTag.name} defines extraneous keys '${extraUnknownProps}', which are unknown`);\n      }\n    }\n    return extendTag;\n  }\n\n  // @ts-ignore\n  const baseTagCreators: CreateElement & {\n    [K in keyof HTMLElementTagNameMap]?: TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>\n  } & {\n    [n: string]: TagCreator<Q & Element & PoElementMethods>\n  } = {\n    createElement(\n      name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n      attrs: any,\n      ...children: ChildTags[]): Node {\n      return (name === baseTagCreators.createElement ? nodes(...children)\n        : typeof name === 'function' ? name(attrs, children)\n        : typeof name === 'string' && name in baseTagCreators ?\n        // @ts-ignore: Expression produces a union type that is too complex to represent.ts(2590)\n            baseTagCreators[name](attrs, children)\n        : name instanceof Node ? name\n        : DyamicElementError({ error: new Error(\"Illegal type in createElement:\" + name) })) as Node\n    }\n  }\n\n  function createTag<K extends keyof HTMLElementTagNameMap>(k: K): TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>;\n  function createTag<E extends Element>(k: string): TagCreator<Q & E & PoElementMethods>;\n  function createTag(k: string): TagCreator<Q & NamespacedElementBase & PoElementMethods> {\n    if (baseTagCreators[k])\n      // @ts-ignore\n      return baseTagCreators[k];\n\n    const tagCreator = (attrs: Q & PoElementMethods & TagCreationOptions | ChildTags, ...children: ChildTags[]) => {\n      if (isChildTag(attrs)) {\n        children.unshift(attrs);\n        attrs = {} as any;\n      }\n\n      // This test is always true, but narrows the type of attrs to avoid further errors\n      if (!isChildTag(attrs)) {\n        if (attrs.debugger) {\n          debugger;\n          delete attrs.debugger;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? thisDoc.createElementNS(nameSpace as string, k.toLowerCase())\n          : thisDoc.createElement(k);\n        e.constructor = tagCreator;\n\n        deepDefine(e, tagPrototypes);\n        assignProps(e, attrs);\n\n        // Append any children\n        e.append(...nodes(...children));\n        return e;\n      }\n    }\n\n    const includingExtender = <TagCreator<Element>><unknown>Object.assign(tagCreator, {\n      super: () => { throw new Error(\"Can't invoke native elemenet constructors directly. Use document.createElement().\") },\n      extended, // How to extend this (base) tag\n      valueOf() { return `TagCreator: <${nameSpace || ''}${nameSpace ? '::' : ''}${k}>` }\n    });\n\n    Object.defineProperty(tagCreator, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    Object.defineProperty(tagCreator, \"name\", { value: '<' + k + '>' });\n    // @ts-ignore\n    return baseTagCreators[k] = includingExtender;\n  }\n\n  tags.forEach(createTag);\n\n  // @ts-ignore\n  return baseTagCreators;\n}\n\n/* DOM node removal logic */\ntype PickByType<T, Value> = {\n  [P in keyof T as T[P] extends Value | undefined ? P : never]: T[P]\n}\nfunction mutationTracker(root: Node, track: keyof PickByType<MutationRecord, NodeList>, enableOnRemovedFromDOM?: boolean) {\n  const tracked = new WeakSet<Node>();\n  function walk(nodes: NodeList) {\n    for (const node of nodes) {\n      // In case it's be re-added/moved\n      if ((track === 'addedNodes') === node.isConnected) {\n        walk(node.childNodes);\n        tracked.add(node);\n        // Legacy onRemovedFromDOM support\n        if (enableOnRemovedFromDOM && 'onRemovedFromDOM' in node && typeof node.onRemovedFromDOM === 'function') node.onRemovedFromDOM();\n      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m[track].length) {\n        walk(m[track])\n      }\n    });\n  }).observe(root, { subtree: true, childList: true });\n\n  return function (node: Node) {\n    return tracked.has(node);\n  }\n}\n", "// @ts-ignore\nexport const DEBUG = globalThis.DEBUG == '*' || globalThis.DEBUG == true || globalThis.DEBUG?.match(/(^|\\W)AI-UI(\\W|$)/) || false;\nexport { _console as console };\nexport const timeOutWarn = 5000;\n\nconst _console = {\n  log(...args: any) {\n    if (DEBUG) console.log('(AI-UI) LOG:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  info(...args: any) {\n    if (DEBUG) console.trace('(AI-UI) INFO:', ...args)\n  }\n}\n\n", "import { DEBUG, console } from \"./debug.js\";\n\n// Create a deferred Promise, which can be asynchronously/externally resolved or rejected.\nexport type DeferredPromise<T> = Promise<T> & {\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (value: any) => void;\n}\n\n// Used to suppress TS error about use before initialisation\nconst nothing = (v: any)=>{};\n\nexport function deferred<T>(): DeferredPromise<T> {\n  let resolve: (value: T | PromiseLike<T>) => void = nothing;\n  let reject: (value: any) => void = nothing;\n  const promise = new Promise<T>((...r) => [resolve, reject] = r) as DeferredPromise<T>;\n  promise.resolve = resolve;\n  promise.reject = reject;\n  if (DEBUG) {\n    const initLocation = new Error().stack;\n    promise.catch(ex => (ex instanceof Error || ex?.value instanceof Error) ? console.log(\"Deferred rejection\", ex, \"allocated at \", initLocation) : undefined);\n  }\n  return promise;\n}\n\n// True if `expr in x` is valid\nexport function isObjectLike(x: any): x is Function | {} {\n  return x && typeof x === 'object' || typeof x === 'function'\n}\n\nexport function isPromiseLike<T>(x: any): x is PromiseLike<T> {\n  return isObjectLike(x) && ('then' in x) && typeof x.then === 'function';\n}\n", "import { DEBUG, console } from \"./debug.js\"\nimport { DeferredPromise, deferred, isObjectLike, isPromiseLike } from \"./deferred.js\"\n\n/* IterableProperties can't be correctly typed in TS right now, either the declaratiion\n  works for retrieval (the getter), or it works for assignments (the setter), but there's\n  no TS syntax that permits correct type-checking at present.\n\n  Ideally, it would be:\n\n  type IterableProperties<IP> = {\n    get [K in keyof IP](): AsyncExtraIterable<IP[K]> & IP[K]\n    set [K in keyof IP](v: IP[K])\n  }\n  See https://github.com/microsoft/TypeScript/issues/43826\n\n  We choose the following type description to avoid the issues above. Because the AsyncExtraIterable\n  is Partial it can be omitted from assignments:\n    this.prop = value;  // Valid, as long as valus has the same type as the prop\n  ...and when retrieved it will be the value type, and optionally the async iterator:\n    Div(this.prop) ; // the value\n    this.prop.map!(....)  // the iterator (note the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts which *accepts* a Partial<AsyncIterator>\n  but casts it to a AsyncIterator before use.\n\n  The iterability of propertys of an object is determined by the presence and value of the `Iterability` symbol.\n  By default, the current implementation does a deep mapping, so an iterable property 'obj' is itself\n  iterable, as are it's members. The only defined value at present is \"shallow\", in which case 'obj' remains\n  iterable, but it's membetrs are just POJS values.\n*/\n\n// Base types that can be made defined as iterable: basically anything, _except_ a function\nexport type IterablePropertyPrimitive = (string | number | bigint | boolean | undefined | null);\n// We should exclude AsyncIterable from the types that can be assigned to iterables (and therefore passed to defineIterableProperty)\nexport type IterablePropertyValue = IterablePropertyPrimitive | IterablePropertyValue[] | { [k: string | symbol | number]: IterablePropertyValue };\n\nexport const Iterability = Symbol(\"Iterability\");\nexport type Iterability<Depth extends 'shallow' = 'shallow'> = { [Iterability]: Depth };\nexport type IterableType<T> = T & Partial<AsyncExtraIterable<T>>;\n\ndeclare global {\n  // This is patch to the std lib definition of Array<T>. I don't know why it's absent,\n  // as this is the implementation in all JavaScript engines. It is probably a result\n  // of its absence in https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values,\n  // which inherits from the Object.prototype, which makes no claim for the return type\n  // since it could be overriddem. However, in that case, a TS defn should also override\n  // it, like Number, String, Boolean etc do.\n  interface Array<T> {\n    valueOf(): Array<T>;\n  }\n  // As above, the return type could be T rather than Object, since this is the default impl,\n  // but it's not, for some reason.\n  interface Object {\n    valueOf<T>(this: T): T extends IterableType<infer Z> ? Z : Object;\n  }\n}\n\nexport type IterableProperties<IP> = IP extends Iterability<'shallow'> ? {\n  [K in keyof Omit<IP, typeof Iterability>]: IterableType<IP[K]>\n} : ({\n  [K in keyof IP]: (\n    IP[K] extends Array<infer E>\n    ? (IterableProperties<E>[] | IterableProperties<E[]>)\n    : ((\n      IP[K] extends object\n      ? IterableProperties<IP[K]>\n      : IP[K]\n    ) & IterableType<IP[K]>)\n  )\n})\n\n/* Things to suppliement the JS base AsyncIterable */\nexport interface QueueIteratableIterator<T> extends AsyncIterableIterator<T>, AsyncIterableHelpers {\n  push(value: T): boolean;\n  readonly length: number;\n}\n\nexport interface AsyncExtraIterable<T> extends AsyncIterable<T>, AsyncIterableHelpers { }\n\n// NB: This also (incorrectly) passes sync iterators, as the protocol names are the same\nexport function isAsyncIterator<T = unknown>(o: any | AsyncIterator<T>): o is AsyncIterator<T> {\n  return isObjectLike(o) && 'next' in o && typeof o?.next === 'function'\n}\nexport function isAsyncIterable<T = unknown>(o: any | AsyncIterable<T>): o is AsyncIterable<T> {\n  return isObjectLike(o) && (Symbol.asyncIterator in o) && typeof o[Symbol.asyncIterator] === 'function'\n}\nexport function isAsyncIter<T = unknown>(o: any | AsyncIterable<T> | AsyncIterator<T>): o is AsyncIterable<T> | AsyncIterator<T> {\n  return isAsyncIterable(o) || isAsyncIterator(o)\n}\n\nexport type AsyncProvider<T> = AsyncIterator<T> | AsyncIterable<T>\n\nexport function asyncIterator<T>(o: AsyncProvider<T>) {\n  if (isAsyncIterator(o)) return o;\n  if (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  throw new Error(\"Not an async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nexport const asyncExtras = {\n  filterMap<U extends PartialIterable, R>(this: U,\n    fn: (o: HelperAsyncIterable<U>, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>,\n    initialValue: R | typeof Ignore = Ignore\n  ) {\n    return filterMap(this, fn, initialValue)\n  },\n  map,\n  filter,\n  unique,\n  waitFor,\n  multi,\n  initially,\n  consume,\n  merge<T, A extends Partial<AsyncIterable<any>>[]>(this: PartialIterable<T>, ...m: A) {\n    return merge(this, ...m);\n  },\n  combine<T, S extends CombinedIterable>(this: PartialIterable<T>, others: S) {\n    return combine(Object.assign({ '_this': this }, others));\n  }\n};\n\nconst extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)] as (keyof typeof asyncExtras)[];\n\n// Like Object.assign, but the assigned properties are not enumerable\nfunction assignHidden<D extends {}, S extends {}>(d: D, s: S) {\n  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];\n  for (const k of keys) {\n    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });\n  }\n  return d as D & S;\n}\n\nconst _pending = Symbol('pending');\nconst _items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [_items]: [] as IteratorResult<T>[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[_items]?.length) {\n        return Promise.resolve(q[_items].shift()!);\n      }\n\n      if (!q[_pending])\n        return Promise.resolve({ done: true as const, value: undefined });\n\n      const value = deferred<IteratorResult<T>>();\n      // We install a catch handler as the promise might be legitimately reject before anything waits for it,\n      // and this suppresses the uncaught exception warning.\n      value.catch(ex => { });\n      q[_pending].unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.resolve(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.resolve(value);\n    },\n\n    throw(...args: any[]) {\n      const value = { done: true as const, value: args[0] };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.reject(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[_items]) return -1; // The queue has no consumers and has terminated.\n      return q[_items].length;\n    },\n\n    push(value: T) {\n      if (!q[_pending])\n        return false;\n\n      if (q[_pending].length) {\n        q[_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[_items].push({ done: false, value })\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst _inflight = Symbol('inflight');\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [_inflight]: Set<T> };\n  q[_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[_pending])\n      return false;\n\n    // Debounce\n    if (q[_inflight].has(value))\n      return true;\n\n    if (q[_pending].length) {\n      q[_inflight].add(value);\n      const p = q[_pending].pop()!;\n      p.finally(() => q[_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[_items].find(v => v.value === value)) {\n        q[_items].push({ done: false, value });\n      }\n    }\n    return true;\n  }\n  return q;\n}\n\n// Re-export to hide the internals\nexport const queueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalQueueIteratableIterator;\nexport const debounceQueueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalDebounceQueueIteratableIterator;\n\ndeclare global {\n  interface ObjectConstructor {\n    defineProperties<T, M extends { [K: string | symbol]: TypedPropertyDescriptor<any> }>(o: T, properties: M & ThisType<any>): T & {\n      [K in keyof M]: M[K] extends TypedPropertyDescriptor<infer T> ? T : never\n    };\n  }\n}\n\n/* Define a \"iterable property\" on `obj`.\n   This is a property that holds a boxed (within an Object() call) value, and is also an AsyncIterableIterator. which\n   yields when the property is set.\n   This routine creates the getter/setter for the specified property, and manages the aassociated async iterator.\n*/\n\nconst _proxiedAsyncIterator = Symbol('_proxiedAsyncIterator');\nexport function defineIterableProperty<T extends {}, const N extends string | symbol, V extends IterablePropertyValue>(obj: T, name: N, v: V): T & IterableProperties<{ [k in N]: V }> {\n  // Make `a` an AsyncExtraIterable. We don't do this until a consumer actually tries to\n  // access the iterator methods to prevent leaks where an iterable is created, but\n  // never referenced, and therefore cannot be consumed and ultimately closed\n  let initIterator = () => {\n    initIterator = () => b;\n    const bi = debounceQueueIteratableIterator<V>();\n    const mi = bi.multi();\n    const b = mi[Symbol.asyncIterator]();\n    extras[Symbol.asyncIterator] = mi[Symbol.asyncIterator];\n    push = bi.push;\n    extraKeys.forEach(k => // @ts-ignore\n      extras[k] = b[k as keyof typeof b]);\n    if (!(_proxiedAsyncIterator in a))\n      assignHidden(a, extras);\n    return b;\n  }\n\n  // Create stubs that lazily create the AsyncExtraIterable interface when invoked\n  function lazyAsyncMethod<M extends keyof typeof asyncExtras>(method: M) {\n    return {\n      [method]: function (this: unknown, ...args: any[]) {\n        initIterator();\n        // @ts-ignore - Fix\n        return a[method].apply(this, args);\n      } as (typeof asyncExtras)[M]\n    }[method];\n  }\n\n  type HelperDescriptors<T> = {\n    [K in keyof AsyncExtraIterable<T>]: TypedPropertyDescriptor<AsyncExtraIterable<T>[K]>\n  } & {\n    [Iterability]?: TypedPropertyDescriptor<'shallow'>\n  };\n\n  const extras = { [Symbol.asyncIterator]: initIterator } as AsyncExtraIterable<V> & { [Iterability]?: 'shallow' };\n  extraKeys.forEach((k) => // @ts-ignore\n    extras[k] = lazyAsyncMethod(k))\n  if (typeof v === 'object' && v && Iterability in v && v[Iterability] === 'shallow') {\n    extras[Iterability] = v[Iterability];\n  }\n\n  // Lazily initialize `push`\n  let push: QueueIteratableIterator<V>['push'] = (v: V) => {\n    initIterator(); // Updates `push` to reference the multi-queue\n    return push(v);\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<V> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: V | AsyncExtraIterable<V>) {\n      if (v !== a) {\n        if (isAsyncIterable(v)) {\n          // Assigning multiple async iterators to a single iterable is probably a\n          // bad idea from a reasoning point of view, and multiple implementations\n          // are possible:\n          //  * merge?\n          //  * ignore subsequent assignments?\n          //  * terminate the first then consume the second?\n          // The solution here (one of many possibilities) is the letter: only to allow\n          // most recent assignment to work, terminating any preceeding iterator when it next\n          // yields and finds this consumer has been re-assigned.\n\n          // If the iterator has been reassigned with no change, just ignore it, as we're already consuming it\n          if (piped === v)\n            return;\n\n          piped = v;\n          let stack = DEBUG ? new Error() : undefined;\n          if (DEBUG)\n            console.info(new Error(`Iterable \"${name.toString()}\" has been assigned to consume another iterator. Did you mean to declare it?`));\n          consume.call(v, y => {\n            if (v !== piped) {\n              // We're being piped from something else. We want to stop that one and get piped from this one\n              throw new Error(`Piped iterable \"${name.toString()}\" has been replaced by another iterator`, { cause: stack });\n            }\n            push(y?.valueOf() as V)\n          })\n            .catch(ex => console.info(ex))\n            .finally(() => (v === piped) && (piped = undefined));\n\n          // Early return as we're going to pipe values in later\n          return;\n        } else {\n          if (piped && DEBUG) {\n            console.log(`Iterable \"${name.toString()}\" is already piped from another iterator, and might be overrwitten later`);\n          }\n          a = box(v, extras);\n        }\n      }\n      push(v?.valueOf() as V);\n    },\n    enumerable: true\n  });\n  return obj as any;\n\n  function box<V>(a: V, pds: AsyncExtraIterable<V>): V & AsyncExtraIterable<V> {\n    if (a === null || a === undefined) {\n      return assignHidden(Object.create(null, {\n        valueOf: { value() { return a }, writable: true, configurable: true },\n        toJSON: { value() { return a }, writable: true, configurable: true }\n      }), pds);\n    }\n    switch (typeof a) {\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return assignHidden(Object(a), Object.assign(pds, {\n          toJSON() { return a.valueOf() }\n        }));\n      case 'object':\n        // We box objects by creating a Proxy for the object that pushes on get/set/delete, and maps the supplied async iterator to push the specified key\n        // The proxies are recursive, so that if an object contains objects, they too are proxied. Objects containing primitives remain proxied to\n        // handle the get/set/selete in place of the usual primitive boxing via Object(primitiveValue)\n        // @ts-ignore\n        return boxObject(a, pds);\n\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n\n  type WithPath = { [_proxiedAsyncIterator]: { a: V, path: string | null } };\n  type PossiblyWithPath = V | WithPath;\n  function isProxiedAsyncIterator(o: PossiblyWithPath): o is WithPath {\n    return isObjectLike(o) && _proxiedAsyncIterator in o;\n  }\n  function destructure(o: any, path: string) {\n    const fields = path.split('.').slice(1);\n    for (let i = 0; i < fields.length && ((o = o?.[fields[i]]) !== undefined); i++);\n    return o;\n  }\n  function boxObject(a: V, pds: AsyncExtraIterable<PossiblyWithPath>) {\n    let withPath: AsyncExtraIterable<WithPath[typeof _proxiedAsyncIterator]>;\n    let withoutPath: AsyncExtraIterable<V>;\n    return new Proxy(a as object, handler()) as V & AsyncExtraIterable<V>;\n\n    function handler(path = ''): ProxyHandler<object> {\n      return {\n        // A boxed object has its own keys, and the keys of an AsyncExtraIterable\n        has(target, key) {\n          return key === _proxiedAsyncIterator || key === Symbol.toPrimitive || key in target || key in pds;\n        },\n        // When a key is set in the target, push the change\n        set(target, key, value, receiver) {\n          if (Object.hasOwn(pds, key)) {\n            throw new Error(`Cannot set ${name.toString()}${path}.${key.toString()} as it is part of asyncIterator`);\n          }\n          if (Reflect.get(target, key, receiver) !== value) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n          }\n          return Reflect.set(target, key, value, receiver);\n        },\n        deleteProperty(target, key) {\n          if (Reflect.deleteProperty(target, key)) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n            return true;\n          }\n          return false;\n        },\n        // When getting the value of a boxed object member, prefer asyncExtraIterable over target keys\n        get(target, key, receiver) {\n          // If the key is an asyncExtraIterable member, create the mapped queue to generate it\n          if (Object.hasOwn(pds, key)) {\n            if (!path.length) {\n              withoutPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator].a : o);\n              return withoutPath[key as keyof typeof pds];\n            } else {\n              withPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator] : { a: o, path: null });\n\n              let ai = filterMap(withPath, (o, p) => {\n                const v = destructure(o.a, path);\n                return p !== v || o.path === null || o.path.startsWith(path) ? v : Ignore;\n              }, Ignore, destructure(a, path));\n              return ai[key as keyof typeof ai];\n            }\n          }\n\n          // If the key is a target property, create the proxy to handle it\n          if (key === 'valueOf') return () => destructure(a, path);\n          if (key === Symbol.toPrimitive) {\n            // Special case, since Symbol.toPrimitive is in ha(), we need to implement it\n            return function (hint?: 'string' | 'number' | 'default') {\n              if (Reflect.has(target, key))\n                return Reflect.get(target, key, target).call(target, hint);\n              if (hint === 'string') return target.toString();\n              if (hint === 'number') return Number(target);\n              return target.valueOf();\n            }\n          }\n          if (typeof key === 'string') {\n            if ((!(key in target) || Object.hasOwn(target, key)) && !(Iterability in target && target[Iterability] === 'shallow')) {\n              const field = Reflect.get(target, key, receiver);\n              return (typeof field === 'function') || isAsyncIter(field)\n                ? field\n                : new Proxy(Object(field), handler(path + '.' + key));\n            }\n          }\n          // This is a symbolic entry, or a prototypical value (since it's in the target, but not a target property)\n          return Reflect.get(target, key, receiver);\n        }\n      }\n    }\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\nconst forever = new Promise<any>(() => { });\n\n/* Merge asyncIterables into a single asyncIterable */\n\n/* TS hack to expose the return AsyncGenerator a generator of the union of the merged types */\ntype CollapseIterableType<T> = T[] extends Partial<AsyncIterable<infer U>>[] ? U : never;\ntype CollapseIterableTypes<T> = AsyncIterable<CollapseIterableType<T>>;\n\nexport const merge = <A extends Partial<AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>>[], TYield, TReturn, TNext>(...ai: A) => {\n  const it: (undefined | AsyncIterator<any>)[] = new Array(ai.length);\n  const promises: Promise<{ idx: number, result: IteratorResult<any> }>[] = new Array(ai.length);\n\n  let init = () => {\n    init = () => { }\n    for (let n = 0; n < ai.length; n++) {\n      const a = ai[n] as AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>;\n      promises[n] = (it[n] = Symbol.asyncIterator in a\n        ? a[Symbol.asyncIterator]()\n        : a as AsyncIterator<any>)\n        .next()\n        .then(result => ({ idx: n, result }));\n    }\n  }\n\n  const results: (TYield | TReturn)[] = [];\n  let count = promises.length;\n\n  const merged: AsyncIterableIterator<A[number]> = {\n    [Symbol.asyncIterator]() { return merged },\n    next() {\n      init();\n      return count\n        ? Promise.race(promises).then(({ idx, result }) => {\n          if (result.done) {\n            count--;\n            promises[idx] = forever;\n            results[idx] = result.value;\n            // We don't yield intermediate return values, we just keep them in results\n            // return { done: count === 0, value: result.value }\n            return merged.next();\n          } else {\n            // `ex` is the underlying async iteration exception\n            promises[idx] = it[idx]\n              ? it[idx]!.next().then(result => ({ idx, result })).catch(ex => ({ idx, result: { done: true, value: ex } }))\n              : Promise.resolve({ idx, result: { done: true, value: undefined } })\n            return result;\n          }\n        }).catch(ex => {\n          return merged.throw?.(ex) ?? Promise.reject({ done: true as const, value: new Error(\"Iterator merge exception\") });\n        })\n        : Promise.resolve({ done: true as const, value: results });\n    },\n    async return(r) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.return?.({ done: true, value: r }).then(v => v.value, ex => ex);\n        }\n      }\n      return { done: true, value: results };\n    },\n    async throw(ex: any) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.throw?.(ex).then(v => v.value, ex => ex);\n        }\n      }\n      // Because we've passed the exception on to all the sources, we're now done\n      // previously: return Promise.reject(ex);\n      return { done: true, value: results };\n    }\n  };\n  return iterableHelpers(merged as unknown as CollapseIterableTypes<A[number]>);\n}\n\ntype CombinedIterable = { [k: string | number | symbol]: PartialIterable };\ntype CombinedIterableType<S extends CombinedIterable> = {\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n};\ntype CombinedIterableResult<S extends CombinedIterable> = AsyncExtraIterable<{\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n}>;\n\nexport interface CombineOptions {\n  ignorePartial?: boolean; // Set to avoid yielding if some sources are absent\n}\n\nexport const combine = <S extends CombinedIterable>(src: S, opts: CombineOptions = {}): CombinedIterableResult<S> => {\n  const accumulated: CombinedIterableType<S> = {};\n  let pc: Promise<{ idx: number, k: string, ir: IteratorResult<any> }>[];\n  let si: AsyncIterator<any>[] = [];\n  let active: number = 0;\n  const ci = {\n    [Symbol.asyncIterator]() { return ci },\n    next(): Promise<IteratorResult<CombinedIterableType<S>>> {\n      if (pc === undefined) {\n        pc = Object.entries(src).map(([k, sit], idx) => {\n          active += 1;\n          si[idx] = sit[Symbol.asyncIterator]!();\n          return si[idx].next().then(ir => ({ si, idx, k, ir }));\n        });\n      }\n\n      return (function step(): Promise<IteratorResult<CombinedIterableType<S>>> {\n        return Promise.race(pc).then(({ idx, k, ir }) => {\n          if (ir.done) {\n            pc[idx] = forever;\n            active -= 1;\n            if (!active)\n              return { done: true, value: undefined };\n            return step();\n          } else {\n            // @ts-ignore\n            accumulated[k] = ir.value;\n            pc[idx] = si[idx].next().then(ir => ({ idx, k, ir }));\n          }\n          if (opts.ignorePartial) {\n            if (Object.keys(accumulated).length < Object.keys(src).length)\n              return step();\n          }\n          return { done: false, value: accumulated };\n        })\n      })();\n    },\n    return(v?: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].return?.(v)\n        }\n      });\n      return Promise.resolve({ done: true, value: v });\n    },\n    throw(ex: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].throw?.(ex)\n        }\n      });\n      return Promise.reject({ done: true, value: ex });\n    }\n  }\n  return iterableHelpers(ci);\n}\n\n\nfunction isExtraIterable<T>(i: any): i is AsyncExtraIterable<T> {\n  return isAsyncIterable(i)\n    && extraKeys.every(k => (k in i) && (i as any)[k] === asyncExtras[k]);\n}\n\n// Attach the pre-defined helpers onto an AsyncIterable and return the modified object correctly typed\nexport function iterableHelpers<A extends AsyncIterable<any>>(ai: A): A & AsyncExtraIterable<A extends AsyncIterable<infer T> ? T : unknown> {\n  if (!isExtraIterable(ai)) {\n    assignHidden(ai, asyncExtras);\n  }\n  return ai as A extends AsyncIterable<infer T> ? AsyncExtraIterable<T> & A : never\n}\n\nexport function generatorHelpers<G extends (...args: any[]) => R, R extends AsyncGenerator>(g: G) {\n  return function (...args: Parameters<G>): ReturnType<G> {\n    const ai = g(...args);\n    return iterableHelpers(ai) as ReturnType<G>;\n  } as (...args: Parameters<G>) => ReturnType<G> & AsyncExtraIterable<ReturnType<G> extends AsyncGenerator<infer T> ? T : unknown>\n}\n\n/* AsyncIterable helpers, which can be attached to an AsyncIterator with `withHelpers(ai)`, and invoked directly for foreign asyncIterators */\n\n/* types that accept Partials as potentiallu async iterators, since we permit this IN TYPING so\n  iterable properties don't complain on every access as they are declared as V & Partial<AsyncIterable<V>>\n  due to the setters and getters having different types, but undeclarable in TS due to syntax limitations */\ntype HelperAsyncIterable<Q extends Partial<AsyncIterable<any>>> = HelperAsyncIterator<Required<Q>[typeof Symbol.asyncIterator]>;\ntype HelperAsyncIterator<F> =\n  F extends () => AsyncIterator<infer T>\n  ? T : never;\n\nasync function consume<U extends Partial<AsyncIterable<any>>>(this: U, f?: (u: HelperAsyncIterable<U>) => void | PromiseLike<void>): Promise<void> {\n  let last: undefined | void | PromiseLike<void> = undefined;\n  for await (const u of this as AsyncIterable<HelperAsyncIterable<U>>) {\n    last = f?.(u);\n  }\n  await last;\n}\n\ntype Mapper<U, R> = ((o: U, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>);\ntype MaybePromised<T> = PromiseLike<T> | T;\n\n/* A general filter & mapper that can handle exceptions & returns */\nexport const Ignore = Symbol(\"Ignore\");\n\ntype PartialIterable<T = any> = Partial<AsyncIterable<T>>;\n\nfunction resolveSync<Z, R>(v: MaybePromised<Z>, then: (v: Z) => R, except: (x: any) => any): MaybePromised<R> {\n  if (isPromiseLike(v))\n    return v.then(then, except);\n  try { return then(v) } catch (ex) { return except(ex) }\n}\n\nexport function filterMap<U extends PartialIterable, R>(source: U,\n  fn: Mapper<HelperAsyncIterable<U>, R>,\n  initialValue: R | typeof Ignore = Ignore,\n  prev: R | typeof Ignore = Ignore\n): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  const fai: AsyncIterableIterator<R> = {\n    [Symbol.asyncIterator]() {\n      return fai;\n    },\n\n    next(...args: [] | [undefined]) {\n      if (initialValue !== Ignore) {\n        const init = Promise.resolve({ done: false, value: initialValue });\n        initialValue = Ignore;\n        return init;\n      }\n\n      return new Promise<IteratorResult<R>>(function step(resolve, reject) {\n        if (!ai)\n          ai = source[Symbol.asyncIterator]!();\n        ai.next(...args).then(\n          p => p.done\n            ? resolve(p)\n            : resolveSync(fn(p.value, prev),\n              f => f === Ignore\n                ? step(resolve, reject)\n                : resolve({ done: false, value: prev = f }),\n              ex => {\n                // The filter function failed...\n                ai.throw ? ai.throw(ex) : ai.return?.(ex) // Terminate the source - for now we ignore the result of the termination\n                reject({ done: true, value: ex }); // Terminate the consumer\n              }\n            ),\n\n          ex =>\n            // The source threw. Tell the consumer\n            reject({ done: true, value: ex })\n        ).catch(ex => {\n          // The callback threw\n          ai.throw ? ai.throw(ex) : ai.return?.(ex); // Terminate the source - for now we ignore the result of the termination\n          reject({ done: true, value: ex })\n        })\n      })\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(fai)\n}\n\nfunction map<U extends PartialIterable, R>(this: U, mapper: Mapper<HelperAsyncIterable<U>, R>): AsyncExtraIterable<R> {\n  return filterMap(this, mapper);\n}\n\nfunction filter<U extends PartialIterable>(this: U, fn: (o: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, async o => (await fn(o) ? o : Ignore));\n}\n\nfunction unique<U extends PartialIterable>(this: U, fn?: (next: HelperAsyncIterable<U>, prev: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return fn\n    ? filterMap(this, async (o, p) => (p === Ignore || await fn(o, p)) ? o : Ignore)\n    : filterMap(this, (o, p) => o === p ? Ignore : o);\n}\n\nfunction initially<U extends PartialIterable, I = HelperAsyncIterable<U>>(this: U, initValue: I): AsyncExtraIterable<HelperAsyncIterable<U> | I> {\n  return filterMap(this, o => o, initValue);\n}\n\nfunction waitFor<U extends PartialIterable>(this: U, cb: (done: (value: void | PromiseLike<void>) => void) => void): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, o => new Promise<HelperAsyncIterable<U>>(resolve => { cb(() => resolve(o)); return o }));\n}\n\nfunction multi<U extends PartialIterable>(this: U): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  type T = HelperAsyncIterable<U>;\n  const source = this;\n  let consumers = 0;\n  let current: DeferredPromise<IteratorResult<T, any>>;\n  let ai: AsyncIterator<T, any, undefined> | undefined = undefined;\n\n  // The source has produced a new result\n  function step(it?: IteratorResult<T, any>) {\n    if (it) current.resolve(it);\n    if (!it?.done) {\n      current = deferred<IteratorResult<T>>();\n      ai!.next()\n        .then(step)\n        .catch(error => current.reject({ done: true, value: error }));\n    }\n  }\n\n  const mai: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      consumers += 1;\n      return mai;\n    },\n\n    next() {\n      if (!ai) {\n        ai = source[Symbol.asyncIterator]!();\n        step();\n      }\n      return current//.then(zalgo => zalgo);\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source if we're the final one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: ex });\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source if we're the only one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: v });\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(mai);\n}\n\nexport function augmentGlobalAsyncGenerators() {\n  let g = (async function* () { })();\n  while (g) {\n    const desc = Object.getOwnPropertyDescriptor(g, Symbol.asyncIterator);\n    if (desc) {\n      iterableHelpers(g);\n      break;\n    }\n    g = Object.getPrototypeOf(g);\n  }\n  if (!g) {\n    console.warn(\"Failed to augment the prototype of `(async function*())()`\");\n  }\n}\n\n", "import { DEBUG, console, timeOutWarn } from './debug.js';\nimport { isPromiseLike } from './deferred.js';\nimport { iterableHelpers, merge, AsyncExtraIterable, queueIteratableIterator } from \"./iterators.js\";\n\n/*\n  `when(....)` is both an AsyncIterable of the events it can generate by observation,\n  and a function that can map those events to a specified type, eg:\n\n  this.when('keyup:#elemet') => AsyncIterable<KeyboardEvent>\n  this.when('#elemet')(e => e.target) => AsyncIterable<EventTarget>\n*/\n// Varargs type passed to \"when\"\nexport type WhenParameters<IDS extends string = string> = ReadonlyArray<\n  AsyncIterable<any>\n  | ValidWhenSelector<IDS>\n  | Element /* Implies \"change\" event */\n  | Promise<any> /* Just gets wrapped in a single `yield` */\n>;\n\n// The Iterated type generated by \"when\", based on the parameters\ntype WhenIteratedType<S extends WhenParameters> =\n  (Extract<S[number], AsyncIterable<any>> extends AsyncIterable<infer I> ? unknown extends I ? never : I : never)\n  | ExtractEvents<Extract<S[number], string>>\n  | (Extract<S[number], Element> extends never ? never : Event)\n\ntype MappableIterable<A extends AsyncIterable<any>> =\n  A extends AsyncIterable<infer T> ?\n    A & AsyncExtraIterable<T> &\n    (<R>(mapper: (value: A extends AsyncIterable<infer T> ? T : never) => R) => (AsyncExtraIterable<Awaited<R>>))\n  : never;\n\n// The extended iterator that supports async iterator mapping, chaining, etc\nexport type WhenReturn<S extends WhenParameters> =\n  MappableIterable<\n    AsyncExtraIterable<\n      WhenIteratedType<S>>>;\n\ntype EmptyObject = Record<string | symbol | number, never>;\n\ntype SpecialWhenEvents = {\n  \"@start\": EmptyObject,  // Always fires when referenced\n  \"@ready\": EmptyObject   // Fires when all Element specified sources are mounted in the DOM\n};\ntype WhenEvents = GlobalEventHandlersEventMap & SpecialWhenEvents;\ntype EventNameList<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : `${S},${EventNameList<R>}`\n  : never;\n\ntype EventNameUnion<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : S | EventNameList<R>\n  : never;\n\n\ntype EventAttribute = `${keyof GlobalEventHandlersEventMap}`\ntype CSSIdentifier<IDS extends string = string> = `#${IDS}` |`.${string}` | `[${string}]`\n\n/* ValidWhenSelectors are:\n    @start\n    @ready\n    event:selector\n    event           \"this\" element, event type='event'\n    selector        specificed selectors, implies \"change\" event\n*/\n\nexport type ValidWhenSelector<IDS extends string = string> = `${keyof SpecialWhenEvents}`\n  | `${EventAttribute}:${CSSIdentifier<IDS>}`\n  | EventAttribute\n  | CSSIdentifier<IDS>;\n\ntype IsValidWhenSelector<S>\n  = S extends ValidWhenSelector ? S : never;\n\ntype ExtractEventNames<S>\n  = S extends keyof SpecialWhenEvents ? S\n  : S extends `${infer V}:${infer L extends CSSIdentifier}`\n  ? EventNameUnion<V> extends never ? never : EventNameUnion<V>\n  : S extends `${infer L extends CSSIdentifier}`\n  ? 'change'\n  : never;\n\ntype ExtractEvents<S> = WhenEvents[ExtractEventNames<S>];\n\n/** when **/\ntype EventObservation<EventName extends keyof GlobalEventHandlersEventMap> = {\n  push: (ev: GlobalEventHandlersEventMap[EventName])=>void;\n  terminate: (ex: Error)=>void;\n  container: Element\n  selector: string | null\n};\nconst eventObservations = new WeakMap<Document, Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  if (!eventObservations.has(this))\n    eventObservations.set(this, new Map());\n\n  const observations = eventObservations.get(this)!.get(ev.type as keyof GlobalEventHandlersEventMap);\n  if (observations) {\n    for (const o of observations) {\n      try {\n        const { push, terminate, container, selector } = o;\n        if (!container.isConnected) {\n          const msg = \"Container `#\" + container.id + \">\" + (selector || '') + \"` removed from DOM. Removing subscription\";\n          observations.delete(o);\n          terminate(new Error(msg));\n        } else {\n          if (ev.target instanceof Node) {\n            if (selector) {\n              const nodes = container.querySelectorAll(selector);\n              for (const n of nodes) {\n                if ((ev.target === n || n.contains(ev.target)) && container.contains(n))\n                  push(ev)\n              }\n            } else {\n              if ((ev.target === container || container.contains(ev.target)))\n                push(ev)\n            }\n          }\n        }\n      } catch (ex) {\n        console.warn('docEventHandler', ex);\n      }\n    }\n  }\n}\n\nfunction isCSSSelector(s: string): s is CSSIdentifier {\n  return Boolean(s && (s.startsWith('#') || s.startsWith('.') || (s.startsWith('[') && s.endsWith(']'))));\n}\n\nfunction parseWhenSelector<EventName extends string>(what: IsValidWhenSelector<EventName>): undefined | [CSSIdentifier | null, keyof GlobalEventHandlersEventMap] {\n  const parts = what.split(':');\n  if (parts.length === 1) {\n    if (isCSSSelector(parts[0]))\n      return [parts[0],\"change\"];\n    return [null, parts[0] as keyof GlobalEventHandlersEventMap];\n  }\n  if (parts.length === 2) {\n    if (isCSSSelector(parts[1]) && !isCSSSelector(parts[0]))\n    return [parts[1], parts[0] as keyof GlobalEventHandlersEventMap]\n  }\n  return undefined;\n}\n\nfunction doThrow(message: string):never {\n  throw new Error(message);\n}\n\nfunction whenEvent<EventName extends string>(container: Element, what: IsValidWhenSelector<EventName>) {\n  const [selector, eventName] = parseWhenSelector(what) ?? doThrow(\"Invalid WhenSelector: \"+what);\n\n  if (!eventObservations.has(container.ownerDocument))\n    eventObservations.set(container.ownerDocument, new Map());\n\n  if (!eventObservations.get(container.ownerDocument)!.has(eventName)) {\n    container.ownerDocument.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.get(container.ownerDocument)!.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.get(container.ownerDocument)?.get(eventName)?.delete(details));\n\n  const details: EventObservation<keyof GlobalEventHandlersEventMap> /*EventObservation<Exclude<ExtractEventNames<EventName>, keyof SpecialWhenEvents>>*/ = {\n    push: queue.push,\n    terminate(ex: Error) { queue.return?.(ex)},\n    container,\n    selector: selector || null\n  };\n\n  containerAndSelectorsMounted(container, selector ? [selector] : undefined)\n    .then(_ => eventObservations.get(container.ownerDocument)?.get(eventName)!.add(details));\n\n  return queue.multi() ;\n}\n\nasync function* neverGonnaHappen<Z>(): AsyncIterableIterator<Z> {\n  await new Promise(() => {});\n  yield undefined as Z; // Never should be executed\n}\n\n/* Syntactic sugar: chainAsync decorates the specified iterator so it can be mapped by\n  a following function, or used directly as an iterable */\nfunction chainAsync<A extends AsyncExtraIterable<X>, X>(src: A): MappableIterable<A> {\n  function mappableAsyncIterable(mapper: Parameters<typeof src.map>[0]) {\n    return src.map(mapper);\n  }\n\n  return Object.assign(iterableHelpers(mappableAsyncIterable as unknown as AsyncIterable<A>), {\n    [Symbol.asyncIterator]: () => src[Symbol.asyncIterator]()\n  }) as MappableIterable<A>;\n}\n\nfunction isValidWhenSelector(what: WhenParameters[number]): what is ValidWhenSelector {\n  if (!what)\n    throw new Error('Falsy async source will never be ready\\n\\n' + JSON.stringify(what));\n  return typeof what === 'string' && what[0] !== '@' && Boolean(parseWhenSelector(what));\n}\n\nasync function* once<T>(p: Promise<T>) {\n  yield p;\n}\n\nexport function when<S extends WhenParameters>(container: Element, ...sources: S): WhenReturn<S> {\n  if (!sources || sources.length === 0) {\n    return chainAsync(whenEvent(container, \"change\")) as unknown as WhenReturn<S>;\n  }\n\n  const iterators = sources.filter(what => typeof what !== 'string' || what[0] !== '@').map(what => typeof what === 'string'\n    ? whenEvent(container, what)\n    : what instanceof Element\n      ? whenEvent(what, \"change\")\n      : isPromiseLike(what)\n        ? once(what)\n        : what);\n\n  if (sources.includes('@start')) {\n    const start: AsyncIterableIterator<{}> = {\n      [Symbol.asyncIterator]: () => start,\n      next() {\n        start.next = () => Promise.resolve({ done: true, value: undefined })\n        return Promise.resolve({ done: false, value: {} })\n      }\n    };\n    iterators.push(start);\n  }\n\n  if (sources.includes('@ready')) {\n    const watchSelectors = sources.filter(isValidWhenSelector).map(what => parseWhenSelector(what)?.[0]);\n\n    function isMissing(sel: CSSIdentifier | null | undefined): sel is CSSIdentifier {\n      return Boolean(typeof sel === 'string' && !container.querySelector(sel));\n    }\n\n    const missing = watchSelectors.filter(isMissing);\n\n    let events: AsyncIterator<any, any, undefined> | undefined = undefined;\n    const ai: AsyncIterableIterator<any> = {\n      [Symbol.asyncIterator]() { return ai },\n      throw(ex: any) {\n        if (events?.throw) return events.throw(ex);\n        return Promise.resolve({ done: true, value: ex });\n      },\n      return(v?: any) {\n        if (events?.return) return events.return(v);\n        return Promise.resolve({ done: true, value: v });\n      },\n      next() {\n        if (events) return events.next();\n\n        return containerAndSelectorsMounted(container, missing).then(() => {\n          const merged = (iterators.length > 1)\n          ? merge(...iterators)\n          : iterators.length === 1\n            ? iterators[0]\n            : (neverGonnaHappen<WhenIteratedType<S>>());\n\n          // Now everything is ready, we simply delegate all async ops to the underlying\n          // merged asyncIterator \"events\"\n          events = merged[Symbol.asyncIterator]();\n          if (!events)\n            return { done: true, value: undefined };\n\n          return { done: false, value: {} };\n        });\n      }\n    };\n    return chainAsync(iterableHelpers(ai));\n  }\n\n  const merged = (iterators.length > 1)\n    ? merge(...iterators)\n    : iterators.length === 1\n      ? iterators[0]\n      : (neverGonnaHappen<WhenIteratedType<S>>());\n\n  return chainAsync(iterableHelpers(merged));\n}\n\nfunction elementIsInDOM(elt: Element): Promise<void> {\n  if (elt.isConnected)\n    return Promise.resolve();\n\n  return new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (elt.isConnected) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(elt.ownerDocument.body, {\n    subtree: true,\n    childList: true\n  }));\n}\n\nfunction containerAndSelectorsMounted(container: Element, selectors?: string[]) {\n  if (selectors?.length)\n    return Promise.all([\n      allSelectorsPresent(container, selectors),\n      elementIsInDOM(container)\n    ]);\n  return elementIsInDOM(container);\n}\n\nfunction allSelectorsPresent(container: Element, missing: string[]): Promise<void> {\n  missing = missing.filter(sel => !container.querySelector(sel))\n  if (!missing.length) {\n    return Promise.resolve(); // Nothing is missing\n  }\n\n  const promise = new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (missing.every(sel => container.querySelector(sel))) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(container, {\n    subtree: true,\n    childList: true\n  }));\n\n  /* debugging help: warn if waiting a long time for a selectors to be ready */\n  if (DEBUG) {\n    const stack = new Error().stack?.replace(/^Error/, \"Missing selectors after 5 seconds:\");\n    const warnTimer = setTimeout(() => {\n      console.warn(stack, missing);\n    }, timeOutWarn);\n\n    promise.finally(() => clearTimeout(warnTimer))\n  }\n\n  return promise;\n}\n"],
  "mappings": "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",
  "names": ["v", "a", "result", "ex", "ir", "isMissing", "merged", "unique", "c", "n", "value", "isAncestral", "children"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/ai-ui.ts", "../src/debug.ts", "../src/deferred.ts", "../src/iterators.ts", "../src/when.ts"],
  "sourcesContent": ["import { isPromiseLike } from './deferred.js';\nimport { Ignore, asyncIterator, defineIterableProperty, isAsyncIter, isAsyncIterator } from './iterators.js';\nimport { WhenParameters, WhenReturn, when } from './when.js';\nimport { DEBUG, console, timeOutWarn } from './debug.js';\nimport type { ChildTags, Constructed, Instance, Overrides, TagCreationOptions, TagCreator, TagCreatorFunction } from './tags.js';\n\n/* Export useful stuff for users of the bundled code */\nexport { when } from './when.js';\nexport type { ChildTags, Instance, TagCreator, TagCreatorFunction } from './tags.js'\nexport * as Iterators from './iterators.js';\n\nexport const UniqueID = Symbol(\"Unique ID\");\n\nconst logNode = DEBUG ? ((n: Node) => `\"${'innerHTML' in n ? n.innerHTML : n.textContent}\"`) : (n: Node) => undefined;\n\n/* A holder for commonProperties specified when `tag(...p)` is invoked, which are always\n  applied (mixed in) when an element is created */\ntype TagFunctionOptions<OtherMembers extends Record<string | symbol, any> = {}> = {\n  commonProperties?: OtherMembers\n  document?: Document\n  /** @deprecated - legacy support */\n  enableOnRemovedFromDOM?: boolean\n}\n\n/* Members applied to EVERY tag created, even base tags */\ninterface PoElementMethods {\n  get ids(): {}\n  when<T extends Element & PoElementMethods, S extends WhenParameters<Exclude<keyof T['ids'], number | symbol>>>(this: T, ...what: S): WhenReturn<S>;\n  // This is a very incomplete type. In practice, set(attrs) requires a deeply partial set of\n  // attributes, in exactly the same way as a TagFunction's first object parameter\n  set attributes(attrs: object);\n  get attributes(): NamedNodeMap\n}\n\n// Support for https://www.npmjs.com/package/htm (or import htm from 'https://cdn.jsdelivr.net/npm/htm/dist/htm.module.js')\n// Note: same signature as React.createElement\nexport interface CreateElement {\n  // Support for htm, JSX, etc\n  createElement(\n    // \"name\" can a HTML tag string, an existing node (just returns itself), or a tag function\n    name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n    // The attributes used to initialise the node (if a string or function - ignore if it's already a node)\n    attrs: any,\n    // The children\n    ...children: ChildTags[]): Node;\n}\n\n/* The interface that creates a set of TagCreators for the specified DOM tags */\nexport interface TagLoader {\n  nodes(...c: ChildTags[]): (Node | (/*P &*/ (Element & PoElementMethods)))[];\n  UniqueID: typeof UniqueID\n\n  /*\n   Signatures for the tag loader. All params are optional in any combination,\n   but must be in order:\n      tag(\n          ?nameSpace?: string,  // absent nameSpace implies HTML\n          ?tags?: string[],     // absent tags defaults to all common HTML tags\n          ?commonProperties?: CommonPropertiesConstraint // absent implies none are defined\n      )\n\n      eg:\n        tags()  // returns TagCreators for all HTML tags\n        tags(['div','button'], { myThing() {} })\n        tags('http://namespace',['Foreign'], { isForeign: true })\n  */\n\n  <Tags extends keyof HTMLElementTagNameMap>(): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap>(tags: Tags[]): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(tags: Tags[], options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: null | undefined | '', tags: Tags[], options?: TagFunctionOptions<Q>): { [k in Tags]: TagCreator<Q & PoElementMethods & HTMLElement> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: string, tags: Tags[], options?: TagFunctionOptions<Q>): Record<string, TagCreator<Q & PoElementMethods & Element>> & CreateElement\n}\n\nlet idCount = 0;\nconst standandTags = [\n  \"a\", \"abbr\", \"address\", \"area\", \"article\", \"aside\", \"audio\", \"b\", \"base\", \"bdi\", \"bdo\", \"blockquote\", \"body\", \"br\", \"button\",\n  \"canvas\", \"caption\", \"cite\", \"code\", \"col\", \"colgroup\", \"data\", \"datalist\", \"dd\", \"del\", \"details\", \"dfn\", \"dialog\", \"div\",\n  \"dl\", \"dt\", \"em\", \"embed\", \"fieldset\", \"figcaption\", \"figure\", \"footer\", \"form\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\",\n  \"header\", \"hgroup\", \"hr\", \"html\", \"i\", \"iframe\", \"img\", \"input\", \"ins\", \"kbd\", \"label\", \"legend\", \"li\", \"link\", \"main\", \"map\",\n  \"mark\", \"menu\", \"meta\", \"meter\", \"nav\", \"noscript\", \"object\", \"ol\", \"optgroup\", \"option\", \"output\", \"p\", \"picture\", \"pre\",\n  \"progress\", \"q\", \"rp\", \"rt\", \"ruby\", \"s\", \"samp\", \"script\", \"search\", \"section\", \"select\", \"slot\", \"small\", \"source\", \"span\",\n  \"strong\", \"style\", \"sub\", \"summary\", \"sup\", \"table\", \"tbody\", \"td\", \"template\", \"textarea\", \"tfoot\", \"th\", \"thead\", \"time\",\n  \"title\", \"tr\", \"track\", \"u\", \"ul\", \"var\", \"video\", \"wbr\"\n] as const;\n\nfunction idsInaccessible(): never {\n  throw new Error(\"<elt>.ids is a read-only map of Elements\")\n}\n\nfunction isChildTag(x: any): x is ChildTags {\n  return typeof x === 'string'\n    || typeof x === 'number'\n    || typeof x === 'boolean'\n    || x instanceof Node\n    || x instanceof NodeList\n    || x instanceof HTMLCollection\n    || x === null\n    || x === undefined\n    // Can't actually test for the contained type, so we assume it's a ChildTag and let it fail at runtime\n    || Array.isArray(x)\n    || isPromiseLike(x)\n    || isAsyncIter(x)\n    || (typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function');\n}\n\n/* tag */\nconst callStackSymbol = Symbol('callStack');\n\nexport const tag = <TagLoader>function <Tags extends string,\n  T1 extends (string | Tags[] | TagFunctionOptions<Q>),\n  T2 extends (Tags[] | TagFunctionOptions<Q>),\n  Q extends {}\n>(\n  _1: T1,\n  _2: T2,\n  _3?: TagFunctionOptions<Q>\n): Record<string, TagCreator<Q & Element>> {\n  type NamespacedElementBase = T1 extends string ? T1 extends '' ? HTMLElement : Element : HTMLElement;\n\n  /* Work out which parameter is which. There are 6 variations:\n    tag()                                           []\n    tag(commonProperties)                           [object]\n    tag(tags[])                                     [string[]]\n    tag(tags[], commonProperties)                   [string[], object]\n    tag(namespace | null, tags[])                   [string | null, string[]]\n    tag(namespace | null, tags[], commonProperties) [string | null, string[], object]\n  */\n  const [nameSpace, tags, options] = (typeof _1 === 'string') || _1 === null\n    ? [_1, _2 as Tags[], _3 as TagFunctionOptions<Q>]\n    : Array.isArray(_1)\n      ? [null, _1 as Tags[], _2 as TagFunctionOptions<Q>]\n      : [null, standandTags, _1 as TagFunctionOptions<Q>];\n\n  const commonProperties = options?.commonProperties;\n  const thisDoc = options?.document ?? globalThis.document;\n\n  const removedNodes = mutationTracker(thisDoc, 'removedNodes', options?.enableOnRemovedFromDOM);\n\n  function DomPromiseContainer() {\n    return thisDoc.createComment(DEBUG\n      ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\"\n      : \"promise\")\n  }\n\n  function DyamicElementError({ error }: { error: Error | IteratorResult<Error> }) {\n    return thisDoc.createComment(error instanceof Error ? error.toString() : 'Error:\\n' + JSON.stringify(error, null, 2));\n  }\n  const poStyleElt = thisDoc.createElement(\"STYLE\");\n  poStyleElt.id = \"--ai-ui-extended-tag-styles-\";\n\n  /* Properties applied to every tag which can be implemented by reference, similar to prototypes */\n  const warned = new Set<string>();\n  const tagPrototypes: PoElementMethods = Object.create(\n    null,\n    {\n      when: {\n        writable: false,\n        configurable: true,\n        enumerable: false,\n        value: function (...what: WhenParameters) {\n          return when(this, ...what)\n        }\n      },\n      attributes: {\n        ...Object.getOwnPropertyDescriptor(Element.prototype, 'attributes'),\n        set(this: Element, a: object) {\n          if (isAsyncIter(a)) {\n            const ai = isAsyncIterator(a) ? a : a[Symbol.asyncIterator]();\n            const step = () => ai.next().then(\n              ({ done, value }) => { assignProps(this, value); done || step() },\n              ex => console.warn(ex));\n            step();\n          }\n          else assignProps(this, a);\n        }\n      },\n      ids: {\n        // .ids is a getter that when invoked for the first time\n        // lazily creates a Proxy that provides live access to children by id\n        configurable: true,\n        enumerable: true,\n        set: idsInaccessible,\n        get(this: Element) {\n          // Now we've been accessed, create the proxy\n          const idProxy = new Proxy(Object.create(null) as Record<string, WeakRef<Element>>, {\n            apply: idsInaccessible,\n            construct: idsInaccessible,\n            defineProperty: idsInaccessible,\n            deleteProperty: idsInaccessible,\n            set: idsInaccessible,\n            setPrototypeOf: idsInaccessible,\n            getPrototypeOf() { return null },\n            isExtensible() { return false },\n            preventExtensions() { return true },\n            getOwnPropertyDescriptor(target, p) {\n              if (this.get!(target, p, null))\n                return Reflect.getOwnPropertyDescriptor(target, p);\n            },\n            has(target, p) {\n              const r = this.get!(target, p, null);\n              return Boolean(r);\n            },\n            ownKeys: (target) => {\n              const ids = [...this.querySelectorAll(`[id]`)].map(e => e.id);\n              const unique = [...new Set(ids)];\n              if (DEBUG && ids.length !== unique.length)\n                console.log(`Element contains multiple, shadowed decendant ids`, unique);\n              return unique;\n            },\n            get: (target, p, receiver) => {\n              if (typeof p === 'string') {\n                // Check if we've cached this ID already\n                if (p in target) {\n                  // Check the element is still contained within this element with the same ID\n                  const ref = target[p].deref();\n                  if (ref && ref.id === p && this.contains(ref))\n                    return ref;\n                  delete target[p];\n                }\n                let e: Element | undefined;\n                if (DEBUG) {\n                  const nl = this.querySelectorAll('#' + CSS.escape(p));\n                  if (nl.length > 1) {\n                    if (!warned.has(p)) {\n                      warned.add(p);\n                      console.log(`Element contains multiple, shadowed decendants with ID \"${p}\"`/*,`\\n\\t${logNode(this)}`*/);\n                    }\n                  }\n                  e = nl[0];\n                } else {\n                  e = this.querySelector('#' + CSS.escape(p)) ?? undefined;\n                }\n                if (e) target[p] = new WeakRef(e);\n                return e;\n              }\n            }\n          });\n          // ..and replace the getter with the Proxy\n          Object.defineProperty(this, 'ids', {\n            configurable: true,\n            enumerable: true,\n            set: idsInaccessible,\n            get() { return idProxy }\n          });\n          // ...and return that from the getter, so subsequent property\n          // accesses go via the Proxy\n          return idProxy;\n        }\n      }\n    }\n  );\n\n  /* Add any user supplied prototypes */\n  if (commonProperties)\n    deepDefine(tagPrototypes, commonProperties);\n\n  function nodes(...c: ChildTags[]) {\n    const appended: Node[] = [];\n    (function children(c: ChildTags): void {\n      if (c === undefined || c === null || c === Ignore)\n        return;\n      if (isPromiseLike(c)) {\n        const g: ChildNode = DomPromiseContainer();\n        appended.push(g);\n        c.then(r => g.replaceWith(...nodes(r)),\n          (x: any) => {\n            console.warn(x, logNode(g));\n            g.replaceWith(DyamicElementError({ error: x }));\n          }\n        );\n        return;\n      }\n      if (c instanceof Node) {\n        appended.push(c);\n        return;\n      }\n\n      // We have an interesting case here where an iterable String is an object with both Symbol.iterator\n      // (inherited from the String prototype) and Symbol.asyncIterator (as it's been augmented by boxed())\n      // but we're only interested in cases like HTMLCollection, NodeList, array, etc., not the fukny ones\n      // It used to be after the isAsyncIter() test, but a non-AsyncIterator *may* also be a sync iterable\n      // For now, we exclude (Symbol.asyncIterator in c) in this case.\n      if (c && typeof c === 'object' && Symbol.iterator in c && !(Symbol.asyncIterator in c) && c[Symbol.iterator]) {\n        for (const d of c) children(d);\n        return;\n      }\n\n      if (isAsyncIter<ChildTags>(c)) {\n        const insertionStack = DEBUG ? ('\\n' + new Error().stack?.replace(/^Error: /, \"Insertion :\")) : '';\n        const ap = isAsyncIterator(c) ? c : c[Symbol.asyncIterator]();\n        // It's possible that this async iterator is a boxed object that also holds a value\n        const unboxed = c.valueOf();\n        const dpm = (unboxed === undefined || unboxed === c) ? [DomPromiseContainer()] : nodes(unboxed as ChildTags)\n\n        let t = dpm.length ? dpm : [DomPromiseContainer()];\n        appended.push(...t);\n        let notYetMounted = true;\n        // DEBUG support\n        let createdAt = Date.now() + timeOutWarn;\n        const createdBy = DEBUG && new Error(\"Created by\").stack;\n\n        const error = (errorValue: any) => {\n          const n = t.filter(n => Boolean(n?.parentNode)) as ChildNode[];\n          if (n.length) {\n            t = [DyamicElementError({ error: errorValue })];\n            n[0].replaceWith(...t);\n            n.slice(1).forEach(e => e?.parentNode!.removeChild(e));\n          }\n          else console.warn(\"Can't report error\", errorValue, createdBy, t.map(logNode));\n          t = [];\n          ap.return?.(errorValue);\n        }\n\n        const update = (es: IteratorResult<ChildTags>) => {\n          if (!es.done) {\n            try {\n              // ChildNode[], since we tested .parentNode\n              const mounted = t.filter(e => e?.parentNode && e.isConnected);\n              const n = notYetMounted ? t : mounted;\n              if (mounted.length) notYetMounted = false;\n\n              if (!n.length || t.every(e => removedNodes(e))) {\n                // We're done - terminate the source quietly (ie this is not an exception as it's expected, but we're done)\n                t = [];\n                const msg = \"Element(s) have been removed from the document: \" + insertionStack;\n                ap.return?.(new Error(msg));\n                return;\n              }\n\n              if (DEBUG && notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Async element not mounted after 5 seconds. If it is never mounted, it will leak.`, createdBy, t.map(logNode));\n              }\n              t = nodes(unbox(es.value) as ChildTags);\n              // If the iterated expression yields no nodes, stuff in a DomPromiseContainer for the next iteration\n              if (!t.length) t.push(DomPromiseContainer());\n              (n[0] as ChildNode).replaceWith(...t);\n              n.slice(1).forEach(e => !t.includes(e) && e.parentNode?.removeChild(e));\n              ap.next().then(update).catch(error);\n            } catch (ex) {\n              // Something went wrong. Terminate the iterator source\n              t = [];\n              ap.return?.(ex);\n            }\n          }\n        }\n        ap.next().then(update).catch(error);\n        return;\n      }\n      appended.push(thisDoc.createTextNode(c.toString()));\n    })(c);\n    return appended;\n  }\n\n  if (!nameSpace) {\n    Object.assign(tag, {\n      nodes,    // Build DOM Node[] from ChildTags\n      UniqueID\n    });\n  }\n\n  /** Just deep copy an object */\n  const plainObjectPrototype = Object.getPrototypeOf({});\n  /** Routine to *define* properties on a dest object from a src object **/\n  function deepDefine(d: Record<string | symbol | number, any>, s: any, declaration?: true): void {\n    if (s === null || s === undefined || typeof s !== 'object' || s === d)\n      return;\n\n    for (const [k, srcDesc] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      try {\n        if ('value' in srcDesc) {\n          const value = srcDesc.value;\n\n          if (value && isAsyncIter<unknown>(value)) {\n            Object.defineProperty(d, k, srcDesc);\n          } else {\n            // This has a real value, which might be an object, so we'll deepDefine it unless it's a\n            // Promise or a function, in which case we just assign it\n            if (value && typeof value === 'object' && !isPromiseLike(value)) {\n              if (!(k in d)) {\n                // If this is a new value in the destination, just define it to be the same value as the source\n                // If the source value is an object, and we're declaring it (therefore it should be a new one), take\n                // a copy so as to not re-use the reference and pollute the declaration. Note: this is probably\n                // a better default for any \"objects\" in a declaration that are plain and not some class type\n                // which can't be copied\n                if (declaration) {\n                  if (Object.getPrototypeOf(value) === plainObjectPrototype || !Object.getPrototypeOf(value)) {\n                    // A plain object can be deep-copied by field\n                    deepDefine(srcDesc.value = {}, value);\n                  } else if (Array.isArray(value)) {\n                    // An array can be deep copied by index\n                    deepDefine(srcDesc.value = [], value);\n                  } else {\n                    // Other object like things (regexps, dates, classes, etc) can't be deep-copied reliably\n                    console.warn(`Declared propety '${k}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`, d, value);\n                  }\n                }\n                Object.defineProperty(d, k, srcDesc);\n              } else {\n                if (value instanceof Node) {\n                  console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child\", k, logNode(value));\n                  d[k] = value;\n                } else {\n                  if (d[k] !== value) {\n                    // Note - if we're copying to an array of different length\n                    // we're decoupling common object references, so we need a clean object to\n                    // assign into\n                    if (Array.isArray(d[k]) && d[k].length !== value.length) {\n                      if (value.constructor === Object || value.constructor === Array) {\n                        deepDefine(d[k] = new (value.constructor), value);\n                      } else {\n                        // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                        d[k] = value;\n                      }\n                    } else {\n                      // This is just a regular object, so we deepDefine recursively\n                      deepDefine(d[k], value);\n                    }\n                  }\n                }\n              }\n            } else {\n              // This is just a primitive value, or a Promise\n              if (s[k] !== undefined)\n                d[k] = s[k];\n            }\n          }\n        } else {\n          // Copy the definition of the getter/setter\n          Object.defineProperty(d, k, srcDesc);\n        }\n      } catch (ex: unknown) {\n        console.warn(\"deepAssign\", k, s[k], ex);\n        throw ex;\n      }\n    }\n  }\n\n  function unbox(a: unknown): unknown {\n    const v = a?.valueOf();\n    return Array.isArray(v) ? Array.prototype.map.call(v, unbox) : v;\n  }\n\n  function assignProps(base: Node, props: Record<string, any>) {\n    // Copy prop hierarchy onto the element via the asssignment operator in order to run setters\n    if (!(callStackSymbol in props)) {\n      (function assign(d: any, s: any): void {\n        if (s === null || s === undefined || typeof s !== 'object')\n          return;\n        // static props before getters/setters\n        const sourceEntries = Object.entries(Object.getOwnPropertyDescriptors(s));\n        if (!Array.isArray(s)) {\n          sourceEntries.sort(a => {\n            const desc = Object.getOwnPropertyDescriptor(d, a[0]);\n            if (desc) {\n              if ('value' in desc) return -1;\n              if ('set' in desc) return 1;\n              if ('get' in desc) return 1;\n            }\n            return 0;\n          });\n        }\n        for (const [k, srcDesc] of sourceEntries) {\n          try {\n            if ('value' in srcDesc) {\n              const value = srcDesc.value;\n              if (isAsyncIter<unknown>(value)) {\n                assignIterable(value, k);\n              } else if (isPromiseLike(value)) {\n                value.then(v => {\n                  if (v && typeof v === 'object') {\n                    // Special case: this promise resolved to an async iterator\n                    if (isAsyncIter<unknown>(v)) {\n                      assignIterable(v, k);\n                    } else {\n                      assignObject(v, k);\n                    }\n                  } else {\n                    if (s[k] !== undefined)\n                      d[k] = v;\n                  }\n                }, error => console.log(\"Failed to set attribute\", error));\n              } else if (!isAsyncIter<unknown>(value)) {\n                // This has a real value, which might be an object\n                if (value && typeof value === 'object' && !isPromiseLike(value))\n                  assignObject(value, k);\n                else {\n                  if (s[k] !== undefined)\n                    d[k] = s[k];\n                }\n              }\n            } else {\n              // Copy the definition of the getter/setter\n              Object.defineProperty(d, k, srcDesc);\n            }\n          } catch (ex: unknown) {\n            console.warn(\"assignProps\", k, s[k], ex);\n            throw ex;\n          }\n        }\n\n        function assignIterable(value: AsyncIterable<unknown> | AsyncIterator<unknown, any, undefined>, k: string) {\n          const ap = asyncIterator(value);\n          let notYetMounted = true;\n          // DEBUG support\n          let createdAt = Date.now() + timeOutWarn;\n          const createdBy = DEBUG && new Error(\"Created by\").stack;\n          const update = (es: IteratorResult<unknown>) => {\n            if (!es.done) {\n              const value = unbox(es.value);\n              if (typeof value === 'object' && value !== null) {\n                /*\n              THIS IS JUST A HACK: `style` has to be set member by member, eg:\n                e.style.color = 'blue'        --- works\n                e.style = { color: 'blue' }   --- doesn't work\n              whereas in general when assigning to property we let the receiver\n              do any work necessary to parse the object. This might be better handled\n              by having a setter for `style` in the PoElementMethods that is sensitive\n              to the type (string|object) being passed so we can just do a straight\n              assignment all the time, or making the decsion based on the location of the\n              property in the prototype chain and assuming anything below \"PO\" must be\n              a primitive\n              */\n                const destDesc = Object.getOwnPropertyDescriptor(d, k);\n                if (k === 'style' || !destDesc?.set)\n                  assign(d[k], value);\n                else\n                  d[k] = value;\n              } else {\n                // Src is not an object (or is null) - just assign it, unless it's undefined\n                if (value !== undefined)\n                  d[k] = value;\n              }\n              const mounted = base.isConnected;\n              // If we have been mounted before, bit aren't now, remove the consumer\n              if (removedNodes(base) || (!notYetMounted && !mounted)) {\n                console.info(`Element does not exist in document when setting async attribute '${k}' to:\\n${logNode(base)}`);\n                ap.return?.();\n                return;\n              }\n              if (mounted) notYetMounted = false;\n              if (notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Element with async attribute '${k}' not mounted after 5 seconds. If it is never mounted, it will leak.\\nElement contains: ${logNode(base)}\\n${createdBy}`);\n              }\n\n              ap.next().then(update).catch(error);\n            }\n          }\n          const error = (errorValue: any) => {\n            console.warn(\"Dynamic attribute error\", errorValue, k, d, createdBy, logNode(base));\n            ap.return?.(errorValue);\n            base.appendChild(DyamicElementError({ error: errorValue }));\n          }\n          const unboxed = value.valueOf();\n          if (unboxed !== undefined && unboxed !== value && !isAsyncIter(unboxed))\n            update({ done: false, value: unboxed });\n          else\n            ap.next().then(update).catch(error);\n        }\n\n        function assignObject(value: any, k: string) {\n          if (value instanceof Node) {\n            console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes\", k, logNode(value));\n            d[k] = value;\n          } else {\n            // Note - if we're copying to ourself (or an array of different length),\n            // we're decoupling common object references, so we need a clean object to\n            // assign into\n            if (!(k in d) || d[k] === value || (Array.isArray(d[k]) && d[k].length !== value.length)) {\n              if (value.constructor === Object || value.constructor === Array) {\n                const copy = new (value.constructor);\n                assign(copy, value);\n                d[k] = copy;\n                //assign(d[k], value);\n              } else {\n                // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                d[k] = value;\n              }\n            } else {\n              if (Object.getOwnPropertyDescriptor(d, k)?.set)\n                d[k] = value;\n\n              else\n                assign(d[k], value);\n            }\n          }\n        }\n      })(base, props);\n    }\n  }\n\n  /*\n  Extend a component class with create a new component class factory:\n      const NewDiv = Div.extended({ overrides })\n          ...or...\n      const NewDic = Div.extended((instance:{ arbitrary-type }) => ({ overrides }))\n         ...later...\n      const eltNewDiv = NewDiv({attrs},...children)\n  */\n\n  type ExtendTagFunction = (attrs: TagCreationOptions & {\n    [callStackSymbol]?: Overrides[];\n    [k: string]: unknown;\n  } | ChildTags, ...children: ChildTags[]) => Element\n\n  interface ExtendTagFunctionInstance extends ExtendTagFunction {\n    super: TagCreator<Element>;\n    definition: Overrides;\n    valueOf: () => string;\n    extended: (this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) => ExtendTagFunctionInstance;\n  }\n\n  function tagHasInstance(this: ExtendTagFunctionInstance, e: any) {\n    for (let c = e.constructor; c; c = c.super) {\n      if (c === this)\n        return true;\n    }\n    return false;\n  }\n\n  function extended(this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) {\n    const instanceDefinition = (typeof _overrides !== 'function')\n      ? (instance: Instance) => Object.assign({}, _overrides, instance)\n      : _overrides\n\n    const uniqueTagID = Date.now().toString(36) + (idCount++).toString(36) + Math.random().toString(36).slice(2);\n    let staticExtensions: Overrides = instanceDefinition({ [UniqueID]: uniqueTagID });\n    /* \"Statically\" create any styles required by this widget */\n    if (staticExtensions.styles) {\n      poStyleElt.appendChild(thisDoc.createTextNode(staticExtensions.styles + '\\n'));\n      if (!thisDoc.head.contains(poStyleElt)) {\n        thisDoc.head.appendChild(poStyleElt);\n      }\n    }\n\n    // \"this\" is the tag we're being extended from, as it's always called as: `(this).extended`\n    // Here's where we actually create the tag, by accumulating all the base attributes and\n    // (finally) assigning those specified by the instantiation\n    const extendTagFn: ExtendTagFunction = (attrs, ...children) => {\n      const noAttrs = isChildTag(attrs);\n      const newCallStack: (Constructed & Overrides)[] = [];\n      const combinedAttrs = { [callStackSymbol]: (noAttrs ? newCallStack : attrs[callStackSymbol]) ?? newCallStack }\n      const e = noAttrs ? this(combinedAttrs, attrs, ...children) : this(combinedAttrs, ...children);\n      e.constructor = extendTag;\n      const tagDefinition = instanceDefinition({ [UniqueID]: uniqueTagID });\n      combinedAttrs[callStackSymbol].push(tagDefinition);\n      if (DEBUG) {\n        // Validate declare and override\n        function isAncestral(creator: TagCreator<Element>, d: string) {\n          for (let f = creator; f; f = f.super)\n            if (f.definition?.declare && d in f.definition.declare) return true;\n          return false;\n        }\n        if (tagDefinition.declare) {\n          const clash = Object.keys(tagDefinition.declare).filter(d => (d in e) || isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Declared keys '${clash}' in ${extendTag.name} already exist in base '${this.valueOf()}'`);\n          }\n        }\n        if (tagDefinition.override) {\n          const clash = Object.keys(tagDefinition.override).filter(d => !(d in e) && !(commonProperties && d in commonProperties) && !isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Overridden keys '${clash}' in ${extendTag.name} do not exist in base '${this.valueOf()}'`);\n          }\n        }\n      }\n      deepDefine(e, tagDefinition.declare, true);\n      deepDefine(e, tagDefinition.override);\n      const reAssign = new Set<string>();\n      tagDefinition.iterable && Object.keys(tagDefinition.iterable).forEach(k => {\n        if (k in e) {\n          console.log(`Ignoring attempt to re-define iterable property \"${k}\" as it could already have consumers`);\n          reAssign.add(k);\n        } else {\n          defineIterableProperty(e, k, tagDefinition.iterable![k as keyof typeof tagDefinition.iterable])\n        }\n      });\n      if (combinedAttrs[callStackSymbol] === newCallStack) {\n        if (!noAttrs)\n          assignProps(e, attrs);\n        for (const base of newCallStack) {\n          const children = base?.constructed?.call(e);\n          if (isChildTag(children)) // technically not necessary, since \"void\" is going to be undefined in 99.9% of cases.\n            e.append(...nodes(children));\n        }\n        // Once the full tree of augmented DOM elements has been constructed, fire all the iterable propeerties\n        // so the full hierarchy gets to consume the initial state, unless they have been assigned\n        // by assignProps from a future\n        const combinedInitialIterableValues = {};\n        let hasInitialValues = false;\n        for (const base of newCallStack) {\n          if (base.iterable) for (const k of Object.keys(base.iterable)) {\n            // We don't self-assign iterables that have themselves been assigned with futures\n            const attrExists = !noAttrs && k in attrs;\n            if ((reAssign.has(k) && attrExists) || !(attrExists && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e]?.valueOf();\n              if (value !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                combinedInitialIterableValues[k] = value;\n                hasInitialValues = true;\n              }\n            }\n          }\n        }\n        if (hasInitialValues)\n          Object.assign(e, combinedInitialIterableValues);\n      }\n      return e;\n    }\n\n    const extendTag: ExtendTagFunctionInstance = Object.assign(extendTagFn, {\n      super: this,\n      definition: Object.assign(staticExtensions, { [UniqueID]: uniqueTagID }),\n      extended,\n      valueOf: () => {\n        const keys = [...Object.keys(staticExtensions.declare || {}), ...Object.keys(staticExtensions.iterable || {})];\n        return `${extendTag.name}: {${keys.join(', ')}}\\n \\u21AA ${this.valueOf()}`\n      }\n    });\n    Object.defineProperty(extendTag, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    const fullProto = {};\n    (function walkProto(creator: TagCreator<Element>) {\n      if (creator?.super)\n        walkProto(creator.super);\n\n      const proto = creator.definition;\n      if (proto) {\n        deepDefine(fullProto, proto?.override);\n        deepDefine(fullProto, proto?.declare);\n      }\n    })(this);\n    deepDefine(fullProto, staticExtensions.override);\n    deepDefine(fullProto, staticExtensions.declare);\n    Object.defineProperties(extendTag, Object.getOwnPropertyDescriptors(fullProto));\n\n    // Attempt to make up a meaningfu;l name for this extended tag\n    const creatorName = fullProto\n      && 'className' in fullProto\n      && typeof fullProto.className === 'string'\n      ? fullProto.className\n      : uniqueTagID;\n    const callSite = DEBUG ? (new Error().stack?.split('\\n')[2] ?? '') : '';\n\n    Object.defineProperty(extendTag, \"name\", {\n      value: \"<ai-\" + creatorName.replace(/\\s+/g, '-') + callSite + \">\"\n    });\n\n    if (DEBUG) {\n      const extraUnknownProps = Object.keys(staticExtensions).filter(k => !['styles', 'ids', 'constructed', 'declare', 'override', 'iterable'].includes(k));\n      if (extraUnknownProps.length) {\n        console.log(`${extendTag.name} defines extraneous keys '${extraUnknownProps}', which are unknown`);\n      }\n    }\n    return extendTag;\n  }\n\n  // @ts-ignore\n  const baseTagCreators: CreateElement & {\n    [K in keyof HTMLElementTagNameMap]?: TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>\n  } & {\n    [n: string]: TagCreator<Q & Element & PoElementMethods>\n  } = {\n    createElement(\n      name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n      attrs: any,\n      ...children: ChildTags[]): Node {\n      return (name === baseTagCreators.createElement ? nodes(...children)\n        : typeof name === 'function' ? name(attrs, children)\n        : typeof name === 'string' && name in baseTagCreators ?\n        // @ts-ignore: Expression produces a union type that is too complex to represent.ts(2590)\n            baseTagCreators[name](attrs, children)\n        : name instanceof Node ? name\n        : DyamicElementError({ error: new Error(\"Illegal type in createElement:\" + name) })) as Node\n    }\n  }\n\n  function createTag<K extends keyof HTMLElementTagNameMap>(k: K): TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>;\n  function createTag<E extends Element>(k: string): TagCreator<Q & E & PoElementMethods>;\n  function createTag(k: string): TagCreator<Q & NamespacedElementBase & PoElementMethods> {\n    if (baseTagCreators[k])\n      // @ts-ignore\n      return baseTagCreators[k];\n\n    const tagCreator = (attrs: Q & PoElementMethods & TagCreationOptions | ChildTags, ...children: ChildTags[]) => {\n      if (isChildTag(attrs)) {\n        children.unshift(attrs);\n        attrs = {} as any;\n      }\n\n      // This test is always true, but narrows the type of attrs to avoid further errors\n      if (!isChildTag(attrs)) {\n        if (attrs.debugger) {\n          debugger;\n          delete attrs.debugger;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? thisDoc.createElementNS(nameSpace as string, k.toLowerCase())\n          : thisDoc.createElement(k);\n        e.constructor = tagCreator;\n\n        deepDefine(e, tagPrototypes);\n        assignProps(e, attrs);\n\n        // Append any children\n        e.append(...nodes(...children));\n        return e;\n      }\n    }\n\n    const includingExtender = <TagCreator<Element>><unknown>Object.assign(tagCreator, {\n      super: () => { throw new Error(\"Can't invoke native elemenet constructors directly. Use document.createElement().\") },\n      extended, // How to extend this (base) tag\n      valueOf() { return `TagCreator: <${nameSpace || ''}${nameSpace ? '::' : ''}${k}>` }\n    });\n\n    Object.defineProperty(tagCreator, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    Object.defineProperty(tagCreator, \"name\", { value: '<' + k + '>' });\n    // @ts-ignore\n    return baseTagCreators[k] = includingExtender;\n  }\n\n  tags.forEach(createTag);\n\n  // @ts-ignore\n  return baseTagCreators;\n}\n\n/* DOM node removal logic */\ntype PickByType<T, Value> = {\n  [P in keyof T as T[P] extends Value | undefined ? P : never]: T[P]\n}\nfunction mutationTracker(root: Node, track: keyof PickByType<MutationRecord, NodeList>, enableOnRemovedFromDOM?: boolean) {\n  const tracked = new WeakSet<Node>();\n  function walk(nodes: NodeList) {\n    for (const node of nodes) {\n      // In case it's be re-added/moved\n      if ((track === 'addedNodes') === node.isConnected) {\n        walk(node.childNodes);\n        tracked.add(node);\n        // Legacy onRemovedFromDOM support\n        if (enableOnRemovedFromDOM && 'onRemovedFromDOM' in node && typeof node.onRemovedFromDOM === 'function') node.onRemovedFromDOM();\n      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m[track].length) {\n        walk(m[track])\n      }\n    });\n  }).observe(root, { subtree: true, childList: true });\n\n  return function (node: Node) {\n    return tracked.has(node);\n  }\n}\n", "// @ts-ignore\nexport const DEBUG = globalThis.DEBUG == '*' || globalThis.DEBUG == true || globalThis.DEBUG?.match(/(^|\\W)AI-UI(\\W|$)/) || false;\nexport { _console as console };\nexport const timeOutWarn = 5000;\n\nconst _console = {\n  log(...args: any) {\n    if (DEBUG) console.log('(AI-UI) LOG:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  info(...args: any) {\n    if (DEBUG) console.trace('(AI-UI) INFO:', ...args)\n  }\n}\n\n", "import { DEBUG, console } from \"./debug.js\";\n\n// Create a deferred Promise, which can be asynchronously/externally resolved or rejected.\nexport type DeferredPromise<T> = Promise<T> & {\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (value: any) => void;\n}\n\n// Used to suppress TS error about use before initialisation\nconst nothing = (v: any)=>{};\n\nexport function deferred<T>(): DeferredPromise<T> {\n  let resolve: (value: T | PromiseLike<T>) => void = nothing;\n  let reject: (value: any) => void = nothing;\n  const promise = new Promise<T>((...r) => [resolve, reject] = r) as DeferredPromise<T>;\n  promise.resolve = resolve;\n  promise.reject = reject;\n  if (DEBUG) {\n    const initLocation = new Error().stack;\n    promise.catch(ex => (ex instanceof Error || ex?.value instanceof Error) ? console.log(\"Deferred rejection\", ex, \"allocated at \", initLocation) : undefined);\n  }\n  return promise;\n}\n\n// True if `expr in x` is valid\nexport function isObjectLike(x: any): x is Function | {} {\n  return x && typeof x === 'object' || typeof x === 'function'\n}\n\nexport function isPromiseLike<T>(x: any): x is PromiseLike<T> {\n  return isObjectLike(x) && ('then' in x) && typeof x.then === 'function';\n}\n", "import { DEBUG, console } from \"./debug.js\"\nimport { DeferredPromise, deferred, isObjectLike, isPromiseLike } from \"./deferred.js\"\n\n/* IterableProperties can't be correctly typed in TS right now, either the declaratiion\n  works for retrieval (the getter), or it works for assignments (the setter), but there's\n  no TS syntax that permits correct type-checking at present.\n\n  Ideally, it would be:\n\n  type IterableProperties<IP> = {\n    get [K in keyof IP](): AsyncExtraIterable<IP[K]> & IP[K]\n    set [K in keyof IP](v: IP[K])\n  }\n  See https://github.com/microsoft/TypeScript/issues/43826\n\n  We choose the following type description to avoid the issues above. Because the AsyncExtraIterable\n  is Partial it can be omitted from assignments:\n    this.prop = value;  // Valid, as long as valus has the same type as the prop\n  ...and when retrieved it will be the value type, and optionally the async iterator:\n    Div(this.prop) ; // the value\n    this.prop.map!(....)  // the iterator (note the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts which *accepts* a Partial<AsyncIterator>\n  but casts it to a AsyncIterator before use.\n\n  The iterability of propertys of an object is determined by the presence and value of the `Iterability` symbol.\n  By default, the current implementation does a deep mapping, so an iterable property 'obj' is itself\n  iterable, as are it's members. The only defined value at present is \"shallow\", in which case 'obj' remains\n  iterable, but it's membetrs are just POJS values.\n*/\n\n// Base types that can be made defined as iterable: basically anything, _except_ a function\nexport type IterablePropertyPrimitive = (string | number | bigint | boolean | undefined | null);\n// We should exclude AsyncIterable from the types that can be assigned to iterables (and therefore passed to defineIterableProperty)\nexport type IterablePropertyValue = IterablePropertyPrimitive | IterablePropertyValue[] | { [k: string | symbol | number]: IterablePropertyValue };\n\nexport const Iterability = Symbol(\"Iterability\");\nexport type Iterability<Depth extends 'shallow' = 'shallow'> = { [Iterability]: Depth };\nexport type IterableType<T> = T & Partial<AsyncExtraIterable<T>>;\n\ndeclare global {\n  // This is patch to the std lib definition of Array<T>. I don't know why it's absent,\n  // as this is the implementation in all JavaScript engines. It is probably a result\n  // of its absence in https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values,\n  // which inherits from the Object.prototype, which makes no claim for the return type\n  // since it could be overriddem. However, in that case, a TS defn should also override\n  // it, like Number, String, Boolean etc do.\n  interface Array<T> {\n    valueOf(): Array<T>;\n  }\n  // As above, the return type could be T rather than Object, since this is the default impl,\n  // but it's not, for some reason.\n  interface Object {\n    valueOf<T>(this: T): T extends IterableType<infer Z> ? Z : Object;\n  }\n}\n\nexport type IterableProperties<IP> = IP extends Iterability<'shallow'> ? {\n  [K in keyof Omit<IP, typeof Iterability>]: IterableType<IP[K]>\n} : ({\n  [K in keyof IP]: (\n    IP[K] extends Array<infer E>\n    ? (IterableProperties<E>[] | IterableProperties<E[]>)\n    : ((\n      IP[K] extends object\n      ? IterableProperties<IP[K]>\n      : IP[K]\n    ) & IterableType<IP[K]>)\n  )\n})\n\n/* Things to suppliement the JS base AsyncIterable */\nexport interface QueueIteratableIterator<T> extends AsyncIterableIterator<T>, AsyncIterableHelpers {\n  push(value: T): boolean;\n  readonly length: number;\n}\n\nexport interface AsyncExtraIterable<T> extends AsyncIterable<T>, AsyncIterableHelpers { }\n\n// NB: This also (incorrectly) passes sync iterators, as the protocol names are the same\nexport function isAsyncIterator<T = unknown>(o: any | AsyncIterator<T>): o is AsyncIterator<T> {\n  return isObjectLike(o) && 'next' in o && typeof o?.next === 'function'\n}\nexport function isAsyncIterable<T = unknown>(o: any | AsyncIterable<T>): o is AsyncIterable<T> {\n  return isObjectLike(o) && (Symbol.asyncIterator in o) && typeof o[Symbol.asyncIterator] === 'function'\n}\nexport function isAsyncIter<T = unknown>(o: any | AsyncIterable<T> | AsyncIterator<T>): o is AsyncIterable<T> | AsyncIterator<T> {\n  return isAsyncIterable(o) || isAsyncIterator(o)\n}\n\nexport type AsyncProvider<T> = AsyncIterator<T> | AsyncIterable<T>\n\nexport function asyncIterator<T>(o: AsyncProvider<T>) {\n  if (isAsyncIterator(o)) return o;\n  if (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  throw new Error(\"Not an async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nexport const asyncExtras = {\n  filterMap<U extends PartialIterable, R>(this: U,\n    fn: (o: HelperAsyncIterable<U>, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>,\n    initialValue: R | typeof Ignore = Ignore\n  ) {\n    return filterMap(this, fn, initialValue)\n  },\n  map,\n  filter,\n  unique,\n  waitFor,\n  multi,\n  initially,\n  consume,\n  merge<T, A extends Partial<AsyncIterable<any>>[]>(this: PartialIterable<T>, ...m: A) {\n    return merge(this, ...m);\n  },\n  combine<T, S extends CombinedIterable>(this: PartialIterable<T>, others: S) {\n    return combine(Object.assign({ '_this': this }, others));\n  }\n};\n\nconst extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)] as (keyof typeof asyncExtras)[];\n\n// Like Object.assign, but the assigned properties are not enumerable\nfunction assignHidden<D extends {}, S extends {}>(d: D, s: S) {\n  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];\n  for (const k of keys) {\n    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });\n  }\n  return d as D & S;\n}\n\nconst _pending = Symbol('pending');\nconst _items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [_items]: [] as IteratorResult<T>[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[_items]?.length) {\n        return Promise.resolve(q[_items].shift()!);\n      }\n\n      if (!q[_pending])\n        return Promise.resolve({ done: true as const, value: undefined });\n\n      const value = deferred<IteratorResult<T>>();\n      // We install a catch handler as the promise might be legitimately reject before anything waits for it,\n      // and this suppresses the uncaught exception warning.\n      value.catch(ex => { });\n      q[_pending].unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.resolve(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.resolve(value);\n    },\n\n    throw(...args: any[]) {\n      const value = { done: true as const, value: args[0] };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.reject(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[_items]) return -1; // The queue has no consumers and has terminated.\n      return q[_items].length;\n    },\n\n    push(value: T) {\n      if (!q[_pending])\n        return false;\n\n      if (q[_pending].length) {\n        q[_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[_items].push({ done: false, value })\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst _inflight = Symbol('inflight');\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [_inflight]: Set<T> };\n  q[_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[_pending])\n      return false;\n\n    // Debounce\n    if (q[_inflight].has(value))\n      return true;\n\n    if (q[_pending].length) {\n      q[_inflight].add(value);\n      const p = q[_pending].pop()!;\n      p.finally(() => q[_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[_items].find(v => v.value === value)) {\n        q[_items].push({ done: false, value });\n      }\n    }\n    return true;\n  }\n  return q;\n}\n\n// Re-export to hide the internals\nexport const queueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalQueueIteratableIterator;\nexport const debounceQueueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalDebounceQueueIteratableIterator;\n\ndeclare global {\n  interface ObjectConstructor {\n    defineProperties<T, M extends { [K: string | symbol]: TypedPropertyDescriptor<any> }>(o: T, properties: M & ThisType<any>): T & {\n      [K in keyof M]: M[K] extends TypedPropertyDescriptor<infer T> ? T : never\n    };\n  }\n}\n\n/* Define a \"iterable property\" on `obj`.\n   This is a property that holds a boxed (within an Object() call) value, and is also an AsyncIterableIterator. which\n   yields when the property is set.\n   This routine creates the getter/setter for the specified property, and manages the aassociated async iterator.\n*/\n\nconst _proxiedAsyncIterator = Symbol('_proxiedAsyncIterator');\nexport function defineIterableProperty<T extends {}, const N extends string | symbol, V extends IterablePropertyValue>(obj: T, name: N, v: V): T & IterableProperties<{ [k in N]: V }> {\n  // Make `a` an AsyncExtraIterable. We don't do this until a consumer actually tries to\n  // access the iterator methods to prevent leaks where an iterable is created, but\n  // never referenced, and therefore cannot be consumed and ultimately closed\n  let initIterator = () => {\n    initIterator = () => b;\n    const bi = debounceQueueIteratableIterator<V>();\n    const mi = bi.multi();\n    const b = mi[Symbol.asyncIterator]();\n    extras[Symbol.asyncIterator] = mi[Symbol.asyncIterator];\n    push = bi.push;\n    extraKeys.forEach(k => // @ts-ignore\n      extras[k] = b[k as keyof typeof b]);\n    if (!(_proxiedAsyncIterator in a))\n      assignHidden(a, extras);\n    return b;\n  }\n\n  // Create stubs that lazily create the AsyncExtraIterable interface when invoked\n  function lazyAsyncMethod<M extends keyof typeof asyncExtras>(method: M) {\n    return {\n      [method]: function (this: unknown, ...args: any[]) {\n        initIterator();\n        // @ts-ignore - Fix\n        return a[method].apply(this, args);\n      } as (typeof asyncExtras)[M]\n    }[method];\n  }\n\n  type HelperDescriptors<T> = {\n    [K in keyof AsyncExtraIterable<T>]: TypedPropertyDescriptor<AsyncExtraIterable<T>[K]>\n  } & {\n    [Iterability]?: TypedPropertyDescriptor<'shallow'>\n  };\n\n  const extras = { [Symbol.asyncIterator]: initIterator } as AsyncExtraIterable<V> & { [Iterability]?: 'shallow' };\n  extraKeys.forEach((k) => // @ts-ignore\n    extras[k] = lazyAsyncMethod(k))\n  if (typeof v === 'object' && v && Iterability in v && v[Iterability] === 'shallow') {\n    extras[Iterability] = v[Iterability];\n  }\n\n  // Lazily initialize `push`\n  let push: QueueIteratableIterator<V>['push'] = (v: V) => {\n    initIterator(); // Updates `push` to reference the multi-queue\n    return push(v);\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<V> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: V | AsyncExtraIterable<V>) {\n      if (v !== a) {\n        if (isAsyncIterable(v)) {\n          // Assigning multiple async iterators to a single iterable is probably a\n          // bad idea from a reasoning point of view, and multiple implementations\n          // are possible:\n          //  * merge?\n          //  * ignore subsequent assignments?\n          //  * terminate the first then consume the second?\n          // The solution here (one of many possibilities) is the letter: only to allow\n          // most recent assignment to work, terminating any preceeding iterator when it next\n          // yields and finds this consumer has been re-assigned.\n\n          // If the iterator has been reassigned with no change, just ignore it, as we're already consuming it\n          if (piped === v)\n            return;\n\n          piped = v;\n          let stack = DEBUG ? new Error() : undefined;\n          if (DEBUG)\n            console.info(new Error(`Iterable \"${name.toString()}\" has been assigned to consume another iterator. Did you mean to declare it?`));\n          consume.call(v, y => {\n            if (v !== piped) {\n              // We're being piped from something else. We want to stop that one and get piped from this one\n              throw new Error(`Piped iterable \"${name.toString()}\" has been replaced by another iterator`, { cause: stack });\n            }\n            push(y?.valueOf() as V)\n          })\n            .catch(ex => console.info(ex))\n            .finally(() => (v === piped) && (piped = undefined));\n\n          // Early return as we're going to pipe values in later\n          return;\n        } else {\n          if (piped && DEBUG) {\n            console.log(`Iterable \"${name.toString()}\" is already piped from another iterator, and might be overrwitten later`);\n          }\n          a = box(v, extras);\n        }\n      }\n      push(v?.valueOf() as V);\n    },\n    enumerable: true\n  });\n  return obj as any;\n\n  function box<V>(a: V, pds: AsyncExtraIterable<V>): V & AsyncExtraIterable<V> {\n    if (a === null || a === undefined) {\n      return assignHidden(Object.create(null, {\n        valueOf: { value() { return a }, writable: true, configurable: true },\n        toJSON: { value() { return a }, writable: true, configurable: true }\n      }), pds);\n    }\n    switch (typeof a) {\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return assignHidden(Object(a), Object.assign(pds, {\n          toJSON() { return a.valueOf() }\n        }));\n      case 'object':\n        // We box objects by creating a Proxy for the object that pushes on get/set/delete, and maps the supplied async iterator to push the specified key\n        // The proxies are recursive, so that if an object contains objects, they too are proxied. Objects containing primitives remain proxied to\n        // handle the get/set/selete in place of the usual primitive boxing via Object(primitiveValue)\n        // @ts-ignore\n        return boxObject(a, pds);\n\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n\n  type WithPath = { [_proxiedAsyncIterator]: { a: V, path: string | null } };\n  type PossiblyWithPath = V | WithPath;\n  function isProxiedAsyncIterator(o: PossiblyWithPath): o is WithPath {\n    return isObjectLike(o) && _proxiedAsyncIterator in o;\n  }\n  function destructure(o: any, path: string) {\n    const fields = path.split('.').slice(1);\n    for (let i = 0; i < fields.length && ((o = o?.[fields[i]]) !== undefined); i++);\n    return o;\n  }\n  function boxObject(a: V, pds: AsyncExtraIterable<PossiblyWithPath>) {\n    let withPath: AsyncExtraIterable<WithPath[typeof _proxiedAsyncIterator]>;\n    let withoutPath: AsyncExtraIterable<V>;\n    return new Proxy(a as object, handler()) as V & AsyncExtraIterable<V>;\n\n    function handler(path = ''): ProxyHandler<object> {\n      return {\n        // A boxed object has its own keys, and the keys of an AsyncExtraIterable\n        has(target, key) {\n          return key === _proxiedAsyncIterator || key === Symbol.toPrimitive || key in target || key in pds;\n        },\n        // When a key is set in the target, push the change\n        set(target, key, value, receiver) {\n          if (Object.hasOwn(pds, key)) {\n            throw new Error(`Cannot set ${name.toString()}${path}.${key.toString()} as it is part of asyncIterator`);\n          }\n          if (Reflect.get(target, key, receiver) !== value) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n          }\n          return Reflect.set(target, key, value, receiver);\n        },\n        deleteProperty(target, key) {\n          if (Reflect.deleteProperty(target, key)) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n            return true;\n          }\n          return false;\n        },\n        // When getting the value of a boxed object member, prefer asyncExtraIterable over target keys\n        get(target, key, receiver) {\n          // If the key is an asyncExtraIterable member, create the mapped queue to generate it\n          if (Object.hasOwn(pds, key)) {\n            if (!path.length) {\n              withoutPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator].a : o);\n              return withoutPath[key as keyof typeof pds];\n            } else {\n              withPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator] : { a: o, path: null });\n\n              let ai = filterMap(withPath, (o, p) => {\n                const v = destructure(o.a, path);\n                return p !== v || o.path === null || o.path.startsWith(path) ? v : Ignore;\n              }, Ignore, destructure(a, path));\n              return ai[key as keyof typeof ai];\n            }\n          }\n\n          // If the key is a target property, create the proxy to handle it\n          if (key === 'valueOf') return () => destructure(a, path);\n          if (key === Symbol.toPrimitive) {\n            // Special case, since Symbol.toPrimitive is in ha(), we need to implement it\n            return function (hint?: 'string' | 'number' | 'default') {\n              if (Reflect.has(target, key))\n                return Reflect.get(target, key, target).call(target, hint);\n              if (hint === 'string') return target.toString();\n              if (hint === 'number') return Number(target);\n              return target.valueOf();\n            }\n          }\n          if (typeof key === 'string') {\n            if ((!(key in target) || Object.hasOwn(target, key)) && !(Iterability in target && target[Iterability] === 'shallow')) {\n              const field = Reflect.get(target, key, receiver);\n              return (typeof field === 'function') || isAsyncIter(field)\n                ? field\n                : new Proxy(Object(field), handler(path + '.' + key));\n            }\n          }\n          // This is a symbolic entry, or a prototypical value (since it's in the target, but not a target property)\n          return Reflect.get(target, key, receiver);\n        }\n      }\n    }\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\nconst forever = new Promise<any>(() => { });\n\n/* Merge asyncIterables into a single asyncIterable */\n\n/* TS hack to expose the return AsyncGenerator a generator of the union of the merged types */\ntype CollapseIterableType<T> = T[] extends Partial<AsyncIterable<infer U>>[] ? U : never;\ntype CollapseIterableTypes<T> = AsyncIterable<CollapseIterableType<T>>;\n\nexport const merge = <A extends Partial<AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>>[], TYield, TReturn, TNext>(...ai: A) => {\n  const it: (undefined | AsyncIterator<any>)[] = new Array(ai.length);\n  const promises: Promise<{ idx: number, result: IteratorResult<any> }>[] = new Array(ai.length);\n\n  let init = () => {\n    init = () => { }\n    for (let n = 0; n < ai.length; n++) {\n      const a = ai[n] as AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>;\n      promises[n] = (it[n] = Symbol.asyncIterator in a\n        ? a[Symbol.asyncIterator]()\n        : a as AsyncIterator<any>)\n        .next()\n        .then(result => ({ idx: n, result }));\n    }\n  }\n\n  const results: (TYield | TReturn)[] = [];\n  let count = promises.length;\n\n  const merged: AsyncIterableIterator<A[number]> = {\n    [Symbol.asyncIterator]() { return merged },\n    next() {\n      init();\n      return count\n        ? Promise.race(promises).then(({ idx, result }) => {\n          if (result.done) {\n            count--;\n            promises[idx] = forever;\n            results[idx] = result.value;\n            // We don't yield intermediate return values, we just keep them in results\n            // return { done: count === 0, value: result.value }\n            return merged.next();\n          } else {\n            // `ex` is the underlying async iteration exception\n            promises[idx] = it[idx]\n              ? it[idx]!.next().then(result => ({ idx, result })).catch(ex => ({ idx, result: { done: true, value: ex } }))\n              : Promise.resolve({ idx, result: { done: true, value: undefined } })\n            return result;\n          }\n        }).catch(ex => {\n          return merged.throw?.(ex) ?? Promise.reject({ done: true as const, value: new Error(\"Iterator merge exception\") });\n        })\n        : Promise.resolve({ done: true as const, value: results });\n    },\n    async return(r) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.return?.({ done: true, value: r }).then(v => v.value, ex => ex);\n        }\n      }\n      return { done: true, value: results };\n    },\n    async throw(ex: any) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.throw?.(ex).then(v => v.value, ex => ex);\n        }\n      }\n      // Because we've passed the exception on to all the sources, we're now done\n      // previously: return Promise.reject(ex);\n      return { done: true, value: results };\n    }\n  };\n  return iterableHelpers(merged as unknown as CollapseIterableTypes<A[number]>);\n}\n\ntype CombinedIterable = { [k: string | number | symbol]: PartialIterable };\ntype CombinedIterableType<S extends CombinedIterable> = {\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n};\ntype CombinedIterableResult<S extends CombinedIterable> = AsyncExtraIterable<{\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n}>;\n\nexport interface CombineOptions {\n  ignorePartial?: boolean; // Set to avoid yielding if some sources are absent\n}\n\nexport const combine = <S extends CombinedIterable>(src: S, opts: CombineOptions = {}): CombinedIterableResult<S> => {\n  const accumulated: CombinedIterableType<S> = {};\n  let pc: Promise<{ idx: number, k: string, ir: IteratorResult<any> }>[];\n  let si: AsyncIterator<any>[] = [];\n  let active: number = 0;\n  const ci = {\n    [Symbol.asyncIterator]() { return ci },\n    next(): Promise<IteratorResult<CombinedIterableType<S>>> {\n      if (pc === undefined) {\n        pc = Object.entries(src).map(([k, sit], idx) => {\n          active += 1;\n          si[idx] = sit[Symbol.asyncIterator]!();\n          return si[idx].next().then(ir => ({ si, idx, k, ir }));\n        });\n      }\n\n      return (function step(): Promise<IteratorResult<CombinedIterableType<S>>> {\n        return Promise.race(pc).then(({ idx, k, ir }) => {\n          if (ir.done) {\n            pc[idx] = forever;\n            active -= 1;\n            if (!active)\n              return { done: true, value: undefined };\n            return step();\n          } else {\n            // @ts-ignore\n            accumulated[k] = ir.value;\n            pc[idx] = si[idx].next().then(ir => ({ idx, k, ir }));\n          }\n          if (opts.ignorePartial) {\n            if (Object.keys(accumulated).length < Object.keys(src).length)\n              return step();\n          }\n          return { done: false, value: accumulated };\n        })\n      })();\n    },\n    return(v?: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].return?.(v)\n        }\n      });\n      return Promise.resolve({ done: true, value: v });\n    },\n    throw(ex: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].throw?.(ex)\n        }\n      });\n      return Promise.reject({ done: true, value: ex });\n    }\n  }\n  return iterableHelpers(ci);\n}\n\n\nfunction isExtraIterable<T>(i: any): i is AsyncExtraIterable<T> {\n  return isAsyncIterable(i)\n    && extraKeys.every(k => (k in i) && (i as any)[k] === asyncExtras[k]);\n}\n\n// Attach the pre-defined helpers onto an AsyncIterable and return the modified object correctly typed\nexport function iterableHelpers<A extends AsyncIterable<any>>(ai: A): A & AsyncExtraIterable<A extends AsyncIterable<infer T> ? T : unknown> {\n  if (!isExtraIterable(ai)) {\n    assignHidden(ai, asyncExtras);\n  }\n  return ai as A extends AsyncIterable<infer T> ? AsyncExtraIterable<T> & A : never\n}\n\nexport function generatorHelpers<G extends (...args: any[]) => R, R extends AsyncGenerator>(g: G) {\n  return function (...args: Parameters<G>): ReturnType<G> {\n    const ai = g(...args);\n    return iterableHelpers(ai) as ReturnType<G>;\n  } as (...args: Parameters<G>) => ReturnType<G> & AsyncExtraIterable<ReturnType<G> extends AsyncGenerator<infer T> ? T : unknown>\n}\n\n/* AsyncIterable helpers, which can be attached to an AsyncIterator with `withHelpers(ai)`, and invoked directly for foreign asyncIterators */\n\n/* types that accept Partials as potentiallu async iterators, since we permit this IN TYPING so\n  iterable properties don't complain on every access as they are declared as V & Partial<AsyncIterable<V>>\n  due to the setters and getters having different types, but undeclarable in TS due to syntax limitations */\ntype HelperAsyncIterable<Q extends Partial<AsyncIterable<any>>> = HelperAsyncIterator<Required<Q>[typeof Symbol.asyncIterator]>;\ntype HelperAsyncIterator<F> =\n  F extends () => AsyncIterator<infer T>\n  ? T : never;\n\nasync function consume<U extends Partial<AsyncIterable<any>>>(this: U, f?: (u: HelperAsyncIterable<U>) => void | PromiseLike<void>): Promise<void> {\n  let last: undefined | void | PromiseLike<void> = undefined;\n  for await (const u of this as AsyncIterable<HelperAsyncIterable<U>>) {\n    last = f?.(u);\n  }\n  await last;\n}\n\ntype Mapper<U, R> = ((o: U, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>);\ntype MaybePromised<T> = PromiseLike<T> | T;\n\n/* A general filter & mapper that can handle exceptions & returns */\nexport const Ignore = Symbol(\"Ignore\");\n\ntype PartialIterable<T = any> = Partial<AsyncIterable<T>>;\n\nfunction resolveSync<Z, R>(v: MaybePromised<Z>, then: (v: Z) => R, except: (x: any) => any): MaybePromised<R> {\n  if (isPromiseLike(v))\n    return v.then(then, except);\n  try { return then(v) } catch (ex) { return except(ex) }\n}\n\nexport function filterMap<U extends PartialIterable, R>(source: U,\n  fn: Mapper<HelperAsyncIterable<U>, R>,\n  initialValue: R | typeof Ignore = Ignore,\n  prev: R | typeof Ignore = Ignore\n): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  const fai: AsyncIterableIterator<R> = {\n    [Symbol.asyncIterator]() {\n      return fai;\n    },\n\n    next(...args: [] | [undefined]) {\n      if (initialValue !== Ignore) {\n        const init = Promise.resolve({ done: false, value: initialValue });\n        initialValue = Ignore;\n        return init;\n      }\n\n      return new Promise<IteratorResult<R>>(function step(resolve, reject) {\n        if (!ai)\n          ai = source[Symbol.asyncIterator]!();\n        ai.next(...args).then(\n          p => p.done\n            ? resolve(p)\n            : resolveSync(fn(p.value, prev),\n              f => f === Ignore\n                ? step(resolve, reject)\n                : resolve({ done: false, value: prev = f }),\n              ex => {\n                // The filter function failed...\n                ai.throw ? ai.throw(ex) : ai.return?.(ex) // Terminate the source - for now we ignore the result of the termination\n                reject({ done: true, value: ex }); // Terminate the consumer\n              }\n            ),\n\n          ex =>\n            // The source threw. Tell the consumer\n            reject({ done: true, value: ex })\n        ).catch(ex => {\n          // The callback threw\n          ai.throw ? ai.throw(ex) : ai.return?.(ex); // Terminate the source - for now we ignore the result of the termination\n          reject({ done: true, value: ex })\n        })\n      })\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(fai)\n}\n\nfunction map<U extends PartialIterable, R>(this: U, mapper: Mapper<HelperAsyncIterable<U>, R>): AsyncExtraIterable<R> {\n  return filterMap(this, mapper);\n}\n\nfunction filter<U extends PartialIterable>(this: U, fn: (o: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, async o => (await fn(o) ? o : Ignore));\n}\n\nfunction unique<U extends PartialIterable>(this: U, fn?: (next: HelperAsyncIterable<U>, prev: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return fn\n    ? filterMap(this, async (o, p) => (p === Ignore || await fn(o, p)) ? o : Ignore)\n    : filterMap(this, (o, p) => o === p ? Ignore : o);\n}\n\nfunction initially<U extends PartialIterable, I = HelperAsyncIterable<U>>(this: U, initValue: I): AsyncExtraIterable<HelperAsyncIterable<U> | I> {\n  return filterMap(this, o => o, initValue);\n}\n\nfunction waitFor<U extends PartialIterable>(this: U, cb: (done: (value: void | PromiseLike<void>) => void) => void): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, o => new Promise<HelperAsyncIterable<U>>(resolve => { cb(() => resolve(o)); return o }));\n}\n\nfunction multi<U extends PartialIterable>(this: U): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  type T = HelperAsyncIterable<U>;\n  const source = this;\n  let consumers = 0;\n  let current: DeferredPromise<IteratorResult<T, any>>;\n  let ai: AsyncIterator<T, any, undefined> | undefined = undefined;\n\n  // The source has produced a new result\n  function step(it?: IteratorResult<T, any>) {\n    if (it) current.resolve(it);\n    if (!it?.done) {\n      current = deferred<IteratorResult<T>>();\n      ai!.next()\n        .then(step)\n        .catch(error => current.reject({ done: true, value: error }));\n    }\n  }\n\n  const mai: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      consumers += 1;\n      return mai;\n    },\n\n    next() {\n      if (!ai) {\n        ai = source[Symbol.asyncIterator]!();\n        step();\n      }\n      return current//.then(zalgo => zalgo);\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source if we're the final one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: ex });\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source if we're the only one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: v });\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(mai);\n}\n\nexport function augmentGlobalAsyncGenerators() {\n  let g = (async function* () { })();\n  while (g) {\n    const desc = Object.getOwnPropertyDescriptor(g, Symbol.asyncIterator);\n    if (desc) {\n      iterableHelpers(g);\n      break;\n    }\n    g = Object.getPrototypeOf(g);\n  }\n  if (!g) {\n    console.warn(\"Failed to augment the prototype of `(async function*())()`\");\n  }\n}\n\n", "import { DEBUG, console, timeOutWarn } from './debug.js';\nimport { isPromiseLike } from './deferred.js';\nimport { iterableHelpers, merge, AsyncExtraIterable, queueIteratableIterator } from \"./iterators.js\";\n\n/*\n  `when(....)` is both an AsyncIterable of the events it can generate by observation,\n  and a function that can map those events to a specified type, eg:\n\n  this.when('keyup:#elemet') => AsyncIterable<KeyboardEvent>\n  this.when('#elemet')(e => e.target) => AsyncIterable<EventTarget>\n*/\n// Varargs type passed to \"when\"\nexport type WhenParameters<IDS extends string = string> = ReadonlyArray<\n  AsyncIterable<any>\n  | ValidWhenSelector<IDS>\n  | Element /* Implies \"change\" event */\n  | Promise<any> /* Just gets wrapped in a single `yield` */\n>;\n\n// The Iterated type generated by \"when\", based on the parameters\ntype WhenIteratedType<S extends WhenParameters> =\n  (Extract<S[number], AsyncIterable<any>> extends AsyncIterable<infer I> ? unknown extends I ? never : I : never)\n  | ExtractEvents<Extract<S[number], string>>\n  | (Extract<S[number], Element> extends never ? never : Event)\n\ntype MappableIterable<A extends AsyncIterable<any>> =\n  A extends AsyncIterable<infer T> ?\n    A & AsyncExtraIterable<T> &\n    (<R>(mapper: (value: A extends AsyncIterable<infer T> ? T : never) => R) => (AsyncExtraIterable<Awaited<R>>))\n  : never;\n\n// The extended iterator that supports async iterator mapping, chaining, etc\nexport type WhenReturn<S extends WhenParameters> =\n  MappableIterable<\n    AsyncExtraIterable<\n      WhenIteratedType<S>>>;\n\ntype EmptyObject = Record<string | symbol | number, never>;\n\ntype SpecialWhenEvents = {\n  \"@start\": EmptyObject,  // Always fires when referenced\n  \"@ready\": EmptyObject   // Fires when all Element specified sources are mounted in the DOM\n};\ntype WhenEvents = GlobalEventHandlersEventMap & SpecialWhenEvents;\ntype EventNameList<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : `${S},${EventNameList<R>}`\n  : never;\n\ntype EventNameUnion<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : S | EventNameList<R>\n  : never;\n\n\ntype EventAttribute = `${keyof GlobalEventHandlersEventMap}`\ntype CSSIdentifier<IDS extends string = string> = `#${IDS}` |`.${string}` | `[${string}]`\n\n/* ValidWhenSelectors are:\n    @start\n    @ready\n    event:selector\n    event           \"this\" element, event type='event'\n    selector        specificed selectors, implies \"change\" event\n*/\n\nexport type ValidWhenSelector<IDS extends string = string> = `${keyof SpecialWhenEvents}`\n  | `${EventAttribute}:${CSSIdentifier<IDS>}`\n  | EventAttribute\n  | CSSIdentifier<IDS>;\n\ntype IsValidWhenSelector<S>\n  = S extends ValidWhenSelector ? S : never;\n\ntype ExtractEventNames<S>\n  = S extends keyof SpecialWhenEvents ? S\n  : S extends `${infer V}:${infer L extends CSSIdentifier}`\n  ? EventNameUnion<V> extends never ? never : EventNameUnion<V>\n  : S extends `${infer L extends CSSIdentifier}`\n  ? 'change'\n  : never;\n\ntype ExtractEvents<S> = WhenEvents[ExtractEventNames<S>];\n\n/** when **/\ntype EventObservation<EventName extends keyof GlobalEventHandlersEventMap> = {\n  push: (ev: GlobalEventHandlersEventMap[EventName])=>void;\n  terminate: (ex: Error)=>void;\n  container: Element\n  selector: string | null\n};\nconst eventObservations = new WeakMap<Document, Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  if (!eventObservations.has(this))\n    eventObservations.set(this, new Map());\n\n  const observations = eventObservations.get(this)!.get(ev.type as keyof GlobalEventHandlersEventMap);\n  if (observations) {\n    for (const o of observations) {\n      try {\n        const { push, terminate, container, selector } = o;\n        if (!container.isConnected) {\n          const msg = \"Container `#\" + container.id + \">\" + (selector || '') + \"` removed from DOM. Removing subscription\";\n          observations.delete(o);\n          terminate(new Error(msg));\n        } else {\n          if (ev.target instanceof Node) {\n            if (selector) {\n              const nodes = container.querySelectorAll(selector);\n              for (const n of nodes) {\n                if ((ev.target === n || n.contains(ev.target)) && container.contains(n))\n                  push(ev)\n              }\n            } else {\n              if ((ev.target === container || container.contains(ev.target)))\n                push(ev)\n            }\n          }\n        }\n      } catch (ex) {\n        console.warn('docEventHandler', ex);\n      }\n    }\n  }\n}\n\nfunction isCSSSelector(s: string): s is CSSIdentifier {\n  return Boolean(s && (s.startsWith('#') || s.startsWith('.') || (s.startsWith('[') && s.endsWith(']'))));\n}\n\nfunction parseWhenSelector<EventName extends string>(what: IsValidWhenSelector<EventName>): undefined | [CSSIdentifier | null, keyof GlobalEventHandlersEventMap] {\n  const parts = what.split(':');\n  if (parts.length === 1) {\n    if (isCSSSelector(parts[0]))\n      return [parts[0],\"change\"];\n    return [null, parts[0] as keyof GlobalEventHandlersEventMap];\n  }\n  if (parts.length === 2) {\n    if (isCSSSelector(parts[1]) && !isCSSSelector(parts[0]))\n    return [parts[1], parts[0] as keyof GlobalEventHandlersEventMap]\n  }\n  return undefined;\n}\n\nfunction doThrow(message: string):never {\n  throw new Error(message);\n}\n\nfunction whenEvent<EventName extends string>(container: Element, what: IsValidWhenSelector<EventName>) {\n  const [selector, eventName] = parseWhenSelector(what) ?? doThrow(\"Invalid WhenSelector: \"+what);\n\n  if (!eventObservations.has(container.ownerDocument))\n    eventObservations.set(container.ownerDocument, new Map());\n\n  if (!eventObservations.get(container.ownerDocument)!.has(eventName)) {\n    container.ownerDocument.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.get(container.ownerDocument)!.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.get(container.ownerDocument)?.get(eventName)?.delete(details));\n\n  const details: EventObservation<keyof GlobalEventHandlersEventMap> /*EventObservation<Exclude<ExtractEventNames<EventName>, keyof SpecialWhenEvents>>*/ = {\n    push: queue.push,\n    terminate(ex: Error) { queue.return?.(ex)},\n    container,\n    selector: selector || null\n  };\n\n  containerAndSelectorsMounted(container, selector ? [selector] : undefined)\n    .then(_ => eventObservations.get(container.ownerDocument)?.get(eventName)!.add(details));\n\n  return queue.multi() ;\n}\n\nasync function* neverGonnaHappen<Z>(): AsyncIterableIterator<Z> {\n  await new Promise(() => {});\n  yield undefined as Z; // Never should be executed\n}\n\n/* Syntactic sugar: chainAsync decorates the specified iterator so it can be mapped by\n  a following function, or used directly as an iterable */\nfunction chainAsync<A extends AsyncExtraIterable<X>, X>(src: A): MappableIterable<A> {\n  function mappableAsyncIterable(mapper: Parameters<typeof src.map>[0]) {\n    return src.map(mapper);\n  }\n\n  return Object.assign(iterableHelpers(mappableAsyncIterable as unknown as AsyncIterable<A>), {\n    [Symbol.asyncIterator]: () => src[Symbol.asyncIterator]()\n  }) as MappableIterable<A>;\n}\n\nfunction isValidWhenSelector(what: WhenParameters[number]): what is ValidWhenSelector {\n  if (!what)\n    throw new Error('Falsy async source will never be ready\\n\\n' + JSON.stringify(what));\n  return typeof what === 'string' && what[0] !== '@' && Boolean(parseWhenSelector(what));\n}\n\nasync function* once<T>(p: Promise<T>) {\n  yield p;\n}\n\nexport function when<S extends WhenParameters>(container: Element, ...sources: S): WhenReturn<S> {\n  if (!sources || sources.length === 0) {\n    return chainAsync(whenEvent(container, \"change\")) as unknown as WhenReturn<S>;\n  }\n\n  const iterators = sources.filter(what => typeof what !== 'string' || what[0] !== '@').map(what => typeof what === 'string'\n    ? whenEvent(container, what)\n    : what instanceof Element\n      ? whenEvent(what, \"change\")\n      : isPromiseLike(what)\n        ? once(what)\n        : what);\n\n  if (sources.includes('@start')) {\n    const start: AsyncIterableIterator<{}> = {\n      [Symbol.asyncIterator]: () => start,\n      next() {\n        start.next = () => Promise.resolve({ done: true, value: undefined })\n        return Promise.resolve({ done: false, value: {} })\n      }\n    };\n    iterators.push(start);\n  }\n\n  if (sources.includes('@ready')) {\n    const watchSelectors = sources.filter(isValidWhenSelector).map(what => parseWhenSelector(what)?.[0]);\n\n    function isMissing(sel: CSSIdentifier | null | undefined): sel is CSSIdentifier {\n      return Boolean(typeof sel === 'string' && !container.querySelector(sel));\n    }\n\n    const missing = watchSelectors.filter(isMissing);\n\n    let events: AsyncIterator<any, any, undefined> | undefined = undefined;\n    const ai: AsyncIterableIterator<any> = {\n      [Symbol.asyncIterator]() { return ai },\n      throw(ex: any) {\n        if (events?.throw) return events.throw(ex);\n        return Promise.resolve({ done: true, value: ex });\n      },\n      return(v?: any) {\n        if (events?.return) return events.return(v);\n        return Promise.resolve({ done: true, value: v });\n      },\n      next() {\n        if (events) return events.next();\n\n        return containerAndSelectorsMounted(container, missing).then(() => {\n          const merged = (iterators.length > 1)\n          ? merge(...iterators)\n          : iterators.length === 1\n            ? iterators[0]\n            : (neverGonnaHappen<WhenIteratedType<S>>());\n\n          // Now everything is ready, we simply delegate all async ops to the underlying\n          // merged asyncIterator \"events\"\n          events = merged[Symbol.asyncIterator]();\n          if (!events)\n            return { done: true, value: undefined };\n\n          return { done: false, value: {} };\n        });\n      }\n    };\n    return chainAsync(iterableHelpers(ai));\n  }\n\n  const merged = (iterators.length > 1)\n    ? merge(...iterators)\n    : iterators.length === 1\n      ? iterators[0]\n      : (neverGonnaHappen<WhenIteratedType<S>>());\n\n  return chainAsync(iterableHelpers(merged));\n}\n\nfunction elementIsInDOM(elt: Element): Promise<void> {\n  if (elt.isConnected)\n    return Promise.resolve();\n\n  return new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (elt.isConnected) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(elt.ownerDocument.body, {\n    subtree: true,\n    childList: true\n  }));\n}\n\nfunction containerAndSelectorsMounted(container: Element, selectors?: string[]) {\n  if (selectors?.length)\n    return Promise.all([\n      allSelectorsPresent(container, selectors),\n      elementIsInDOM(container)\n    ]);\n  return elementIsInDOM(container);\n}\n\nfunction allSelectorsPresent(container: Element, missing: string[]): Promise<void> {\n  missing = missing.filter(sel => !container.querySelector(sel))\n  if (!missing.length) {\n    return Promise.resolve(); // Nothing is missing\n  }\n\n  const promise = new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (missing.every(sel => container.querySelector(sel))) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(container, {\n    subtree: true,\n    childList: true\n  }));\n\n  /* debugging help: warn if waiting a long time for a selectors to be ready */\n  if (DEBUG) {\n    const stack = new Error().stack?.replace(/^Error/, \"Missing selectors after 5 seconds:\");\n    const warnTimer = setTimeout(() => {\n      console.warn(stack, missing);\n    }, timeOutWarn);\n\n    promise.finally(() => clearTimeout(warnTimer))\n  }\n\n  return promise;\n}\n"],
  "mappings": "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",
  "names": ["v", "a", "result", "ex", "ir", "isMissing", "merged", "unique", "c", "n", "value", "isAncestral", "children"]
}
 diff --git a/module/dist/ai-ui.min.cjs b/module/dist/ai-ui.min.cjs index 97bdd11..3369ce8 100644 --- a/module/dist/ai-ui.min.cjs +++ b/module/dist/ai-ui.min.cjs @@ -1,13 +1,13 @@ -"use strict";var ge=Object.defineProperty;var Fe=Object.getOwnPropertyDescriptor;var Ge=Object.getOwnPropertyNames;var Ve=Object.prototype.hasOwnProperty;var Ne=(e,t)=>{for(var n in t)ge(e,n,{get:t[n],enumerable:!0})},Qe=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of Ge(t))!Ve.call(e,i)&&i!==n&&ge(e,i,{get:()=>t[i],enumerable:!(o=Fe(t,i))||o.enumerable});return e};var qe=e=>Qe(ge({},"__esModule",{value:!0}),e);var dt={};Ne(dt,{Iterators:()=>Pe,UniqueID:()=>fe,tag:()=>$e,when:()=>me});module.exports=qe(dt);var S=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var se=5e3,E={log(...e){S&&console.log("(AI-UI) LOG:",...e,new Error().stack?.replace(/Error\n\s*.*\n/,` +"use strict";var ge=Object.defineProperty;var Fe=Object.getOwnPropertyDescriptor;var Ge=Object.getOwnPropertyNames;var Ve=Object.prototype.hasOwnProperty;var Ne=(e,t)=>{for(var n in t)ge(e,n,{get:t[n],enumerable:!0})},Qe=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let l of Ge(t))!Ve.call(e,l)&&l!==n&&ge(e,l,{get:()=>t[l],enumerable:!(o=Fe(t,l))||o.enumerable});return e};var qe=e=>Qe(ge({},"__esModule",{value:!0}),e);var dt={};Ne(dt,{Iterators:()=>Pe,UniqueID:()=>fe,tag:()=>$e,when:()=>me});module.exports=qe(dt);var S=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var se=5e3,E={log(...e){S&&console.log("(AI-UI) LOG:",...e,new Error().stack?.replace(/Error\n\s*.*\n/,` `))},warn(...e){S&&console.warn("(AI-UI) WARN:",...e,new Error().stack?.replace(/Error\n\s*.*\n/,` -`))},info(...e){S&&console.trace("(AI-UI) INFO:",...e)}};var ke=e=>{};function Ie(){let e=ke,t=ke,n=new Promise((...o)=>[e,t]=o);if(n.resolve=e,n.reject=t,S){let o=new Error().stack;n.catch(i=>i instanceof Error||i?.value instanceof Error?E.log("Deferred rejection",i,"allocated at ",o):void 0)}return n}function ie(e){return e&&typeof e=="object"||typeof e=="function"}function Y(e){return ie(e)&&"then"in e&&typeof e.then=="function"}var Pe={};Ne(Pe,{Ignore:()=>$,Iterability:()=>re,asyncExtras:()=>le,asyncIterator:()=>Ee,augmentGlobalAsyncGenerators:()=>nt,combine:()=>Re,debounceQueueIteratableIterator:()=>De,defineIterableProperty:()=>xe,filterMap:()=>Z,generatorHelpers:()=>Ye,isAsyncIter:()=>K,isAsyncIterable:()=>ce,isAsyncIterator:()=>ae,iterableHelpers:()=>B,merge:()=>ue,queueIteratableIterator:()=>ve});var re=Symbol("Iterability");function ae(e){return ie(e)&&"next"in e&&typeof e?.next=="function"}function ce(e){return ie(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function K(e){return ce(e)||ae(e)}function Ee(e){if(ae(e))return e;if(ce(e))return e[Symbol.asyncIterator]();throw new Error("Not an async provider")}var le={filterMap(e,t=$){return Z(this,e,t)},map:_e,filter:Je,unique:Xe,waitFor:et,multi:tt,initially:ze,consume:He,merge(...e){return ue(this,...e)},combine(e){return Re(Object.assign({_this:this},e))}},Te=[...Object.getOwnPropertySymbols(le),...Object.keys(le)];function be(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let o of n)Object.defineProperty(e,o,{...Object.getOwnPropertyDescriptor(t,o),enumerable:!1});return e}var D=Symbol("pending"),q=Symbol("items");function je(e=()=>{}){let t={[D]:[],[q]:[],[Symbol.asyncIterator](){return t},next(){if(t[q]?.length)return Promise.resolve(t[q].shift());if(!t[D])return Promise.resolve({done:!0,value:void 0});let n=Ie();return n.catch(o=>{}),t[D].unshift(n),n},return(n){let o={done:!0,value:void 0};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().resolve(o);t[q]=t[D]=null}return Promise.resolve(o)},throw(...n){let o={done:!0,value:n[0]};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().reject(o);t[q]=t[D]=null}return Promise.reject(o)},get length(){return t[q]?t[q].length:-1},push(n){return t[D]?(t[D].length?t[D].pop().resolve({done:!1,value:n}):t[q]?t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers"),!0):!1}};return B(t)}var pe=Symbol("inflight");function Ke(e=()=>{}){let t=je(e);return t[pe]=new Set,t.push=function(n){if(!t[D])return!1;if(t[pe].has(n))return!0;if(t[D].length){t[pe].add(n);let o=t[D].pop();o.finally(()=>t[pe].delete(n)),o.resolve({done:!1,value:n})}else t[q]?t[q].find(o=>o.value===n)||t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers");return!0},t}var ve=je,De=Ke,ne=Symbol("_proxiedAsyncIterator");function xe(e,t,n){let o=()=>{o=()=>W;let b=De(),x=b.multi(),W=x[Symbol.asyncIterator]();return u[Symbol.asyncIterator]=x[Symbol.asyncIterator],l=b.push,Te.forEach(O=>u[O]=W[O]),ne in s||be(s,u),W};function i(b){return{[b]:function(...x){return o(),s[b].apply(this,x)}}[b]}let u={[Symbol.asyncIterator]:o};Te.forEach(b=>u[b]=i(b)),typeof n=="object"&&n&&re in n&&n[re]==="shallow"&&(u[re]=n[re]);let l=b=>(o(),l(b)),s=h(n,u),c;return Object.defineProperty(e,t,{get(){return s},set(b){if(b!==s)if(ce(b)){if(c===b)return;c=b;let x=S?new Error:void 0;S&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),He.call(b,W=>{if(b!==c)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:x});l(W?.valueOf())}).catch(W=>E.info(W)).finally(()=>b===c&&(c=void 0));return}else c&&S&&E.log(`Iterable "${t.toString()}" is already piped from another iterator, and might be overrwitten later`),s=h(b,u);l(b?.valueOf())},enumerable:!0}),e;function h(b,x){if(b==null)return be(Object.create(null,{valueOf:{value(){return b},writable:!0,configurable:!0},toJSON:{value(){return b},writable:!0,configurable:!0}}),x);switch(typeof b){case"bigint":case"boolean":case"number":case"string":return be(Object(b),Object.assign(x,{toJSON(){return b.valueOf()}}));case"object":return ye(b,x)}throw new TypeError('Iterable properties cannot be of type "'+typeof b+'"')}function I(b){return ie(b)&&ne in b}function j(b,x){let W=x.split(".").slice(1);for(let O=0;OI(a)?a[ne]:{a,path:null})),Z(W,(a,f)=>{let m=j(a.a,F);return f!==m||a.path===null||a.path.startsWith(F)?m:$},$,j(b,F))[v]):(O??(O=Z(x,N=>I(N)?N[ne].a:N)),O[v]);if(v==="valueOf")return()=>j(b,F);if(v===Symbol.toPrimitive)return function(N){return Reflect.has(A,v)?Reflect.get(A,v,A).call(A,N):N==="string"?A.toString():N==="number"?Number(A):A.valueOf()};if(typeof v=="string"&&(!(v in A)||Object.hasOwn(A,v))&&!(re in A&&A[re]==="shallow")){let N=Reflect.get(A,v,G);return typeof N=="function"||K(N)?N:new Proxy(Object(N),oe(F+"."+v))}return Reflect.get(A,v,G)}}}}}var X=new Promise(()=>{}),ue=(...e)=>{let t=new Array(e.length),n=new Array(e.length),o=()=>{o=()=>{};for(let s=0;s({idx:s,result:h}))}},i=[],u=n.length,l={[Symbol.asyncIterator](){return l},next(){return o(),u?Promise.race(n).then(({idx:s,result:c})=>c.done?(u--,n[s]=X,i[s]=c.value,l.next()):(n[s]=t[s]?t[s].next().then(h=>({idx:s,result:h})).catch(h=>({idx:s,result:{done:!0,value:h}})):Promise.resolve({idx:s,result:{done:!0,value:void 0}}),c)).catch(s=>l.throw?.(s)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:i})},async return(s){for(let c=0;ch.value,h=>h));return{done:!0,value:i}},async throw(s){for(let c=0;ch.value,h=>h));return{done:!0,value:i}}};return B(l)},Re=(e,t={})=>{let n={},o,i=[],u=0,l={[Symbol.asyncIterator](){return l},next(){return o===void 0&&(o=Object.entries(e).map(([s,c],h)=>(u+=1,i[h]=c[Symbol.asyncIterator](),i[h].next().then(I=>({si:i,idx:h,k:s,ir:I}))))),function s(){return Promise.race(o).then(({idx:c,k:h,ir:I})=>I.done?(o[c]=X,u-=1,u?s():{done:!0,value:void 0}):(n[h]=I.value,o[c]=i[c].next().then(j=>({idx:c,k:h,ir:j})),t.ignorePartial&&Object.keys(n).length{c!==X&&i[h].return?.(s)}),Promise.resolve({done:!0,value:s})},throw(s){return o.forEach((c,h)=>{c!==X&&i[h].throw?.(s)}),Promise.reject({done:!0,value:s})}};return B(l)};function Be(e){return ce(e)&&Te.every(t=>t in e&&e[t]===le[t])}function B(e){return Be(e)||be(e,le),e}function Ye(e){return function(...t){let n=e(...t);return B(n)}}async function He(e){let t;for await(let n of this)t=e?.(n);await t}var $=Symbol("Ignore");function Ze(e,t,n){if(Y(e))return e.then(t,n);try{return t(e)}catch(o){return n(o)}}function Z(e,t,n=$,o=$){let i,u={[Symbol.asyncIterator](){return u},next(...l){if(n!==$){let s=Promise.resolve({done:!1,value:n});return n=$,s}return new Promise(function s(c,h){i||(i=e[Symbol.asyncIterator]()),i.next(...l).then(I=>I.done?c(I):Ze(t(I.value,o),j=>j===$?s(c,h):c({done:!1,value:o=j}),j=>{i.throw?i.throw(j):i.return?.(j),h({done:!0,value:j})}),I=>h({done:!0,value:I})).catch(I=>{i.throw?i.throw(I):i.return?.(I),h({done:!0,value:I})})})},throw(l){return Promise.resolve(i?.throw?i.throw(l):i?.return?.(l)).then(s=>({done:!0,value:s?.value}))},return(l){return Promise.resolve(i?.return?.(l)).then(s=>({done:!0,value:s?.value}))}};return B(u)}function _e(e){return Z(this,e)}function Je(e){return Z(this,async t=>await e(t)?t:$)}function Xe(e){return e?Z(this,async(t,n)=>n===$||await e(t,n)?t:$):Z(this,(t,n)=>t===n?$:t)}function ze(e){return Z(this,t=>t,e)}function et(e){return Z(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function tt(){let e=this,t=0,n,o;function i(l){l&&n.resolve(l),l?.done||(n=Ie(),o.next().then(i).catch(s=>n.reject({done:!0,value:s})))}let u={[Symbol.asyncIterator](){return t+=1,u},next(){return o||(o=e[Symbol.asyncIterator](),i()),n},throw(l){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:l}):Promise.resolve(o?.throw?o.throw(l):o?.return?.(l)).then(s=>({done:!0,value:s?.value}))},return(l){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:l}):Promise.resolve(o?.return?.(l)).then(s=>({done:!0,value:s?.value}))}};return B(u)}function nt(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){B(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var J=new WeakMap;function rt(e){J.has(this)||J.set(this,new Map);let t=J.get(this).get(e.type);if(t)for(let n of t)try{let{push:o,terminate:i,container:u,selector:l}=n;if(u.isConnected){if(e.target instanceof Node)if(l){let s=u.querySelectorAll(l);for(let c of s)(e.target===c||c.contains(e.target))&&u.contains(c)&&o(e)}else(e.target===u||u.contains(e.target))&&o(e)}else{let s="Container `#"+u.id+">"+(l||"")+"` removed from DOM. Removing subscription";t.delete(n),i(new Error(s))}}catch(o){E.warn("docEventHandler",o)}}function we(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function Oe(e){let t=e.split(":");if(t.length===1)return we(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&we(t[1])&&!we(t[0]))return[t[1],t[0]]}function ot(e){throw new Error(e)}function Ae(e,t){let[n,o]=Oe(t)??ot("Invalid WhenSelector: "+t);J.has(e.ownerDocument)||J.set(e.ownerDocument,new Map),J.get(e.ownerDocument).has(o)||(e.ownerDocument.addEventListener(o,rt,{passive:!0,capture:!0}),J.get(e.ownerDocument).set(o,new Set));let i=ve(()=>J.get(e.ownerDocument)?.get(o)?.delete(u)),u={push:i.push,terminate(l){i.return?.(l)},container:e,selector:n||null};return Ue(e,n?[n]:void 0).then(l=>J.get(e.ownerDocument)?.get(o).add(u)),i.multi()}async function*We(){await new Promise(()=>{}),yield void 0}function Se(e){function t(n){return e.map(n)}return Object.assign(B(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function at(e){if(!e)throw new Error(`Falsy async source will never be ready +`))},info(...e){S&&console.trace("(AI-UI) INFO:",...e)}};var ke=e=>{};function Ie(){let e=ke,t=ke,n=new Promise((...o)=>[e,t]=o);if(n.resolve=e,n.reject=t,S){let o=new Error().stack;n.catch(l=>l instanceof Error||l?.value instanceof Error?E.log("Deferred rejection",l,"allocated at ",o):void 0)}return n}function ie(e){return e&&typeof e=="object"||typeof e=="function"}function Y(e){return ie(e)&&"then"in e&&typeof e.then=="function"}var Pe={};Ne(Pe,{Ignore:()=>$,Iterability:()=>re,asyncExtras:()=>le,asyncIterator:()=>Ee,augmentGlobalAsyncGenerators:()=>nt,combine:()=>Re,debounceQueueIteratableIterator:()=>De,defineIterableProperty:()=>xe,filterMap:()=>Z,generatorHelpers:()=>Ye,isAsyncIter:()=>K,isAsyncIterable:()=>ce,isAsyncIterator:()=>ae,iterableHelpers:()=>B,merge:()=>ue,queueIteratableIterator:()=>ve});var re=Symbol("Iterability");function ae(e){return ie(e)&&"next"in e&&typeof e?.next=="function"}function ce(e){return ie(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function K(e){return ce(e)||ae(e)}function Ee(e){if(ae(e))return e;if(ce(e))return e[Symbol.asyncIterator]();throw new Error("Not an async provider")}var le={filterMap(e,t=$){return Z(this,e,t)},map:_e,filter:Je,unique:Xe,waitFor:et,multi:tt,initially:ze,consume:He,merge(...e){return ue(this,...e)},combine(e){return Re(Object.assign({_this:this},e))}},Te=[...Object.getOwnPropertySymbols(le),...Object.keys(le)];function be(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let o of n)Object.defineProperty(e,o,{...Object.getOwnPropertyDescriptor(t,o),enumerable:!1});return e}var D=Symbol("pending"),q=Symbol("items");function je(e=()=>{}){let t={[D]:[],[q]:[],[Symbol.asyncIterator](){return t},next(){if(t[q]?.length)return Promise.resolve(t[q].shift());if(!t[D])return Promise.resolve({done:!0,value:void 0});let n=Ie();return n.catch(o=>{}),t[D].unshift(n),n},return(n){let o={done:!0,value:void 0};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().resolve(o);t[q]=t[D]=null}return Promise.resolve(o)},throw(...n){let o={done:!0,value:n[0]};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().reject(o);t[q]=t[D]=null}return Promise.reject(o)},get length(){return t[q]?t[q].length:-1},push(n){return t[D]?(t[D].length?t[D].pop().resolve({done:!1,value:n}):t[q]?t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers"),!0):!1}};return B(t)}var pe=Symbol("inflight");function Ke(e=()=>{}){let t=je(e);return t[pe]=new Set,t.push=function(n){if(!t[D])return!1;if(t[pe].has(n))return!0;if(t[D].length){t[pe].add(n);let o=t[D].pop();o.finally(()=>t[pe].delete(n)),o.resolve({done:!1,value:n})}else t[q]?t[q].find(o=>o.value===n)||t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers");return!0},t}var ve=je,De=Ke,ne=Symbol("_proxiedAsyncIterator");function xe(e,t,n){let o=()=>{o=()=>W;let b=De(),x=b.multi(),W=x[Symbol.asyncIterator]();return d[Symbol.asyncIterator]=x[Symbol.asyncIterator],c=b.push,Te.forEach(O=>d[O]=W[O]),ne in s||be(s,d),W};function l(b){return{[b]:function(...x){return o(),s[b].apply(this,x)}}[b]}let d={[Symbol.asyncIterator]:o};Te.forEach(b=>d[b]=l(b)),typeof n=="object"&&n&&re in n&&n[re]==="shallow"&&(d[re]=n[re]);let c=b=>(o(),c(b)),s=h(n,d),u;return Object.defineProperty(e,t,{get(){return s},set(b){if(b!==s)if(ce(b)){if(u===b)return;u=b;let x=S?new Error:void 0;S&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),He.call(b,W=>{if(b!==u)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:x});c(W?.valueOf())}).catch(W=>E.info(W)).finally(()=>b===u&&(u=void 0));return}else u&&S&&E.log(`Iterable "${t.toString()}" is already piped from another iterator, and might be overrwitten later`),s=h(b,d);c(b?.valueOf())},enumerable:!0}),e;function h(b,x){if(b==null)return be(Object.create(null,{valueOf:{value(){return b},writable:!0,configurable:!0},toJSON:{value(){return b},writable:!0,configurable:!0}}),x);switch(typeof b){case"bigint":case"boolean":case"number":case"string":return be(Object(b),Object.assign(x,{toJSON(){return b.valueOf()}}));case"object":return ye(b,x)}throw new TypeError('Iterable properties cannot be of type "'+typeof b+'"')}function I(b){return ie(b)&&ne in b}function j(b,x){let W=x.split(".").slice(1);for(let O=0;OI(a)?a[ne]:{a,path:null})),Z(W,(a,f)=>{let m=j(a.a,F);return f!==m||a.path===null||a.path.startsWith(F)?m:$},$,j(b,F))[v]):(O??(O=Z(x,N=>I(N)?N[ne].a:N)),O[v]);if(v==="valueOf")return()=>j(b,F);if(v===Symbol.toPrimitive)return function(N){return Reflect.has(A,v)?Reflect.get(A,v,A).call(A,N):N==="string"?A.toString():N==="number"?Number(A):A.valueOf()};if(typeof v=="string"&&(!(v in A)||Object.hasOwn(A,v))&&!(re in A&&A[re]==="shallow")){let N=Reflect.get(A,v,G);return typeof N=="function"||K(N)?N:new Proxy(Object(N),oe(F+"."+v))}return Reflect.get(A,v,G)}}}}}var X=new Promise(()=>{}),ue=(...e)=>{let t=new Array(e.length),n=new Array(e.length),o=()=>{o=()=>{};for(let s=0;s({idx:s,result:h}))}},l=[],d=n.length,c={[Symbol.asyncIterator](){return c},next(){return o(),d?Promise.race(n).then(({idx:s,result:u})=>u.done?(d--,n[s]=X,l[s]=u.value,c.next()):(n[s]=t[s]?t[s].next().then(h=>({idx:s,result:h})).catch(h=>({idx:s,result:{done:!0,value:h}})):Promise.resolve({idx:s,result:{done:!0,value:void 0}}),u)).catch(s=>c.throw?.(s)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:l})},async return(s){for(let u=0;uh.value,h=>h));return{done:!0,value:l}},async throw(s){for(let u=0;uh.value,h=>h));return{done:!0,value:l}}};return B(c)},Re=(e,t={})=>{let n={},o,l=[],d=0,c={[Symbol.asyncIterator](){return c},next(){return o===void 0&&(o=Object.entries(e).map(([s,u],h)=>(d+=1,l[h]=u[Symbol.asyncIterator](),l[h].next().then(I=>({si:l,idx:h,k:s,ir:I}))))),function s(){return Promise.race(o).then(({idx:u,k:h,ir:I})=>I.done?(o[u]=X,d-=1,d?s():{done:!0,value:void 0}):(n[h]=I.value,o[u]=l[u].next().then(j=>({idx:u,k:h,ir:j})),t.ignorePartial&&Object.keys(n).length{u!==X&&l[h].return?.(s)}),Promise.resolve({done:!0,value:s})},throw(s){return o.forEach((u,h)=>{u!==X&&l[h].throw?.(s)}),Promise.reject({done:!0,value:s})}};return B(c)};function Be(e){return ce(e)&&Te.every(t=>t in e&&e[t]===le[t])}function B(e){return Be(e)||be(e,le),e}function Ye(e){return function(...t){let n=e(...t);return B(n)}}async function He(e){let t;for await(let n of this)t=e?.(n);await t}var $=Symbol("Ignore");function Ze(e,t,n){if(Y(e))return e.then(t,n);try{return t(e)}catch(o){return n(o)}}function Z(e,t,n=$,o=$){let l,d={[Symbol.asyncIterator](){return d},next(...c){if(n!==$){let s=Promise.resolve({done:!1,value:n});return n=$,s}return new Promise(function s(u,h){l||(l=e[Symbol.asyncIterator]()),l.next(...c).then(I=>I.done?u(I):Ze(t(I.value,o),j=>j===$?s(u,h):u({done:!1,value:o=j}),j=>{l.throw?l.throw(j):l.return?.(j),h({done:!0,value:j})}),I=>h({done:!0,value:I})).catch(I=>{l.throw?l.throw(I):l.return?.(I),h({done:!0,value:I})})})},throw(c){return Promise.resolve(l?.throw?l.throw(c):l?.return?.(c)).then(s=>({done:!0,value:s?.value}))},return(c){return Promise.resolve(l?.return?.(c)).then(s=>({done:!0,value:s?.value}))}};return B(d)}function _e(e){return Z(this,e)}function Je(e){return Z(this,async t=>await e(t)?t:$)}function Xe(e){return e?Z(this,async(t,n)=>n===$||await e(t,n)?t:$):Z(this,(t,n)=>t===n?$:t)}function ze(e){return Z(this,t=>t,e)}function et(e){return Z(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function tt(){let e=this,t=0,n,o;function l(c){c&&n.resolve(c),c?.done||(n=Ie(),o.next().then(l).catch(s=>n.reject({done:!0,value:s})))}let d={[Symbol.asyncIterator](){return t+=1,d},next(){return o||(o=e[Symbol.asyncIterator](),l()),n},throw(c){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:c}):Promise.resolve(o?.throw?o.throw(c):o?.return?.(c)).then(s=>({done:!0,value:s?.value}))},return(c){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:c}):Promise.resolve(o?.return?.(c)).then(s=>({done:!0,value:s?.value}))}};return B(d)}function nt(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){B(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var J=new WeakMap;function rt(e){J.has(this)||J.set(this,new Map);let t=J.get(this).get(e.type);if(t)for(let n of t)try{let{push:o,terminate:l,container:d,selector:c}=n;if(d.isConnected){if(e.target instanceof Node)if(c){let s=d.querySelectorAll(c);for(let u of s)(e.target===u||u.contains(e.target))&&d.contains(u)&&o(e)}else(e.target===d||d.contains(e.target))&&o(e)}else{let s="Container `#"+d.id+">"+(c||"")+"` removed from DOM. Removing subscription";t.delete(n),l(new Error(s))}}catch(o){E.warn("docEventHandler",o)}}function we(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function Oe(e){let t=e.split(":");if(t.length===1)return we(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&we(t[1])&&!we(t[0]))return[t[1],t[0]]}function ot(e){throw new Error(e)}function Ae(e,t){let[n,o]=Oe(t)??ot("Invalid WhenSelector: "+t);J.has(e.ownerDocument)||J.set(e.ownerDocument,new Map),J.get(e.ownerDocument).has(o)||(e.ownerDocument.addEventListener(o,rt,{passive:!0,capture:!0}),J.get(e.ownerDocument).set(o,new Set));let l=ve(()=>J.get(e.ownerDocument)?.get(o)?.delete(d)),d={push:l.push,terminate(c){l.return?.(c)},container:e,selector:n||null};return Ue(e,n?[n]:void 0).then(c=>J.get(e.ownerDocument)?.get(o).add(d)),l.multi()}async function*We(){await new Promise(()=>{}),yield void 0}function Se(e){function t(n){return e.map(n)}return Object.assign(B(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function at(e){if(!e)throw new Error(`Falsy async source will never be ready -`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!Oe(e)}async function*st(e){yield e}function me(e,...t){if(!t||t.length===0)return Se(Ae(e,"change"));let n=t.filter(u=>typeof u!="string"||u[0]!=="@").map(u=>typeof u=="string"?Ae(e,u):u instanceof Element?Ae(u,"change"):Y(u)?st(u):u);if(t.includes("@start")){let u={[Symbol.asyncIterator]:()=>u,next(){return u.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(u)}if(t.includes("@ready")){let l=function(I){return typeof I=="string"&&!e.querySelector(I)};var i=l;let s=t.filter(at).map(I=>Oe(I)?.[0]).filter(l),c,h={[Symbol.asyncIterator](){return h},throw(I){return c?.throw?c.throw(I):Promise.resolve({done:!0,value:I})},return(I){return c?.return?c.return(I):Promise.resolve({done:!0,value:I})},next(){return c?c.next():Ue(e,s).then(()=>(c=(n.length>1?ue(...n):n.length===1?n[0]:We())[Symbol.asyncIterator](),c?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Se(B(h))}let o=n.length>1?ue(...n):n.length===1?n[0]:We();return Se(B(o))}function Le(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,o)=>{n.some(i=>i.addedNodes?.length)&&e.isConnected&&(o.disconnect(),t())}).observe(e.ownerDocument.body,{subtree:!0,childList:!0}))}function Ue(e,t){return t?.length?Promise.all([it(e,t),Le(e)]):Le(e)}function it(e,t){if(t=t.filter(o=>!e.querySelector(o)),!t.length)return Promise.resolve();let n=new Promise(o=>new MutationObserver((i,u)=>{i.some(l=>l.addedNodes?.length)&&t.every(l=>e.querySelector(l))&&(u.disconnect(),o())}).observe(e,{subtree:!0,childList:!0}));if(S){let o=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),i=setTimeout(()=>{E.warn(o,t)},se);n.finally(()=>clearTimeout(i))}return n}var fe=Symbol("Unique ID"),z=S?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},lt=0,ct=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","link","main","map","mark","menu","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","script","search","section","select","slot","small","source","span","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr"];function ee(){throw new Error(".ids is a read-only map of Elements")}function he(e){return typeof e=="string"||typeof e=="number"||typeof e=="boolean"||e instanceof Node||e instanceof NodeList||e instanceof HTMLCollection||e===null||e===void 0||Array.isArray(e)||Y(e)||K(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var de=Symbol("callStack"),$e=function(e,t,n){let[o,i,u]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,ct,e],l=u?.commonProperties,s=u?.document??globalThis.document,c=ut(s,"removedNodes",u?.enableOnRemovedFromDOM);function h(){return s.createComment(S&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function I({error:a}){return s.createComment(a instanceof Error?a.toString():`Error: -`+JSON.stringify(a,null,2))}let j=s.createElement("STYLE");j.id="--ai-ui-extended-tag-styles-";let ye=new Set,b=Object.create(null,{when:{writable:!1,configurable:!0,enumerable:!1,value:function(...a){return me(this,...a)}},attributes:{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(a){if(K(a)){let f=ae(a)?a:a[Symbol.asyncIterator](),m=()=>f.next().then(({done:r,value:g})=>{F(this,g),r||m()},r=>E.warn(r));m()}else F(this,a)}},ids:{configurable:!0,enumerable:!0,set:ee,get(){let a=new Proxy(Object.create(null),{apply:ee,construct:ee,defineProperty:ee,deleteProperty:ee,set:ee,setPrototypeOf:ee,getPrototypeOf(){return null},isExtensible(){return!1},preventExtensions(){return!0},getOwnPropertyDescriptor(f,m){if(this.get(f,m,null))return Reflect.getOwnPropertyDescriptor(f,m)},has(f,m){return!!this.get(f,m,null)},ownKeys:f=>{let m=[...this.querySelectorAll("[id]")].map(g=>g.id),r=[...new Set(m)];return S&&m.length!==r.length&&E.log("Element contains multiple, shadowed decendant ids",r),r},get:(f,m,r)=>{if(typeof m=="string"){if(m in f){if(this.contains(f[m]))return f[m];delete f[m]}let g;if(S){let d=this.querySelectorAll("#"+CSS.escape(m));d.length>1&&(ye.has(m)||(ye.add(m),E.log(`Element contains multiple, shadowed decendants with ID "${m}"`))),g=d[0]}else g=this.querySelector("#"+CSS.escape(m))??void 0;return g&&(f[m]=g),g}}});return Object.defineProperty(this,"ids",{configurable:!0,enumerable:!0,set:ee,get(){return a}}),a}}});l&&O(b,l);function x(...a){let f=[];return function m(r){if(!(r==null||r===$)){if(Y(r)){let g=h();f.push(g),r.then(d=>g.replaceWith(...x(d)),d=>{E.warn(d,z(g)),g.replaceWith(I({error:d}))});return}if(r instanceof Node){f.push(r);return}if(r&&typeof r=="object"&&Symbol.iterator in r&&!(Symbol.asyncIterator in r)&&r[Symbol.iterator]){for(let g of r)m(g);return}if(K(r)){let g=S?` -`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",d=ae(r)?r:r[Symbol.asyncIterator](),R=r.valueOf(),te=R===void 0||R===r?[h()]:x(R),y=te.length?te:[h()];f.push(...y);let p=!0,T=Date.now()+se,P=S&&new Error("Created by").stack,Q=w=>{let M=y.filter(H=>!!H?.parentNode);M.length?(y=[I({error:w})],M[0].replaceWith(...y),M.slice(1).forEach(H=>H?.parentNode.removeChild(H))):E.warn("Can't report error",w,P,y.map(z)),y=[],d.return?.(w)},_=w=>{if(!w.done)try{let M=y.filter(k=>k?.parentNode&&k.isConnected),H=p?y:M;if(M.length&&(p=!1),!H.length||y.every(k=>c(k))){y=[];let k="Element(s) have been removed from the document: "+g;d.return?.(new Error(k));return}S&&p&&T&&T!y.includes(k)&&k.parentNode?.removeChild(k)),d.next().then(_).catch(Q)}catch(M){y=[],d.return?.(M)}};d.next().then(_).catch(Q);return}f.push(s.createTextNode(r.toString()))}}(a),f}o||Object.assign($e,{nodes:x,UniqueID:fe});let W=Object.getPrototypeOf({});function O(a,f,m){if(!(f==null||typeof f!="object"||f===a))for(let[r,g]of Object.entries(Object.getOwnPropertyDescriptors(f)))try{if("value"in g){let d=g.value;d&&K(d)?Object.defineProperty(a,r,g):d&&typeof d=="object"&&!Y(d)?r in a?d instanceof Node?(E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child",r,z(d)),a[r]=d):a[r]!==d&&(Array.isArray(a[r])&&a[r].length!==d.length?d.constructor===Object||d.constructor===Array?O(a[r]=new d.constructor,d):a[r]=d:O(a[r],d)):(m&&(Object.getPrototypeOf(d)===W||!Object.getPrototypeOf(d)?O(g.value={},d):Array.isArray(d)?O(g.value=[],d):E.warn(`Declared propety '${r}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,a,d)),Object.defineProperty(a,r,g)):f[r]!==void 0&&(a[r]=f[r])}else Object.defineProperty(a,r,g)}catch(d){throw E.warn("deepAssign",r,f[r],d),d}}function oe(a){let f=a?.valueOf();return Array.isArray(f)?Array.prototype.map.call(f,oe):f}function F(a,f){de in f||function m(r,g){if(g==null||typeof g!="object")return;let d=Object.entries(Object.getOwnPropertyDescriptors(g));Array.isArray(g)||d.sort(y=>{let p=Object.getOwnPropertyDescriptor(r,y[0]);if(p){if("value"in p)return-1;if("set"in p||"get"in p)return 1}return 0});for(let[y,p]of d)try{if("value"in p){let T=p.value;K(T)?R(T,y):Y(T)?T.then(P=>{P&&typeof P=="object"?K(P)?R(P,y):te(P,y):g[y]!==void 0&&(r[y]=P)},P=>E.log("Failed to set attribute",P)):K(T)||(T&&typeof T=="object"&&!Y(T)?te(T,y):g[y]!==void 0&&(r[y]=g[y]))}else Object.defineProperty(r,y,p)}catch(T){throw E.warn("assignProps",y,g[y],T),T}function R(y,p){let T=Ee(y),P=!0,Q=Date.now()+se,_=S&&new Error("Created by").stack,w=k=>{if(!k.done){let C=oe(k.value);if(typeof C=="object"&&C!==null){let L=Object.getOwnPropertyDescriptor(r,p);p==="style"||!L?.set?m(r[p],C):r[p]=C}else C!==void 0&&(r[p]=C);let V=a.isConnected;if(c(a)||!P&&!V){E.info(`Element does not exist in document when setting async attribute '${p}' to: +`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!Oe(e)}async function*st(e){yield e}function me(e,...t){if(!t||t.length===0)return Se(Ae(e,"change"));let n=t.filter(d=>typeof d!="string"||d[0]!=="@").map(d=>typeof d=="string"?Ae(e,d):d instanceof Element?Ae(d,"change"):Y(d)?st(d):d);if(t.includes("@start")){let d={[Symbol.asyncIterator]:()=>d,next(){return d.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(d)}if(t.includes("@ready")){let c=function(I){return typeof I=="string"&&!e.querySelector(I)};var l=c;let s=t.filter(at).map(I=>Oe(I)?.[0]).filter(c),u,h={[Symbol.asyncIterator](){return h},throw(I){return u?.throw?u.throw(I):Promise.resolve({done:!0,value:I})},return(I){return u?.return?u.return(I):Promise.resolve({done:!0,value:I})},next(){return u?u.next():Ue(e,s).then(()=>(u=(n.length>1?ue(...n):n.length===1?n[0]:We())[Symbol.asyncIterator](),u?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Se(B(h))}let o=n.length>1?ue(...n):n.length===1?n[0]:We();return Se(B(o))}function Le(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,o)=>{n.some(l=>l.addedNodes?.length)&&e.isConnected&&(o.disconnect(),t())}).observe(e.ownerDocument.body,{subtree:!0,childList:!0}))}function Ue(e,t){return t?.length?Promise.all([it(e,t),Le(e)]):Le(e)}function it(e,t){if(t=t.filter(o=>!e.querySelector(o)),!t.length)return Promise.resolve();let n=new Promise(o=>new MutationObserver((l,d)=>{l.some(c=>c.addedNodes?.length)&&t.every(c=>e.querySelector(c))&&(d.disconnect(),o())}).observe(e,{subtree:!0,childList:!0}));if(S){let o=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),l=setTimeout(()=>{E.warn(o,t)},se);n.finally(()=>clearTimeout(l))}return n}var fe=Symbol("Unique ID"),z=S?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},lt=0,ct=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","link","main","map","mark","menu","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","script","search","section","select","slot","small","source","span","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr"];function ee(){throw new Error(".ids is a read-only map of Elements")}function he(e){return typeof e=="string"||typeof e=="number"||typeof e=="boolean"||e instanceof Node||e instanceof NodeList||e instanceof HTMLCollection||e===null||e===void 0||Array.isArray(e)||Y(e)||K(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var de=Symbol("callStack"),$e=function(e,t,n){let[o,l,d]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,ct,e],c=d?.commonProperties,s=d?.document??globalThis.document,u=ut(s,"removedNodes",d?.enableOnRemovedFromDOM);function h(){return s.createComment(S&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function I({error:a}){return s.createComment(a instanceof Error?a.toString():`Error: +`+JSON.stringify(a,null,2))}let j=s.createElement("STYLE");j.id="--ai-ui-extended-tag-styles-";let ye=new Set,b=Object.create(null,{when:{writable:!1,configurable:!0,enumerable:!1,value:function(...a){return me(this,...a)}},attributes:{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(a){if(K(a)){let f=ae(a)?a:a[Symbol.asyncIterator](),m=()=>f.next().then(({done:r,value:g})=>{F(this,g),r||m()},r=>E.warn(r));m()}else F(this,a)}},ids:{configurable:!0,enumerable:!0,set:ee,get(){let a=new Proxy(Object.create(null),{apply:ee,construct:ee,defineProperty:ee,deleteProperty:ee,set:ee,setPrototypeOf:ee,getPrototypeOf(){return null},isExtensible(){return!1},preventExtensions(){return!0},getOwnPropertyDescriptor(f,m){if(this.get(f,m,null))return Reflect.getOwnPropertyDescriptor(f,m)},has(f,m){return!!this.get(f,m,null)},ownKeys:f=>{let m=[...this.querySelectorAll("[id]")].map(g=>g.id),r=[...new Set(m)];return S&&m.length!==r.length&&E.log("Element contains multiple, shadowed decendant ids",r),r},get:(f,m,r)=>{if(typeof m=="string"){if(m in f){let i=f[m].deref();if(i&&i.id===m&&this.contains(i))return i;delete f[m]}let g;if(S){let i=this.querySelectorAll("#"+CSS.escape(m));i.length>1&&(ye.has(m)||(ye.add(m),E.log(`Element contains multiple, shadowed decendants with ID "${m}"`))),g=i[0]}else g=this.querySelector("#"+CSS.escape(m))??void 0;return g&&(f[m]=new WeakRef(g)),g}}});return Object.defineProperty(this,"ids",{configurable:!0,enumerable:!0,set:ee,get(){return a}}),a}}});c&&O(b,c);function x(...a){let f=[];return function m(r){if(!(r==null||r===$)){if(Y(r)){let g=h();f.push(g),r.then(i=>g.replaceWith(...x(i)),i=>{E.warn(i,z(g)),g.replaceWith(I({error:i}))});return}if(r instanceof Node){f.push(r);return}if(r&&typeof r=="object"&&Symbol.iterator in r&&!(Symbol.asyncIterator in r)&&r[Symbol.iterator]){for(let g of r)m(g);return}if(K(r)){let g=S?` +`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",i=ae(r)?r:r[Symbol.asyncIterator](),R=r.valueOf(),te=R===void 0||R===r?[h()]:x(R),y=te.length?te:[h()];f.push(...y);let p=!0,T=Date.now()+se,P=S&&new Error("Created by").stack,Q=w=>{let M=y.filter(H=>!!H?.parentNode);M.length?(y=[I({error:w})],M[0].replaceWith(...y),M.slice(1).forEach(H=>H?.parentNode.removeChild(H))):E.warn("Can't report error",w,P,y.map(z)),y=[],i.return?.(w)},_=w=>{if(!w.done)try{let M=y.filter(k=>k?.parentNode&&k.isConnected),H=p?y:M;if(M.length&&(p=!1),!H.length||y.every(k=>u(k))){y=[];let k="Element(s) have been removed from the document: "+g;i.return?.(new Error(k));return}S&&p&&T&&T!y.includes(k)&&k.parentNode?.removeChild(k)),i.next().then(_).catch(Q)}catch(M){y=[],i.return?.(M)}};i.next().then(_).catch(Q);return}f.push(s.createTextNode(r.toString()))}}(a),f}o||Object.assign($e,{nodes:x,UniqueID:fe});let W=Object.getPrototypeOf({});function O(a,f,m){if(!(f==null||typeof f!="object"||f===a))for(let[r,g]of Object.entries(Object.getOwnPropertyDescriptors(f)))try{if("value"in g){let i=g.value;i&&K(i)?Object.defineProperty(a,r,g):i&&typeof i=="object"&&!Y(i)?r in a?i instanceof Node?(E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child",r,z(i)),a[r]=i):a[r]!==i&&(Array.isArray(a[r])&&a[r].length!==i.length?i.constructor===Object||i.constructor===Array?O(a[r]=new i.constructor,i):a[r]=i:O(a[r],i)):(m&&(Object.getPrototypeOf(i)===W||!Object.getPrototypeOf(i)?O(g.value={},i):Array.isArray(i)?O(g.value=[],i):E.warn(`Declared propety '${r}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,a,i)),Object.defineProperty(a,r,g)):f[r]!==void 0&&(a[r]=f[r])}else Object.defineProperty(a,r,g)}catch(i){throw E.warn("deepAssign",r,f[r],i),i}}function oe(a){let f=a?.valueOf();return Array.isArray(f)?Array.prototype.map.call(f,oe):f}function F(a,f){de in f||function m(r,g){if(g==null||typeof g!="object")return;let i=Object.entries(Object.getOwnPropertyDescriptors(g));Array.isArray(g)||i.sort(y=>{let p=Object.getOwnPropertyDescriptor(r,y[0]);if(p){if("value"in p)return-1;if("set"in p||"get"in p)return 1}return 0});for(let[y,p]of i)try{if("value"in p){let T=p.value;K(T)?R(T,y):Y(T)?T.then(P=>{P&&typeof P=="object"?K(P)?R(P,y):te(P,y):g[y]!==void 0&&(r[y]=P)},P=>E.log("Failed to set attribute",P)):K(T)||(T&&typeof T=="object"&&!Y(T)?te(T,y):g[y]!==void 0&&(r[y]=g[y]))}else Object.defineProperty(r,y,p)}catch(T){throw E.warn("assignProps",y,g[y],T),T}function R(y,p){let T=Ee(y),P=!0,Q=Date.now()+se,_=S&&new Error("Created by").stack,w=k=>{if(!k.done){let C=oe(k.value);if(typeof C=="object"&&C!==null){let L=Object.getOwnPropertyDescriptor(r,p);p==="style"||!L?.set?m(r[p],C):r[p]=C}else C!==void 0&&(r[p]=C);let V=a.isConnected;if(u(a)||!P&&!V){E.info(`Element does not exist in document when setting async attribute '${p}' to: ${z(a)}`),T.return?.();return}V&&(P=!1),P&&Q&&Q{E.warn("Dynamic attribute error",k,p,r,_,z(a)),T.return?.(k),a.appendChild(I({error:k}))},H=y.valueOf();H!==void 0&&H!==y&&!K(H)?w({done:!1,value:H}):T.next().then(w).catch(M)}function te(y,p){if(y instanceof Node)E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes",p,z(y)),r[p]=y;else if(!(p in r)||r[p]===y||Array.isArray(r[p])&&r[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let T=new y.constructor;m(T,y),r[p]=T}else r[p]=y;else Object.getOwnPropertyDescriptor(r,p)?.set?r[p]=y:m(r[p],y)}}(a,f)}function A(a){for(let f=a.constructor;f;f=f.super)if(f===this)return!0;return!1}function v(a){let f=typeof a!="function"?p=>Object.assign({},a,p):a,m=Date.now().toString(36)+(lt++).toString(36)+Math.random().toString(36).slice(2),r=f({[fe]:m});r.styles&&(j.appendChild(s.createTextNode(r.styles+` -`)),s.head.contains(j)||s.head.appendChild(j));let d=Object.assign((p,...T)=>{let P=he(p),Q=[],_={[de]:(P?Q:p[de])??Q},w=P?this(_,p,...T):this(_,...T);w.constructor=d;let M=f({[fe]:m});if(_[de].push(M),S){let C=function(V,L){for(let U=V;U;U=U.super)if(U.definition?.declare&&L in U.definition.declare)return!0;return!1};var k=C;if(M.declare){let V=Object.keys(M.declare).filter(L=>L in w||C(this,L));V.length&&E.log(`Declared keys '${V}' in ${d.name} already exist in base '${this.valueOf()}'`)}if(M.override){let V=Object.keys(M.override).filter(L=>!(L in w)&&!(l&&L in l)&&!C(this,L));V.length&&E.log(`Overridden keys '${V}' in ${d.name} do not exist in base '${this.valueOf()}'`)}}O(w,M.declare,!0),O(w,M.override);let H=new Set;if(M.iterable&&Object.keys(M.iterable).forEach(C=>{C in w?(E.log(`Ignoring attempt to re-define iterable property "${C}" as it could already have consumers`),H.add(C)):xe(w,C,M.iterable[C])}),_[de]===Q){P||F(w,p);for(let L of Q){let U=L?.constructed?.call(w);he(U)&&w.append(...x(U))}let C={},V=!1;for(let L of Q)if(L.iterable)for(let U of Object.keys(L.iterable)){let Me=!P&&U in p;if(H.has(U)&&Me||!(Me&&(!Y(p[U])||!K(p[U])))){let Ce=w[U]?.valueOf();Ce!==void 0&&(C[U]=Ce,V=!0)}}V&&Object.assign(w,C)}return w},{super:this,definition:Object.assign(r,{[fe]:m}),extended:v,valueOf:()=>{let p=[...Object.keys(r.declare||{}),...Object.keys(r.iterable||{})];return`${d.name}: {${p.join(", ")}} - \u21AA ${this.valueOf()}`}});Object.defineProperty(d,Symbol.hasInstance,{value:A,writable:!0,configurable:!0});let R={};(function p(T){T?.super&&p(T.super);let P=T.definition;P&&(O(R,P?.override),O(R,P?.declare))})(this),O(R,r.override),O(R,r.declare),Object.defineProperties(d,Object.getOwnPropertyDescriptors(R));let te=R&&"className"in R&&typeof R.className=="string"?R.className:m,y=S?new Error().stack?.split(` -`)[2]??"":"";if(Object.defineProperty(d,"name",{value:""}),S){let p=Object.keys(r).filter(T=>!["styles","ids","constructed","declare","override","iterable"].includes(T));p.length&&E.log(`${d.name} defines extraneous keys '${p}', which are unknown`)}return d}let G={createElement(a,f,...m){return a===G.createElement?x(...m):typeof a=="function"?a(f,m):typeof a=="string"&&a in G?G[a](f,m):a instanceof Node?a:I({error:new Error("Illegal type in createElement:"+a)})}};function N(a){if(G[a])return G[a];let f=(r,...g)=>{if(he(r)&&(g.unshift(r),r={}),!he(r)){if(r.debugger){debugger;delete r.debugger}let d=o?s.createElementNS(o,a.toLowerCase()):s.createElement(a);return d.constructor=f,O(d,b),F(d,r),d.append(...x(...g)),d}},m=Object.assign(f,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:v,valueOf(){return`TagCreator: <${o||""}${o?"::":""}${a}>`}});return Object.defineProperty(f,Symbol.hasInstance,{value:A,writable:!0,configurable:!0}),Object.defineProperty(f,"name",{value:"<"+a+">"}),G[a]=m}return i.forEach(N),G};function ut(e,t,n){let o=new WeakSet;function i(u){for(let l of u)t==="addedNodes"===l.isConnected&&(i(l.childNodes),o.add(l),n&&"onRemovedFromDOM"in l&&typeof l.onRemovedFromDOM=="function"&&l.onRemovedFromDOM())}return new MutationObserver(u=>{u.forEach(function(l){l.type==="childList"&&l[t].length&&i(l[t])})}).observe(e,{subtree:!0,childList:!0}),function(u){return o.has(u)}} +`)),s.head.contains(j)||s.head.appendChild(j));let i=Object.assign((p,...T)=>{let P=he(p),Q=[],_={[de]:(P?Q:p[de])??Q},w=P?this(_,p,...T):this(_,...T);w.constructor=i;let M=f({[fe]:m});if(_[de].push(M),S){let C=function(V,L){for(let U=V;U;U=U.super)if(U.definition?.declare&&L in U.definition.declare)return!0;return!1};var k=C;if(M.declare){let V=Object.keys(M.declare).filter(L=>L in w||C(this,L));V.length&&E.log(`Declared keys '${V}' in ${i.name} already exist in base '${this.valueOf()}'`)}if(M.override){let V=Object.keys(M.override).filter(L=>!(L in w)&&!(c&&L in c)&&!C(this,L));V.length&&E.log(`Overridden keys '${V}' in ${i.name} do not exist in base '${this.valueOf()}'`)}}O(w,M.declare,!0),O(w,M.override);let H=new Set;if(M.iterable&&Object.keys(M.iterable).forEach(C=>{C in w?(E.log(`Ignoring attempt to re-define iterable property "${C}" as it could already have consumers`),H.add(C)):xe(w,C,M.iterable[C])}),_[de]===Q){P||F(w,p);for(let L of Q){let U=L?.constructed?.call(w);he(U)&&w.append(...x(U))}let C={},V=!1;for(let L of Q)if(L.iterable)for(let U of Object.keys(L.iterable)){let Me=!P&&U in p;if(H.has(U)&&Me||!(Me&&(!Y(p[U])||!K(p[U])))){let Ce=w[U]?.valueOf();Ce!==void 0&&(C[U]=Ce,V=!0)}}V&&Object.assign(w,C)}return w},{super:this,definition:Object.assign(r,{[fe]:m}),extended:v,valueOf:()=>{let p=[...Object.keys(r.declare||{}),...Object.keys(r.iterable||{})];return`${i.name}: {${p.join(", ")}} + \u21AA ${this.valueOf()}`}});Object.defineProperty(i,Symbol.hasInstance,{value:A,writable:!0,configurable:!0});let R={};(function p(T){T?.super&&p(T.super);let P=T.definition;P&&(O(R,P?.override),O(R,P?.declare))})(this),O(R,r.override),O(R,r.declare),Object.defineProperties(i,Object.getOwnPropertyDescriptors(R));let te=R&&"className"in R&&typeof R.className=="string"?R.className:m,y=S?new Error().stack?.split(` +`)[2]??"":"";if(Object.defineProperty(i,"name",{value:""}),S){let p=Object.keys(r).filter(T=>!["styles","ids","constructed","declare","override","iterable"].includes(T));p.length&&E.log(`${i.name} defines extraneous keys '${p}', which are unknown`)}return i}let G={createElement(a,f,...m){return a===G.createElement?x(...m):typeof a=="function"?a(f,m):typeof a=="string"&&a in G?G[a](f,m):a instanceof Node?a:I({error:new Error("Illegal type in createElement:"+a)})}};function N(a){if(G[a])return G[a];let f=(r,...g)=>{if(he(r)&&(g.unshift(r),r={}),!he(r)){if(r.debugger){debugger;delete r.debugger}let i=o?s.createElementNS(o,a.toLowerCase()):s.createElement(a);return i.constructor=f,O(i,b),F(i,r),i.append(...x(...g)),i}},m=Object.assign(f,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:v,valueOf(){return`TagCreator: <${o||""}${o?"::":""}${a}>`}});return Object.defineProperty(f,Symbol.hasInstance,{value:A,writable:!0,configurable:!0}),Object.defineProperty(f,"name",{value:"<"+a+">"}),G[a]=m}return l.forEach(N),G};function ut(e,t,n){let o=new WeakSet;function l(d){for(let c of d)t==="addedNodes"===c.isConnected&&(l(c.childNodes),o.add(c),n&&"onRemovedFromDOM"in c&&typeof c.onRemovedFromDOM=="function"&&c.onRemovedFromDOM())}return new MutationObserver(d=>{d.forEach(function(c){c.type==="childList"&&c[t].length&&l(c[t])})}).observe(e,{subtree:!0,childList:!0}),function(d){return o.has(d)}} diff --git a/module/dist/ai-ui.min.js b/module/dist/ai-ui.min.js index 6a723d1..24b1af6 100644 --- a/module/dist/ai-ui.min.js +++ b/module/dist/ai-ui.min.js @@ -1,13 +1,13 @@ -"use strict";var AIUI=(()=>{var ge=Object.defineProperty;var Fe=Object.getOwnPropertyDescriptor;var Ge=Object.getOwnPropertyNames;var Ve=Object.prototype.hasOwnProperty;var Ne=(e,t)=>{for(var n in t)ge(e,n,{get:t[n],enumerable:!0})},Qe=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of Ge(t))!Ve.call(e,i)&&i!==n&&ge(e,i,{get:()=>t[i],enumerable:!(o=Fe(t,i))||o.enumerable});return e};var qe=e=>Qe(ge({},"__esModule",{value:!0}),e);var dt={};Ne(dt,{Iterators:()=>Pe,UniqueID:()=>fe,tag:()=>$e,when:()=>me});var S=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var se=5e3,E={log(...e){S&&console.log("(AI-UI) LOG:",...e,new Error().stack?.replace(/Error\n\s*.*\n/,` +"use strict";var AIUI=(()=>{var ge=Object.defineProperty;var Fe=Object.getOwnPropertyDescriptor;var Ge=Object.getOwnPropertyNames;var Ve=Object.prototype.hasOwnProperty;var Ne=(e,t)=>{for(var n in t)ge(e,n,{get:t[n],enumerable:!0})},Qe=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let l of Ge(t))!Ve.call(e,l)&&l!==n&&ge(e,l,{get:()=>t[l],enumerable:!(o=Fe(t,l))||o.enumerable});return e};var qe=e=>Qe(ge({},"__esModule",{value:!0}),e);var dt={};Ne(dt,{Iterators:()=>Pe,UniqueID:()=>fe,tag:()=>$e,when:()=>me});var S=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var se=5e3,E={log(...e){S&&console.log("(AI-UI) LOG:",...e,new Error().stack?.replace(/Error\n\s*.*\n/,` `))},warn(...e){S&&console.warn("(AI-UI) WARN:",...e,new Error().stack?.replace(/Error\n\s*.*\n/,` -`))},info(...e){S&&console.trace("(AI-UI) INFO:",...e)}};var ke=e=>{};function Ie(){let e=ke,t=ke,n=new Promise((...o)=>[e,t]=o);if(n.resolve=e,n.reject=t,S){let o=new Error().stack;n.catch(i=>i instanceof Error||i?.value instanceof Error?E.log("Deferred rejection",i,"allocated at ",o):void 0)}return n}function ie(e){return e&&typeof e=="object"||typeof e=="function"}function Y(e){return ie(e)&&"then"in e&&typeof e.then=="function"}var Pe={};Ne(Pe,{Ignore:()=>$,Iterability:()=>re,asyncExtras:()=>le,asyncIterator:()=>Ee,augmentGlobalAsyncGenerators:()=>nt,combine:()=>Re,debounceQueueIteratableIterator:()=>De,defineIterableProperty:()=>xe,filterMap:()=>Z,generatorHelpers:()=>Ye,isAsyncIter:()=>K,isAsyncIterable:()=>ce,isAsyncIterator:()=>ae,iterableHelpers:()=>B,merge:()=>ue,queueIteratableIterator:()=>ve});var re=Symbol("Iterability");function ae(e){return ie(e)&&"next"in e&&typeof e?.next=="function"}function ce(e){return ie(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function K(e){return ce(e)||ae(e)}function Ee(e){if(ae(e))return e;if(ce(e))return e[Symbol.asyncIterator]();throw new Error("Not an async provider")}var le={filterMap(e,t=$){return Z(this,e,t)},map:_e,filter:Je,unique:Xe,waitFor:et,multi:tt,initially:ze,consume:He,merge(...e){return ue(this,...e)},combine(e){return Re(Object.assign({_this:this},e))}},Te=[...Object.getOwnPropertySymbols(le),...Object.keys(le)];function be(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let o of n)Object.defineProperty(e,o,{...Object.getOwnPropertyDescriptor(t,o),enumerable:!1});return e}var D=Symbol("pending"),q=Symbol("items");function je(e=()=>{}){let t={[D]:[],[q]:[],[Symbol.asyncIterator](){return t},next(){if(t[q]?.length)return Promise.resolve(t[q].shift());if(!t[D])return Promise.resolve({done:!0,value:void 0});let n=Ie();return n.catch(o=>{}),t[D].unshift(n),n},return(n){let o={done:!0,value:void 0};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().resolve(o);t[q]=t[D]=null}return Promise.resolve(o)},throw(...n){let o={done:!0,value:n[0]};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().reject(o);t[q]=t[D]=null}return Promise.reject(o)},get length(){return t[q]?t[q].length:-1},push(n){return t[D]?(t[D].length?t[D].pop().resolve({done:!1,value:n}):t[q]?t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers"),!0):!1}};return B(t)}var pe=Symbol("inflight");function Ke(e=()=>{}){let t=je(e);return t[pe]=new Set,t.push=function(n){if(!t[D])return!1;if(t[pe].has(n))return!0;if(t[D].length){t[pe].add(n);let o=t[D].pop();o.finally(()=>t[pe].delete(n)),o.resolve({done:!1,value:n})}else t[q]?t[q].find(o=>o.value===n)||t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers");return!0},t}var ve=je,De=Ke,ne=Symbol("_proxiedAsyncIterator");function xe(e,t,n){let o=()=>{o=()=>W;let b=De(),x=b.multi(),W=x[Symbol.asyncIterator]();return u[Symbol.asyncIterator]=x[Symbol.asyncIterator],l=b.push,Te.forEach(O=>u[O]=W[O]),ne in s||be(s,u),W};function i(b){return{[b]:function(...x){return o(),s[b].apply(this,x)}}[b]}let u={[Symbol.asyncIterator]:o};Te.forEach(b=>u[b]=i(b)),typeof n=="object"&&n&&re in n&&n[re]==="shallow"&&(u[re]=n[re]);let l=b=>(o(),l(b)),s=h(n,u),c;return Object.defineProperty(e,t,{get(){return s},set(b){if(b!==s)if(ce(b)){if(c===b)return;c=b;let x=S?new Error:void 0;S&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),He.call(b,W=>{if(b!==c)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:x});l(W?.valueOf())}).catch(W=>E.info(W)).finally(()=>b===c&&(c=void 0));return}else c&&S&&E.log(`Iterable "${t.toString()}" is already piped from another iterator, and might be overrwitten later`),s=h(b,u);l(b?.valueOf())},enumerable:!0}),e;function h(b,x){if(b==null)return be(Object.create(null,{valueOf:{value(){return b},writable:!0,configurable:!0},toJSON:{value(){return b},writable:!0,configurable:!0}}),x);switch(typeof b){case"bigint":case"boolean":case"number":case"string":return be(Object(b),Object.assign(x,{toJSON(){return b.valueOf()}}));case"object":return ye(b,x)}throw new TypeError('Iterable properties cannot be of type "'+typeof b+'"')}function I(b){return ie(b)&&ne in b}function j(b,x){let W=x.split(".").slice(1);for(let O=0;OI(a)?a[ne]:{a,path:null})),Z(W,(a,f)=>{let m=j(a.a,F);return f!==m||a.path===null||a.path.startsWith(F)?m:$},$,j(b,F))[v]):(O??(O=Z(x,N=>I(N)?N[ne].a:N)),O[v]);if(v==="valueOf")return()=>j(b,F);if(v===Symbol.toPrimitive)return function(N){return Reflect.has(A,v)?Reflect.get(A,v,A).call(A,N):N==="string"?A.toString():N==="number"?Number(A):A.valueOf()};if(typeof v=="string"&&(!(v in A)||Object.hasOwn(A,v))&&!(re in A&&A[re]==="shallow")){let N=Reflect.get(A,v,G);return typeof N=="function"||K(N)?N:new Proxy(Object(N),oe(F+"."+v))}return Reflect.get(A,v,G)}}}}}var X=new Promise(()=>{}),ue=(...e)=>{let t=new Array(e.length),n=new Array(e.length),o=()=>{o=()=>{};for(let s=0;s({idx:s,result:h}))}},i=[],u=n.length,l={[Symbol.asyncIterator](){return l},next(){return o(),u?Promise.race(n).then(({idx:s,result:c})=>c.done?(u--,n[s]=X,i[s]=c.value,l.next()):(n[s]=t[s]?t[s].next().then(h=>({idx:s,result:h})).catch(h=>({idx:s,result:{done:!0,value:h}})):Promise.resolve({idx:s,result:{done:!0,value:void 0}}),c)).catch(s=>l.throw?.(s)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:i})},async return(s){for(let c=0;ch.value,h=>h));return{done:!0,value:i}},async throw(s){for(let c=0;ch.value,h=>h));return{done:!0,value:i}}};return B(l)},Re=(e,t={})=>{let n={},o,i=[],u=0,l={[Symbol.asyncIterator](){return l},next(){return o===void 0&&(o=Object.entries(e).map(([s,c],h)=>(u+=1,i[h]=c[Symbol.asyncIterator](),i[h].next().then(I=>({si:i,idx:h,k:s,ir:I}))))),function s(){return Promise.race(o).then(({idx:c,k:h,ir:I})=>I.done?(o[c]=X,u-=1,u?s():{done:!0,value:void 0}):(n[h]=I.value,o[c]=i[c].next().then(j=>({idx:c,k:h,ir:j})),t.ignorePartial&&Object.keys(n).length{c!==X&&i[h].return?.(s)}),Promise.resolve({done:!0,value:s})},throw(s){return o.forEach((c,h)=>{c!==X&&i[h].throw?.(s)}),Promise.reject({done:!0,value:s})}};return B(l)};function Be(e){return ce(e)&&Te.every(t=>t in e&&e[t]===le[t])}function B(e){return Be(e)||be(e,le),e}function Ye(e){return function(...t){let n=e(...t);return B(n)}}async function He(e){let t;for await(let n of this)t=e?.(n);await t}var $=Symbol("Ignore");function Ze(e,t,n){if(Y(e))return e.then(t,n);try{return t(e)}catch(o){return n(o)}}function Z(e,t,n=$,o=$){let i,u={[Symbol.asyncIterator](){return u},next(...l){if(n!==$){let s=Promise.resolve({done:!1,value:n});return n=$,s}return new Promise(function s(c,h){i||(i=e[Symbol.asyncIterator]()),i.next(...l).then(I=>I.done?c(I):Ze(t(I.value,o),j=>j===$?s(c,h):c({done:!1,value:o=j}),j=>{i.throw?i.throw(j):i.return?.(j),h({done:!0,value:j})}),I=>h({done:!0,value:I})).catch(I=>{i.throw?i.throw(I):i.return?.(I),h({done:!0,value:I})})})},throw(l){return Promise.resolve(i?.throw?i.throw(l):i?.return?.(l)).then(s=>({done:!0,value:s?.value}))},return(l){return Promise.resolve(i?.return?.(l)).then(s=>({done:!0,value:s?.value}))}};return B(u)}function _e(e){return Z(this,e)}function Je(e){return Z(this,async t=>await e(t)?t:$)}function Xe(e){return e?Z(this,async(t,n)=>n===$||await e(t,n)?t:$):Z(this,(t,n)=>t===n?$:t)}function ze(e){return Z(this,t=>t,e)}function et(e){return Z(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function tt(){let e=this,t=0,n,o;function i(l){l&&n.resolve(l),l?.done||(n=Ie(),o.next().then(i).catch(s=>n.reject({done:!0,value:s})))}let u={[Symbol.asyncIterator](){return t+=1,u},next(){return o||(o=e[Symbol.asyncIterator](),i()),n},throw(l){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:l}):Promise.resolve(o?.throw?o.throw(l):o?.return?.(l)).then(s=>({done:!0,value:s?.value}))},return(l){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:l}):Promise.resolve(o?.return?.(l)).then(s=>({done:!0,value:s?.value}))}};return B(u)}function nt(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){B(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var J=new WeakMap;function rt(e){J.has(this)||J.set(this,new Map);let t=J.get(this).get(e.type);if(t)for(let n of t)try{let{push:o,terminate:i,container:u,selector:l}=n;if(u.isConnected){if(e.target instanceof Node)if(l){let s=u.querySelectorAll(l);for(let c of s)(e.target===c||c.contains(e.target))&&u.contains(c)&&o(e)}else(e.target===u||u.contains(e.target))&&o(e)}else{let s="Container `#"+u.id+">"+(l||"")+"` removed from DOM. Removing subscription";t.delete(n),i(new Error(s))}}catch(o){E.warn("docEventHandler",o)}}function we(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function Oe(e){let t=e.split(":");if(t.length===1)return we(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&we(t[1])&&!we(t[0]))return[t[1],t[0]]}function ot(e){throw new Error(e)}function Ae(e,t){let[n,o]=Oe(t)??ot("Invalid WhenSelector: "+t);J.has(e.ownerDocument)||J.set(e.ownerDocument,new Map),J.get(e.ownerDocument).has(o)||(e.ownerDocument.addEventListener(o,rt,{passive:!0,capture:!0}),J.get(e.ownerDocument).set(o,new Set));let i=ve(()=>J.get(e.ownerDocument)?.get(o)?.delete(u)),u={push:i.push,terminate(l){i.return?.(l)},container:e,selector:n||null};return Ue(e,n?[n]:void 0).then(l=>J.get(e.ownerDocument)?.get(o).add(u)),i.multi()}async function*We(){await new Promise(()=>{}),yield void 0}function Se(e){function t(n){return e.map(n)}return Object.assign(B(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function at(e){if(!e)throw new Error(`Falsy async source will never be ready +`))},info(...e){S&&console.trace("(AI-UI) INFO:",...e)}};var ke=e=>{};function Ie(){let e=ke,t=ke,n=new Promise((...o)=>[e,t]=o);if(n.resolve=e,n.reject=t,S){let o=new Error().stack;n.catch(l=>l instanceof Error||l?.value instanceof Error?E.log("Deferred rejection",l,"allocated at ",o):void 0)}return n}function ie(e){return e&&typeof e=="object"||typeof e=="function"}function Y(e){return ie(e)&&"then"in e&&typeof e.then=="function"}var Pe={};Ne(Pe,{Ignore:()=>$,Iterability:()=>re,asyncExtras:()=>le,asyncIterator:()=>Ee,augmentGlobalAsyncGenerators:()=>nt,combine:()=>Re,debounceQueueIteratableIterator:()=>De,defineIterableProperty:()=>xe,filterMap:()=>Z,generatorHelpers:()=>Ye,isAsyncIter:()=>K,isAsyncIterable:()=>ce,isAsyncIterator:()=>ae,iterableHelpers:()=>B,merge:()=>ue,queueIteratableIterator:()=>ve});var re=Symbol("Iterability");function ae(e){return ie(e)&&"next"in e&&typeof e?.next=="function"}function ce(e){return ie(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function K(e){return ce(e)||ae(e)}function Ee(e){if(ae(e))return e;if(ce(e))return e[Symbol.asyncIterator]();throw new Error("Not an async provider")}var le={filterMap(e,t=$){return Z(this,e,t)},map:_e,filter:Je,unique:Xe,waitFor:et,multi:tt,initially:ze,consume:He,merge(...e){return ue(this,...e)},combine(e){return Re(Object.assign({_this:this},e))}},Te=[...Object.getOwnPropertySymbols(le),...Object.keys(le)];function be(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let o of n)Object.defineProperty(e,o,{...Object.getOwnPropertyDescriptor(t,o),enumerable:!1});return e}var D=Symbol("pending"),q=Symbol("items");function je(e=()=>{}){let t={[D]:[],[q]:[],[Symbol.asyncIterator](){return t},next(){if(t[q]?.length)return Promise.resolve(t[q].shift());if(!t[D])return Promise.resolve({done:!0,value:void 0});let n=Ie();return n.catch(o=>{}),t[D].unshift(n),n},return(n){let o={done:!0,value:void 0};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().resolve(o);t[q]=t[D]=null}return Promise.resolve(o)},throw(...n){let o={done:!0,value:n[0]};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().reject(o);t[q]=t[D]=null}return Promise.reject(o)},get length(){return t[q]?t[q].length:-1},push(n){return t[D]?(t[D].length?t[D].pop().resolve({done:!1,value:n}):t[q]?t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers"),!0):!1}};return B(t)}var pe=Symbol("inflight");function Ke(e=()=>{}){let t=je(e);return t[pe]=new Set,t.push=function(n){if(!t[D])return!1;if(t[pe].has(n))return!0;if(t[D].length){t[pe].add(n);let o=t[D].pop();o.finally(()=>t[pe].delete(n)),o.resolve({done:!1,value:n})}else t[q]?t[q].find(o=>o.value===n)||t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers");return!0},t}var ve=je,De=Ke,ne=Symbol("_proxiedAsyncIterator");function xe(e,t,n){let o=()=>{o=()=>W;let b=De(),x=b.multi(),W=x[Symbol.asyncIterator]();return d[Symbol.asyncIterator]=x[Symbol.asyncIterator],c=b.push,Te.forEach(O=>d[O]=W[O]),ne in s||be(s,d),W};function l(b){return{[b]:function(...x){return o(),s[b].apply(this,x)}}[b]}let d={[Symbol.asyncIterator]:o};Te.forEach(b=>d[b]=l(b)),typeof n=="object"&&n&&re in n&&n[re]==="shallow"&&(d[re]=n[re]);let c=b=>(o(),c(b)),s=h(n,d),u;return Object.defineProperty(e,t,{get(){return s},set(b){if(b!==s)if(ce(b)){if(u===b)return;u=b;let x=S?new Error:void 0;S&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),He.call(b,W=>{if(b!==u)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:x});c(W?.valueOf())}).catch(W=>E.info(W)).finally(()=>b===u&&(u=void 0));return}else u&&S&&E.log(`Iterable "${t.toString()}" is already piped from another iterator, and might be overrwitten later`),s=h(b,d);c(b?.valueOf())},enumerable:!0}),e;function h(b,x){if(b==null)return be(Object.create(null,{valueOf:{value(){return b},writable:!0,configurable:!0},toJSON:{value(){return b},writable:!0,configurable:!0}}),x);switch(typeof b){case"bigint":case"boolean":case"number":case"string":return be(Object(b),Object.assign(x,{toJSON(){return b.valueOf()}}));case"object":return ye(b,x)}throw new TypeError('Iterable properties cannot be of type "'+typeof b+'"')}function I(b){return ie(b)&&ne in b}function j(b,x){let W=x.split(".").slice(1);for(let O=0;OI(a)?a[ne]:{a,path:null})),Z(W,(a,f)=>{let m=j(a.a,F);return f!==m||a.path===null||a.path.startsWith(F)?m:$},$,j(b,F))[v]):(O??(O=Z(x,N=>I(N)?N[ne].a:N)),O[v]);if(v==="valueOf")return()=>j(b,F);if(v===Symbol.toPrimitive)return function(N){return Reflect.has(A,v)?Reflect.get(A,v,A).call(A,N):N==="string"?A.toString():N==="number"?Number(A):A.valueOf()};if(typeof v=="string"&&(!(v in A)||Object.hasOwn(A,v))&&!(re in A&&A[re]==="shallow")){let N=Reflect.get(A,v,G);return typeof N=="function"||K(N)?N:new Proxy(Object(N),oe(F+"."+v))}return Reflect.get(A,v,G)}}}}}var X=new Promise(()=>{}),ue=(...e)=>{let t=new Array(e.length),n=new Array(e.length),o=()=>{o=()=>{};for(let s=0;s({idx:s,result:h}))}},l=[],d=n.length,c={[Symbol.asyncIterator](){return c},next(){return o(),d?Promise.race(n).then(({idx:s,result:u})=>u.done?(d--,n[s]=X,l[s]=u.value,c.next()):(n[s]=t[s]?t[s].next().then(h=>({idx:s,result:h})).catch(h=>({idx:s,result:{done:!0,value:h}})):Promise.resolve({idx:s,result:{done:!0,value:void 0}}),u)).catch(s=>c.throw?.(s)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:l})},async return(s){for(let u=0;uh.value,h=>h));return{done:!0,value:l}},async throw(s){for(let u=0;uh.value,h=>h));return{done:!0,value:l}}};return B(c)},Re=(e,t={})=>{let n={},o,l=[],d=0,c={[Symbol.asyncIterator](){return c},next(){return o===void 0&&(o=Object.entries(e).map(([s,u],h)=>(d+=1,l[h]=u[Symbol.asyncIterator](),l[h].next().then(I=>({si:l,idx:h,k:s,ir:I}))))),function s(){return Promise.race(o).then(({idx:u,k:h,ir:I})=>I.done?(o[u]=X,d-=1,d?s():{done:!0,value:void 0}):(n[h]=I.value,o[u]=l[u].next().then(j=>({idx:u,k:h,ir:j})),t.ignorePartial&&Object.keys(n).length{u!==X&&l[h].return?.(s)}),Promise.resolve({done:!0,value:s})},throw(s){return o.forEach((u,h)=>{u!==X&&l[h].throw?.(s)}),Promise.reject({done:!0,value:s})}};return B(c)};function Be(e){return ce(e)&&Te.every(t=>t in e&&e[t]===le[t])}function B(e){return Be(e)||be(e,le),e}function Ye(e){return function(...t){let n=e(...t);return B(n)}}async function He(e){let t;for await(let n of this)t=e?.(n);await t}var $=Symbol("Ignore");function Ze(e,t,n){if(Y(e))return e.then(t,n);try{return t(e)}catch(o){return n(o)}}function Z(e,t,n=$,o=$){let l,d={[Symbol.asyncIterator](){return d},next(...c){if(n!==$){let s=Promise.resolve({done:!1,value:n});return n=$,s}return new Promise(function s(u,h){l||(l=e[Symbol.asyncIterator]()),l.next(...c).then(I=>I.done?u(I):Ze(t(I.value,o),j=>j===$?s(u,h):u({done:!1,value:o=j}),j=>{l.throw?l.throw(j):l.return?.(j),h({done:!0,value:j})}),I=>h({done:!0,value:I})).catch(I=>{l.throw?l.throw(I):l.return?.(I),h({done:!0,value:I})})})},throw(c){return Promise.resolve(l?.throw?l.throw(c):l?.return?.(c)).then(s=>({done:!0,value:s?.value}))},return(c){return Promise.resolve(l?.return?.(c)).then(s=>({done:!0,value:s?.value}))}};return B(d)}function _e(e){return Z(this,e)}function Je(e){return Z(this,async t=>await e(t)?t:$)}function Xe(e){return e?Z(this,async(t,n)=>n===$||await e(t,n)?t:$):Z(this,(t,n)=>t===n?$:t)}function ze(e){return Z(this,t=>t,e)}function et(e){return Z(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function tt(){let e=this,t=0,n,o;function l(c){c&&n.resolve(c),c?.done||(n=Ie(),o.next().then(l).catch(s=>n.reject({done:!0,value:s})))}let d={[Symbol.asyncIterator](){return t+=1,d},next(){return o||(o=e[Symbol.asyncIterator](),l()),n},throw(c){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:c}):Promise.resolve(o?.throw?o.throw(c):o?.return?.(c)).then(s=>({done:!0,value:s?.value}))},return(c){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:c}):Promise.resolve(o?.return?.(c)).then(s=>({done:!0,value:s?.value}))}};return B(d)}function nt(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){B(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var J=new WeakMap;function rt(e){J.has(this)||J.set(this,new Map);let t=J.get(this).get(e.type);if(t)for(let n of t)try{let{push:o,terminate:l,container:d,selector:c}=n;if(d.isConnected){if(e.target instanceof Node)if(c){let s=d.querySelectorAll(c);for(let u of s)(e.target===u||u.contains(e.target))&&d.contains(u)&&o(e)}else(e.target===d||d.contains(e.target))&&o(e)}else{let s="Container `#"+d.id+">"+(c||"")+"` removed from DOM. Removing subscription";t.delete(n),l(new Error(s))}}catch(o){E.warn("docEventHandler",o)}}function we(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function Oe(e){let t=e.split(":");if(t.length===1)return we(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&we(t[1])&&!we(t[0]))return[t[1],t[0]]}function ot(e){throw new Error(e)}function Ae(e,t){let[n,o]=Oe(t)??ot("Invalid WhenSelector: "+t);J.has(e.ownerDocument)||J.set(e.ownerDocument,new Map),J.get(e.ownerDocument).has(o)||(e.ownerDocument.addEventListener(o,rt,{passive:!0,capture:!0}),J.get(e.ownerDocument).set(o,new Set));let l=ve(()=>J.get(e.ownerDocument)?.get(o)?.delete(d)),d={push:l.push,terminate(c){l.return?.(c)},container:e,selector:n||null};return Ue(e,n?[n]:void 0).then(c=>J.get(e.ownerDocument)?.get(o).add(d)),l.multi()}async function*We(){await new Promise(()=>{}),yield void 0}function Se(e){function t(n){return e.map(n)}return Object.assign(B(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function at(e){if(!e)throw new Error(`Falsy async source will never be ready -`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!Oe(e)}async function*st(e){yield e}function me(e,...t){if(!t||t.length===0)return Se(Ae(e,"change"));let n=t.filter(u=>typeof u!="string"||u[0]!=="@").map(u=>typeof u=="string"?Ae(e,u):u instanceof Element?Ae(u,"change"):Y(u)?st(u):u);if(t.includes("@start")){let u={[Symbol.asyncIterator]:()=>u,next(){return u.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(u)}if(t.includes("@ready")){let l=function(I){return typeof I=="string"&&!e.querySelector(I)};var i=l;let s=t.filter(at).map(I=>Oe(I)?.[0]).filter(l),c,h={[Symbol.asyncIterator](){return h},throw(I){return c?.throw?c.throw(I):Promise.resolve({done:!0,value:I})},return(I){return c?.return?c.return(I):Promise.resolve({done:!0,value:I})},next(){return c?c.next():Ue(e,s).then(()=>(c=(n.length>1?ue(...n):n.length===1?n[0]:We())[Symbol.asyncIterator](),c?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Se(B(h))}let o=n.length>1?ue(...n):n.length===1?n[0]:We();return Se(B(o))}function Le(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,o)=>{n.some(i=>i.addedNodes?.length)&&e.isConnected&&(o.disconnect(),t())}).observe(e.ownerDocument.body,{subtree:!0,childList:!0}))}function Ue(e,t){return t?.length?Promise.all([it(e,t),Le(e)]):Le(e)}function it(e,t){if(t=t.filter(o=>!e.querySelector(o)),!t.length)return Promise.resolve();let n=new Promise(o=>new MutationObserver((i,u)=>{i.some(l=>l.addedNodes?.length)&&t.every(l=>e.querySelector(l))&&(u.disconnect(),o())}).observe(e,{subtree:!0,childList:!0}));if(S){let o=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),i=setTimeout(()=>{E.warn(o,t)},se);n.finally(()=>clearTimeout(i))}return n}var fe=Symbol("Unique ID"),z=S?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},lt=0,ct=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","link","main","map","mark","menu","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","script","search","section","select","slot","small","source","span","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr"];function ee(){throw new Error(".ids is a read-only map of Elements")}function he(e){return typeof e=="string"||typeof e=="number"||typeof e=="boolean"||e instanceof Node||e instanceof NodeList||e instanceof HTMLCollection||e===null||e===void 0||Array.isArray(e)||Y(e)||K(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var de=Symbol("callStack"),$e=function(e,t,n){let[o,i,u]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,ct,e],l=u?.commonProperties,s=u?.document??globalThis.document,c=ut(s,"removedNodes",u?.enableOnRemovedFromDOM);function h(){return s.createComment(S&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function I({error:a}){return s.createComment(a instanceof Error?a.toString():`Error: -`+JSON.stringify(a,null,2))}let j=s.createElement("STYLE");j.id="--ai-ui-extended-tag-styles-";let ye=new Set,b=Object.create(null,{when:{writable:!1,configurable:!0,enumerable:!1,value:function(...a){return me(this,...a)}},attributes:{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(a){if(K(a)){let f=ae(a)?a:a[Symbol.asyncIterator](),m=()=>f.next().then(({done:r,value:g})=>{F(this,g),r||m()},r=>E.warn(r));m()}else F(this,a)}},ids:{configurable:!0,enumerable:!0,set:ee,get(){let a=new Proxy(Object.create(null),{apply:ee,construct:ee,defineProperty:ee,deleteProperty:ee,set:ee,setPrototypeOf:ee,getPrototypeOf(){return null},isExtensible(){return!1},preventExtensions(){return!0},getOwnPropertyDescriptor(f,m){if(this.get(f,m,null))return Reflect.getOwnPropertyDescriptor(f,m)},has(f,m){return!!this.get(f,m,null)},ownKeys:f=>{let m=[...this.querySelectorAll("[id]")].map(g=>g.id),r=[...new Set(m)];return S&&m.length!==r.length&&E.log("Element contains multiple, shadowed decendant ids",r),r},get:(f,m,r)=>{if(typeof m=="string"){if(m in f){if(this.contains(f[m]))return f[m];delete f[m]}let g;if(S){let d=this.querySelectorAll("#"+CSS.escape(m));d.length>1&&(ye.has(m)||(ye.add(m),E.log(`Element contains multiple, shadowed decendants with ID "${m}"`))),g=d[0]}else g=this.querySelector("#"+CSS.escape(m))??void 0;return g&&(f[m]=g),g}}});return Object.defineProperty(this,"ids",{configurable:!0,enumerable:!0,set:ee,get(){return a}}),a}}});l&&O(b,l);function x(...a){let f=[];return function m(r){if(!(r==null||r===$)){if(Y(r)){let g=h();f.push(g),r.then(d=>g.replaceWith(...x(d)),d=>{E.warn(d,z(g)),g.replaceWith(I({error:d}))});return}if(r instanceof Node){f.push(r);return}if(r&&typeof r=="object"&&Symbol.iterator in r&&!(Symbol.asyncIterator in r)&&r[Symbol.iterator]){for(let g of r)m(g);return}if(K(r)){let g=S?` -`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",d=ae(r)?r:r[Symbol.asyncIterator](),R=r.valueOf(),te=R===void 0||R===r?[h()]:x(R),y=te.length?te:[h()];f.push(...y);let p=!0,T=Date.now()+se,P=S&&new Error("Created by").stack,Q=w=>{let M=y.filter(H=>!!H?.parentNode);M.length?(y=[I({error:w})],M[0].replaceWith(...y),M.slice(1).forEach(H=>H?.parentNode.removeChild(H))):E.warn("Can't report error",w,P,y.map(z)),y=[],d.return?.(w)},_=w=>{if(!w.done)try{let M=y.filter(k=>k?.parentNode&&k.isConnected),H=p?y:M;if(M.length&&(p=!1),!H.length||y.every(k=>c(k))){y=[];let k="Element(s) have been removed from the document: "+g;d.return?.(new Error(k));return}S&&p&&T&&T!y.includes(k)&&k.parentNode?.removeChild(k)),d.next().then(_).catch(Q)}catch(M){y=[],d.return?.(M)}};d.next().then(_).catch(Q);return}f.push(s.createTextNode(r.toString()))}}(a),f}o||Object.assign($e,{nodes:x,UniqueID:fe});let W=Object.getPrototypeOf({});function O(a,f,m){if(!(f==null||typeof f!="object"||f===a))for(let[r,g]of Object.entries(Object.getOwnPropertyDescriptors(f)))try{if("value"in g){let d=g.value;d&&K(d)?Object.defineProperty(a,r,g):d&&typeof d=="object"&&!Y(d)?r in a?d instanceof Node?(E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child",r,z(d)),a[r]=d):a[r]!==d&&(Array.isArray(a[r])&&a[r].length!==d.length?d.constructor===Object||d.constructor===Array?O(a[r]=new d.constructor,d):a[r]=d:O(a[r],d)):(m&&(Object.getPrototypeOf(d)===W||!Object.getPrototypeOf(d)?O(g.value={},d):Array.isArray(d)?O(g.value=[],d):E.warn(`Declared propety '${r}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,a,d)),Object.defineProperty(a,r,g)):f[r]!==void 0&&(a[r]=f[r])}else Object.defineProperty(a,r,g)}catch(d){throw E.warn("deepAssign",r,f[r],d),d}}function oe(a){let f=a?.valueOf();return Array.isArray(f)?Array.prototype.map.call(f,oe):f}function F(a,f){de in f||function m(r,g){if(g==null||typeof g!="object")return;let d=Object.entries(Object.getOwnPropertyDescriptors(g));Array.isArray(g)||d.sort(y=>{let p=Object.getOwnPropertyDescriptor(r,y[0]);if(p){if("value"in p)return-1;if("set"in p||"get"in p)return 1}return 0});for(let[y,p]of d)try{if("value"in p){let T=p.value;K(T)?R(T,y):Y(T)?T.then(P=>{P&&typeof P=="object"?K(P)?R(P,y):te(P,y):g[y]!==void 0&&(r[y]=P)},P=>E.log("Failed to set attribute",P)):K(T)||(T&&typeof T=="object"&&!Y(T)?te(T,y):g[y]!==void 0&&(r[y]=g[y]))}else Object.defineProperty(r,y,p)}catch(T){throw E.warn("assignProps",y,g[y],T),T}function R(y,p){let T=Ee(y),P=!0,Q=Date.now()+se,_=S&&new Error("Created by").stack,w=k=>{if(!k.done){let C=oe(k.value);if(typeof C=="object"&&C!==null){let L=Object.getOwnPropertyDescriptor(r,p);p==="style"||!L?.set?m(r[p],C):r[p]=C}else C!==void 0&&(r[p]=C);let V=a.isConnected;if(c(a)||!P&&!V){E.info(`Element does not exist in document when setting async attribute '${p}' to: +`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!Oe(e)}async function*st(e){yield e}function me(e,...t){if(!t||t.length===0)return Se(Ae(e,"change"));let n=t.filter(d=>typeof d!="string"||d[0]!=="@").map(d=>typeof d=="string"?Ae(e,d):d instanceof Element?Ae(d,"change"):Y(d)?st(d):d);if(t.includes("@start")){let d={[Symbol.asyncIterator]:()=>d,next(){return d.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(d)}if(t.includes("@ready")){let c=function(I){return typeof I=="string"&&!e.querySelector(I)};var l=c;let s=t.filter(at).map(I=>Oe(I)?.[0]).filter(c),u,h={[Symbol.asyncIterator](){return h},throw(I){return u?.throw?u.throw(I):Promise.resolve({done:!0,value:I})},return(I){return u?.return?u.return(I):Promise.resolve({done:!0,value:I})},next(){return u?u.next():Ue(e,s).then(()=>(u=(n.length>1?ue(...n):n.length===1?n[0]:We())[Symbol.asyncIterator](),u?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Se(B(h))}let o=n.length>1?ue(...n):n.length===1?n[0]:We();return Se(B(o))}function Le(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,o)=>{n.some(l=>l.addedNodes?.length)&&e.isConnected&&(o.disconnect(),t())}).observe(e.ownerDocument.body,{subtree:!0,childList:!0}))}function Ue(e,t){return t?.length?Promise.all([it(e,t),Le(e)]):Le(e)}function it(e,t){if(t=t.filter(o=>!e.querySelector(o)),!t.length)return Promise.resolve();let n=new Promise(o=>new MutationObserver((l,d)=>{l.some(c=>c.addedNodes?.length)&&t.every(c=>e.querySelector(c))&&(d.disconnect(),o())}).observe(e,{subtree:!0,childList:!0}));if(S){let o=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),l=setTimeout(()=>{E.warn(o,t)},se);n.finally(()=>clearTimeout(l))}return n}var fe=Symbol("Unique ID"),z=S?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},lt=0,ct=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","link","main","map","mark","menu","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","script","search","section","select","slot","small","source","span","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr"];function ee(){throw new Error(".ids is a read-only map of Elements")}function he(e){return typeof e=="string"||typeof e=="number"||typeof e=="boolean"||e instanceof Node||e instanceof NodeList||e instanceof HTMLCollection||e===null||e===void 0||Array.isArray(e)||Y(e)||K(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var de=Symbol("callStack"),$e=function(e,t,n){let[o,l,d]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,ct,e],c=d?.commonProperties,s=d?.document??globalThis.document,u=ut(s,"removedNodes",d?.enableOnRemovedFromDOM);function h(){return s.createComment(S&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function I({error:a}){return s.createComment(a instanceof Error?a.toString():`Error: +`+JSON.stringify(a,null,2))}let j=s.createElement("STYLE");j.id="--ai-ui-extended-tag-styles-";let ye=new Set,b=Object.create(null,{when:{writable:!1,configurable:!0,enumerable:!1,value:function(...a){return me(this,...a)}},attributes:{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(a){if(K(a)){let f=ae(a)?a:a[Symbol.asyncIterator](),m=()=>f.next().then(({done:r,value:g})=>{F(this,g),r||m()},r=>E.warn(r));m()}else F(this,a)}},ids:{configurable:!0,enumerable:!0,set:ee,get(){let a=new Proxy(Object.create(null),{apply:ee,construct:ee,defineProperty:ee,deleteProperty:ee,set:ee,setPrototypeOf:ee,getPrototypeOf(){return null},isExtensible(){return!1},preventExtensions(){return!0},getOwnPropertyDescriptor(f,m){if(this.get(f,m,null))return Reflect.getOwnPropertyDescriptor(f,m)},has(f,m){return!!this.get(f,m,null)},ownKeys:f=>{let m=[...this.querySelectorAll("[id]")].map(g=>g.id),r=[...new Set(m)];return S&&m.length!==r.length&&E.log("Element contains multiple, shadowed decendant ids",r),r},get:(f,m,r)=>{if(typeof m=="string"){if(m in f){let i=f[m].deref();if(i&&i.id===m&&this.contains(i))return i;delete f[m]}let g;if(S){let i=this.querySelectorAll("#"+CSS.escape(m));i.length>1&&(ye.has(m)||(ye.add(m),E.log(`Element contains multiple, shadowed decendants with ID "${m}"`))),g=i[0]}else g=this.querySelector("#"+CSS.escape(m))??void 0;return g&&(f[m]=new WeakRef(g)),g}}});return Object.defineProperty(this,"ids",{configurable:!0,enumerable:!0,set:ee,get(){return a}}),a}}});c&&O(b,c);function x(...a){let f=[];return function m(r){if(!(r==null||r===$)){if(Y(r)){let g=h();f.push(g),r.then(i=>g.replaceWith(...x(i)),i=>{E.warn(i,z(g)),g.replaceWith(I({error:i}))});return}if(r instanceof Node){f.push(r);return}if(r&&typeof r=="object"&&Symbol.iterator in r&&!(Symbol.asyncIterator in r)&&r[Symbol.iterator]){for(let g of r)m(g);return}if(K(r)){let g=S?` +`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",i=ae(r)?r:r[Symbol.asyncIterator](),R=r.valueOf(),te=R===void 0||R===r?[h()]:x(R),y=te.length?te:[h()];f.push(...y);let p=!0,T=Date.now()+se,P=S&&new Error("Created by").stack,Q=w=>{let M=y.filter(H=>!!H?.parentNode);M.length?(y=[I({error:w})],M[0].replaceWith(...y),M.slice(1).forEach(H=>H?.parentNode.removeChild(H))):E.warn("Can't report error",w,P,y.map(z)),y=[],i.return?.(w)},_=w=>{if(!w.done)try{let M=y.filter(k=>k?.parentNode&&k.isConnected),H=p?y:M;if(M.length&&(p=!1),!H.length||y.every(k=>u(k))){y=[];let k="Element(s) have been removed from the document: "+g;i.return?.(new Error(k));return}S&&p&&T&&T!y.includes(k)&&k.parentNode?.removeChild(k)),i.next().then(_).catch(Q)}catch(M){y=[],i.return?.(M)}};i.next().then(_).catch(Q);return}f.push(s.createTextNode(r.toString()))}}(a),f}o||Object.assign($e,{nodes:x,UniqueID:fe});let W=Object.getPrototypeOf({});function O(a,f,m){if(!(f==null||typeof f!="object"||f===a))for(let[r,g]of Object.entries(Object.getOwnPropertyDescriptors(f)))try{if("value"in g){let i=g.value;i&&K(i)?Object.defineProperty(a,r,g):i&&typeof i=="object"&&!Y(i)?r in a?i instanceof Node?(E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child",r,z(i)),a[r]=i):a[r]!==i&&(Array.isArray(a[r])&&a[r].length!==i.length?i.constructor===Object||i.constructor===Array?O(a[r]=new i.constructor,i):a[r]=i:O(a[r],i)):(m&&(Object.getPrototypeOf(i)===W||!Object.getPrototypeOf(i)?O(g.value={},i):Array.isArray(i)?O(g.value=[],i):E.warn(`Declared propety '${r}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,a,i)),Object.defineProperty(a,r,g)):f[r]!==void 0&&(a[r]=f[r])}else Object.defineProperty(a,r,g)}catch(i){throw E.warn("deepAssign",r,f[r],i),i}}function oe(a){let f=a?.valueOf();return Array.isArray(f)?Array.prototype.map.call(f,oe):f}function F(a,f){de in f||function m(r,g){if(g==null||typeof g!="object")return;let i=Object.entries(Object.getOwnPropertyDescriptors(g));Array.isArray(g)||i.sort(y=>{let p=Object.getOwnPropertyDescriptor(r,y[0]);if(p){if("value"in p)return-1;if("set"in p||"get"in p)return 1}return 0});for(let[y,p]of i)try{if("value"in p){let T=p.value;K(T)?R(T,y):Y(T)?T.then(P=>{P&&typeof P=="object"?K(P)?R(P,y):te(P,y):g[y]!==void 0&&(r[y]=P)},P=>E.log("Failed to set attribute",P)):K(T)||(T&&typeof T=="object"&&!Y(T)?te(T,y):g[y]!==void 0&&(r[y]=g[y]))}else Object.defineProperty(r,y,p)}catch(T){throw E.warn("assignProps",y,g[y],T),T}function R(y,p){let T=Ee(y),P=!0,Q=Date.now()+se,_=S&&new Error("Created by").stack,w=k=>{if(!k.done){let C=oe(k.value);if(typeof C=="object"&&C!==null){let L=Object.getOwnPropertyDescriptor(r,p);p==="style"||!L?.set?m(r[p],C):r[p]=C}else C!==void 0&&(r[p]=C);let V=a.isConnected;if(u(a)||!P&&!V){E.info(`Element does not exist in document when setting async attribute '${p}' to: ${z(a)}`),T.return?.();return}V&&(P=!1),P&&Q&&Q{E.warn("Dynamic attribute error",k,p,r,_,z(a)),T.return?.(k),a.appendChild(I({error:k}))},H=y.valueOf();H!==void 0&&H!==y&&!K(H)?w({done:!1,value:H}):T.next().then(w).catch(M)}function te(y,p){if(y instanceof Node)E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes",p,z(y)),r[p]=y;else if(!(p in r)||r[p]===y||Array.isArray(r[p])&&r[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let T=new y.constructor;m(T,y),r[p]=T}else r[p]=y;else Object.getOwnPropertyDescriptor(r,p)?.set?r[p]=y:m(r[p],y)}}(a,f)}function A(a){for(let f=a.constructor;f;f=f.super)if(f===this)return!0;return!1}function v(a){let f=typeof a!="function"?p=>Object.assign({},a,p):a,m=Date.now().toString(36)+(lt++).toString(36)+Math.random().toString(36).slice(2),r=f({[fe]:m});r.styles&&(j.appendChild(s.createTextNode(r.styles+` -`)),s.head.contains(j)||s.head.appendChild(j));let d=Object.assign((p,...T)=>{let P=he(p),Q=[],_={[de]:(P?Q:p[de])??Q},w=P?this(_,p,...T):this(_,...T);w.constructor=d;let M=f({[fe]:m});if(_[de].push(M),S){let C=function(V,L){for(let U=V;U;U=U.super)if(U.definition?.declare&&L in U.definition.declare)return!0;return!1};var k=C;if(M.declare){let V=Object.keys(M.declare).filter(L=>L in w||C(this,L));V.length&&E.log(`Declared keys '${V}' in ${d.name} already exist in base '${this.valueOf()}'`)}if(M.override){let V=Object.keys(M.override).filter(L=>!(L in w)&&!(l&&L in l)&&!C(this,L));V.length&&E.log(`Overridden keys '${V}' in ${d.name} do not exist in base '${this.valueOf()}'`)}}O(w,M.declare,!0),O(w,M.override);let H=new Set;if(M.iterable&&Object.keys(M.iterable).forEach(C=>{C in w?(E.log(`Ignoring attempt to re-define iterable property "${C}" as it could already have consumers`),H.add(C)):xe(w,C,M.iterable[C])}),_[de]===Q){P||F(w,p);for(let L of Q){let U=L?.constructed?.call(w);he(U)&&w.append(...x(U))}let C={},V=!1;for(let L of Q)if(L.iterable)for(let U of Object.keys(L.iterable)){let Me=!P&&U in p;if(H.has(U)&&Me||!(Me&&(!Y(p[U])||!K(p[U])))){let Ce=w[U]?.valueOf();Ce!==void 0&&(C[U]=Ce,V=!0)}}V&&Object.assign(w,C)}return w},{super:this,definition:Object.assign(r,{[fe]:m}),extended:v,valueOf:()=>{let p=[...Object.keys(r.declare||{}),...Object.keys(r.iterable||{})];return`${d.name}: {${p.join(", ")}} - \u21AA ${this.valueOf()}`}});Object.defineProperty(d,Symbol.hasInstance,{value:A,writable:!0,configurable:!0});let R={};(function p(T){T?.super&&p(T.super);let P=T.definition;P&&(O(R,P?.override),O(R,P?.declare))})(this),O(R,r.override),O(R,r.declare),Object.defineProperties(d,Object.getOwnPropertyDescriptors(R));let te=R&&"className"in R&&typeof R.className=="string"?R.className:m,y=S?new Error().stack?.split(` -`)[2]??"":"";if(Object.defineProperty(d,"name",{value:""}),S){let p=Object.keys(r).filter(T=>!["styles","ids","constructed","declare","override","iterable"].includes(T));p.length&&E.log(`${d.name} defines extraneous keys '${p}', which are unknown`)}return d}let G={createElement(a,f,...m){return a===G.createElement?x(...m):typeof a=="function"?a(f,m):typeof a=="string"&&a in G?G[a](f,m):a instanceof Node?a:I({error:new Error("Illegal type in createElement:"+a)})}};function N(a){if(G[a])return G[a];let f=(r,...g)=>{if(he(r)&&(g.unshift(r),r={}),!he(r)){if(r.debugger){debugger;delete r.debugger}let d=o?s.createElementNS(o,a.toLowerCase()):s.createElement(a);return d.constructor=f,O(d,b),F(d,r),d.append(...x(...g)),d}},m=Object.assign(f,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:v,valueOf(){return`TagCreator: <${o||""}${o?"::":""}${a}>`}});return Object.defineProperty(f,Symbol.hasInstance,{value:A,writable:!0,configurable:!0}),Object.defineProperty(f,"name",{value:"<"+a+">"}),G[a]=m}return i.forEach(N),G};function ut(e,t,n){let o=new WeakSet;function i(u){for(let l of u)t==="addedNodes"===l.isConnected&&(i(l.childNodes),o.add(l),n&&"onRemovedFromDOM"in l&&typeof l.onRemovedFromDOM=="function"&&l.onRemovedFromDOM())}return new MutationObserver(u=>{u.forEach(function(l){l.type==="childList"&&l[t].length&&i(l[t])})}).observe(e,{subtree:!0,childList:!0}),function(u){return o.has(u)}}return qe(dt);})(); +`)),s.head.contains(j)||s.head.appendChild(j));let i=Object.assign((p,...T)=>{let P=he(p),Q=[],_={[de]:(P?Q:p[de])??Q},w=P?this(_,p,...T):this(_,...T);w.constructor=i;let M=f({[fe]:m});if(_[de].push(M),S){let C=function(V,L){for(let U=V;U;U=U.super)if(U.definition?.declare&&L in U.definition.declare)return!0;return!1};var k=C;if(M.declare){let V=Object.keys(M.declare).filter(L=>L in w||C(this,L));V.length&&E.log(`Declared keys '${V}' in ${i.name} already exist in base '${this.valueOf()}'`)}if(M.override){let V=Object.keys(M.override).filter(L=>!(L in w)&&!(c&&L in c)&&!C(this,L));V.length&&E.log(`Overridden keys '${V}' in ${i.name} do not exist in base '${this.valueOf()}'`)}}O(w,M.declare,!0),O(w,M.override);let H=new Set;if(M.iterable&&Object.keys(M.iterable).forEach(C=>{C in w?(E.log(`Ignoring attempt to re-define iterable property "${C}" as it could already have consumers`),H.add(C)):xe(w,C,M.iterable[C])}),_[de]===Q){P||F(w,p);for(let L of Q){let U=L?.constructed?.call(w);he(U)&&w.append(...x(U))}let C={},V=!1;for(let L of Q)if(L.iterable)for(let U of Object.keys(L.iterable)){let Me=!P&&U in p;if(H.has(U)&&Me||!(Me&&(!Y(p[U])||!K(p[U])))){let Ce=w[U]?.valueOf();Ce!==void 0&&(C[U]=Ce,V=!0)}}V&&Object.assign(w,C)}return w},{super:this,definition:Object.assign(r,{[fe]:m}),extended:v,valueOf:()=>{let p=[...Object.keys(r.declare||{}),...Object.keys(r.iterable||{})];return`${i.name}: {${p.join(", ")}} + \u21AA ${this.valueOf()}`}});Object.defineProperty(i,Symbol.hasInstance,{value:A,writable:!0,configurable:!0});let R={};(function p(T){T?.super&&p(T.super);let P=T.definition;P&&(O(R,P?.override),O(R,P?.declare))})(this),O(R,r.override),O(R,r.declare),Object.defineProperties(i,Object.getOwnPropertyDescriptors(R));let te=R&&"className"in R&&typeof R.className=="string"?R.className:m,y=S?new Error().stack?.split(` +`)[2]??"":"";if(Object.defineProperty(i,"name",{value:""}),S){let p=Object.keys(r).filter(T=>!["styles","ids","constructed","declare","override","iterable"].includes(T));p.length&&E.log(`${i.name} defines extraneous keys '${p}', which are unknown`)}return i}let G={createElement(a,f,...m){return a===G.createElement?x(...m):typeof a=="function"?a(f,m):typeof a=="string"&&a in G?G[a](f,m):a instanceof Node?a:I({error:new Error("Illegal type in createElement:"+a)})}};function N(a){if(G[a])return G[a];let f=(r,...g)=>{if(he(r)&&(g.unshift(r),r={}),!he(r)){if(r.debugger){debugger;delete r.debugger}let i=o?s.createElementNS(o,a.toLowerCase()):s.createElement(a);return i.constructor=f,O(i,b),F(i,r),i.append(...x(...g)),i}},m=Object.assign(f,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:v,valueOf(){return`TagCreator: <${o||""}${o?"::":""}${a}>`}});return Object.defineProperty(f,Symbol.hasInstance,{value:A,writable:!0,configurable:!0}),Object.defineProperty(f,"name",{value:"<"+a+">"}),G[a]=m}return l.forEach(N),G};function ut(e,t,n){let o=new WeakSet;function l(d){for(let c of d)t==="addedNodes"===c.isConnected&&(l(c.childNodes),o.add(c),n&&"onRemovedFromDOM"in c&&typeof c.onRemovedFromDOM=="function"&&c.onRemovedFromDOM())}return new MutationObserver(d=>{d.forEach(function(c){c.type==="childList"&&c[t].length&&l(c[t])})}).observe(e,{subtree:!0,childList:!0}),function(d){return o.has(d)}}return qe(dt);})(); diff --git a/module/dist/ai-ui.min.mjs b/module/dist/ai-ui.min.mjs index aa9c0d2..bae47d1 100644 --- a/module/dist/ai-ui.min.mjs +++ b/module/dist/ai-ui.min.mjs @@ -1,13 +1,13 @@ var Le=Object.defineProperty;var Ue=(e,t)=>{for(var n in t)Le(e,n,{get:t[n],enumerable:!0})};var S=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var se=5e3,E={log(...e){S&&console.log("(AI-UI) LOG:",...e,new Error().stack?.replace(/Error\n\s*.*\n/,` `))},warn(...e){S&&console.warn("(AI-UI) WARN:",...e,new Error().stack?.replace(/Error\n\s*.*\n/,` -`))},info(...e){S&&console.trace("(AI-UI) INFO:",...e)}};var Me=e=>{};function he(){let e=Me,t=Me,n=new Promise((...o)=>[e,t]=o);if(n.resolve=e,n.reject=t,S){let o=new Error().stack;n.catch(d=>d instanceof Error||d?.value instanceof Error?E.log("Deferred rejection",d,"allocated at ",o):void 0)}return n}function ie(e){return e&&typeof e=="object"||typeof e=="function"}function Y(e){return ie(e)&&"then"in e&&typeof e.then=="function"}var De={};Ue(De,{Ignore:()=>$,Iterability:()=>re,asyncExtras:()=>le,asyncIterator:()=>Ie,augmentGlobalAsyncGenerators:()=>_e,combine:()=>ke,debounceQueueIteratableIterator:()=>Ne,defineIterableProperty:()=>Ee,filterMap:()=>Z,generatorHelpers:()=>Ge,isAsyncIter:()=>K,isAsyncIterable:()=>ce,isAsyncIterator:()=>ae,iterableHelpers:()=>B,merge:()=>ue,queueIteratableIterator:()=>Te});var re=Symbol("Iterability");function ae(e){return ie(e)&&"next"in e&&typeof e?.next=="function"}function ce(e){return ie(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function K(e){return ce(e)||ae(e)}function Ie(e){if(ae(e))return e;if(ce(e))return e[Symbol.asyncIterator]();throw new Error("Not an async provider")}var le={filterMap(e,t=$){return Z(this,e,t)},map:Qe,filter:qe,unique:Ke,waitFor:Ye,multi:Ze,initially:Be,consume:je,merge(...e){return ue(this,...e)},combine(e){return ke(Object.assign({_this:this},e))}},ge=[...Object.getOwnPropertySymbols(le),...Object.keys(le)];function pe(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let o of n)Object.defineProperty(e,o,{...Object.getOwnPropertyDescriptor(t,o),enumerable:!1});return e}var D=Symbol("pending"),q=Symbol("items");function Ce(e=()=>{}){let t={[D]:[],[q]:[],[Symbol.asyncIterator](){return t},next(){if(t[q]?.length)return Promise.resolve(t[q].shift());if(!t[D])return Promise.resolve({done:!0,value:void 0});let n=he();return n.catch(o=>{}),t[D].unshift(n),n},return(n){let o={done:!0,value:void 0};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().resolve(o);t[q]=t[D]=null}return Promise.resolve(o)},throw(...n){let o={done:!0,value:n[0]};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().reject(o);t[q]=t[D]=null}return Promise.reject(o)},get length(){return t[q]?t[q].length:-1},push(n){return t[D]?(t[D].length?t[D].pop().resolve({done:!1,value:n}):t[q]?t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers"),!0):!1}};return B(t)}var ye=Symbol("inflight");function $e(e=()=>{}){let t=Ce(e);return t[ye]=new Set,t.push=function(n){if(!t[D])return!1;if(t[ye].has(n))return!0;if(t[D].length){t[ye].add(n);let o=t[D].pop();o.finally(()=>t[ye].delete(n)),o.resolve({done:!1,value:n})}else t[q]?t[q].find(o=>o.value===n)||t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers");return!0},t}var Te=Ce,Ne=$e,ne=Symbol("_proxiedAsyncIterator");function Ee(e,t,n){let o=()=>{o=()=>W;let b=Ne(),x=b.multi(),W=x[Symbol.asyncIterator]();return c[Symbol.asyncIterator]=x[Symbol.asyncIterator],i=b.push,ge.forEach(O=>c[O]=W[O]),ne in s||pe(s,c),W};function d(b){return{[b]:function(...x){return o(),s[b].apply(this,x)}}[b]}let c={[Symbol.asyncIterator]:o};ge.forEach(b=>c[b]=d(b)),typeof n=="object"&&n&&re in n&&n[re]==="shallow"&&(c[re]=n[re]);let i=b=>(o(),i(b)),s=h(n,c),l;return Object.defineProperty(e,t,{get(){return s},set(b){if(b!==s)if(ce(b)){if(l===b)return;l=b;let x=S?new Error:void 0;S&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),je.call(b,W=>{if(b!==l)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:x});i(W?.valueOf())}).catch(W=>E.info(W)).finally(()=>b===l&&(l=void 0));return}else l&&S&&E.log(`Iterable "${t.toString()}" is already piped from another iterator, and might be overrwitten later`),s=h(b,c);i(b?.valueOf())},enumerable:!0}),e;function h(b,x){if(b==null)return pe(Object.create(null,{valueOf:{value(){return b},writable:!0,configurable:!0},toJSON:{value(){return b},writable:!0,configurable:!0}}),x);switch(typeof b){case"bigint":case"boolean":case"number":case"string":return pe(Object(b),Object.assign(x,{toJSON(){return b.valueOf()}}));case"object":return fe(b,x)}throw new TypeError('Iterable properties cannot be of type "'+typeof b+'"')}function I(b){return ie(b)&&ne in b}function j(b,x){let W=x.split(".").slice(1);for(let O=0;OI(a)?a[ne]:{a,path:null})),Z(W,(a,f)=>{let m=j(a.a,F);return f!==m||a.path===null||a.path.startsWith(F)?m:$},$,j(b,F))[v]):(O??(O=Z(x,N=>I(N)?N[ne].a:N)),O[v]);if(v==="valueOf")return()=>j(b,F);if(v===Symbol.toPrimitive)return function(N){return Reflect.has(A,v)?Reflect.get(A,v,A).call(A,N):N==="string"?A.toString():N==="number"?Number(A):A.valueOf()};if(typeof v=="string"&&(!(v in A)||Object.hasOwn(A,v))&&!(re in A&&A[re]==="shallow")){let N=Reflect.get(A,v,G);return typeof N=="function"||K(N)?N:new Proxy(Object(N),oe(F+"."+v))}return Reflect.get(A,v,G)}}}}}var X=new Promise(()=>{}),ue=(...e)=>{let t=new Array(e.length),n=new Array(e.length),o=()=>{o=()=>{};for(let s=0;s({idx:s,result:h}))}},d=[],c=n.length,i={[Symbol.asyncIterator](){return i},next(){return o(),c?Promise.race(n).then(({idx:s,result:l})=>l.done?(c--,n[s]=X,d[s]=l.value,i.next()):(n[s]=t[s]?t[s].next().then(h=>({idx:s,result:h})).catch(h=>({idx:s,result:{done:!0,value:h}})):Promise.resolve({idx:s,result:{done:!0,value:void 0}}),l)).catch(s=>i.throw?.(s)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:d})},async return(s){for(let l=0;lh.value,h=>h));return{done:!0,value:d}},async throw(s){for(let l=0;lh.value,h=>h));return{done:!0,value:d}}};return B(i)},ke=(e,t={})=>{let n={},o,d=[],c=0,i={[Symbol.asyncIterator](){return i},next(){return o===void 0&&(o=Object.entries(e).map(([s,l],h)=>(c+=1,d[h]=l[Symbol.asyncIterator](),d[h].next().then(I=>({si:d,idx:h,k:s,ir:I}))))),function s(){return Promise.race(o).then(({idx:l,k:h,ir:I})=>I.done?(o[l]=X,c-=1,c?s():{done:!0,value:void 0}):(n[h]=I.value,o[l]=d[l].next().then(j=>({idx:l,k:h,ir:j})),t.ignorePartial&&Object.keys(n).length{l!==X&&d[h].return?.(s)}),Promise.resolve({done:!0,value:s})},throw(s){return o.forEach((l,h)=>{l!==X&&d[h].throw?.(s)}),Promise.reject({done:!0,value:s})}};return B(i)};function Fe(e){return ce(e)&&ge.every(t=>t in e&&e[t]===le[t])}function B(e){return Fe(e)||pe(e,le),e}function Ge(e){return function(...t){let n=e(...t);return B(n)}}async function je(e){let t;for await(let n of this)t=e?.(n);await t}var $=Symbol("Ignore");function Ve(e,t,n){if(Y(e))return e.then(t,n);try{return t(e)}catch(o){return n(o)}}function Z(e,t,n=$,o=$){let d,c={[Symbol.asyncIterator](){return c},next(...i){if(n!==$){let s=Promise.resolve({done:!1,value:n});return n=$,s}return new Promise(function s(l,h){d||(d=e[Symbol.asyncIterator]()),d.next(...i).then(I=>I.done?l(I):Ve(t(I.value,o),j=>j===$?s(l,h):l({done:!1,value:o=j}),j=>{d.throw?d.throw(j):d.return?.(j),h({done:!0,value:j})}),I=>h({done:!0,value:I})).catch(I=>{d.throw?d.throw(I):d.return?.(I),h({done:!0,value:I})})})},throw(i){return Promise.resolve(d?.throw?d.throw(i):d?.return?.(i)).then(s=>({done:!0,value:s?.value}))},return(i){return Promise.resolve(d?.return?.(i)).then(s=>({done:!0,value:s?.value}))}};return B(c)}function Qe(e){return Z(this,e)}function qe(e){return Z(this,async t=>await e(t)?t:$)}function Ke(e){return e?Z(this,async(t,n)=>n===$||await e(t,n)?t:$):Z(this,(t,n)=>t===n?$:t)}function Be(e){return Z(this,t=>t,e)}function Ye(e){return Z(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function Ze(){let e=this,t=0,n,o;function d(i){i&&n.resolve(i),i?.done||(n=he(),o.next().then(d).catch(s=>n.reject({done:!0,value:s})))}let c={[Symbol.asyncIterator](){return t+=1,c},next(){return o||(o=e[Symbol.asyncIterator](),d()),n},throw(i){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:i}):Promise.resolve(o?.throw?o.throw(i):o?.return?.(i)).then(s=>({done:!0,value:s?.value}))},return(i){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:i}):Promise.resolve(o?.return?.(i)).then(s=>({done:!0,value:s?.value}))}};return B(c)}function _e(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){B(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var J=new WeakMap;function Je(e){J.has(this)||J.set(this,new Map);let t=J.get(this).get(e.type);if(t)for(let n of t)try{let{push:o,terminate:d,container:c,selector:i}=n;if(c.isConnected){if(e.target instanceof Node)if(i){let s=c.querySelectorAll(i);for(let l of s)(e.target===l||l.contains(e.target))&&c.contains(l)&&o(e)}else(e.target===c||c.contains(e.target))&&o(e)}else{let s="Container `#"+c.id+">"+(i||"")+"` removed from DOM. Removing subscription";t.delete(n),d(new Error(s))}}catch(o){E.warn("docEventHandler",o)}}function ve(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function we(e){let t=e.split(":");if(t.length===1)return ve(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&ve(t[1])&&!ve(t[0]))return[t[1],t[0]]}function Xe(e){throw new Error(e)}function xe(e,t){let[n,o]=we(t)??Xe("Invalid WhenSelector: "+t);J.has(e.ownerDocument)||J.set(e.ownerDocument,new Map),J.get(e.ownerDocument).has(o)||(e.ownerDocument.addEventListener(o,Je,{passive:!0,capture:!0}),J.get(e.ownerDocument).set(o,new Set));let d=Te(()=>J.get(e.ownerDocument)?.get(o)?.delete(c)),c={push:d.push,terminate(i){d.return?.(i)},container:e,selector:n||null};return We(e,n?[n]:void 0).then(i=>J.get(e.ownerDocument)?.get(o).add(c)),d.multi()}async function*Re(){await new Promise(()=>{}),yield void 0}function Pe(e){function t(n){return e.map(n)}return Object.assign(B(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function ze(e){if(!e)throw new Error(`Falsy async source will never be ready +`))},info(...e){S&&console.trace("(AI-UI) INFO:",...e)}};var Me=e=>{};function he(){let e=Me,t=Me,n=new Promise((...o)=>[e,t]=o);if(n.resolve=e,n.reject=t,S){let o=new Error().stack;n.catch(d=>d instanceof Error||d?.value instanceof Error?E.log("Deferred rejection",d,"allocated at ",o):void 0)}return n}function ie(e){return e&&typeof e=="object"||typeof e=="function"}function Y(e){return ie(e)&&"then"in e&&typeof e.then=="function"}var De={};Ue(De,{Ignore:()=>$,Iterability:()=>re,asyncExtras:()=>le,asyncIterator:()=>Ie,augmentGlobalAsyncGenerators:()=>_e,combine:()=>ke,debounceQueueIteratableIterator:()=>Ne,defineIterableProperty:()=>Ee,filterMap:()=>Z,generatorHelpers:()=>Ge,isAsyncIter:()=>K,isAsyncIterable:()=>ce,isAsyncIterator:()=>ae,iterableHelpers:()=>B,merge:()=>ue,queueIteratableIterator:()=>Te});var re=Symbol("Iterability");function ae(e){return ie(e)&&"next"in e&&typeof e?.next=="function"}function ce(e){return ie(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function K(e){return ce(e)||ae(e)}function Ie(e){if(ae(e))return e;if(ce(e))return e[Symbol.asyncIterator]();throw new Error("Not an async provider")}var le={filterMap(e,t=$){return Z(this,e,t)},map:Qe,filter:qe,unique:Ke,waitFor:Ye,multi:Ze,initially:Be,consume:je,merge(...e){return ue(this,...e)},combine(e){return ke(Object.assign({_this:this},e))}},ge=[...Object.getOwnPropertySymbols(le),...Object.keys(le)];function pe(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let o of n)Object.defineProperty(e,o,{...Object.getOwnPropertyDescriptor(t,o),enumerable:!1});return e}var D=Symbol("pending"),q=Symbol("items");function Ce(e=()=>{}){let t={[D]:[],[q]:[],[Symbol.asyncIterator](){return t},next(){if(t[q]?.length)return Promise.resolve(t[q].shift());if(!t[D])return Promise.resolve({done:!0,value:void 0});let n=he();return n.catch(o=>{}),t[D].unshift(n),n},return(n){let o={done:!0,value:void 0};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().resolve(o);t[q]=t[D]=null}return Promise.resolve(o)},throw(...n){let o={done:!0,value:n[0]};if(t[D]){try{e()}catch{}for(;t[D].length;)t[D].pop().reject(o);t[q]=t[D]=null}return Promise.reject(o)},get length(){return t[q]?t[q].length:-1},push(n){return t[D]?(t[D].length?t[D].pop().resolve({done:!1,value:n}):t[q]?t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers"),!0):!1}};return B(t)}var ye=Symbol("inflight");function $e(e=()=>{}){let t=Ce(e);return t[ye]=new Set,t.push=function(n){if(!t[D])return!1;if(t[ye].has(n))return!0;if(t[D].length){t[ye].add(n);let o=t[D].pop();o.finally(()=>t[ye].delete(n)),o.resolve({done:!1,value:n})}else t[q]?t[q].find(o=>o.value===n)||t[q].push({done:!1,value:n}):E.log("Discarding queue push as there are no consumers");return!0},t}var Te=Ce,Ne=$e,ne=Symbol("_proxiedAsyncIterator");function Ee(e,t,n){let o=()=>{o=()=>W;let b=Ne(),x=b.multi(),W=x[Symbol.asyncIterator]();return u[Symbol.asyncIterator]=x[Symbol.asyncIterator],l=b.push,ge.forEach(O=>u[O]=W[O]),ne in s||pe(s,u),W};function d(b){return{[b]:function(...x){return o(),s[b].apply(this,x)}}[b]}let u={[Symbol.asyncIterator]:o};ge.forEach(b=>u[b]=d(b)),typeof n=="object"&&n&&re in n&&n[re]==="shallow"&&(u[re]=n[re]);let l=b=>(o(),l(b)),s=h(n,u),c;return Object.defineProperty(e,t,{get(){return s},set(b){if(b!==s)if(ce(b)){if(c===b)return;c=b;let x=S?new Error:void 0;S&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),je.call(b,W=>{if(b!==c)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:x});l(W?.valueOf())}).catch(W=>E.info(W)).finally(()=>b===c&&(c=void 0));return}else c&&S&&E.log(`Iterable "${t.toString()}" is already piped from another iterator, and might be overrwitten later`),s=h(b,u);l(b?.valueOf())},enumerable:!0}),e;function h(b,x){if(b==null)return pe(Object.create(null,{valueOf:{value(){return b},writable:!0,configurable:!0},toJSON:{value(){return b},writable:!0,configurable:!0}}),x);switch(typeof b){case"bigint":case"boolean":case"number":case"string":return pe(Object(b),Object.assign(x,{toJSON(){return b.valueOf()}}));case"object":return fe(b,x)}throw new TypeError('Iterable properties cannot be of type "'+typeof b+'"')}function I(b){return ie(b)&&ne in b}function j(b,x){let W=x.split(".").slice(1);for(let O=0;OI(a)?a[ne]:{a,path:null})),Z(W,(a,f)=>{let m=j(a.a,F);return f!==m||a.path===null||a.path.startsWith(F)?m:$},$,j(b,F))[v]):(O??(O=Z(x,N=>I(N)?N[ne].a:N)),O[v]);if(v==="valueOf")return()=>j(b,F);if(v===Symbol.toPrimitive)return function(N){return Reflect.has(A,v)?Reflect.get(A,v,A).call(A,N):N==="string"?A.toString():N==="number"?Number(A):A.valueOf()};if(typeof v=="string"&&(!(v in A)||Object.hasOwn(A,v))&&!(re in A&&A[re]==="shallow")){let N=Reflect.get(A,v,G);return typeof N=="function"||K(N)?N:new Proxy(Object(N),oe(F+"."+v))}return Reflect.get(A,v,G)}}}}}var X=new Promise(()=>{}),ue=(...e)=>{let t=new Array(e.length),n=new Array(e.length),o=()=>{o=()=>{};for(let s=0;s({idx:s,result:h}))}},d=[],u=n.length,l={[Symbol.asyncIterator](){return l},next(){return o(),u?Promise.race(n).then(({idx:s,result:c})=>c.done?(u--,n[s]=X,d[s]=c.value,l.next()):(n[s]=t[s]?t[s].next().then(h=>({idx:s,result:h})).catch(h=>({idx:s,result:{done:!0,value:h}})):Promise.resolve({idx:s,result:{done:!0,value:void 0}}),c)).catch(s=>l.throw?.(s)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:d})},async return(s){for(let c=0;ch.value,h=>h));return{done:!0,value:d}},async throw(s){for(let c=0;ch.value,h=>h));return{done:!0,value:d}}};return B(l)},ke=(e,t={})=>{let n={},o,d=[],u=0,l={[Symbol.asyncIterator](){return l},next(){return o===void 0&&(o=Object.entries(e).map(([s,c],h)=>(u+=1,d[h]=c[Symbol.asyncIterator](),d[h].next().then(I=>({si:d,idx:h,k:s,ir:I}))))),function s(){return Promise.race(o).then(({idx:c,k:h,ir:I})=>I.done?(o[c]=X,u-=1,u?s():{done:!0,value:void 0}):(n[h]=I.value,o[c]=d[c].next().then(j=>({idx:c,k:h,ir:j})),t.ignorePartial&&Object.keys(n).length{c!==X&&d[h].return?.(s)}),Promise.resolve({done:!0,value:s})},throw(s){return o.forEach((c,h)=>{c!==X&&d[h].throw?.(s)}),Promise.reject({done:!0,value:s})}};return B(l)};function Fe(e){return ce(e)&&ge.every(t=>t in e&&e[t]===le[t])}function B(e){return Fe(e)||pe(e,le),e}function Ge(e){return function(...t){let n=e(...t);return B(n)}}async function je(e){let t;for await(let n of this)t=e?.(n);await t}var $=Symbol("Ignore");function Ve(e,t,n){if(Y(e))return e.then(t,n);try{return t(e)}catch(o){return n(o)}}function Z(e,t,n=$,o=$){let d,u={[Symbol.asyncIterator](){return u},next(...l){if(n!==$){let s=Promise.resolve({done:!1,value:n});return n=$,s}return new Promise(function s(c,h){d||(d=e[Symbol.asyncIterator]()),d.next(...l).then(I=>I.done?c(I):Ve(t(I.value,o),j=>j===$?s(c,h):c({done:!1,value:o=j}),j=>{d.throw?d.throw(j):d.return?.(j),h({done:!0,value:j})}),I=>h({done:!0,value:I})).catch(I=>{d.throw?d.throw(I):d.return?.(I),h({done:!0,value:I})})})},throw(l){return Promise.resolve(d?.throw?d.throw(l):d?.return?.(l)).then(s=>({done:!0,value:s?.value}))},return(l){return Promise.resolve(d?.return?.(l)).then(s=>({done:!0,value:s?.value}))}};return B(u)}function Qe(e){return Z(this,e)}function qe(e){return Z(this,async t=>await e(t)?t:$)}function Ke(e){return e?Z(this,async(t,n)=>n===$||await e(t,n)?t:$):Z(this,(t,n)=>t===n?$:t)}function Be(e){return Z(this,t=>t,e)}function Ye(e){return Z(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function Ze(){let e=this,t=0,n,o;function d(l){l&&n.resolve(l),l?.done||(n=he(),o.next().then(d).catch(s=>n.reject({done:!0,value:s})))}let u={[Symbol.asyncIterator](){return t+=1,u},next(){return o||(o=e[Symbol.asyncIterator](),d()),n},throw(l){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:l}):Promise.resolve(o?.throw?o.throw(l):o?.return?.(l)).then(s=>({done:!0,value:s?.value}))},return(l){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:l}):Promise.resolve(o?.return?.(l)).then(s=>({done:!0,value:s?.value}))}};return B(u)}function _e(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){B(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var J=new WeakMap;function Je(e){J.has(this)||J.set(this,new Map);let t=J.get(this).get(e.type);if(t)for(let n of t)try{let{push:o,terminate:d,container:u,selector:l}=n;if(u.isConnected){if(e.target instanceof Node)if(l){let s=u.querySelectorAll(l);for(let c of s)(e.target===c||c.contains(e.target))&&u.contains(c)&&o(e)}else(e.target===u||u.contains(e.target))&&o(e)}else{let s="Container `#"+u.id+">"+(l||"")+"` removed from DOM. Removing subscription";t.delete(n),d(new Error(s))}}catch(o){E.warn("docEventHandler",o)}}function ve(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function we(e){let t=e.split(":");if(t.length===1)return ve(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&ve(t[1])&&!ve(t[0]))return[t[1],t[0]]}function Xe(e){throw new Error(e)}function xe(e,t){let[n,o]=we(t)??Xe("Invalid WhenSelector: "+t);J.has(e.ownerDocument)||J.set(e.ownerDocument,new Map),J.get(e.ownerDocument).has(o)||(e.ownerDocument.addEventListener(o,Je,{passive:!0,capture:!0}),J.get(e.ownerDocument).set(o,new Set));let d=Te(()=>J.get(e.ownerDocument)?.get(o)?.delete(u)),u={push:d.push,terminate(l){d.return?.(l)},container:e,selector:n||null};return We(e,n?[n]:void 0).then(l=>J.get(e.ownerDocument)?.get(o).add(u)),d.multi()}async function*Re(){await new Promise(()=>{}),yield void 0}function Pe(e){function t(n){return e.map(n)}return Object.assign(B(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function ze(e){if(!e)throw new Error(`Falsy async source will never be ready -`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!we(e)}async function*et(e){yield e}function Ae(e,...t){if(!t||t.length===0)return Pe(xe(e,"change"));let n=t.filter(c=>typeof c!="string"||c[0]!=="@").map(c=>typeof c=="string"?xe(e,c):c instanceof Element?xe(c,"change"):Y(c)?et(c):c);if(t.includes("@start")){let c={[Symbol.asyncIterator]:()=>c,next(){return c.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(c)}if(t.includes("@ready")){let i=function(I){return typeof I=="string"&&!e.querySelector(I)};var d=i;let s=t.filter(ze).map(I=>we(I)?.[0]).filter(i),l,h={[Symbol.asyncIterator](){return h},throw(I){return l?.throw?l.throw(I):Promise.resolve({done:!0,value:I})},return(I){return l?.return?l.return(I):Promise.resolve({done:!0,value:I})},next(){return l?l.next():We(e,s).then(()=>(l=(n.length>1?ue(...n):n.length===1?n[0]:Re())[Symbol.asyncIterator](),l?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Pe(B(h))}let o=n.length>1?ue(...n):n.length===1?n[0]:Re();return Pe(B(o))}function He(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,o)=>{n.some(d=>d.addedNodes?.length)&&e.isConnected&&(o.disconnect(),t())}).observe(e.ownerDocument.body,{subtree:!0,childList:!0}))}function We(e,t){return t?.length?Promise.all([tt(e,t),He(e)]):He(e)}function tt(e,t){if(t=t.filter(o=>!e.querySelector(o)),!t.length)return Promise.resolve();let n=new Promise(o=>new MutationObserver((d,c)=>{d.some(i=>i.addedNodes?.length)&&t.every(i=>e.querySelector(i))&&(c.disconnect(),o())}).observe(e,{subtree:!0,childList:!0}));if(S){let o=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),d=setTimeout(()=>{E.warn(o,t)},se);n.finally(()=>clearTimeout(d))}return n}var be=Symbol("Unique ID"),z=S?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},nt=0,rt=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","link","main","map","mark","menu","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","script","search","section","select","slot","small","source","span","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr"];function ee(){throw new Error(".ids is a read-only map of Elements")}function me(e){return typeof e=="string"||typeof e=="number"||typeof e=="boolean"||e instanceof Node||e instanceof NodeList||e instanceof HTMLCollection||e===null||e===void 0||Array.isArray(e)||Y(e)||K(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var de=Symbol("callStack"),ot=function(e,t,n){let[o,d,c]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,rt,e],i=c?.commonProperties,s=c?.document??globalThis.document,l=at(s,"removedNodes",c?.enableOnRemovedFromDOM);function h(){return s.createComment(S&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function I({error:a}){return s.createComment(a instanceof Error?a.toString():`Error: -`+JSON.stringify(a,null,2))}let j=s.createElement("STYLE");j.id="--ai-ui-extended-tag-styles-";let fe=new Set,b=Object.create(null,{when:{writable:!1,configurable:!0,enumerable:!1,value:function(...a){return Ae(this,...a)}},attributes:{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(a){if(K(a)){let f=ae(a)?a:a[Symbol.asyncIterator](),m=()=>f.next().then(({done:r,value:g})=>{F(this,g),r||m()},r=>E.warn(r));m()}else F(this,a)}},ids:{configurable:!0,enumerable:!0,set:ee,get(){let a=new Proxy(Object.create(null),{apply:ee,construct:ee,defineProperty:ee,deleteProperty:ee,set:ee,setPrototypeOf:ee,getPrototypeOf(){return null},isExtensible(){return!1},preventExtensions(){return!0},getOwnPropertyDescriptor(f,m){if(this.get(f,m,null))return Reflect.getOwnPropertyDescriptor(f,m)},has(f,m){return!!this.get(f,m,null)},ownKeys:f=>{let m=[...this.querySelectorAll("[id]")].map(g=>g.id),r=[...new Set(m)];return S&&m.length!==r.length&&E.log("Element contains multiple, shadowed decendant ids",r),r},get:(f,m,r)=>{if(typeof m=="string"){if(m in f){if(this.contains(f[m]))return f[m];delete f[m]}let g;if(S){let u=this.querySelectorAll("#"+CSS.escape(m));u.length>1&&(fe.has(m)||(fe.add(m),E.log(`Element contains multiple, shadowed decendants with ID "${m}"`))),g=u[0]}else g=this.querySelector("#"+CSS.escape(m))??void 0;return g&&(f[m]=g),g}}});return Object.defineProperty(this,"ids",{configurable:!0,enumerable:!0,set:ee,get(){return a}}),a}}});i&&O(b,i);function x(...a){let f=[];return function m(r){if(!(r==null||r===$)){if(Y(r)){let g=h();f.push(g),r.then(u=>g.replaceWith(...x(u)),u=>{E.warn(u,z(g)),g.replaceWith(I({error:u}))});return}if(r instanceof Node){f.push(r);return}if(r&&typeof r=="object"&&Symbol.iterator in r&&!(Symbol.asyncIterator in r)&&r[Symbol.iterator]){for(let g of r)m(g);return}if(K(r)){let g=S?` -`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",u=ae(r)?r:r[Symbol.asyncIterator](),R=r.valueOf(),te=R===void 0||R===r?[h()]:x(R),y=te.length?te:[h()];f.push(...y);let p=!0,T=Date.now()+se,P=S&&new Error("Created by").stack,Q=w=>{let M=y.filter(H=>!!H?.parentNode);M.length?(y=[I({error:w})],M[0].replaceWith(...y),M.slice(1).forEach(H=>H?.parentNode.removeChild(H))):E.warn("Can't report error",w,P,y.map(z)),y=[],u.return?.(w)},_=w=>{if(!w.done)try{let M=y.filter(k=>k?.parentNode&&k.isConnected),H=p?y:M;if(M.length&&(p=!1),!H.length||y.every(k=>l(k))){y=[];let k="Element(s) have been removed from the document: "+g;u.return?.(new Error(k));return}S&&p&&T&&T!y.includes(k)&&k.parentNode?.removeChild(k)),u.next().then(_).catch(Q)}catch(M){y=[],u.return?.(M)}};u.next().then(_).catch(Q);return}f.push(s.createTextNode(r.toString()))}}(a),f}o||Object.assign(ot,{nodes:x,UniqueID:be});let W=Object.getPrototypeOf({});function O(a,f,m){if(!(f==null||typeof f!="object"||f===a))for(let[r,g]of Object.entries(Object.getOwnPropertyDescriptors(f)))try{if("value"in g){let u=g.value;u&&K(u)?Object.defineProperty(a,r,g):u&&typeof u=="object"&&!Y(u)?r in a?u instanceof Node?(E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child",r,z(u)),a[r]=u):a[r]!==u&&(Array.isArray(a[r])&&a[r].length!==u.length?u.constructor===Object||u.constructor===Array?O(a[r]=new u.constructor,u):a[r]=u:O(a[r],u)):(m&&(Object.getPrototypeOf(u)===W||!Object.getPrototypeOf(u)?O(g.value={},u):Array.isArray(u)?O(g.value=[],u):E.warn(`Declared propety '${r}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,a,u)),Object.defineProperty(a,r,g)):f[r]!==void 0&&(a[r]=f[r])}else Object.defineProperty(a,r,g)}catch(u){throw E.warn("deepAssign",r,f[r],u),u}}function oe(a){let f=a?.valueOf();return Array.isArray(f)?Array.prototype.map.call(f,oe):f}function F(a,f){de in f||function m(r,g){if(g==null||typeof g!="object")return;let u=Object.entries(Object.getOwnPropertyDescriptors(g));Array.isArray(g)||u.sort(y=>{let p=Object.getOwnPropertyDescriptor(r,y[0]);if(p){if("value"in p)return-1;if("set"in p||"get"in p)return 1}return 0});for(let[y,p]of u)try{if("value"in p){let T=p.value;K(T)?R(T,y):Y(T)?T.then(P=>{P&&typeof P=="object"?K(P)?R(P,y):te(P,y):g[y]!==void 0&&(r[y]=P)},P=>E.log("Failed to set attribute",P)):K(T)||(T&&typeof T=="object"&&!Y(T)?te(T,y):g[y]!==void 0&&(r[y]=g[y]))}else Object.defineProperty(r,y,p)}catch(T){throw E.warn("assignProps",y,g[y],T),T}function R(y,p){let T=Ie(y),P=!0,Q=Date.now()+se,_=S&&new Error("Created by").stack,w=k=>{if(!k.done){let C=oe(k.value);if(typeof C=="object"&&C!==null){let L=Object.getOwnPropertyDescriptor(r,p);p==="style"||!L?.set?m(r[p],C):r[p]=C}else C!==void 0&&(r[p]=C);let V=a.isConnected;if(l(a)||!P&&!V){E.info(`Element does not exist in document when setting async attribute '${p}' to: +`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!we(e)}async function*et(e){yield e}function Ae(e,...t){if(!t||t.length===0)return Pe(xe(e,"change"));let n=t.filter(u=>typeof u!="string"||u[0]!=="@").map(u=>typeof u=="string"?xe(e,u):u instanceof Element?xe(u,"change"):Y(u)?et(u):u);if(t.includes("@start")){let u={[Symbol.asyncIterator]:()=>u,next(){return u.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(u)}if(t.includes("@ready")){let l=function(I){return typeof I=="string"&&!e.querySelector(I)};var d=l;let s=t.filter(ze).map(I=>we(I)?.[0]).filter(l),c,h={[Symbol.asyncIterator](){return h},throw(I){return c?.throw?c.throw(I):Promise.resolve({done:!0,value:I})},return(I){return c?.return?c.return(I):Promise.resolve({done:!0,value:I})},next(){return c?c.next():We(e,s).then(()=>(c=(n.length>1?ue(...n):n.length===1?n[0]:Re())[Symbol.asyncIterator](),c?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Pe(B(h))}let o=n.length>1?ue(...n):n.length===1?n[0]:Re();return Pe(B(o))}function He(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,o)=>{n.some(d=>d.addedNodes?.length)&&e.isConnected&&(o.disconnect(),t())}).observe(e.ownerDocument.body,{subtree:!0,childList:!0}))}function We(e,t){return t?.length?Promise.all([tt(e,t),He(e)]):He(e)}function tt(e,t){if(t=t.filter(o=>!e.querySelector(o)),!t.length)return Promise.resolve();let n=new Promise(o=>new MutationObserver((d,u)=>{d.some(l=>l.addedNodes?.length)&&t.every(l=>e.querySelector(l))&&(u.disconnect(),o())}).observe(e,{subtree:!0,childList:!0}));if(S){let o=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),d=setTimeout(()=>{E.warn(o,t)},se);n.finally(()=>clearTimeout(d))}return n}var be=Symbol("Unique ID"),z=S?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},nt=0,rt=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","link","main","map","mark","menu","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","script","search","section","select","slot","small","source","span","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr"];function ee(){throw new Error(".ids is a read-only map of Elements")}function me(e){return typeof e=="string"||typeof e=="number"||typeof e=="boolean"||e instanceof Node||e instanceof NodeList||e instanceof HTMLCollection||e===null||e===void 0||Array.isArray(e)||Y(e)||K(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var de=Symbol("callStack"),ot=function(e,t,n){let[o,d,u]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,rt,e],l=u?.commonProperties,s=u?.document??globalThis.document,c=at(s,"removedNodes",u?.enableOnRemovedFromDOM);function h(){return s.createComment(S&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function I({error:a}){return s.createComment(a instanceof Error?a.toString():`Error: +`+JSON.stringify(a,null,2))}let j=s.createElement("STYLE");j.id="--ai-ui-extended-tag-styles-";let fe=new Set,b=Object.create(null,{when:{writable:!1,configurable:!0,enumerable:!1,value:function(...a){return Ae(this,...a)}},attributes:{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(a){if(K(a)){let f=ae(a)?a:a[Symbol.asyncIterator](),m=()=>f.next().then(({done:r,value:g})=>{F(this,g),r||m()},r=>E.warn(r));m()}else F(this,a)}},ids:{configurable:!0,enumerable:!0,set:ee,get(){let a=new Proxy(Object.create(null),{apply:ee,construct:ee,defineProperty:ee,deleteProperty:ee,set:ee,setPrototypeOf:ee,getPrototypeOf(){return null},isExtensible(){return!1},preventExtensions(){return!0},getOwnPropertyDescriptor(f,m){if(this.get(f,m,null))return Reflect.getOwnPropertyDescriptor(f,m)},has(f,m){return!!this.get(f,m,null)},ownKeys:f=>{let m=[...this.querySelectorAll("[id]")].map(g=>g.id),r=[...new Set(m)];return S&&m.length!==r.length&&E.log("Element contains multiple, shadowed decendant ids",r),r},get:(f,m,r)=>{if(typeof m=="string"){if(m in f){let i=f[m].deref();if(i&&i.id===m&&this.contains(i))return i;delete f[m]}let g;if(S){let i=this.querySelectorAll("#"+CSS.escape(m));i.length>1&&(fe.has(m)||(fe.add(m),E.log(`Element contains multiple, shadowed decendants with ID "${m}"`))),g=i[0]}else g=this.querySelector("#"+CSS.escape(m))??void 0;return g&&(f[m]=new WeakRef(g)),g}}});return Object.defineProperty(this,"ids",{configurable:!0,enumerable:!0,set:ee,get(){return a}}),a}}});l&&O(b,l);function x(...a){let f=[];return function m(r){if(!(r==null||r===$)){if(Y(r)){let g=h();f.push(g),r.then(i=>g.replaceWith(...x(i)),i=>{E.warn(i,z(g)),g.replaceWith(I({error:i}))});return}if(r instanceof Node){f.push(r);return}if(r&&typeof r=="object"&&Symbol.iterator in r&&!(Symbol.asyncIterator in r)&&r[Symbol.iterator]){for(let g of r)m(g);return}if(K(r)){let g=S?` +`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",i=ae(r)?r:r[Symbol.asyncIterator](),R=r.valueOf(),te=R===void 0||R===r?[h()]:x(R),y=te.length?te:[h()];f.push(...y);let p=!0,T=Date.now()+se,P=S&&new Error("Created by").stack,Q=w=>{let M=y.filter(H=>!!H?.parentNode);M.length?(y=[I({error:w})],M[0].replaceWith(...y),M.slice(1).forEach(H=>H?.parentNode.removeChild(H))):E.warn("Can't report error",w,P,y.map(z)),y=[],i.return?.(w)},_=w=>{if(!w.done)try{let M=y.filter(k=>k?.parentNode&&k.isConnected),H=p?y:M;if(M.length&&(p=!1),!H.length||y.every(k=>c(k))){y=[];let k="Element(s) have been removed from the document: "+g;i.return?.(new Error(k));return}S&&p&&T&&T!y.includes(k)&&k.parentNode?.removeChild(k)),i.next().then(_).catch(Q)}catch(M){y=[],i.return?.(M)}};i.next().then(_).catch(Q);return}f.push(s.createTextNode(r.toString()))}}(a),f}o||Object.assign(ot,{nodes:x,UniqueID:be});let W=Object.getPrototypeOf({});function O(a,f,m){if(!(f==null||typeof f!="object"||f===a))for(let[r,g]of Object.entries(Object.getOwnPropertyDescriptors(f)))try{if("value"in g){let i=g.value;i&&K(i)?Object.defineProperty(a,r,g):i&&typeof i=="object"&&!Y(i)?r in a?i instanceof Node?(E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child",r,z(i)),a[r]=i):a[r]!==i&&(Array.isArray(a[r])&&a[r].length!==i.length?i.constructor===Object||i.constructor===Array?O(a[r]=new i.constructor,i):a[r]=i:O(a[r],i)):(m&&(Object.getPrototypeOf(i)===W||!Object.getPrototypeOf(i)?O(g.value={},i):Array.isArray(i)?O(g.value=[],i):E.warn(`Declared propety '${r}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,a,i)),Object.defineProperty(a,r,g)):f[r]!==void 0&&(a[r]=f[r])}else Object.defineProperty(a,r,g)}catch(i){throw E.warn("deepAssign",r,f[r],i),i}}function oe(a){let f=a?.valueOf();return Array.isArray(f)?Array.prototype.map.call(f,oe):f}function F(a,f){de in f||function m(r,g){if(g==null||typeof g!="object")return;let i=Object.entries(Object.getOwnPropertyDescriptors(g));Array.isArray(g)||i.sort(y=>{let p=Object.getOwnPropertyDescriptor(r,y[0]);if(p){if("value"in p)return-1;if("set"in p||"get"in p)return 1}return 0});for(let[y,p]of i)try{if("value"in p){let T=p.value;K(T)?R(T,y):Y(T)?T.then(P=>{P&&typeof P=="object"?K(P)?R(P,y):te(P,y):g[y]!==void 0&&(r[y]=P)},P=>E.log("Failed to set attribute",P)):K(T)||(T&&typeof T=="object"&&!Y(T)?te(T,y):g[y]!==void 0&&(r[y]=g[y]))}else Object.defineProperty(r,y,p)}catch(T){throw E.warn("assignProps",y,g[y],T),T}function R(y,p){let T=Ie(y),P=!0,Q=Date.now()+se,_=S&&new Error("Created by").stack,w=k=>{if(!k.done){let C=oe(k.value);if(typeof C=="object"&&C!==null){let L=Object.getOwnPropertyDescriptor(r,p);p==="style"||!L?.set?m(r[p],C):r[p]=C}else C!==void 0&&(r[p]=C);let V=a.isConnected;if(c(a)||!P&&!V){E.info(`Element does not exist in document when setting async attribute '${p}' to: ${z(a)}`),T.return?.();return}V&&(P=!1),P&&Q&&Q{E.warn("Dynamic attribute error",k,p,r,_,z(a)),T.return?.(k),a.appendChild(I({error:k}))},H=y.valueOf();H!==void 0&&H!==y&&!K(H)?w({done:!1,value:H}):T.next().then(w).catch(M)}function te(y,p){if(y instanceof Node)E.info("Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes",p,z(y)),r[p]=y;else if(!(p in r)||r[p]===y||Array.isArray(r[p])&&r[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let T=new y.constructor;m(T,y),r[p]=T}else r[p]=y;else Object.getOwnPropertyDescriptor(r,p)?.set?r[p]=y:m(r[p],y)}}(a,f)}function A(a){for(let f=a.constructor;f;f=f.super)if(f===this)return!0;return!1}function v(a){let f=typeof a!="function"?p=>Object.assign({},a,p):a,m=Date.now().toString(36)+(nt++).toString(36)+Math.random().toString(36).slice(2),r=f({[be]:m});r.styles&&(j.appendChild(s.createTextNode(r.styles+` -`)),s.head.contains(j)||s.head.appendChild(j));let u=Object.assign((p,...T)=>{let P=me(p),Q=[],_={[de]:(P?Q:p[de])??Q},w=P?this(_,p,...T):this(_,...T);w.constructor=u;let M=f({[be]:m});if(_[de].push(M),S){let C=function(V,L){for(let U=V;U;U=U.super)if(U.definition?.declare&&L in U.definition.declare)return!0;return!1};var k=C;if(M.declare){let V=Object.keys(M.declare).filter(L=>L in w||C(this,L));V.length&&E.log(`Declared keys '${V}' in ${u.name} already exist in base '${this.valueOf()}'`)}if(M.override){let V=Object.keys(M.override).filter(L=>!(L in w)&&!(i&&L in i)&&!C(this,L));V.length&&E.log(`Overridden keys '${V}' in ${u.name} do not exist in base '${this.valueOf()}'`)}}O(w,M.declare,!0),O(w,M.override);let H=new Set;if(M.iterable&&Object.keys(M.iterable).forEach(C=>{C in w?(E.log(`Ignoring attempt to re-define iterable property "${C}" as it could already have consumers`),H.add(C)):Ee(w,C,M.iterable[C])}),_[de]===Q){P||F(w,p);for(let L of Q){let U=L?.constructed?.call(w);me(U)&&w.append(...x(U))}let C={},V=!1;for(let L of Q)if(L.iterable)for(let U of Object.keys(L.iterable)){let Se=!P&&U in p;if(H.has(U)&&Se||!(Se&&(!Y(p[U])||!K(p[U])))){let Oe=w[U]?.valueOf();Oe!==void 0&&(C[U]=Oe,V=!0)}}V&&Object.assign(w,C)}return w},{super:this,definition:Object.assign(r,{[be]:m}),extended:v,valueOf:()=>{let p=[...Object.keys(r.declare||{}),...Object.keys(r.iterable||{})];return`${u.name}: {${p.join(", ")}} - \u21AA ${this.valueOf()}`}});Object.defineProperty(u,Symbol.hasInstance,{value:A,writable:!0,configurable:!0});let R={};(function p(T){T?.super&&p(T.super);let P=T.definition;P&&(O(R,P?.override),O(R,P?.declare))})(this),O(R,r.override),O(R,r.declare),Object.defineProperties(u,Object.getOwnPropertyDescriptors(R));let te=R&&"className"in R&&typeof R.className=="string"?R.className:m,y=S?new Error().stack?.split(` -`)[2]??"":"";if(Object.defineProperty(u,"name",{value:""}),S){let p=Object.keys(r).filter(T=>!["styles","ids","constructed","declare","override","iterable"].includes(T));p.length&&E.log(`${u.name} defines extraneous keys '${p}', which are unknown`)}return u}let G={createElement(a,f,...m){return a===G.createElement?x(...m):typeof a=="function"?a(f,m):typeof a=="string"&&a in G?G[a](f,m):a instanceof Node?a:I({error:new Error("Illegal type in createElement:"+a)})}};function N(a){if(G[a])return G[a];let f=(r,...g)=>{if(me(r)&&(g.unshift(r),r={}),!me(r)){if(r.debugger){debugger;delete r.debugger}let u=o?s.createElementNS(o,a.toLowerCase()):s.createElement(a);return u.constructor=f,O(u,b),F(u,r),u.append(...x(...g)),u}},m=Object.assign(f,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:v,valueOf(){return`TagCreator: <${o||""}${o?"::":""}${a}>`}});return Object.defineProperty(f,Symbol.hasInstance,{value:A,writable:!0,configurable:!0}),Object.defineProperty(f,"name",{value:"<"+a+">"}),G[a]=m}return d.forEach(N),G};function at(e,t,n){let o=new WeakSet;function d(c){for(let i of c)t==="addedNodes"===i.isConnected&&(d(i.childNodes),o.add(i),n&&"onRemovedFromDOM"in i&&typeof i.onRemovedFromDOM=="function"&&i.onRemovedFromDOM())}return new MutationObserver(c=>{c.forEach(function(i){i.type==="childList"&&i[t].length&&d(i[t])})}).observe(e,{subtree:!0,childList:!0}),function(c){return o.has(c)}}export{De as Iterators,be as UniqueID,ot as tag,Ae as when}; +`)),s.head.contains(j)||s.head.appendChild(j));let i=Object.assign((p,...T)=>{let P=me(p),Q=[],_={[de]:(P?Q:p[de])??Q},w=P?this(_,p,...T):this(_,...T);w.constructor=i;let M=f({[be]:m});if(_[de].push(M),S){let C=function(V,L){for(let U=V;U;U=U.super)if(U.definition?.declare&&L in U.definition.declare)return!0;return!1};var k=C;if(M.declare){let V=Object.keys(M.declare).filter(L=>L in w||C(this,L));V.length&&E.log(`Declared keys '${V}' in ${i.name} already exist in base '${this.valueOf()}'`)}if(M.override){let V=Object.keys(M.override).filter(L=>!(L in w)&&!(l&&L in l)&&!C(this,L));V.length&&E.log(`Overridden keys '${V}' in ${i.name} do not exist in base '${this.valueOf()}'`)}}O(w,M.declare,!0),O(w,M.override);let H=new Set;if(M.iterable&&Object.keys(M.iterable).forEach(C=>{C in w?(E.log(`Ignoring attempt to re-define iterable property "${C}" as it could already have consumers`),H.add(C)):Ee(w,C,M.iterable[C])}),_[de]===Q){P||F(w,p);for(let L of Q){let U=L?.constructed?.call(w);me(U)&&w.append(...x(U))}let C={},V=!1;for(let L of Q)if(L.iterable)for(let U of Object.keys(L.iterable)){let Se=!P&&U in p;if(H.has(U)&&Se||!(Se&&(!Y(p[U])||!K(p[U])))){let Oe=w[U]?.valueOf();Oe!==void 0&&(C[U]=Oe,V=!0)}}V&&Object.assign(w,C)}return w},{super:this,definition:Object.assign(r,{[be]:m}),extended:v,valueOf:()=>{let p=[...Object.keys(r.declare||{}),...Object.keys(r.iterable||{})];return`${i.name}: {${p.join(", ")}} + \u21AA ${this.valueOf()}`}});Object.defineProperty(i,Symbol.hasInstance,{value:A,writable:!0,configurable:!0});let R={};(function p(T){T?.super&&p(T.super);let P=T.definition;P&&(O(R,P?.override),O(R,P?.declare))})(this),O(R,r.override),O(R,r.declare),Object.defineProperties(i,Object.getOwnPropertyDescriptors(R));let te=R&&"className"in R&&typeof R.className=="string"?R.className:m,y=S?new Error().stack?.split(` +`)[2]??"":"";if(Object.defineProperty(i,"name",{value:""}),S){let p=Object.keys(r).filter(T=>!["styles","ids","constructed","declare","override","iterable"].includes(T));p.length&&E.log(`${i.name} defines extraneous keys '${p}', which are unknown`)}return i}let G={createElement(a,f,...m){return a===G.createElement?x(...m):typeof a=="function"?a(f,m):typeof a=="string"&&a in G?G[a](f,m):a instanceof Node?a:I({error:new Error("Illegal type in createElement:"+a)})}};function N(a){if(G[a])return G[a];let f=(r,...g)=>{if(me(r)&&(g.unshift(r),r={}),!me(r)){if(r.debugger){debugger;delete r.debugger}let i=o?s.createElementNS(o,a.toLowerCase()):s.createElement(a);return i.constructor=f,O(i,b),F(i,r),i.append(...x(...g)),i}},m=Object.assign(f,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:v,valueOf(){return`TagCreator: <${o||""}${o?"::":""}${a}>`}});return Object.defineProperty(f,Symbol.hasInstance,{value:A,writable:!0,configurable:!0}),Object.defineProperty(f,"name",{value:"<"+a+">"}),G[a]=m}return d.forEach(N),G};function at(e,t,n){let o=new WeakSet;function d(u){for(let l of u)t==="addedNodes"===l.isConnected&&(d(l.childNodes),o.add(l),n&&"onRemovedFromDOM"in l&&typeof l.onRemovedFromDOM=="function"&&l.onRemovedFromDOM())}return new MutationObserver(u=>{u.forEach(function(l){l.type==="childList"&&l[t].length&&d(l[t])})}).observe(e,{subtree:!0,childList:!0}),function(u){return o.has(u)}}export{De as Iterators,be as UniqueID,ot as tag,Ae as when}; diff --git a/module/dist/ai-ui.mjs b/module/dist/ai-ui.mjs index 4821ed1..8942228 100644 --- a/module/dist/ai-ui.mjs +++ b/module/dist/ai-ui.mjs @@ -1036,8 +1036,9 @@ var tag = function(_1, _2, _3) { get: (target, p, receiver) => { if (typeof p === "string") { if (p in target) { - if (this.contains(target[p])) - return target[p]; + const ref = target[p].deref(); + if (ref && ref.id === p && this.contains(ref)) + return ref; delete target[p]; } let e; @@ -1056,7 +1057,7 @@ var tag = function(_1, _2, _3) { } else { e = this.querySelector("#" + CSS.escape(p)) ?? void 0; } - if (e) target[p] = e; + if (e) target[p] = new WeakRef(e); return e; } } @@ -1545,4 +1546,4 @@ export { tag, when }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/debug.ts", "../src/deferred.ts", "../src/iterators.ts", "../src/when.ts", "../src/ai-ui.ts"],
  "sourcesContent": ["// @ts-ignore\nexport const DEBUG = globalThis.DEBUG == '*' || globalThis.DEBUG == true || globalThis.DEBUG?.match(/(^|\\W)AI-UI(\\W|$)/) || false;\nexport { _console as console };\nexport const timeOutWarn = 5000;\n\nconst _console = {\n  log(...args: any) {\n    if (DEBUG) console.log('(AI-UI) LOG:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  info(...args: any) {\n    if (DEBUG) console.trace('(AI-UI) INFO:', ...args)\n  }\n}\n\n", "import { DEBUG, console } from \"./debug.js\";\n\n// Create a deferred Promise, which can be asynchronously/externally resolved or rejected.\nexport type DeferredPromise<T> = Promise<T> & {\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (value: any) => void;\n}\n\n// Used to suppress TS error about use before initialisation\nconst nothing = (v: any)=>{};\n\nexport function deferred<T>(): DeferredPromise<T> {\n  let resolve: (value: T | PromiseLike<T>) => void = nothing;\n  let reject: (value: any) => void = nothing;\n  const promise = new Promise<T>((...r) => [resolve, reject] = r) as DeferredPromise<T>;\n  promise.resolve = resolve;\n  promise.reject = reject;\n  if (DEBUG) {\n    const initLocation = new Error().stack;\n    promise.catch(ex => (ex instanceof Error || ex?.value instanceof Error) ? console.log(\"Deferred rejection\", ex, \"allocated at \", initLocation) : undefined);\n  }\n  return promise;\n}\n\n// True if `expr in x` is valid\nexport function isObjectLike(x: any): x is Function | {} {\n  return x && typeof x === 'object' || typeof x === 'function'\n}\n\nexport function isPromiseLike<T>(x: any): x is PromiseLike<T> {\n  return isObjectLike(x) && ('then' in x) && typeof x.then === 'function';\n}\n", "import { DEBUG, console } from \"./debug.js\"\nimport { DeferredPromise, deferred, isObjectLike, isPromiseLike } from \"./deferred.js\"\n\n/* IterableProperties can't be correctly typed in TS right now, either the declaratiion\n  works for retrieval (the getter), or it works for assignments (the setter), but there's\n  no TS syntax that permits correct type-checking at present.\n\n  Ideally, it would be:\n\n  type IterableProperties<IP> = {\n    get [K in keyof IP](): AsyncExtraIterable<IP[K]> & IP[K]\n    set [K in keyof IP](v: IP[K])\n  }\n  See https://github.com/microsoft/TypeScript/issues/43826\n\n  We choose the following type description to avoid the issues above. Because the AsyncExtraIterable\n  is Partial it can be omitted from assignments:\n    this.prop = value;  // Valid, as long as valus has the same type as the prop\n  ...and when retrieved it will be the value type, and optionally the async iterator:\n    Div(this.prop) ; // the value\n    this.prop.map!(....)  // the iterator (note the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts which *accepts* a Partial<AsyncIterator>\n  but casts it to a AsyncIterator before use.\n\n  The iterability of propertys of an object is determined by the presence and value of the `Iterability` symbol.\n  By default, the current implementation does a deep mapping, so an iterable property 'obj' is itself\n  iterable, as are it's members. The only defined value at present is \"shallow\", in which case 'obj' remains\n  iterable, but it's membetrs are just POJS values.\n*/\n\n// Base types that can be made defined as iterable: basically anything, _except_ a function\nexport type IterablePropertyPrimitive = (string | number | bigint | boolean | undefined | null);\n// We should exclude AsyncIterable from the types that can be assigned to iterables (and therefore passed to defineIterableProperty)\nexport type IterablePropertyValue = IterablePropertyPrimitive | IterablePropertyValue[] | { [k: string | symbol | number]: IterablePropertyValue };\n\nexport const Iterability = Symbol(\"Iterability\");\nexport type Iterability<Depth extends 'shallow' = 'shallow'> = { [Iterability]: Depth };\nexport type IterableType<T> = T & Partial<AsyncExtraIterable<T>>;\n\ndeclare global {\n  // This is patch to the std lib definition of Array<T>. I don't know why it's absent,\n  // as this is the implementation in all JavaScript engines. It is probably a result\n  // of its absence in https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values,\n  // which inherits from the Object.prototype, which makes no claim for the return type\n  // since it could be overriddem. However, in that case, a TS defn should also override\n  // it, like Number, String, Boolean etc do.\n  interface Array<T> {\n    valueOf(): Array<T>;\n  }\n  // As above, the return type could be T rather than Object, since this is the default impl,\n  // but it's not, for some reason.\n  interface Object {\n    valueOf<T>(this: T): T extends IterableType<infer Z> ? Z : Object;\n  }\n}\n\nexport type IterableProperties<IP> = IP extends Iterability<'shallow'> ? {\n  [K in keyof Omit<IP, typeof Iterability>]: IterableType<IP[K]>\n} : ({\n  [K in keyof IP]: (\n    IP[K] extends Array<infer E>\n    ? (IterableProperties<E>[] | IterableProperties<E[]>)\n    : ((\n      IP[K] extends object\n      ? IterableProperties<IP[K]>\n      : IP[K]\n    ) & IterableType<IP[K]>)\n  )\n})\n\n/* Things to suppliement the JS base AsyncIterable */\nexport interface QueueIteratableIterator<T> extends AsyncIterableIterator<T>, AsyncIterableHelpers {\n  push(value: T): boolean;\n  readonly length: number;\n}\n\nexport interface AsyncExtraIterable<T> extends AsyncIterable<T>, AsyncIterableHelpers { }\n\n// NB: This also (incorrectly) passes sync iterators, as the protocol names are the same\nexport function isAsyncIterator<T = unknown>(o: any | AsyncIterator<T>): o is AsyncIterator<T> {\n  return isObjectLike(o) && 'next' in o && typeof o?.next === 'function'\n}\nexport function isAsyncIterable<T = unknown>(o: any | AsyncIterable<T>): o is AsyncIterable<T> {\n  return isObjectLike(o) && (Symbol.asyncIterator in o) && typeof o[Symbol.asyncIterator] === 'function'\n}\nexport function isAsyncIter<T = unknown>(o: any | AsyncIterable<T> | AsyncIterator<T>): o is AsyncIterable<T> | AsyncIterator<T> {\n  return isAsyncIterable(o) || isAsyncIterator(o)\n}\n\nexport type AsyncProvider<T> = AsyncIterator<T> | AsyncIterable<T>\n\nexport function asyncIterator<T>(o: AsyncProvider<T>) {\n  if (isAsyncIterator(o)) return o;\n  if (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  throw new Error(\"Not an async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nexport const asyncExtras = {\n  filterMap<U extends PartialIterable, R>(this: U,\n    fn: (o: HelperAsyncIterable<U>, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>,\n    initialValue: R | typeof Ignore = Ignore\n  ) {\n    return filterMap(this, fn, initialValue)\n  },\n  map,\n  filter,\n  unique,\n  waitFor,\n  multi,\n  initially,\n  consume,\n  merge<T, A extends Partial<AsyncIterable<any>>[]>(this: PartialIterable<T>, ...m: A) {\n    return merge(this, ...m);\n  },\n  combine<T, S extends CombinedIterable>(this: PartialIterable<T>, others: S) {\n    return combine(Object.assign({ '_this': this }, others));\n  }\n};\n\nconst extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)] as (keyof typeof asyncExtras)[];\n\n// Like Object.assign, but the assigned properties are not enumerable\nfunction assignHidden<D extends {}, S extends {}>(d: D, s: S) {\n  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];\n  for (const k of keys) {\n    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });\n  }\n  return d as D & S;\n}\n\nconst _pending = Symbol('pending');\nconst _items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [_items]: [] as IteratorResult<T>[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[_items]?.length) {\n        return Promise.resolve(q[_items].shift()!);\n      }\n\n      if (!q[_pending])\n        return Promise.resolve({ done: true as const, value: undefined });\n\n      const value = deferred<IteratorResult<T>>();\n      // We install a catch handler as the promise might be legitimately reject before anything waits for it,\n      // and this suppresses the uncaught exception warning.\n      value.catch(ex => { });\n      q[_pending].unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.resolve(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.resolve(value);\n    },\n\n    throw(...args: any[]) {\n      const value = { done: true as const, value: args[0] };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.reject(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[_items]) return -1; // The queue has no consumers and has terminated.\n      return q[_items].length;\n    },\n\n    push(value: T) {\n      if (!q[_pending])\n        return false;\n\n      if (q[_pending].length) {\n        q[_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[_items].push({ done: false, value })\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst _inflight = Symbol('inflight');\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [_inflight]: Set<T> };\n  q[_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[_pending])\n      return false;\n\n    // Debounce\n    if (q[_inflight].has(value))\n      return true;\n\n    if (q[_pending].length) {\n      q[_inflight].add(value);\n      const p = q[_pending].pop()!;\n      p.finally(() => q[_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[_items].find(v => v.value === value)) {\n        q[_items].push({ done: false, value });\n      }\n    }\n    return true;\n  }\n  return q;\n}\n\n// Re-export to hide the internals\nexport const queueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalQueueIteratableIterator;\nexport const debounceQueueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalDebounceQueueIteratableIterator;\n\ndeclare global {\n  interface ObjectConstructor {\n    defineProperties<T, M extends { [K: string | symbol]: TypedPropertyDescriptor<any> }>(o: T, properties: M & ThisType<any>): T & {\n      [K in keyof M]: M[K] extends TypedPropertyDescriptor<infer T> ? T : never\n    };\n  }\n}\n\n/* Define a \"iterable property\" on `obj`.\n   This is a property that holds a boxed (within an Object() call) value, and is also an AsyncIterableIterator. which\n   yields when the property is set.\n   This routine creates the getter/setter for the specified property, and manages the aassociated async iterator.\n*/\n\nconst _proxiedAsyncIterator = Symbol('_proxiedAsyncIterator');\nexport function defineIterableProperty<T extends {}, const N extends string | symbol, V extends IterablePropertyValue>(obj: T, name: N, v: V): T & IterableProperties<{ [k in N]: V }> {\n  // Make `a` an AsyncExtraIterable. We don't do this until a consumer actually tries to\n  // access the iterator methods to prevent leaks where an iterable is created, but\n  // never referenced, and therefore cannot be consumed and ultimately closed\n  let initIterator = () => {\n    initIterator = () => b;\n    const bi = debounceQueueIteratableIterator<V>();\n    const mi = bi.multi();\n    const b = mi[Symbol.asyncIterator]();\n    extras[Symbol.asyncIterator] = mi[Symbol.asyncIterator];\n    push = bi.push;\n    extraKeys.forEach(k => // @ts-ignore\n      extras[k] = b[k as keyof typeof b]);\n    if (!(_proxiedAsyncIterator in a))\n      assignHidden(a, extras);\n    return b;\n  }\n\n  // Create stubs that lazily create the AsyncExtraIterable interface when invoked\n  function lazyAsyncMethod<M extends keyof typeof asyncExtras>(method: M) {\n    return {\n      [method]: function (this: unknown, ...args: any[]) {\n        initIterator();\n        // @ts-ignore - Fix\n        return a[method].apply(this, args);\n      } as (typeof asyncExtras)[M]\n    }[method];\n  }\n\n  type HelperDescriptors<T> = {\n    [K in keyof AsyncExtraIterable<T>]: TypedPropertyDescriptor<AsyncExtraIterable<T>[K]>\n  } & {\n    [Iterability]?: TypedPropertyDescriptor<'shallow'>\n  };\n\n  const extras = { [Symbol.asyncIterator]: initIterator } as AsyncExtraIterable<V> & { [Iterability]?: 'shallow' };\n  extraKeys.forEach((k) => // @ts-ignore\n    extras[k] = lazyAsyncMethod(k))\n  if (typeof v === 'object' && v && Iterability in v && v[Iterability] === 'shallow') {\n    extras[Iterability] = v[Iterability];\n  }\n\n  // Lazily initialize `push`\n  let push: QueueIteratableIterator<V>['push'] = (v: V) => {\n    initIterator(); // Updates `push` to reference the multi-queue\n    return push(v);\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<V> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: V | AsyncExtraIterable<V>) {\n      if (v !== a) {\n        if (isAsyncIterable(v)) {\n          // Assigning multiple async iterators to a single iterable is probably a\n          // bad idea from a reasoning point of view, and multiple implementations\n          // are possible:\n          //  * merge?\n          //  * ignore subsequent assignments?\n          //  * terminate the first then consume the second?\n          // The solution here (one of many possibilities) is the letter: only to allow\n          // most recent assignment to work, terminating any preceeding iterator when it next\n          // yields and finds this consumer has been re-assigned.\n\n          // If the iterator has been reassigned with no change, just ignore it, as we're already consuming it\n          if (piped === v)\n            return;\n\n          piped = v;\n          let stack = DEBUG ? new Error() : undefined;\n          if (DEBUG)\n            console.info(new Error(`Iterable \"${name.toString()}\" has been assigned to consume another iterator. Did you mean to declare it?`));\n          consume.call(v, y => {\n            if (v !== piped) {\n              // We're being piped from something else. We want to stop that one and get piped from this one\n              throw new Error(`Piped iterable \"${name.toString()}\" has been replaced by another iterator`, { cause: stack });\n            }\n            push(y?.valueOf() as V)\n          })\n            .catch(ex => console.info(ex))\n            .finally(() => (v === piped) && (piped = undefined));\n\n          // Early return as we're going to pipe values in later\n          return;\n        } else {\n          if (piped && DEBUG) {\n            console.log(`Iterable \"${name.toString()}\" is already piped from another iterator, and might be overrwitten later`);\n          }\n          a = box(v, extras);\n        }\n      }\n      push(v?.valueOf() as V);\n    },\n    enumerable: true\n  });\n  return obj as any;\n\n  function box<V>(a: V, pds: AsyncExtraIterable<V>): V & AsyncExtraIterable<V> {\n    if (a === null || a === undefined) {\n      return assignHidden(Object.create(null, {\n        valueOf: { value() { return a }, writable: true, configurable: true },\n        toJSON: { value() { return a }, writable: true, configurable: true }\n      }), pds);\n    }\n    switch (typeof a) {\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return assignHidden(Object(a), Object.assign(pds, {\n          toJSON() { return a.valueOf() }\n        }));\n      case 'object':\n        // We box objects by creating a Proxy for the object that pushes on get/set/delete, and maps the supplied async iterator to push the specified key\n        // The proxies are recursive, so that if an object contains objects, they too are proxied. Objects containing primitives remain proxied to\n        // handle the get/set/selete in place of the usual primitive boxing via Object(primitiveValue)\n        // @ts-ignore\n        return boxObject(a, pds);\n\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n\n  type WithPath = { [_proxiedAsyncIterator]: { a: V, path: string | null } };\n  type PossiblyWithPath = V | WithPath;\n  function isProxiedAsyncIterator(o: PossiblyWithPath): o is WithPath {\n    return isObjectLike(o) && _proxiedAsyncIterator in o;\n  }\n  function destructure(o: any, path: string) {\n    const fields = path.split('.').slice(1);\n    for (let i = 0; i < fields.length && ((o = o?.[fields[i]]) !== undefined); i++);\n    return o;\n  }\n  function boxObject(a: V, pds: AsyncExtraIterable<PossiblyWithPath>) {\n    let withPath: AsyncExtraIterable<WithPath[typeof _proxiedAsyncIterator]>;\n    let withoutPath: AsyncExtraIterable<V>;\n    return new Proxy(a as object, handler()) as V & AsyncExtraIterable<V>;\n\n    function handler(path = ''): ProxyHandler<object> {\n      return {\n        // A boxed object has its own keys, and the keys of an AsyncExtraIterable\n        has(target, key) {\n          return key === _proxiedAsyncIterator || key === Symbol.toPrimitive || key in target || key in pds;\n        },\n        // When a key is set in the target, push the change\n        set(target, key, value, receiver) {\n          if (Object.hasOwn(pds, key)) {\n            throw new Error(`Cannot set ${name.toString()}${path}.${key.toString()} as it is part of asyncIterator`);\n          }\n          if (Reflect.get(target, key, receiver) !== value) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n          }\n          return Reflect.set(target, key, value, receiver);\n        },\n        deleteProperty(target, key) {\n          if (Reflect.deleteProperty(target, key)) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n            return true;\n          }\n          return false;\n        },\n        // When getting the value of a boxed object member, prefer asyncExtraIterable over target keys\n        get(target, key, receiver) {\n          // If the key is an asyncExtraIterable member, create the mapped queue to generate it\n          if (Object.hasOwn(pds, key)) {\n            if (!path.length) {\n              withoutPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator].a : o);\n              return withoutPath[key as keyof typeof pds];\n            } else {\n              withPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator] : { a: o, path: null });\n\n              let ai = filterMap(withPath, (o, p) => {\n                const v = destructure(o.a, path);\n                return p !== v || o.path === null || o.path.startsWith(path) ? v : Ignore;\n              }, Ignore, destructure(a, path));\n              return ai[key as keyof typeof ai];\n            }\n          }\n\n          // If the key is a target property, create the proxy to handle it\n          if (key === 'valueOf') return () => destructure(a, path);\n          if (key === Symbol.toPrimitive) {\n            // Special case, since Symbol.toPrimitive is in ha(), we need to implement it\n            return function (hint?: 'string' | 'number' | 'default') {\n              if (Reflect.has(target, key))\n                return Reflect.get(target, key, target).call(target, hint);\n              if (hint === 'string') return target.toString();\n              if (hint === 'number') return Number(target);\n              return target.valueOf();\n            }\n          }\n          if (typeof key === 'string') {\n            if ((!(key in target) || Object.hasOwn(target, key)) && !(Iterability in target && target[Iterability] === 'shallow')) {\n              const field = Reflect.get(target, key, receiver);\n              return (typeof field === 'function') || isAsyncIter(field)\n                ? field\n                : new Proxy(Object(field), handler(path + '.' + key));\n            }\n          }\n          // This is a symbolic entry, or a prototypical value (since it's in the target, but not a target property)\n          return Reflect.get(target, key, receiver);\n        }\n      }\n    }\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\nconst forever = new Promise<any>(() => { });\n\n/* Merge asyncIterables into a single asyncIterable */\n\n/* TS hack to expose the return AsyncGenerator a generator of the union of the merged types */\ntype CollapseIterableType<T> = T[] extends Partial<AsyncIterable<infer U>>[] ? U : never;\ntype CollapseIterableTypes<T> = AsyncIterable<CollapseIterableType<T>>;\n\nexport const merge = <A extends Partial<AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>>[], TYield, TReturn, TNext>(...ai: A) => {\n  const it: (undefined | AsyncIterator<any>)[] = new Array(ai.length);\n  const promises: Promise<{ idx: number, result: IteratorResult<any> }>[] = new Array(ai.length);\n\n  let init = () => {\n    init = () => { }\n    for (let n = 0; n < ai.length; n++) {\n      const a = ai[n] as AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>;\n      promises[n] = (it[n] = Symbol.asyncIterator in a\n        ? a[Symbol.asyncIterator]()\n        : a as AsyncIterator<any>)\n        .next()\n        .then(result => ({ idx: n, result }));\n    }\n  }\n\n  const results: (TYield | TReturn)[] = [];\n  let count = promises.length;\n\n  const merged: AsyncIterableIterator<A[number]> = {\n    [Symbol.asyncIterator]() { return merged },\n    next() {\n      init();\n      return count\n        ? Promise.race(promises).then(({ idx, result }) => {\n          if (result.done) {\n            count--;\n            promises[idx] = forever;\n            results[idx] = result.value;\n            // We don't yield intermediate return values, we just keep them in results\n            // return { done: count === 0, value: result.value }\n            return merged.next();\n          } else {\n            // `ex` is the underlying async iteration exception\n            promises[idx] = it[idx]\n              ? it[idx]!.next().then(result => ({ idx, result })).catch(ex => ({ idx, result: { done: true, value: ex } }))\n              : Promise.resolve({ idx, result: { done: true, value: undefined } })\n            return result;\n          }\n        }).catch(ex => {\n          return merged.throw?.(ex) ?? Promise.reject({ done: true as const, value: new Error(\"Iterator merge exception\") });\n        })\n        : Promise.resolve({ done: true as const, value: results });\n    },\n    async return(r) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.return?.({ done: true, value: r }).then(v => v.value, ex => ex);\n        }\n      }\n      return { done: true, value: results };\n    },\n    async throw(ex: any) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.throw?.(ex).then(v => v.value, ex => ex);\n        }\n      }\n      // Because we've passed the exception on to all the sources, we're now done\n      // previously: return Promise.reject(ex);\n      return { done: true, value: results };\n    }\n  };\n  return iterableHelpers(merged as unknown as CollapseIterableTypes<A[number]>);\n}\n\ntype CombinedIterable = { [k: string | number | symbol]: PartialIterable };\ntype CombinedIterableType<S extends CombinedIterable> = {\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n};\ntype CombinedIterableResult<S extends CombinedIterable> = AsyncExtraIterable<{\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n}>;\n\nexport interface CombineOptions {\n  ignorePartial?: boolean; // Set to avoid yielding if some sources are absent\n}\n\nexport const combine = <S extends CombinedIterable>(src: S, opts: CombineOptions = {}): CombinedIterableResult<S> => {\n  const accumulated: CombinedIterableType<S> = {};\n  let pc: Promise<{ idx: number, k: string, ir: IteratorResult<any> }>[];\n  let si: AsyncIterator<any>[] = [];\n  let active: number = 0;\n  const ci = {\n    [Symbol.asyncIterator]() { return ci },\n    next(): Promise<IteratorResult<CombinedIterableType<S>>> {\n      if (pc === undefined) {\n        pc = Object.entries(src).map(([k, sit], idx) => {\n          active += 1;\n          si[idx] = sit[Symbol.asyncIterator]!();\n          return si[idx].next().then(ir => ({ si, idx, k, ir }));\n        });\n      }\n\n      return (function step(): Promise<IteratorResult<CombinedIterableType<S>>> {\n        return Promise.race(pc).then(({ idx, k, ir }) => {\n          if (ir.done) {\n            pc[idx] = forever;\n            active -= 1;\n            if (!active)\n              return { done: true, value: undefined };\n            return step();\n          } else {\n            // @ts-ignore\n            accumulated[k] = ir.value;\n            pc[idx] = si[idx].next().then(ir => ({ idx, k, ir }));\n          }\n          if (opts.ignorePartial) {\n            if (Object.keys(accumulated).length < Object.keys(src).length)\n              return step();\n          }\n          return { done: false, value: accumulated };\n        })\n      })();\n    },\n    return(v?: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].return?.(v)\n        }\n      });\n      return Promise.resolve({ done: true, value: v });\n    },\n    throw(ex: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].throw?.(ex)\n        }\n      });\n      return Promise.reject({ done: true, value: ex });\n    }\n  }\n  return iterableHelpers(ci);\n}\n\n\nfunction isExtraIterable<T>(i: any): i is AsyncExtraIterable<T> {\n  return isAsyncIterable(i)\n    && extraKeys.every(k => (k in i) && (i as any)[k] === asyncExtras[k]);\n}\n\n// Attach the pre-defined helpers onto an AsyncIterable and return the modified object correctly typed\nexport function iterableHelpers<A extends AsyncIterable<any>>(ai: A): A & AsyncExtraIterable<A extends AsyncIterable<infer T> ? T : unknown> {\n  if (!isExtraIterable(ai)) {\n    assignHidden(ai, asyncExtras);\n  }\n  return ai as A extends AsyncIterable<infer T> ? AsyncExtraIterable<T> & A : never\n}\n\nexport function generatorHelpers<G extends (...args: any[]) => R, R extends AsyncGenerator>(g: G) {\n  return function (...args: Parameters<G>): ReturnType<G> {\n    const ai = g(...args);\n    return iterableHelpers(ai) as ReturnType<G>;\n  } as (...args: Parameters<G>) => ReturnType<G> & AsyncExtraIterable<ReturnType<G> extends AsyncGenerator<infer T> ? T : unknown>\n}\n\n/* AsyncIterable helpers, which can be attached to an AsyncIterator with `withHelpers(ai)`, and invoked directly for foreign asyncIterators */\n\n/* types that accept Partials as potentiallu async iterators, since we permit this IN TYPING so\n  iterable properties don't complain on every access as they are declared as V & Partial<AsyncIterable<V>>\n  due to the setters and getters having different types, but undeclarable in TS due to syntax limitations */\ntype HelperAsyncIterable<Q extends Partial<AsyncIterable<any>>> = HelperAsyncIterator<Required<Q>[typeof Symbol.asyncIterator]>;\ntype HelperAsyncIterator<F> =\n  F extends () => AsyncIterator<infer T>\n  ? T : never;\n\nasync function consume<U extends Partial<AsyncIterable<any>>>(this: U, f?: (u: HelperAsyncIterable<U>) => void | PromiseLike<void>): Promise<void> {\n  let last: undefined | void | PromiseLike<void> = undefined;\n  for await (const u of this as AsyncIterable<HelperAsyncIterable<U>>) {\n    last = f?.(u);\n  }\n  await last;\n}\n\ntype Mapper<U, R> = ((o: U, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>);\ntype MaybePromised<T> = PromiseLike<T> | T;\n\n/* A general filter & mapper that can handle exceptions & returns */\nexport const Ignore = Symbol(\"Ignore\");\n\ntype PartialIterable<T = any> = Partial<AsyncIterable<T>>;\n\nfunction resolveSync<Z, R>(v: MaybePromised<Z>, then: (v: Z) => R, except: (x: any) => any): MaybePromised<R> {\n  if (isPromiseLike(v))\n    return v.then(then, except);\n  try { return then(v) } catch (ex) { return except(ex) }\n}\n\nexport function filterMap<U extends PartialIterable, R>(source: U,\n  fn: Mapper<HelperAsyncIterable<U>, R>,\n  initialValue: R | typeof Ignore = Ignore,\n  prev: R | typeof Ignore = Ignore\n): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  const fai: AsyncIterableIterator<R> = {\n    [Symbol.asyncIterator]() {\n      return fai;\n    },\n\n    next(...args: [] | [undefined]) {\n      if (initialValue !== Ignore) {\n        const init = Promise.resolve({ done: false, value: initialValue });\n        initialValue = Ignore;\n        return init;\n      }\n\n      return new Promise<IteratorResult<R>>(function step(resolve, reject) {\n        if (!ai)\n          ai = source[Symbol.asyncIterator]!();\n        ai.next(...args).then(\n          p => p.done\n            ? resolve(p)\n            : resolveSync(fn(p.value, prev),\n              f => f === Ignore\n                ? step(resolve, reject)\n                : resolve({ done: false, value: prev = f }),\n              ex => {\n                // The filter function failed...\n                ai.throw ? ai.throw(ex) : ai.return?.(ex) // Terminate the source - for now we ignore the result of the termination\n                reject({ done: true, value: ex }); // Terminate the consumer\n              }\n            ),\n\n          ex =>\n            // The source threw. Tell the consumer\n            reject({ done: true, value: ex })\n        ).catch(ex => {\n          // The callback threw\n          ai.throw ? ai.throw(ex) : ai.return?.(ex); // Terminate the source - for now we ignore the result of the termination\n          reject({ done: true, value: ex })\n        })\n      })\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(fai)\n}\n\nfunction map<U extends PartialIterable, R>(this: U, mapper: Mapper<HelperAsyncIterable<U>, R>): AsyncExtraIterable<R> {\n  return filterMap(this, mapper);\n}\n\nfunction filter<U extends PartialIterable>(this: U, fn: (o: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, async o => (await fn(o) ? o : Ignore));\n}\n\nfunction unique<U extends PartialIterable>(this: U, fn?: (next: HelperAsyncIterable<U>, prev: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return fn\n    ? filterMap(this, async (o, p) => (p === Ignore || await fn(o, p)) ? o : Ignore)\n    : filterMap(this, (o, p) => o === p ? Ignore : o);\n}\n\nfunction initially<U extends PartialIterable, I = HelperAsyncIterable<U>>(this: U, initValue: I): AsyncExtraIterable<HelperAsyncIterable<U> | I> {\n  return filterMap(this, o => o, initValue);\n}\n\nfunction waitFor<U extends PartialIterable>(this: U, cb: (done: (value: void | PromiseLike<void>) => void) => void): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, o => new Promise<HelperAsyncIterable<U>>(resolve => { cb(() => resolve(o)); return o }));\n}\n\nfunction multi<U extends PartialIterable>(this: U): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  type T = HelperAsyncIterable<U>;\n  const source = this;\n  let consumers = 0;\n  let current: DeferredPromise<IteratorResult<T, any>>;\n  let ai: AsyncIterator<T, any, undefined> | undefined = undefined;\n\n  // The source has produced a new result\n  function step(it?: IteratorResult<T, any>) {\n    if (it) current.resolve(it);\n    if (!it?.done) {\n      current = deferred<IteratorResult<T>>();\n      ai!.next()\n        .then(step)\n        .catch(error => current.reject({ done: true, value: error }));\n    }\n  }\n\n  const mai: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      consumers += 1;\n      return mai;\n    },\n\n    next() {\n      if (!ai) {\n        ai = source[Symbol.asyncIterator]!();\n        step();\n      }\n      return current//.then(zalgo => zalgo);\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source if we're the final one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: ex });\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source if we're the only one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: v });\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(mai);\n}\n\nexport function augmentGlobalAsyncGenerators() {\n  let g = (async function* () { })();\n  while (g) {\n    const desc = Object.getOwnPropertyDescriptor(g, Symbol.asyncIterator);\n    if (desc) {\n      iterableHelpers(g);\n      break;\n    }\n    g = Object.getPrototypeOf(g);\n  }\n  if (!g) {\n    console.warn(\"Failed to augment the prototype of `(async function*())()`\");\n  }\n}\n\n", "import { DEBUG, console, timeOutWarn } from './debug.js';\nimport { isPromiseLike } from './deferred.js';\nimport { iterableHelpers, merge, AsyncExtraIterable, queueIteratableIterator } from \"./iterators.js\";\n\n/*\n  `when(....)` is both an AsyncIterable of the events it can generate by observation,\n  and a function that can map those events to a specified type, eg:\n\n  this.when('keyup:#elemet') => AsyncIterable<KeyboardEvent>\n  this.when('#elemet')(e => e.target) => AsyncIterable<EventTarget>\n*/\n// Varargs type passed to \"when\"\nexport type WhenParameters<IDS extends string = string> = ReadonlyArray<\n  AsyncIterable<any>\n  | ValidWhenSelector<IDS>\n  | Element /* Implies \"change\" event */\n  | Promise<any> /* Just gets wrapped in a single `yield` */\n>;\n\n// The Iterated type generated by \"when\", based on the parameters\ntype WhenIteratedType<S extends WhenParameters> =\n  (Extract<S[number], AsyncIterable<any>> extends AsyncIterable<infer I> ? unknown extends I ? never : I : never)\n  | ExtractEvents<Extract<S[number], string>>\n  | (Extract<S[number], Element> extends never ? never : Event)\n\ntype MappableIterable<A extends AsyncIterable<any>> =\n  A extends AsyncIterable<infer T> ?\n    A & AsyncExtraIterable<T> &\n    (<R>(mapper: (value: A extends AsyncIterable<infer T> ? T : never) => R) => (AsyncExtraIterable<Awaited<R>>))\n  : never;\n\n// The extended iterator that supports async iterator mapping, chaining, etc\nexport type WhenReturn<S extends WhenParameters> =\n  MappableIterable<\n    AsyncExtraIterable<\n      WhenIteratedType<S>>>;\n\ntype EmptyObject = Record<string | symbol | number, never>;\n\ntype SpecialWhenEvents = {\n  \"@start\": EmptyObject,  // Always fires when referenced\n  \"@ready\": EmptyObject   // Fires when all Element specified sources are mounted in the DOM\n};\ntype WhenEvents = GlobalEventHandlersEventMap & SpecialWhenEvents;\ntype EventNameList<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : `${S},${EventNameList<R>}`\n  : never;\n\ntype EventNameUnion<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : S | EventNameList<R>\n  : never;\n\n\ntype EventAttribute = `${keyof GlobalEventHandlersEventMap}`\ntype CSSIdentifier<IDS extends string = string> = `#${IDS}` |`.${string}` | `[${string}]`\n\n/* ValidWhenSelectors are:\n    @start\n    @ready\n    event:selector\n    event           \"this\" element, event type='event'\n    selector        specificed selectors, implies \"change\" event\n*/\n\nexport type ValidWhenSelector<IDS extends string = string> = `${keyof SpecialWhenEvents}`\n  | `${EventAttribute}:${CSSIdentifier<IDS>}`\n  | EventAttribute\n  | CSSIdentifier<IDS>;\n\ntype IsValidWhenSelector<S>\n  = S extends ValidWhenSelector ? S : never;\n\ntype ExtractEventNames<S>\n  = S extends keyof SpecialWhenEvents ? S\n  : S extends `${infer V}:${infer L extends CSSIdentifier}`\n  ? EventNameUnion<V> extends never ? never : EventNameUnion<V>\n  : S extends `${infer L extends CSSIdentifier}`\n  ? 'change'\n  : never;\n\ntype ExtractEvents<S> = WhenEvents[ExtractEventNames<S>];\n\n/** when **/\ntype EventObservation<EventName extends keyof GlobalEventHandlersEventMap> = {\n  push: (ev: GlobalEventHandlersEventMap[EventName])=>void;\n  terminate: (ex: Error)=>void;\n  container: Element\n  selector: string | null\n};\nconst eventObservations = new WeakMap<Document, Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  if (!eventObservations.has(this))\n    eventObservations.set(this, new Map());\n\n  const observations = eventObservations.get(this)!.get(ev.type as keyof GlobalEventHandlersEventMap);\n  if (observations) {\n    for (const o of observations) {\n      try {\n        const { push, terminate, container, selector } = o;\n        if (!container.isConnected) {\n          const msg = \"Container `#\" + container.id + \">\" + (selector || '') + \"` removed from DOM. Removing subscription\";\n          observations.delete(o);\n          terminate(new Error(msg));\n        } else {\n          if (ev.target instanceof Node) {\n            if (selector) {\n              const nodes = container.querySelectorAll(selector);\n              for (const n of nodes) {\n                if ((ev.target === n || n.contains(ev.target)) && container.contains(n))\n                  push(ev)\n              }\n            } else {\n              if ((ev.target === container || container.contains(ev.target)))\n                push(ev)\n            }\n          }\n        }\n      } catch (ex) {\n        console.warn('docEventHandler', ex);\n      }\n    }\n  }\n}\n\nfunction isCSSSelector(s: string): s is CSSIdentifier {\n  return Boolean(s && (s.startsWith('#') || s.startsWith('.') || (s.startsWith('[') && s.endsWith(']'))));\n}\n\nfunction parseWhenSelector<EventName extends string>(what: IsValidWhenSelector<EventName>): undefined | [CSSIdentifier | null, keyof GlobalEventHandlersEventMap] {\n  const parts = what.split(':');\n  if (parts.length === 1) {\n    if (isCSSSelector(parts[0]))\n      return [parts[0],\"change\"];\n    return [null, parts[0] as keyof GlobalEventHandlersEventMap];\n  }\n  if (parts.length === 2) {\n    if (isCSSSelector(parts[1]) && !isCSSSelector(parts[0]))\n    return [parts[1], parts[0] as keyof GlobalEventHandlersEventMap]\n  }\n  return undefined;\n}\n\nfunction doThrow(message: string):never {\n  throw new Error(message);\n}\n\nfunction whenEvent<EventName extends string>(container: Element, what: IsValidWhenSelector<EventName>) {\n  const [selector, eventName] = parseWhenSelector(what) ?? doThrow(\"Invalid WhenSelector: \"+what);\n\n  if (!eventObservations.has(container.ownerDocument))\n    eventObservations.set(container.ownerDocument, new Map());\n\n  if (!eventObservations.get(container.ownerDocument)!.has(eventName)) {\n    container.ownerDocument.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.get(container.ownerDocument)!.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.get(container.ownerDocument)?.get(eventName)?.delete(details));\n\n  const details: EventObservation<keyof GlobalEventHandlersEventMap> /*EventObservation<Exclude<ExtractEventNames<EventName>, keyof SpecialWhenEvents>>*/ = {\n    push: queue.push,\n    terminate(ex: Error) { queue.return?.(ex)},\n    container,\n    selector: selector || null\n  };\n\n  containerAndSelectorsMounted(container, selector ? [selector] : undefined)\n    .then(_ => eventObservations.get(container.ownerDocument)?.get(eventName)!.add(details));\n\n  return queue.multi() ;\n}\n\nasync function* neverGonnaHappen<Z>(): AsyncIterableIterator<Z> {\n  await new Promise(() => {});\n  yield undefined as Z; // Never should be executed\n}\n\n/* Syntactic sugar: chainAsync decorates the specified iterator so it can be mapped by\n  a following function, or used directly as an iterable */\nfunction chainAsync<A extends AsyncExtraIterable<X>, X>(src: A): MappableIterable<A> {\n  function mappableAsyncIterable(mapper: Parameters<typeof src.map>[0]) {\n    return src.map(mapper);\n  }\n\n  return Object.assign(iterableHelpers(mappableAsyncIterable as unknown as AsyncIterable<A>), {\n    [Symbol.asyncIterator]: () => src[Symbol.asyncIterator]()\n  }) as MappableIterable<A>;\n}\n\nfunction isValidWhenSelector(what: WhenParameters[number]): what is ValidWhenSelector {\n  if (!what)\n    throw new Error('Falsy async source will never be ready\\n\\n' + JSON.stringify(what));\n  return typeof what === 'string' && what[0] !== '@' && Boolean(parseWhenSelector(what));\n}\n\nasync function* once<T>(p: Promise<T>) {\n  yield p;\n}\n\nexport function when<S extends WhenParameters>(container: Element, ...sources: S): WhenReturn<S> {\n  if (!sources || sources.length === 0) {\n    return chainAsync(whenEvent(container, \"change\")) as unknown as WhenReturn<S>;\n  }\n\n  const iterators = sources.filter(what => typeof what !== 'string' || what[0] !== '@').map(what => typeof what === 'string'\n    ? whenEvent(container, what)\n    : what instanceof Element\n      ? whenEvent(what, \"change\")\n      : isPromiseLike(what)\n        ? once(what)\n        : what);\n\n  if (sources.includes('@start')) {\n    const start: AsyncIterableIterator<{}> = {\n      [Symbol.asyncIterator]: () => start,\n      next() {\n        start.next = () => Promise.resolve({ done: true, value: undefined })\n        return Promise.resolve({ done: false, value: {} })\n      }\n    };\n    iterators.push(start);\n  }\n\n  if (sources.includes('@ready')) {\n    const watchSelectors = sources.filter(isValidWhenSelector).map(what => parseWhenSelector(what)?.[0]);\n\n    function isMissing(sel: CSSIdentifier | null | undefined): sel is CSSIdentifier {\n      return Boolean(typeof sel === 'string' && !container.querySelector(sel));\n    }\n\n    const missing = watchSelectors.filter(isMissing);\n\n    let events: AsyncIterator<any, any, undefined> | undefined = undefined;\n    const ai: AsyncIterableIterator<any> = {\n      [Symbol.asyncIterator]() { return ai },\n      throw(ex: any) {\n        if (events?.throw) return events.throw(ex);\n        return Promise.resolve({ done: true, value: ex });\n      },\n      return(v?: any) {\n        if (events?.return) return events.return(v);\n        return Promise.resolve({ done: true, value: v });\n      },\n      next() {\n        if (events) return events.next();\n\n        return containerAndSelectorsMounted(container, missing).then(() => {\n          const merged = (iterators.length > 1)\n          ? merge(...iterators)\n          : iterators.length === 1\n            ? iterators[0]\n            : (neverGonnaHappen<WhenIteratedType<S>>());\n\n          // Now everything is ready, we simply delegate all async ops to the underlying\n          // merged asyncIterator \"events\"\n          events = merged[Symbol.asyncIterator]();\n          if (!events)\n            return { done: true, value: undefined };\n\n          return { done: false, value: {} };\n        });\n      }\n    };\n    return chainAsync(iterableHelpers(ai));\n  }\n\n  const merged = (iterators.length > 1)\n    ? merge(...iterators)\n    : iterators.length === 1\n      ? iterators[0]\n      : (neverGonnaHappen<WhenIteratedType<S>>());\n\n  return chainAsync(iterableHelpers(merged));\n}\n\nfunction elementIsInDOM(elt: Element): Promise<void> {\n  if (elt.isConnected)\n    return Promise.resolve();\n\n  return new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (elt.isConnected) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(elt.ownerDocument.body, {\n    subtree: true,\n    childList: true\n  }));\n}\n\nfunction containerAndSelectorsMounted(container: Element, selectors?: string[]) {\n  if (selectors?.length)\n    return Promise.all([\n      allSelectorsPresent(container, selectors),\n      elementIsInDOM(container)\n    ]);\n  return elementIsInDOM(container);\n}\n\nfunction allSelectorsPresent(container: Element, missing: string[]): Promise<void> {\n  missing = missing.filter(sel => !container.querySelector(sel))\n  if (!missing.length) {\n    return Promise.resolve(); // Nothing is missing\n  }\n\n  const promise = new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (missing.every(sel => container.querySelector(sel))) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(container, {\n    subtree: true,\n    childList: true\n  }));\n\n  /* debugging help: warn if waiting a long time for a selectors to be ready */\n  if (DEBUG) {\n    const stack = new Error().stack?.replace(/^Error/, \"Missing selectors after 5 seconds:\");\n    const warnTimer = setTimeout(() => {\n      console.warn(stack, missing);\n    }, timeOutWarn);\n\n    promise.finally(() => clearTimeout(warnTimer))\n  }\n\n  return promise;\n}\n", "import { isPromiseLike } from './deferred.js';\nimport { Ignore, asyncIterator, defineIterableProperty, isAsyncIter, isAsyncIterator } from './iterators.js';\nimport { WhenParameters, WhenReturn, when } from './when.js';\nimport { DEBUG, console, timeOutWarn } from './debug.js';\nimport type { ChildTags, Constructed, Instance, Overrides, TagCreationOptions, TagCreator, TagCreatorFunction } from './tags.js';\n\n/* Export useful stuff for users of the bundled code */\nexport { when } from './when.js';\nexport type { ChildTags, Instance, TagCreator, TagCreatorFunction } from './tags.js'\nexport * as Iterators from './iterators.js';\n\nexport const UniqueID = Symbol(\"Unique ID\");\n\nconst logNode = DEBUG ? ((n: Node) => `\"${'innerHTML' in n ? n.innerHTML : n.textContent}\"`) : (n: Node) => undefined;\n\n/* A holder for commonProperties specified when `tag(...p)` is invoked, which are always\n  applied (mixed in) when an element is created */\ntype TagFunctionOptions<OtherMembers extends Record<string | symbol, any> = {}> = {\n  commonProperties?: OtherMembers\n  document?: Document\n  /** @deprecated - legacy support */\n  enableOnRemovedFromDOM?: boolean\n}\n\n/* Members applied to EVERY tag created, even base tags */\ninterface PoElementMethods {\n  get ids(): {}\n  when<T extends Element & PoElementMethods, S extends WhenParameters<Exclude<keyof T['ids'], number | symbol>>>(this: T, ...what: S): WhenReturn<S>;\n  // This is a very incomplete type. In practice, set(attrs) requires a deeply partial set of\n  // attributes, in exactly the same way as a TagFunction's first object parameter\n  set attributes(attrs: object);\n  get attributes(): NamedNodeMap\n}\n\n// Support for https://www.npmjs.com/package/htm (or import htm from 'https://cdn.jsdelivr.net/npm/htm/dist/htm.module.js')\n// Note: same signature as React.createElement\nexport interface CreateElement {\n  // Support for htm, JSX, etc\n  createElement(\n    // \"name\" can a HTML tag string, an existing node (just returns itself), or a tag function\n    name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n    // The attributes used to initialise the node (if a string or function - ignore if it's already a node)\n    attrs: any,\n    // The children\n    ...children: ChildTags[]): Node;\n}\n\n/* The interface that creates a set of TagCreators for the specified DOM tags */\nexport interface TagLoader {\n  nodes(...c: ChildTags[]): (Node | (/*P &*/ (Element & PoElementMethods)))[];\n  UniqueID: typeof UniqueID\n\n  /*\n   Signatures for the tag loader. All params are optional in any combination,\n   but must be in order:\n      tag(\n          ?nameSpace?: string,  // absent nameSpace implies HTML\n          ?tags?: string[],     // absent tags defaults to all common HTML tags\n          ?commonProperties?: CommonPropertiesConstraint // absent implies none are defined\n      )\n\n      eg:\n        tags()  // returns TagCreators for all HTML tags\n        tags(['div','button'], { myThing() {} })\n        tags('http://namespace',['Foreign'], { isForeign: true })\n  */\n\n  <Tags extends keyof HTMLElementTagNameMap>(): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap>(tags: Tags[]): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(tags: Tags[], options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: null | undefined | '', tags: Tags[], options?: TagFunctionOptions<Q>): { [k in Tags]: TagCreator<Q & PoElementMethods & HTMLElement> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: string, tags: Tags[], options?: TagFunctionOptions<Q>): Record<string, TagCreator<Q & PoElementMethods & Element>> & CreateElement\n}\n\nlet idCount = 0;\nconst standandTags = [\n  \"a\", \"abbr\", \"address\", \"area\", \"article\", \"aside\", \"audio\", \"b\", \"base\", \"bdi\", \"bdo\", \"blockquote\", \"body\", \"br\", \"button\",\n  \"canvas\", \"caption\", \"cite\", \"code\", \"col\", \"colgroup\", \"data\", \"datalist\", \"dd\", \"del\", \"details\", \"dfn\", \"dialog\", \"div\",\n  \"dl\", \"dt\", \"em\", \"embed\", \"fieldset\", \"figcaption\", \"figure\", \"footer\", \"form\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\",\n  \"header\", \"hgroup\", \"hr\", \"html\", \"i\", \"iframe\", \"img\", \"input\", \"ins\", \"kbd\", \"label\", \"legend\", \"li\", \"link\", \"main\", \"map\",\n  \"mark\", \"menu\", \"meta\", \"meter\", \"nav\", \"noscript\", \"object\", \"ol\", \"optgroup\", \"option\", \"output\", \"p\", \"picture\", \"pre\",\n  \"progress\", \"q\", \"rp\", \"rt\", \"ruby\", \"s\", \"samp\", \"script\", \"search\", \"section\", \"select\", \"slot\", \"small\", \"source\", \"span\",\n  \"strong\", \"style\", \"sub\", \"summary\", \"sup\", \"table\", \"tbody\", \"td\", \"template\", \"textarea\", \"tfoot\", \"th\", \"thead\", \"time\",\n  \"title\", \"tr\", \"track\", \"u\", \"ul\", \"var\", \"video\", \"wbr\"\n] as const;\n\nfunction idsInaccessible(): never {\n  throw new Error(\"<elt>.ids is a read-only map of Elements\")\n}\n\nfunction isChildTag(x: any): x is ChildTags {\n  return typeof x === 'string'\n    || typeof x === 'number'\n    || typeof x === 'boolean'\n    || x instanceof Node\n    || x instanceof NodeList\n    || x instanceof HTMLCollection\n    || x === null\n    || x === undefined\n    // Can't actually test for the contained type, so we assume it's a ChildTag and let it fail at runtime\n    || Array.isArray(x)\n    || isPromiseLike(x)\n    || isAsyncIter(x)\n    || (typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function');\n}\n\n/* tag */\nconst callStackSymbol = Symbol('callStack');\n\nexport const tag = <TagLoader>function <Tags extends string,\n  T1 extends (string | Tags[] | TagFunctionOptions<Q>),\n  T2 extends (Tags[] | TagFunctionOptions<Q>),\n  Q extends {}\n>(\n  _1: T1,\n  _2: T2,\n  _3?: TagFunctionOptions<Q>\n): Record<string, TagCreator<Q & Element>> {\n  type NamespacedElementBase = T1 extends string ? T1 extends '' ? HTMLElement : Element : HTMLElement;\n\n  /* Work out which parameter is which. There are 6 variations:\n    tag()                                           []\n    tag(commonProperties)                           [object]\n    tag(tags[])                                     [string[]]\n    tag(tags[], commonProperties)                   [string[], object]\n    tag(namespace | null, tags[])                   [string | null, string[]]\n    tag(namespace | null, tags[], commonProperties) [string | null, string[], object]\n  */\n  const [nameSpace, tags, options] = (typeof _1 === 'string') || _1 === null\n    ? [_1, _2 as Tags[], _3 as TagFunctionOptions<Q>]\n    : Array.isArray(_1)\n      ? [null, _1 as Tags[], _2 as TagFunctionOptions<Q>]\n      : [null, standandTags, _1 as TagFunctionOptions<Q>];\n\n  const commonProperties = options?.commonProperties;\n  const thisDoc = options?.document ?? globalThis.document;\n\n  const removedNodes = mutationTracker(thisDoc, 'removedNodes', options?.enableOnRemovedFromDOM);\n\n  function DomPromiseContainer() {\n    return thisDoc.createComment(DEBUG\n      ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\"\n      : \"promise\")\n  }\n\n  function DyamicElementError({ error }: { error: Error | IteratorResult<Error> }) {\n    return thisDoc.createComment(error instanceof Error ? error.toString() : 'Error:\\n' + JSON.stringify(error, null, 2));\n  }\n  const poStyleElt = thisDoc.createElement(\"STYLE\");\n  poStyleElt.id = \"--ai-ui-extended-tag-styles-\";\n\n  /* Properties applied to every tag which can be implemented by reference, similar to prototypes */\n  const warned = new Set<string>();\n  const tagPrototypes: PoElementMethods = Object.create(\n    null,\n    {\n      when: {\n        writable: false,\n        configurable: true,\n        enumerable: false,\n        value: function (...what: WhenParameters) {\n          return when(this, ...what)\n        }\n      },\n      attributes: {\n        ...Object.getOwnPropertyDescriptor(Element.prototype, 'attributes'),\n        set(this: Element, a: object) {\n          if (isAsyncIter(a)) {\n            const ai = isAsyncIterator(a) ? a : a[Symbol.asyncIterator]();\n            const step = () => ai.next().then(\n              ({ done, value }) => { assignProps(this, value); done || step() },\n              ex => console.warn(ex));\n            step();\n          }\n          else assignProps(this, a);\n        }\n      },\n      ids: {\n        // .ids is a getter that when invoked for the first time\n        // lazily creates a Proxy that provides live access to children by id\n        configurable: true,\n        enumerable: true,\n        set: idsInaccessible,\n        get(this: Element) {\n          // Now we've been accessed, create the proxy\n          const idProxy = new Proxy(Object.create(null), {\n            apply: idsInaccessible,\n            construct: idsInaccessible,\n            defineProperty: idsInaccessible,\n            deleteProperty: idsInaccessible,\n            set: idsInaccessible,\n            setPrototypeOf: idsInaccessible,\n            getPrototypeOf() { return null },\n            isExtensible() { return false },\n            preventExtensions() { return true },\n            getOwnPropertyDescriptor(target, p) {\n              if (this.get!(target, p, null))\n                return Reflect.getOwnPropertyDescriptor(target, p);\n            },\n            has(target, p) {\n              const r = this.get!(target, p, null);\n              return Boolean(r);\n            },\n            ownKeys: (target) => {\n              const ids = [...this.querySelectorAll(`[id]`)].map(e => e.id);\n              const unique = [...new Set(ids)];\n              if (DEBUG && ids.length !== unique.length)\n                console.log(`Element contains multiple, shadowed decendant ids`, unique);\n              return unique;\n            },\n            get: (target, p, receiver) => {\n              if (typeof p === 'string') {\n                if (p in target) {\n                  if (this.contains(target[p]))\n                    return target[p];\n                  delete target[p];\n                }\n                let e: Element | undefined;\n                if (DEBUG) {\n                  const nl = this.querySelectorAll('#' + CSS.escape(p));\n                  if (nl.length > 1) {\n                    if (!warned.has(p)) {\n                      warned.add(p);\n                      console.log(`Element contains multiple, shadowed decendants with ID \"${p}\"`/*,`\\n\\t${logNode(this)}`*/);\n                    }\n                  }\n                  e = nl[0];\n                } else {\n                  e = this.querySelector('#' + CSS.escape(p)) ?? undefined;\n                }\n                if (e) target[p] = e;\n                return e;\n              }\n            }\n          });\n          // ..and replace the getter with the Proxy\n          Object.defineProperty(this, 'ids', {\n            configurable: true,\n            enumerable: true,\n            set: idsInaccessible,\n            get() { return idProxy }\n          });\n          // ...and return that from the getter, so subsequent property\n          // accesses go via the Proxy\n          return idProxy;\n        }\n      }\n    }\n  );\n\n  /* Add any user supplied prototypes */\n  if (commonProperties)\n    deepDefine(tagPrototypes, commonProperties);\n\n  function nodes(...c: ChildTags[]) {\n    const appended: Node[] = [];\n    (function children(c: ChildTags): void {\n      if (c === undefined || c === null || c === Ignore)\n        return;\n      if (isPromiseLike(c)) {\n        const g: ChildNode = DomPromiseContainer();\n        appended.push(g);\n        c.then(r => g.replaceWith(...nodes(r)),\n          (x: any) => {\n            console.warn(x, logNode(g));\n            g.replaceWith(DyamicElementError({ error: x }));\n          }\n        );\n        return;\n      }\n      if (c instanceof Node) {\n        appended.push(c);\n        return;\n      }\n\n      // We have an interesting case here where an iterable String is an object with both Symbol.iterator\n      // (inherited from the String prototype) and Symbol.asyncIterator (as it's been augmented by boxed())\n      // but we're only interested in cases like HTMLCollection, NodeList, array, etc., not the fukny ones\n      // It used to be after the isAsyncIter() test, but a non-AsyncIterator *may* also be a sync iterable\n      // For now, we exclude (Symbol.asyncIterator in c) in this case.\n      if (c && typeof c === 'object' && Symbol.iterator in c && !(Symbol.asyncIterator in c) && c[Symbol.iterator]) {\n        for (const d of c) children(d);\n        return;\n      }\n\n      if (isAsyncIter<ChildTags>(c)) {\n        const insertionStack = DEBUG ? ('\\n' + new Error().stack?.replace(/^Error: /, \"Insertion :\")) : '';\n        const ap = isAsyncIterator(c) ? c : c[Symbol.asyncIterator]();\n        // It's possible that this async iterator is a boxed object that also holds a value\n        const unboxed = c.valueOf();\n        const dpm = (unboxed === undefined || unboxed === c) ? [DomPromiseContainer()] : nodes(unboxed as ChildTags)\n\n        let t = dpm.length ? dpm : [DomPromiseContainer()];\n        appended.push(...t);\n        let notYetMounted = true;\n        // DEBUG support\n        let createdAt = Date.now() + timeOutWarn;\n        const createdBy = DEBUG && new Error(\"Created by\").stack;\n\n        const error = (errorValue: any) => {\n          const n = t.filter(n => Boolean(n?.parentNode)) as ChildNode[];\n          if (n.length) {\n            t = [DyamicElementError({ error: errorValue })];\n            n[0].replaceWith(...t);\n            n.slice(1).forEach(e => e?.parentNode!.removeChild(e));\n          }\n          else console.warn(\"Can't report error\", errorValue, createdBy, t.map(logNode));\n          t = [];\n          ap.return?.(errorValue);\n        }\n\n        const update = (es: IteratorResult<ChildTags>) => {\n          if (!es.done) {\n            try {\n              // ChildNode[], since we tested .parentNode\n              const mounted = t.filter(e => e?.parentNode && e.isConnected);\n              const n = notYetMounted ? t : mounted;\n              if (mounted.length) notYetMounted = false;\n\n              if (!n.length || t.every(e => removedNodes(e))) {\n                // We're done - terminate the source quietly (ie this is not an exception as it's expected, but we're done)\n                t = [];\n                const msg = \"Element(s) have been removed from the document: \" + insertionStack;\n                ap.return?.(new Error(msg));\n                return;\n              }\n\n              if (DEBUG && notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Async element not mounted after 5 seconds. If it is never mounted, it will leak.`, createdBy, t.map(logNode));\n              }\n              t = nodes(unbox(es.value) as ChildTags);\n              // If the iterated expression yields no nodes, stuff in a DomPromiseContainer for the next iteration\n              if (!t.length) t.push(DomPromiseContainer());\n              (n[0] as ChildNode).replaceWith(...t);\n              n.slice(1).forEach(e => !t.includes(e) && e.parentNode?.removeChild(e));\n              ap.next().then(update).catch(error);\n            } catch (ex) {\n              // Something went wrong. Terminate the iterator source\n              t = [];\n              ap.return?.(ex);\n            }\n          }\n        }\n        ap.next().then(update).catch(error);\n        return;\n      }\n      appended.push(thisDoc.createTextNode(c.toString()));\n    })(c);\n    return appended;\n  }\n\n  if (!nameSpace) {\n    Object.assign(tag, {\n      nodes,    // Build DOM Node[] from ChildTags\n      UniqueID\n    });\n  }\n\n  /** Just deep copy an object */\n  const plainObjectPrototype = Object.getPrototypeOf({});\n  /** Routine to *define* properties on a dest object from a src object **/\n  function deepDefine(d: Record<string | symbol | number, any>, s: any, declaration?: true): void {\n    if (s === null || s === undefined || typeof s !== 'object' || s === d)\n      return;\n\n    for (const [k, srcDesc] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      try {\n        if ('value' in srcDesc) {\n          const value = srcDesc.value;\n\n          if (value && isAsyncIter<unknown>(value)) {\n            Object.defineProperty(d, k, srcDesc);\n          } else {\n            // This has a real value, which might be an object, so we'll deepDefine it unless it's a\n            // Promise or a function, in which case we just assign it\n            if (value && typeof value === 'object' && !isPromiseLike(value)) {\n              if (!(k in d)) {\n                // If this is a new value in the destination, just define it to be the same value as the source\n                // If the source value is an object, and we're declaring it (therefore it should be a new one), take\n                // a copy so as to not re-use the reference and pollute the declaration. Note: this is probably\n                // a better default for any \"objects\" in a declaration that are plain and not some class type\n                // which can't be copied\n                if (declaration) {\n                  if (Object.getPrototypeOf(value) === plainObjectPrototype || !Object.getPrototypeOf(value)) {\n                    // A plain object can be deep-copied by field\n                    deepDefine(srcDesc.value = {}, value);\n                  } else if (Array.isArray(value)) {\n                    // An array can be deep copied by index\n                    deepDefine(srcDesc.value = [], value);\n                  } else {\n                    // Other object like things (regexps, dates, classes, etc) can't be deep-copied reliably\n                    console.warn(`Declared propety '${k}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`, d, value);\n                  }\n                }\n                Object.defineProperty(d, k, srcDesc);\n              } else {\n                if (value instanceof Node) {\n                  console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child\", k, logNode(value));\n                  d[k] = value;\n                } else {\n                  if (d[k] !== value) {\n                    // Note - if we're copying to an array of different length\n                    // we're decoupling common object references, so we need a clean object to\n                    // assign into\n                    if (Array.isArray(d[k]) && d[k].length !== value.length) {\n                      if (value.constructor === Object || value.constructor === Array) {\n                        deepDefine(d[k] = new (value.constructor), value);\n                      } else {\n                        // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                        d[k] = value;\n                      }\n                    } else {\n                      // This is just a regular object, so we deepDefine recursively\n                      deepDefine(d[k], value);\n                    }\n                  }\n                }\n              }\n            } else {\n              // This is just a primitive value, or a Promise\n              if (s[k] !== undefined)\n                d[k] = s[k];\n            }\n          }\n        } else {\n          // Copy the definition of the getter/setter\n          Object.defineProperty(d, k, srcDesc);\n        }\n      } catch (ex: unknown) {\n        console.warn(\"deepAssign\", k, s[k], ex);\n        throw ex;\n      }\n    }\n  }\n\n  function unbox(a: unknown): unknown {\n    const v = a?.valueOf();\n    return Array.isArray(v) ? Array.prototype.map.call(v, unbox) : v;\n  }\n\n  function assignProps(base: Node, props: Record<string, any>) {\n    // Copy prop hierarchy onto the element via the asssignment operator in order to run setters\n    if (!(callStackSymbol in props)) {\n      (function assign(d: any, s: any): void {\n        if (s === null || s === undefined || typeof s !== 'object')\n          return;\n        // static props before getters/setters\n        const sourceEntries = Object.entries(Object.getOwnPropertyDescriptors(s));\n        if (!Array.isArray(s)) {\n          sourceEntries.sort(a => {\n            const desc = Object.getOwnPropertyDescriptor(d, a[0]);\n            if (desc) {\n              if ('value' in desc) return -1;\n              if ('set' in desc) return 1;\n              if ('get' in desc) return 1;\n            }\n            return 0;\n          });\n        }\n        for (const [k, srcDesc] of sourceEntries) {\n          try {\n            if ('value' in srcDesc) {\n              const value = srcDesc.value;\n              if (isAsyncIter<unknown>(value)) {\n                assignIterable(value, k);\n              } else if (isPromiseLike(value)) {\n                value.then(v => {\n                  if (v && typeof v === 'object') {\n                    // Special case: this promise resolved to an async iterator\n                    if (isAsyncIter<unknown>(v)) {\n                      assignIterable(v, k);\n                    } else {\n                      assignObject(v, k);\n                    }\n                  } else {\n                    if (s[k] !== undefined)\n                      d[k] = v;\n                  }\n                }, error => console.log(\"Failed to set attribute\", error));\n              } else if (!isAsyncIter<unknown>(value)) {\n                // This has a real value, which might be an object\n                if (value && typeof value === 'object' && !isPromiseLike(value))\n                  assignObject(value, k);\n                else {\n                  if (s[k] !== undefined)\n                    d[k] = s[k];\n                }\n              }\n            } else {\n              // Copy the definition of the getter/setter\n              Object.defineProperty(d, k, srcDesc);\n            }\n          } catch (ex: unknown) {\n            console.warn(\"assignProps\", k, s[k], ex);\n            throw ex;\n          }\n        }\n\n        function assignIterable(value: AsyncIterable<unknown> | AsyncIterator<unknown, any, undefined>, k: string) {\n          const ap = asyncIterator(value);\n          let notYetMounted = true;\n          // DEBUG support\n          let createdAt = Date.now() + timeOutWarn;\n          const createdBy = DEBUG && new Error(\"Created by\").stack;\n          const update = (es: IteratorResult<unknown>) => {\n            if (!es.done) {\n              const value = unbox(es.value);\n              if (typeof value === 'object' && value !== null) {\n                /*\n              THIS IS JUST A HACK: `style` has to be set member by member, eg:\n                e.style.color = 'blue'        --- works\n                e.style = { color: 'blue' }   --- doesn't work\n              whereas in general when assigning to property we let the receiver\n              do any work necessary to parse the object. This might be better handled\n              by having a setter for `style` in the PoElementMethods that is sensitive\n              to the type (string|object) being passed so we can just do a straight\n              assignment all the time, or making the decsion based on the location of the\n              property in the prototype chain and assuming anything below \"PO\" must be\n              a primitive\n              */\n                const destDesc = Object.getOwnPropertyDescriptor(d, k);\n                if (k === 'style' || !destDesc?.set)\n                  assign(d[k], value);\n                else\n                  d[k] = value;\n              } else {\n                // Src is not an object (or is null) - just assign it, unless it's undefined\n                if (value !== undefined)\n                  d[k] = value;\n              }\n              const mounted = base.isConnected;\n              // If we have been mounted before, bit aren't now, remove the consumer\n              if (removedNodes(base) || (!notYetMounted && !mounted)) {\n                console.info(`Element does not exist in document when setting async attribute '${k}' to:\\n${logNode(base)}`);\n                ap.return?.();\n                return;\n              }\n              if (mounted) notYetMounted = false;\n              if (notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Element with async attribute '${k}' not mounted after 5 seconds. If it is never mounted, it will leak.\\nElement contains: ${logNode(base)}\\n${createdBy}`);\n              }\n\n              ap.next().then(update).catch(error);\n            }\n          }\n          const error = (errorValue: any) => {\n            console.warn(\"Dynamic attribute error\", errorValue, k, d, createdBy, logNode(base));\n            ap.return?.(errorValue);\n            base.appendChild(DyamicElementError({ error: errorValue }));\n          }\n          const unboxed = value.valueOf();\n          if (unboxed !== undefined && unboxed !== value && !isAsyncIter(unboxed))\n            update({ done: false, value: unboxed });\n          else\n            ap.next().then(update).catch(error);\n        }\n\n        function assignObject(value: any, k: string) {\n          if (value instanceof Node) {\n            console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes\", k, logNode(value));\n            d[k] = value;\n          } else {\n            // Note - if we're copying to ourself (or an array of different length),\n            // we're decoupling common object references, so we need a clean object to\n            // assign into\n            if (!(k in d) || d[k] === value || (Array.isArray(d[k]) && d[k].length !== value.length)) {\n              if (value.constructor === Object || value.constructor === Array) {\n                const copy = new (value.constructor);\n                assign(copy, value);\n                d[k] = copy;\n                //assign(d[k], value);\n              } else {\n                // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                d[k] = value;\n              }\n            } else {\n              if (Object.getOwnPropertyDescriptor(d, k)?.set)\n                d[k] = value;\n\n              else\n                assign(d[k], value);\n            }\n          }\n        }\n      })(base, props);\n    }\n  }\n\n  /*\n  Extend a component class with create a new component class factory:\n      const NewDiv = Div.extended({ overrides })\n          ...or...\n      const NewDic = Div.extended((instance:{ arbitrary-type }) => ({ overrides }))\n         ...later...\n      const eltNewDiv = NewDiv({attrs},...children)\n  */\n\n  type ExtendTagFunction = (attrs: TagCreationOptions & {\n    [callStackSymbol]?: Overrides[];\n    [k: string]: unknown;\n  } | ChildTags, ...children: ChildTags[]) => Element\n\n  interface ExtendTagFunctionInstance extends ExtendTagFunction {\n    super: TagCreator<Element>;\n    definition: Overrides;\n    valueOf: () => string;\n    extended: (this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) => ExtendTagFunctionInstance;\n  }\n\n  function tagHasInstance(this: ExtendTagFunctionInstance, e: any) {\n    for (let c = e.constructor; c; c = c.super) {\n      if (c === this)\n        return true;\n    }\n    return false;\n  }\n\n  function extended(this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) {\n    const instanceDefinition = (typeof _overrides !== 'function')\n      ? (instance: Instance) => Object.assign({}, _overrides, instance)\n      : _overrides\n\n    const uniqueTagID = Date.now().toString(36) + (idCount++).toString(36) + Math.random().toString(36).slice(2);\n    let staticExtensions: Overrides = instanceDefinition({ [UniqueID]: uniqueTagID });\n    /* \"Statically\" create any styles required by this widget */\n    if (staticExtensions.styles) {\n      poStyleElt.appendChild(thisDoc.createTextNode(staticExtensions.styles + '\\n'));\n      if (!thisDoc.head.contains(poStyleElt)) {\n        thisDoc.head.appendChild(poStyleElt);\n      }\n    }\n\n    // \"this\" is the tag we're being extended from, as it's always called as: `(this).extended`\n    // Here's where we actually create the tag, by accumulating all the base attributes and\n    // (finally) assigning those specified by the instantiation\n    const extendTagFn: ExtendTagFunction = (attrs, ...children) => {\n      const noAttrs = isChildTag(attrs);\n      const newCallStack: (Constructed & Overrides)[] = [];\n      const combinedAttrs = { [callStackSymbol]: (noAttrs ? newCallStack : attrs[callStackSymbol]) ?? newCallStack }\n      const e = noAttrs ? this(combinedAttrs, attrs, ...children) : this(combinedAttrs, ...children);\n      e.constructor = extendTag;\n      const tagDefinition = instanceDefinition({ [UniqueID]: uniqueTagID });\n      combinedAttrs[callStackSymbol].push(tagDefinition);\n      if (DEBUG) {\n        // Validate declare and override\n        function isAncestral(creator: TagCreator<Element>, d: string) {\n          for (let f = creator; f; f = f.super)\n            if (f.definition?.declare && d in f.definition.declare) return true;\n          return false;\n        }\n        if (tagDefinition.declare) {\n          const clash = Object.keys(tagDefinition.declare).filter(d => (d in e) || isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Declared keys '${clash}' in ${extendTag.name} already exist in base '${this.valueOf()}'`);\n          }\n        }\n        if (tagDefinition.override) {\n          const clash = Object.keys(tagDefinition.override).filter(d => !(d in e) && !(commonProperties && d in commonProperties) && !isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Overridden keys '${clash}' in ${extendTag.name} do not exist in base '${this.valueOf()}'`);\n          }\n        }\n      }\n      deepDefine(e, tagDefinition.declare, true);\n      deepDefine(e, tagDefinition.override);\n      const reAssign = new Set<string>();\n      tagDefinition.iterable && Object.keys(tagDefinition.iterable).forEach(k => {\n        if (k in e) {\n          console.log(`Ignoring attempt to re-define iterable property \"${k}\" as it could already have consumers`);\n          reAssign.add(k);\n        } else {\n          defineIterableProperty(e, k, tagDefinition.iterable![k as keyof typeof tagDefinition.iterable])\n        }\n      });\n      if (combinedAttrs[callStackSymbol] === newCallStack) {\n        if (!noAttrs)\n          assignProps(e, attrs);\n        for (const base of newCallStack) {\n          const children = base?.constructed?.call(e);\n          if (isChildTag(children)) // technically not necessary, since \"void\" is going to be undefined in 99.9% of cases.\n            e.append(...nodes(children));\n        }\n        // Once the full tree of augmented DOM elements has been constructed, fire all the iterable propeerties\n        // so the full hierarchy gets to consume the initial state, unless they have been assigned\n        // by assignProps from a future\n        const combinedInitialIterableValues = {};\n        let hasInitialValues = false;\n        for (const base of newCallStack) {\n          if (base.iterable) for (const k of Object.keys(base.iterable)) {\n            // We don't self-assign iterables that have themselves been assigned with futures\n            const attrExists = !noAttrs && k in attrs;\n            if ((reAssign.has(k) && attrExists) || !(attrExists && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e]?.valueOf();\n              if (value !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                combinedInitialIterableValues[k] = value;\n                hasInitialValues = true;\n              }\n            }\n          }\n        }\n        if (hasInitialValues)\n          Object.assign(e, combinedInitialIterableValues);\n      }\n      return e;\n    }\n\n    const extendTag: ExtendTagFunctionInstance = Object.assign(extendTagFn, {\n      super: this,\n      definition: Object.assign(staticExtensions, { [UniqueID]: uniqueTagID }),\n      extended,\n      valueOf: () => {\n        const keys = [...Object.keys(staticExtensions.declare || {}), ...Object.keys(staticExtensions.iterable || {})];\n        return `${extendTag.name}: {${keys.join(', ')}}\\n \\u21AA ${this.valueOf()}`\n      }\n    });\n    Object.defineProperty(extendTag, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    const fullProto = {};\n    (function walkProto(creator: TagCreator<Element>) {\n      if (creator?.super)\n        walkProto(creator.super);\n\n      const proto = creator.definition;\n      if (proto) {\n        deepDefine(fullProto, proto?.override);\n        deepDefine(fullProto, proto?.declare);\n      }\n    })(this);\n    deepDefine(fullProto, staticExtensions.override);\n    deepDefine(fullProto, staticExtensions.declare);\n    Object.defineProperties(extendTag, Object.getOwnPropertyDescriptors(fullProto));\n\n    // Attempt to make up a meaningfu;l name for this extended tag\n    const creatorName = fullProto\n      && 'className' in fullProto\n      && typeof fullProto.className === 'string'\n      ? fullProto.className\n      : uniqueTagID;\n    const callSite = DEBUG ? (new Error().stack?.split('\\n')[2] ?? '') : '';\n\n    Object.defineProperty(extendTag, \"name\", {\n      value: \"<ai-\" + creatorName.replace(/\\s+/g, '-') + callSite + \">\"\n    });\n\n    if (DEBUG) {\n      const extraUnknownProps = Object.keys(staticExtensions).filter(k => !['styles', 'ids', 'constructed', 'declare', 'override', 'iterable'].includes(k));\n      if (extraUnknownProps.length) {\n        console.log(`${extendTag.name} defines extraneous keys '${extraUnknownProps}', which are unknown`);\n      }\n    }\n    return extendTag;\n  }\n\n  // @ts-ignore\n  const baseTagCreators: CreateElement & {\n    [K in keyof HTMLElementTagNameMap]?: TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>\n  } & {\n    [n: string]: TagCreator<Q & Element & PoElementMethods>\n  } = {\n    createElement(\n      name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n      attrs: any,\n      ...children: ChildTags[]): Node {\n      return (name === baseTagCreators.createElement ? nodes(...children)\n        : typeof name === 'function' ? name(attrs, children)\n        : typeof name === 'string' && name in baseTagCreators ?\n        // @ts-ignore: Expression produces a union type that is too complex to represent.ts(2590)\n            baseTagCreators[name](attrs, children)\n        : name instanceof Node ? name\n        : DyamicElementError({ error: new Error(\"Illegal type in createElement:\" + name) })) as Node\n    }\n  }\n\n  function createTag<K extends keyof HTMLElementTagNameMap>(k: K): TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>;\n  function createTag<E extends Element>(k: string): TagCreator<Q & E & PoElementMethods>;\n  function createTag(k: string): TagCreator<Q & NamespacedElementBase & PoElementMethods> {\n    if (baseTagCreators[k])\n      // @ts-ignore\n      return baseTagCreators[k];\n\n    const tagCreator = (attrs: Q & PoElementMethods & TagCreationOptions | ChildTags, ...children: ChildTags[]) => {\n      if (isChildTag(attrs)) {\n        children.unshift(attrs);\n        attrs = {} as any;\n      }\n\n      // This test is always true, but narrows the type of attrs to avoid further errors\n      if (!isChildTag(attrs)) {\n        if (attrs.debugger) {\n          debugger;\n          delete attrs.debugger;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? thisDoc.createElementNS(nameSpace as string, k.toLowerCase())\n          : thisDoc.createElement(k);\n        e.constructor = tagCreator;\n\n        deepDefine(e, tagPrototypes);\n        assignProps(e, attrs);\n\n        // Append any children\n        e.append(...nodes(...children));\n        return e;\n      }\n    }\n\n    const includingExtender = <TagCreator<Element>><unknown>Object.assign(tagCreator, {\n      super: () => { throw new Error(\"Can't invoke native elemenet constructors directly. Use document.createElement().\") },\n      extended, // How to extend this (base) tag\n      valueOf() { return `TagCreator: <${nameSpace || ''}${nameSpace ? '::' : ''}${k}>` }\n    });\n\n    Object.defineProperty(tagCreator, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    Object.defineProperty(tagCreator, \"name\", { value: '<' + k + '>' });\n    // @ts-ignore\n    return baseTagCreators[k] = includingExtender;\n  }\n\n  tags.forEach(createTag);\n\n  // @ts-ignore\n  return baseTagCreators;\n}\n\n/* DOM node removal logic */\ntype PickByType<T, Value> = {\n  [P in keyof T as T[P] extends Value | undefined ? P : never]: T[P]\n}\nfunction mutationTracker(root: Node, track: keyof PickByType<MutationRecord, NodeList>, enableOnRemovedFromDOM?: boolean) {\n  const tracked = new WeakSet<Node>();\n  function walk(nodes: NodeList) {\n    for (const node of nodes) {\n      // In case it's be re-added/moved\n      if ((track === 'addedNodes') === node.isConnected) {\n        walk(node.childNodes);\n        tracked.add(node);\n        // Legacy onRemovedFromDOM support\n        if (enableOnRemovedFromDOM && 'onRemovedFromDOM' in node && typeof node.onRemovedFromDOM === 'function') node.onRemovedFromDOM();\n      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m[track].length) {\n        walk(m[track])\n      }\n    });\n  }).observe(root, { subtree: true, childList: true });\n\n  return function (node: Node) {\n    return tracked.has(node);\n  }\n}\n"],
  "mappings": "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",
  "names": ["v", "a", "result", "ex", "ir", "isMissing", "merged", "unique", "c", "n", "value", "isAncestral", "children"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/debug.ts", "../src/deferred.ts", "../src/iterators.ts", "../src/when.ts", "../src/ai-ui.ts"],
  "sourcesContent": ["// @ts-ignore\nexport const DEBUG = globalThis.DEBUG == '*' || globalThis.DEBUG == true || globalThis.DEBUG?.match(/(^|\\W)AI-UI(\\W|$)/) || false;\nexport { _console as console };\nexport const timeOutWarn = 5000;\n\nconst _console = {\n  log(...args: any) {\n    if (DEBUG) console.log('(AI-UI) LOG:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args, new Error().stack?.replace(/Error\\n\\s*.*\\n/,'\\n'))\n  },\n  info(...args: any) {\n    if (DEBUG) console.trace('(AI-UI) INFO:', ...args)\n  }\n}\n\n", "import { DEBUG, console } from \"./debug.js\";\n\n// Create a deferred Promise, which can be asynchronously/externally resolved or rejected.\nexport type DeferredPromise<T> = Promise<T> & {\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (value: any) => void;\n}\n\n// Used to suppress TS error about use before initialisation\nconst nothing = (v: any)=>{};\n\nexport function deferred<T>(): DeferredPromise<T> {\n  let resolve: (value: T | PromiseLike<T>) => void = nothing;\n  let reject: (value: any) => void = nothing;\n  const promise = new Promise<T>((...r) => [resolve, reject] = r) as DeferredPromise<T>;\n  promise.resolve = resolve;\n  promise.reject = reject;\n  if (DEBUG) {\n    const initLocation = new Error().stack;\n    promise.catch(ex => (ex instanceof Error || ex?.value instanceof Error) ? console.log(\"Deferred rejection\", ex, \"allocated at \", initLocation) : undefined);\n  }\n  return promise;\n}\n\n// True if `expr in x` is valid\nexport function isObjectLike(x: any): x is Function | {} {\n  return x && typeof x === 'object' || typeof x === 'function'\n}\n\nexport function isPromiseLike<T>(x: any): x is PromiseLike<T> {\n  return isObjectLike(x) && ('then' in x) && typeof x.then === 'function';\n}\n", "import { DEBUG, console } from \"./debug.js\"\nimport { DeferredPromise, deferred, isObjectLike, isPromiseLike } from \"./deferred.js\"\n\n/* IterableProperties can't be correctly typed in TS right now, either the declaratiion\n  works for retrieval (the getter), or it works for assignments (the setter), but there's\n  no TS syntax that permits correct type-checking at present.\n\n  Ideally, it would be:\n\n  type IterableProperties<IP> = {\n    get [K in keyof IP](): AsyncExtraIterable<IP[K]> & IP[K]\n    set [K in keyof IP](v: IP[K])\n  }\n  See https://github.com/microsoft/TypeScript/issues/43826\n\n  We choose the following type description to avoid the issues above. Because the AsyncExtraIterable\n  is Partial it can be omitted from assignments:\n    this.prop = value;  // Valid, as long as valus has the same type as the prop\n  ...and when retrieved it will be the value type, and optionally the async iterator:\n    Div(this.prop) ; // the value\n    this.prop.map!(....)  // the iterator (note the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts which *accepts* a Partial<AsyncIterator>\n  but casts it to a AsyncIterator before use.\n\n  The iterability of propertys of an object is determined by the presence and value of the `Iterability` symbol.\n  By default, the current implementation does a deep mapping, so an iterable property 'obj' is itself\n  iterable, as are it's members. The only defined value at present is \"shallow\", in which case 'obj' remains\n  iterable, but it's membetrs are just POJS values.\n*/\n\n// Base types that can be made defined as iterable: basically anything, _except_ a function\nexport type IterablePropertyPrimitive = (string | number | bigint | boolean | undefined | null);\n// We should exclude AsyncIterable from the types that can be assigned to iterables (and therefore passed to defineIterableProperty)\nexport type IterablePropertyValue = IterablePropertyPrimitive | IterablePropertyValue[] | { [k: string | symbol | number]: IterablePropertyValue };\n\nexport const Iterability = Symbol(\"Iterability\");\nexport type Iterability<Depth extends 'shallow' = 'shallow'> = { [Iterability]: Depth };\nexport type IterableType<T> = T & Partial<AsyncExtraIterable<T>>;\n\ndeclare global {\n  // This is patch to the std lib definition of Array<T>. I don't know why it's absent,\n  // as this is the implementation in all JavaScript engines. It is probably a result\n  // of its absence in https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values,\n  // which inherits from the Object.prototype, which makes no claim for the return type\n  // since it could be overriddem. However, in that case, a TS defn should also override\n  // it, like Number, String, Boolean etc do.\n  interface Array<T> {\n    valueOf(): Array<T>;\n  }\n  // As above, the return type could be T rather than Object, since this is the default impl,\n  // but it's not, for some reason.\n  interface Object {\n    valueOf<T>(this: T): T extends IterableType<infer Z> ? Z : Object;\n  }\n}\n\nexport type IterableProperties<IP> = IP extends Iterability<'shallow'> ? {\n  [K in keyof Omit<IP, typeof Iterability>]: IterableType<IP[K]>\n} : ({\n  [K in keyof IP]: (\n    IP[K] extends Array<infer E>\n    ? (IterableProperties<E>[] | IterableProperties<E[]>)\n    : ((\n      IP[K] extends object\n      ? IterableProperties<IP[K]>\n      : IP[K]\n    ) & IterableType<IP[K]>)\n  )\n})\n\n/* Things to suppliement the JS base AsyncIterable */\nexport interface QueueIteratableIterator<T> extends AsyncIterableIterator<T>, AsyncIterableHelpers {\n  push(value: T): boolean;\n  readonly length: number;\n}\n\nexport interface AsyncExtraIterable<T> extends AsyncIterable<T>, AsyncIterableHelpers { }\n\n// NB: This also (incorrectly) passes sync iterators, as the protocol names are the same\nexport function isAsyncIterator<T = unknown>(o: any | AsyncIterator<T>): o is AsyncIterator<T> {\n  return isObjectLike(o) && 'next' in o && typeof o?.next === 'function'\n}\nexport function isAsyncIterable<T = unknown>(o: any | AsyncIterable<T>): o is AsyncIterable<T> {\n  return isObjectLike(o) && (Symbol.asyncIterator in o) && typeof o[Symbol.asyncIterator] === 'function'\n}\nexport function isAsyncIter<T = unknown>(o: any | AsyncIterable<T> | AsyncIterator<T>): o is AsyncIterable<T> | AsyncIterator<T> {\n  return isAsyncIterable(o) || isAsyncIterator(o)\n}\n\nexport type AsyncProvider<T> = AsyncIterator<T> | AsyncIterable<T>\n\nexport function asyncIterator<T>(o: AsyncProvider<T>) {\n  if (isAsyncIterator(o)) return o;\n  if (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  throw new Error(\"Not an async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nexport const asyncExtras = {\n  filterMap<U extends PartialIterable, R>(this: U,\n    fn: (o: HelperAsyncIterable<U>, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>,\n    initialValue: R | typeof Ignore = Ignore\n  ) {\n    return filterMap(this, fn, initialValue)\n  },\n  map,\n  filter,\n  unique,\n  waitFor,\n  multi,\n  initially,\n  consume,\n  merge<T, A extends Partial<AsyncIterable<any>>[]>(this: PartialIterable<T>, ...m: A) {\n    return merge(this, ...m);\n  },\n  combine<T, S extends CombinedIterable>(this: PartialIterable<T>, others: S) {\n    return combine(Object.assign({ '_this': this }, others));\n  }\n};\n\nconst extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)] as (keyof typeof asyncExtras)[];\n\n// Like Object.assign, but the assigned properties are not enumerable\nfunction assignHidden<D extends {}, S extends {}>(d: D, s: S) {\n  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];\n  for (const k of keys) {\n    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });\n  }\n  return d as D & S;\n}\n\nconst _pending = Symbol('pending');\nconst _items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [_items]: [] as IteratorResult<T>[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[_items]?.length) {\n        return Promise.resolve(q[_items].shift()!);\n      }\n\n      if (!q[_pending])\n        return Promise.resolve({ done: true as const, value: undefined });\n\n      const value = deferred<IteratorResult<T>>();\n      // We install a catch handler as the promise might be legitimately reject before anything waits for it,\n      // and this suppresses the uncaught exception warning.\n      value.catch(ex => { });\n      q[_pending].unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.resolve(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.resolve(value);\n    },\n\n    throw(...args: any[]) {\n      const value = { done: true as const, value: args[0] };\n      if (q[_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[_pending].length)\n          q[_pending].pop()!.reject(value);\n        q[_items] = q[_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[_items]) return -1; // The queue has no consumers and has terminated.\n      return q[_items].length;\n    },\n\n    push(value: T) {\n      if (!q[_pending])\n        return false;\n\n      if (q[_pending].length) {\n        q[_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[_items].push({ done: false, value })\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst _inflight = Symbol('inflight');\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [_inflight]: Set<T> };\n  q[_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[_pending])\n      return false;\n\n    // Debounce\n    if (q[_inflight].has(value))\n      return true;\n\n    if (q[_pending].length) {\n      q[_inflight].add(value);\n      const p = q[_pending].pop()!;\n      p.finally(() => q[_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[_items].find(v => v.value === value)) {\n        q[_items].push({ done: false, value });\n      }\n    }\n    return true;\n  }\n  return q;\n}\n\n// Re-export to hide the internals\nexport const queueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalQueueIteratableIterator;\nexport const debounceQueueIteratableIterator: <T>(stop?: () => void) => QueueIteratableIterator<T> = internalDebounceQueueIteratableIterator;\n\ndeclare global {\n  interface ObjectConstructor {\n    defineProperties<T, M extends { [K: string | symbol]: TypedPropertyDescriptor<any> }>(o: T, properties: M & ThisType<any>): T & {\n      [K in keyof M]: M[K] extends TypedPropertyDescriptor<infer T> ? T : never\n    };\n  }\n}\n\n/* Define a \"iterable property\" on `obj`.\n   This is a property that holds a boxed (within an Object() call) value, and is also an AsyncIterableIterator. which\n   yields when the property is set.\n   This routine creates the getter/setter for the specified property, and manages the aassociated async iterator.\n*/\n\nconst _proxiedAsyncIterator = Symbol('_proxiedAsyncIterator');\nexport function defineIterableProperty<T extends {}, const N extends string | symbol, V extends IterablePropertyValue>(obj: T, name: N, v: V): T & IterableProperties<{ [k in N]: V }> {\n  // Make `a` an AsyncExtraIterable. We don't do this until a consumer actually tries to\n  // access the iterator methods to prevent leaks where an iterable is created, but\n  // never referenced, and therefore cannot be consumed and ultimately closed\n  let initIterator = () => {\n    initIterator = () => b;\n    const bi = debounceQueueIteratableIterator<V>();\n    const mi = bi.multi();\n    const b = mi[Symbol.asyncIterator]();\n    extras[Symbol.asyncIterator] = mi[Symbol.asyncIterator];\n    push = bi.push;\n    extraKeys.forEach(k => // @ts-ignore\n      extras[k] = b[k as keyof typeof b]);\n    if (!(_proxiedAsyncIterator in a))\n      assignHidden(a, extras);\n    return b;\n  }\n\n  // Create stubs that lazily create the AsyncExtraIterable interface when invoked\n  function lazyAsyncMethod<M extends keyof typeof asyncExtras>(method: M) {\n    return {\n      [method]: function (this: unknown, ...args: any[]) {\n        initIterator();\n        // @ts-ignore - Fix\n        return a[method].apply(this, args);\n      } as (typeof asyncExtras)[M]\n    }[method];\n  }\n\n  type HelperDescriptors<T> = {\n    [K in keyof AsyncExtraIterable<T>]: TypedPropertyDescriptor<AsyncExtraIterable<T>[K]>\n  } & {\n    [Iterability]?: TypedPropertyDescriptor<'shallow'>\n  };\n\n  const extras = { [Symbol.asyncIterator]: initIterator } as AsyncExtraIterable<V> & { [Iterability]?: 'shallow' };\n  extraKeys.forEach((k) => // @ts-ignore\n    extras[k] = lazyAsyncMethod(k))\n  if (typeof v === 'object' && v && Iterability in v && v[Iterability] === 'shallow') {\n    extras[Iterability] = v[Iterability];\n  }\n\n  // Lazily initialize `push`\n  let push: QueueIteratableIterator<V>['push'] = (v: V) => {\n    initIterator(); // Updates `push` to reference the multi-queue\n    return push(v);\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<V> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: V | AsyncExtraIterable<V>) {\n      if (v !== a) {\n        if (isAsyncIterable(v)) {\n          // Assigning multiple async iterators to a single iterable is probably a\n          // bad idea from a reasoning point of view, and multiple implementations\n          // are possible:\n          //  * merge?\n          //  * ignore subsequent assignments?\n          //  * terminate the first then consume the second?\n          // The solution here (one of many possibilities) is the letter: only to allow\n          // most recent assignment to work, terminating any preceeding iterator when it next\n          // yields and finds this consumer has been re-assigned.\n\n          // If the iterator has been reassigned with no change, just ignore it, as we're already consuming it\n          if (piped === v)\n            return;\n\n          piped = v;\n          let stack = DEBUG ? new Error() : undefined;\n          if (DEBUG)\n            console.info(new Error(`Iterable \"${name.toString()}\" has been assigned to consume another iterator. Did you mean to declare it?`));\n          consume.call(v, y => {\n            if (v !== piped) {\n              // We're being piped from something else. We want to stop that one and get piped from this one\n              throw new Error(`Piped iterable \"${name.toString()}\" has been replaced by another iterator`, { cause: stack });\n            }\n            push(y?.valueOf() as V)\n          })\n            .catch(ex => console.info(ex))\n            .finally(() => (v === piped) && (piped = undefined));\n\n          // Early return as we're going to pipe values in later\n          return;\n        } else {\n          if (piped && DEBUG) {\n            console.log(`Iterable \"${name.toString()}\" is already piped from another iterator, and might be overrwitten later`);\n          }\n          a = box(v, extras);\n        }\n      }\n      push(v?.valueOf() as V);\n    },\n    enumerable: true\n  });\n  return obj as any;\n\n  function box<V>(a: V, pds: AsyncExtraIterable<V>): V & AsyncExtraIterable<V> {\n    if (a === null || a === undefined) {\n      return assignHidden(Object.create(null, {\n        valueOf: { value() { return a }, writable: true, configurable: true },\n        toJSON: { value() { return a }, writable: true, configurable: true }\n      }), pds);\n    }\n    switch (typeof a) {\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return assignHidden(Object(a), Object.assign(pds, {\n          toJSON() { return a.valueOf() }\n        }));\n      case 'object':\n        // We box objects by creating a Proxy for the object that pushes on get/set/delete, and maps the supplied async iterator to push the specified key\n        // The proxies are recursive, so that if an object contains objects, they too are proxied. Objects containing primitives remain proxied to\n        // handle the get/set/selete in place of the usual primitive boxing via Object(primitiveValue)\n        // @ts-ignore\n        return boxObject(a, pds);\n\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n\n  type WithPath = { [_proxiedAsyncIterator]: { a: V, path: string | null } };\n  type PossiblyWithPath = V | WithPath;\n  function isProxiedAsyncIterator(o: PossiblyWithPath): o is WithPath {\n    return isObjectLike(o) && _proxiedAsyncIterator in o;\n  }\n  function destructure(o: any, path: string) {\n    const fields = path.split('.').slice(1);\n    for (let i = 0; i < fields.length && ((o = o?.[fields[i]]) !== undefined); i++);\n    return o;\n  }\n  function boxObject(a: V, pds: AsyncExtraIterable<PossiblyWithPath>) {\n    let withPath: AsyncExtraIterable<WithPath[typeof _proxiedAsyncIterator]>;\n    let withoutPath: AsyncExtraIterable<V>;\n    return new Proxy(a as object, handler()) as V & AsyncExtraIterable<V>;\n\n    function handler(path = ''): ProxyHandler<object> {\n      return {\n        // A boxed object has its own keys, and the keys of an AsyncExtraIterable\n        has(target, key) {\n          return key === _proxiedAsyncIterator || key === Symbol.toPrimitive || key in target || key in pds;\n        },\n        // When a key is set in the target, push the change\n        set(target, key, value, receiver) {\n          if (Object.hasOwn(pds, key)) {\n            throw new Error(`Cannot set ${name.toString()}${path}.${key.toString()} as it is part of asyncIterator`);\n          }\n          if (Reflect.get(target, key, receiver) !== value) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n          }\n          return Reflect.set(target, key, value, receiver);\n        },\n        deleteProperty(target, key) {\n          if (Reflect.deleteProperty(target, key)) {\n            push({ [_proxiedAsyncIterator]: { a, path } } as any);\n            return true;\n          }\n          return false;\n        },\n        // When getting the value of a boxed object member, prefer asyncExtraIterable over target keys\n        get(target, key, receiver) {\n          // If the key is an asyncExtraIterable member, create the mapped queue to generate it\n          if (Object.hasOwn(pds, key)) {\n            if (!path.length) {\n              withoutPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator].a : o);\n              return withoutPath[key as keyof typeof pds];\n            } else {\n              withPath ??= filterMap(pds, o => isProxiedAsyncIterator(o) ? o[_proxiedAsyncIterator] : { a: o, path: null });\n\n              let ai = filterMap(withPath, (o, p) => {\n                const v = destructure(o.a, path);\n                return p !== v || o.path === null || o.path.startsWith(path) ? v : Ignore;\n              }, Ignore, destructure(a, path));\n              return ai[key as keyof typeof ai];\n            }\n          }\n\n          // If the key is a target property, create the proxy to handle it\n          if (key === 'valueOf') return () => destructure(a, path);\n          if (key === Symbol.toPrimitive) {\n            // Special case, since Symbol.toPrimitive is in ha(), we need to implement it\n            return function (hint?: 'string' | 'number' | 'default') {\n              if (Reflect.has(target, key))\n                return Reflect.get(target, key, target).call(target, hint);\n              if (hint === 'string') return target.toString();\n              if (hint === 'number') return Number(target);\n              return target.valueOf();\n            }\n          }\n          if (typeof key === 'string') {\n            if ((!(key in target) || Object.hasOwn(target, key)) && !(Iterability in target && target[Iterability] === 'shallow')) {\n              const field = Reflect.get(target, key, receiver);\n              return (typeof field === 'function') || isAsyncIter(field)\n                ? field\n                : new Proxy(Object(field), handler(path + '.' + key));\n            }\n          }\n          // This is a symbolic entry, or a prototypical value (since it's in the target, but not a target property)\n          return Reflect.get(target, key, receiver);\n        }\n      }\n    }\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\nconst forever = new Promise<any>(() => { });\n\n/* Merge asyncIterables into a single asyncIterable */\n\n/* TS hack to expose the return AsyncGenerator a generator of the union of the merged types */\ntype CollapseIterableType<T> = T[] extends Partial<AsyncIterable<infer U>>[] ? U : never;\ntype CollapseIterableTypes<T> = AsyncIterable<CollapseIterableType<T>>;\n\nexport const merge = <A extends Partial<AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>>[], TYield, TReturn, TNext>(...ai: A) => {\n  const it: (undefined | AsyncIterator<any>)[] = new Array(ai.length);\n  const promises: Promise<{ idx: number, result: IteratorResult<any> }>[] = new Array(ai.length);\n\n  let init = () => {\n    init = () => { }\n    for (let n = 0; n < ai.length; n++) {\n      const a = ai[n] as AsyncIterable<TYield> | AsyncIterator<TYield, TReturn, TNext>;\n      promises[n] = (it[n] = Symbol.asyncIterator in a\n        ? a[Symbol.asyncIterator]()\n        : a as AsyncIterator<any>)\n        .next()\n        .then(result => ({ idx: n, result }));\n    }\n  }\n\n  const results: (TYield | TReturn)[] = [];\n  let count = promises.length;\n\n  const merged: AsyncIterableIterator<A[number]> = {\n    [Symbol.asyncIterator]() { return merged },\n    next() {\n      init();\n      return count\n        ? Promise.race(promises).then(({ idx, result }) => {\n          if (result.done) {\n            count--;\n            promises[idx] = forever;\n            results[idx] = result.value;\n            // We don't yield intermediate return values, we just keep them in results\n            // return { done: count === 0, value: result.value }\n            return merged.next();\n          } else {\n            // `ex` is the underlying async iteration exception\n            promises[idx] = it[idx]\n              ? it[idx]!.next().then(result => ({ idx, result })).catch(ex => ({ idx, result: { done: true, value: ex } }))\n              : Promise.resolve({ idx, result: { done: true, value: undefined } })\n            return result;\n          }\n        }).catch(ex => {\n          return merged.throw?.(ex) ?? Promise.reject({ done: true as const, value: new Error(\"Iterator merge exception\") });\n        })\n        : Promise.resolve({ done: true as const, value: results });\n    },\n    async return(r) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.return?.({ done: true, value: r }).then(v => v.value, ex => ex);\n        }\n      }\n      return { done: true, value: results };\n    },\n    async throw(ex: any) {\n      for (let i = 0; i < it.length; i++) {\n        if (promises[i] !== forever) {\n          promises[i] = forever;\n          results[i] = await it[i]?.throw?.(ex).then(v => v.value, ex => ex);\n        }\n      }\n      // Because we've passed the exception on to all the sources, we're now done\n      // previously: return Promise.reject(ex);\n      return { done: true, value: results };\n    }\n  };\n  return iterableHelpers(merged as unknown as CollapseIterableTypes<A[number]>);\n}\n\ntype CombinedIterable = { [k: string | number | symbol]: PartialIterable };\ntype CombinedIterableType<S extends CombinedIterable> = {\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n};\ntype CombinedIterableResult<S extends CombinedIterable> = AsyncExtraIterable<{\n  [K in keyof S]?: S[K] extends PartialIterable<infer T> ? T : never\n}>;\n\nexport interface CombineOptions {\n  ignorePartial?: boolean; // Set to avoid yielding if some sources are absent\n}\n\nexport const combine = <S extends CombinedIterable>(src: S, opts: CombineOptions = {}): CombinedIterableResult<S> => {\n  const accumulated: CombinedIterableType<S> = {};\n  let pc: Promise<{ idx: number, k: string, ir: IteratorResult<any> }>[];\n  let si: AsyncIterator<any>[] = [];\n  let active: number = 0;\n  const ci = {\n    [Symbol.asyncIterator]() { return ci },\n    next(): Promise<IteratorResult<CombinedIterableType<S>>> {\n      if (pc === undefined) {\n        pc = Object.entries(src).map(([k, sit], idx) => {\n          active += 1;\n          si[idx] = sit[Symbol.asyncIterator]!();\n          return si[idx].next().then(ir => ({ si, idx, k, ir }));\n        });\n      }\n\n      return (function step(): Promise<IteratorResult<CombinedIterableType<S>>> {\n        return Promise.race(pc).then(({ idx, k, ir }) => {\n          if (ir.done) {\n            pc[idx] = forever;\n            active -= 1;\n            if (!active)\n              return { done: true, value: undefined };\n            return step();\n          } else {\n            // @ts-ignore\n            accumulated[k] = ir.value;\n            pc[idx] = si[idx].next().then(ir => ({ idx, k, ir }));\n          }\n          if (opts.ignorePartial) {\n            if (Object.keys(accumulated).length < Object.keys(src).length)\n              return step();\n          }\n          return { done: false, value: accumulated };\n        })\n      })();\n    },\n    return(v?: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].return?.(v)\n        }\n      });\n      return Promise.resolve({ done: true, value: v });\n    },\n    throw(ex: any) {\n      pc.forEach((p, idx) => {\n        if (p !== forever) {\n          si[idx].throw?.(ex)\n        }\n      });\n      return Promise.reject({ done: true, value: ex });\n    }\n  }\n  return iterableHelpers(ci);\n}\n\n\nfunction isExtraIterable<T>(i: any): i is AsyncExtraIterable<T> {\n  return isAsyncIterable(i)\n    && extraKeys.every(k => (k in i) && (i as any)[k] === asyncExtras[k]);\n}\n\n// Attach the pre-defined helpers onto an AsyncIterable and return the modified object correctly typed\nexport function iterableHelpers<A extends AsyncIterable<any>>(ai: A): A & AsyncExtraIterable<A extends AsyncIterable<infer T> ? T : unknown> {\n  if (!isExtraIterable(ai)) {\n    assignHidden(ai, asyncExtras);\n  }\n  return ai as A extends AsyncIterable<infer T> ? AsyncExtraIterable<T> & A : never\n}\n\nexport function generatorHelpers<G extends (...args: any[]) => R, R extends AsyncGenerator>(g: G) {\n  return function (...args: Parameters<G>): ReturnType<G> {\n    const ai = g(...args);\n    return iterableHelpers(ai) as ReturnType<G>;\n  } as (...args: Parameters<G>) => ReturnType<G> & AsyncExtraIterable<ReturnType<G> extends AsyncGenerator<infer T> ? T : unknown>\n}\n\n/* AsyncIterable helpers, which can be attached to an AsyncIterator with `withHelpers(ai)`, and invoked directly for foreign asyncIterators */\n\n/* types that accept Partials as potentiallu async iterators, since we permit this IN TYPING so\n  iterable properties don't complain on every access as they are declared as V & Partial<AsyncIterable<V>>\n  due to the setters and getters having different types, but undeclarable in TS due to syntax limitations */\ntype HelperAsyncIterable<Q extends Partial<AsyncIterable<any>>> = HelperAsyncIterator<Required<Q>[typeof Symbol.asyncIterator]>;\ntype HelperAsyncIterator<F> =\n  F extends () => AsyncIterator<infer T>\n  ? T : never;\n\nasync function consume<U extends Partial<AsyncIterable<any>>>(this: U, f?: (u: HelperAsyncIterable<U>) => void | PromiseLike<void>): Promise<void> {\n  let last: undefined | void | PromiseLike<void> = undefined;\n  for await (const u of this as AsyncIterable<HelperAsyncIterable<U>>) {\n    last = f?.(u);\n  }\n  await last;\n}\n\ntype Mapper<U, R> = ((o: U, prev: R | typeof Ignore) => MaybePromised<R | typeof Ignore>);\ntype MaybePromised<T> = PromiseLike<T> | T;\n\n/* A general filter & mapper that can handle exceptions & returns */\nexport const Ignore = Symbol(\"Ignore\");\n\ntype PartialIterable<T = any> = Partial<AsyncIterable<T>>;\n\nfunction resolveSync<Z, R>(v: MaybePromised<Z>, then: (v: Z) => R, except: (x: any) => any): MaybePromised<R> {\n  if (isPromiseLike(v))\n    return v.then(then, except);\n  try { return then(v) } catch (ex) { return except(ex) }\n}\n\nexport function filterMap<U extends PartialIterable, R>(source: U,\n  fn: Mapper<HelperAsyncIterable<U>, R>,\n  initialValue: R | typeof Ignore = Ignore,\n  prev: R | typeof Ignore = Ignore\n): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  const fai: AsyncIterableIterator<R> = {\n    [Symbol.asyncIterator]() {\n      return fai;\n    },\n\n    next(...args: [] | [undefined]) {\n      if (initialValue !== Ignore) {\n        const init = Promise.resolve({ done: false, value: initialValue });\n        initialValue = Ignore;\n        return init;\n      }\n\n      return new Promise<IteratorResult<R>>(function step(resolve, reject) {\n        if (!ai)\n          ai = source[Symbol.asyncIterator]!();\n        ai.next(...args).then(\n          p => p.done\n            ? resolve(p)\n            : resolveSync(fn(p.value, prev),\n              f => f === Ignore\n                ? step(resolve, reject)\n                : resolve({ done: false, value: prev = f }),\n              ex => {\n                // The filter function failed...\n                ai.throw ? ai.throw(ex) : ai.return?.(ex) // Terminate the source - for now we ignore the result of the termination\n                reject({ done: true, value: ex }); // Terminate the consumer\n              }\n            ),\n\n          ex =>\n            // The source threw. Tell the consumer\n            reject({ done: true, value: ex })\n        ).catch(ex => {\n          // The callback threw\n          ai.throw ? ai.throw(ex) : ai.return?.(ex); // Terminate the source - for now we ignore the result of the termination\n          reject({ done: true, value: ex })\n        })\n      })\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(fai)\n}\n\nfunction map<U extends PartialIterable, R>(this: U, mapper: Mapper<HelperAsyncIterable<U>, R>): AsyncExtraIterable<R> {\n  return filterMap(this, mapper);\n}\n\nfunction filter<U extends PartialIterable>(this: U, fn: (o: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, async o => (await fn(o) ? o : Ignore));\n}\n\nfunction unique<U extends PartialIterable>(this: U, fn?: (next: HelperAsyncIterable<U>, prev: HelperAsyncIterable<U>) => boolean | PromiseLike<boolean>): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return fn\n    ? filterMap(this, async (o, p) => (p === Ignore || await fn(o, p)) ? o : Ignore)\n    : filterMap(this, (o, p) => o === p ? Ignore : o);\n}\n\nfunction initially<U extends PartialIterable, I = HelperAsyncIterable<U>>(this: U, initValue: I): AsyncExtraIterable<HelperAsyncIterable<U> | I> {\n  return filterMap(this, o => o, initValue);\n}\n\nfunction waitFor<U extends PartialIterable>(this: U, cb: (done: (value: void | PromiseLike<void>) => void) => void): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  return filterMap(this, o => new Promise<HelperAsyncIterable<U>>(resolve => { cb(() => resolve(o)); return o }));\n}\n\nfunction multi<U extends PartialIterable>(this: U): AsyncExtraIterable<HelperAsyncIterable<U>> {\n  type T = HelperAsyncIterable<U>;\n  const source = this;\n  let consumers = 0;\n  let current: DeferredPromise<IteratorResult<T, any>>;\n  let ai: AsyncIterator<T, any, undefined> | undefined = undefined;\n\n  // The source has produced a new result\n  function step(it?: IteratorResult<T, any>) {\n    if (it) current.resolve(it);\n    if (!it?.done) {\n      current = deferred<IteratorResult<T>>();\n      ai!.next()\n        .then(step)\n        .catch(error => current.reject({ done: true, value: error }));\n    }\n  }\n\n  const mai: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      consumers += 1;\n      return mai;\n    },\n\n    next() {\n      if (!ai) {\n        ai = source[Symbol.asyncIterator]!();\n        step();\n      }\n      return current//.then(zalgo => zalgo);\n    },\n\n    throw(ex: any) {\n      // The consumer wants us to exit with an exception. Tell the source if we're the final one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: ex });\n      return Promise.resolve(ai?.throw ? ai.throw(ex) : ai?.return?.(ex)).then(v => ({ done: true, value: v?.value }))\n    },\n\n    return(v?: any) {\n      // The consumer told us to return, so we need to terminate the source if we're the only one\n      if (consumers < 1)\n        throw new Error(\"AsyncIterator protocol error\");\n      consumers -= 1;\n      if (consumers)\n        return Promise.resolve({ done: true, value: v });\n      return Promise.resolve(ai?.return?.(v)).then(v => ({ done: true, value: v?.value }))\n    }\n  };\n  return iterableHelpers(mai);\n}\n\nexport function augmentGlobalAsyncGenerators() {\n  let g = (async function* () { })();\n  while (g) {\n    const desc = Object.getOwnPropertyDescriptor(g, Symbol.asyncIterator);\n    if (desc) {\n      iterableHelpers(g);\n      break;\n    }\n    g = Object.getPrototypeOf(g);\n  }\n  if (!g) {\n    console.warn(\"Failed to augment the prototype of `(async function*())()`\");\n  }\n}\n\n", "import { DEBUG, console, timeOutWarn } from './debug.js';\nimport { isPromiseLike } from './deferred.js';\nimport { iterableHelpers, merge, AsyncExtraIterable, queueIteratableIterator } from \"./iterators.js\";\n\n/*\n  `when(....)` is both an AsyncIterable of the events it can generate by observation,\n  and a function that can map those events to a specified type, eg:\n\n  this.when('keyup:#elemet') => AsyncIterable<KeyboardEvent>\n  this.when('#elemet')(e => e.target) => AsyncIterable<EventTarget>\n*/\n// Varargs type passed to \"when\"\nexport type WhenParameters<IDS extends string = string> = ReadonlyArray<\n  AsyncIterable<any>\n  | ValidWhenSelector<IDS>\n  | Element /* Implies \"change\" event */\n  | Promise<any> /* Just gets wrapped in a single `yield` */\n>;\n\n// The Iterated type generated by \"when\", based on the parameters\ntype WhenIteratedType<S extends WhenParameters> =\n  (Extract<S[number], AsyncIterable<any>> extends AsyncIterable<infer I> ? unknown extends I ? never : I : never)\n  | ExtractEvents<Extract<S[number], string>>\n  | (Extract<S[number], Element> extends never ? never : Event)\n\ntype MappableIterable<A extends AsyncIterable<any>> =\n  A extends AsyncIterable<infer T> ?\n    A & AsyncExtraIterable<T> &\n    (<R>(mapper: (value: A extends AsyncIterable<infer T> ? T : never) => R) => (AsyncExtraIterable<Awaited<R>>))\n  : never;\n\n// The extended iterator that supports async iterator mapping, chaining, etc\nexport type WhenReturn<S extends WhenParameters> =\n  MappableIterable<\n    AsyncExtraIterable<\n      WhenIteratedType<S>>>;\n\ntype EmptyObject = Record<string | symbol | number, never>;\n\ntype SpecialWhenEvents = {\n  \"@start\": EmptyObject,  // Always fires when referenced\n  \"@ready\": EmptyObject   // Fires when all Element specified sources are mounted in the DOM\n};\ntype WhenEvents = GlobalEventHandlersEventMap & SpecialWhenEvents;\ntype EventNameList<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : `${S},${EventNameList<R>}`\n  : never;\n\ntype EventNameUnion<T extends string> = T extends keyof WhenEvents\n  ? T\n  : T extends `${infer S extends keyof WhenEvents},${infer R}`\n  ? EventNameList<R> extends never ? never : S | EventNameList<R>\n  : never;\n\n\ntype EventAttribute = `${keyof GlobalEventHandlersEventMap}`\ntype CSSIdentifier<IDS extends string = string> = `#${IDS}` |`.${string}` | `[${string}]`\n\n/* ValidWhenSelectors are:\n    @start\n    @ready\n    event:selector\n    event           \"this\" element, event type='event'\n    selector        specificed selectors, implies \"change\" event\n*/\n\nexport type ValidWhenSelector<IDS extends string = string> = `${keyof SpecialWhenEvents}`\n  | `${EventAttribute}:${CSSIdentifier<IDS>}`\n  | EventAttribute\n  | CSSIdentifier<IDS>;\n\ntype IsValidWhenSelector<S>\n  = S extends ValidWhenSelector ? S : never;\n\ntype ExtractEventNames<S>\n  = S extends keyof SpecialWhenEvents ? S\n  : S extends `${infer V}:${infer L extends CSSIdentifier}`\n  ? EventNameUnion<V> extends never ? never : EventNameUnion<V>\n  : S extends `${infer L extends CSSIdentifier}`\n  ? 'change'\n  : never;\n\ntype ExtractEvents<S> = WhenEvents[ExtractEventNames<S>];\n\n/** when **/\ntype EventObservation<EventName extends keyof GlobalEventHandlersEventMap> = {\n  push: (ev: GlobalEventHandlersEventMap[EventName])=>void;\n  terminate: (ex: Error)=>void;\n  container: Element\n  selector: string | null\n};\nconst eventObservations = new WeakMap<Document, Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  if (!eventObservations.has(this))\n    eventObservations.set(this, new Map());\n\n  const observations = eventObservations.get(this)!.get(ev.type as keyof GlobalEventHandlersEventMap);\n  if (observations) {\n    for (const o of observations) {\n      try {\n        const { push, terminate, container, selector } = o;\n        if (!container.isConnected) {\n          const msg = \"Container `#\" + container.id + \">\" + (selector || '') + \"` removed from DOM. Removing subscription\";\n          observations.delete(o);\n          terminate(new Error(msg));\n        } else {\n          if (ev.target instanceof Node) {\n            if (selector) {\n              const nodes = container.querySelectorAll(selector);\n              for (const n of nodes) {\n                if ((ev.target === n || n.contains(ev.target)) && container.contains(n))\n                  push(ev)\n              }\n            } else {\n              if ((ev.target === container || container.contains(ev.target)))\n                push(ev)\n            }\n          }\n        }\n      } catch (ex) {\n        console.warn('docEventHandler', ex);\n      }\n    }\n  }\n}\n\nfunction isCSSSelector(s: string): s is CSSIdentifier {\n  return Boolean(s && (s.startsWith('#') || s.startsWith('.') || (s.startsWith('[') && s.endsWith(']'))));\n}\n\nfunction parseWhenSelector<EventName extends string>(what: IsValidWhenSelector<EventName>): undefined | [CSSIdentifier | null, keyof GlobalEventHandlersEventMap] {\n  const parts = what.split(':');\n  if (parts.length === 1) {\n    if (isCSSSelector(parts[0]))\n      return [parts[0],\"change\"];\n    return [null, parts[0] as keyof GlobalEventHandlersEventMap];\n  }\n  if (parts.length === 2) {\n    if (isCSSSelector(parts[1]) && !isCSSSelector(parts[0]))\n    return [parts[1], parts[0] as keyof GlobalEventHandlersEventMap]\n  }\n  return undefined;\n}\n\nfunction doThrow(message: string):never {\n  throw new Error(message);\n}\n\nfunction whenEvent<EventName extends string>(container: Element, what: IsValidWhenSelector<EventName>) {\n  const [selector, eventName] = parseWhenSelector(what) ?? doThrow(\"Invalid WhenSelector: \"+what);\n\n  if (!eventObservations.has(container.ownerDocument))\n    eventObservations.set(container.ownerDocument, new Map());\n\n  if (!eventObservations.get(container.ownerDocument)!.has(eventName)) {\n    container.ownerDocument.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.get(container.ownerDocument)!.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.get(container.ownerDocument)?.get(eventName)?.delete(details));\n\n  const details: EventObservation<keyof GlobalEventHandlersEventMap> /*EventObservation<Exclude<ExtractEventNames<EventName>, keyof SpecialWhenEvents>>*/ = {\n    push: queue.push,\n    terminate(ex: Error) { queue.return?.(ex)},\n    container,\n    selector: selector || null\n  };\n\n  containerAndSelectorsMounted(container, selector ? [selector] : undefined)\n    .then(_ => eventObservations.get(container.ownerDocument)?.get(eventName)!.add(details));\n\n  return queue.multi() ;\n}\n\nasync function* neverGonnaHappen<Z>(): AsyncIterableIterator<Z> {\n  await new Promise(() => {});\n  yield undefined as Z; // Never should be executed\n}\n\n/* Syntactic sugar: chainAsync decorates the specified iterator so it can be mapped by\n  a following function, or used directly as an iterable */\nfunction chainAsync<A extends AsyncExtraIterable<X>, X>(src: A): MappableIterable<A> {\n  function mappableAsyncIterable(mapper: Parameters<typeof src.map>[0]) {\n    return src.map(mapper);\n  }\n\n  return Object.assign(iterableHelpers(mappableAsyncIterable as unknown as AsyncIterable<A>), {\n    [Symbol.asyncIterator]: () => src[Symbol.asyncIterator]()\n  }) as MappableIterable<A>;\n}\n\nfunction isValidWhenSelector(what: WhenParameters[number]): what is ValidWhenSelector {\n  if (!what)\n    throw new Error('Falsy async source will never be ready\\n\\n' + JSON.stringify(what));\n  return typeof what === 'string' && what[0] !== '@' && Boolean(parseWhenSelector(what));\n}\n\nasync function* once<T>(p: Promise<T>) {\n  yield p;\n}\n\nexport function when<S extends WhenParameters>(container: Element, ...sources: S): WhenReturn<S> {\n  if (!sources || sources.length === 0) {\n    return chainAsync(whenEvent(container, \"change\")) as unknown as WhenReturn<S>;\n  }\n\n  const iterators = sources.filter(what => typeof what !== 'string' || what[0] !== '@').map(what => typeof what === 'string'\n    ? whenEvent(container, what)\n    : what instanceof Element\n      ? whenEvent(what, \"change\")\n      : isPromiseLike(what)\n        ? once(what)\n        : what);\n\n  if (sources.includes('@start')) {\n    const start: AsyncIterableIterator<{}> = {\n      [Symbol.asyncIterator]: () => start,\n      next() {\n        start.next = () => Promise.resolve({ done: true, value: undefined })\n        return Promise.resolve({ done: false, value: {} })\n      }\n    };\n    iterators.push(start);\n  }\n\n  if (sources.includes('@ready')) {\n    const watchSelectors = sources.filter(isValidWhenSelector).map(what => parseWhenSelector(what)?.[0]);\n\n    function isMissing(sel: CSSIdentifier | null | undefined): sel is CSSIdentifier {\n      return Boolean(typeof sel === 'string' && !container.querySelector(sel));\n    }\n\n    const missing = watchSelectors.filter(isMissing);\n\n    let events: AsyncIterator<any, any, undefined> | undefined = undefined;\n    const ai: AsyncIterableIterator<any> = {\n      [Symbol.asyncIterator]() { return ai },\n      throw(ex: any) {\n        if (events?.throw) return events.throw(ex);\n        return Promise.resolve({ done: true, value: ex });\n      },\n      return(v?: any) {\n        if (events?.return) return events.return(v);\n        return Promise.resolve({ done: true, value: v });\n      },\n      next() {\n        if (events) return events.next();\n\n        return containerAndSelectorsMounted(container, missing).then(() => {\n          const merged = (iterators.length > 1)\n          ? merge(...iterators)\n          : iterators.length === 1\n            ? iterators[0]\n            : (neverGonnaHappen<WhenIteratedType<S>>());\n\n          // Now everything is ready, we simply delegate all async ops to the underlying\n          // merged asyncIterator \"events\"\n          events = merged[Symbol.asyncIterator]();\n          if (!events)\n            return { done: true, value: undefined };\n\n          return { done: false, value: {} };\n        });\n      }\n    };\n    return chainAsync(iterableHelpers(ai));\n  }\n\n  const merged = (iterators.length > 1)\n    ? merge(...iterators)\n    : iterators.length === 1\n      ? iterators[0]\n      : (neverGonnaHappen<WhenIteratedType<S>>());\n\n  return chainAsync(iterableHelpers(merged));\n}\n\nfunction elementIsInDOM(elt: Element): Promise<void> {\n  if (elt.isConnected)\n    return Promise.resolve();\n\n  return new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (elt.isConnected) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(elt.ownerDocument.body, {\n    subtree: true,\n    childList: true\n  }));\n}\n\nfunction containerAndSelectorsMounted(container: Element, selectors?: string[]) {\n  if (selectors?.length)\n    return Promise.all([\n      allSelectorsPresent(container, selectors),\n      elementIsInDOM(container)\n    ]);\n  return elementIsInDOM(container);\n}\n\nfunction allSelectorsPresent(container: Element, missing: string[]): Promise<void> {\n  missing = missing.filter(sel => !container.querySelector(sel))\n  if (!missing.length) {\n    return Promise.resolve(); // Nothing is missing\n  }\n\n  const promise = new Promise<void>(resolve => new MutationObserver((records, mutation) => {\n    if (records.some(r => r.addedNodes?.length)) {\n      if (missing.every(sel => container.querySelector(sel))) {\n        mutation.disconnect();\n        resolve();\n      }\n    }\n  }).observe(container, {\n    subtree: true,\n    childList: true\n  }));\n\n  /* debugging help: warn if waiting a long time for a selectors to be ready */\n  if (DEBUG) {\n    const stack = new Error().stack?.replace(/^Error/, \"Missing selectors after 5 seconds:\");\n    const warnTimer = setTimeout(() => {\n      console.warn(stack, missing);\n    }, timeOutWarn);\n\n    promise.finally(() => clearTimeout(warnTimer))\n  }\n\n  return promise;\n}\n", "import { isPromiseLike } from './deferred.js';\nimport { Ignore, asyncIterator, defineIterableProperty, isAsyncIter, isAsyncIterator } from './iterators.js';\nimport { WhenParameters, WhenReturn, when } from './when.js';\nimport { DEBUG, console, timeOutWarn } from './debug.js';\nimport type { ChildTags, Constructed, Instance, Overrides, TagCreationOptions, TagCreator, TagCreatorFunction } from './tags.js';\n\n/* Export useful stuff for users of the bundled code */\nexport { when } from './when.js';\nexport type { ChildTags, Instance, TagCreator, TagCreatorFunction } from './tags.js'\nexport * as Iterators from './iterators.js';\n\nexport const UniqueID = Symbol(\"Unique ID\");\n\nconst logNode = DEBUG ? ((n: Node) => `\"${'innerHTML' in n ? n.innerHTML : n.textContent}\"`) : (n: Node) => undefined;\n\n/* A holder for commonProperties specified when `tag(...p)` is invoked, which are always\n  applied (mixed in) when an element is created */\ntype TagFunctionOptions<OtherMembers extends Record<string | symbol, any> = {}> = {\n  commonProperties?: OtherMembers\n  document?: Document\n  /** @deprecated - legacy support */\n  enableOnRemovedFromDOM?: boolean\n}\n\n/* Members applied to EVERY tag created, even base tags */\ninterface PoElementMethods {\n  get ids(): {}\n  when<T extends Element & PoElementMethods, S extends WhenParameters<Exclude<keyof T['ids'], number | symbol>>>(this: T, ...what: S): WhenReturn<S>;\n  // This is a very incomplete type. In practice, set(attrs) requires a deeply partial set of\n  // attributes, in exactly the same way as a TagFunction's first object parameter\n  set attributes(attrs: object);\n  get attributes(): NamedNodeMap\n}\n\n// Support for https://www.npmjs.com/package/htm (or import htm from 'https://cdn.jsdelivr.net/npm/htm/dist/htm.module.js')\n// Note: same signature as React.createElement\nexport interface CreateElement {\n  // Support for htm, JSX, etc\n  createElement(\n    // \"name\" can a HTML tag string, an existing node (just returns itself), or a tag function\n    name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n    // The attributes used to initialise the node (if a string or function - ignore if it's already a node)\n    attrs: any,\n    // The children\n    ...children: ChildTags[]): Node;\n}\n\n/* The interface that creates a set of TagCreators for the specified DOM tags */\nexport interface TagLoader {\n  nodes(...c: ChildTags[]): (Node | (/*P &*/ (Element & PoElementMethods)))[];\n  UniqueID: typeof UniqueID\n\n  /*\n   Signatures for the tag loader. All params are optional in any combination,\n   but must be in order:\n      tag(\n          ?nameSpace?: string,  // absent nameSpace implies HTML\n          ?tags?: string[],     // absent tags defaults to all common HTML tags\n          ?commonProperties?: CommonPropertiesConstraint // absent implies none are defined\n      )\n\n      eg:\n        tags()  // returns TagCreators for all HTML tags\n        tags(['div','button'], { myThing() {} })\n        tags('http://namespace',['Foreign'], { isForeign: true })\n  */\n\n  <Tags extends keyof HTMLElementTagNameMap>(): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap>(tags: Tags[]): { [k in Lowercase<Tags>]: TagCreator<PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends keyof HTMLElementTagNameMap, Q extends {}>(tags: Tags[], options: TagFunctionOptions<Q>): { [k in Lowercase<Tags>]: TagCreator<Q & PoElementMethods & HTMLElementTagNameMap[k]> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: null | undefined | '', tags: Tags[], options?: TagFunctionOptions<Q>): { [k in Tags]: TagCreator<Q & PoElementMethods & HTMLElement> } & CreateElement\n  <Tags extends string, Q extends {}>(nameSpace: string, tags: Tags[], options?: TagFunctionOptions<Q>): Record<string, TagCreator<Q & PoElementMethods & Element>> & CreateElement\n}\n\nlet idCount = 0;\nconst standandTags = [\n  \"a\", \"abbr\", \"address\", \"area\", \"article\", \"aside\", \"audio\", \"b\", \"base\", \"bdi\", \"bdo\", \"blockquote\", \"body\", \"br\", \"button\",\n  \"canvas\", \"caption\", \"cite\", \"code\", \"col\", \"colgroup\", \"data\", \"datalist\", \"dd\", \"del\", \"details\", \"dfn\", \"dialog\", \"div\",\n  \"dl\", \"dt\", \"em\", \"embed\", \"fieldset\", \"figcaption\", \"figure\", \"footer\", \"form\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\",\n  \"header\", \"hgroup\", \"hr\", \"html\", \"i\", \"iframe\", \"img\", \"input\", \"ins\", \"kbd\", \"label\", \"legend\", \"li\", \"link\", \"main\", \"map\",\n  \"mark\", \"menu\", \"meta\", \"meter\", \"nav\", \"noscript\", \"object\", \"ol\", \"optgroup\", \"option\", \"output\", \"p\", \"picture\", \"pre\",\n  \"progress\", \"q\", \"rp\", \"rt\", \"ruby\", \"s\", \"samp\", \"script\", \"search\", \"section\", \"select\", \"slot\", \"small\", \"source\", \"span\",\n  \"strong\", \"style\", \"sub\", \"summary\", \"sup\", \"table\", \"tbody\", \"td\", \"template\", \"textarea\", \"tfoot\", \"th\", \"thead\", \"time\",\n  \"title\", \"tr\", \"track\", \"u\", \"ul\", \"var\", \"video\", \"wbr\"\n] as const;\n\nfunction idsInaccessible(): never {\n  throw new Error(\"<elt>.ids is a read-only map of Elements\")\n}\n\nfunction isChildTag(x: any): x is ChildTags {\n  return typeof x === 'string'\n    || typeof x === 'number'\n    || typeof x === 'boolean'\n    || x instanceof Node\n    || x instanceof NodeList\n    || x instanceof HTMLCollection\n    || x === null\n    || x === undefined\n    // Can't actually test for the contained type, so we assume it's a ChildTag and let it fail at runtime\n    || Array.isArray(x)\n    || isPromiseLike(x)\n    || isAsyncIter(x)\n    || (typeof x === 'object' && Symbol.iterator in x && typeof x[Symbol.iterator] === 'function');\n}\n\n/* tag */\nconst callStackSymbol = Symbol('callStack');\n\nexport const tag = <TagLoader>function <Tags extends string,\n  T1 extends (string | Tags[] | TagFunctionOptions<Q>),\n  T2 extends (Tags[] | TagFunctionOptions<Q>),\n  Q extends {}\n>(\n  _1: T1,\n  _2: T2,\n  _3?: TagFunctionOptions<Q>\n): Record<string, TagCreator<Q & Element>> {\n  type NamespacedElementBase = T1 extends string ? T1 extends '' ? HTMLElement : Element : HTMLElement;\n\n  /* Work out which parameter is which. There are 6 variations:\n    tag()                                           []\n    tag(commonProperties)                           [object]\n    tag(tags[])                                     [string[]]\n    tag(tags[], commonProperties)                   [string[], object]\n    tag(namespace | null, tags[])                   [string | null, string[]]\n    tag(namespace | null, tags[], commonProperties) [string | null, string[], object]\n  */\n  const [nameSpace, tags, options] = (typeof _1 === 'string') || _1 === null\n    ? [_1, _2 as Tags[], _3 as TagFunctionOptions<Q>]\n    : Array.isArray(_1)\n      ? [null, _1 as Tags[], _2 as TagFunctionOptions<Q>]\n      : [null, standandTags, _1 as TagFunctionOptions<Q>];\n\n  const commonProperties = options?.commonProperties;\n  const thisDoc = options?.document ?? globalThis.document;\n\n  const removedNodes = mutationTracker(thisDoc, 'removedNodes', options?.enableOnRemovedFromDOM);\n\n  function DomPromiseContainer() {\n    return thisDoc.createComment(DEBUG\n      ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\"\n      : \"promise\")\n  }\n\n  function DyamicElementError({ error }: { error: Error | IteratorResult<Error> }) {\n    return thisDoc.createComment(error instanceof Error ? error.toString() : 'Error:\\n' + JSON.stringify(error, null, 2));\n  }\n  const poStyleElt = thisDoc.createElement(\"STYLE\");\n  poStyleElt.id = \"--ai-ui-extended-tag-styles-\";\n\n  /* Properties applied to every tag which can be implemented by reference, similar to prototypes */\n  const warned = new Set<string>();\n  const tagPrototypes: PoElementMethods = Object.create(\n    null,\n    {\n      when: {\n        writable: false,\n        configurable: true,\n        enumerable: false,\n        value: function (...what: WhenParameters) {\n          return when(this, ...what)\n        }\n      },\n      attributes: {\n        ...Object.getOwnPropertyDescriptor(Element.prototype, 'attributes'),\n        set(this: Element, a: object) {\n          if (isAsyncIter(a)) {\n            const ai = isAsyncIterator(a) ? a : a[Symbol.asyncIterator]();\n            const step = () => ai.next().then(\n              ({ done, value }) => { assignProps(this, value); done || step() },\n              ex => console.warn(ex));\n            step();\n          }\n          else assignProps(this, a);\n        }\n      },\n      ids: {\n        // .ids is a getter that when invoked for the first time\n        // lazily creates a Proxy that provides live access to children by id\n        configurable: true,\n        enumerable: true,\n        set: idsInaccessible,\n        get(this: Element) {\n          // Now we've been accessed, create the proxy\n          const idProxy = new Proxy(Object.create(null) as Record<string, WeakRef<Element>>, {\n            apply: idsInaccessible,\n            construct: idsInaccessible,\n            defineProperty: idsInaccessible,\n            deleteProperty: idsInaccessible,\n            set: idsInaccessible,\n            setPrototypeOf: idsInaccessible,\n            getPrototypeOf() { return null },\n            isExtensible() { return false },\n            preventExtensions() { return true },\n            getOwnPropertyDescriptor(target, p) {\n              if (this.get!(target, p, null))\n                return Reflect.getOwnPropertyDescriptor(target, p);\n            },\n            has(target, p) {\n              const r = this.get!(target, p, null);\n              return Boolean(r);\n            },\n            ownKeys: (target) => {\n              const ids = [...this.querySelectorAll(`[id]`)].map(e => e.id);\n              const unique = [...new Set(ids)];\n              if (DEBUG && ids.length !== unique.length)\n                console.log(`Element contains multiple, shadowed decendant ids`, unique);\n              return unique;\n            },\n            get: (target, p, receiver) => {\n              if (typeof p === 'string') {\n                // Check if we've cached this ID already\n                if (p in target) {\n                  // Check the element is still contained within this element with the same ID\n                  const ref = target[p].deref();\n                  if (ref && ref.id === p && this.contains(ref))\n                    return ref;\n                  delete target[p];\n                }\n                let e: Element | undefined;\n                if (DEBUG) {\n                  const nl = this.querySelectorAll('#' + CSS.escape(p));\n                  if (nl.length > 1) {\n                    if (!warned.has(p)) {\n                      warned.add(p);\n                      console.log(`Element contains multiple, shadowed decendants with ID \"${p}\"`/*,`\\n\\t${logNode(this)}`*/);\n                    }\n                  }\n                  e = nl[0];\n                } else {\n                  e = this.querySelector('#' + CSS.escape(p)) ?? undefined;\n                }\n                if (e) target[p] = new WeakRef(e);\n                return e;\n              }\n            }\n          });\n          // ..and replace the getter with the Proxy\n          Object.defineProperty(this, 'ids', {\n            configurable: true,\n            enumerable: true,\n            set: idsInaccessible,\n            get() { return idProxy }\n          });\n          // ...and return that from the getter, so subsequent property\n          // accesses go via the Proxy\n          return idProxy;\n        }\n      }\n    }\n  );\n\n  /* Add any user supplied prototypes */\n  if (commonProperties)\n    deepDefine(tagPrototypes, commonProperties);\n\n  function nodes(...c: ChildTags[]) {\n    const appended: Node[] = [];\n    (function children(c: ChildTags): void {\n      if (c === undefined || c === null || c === Ignore)\n        return;\n      if (isPromiseLike(c)) {\n        const g: ChildNode = DomPromiseContainer();\n        appended.push(g);\n        c.then(r => g.replaceWith(...nodes(r)),\n          (x: any) => {\n            console.warn(x, logNode(g));\n            g.replaceWith(DyamicElementError({ error: x }));\n          }\n        );\n        return;\n      }\n      if (c instanceof Node) {\n        appended.push(c);\n        return;\n      }\n\n      // We have an interesting case here where an iterable String is an object with both Symbol.iterator\n      // (inherited from the String prototype) and Symbol.asyncIterator (as it's been augmented by boxed())\n      // but we're only interested in cases like HTMLCollection, NodeList, array, etc., not the fukny ones\n      // It used to be after the isAsyncIter() test, but a non-AsyncIterator *may* also be a sync iterable\n      // For now, we exclude (Symbol.asyncIterator in c) in this case.\n      if (c && typeof c === 'object' && Symbol.iterator in c && !(Symbol.asyncIterator in c) && c[Symbol.iterator]) {\n        for (const d of c) children(d);\n        return;\n      }\n\n      if (isAsyncIter<ChildTags>(c)) {\n        const insertionStack = DEBUG ? ('\\n' + new Error().stack?.replace(/^Error: /, \"Insertion :\")) : '';\n        const ap = isAsyncIterator(c) ? c : c[Symbol.asyncIterator]();\n        // It's possible that this async iterator is a boxed object that also holds a value\n        const unboxed = c.valueOf();\n        const dpm = (unboxed === undefined || unboxed === c) ? [DomPromiseContainer()] : nodes(unboxed as ChildTags)\n\n        let t = dpm.length ? dpm : [DomPromiseContainer()];\n        appended.push(...t);\n        let notYetMounted = true;\n        // DEBUG support\n        let createdAt = Date.now() + timeOutWarn;\n        const createdBy = DEBUG && new Error(\"Created by\").stack;\n\n        const error = (errorValue: any) => {\n          const n = t.filter(n => Boolean(n?.parentNode)) as ChildNode[];\n          if (n.length) {\n            t = [DyamicElementError({ error: errorValue })];\n            n[0].replaceWith(...t);\n            n.slice(1).forEach(e => e?.parentNode!.removeChild(e));\n          }\n          else console.warn(\"Can't report error\", errorValue, createdBy, t.map(logNode));\n          t = [];\n          ap.return?.(errorValue);\n        }\n\n        const update = (es: IteratorResult<ChildTags>) => {\n          if (!es.done) {\n            try {\n              // ChildNode[], since we tested .parentNode\n              const mounted = t.filter(e => e?.parentNode && e.isConnected);\n              const n = notYetMounted ? t : mounted;\n              if (mounted.length) notYetMounted = false;\n\n              if (!n.length || t.every(e => removedNodes(e))) {\n                // We're done - terminate the source quietly (ie this is not an exception as it's expected, but we're done)\n                t = [];\n                const msg = \"Element(s) have been removed from the document: \" + insertionStack;\n                ap.return?.(new Error(msg));\n                return;\n              }\n\n              if (DEBUG && notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Async element not mounted after 5 seconds. If it is never mounted, it will leak.`, createdBy, t.map(logNode));\n              }\n              t = nodes(unbox(es.value) as ChildTags);\n              // If the iterated expression yields no nodes, stuff in a DomPromiseContainer for the next iteration\n              if (!t.length) t.push(DomPromiseContainer());\n              (n[0] as ChildNode).replaceWith(...t);\n              n.slice(1).forEach(e => !t.includes(e) && e.parentNode?.removeChild(e));\n              ap.next().then(update).catch(error);\n            } catch (ex) {\n              // Something went wrong. Terminate the iterator source\n              t = [];\n              ap.return?.(ex);\n            }\n          }\n        }\n        ap.next().then(update).catch(error);\n        return;\n      }\n      appended.push(thisDoc.createTextNode(c.toString()));\n    })(c);\n    return appended;\n  }\n\n  if (!nameSpace) {\n    Object.assign(tag, {\n      nodes,    // Build DOM Node[] from ChildTags\n      UniqueID\n    });\n  }\n\n  /** Just deep copy an object */\n  const plainObjectPrototype = Object.getPrototypeOf({});\n  /** Routine to *define* properties on a dest object from a src object **/\n  function deepDefine(d: Record<string | symbol | number, any>, s: any, declaration?: true): void {\n    if (s === null || s === undefined || typeof s !== 'object' || s === d)\n      return;\n\n    for (const [k, srcDesc] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      try {\n        if ('value' in srcDesc) {\n          const value = srcDesc.value;\n\n          if (value && isAsyncIter<unknown>(value)) {\n            Object.defineProperty(d, k, srcDesc);\n          } else {\n            // This has a real value, which might be an object, so we'll deepDefine it unless it's a\n            // Promise or a function, in which case we just assign it\n            if (value && typeof value === 'object' && !isPromiseLike(value)) {\n              if (!(k in d)) {\n                // If this is a new value in the destination, just define it to be the same value as the source\n                // If the source value is an object, and we're declaring it (therefore it should be a new one), take\n                // a copy so as to not re-use the reference and pollute the declaration. Note: this is probably\n                // a better default for any \"objects\" in a declaration that are plain and not some class type\n                // which can't be copied\n                if (declaration) {\n                  if (Object.getPrototypeOf(value) === plainObjectPrototype || !Object.getPrototypeOf(value)) {\n                    // A plain object can be deep-copied by field\n                    deepDefine(srcDesc.value = {}, value);\n                  } else if (Array.isArray(value)) {\n                    // An array can be deep copied by index\n                    deepDefine(srcDesc.value = [], value);\n                  } else {\n                    // Other object like things (regexps, dates, classes, etc) can't be deep-copied reliably\n                    console.warn(`Declared propety '${k}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`, d, value);\n                  }\n                }\n                Object.defineProperty(d, k, srcDesc);\n              } else {\n                if (value instanceof Node) {\n                  console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or as a child\", k, logNode(value));\n                  d[k] = value;\n                } else {\n                  if (d[k] !== value) {\n                    // Note - if we're copying to an array of different length\n                    // we're decoupling common object references, so we need a clean object to\n                    // assign into\n                    if (Array.isArray(d[k]) && d[k].length !== value.length) {\n                      if (value.constructor === Object || value.constructor === Array) {\n                        deepDefine(d[k] = new (value.constructor), value);\n                      } else {\n                        // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                        d[k] = value;\n                      }\n                    } else {\n                      // This is just a regular object, so we deepDefine recursively\n                      deepDefine(d[k], value);\n                    }\n                  }\n                }\n              }\n            } else {\n              // This is just a primitive value, or a Promise\n              if (s[k] !== undefined)\n                d[k] = s[k];\n            }\n          }\n        } else {\n          // Copy the definition of the getter/setter\n          Object.defineProperty(d, k, srcDesc);\n        }\n      } catch (ex: unknown) {\n        console.warn(\"deepAssign\", k, s[k], ex);\n        throw ex;\n      }\n    }\n  }\n\n  function unbox(a: unknown): unknown {\n    const v = a?.valueOf();\n    return Array.isArray(v) ? Array.prototype.map.call(v, unbox) : v;\n  }\n\n  function assignProps(base: Node, props: Record<string, any>) {\n    // Copy prop hierarchy onto the element via the asssignment operator in order to run setters\n    if (!(callStackSymbol in props)) {\n      (function assign(d: any, s: any): void {\n        if (s === null || s === undefined || typeof s !== 'object')\n          return;\n        // static props before getters/setters\n        const sourceEntries = Object.entries(Object.getOwnPropertyDescriptors(s));\n        if (!Array.isArray(s)) {\n          sourceEntries.sort(a => {\n            const desc = Object.getOwnPropertyDescriptor(d, a[0]);\n            if (desc) {\n              if ('value' in desc) return -1;\n              if ('set' in desc) return 1;\n              if ('get' in desc) return 1;\n            }\n            return 0;\n          });\n        }\n        for (const [k, srcDesc] of sourceEntries) {\n          try {\n            if ('value' in srcDesc) {\n              const value = srcDesc.value;\n              if (isAsyncIter<unknown>(value)) {\n                assignIterable(value, k);\n              } else if (isPromiseLike(value)) {\n                value.then(v => {\n                  if (v && typeof v === 'object') {\n                    // Special case: this promise resolved to an async iterator\n                    if (isAsyncIter<unknown>(v)) {\n                      assignIterable(v, k);\n                    } else {\n                      assignObject(v, k);\n                    }\n                  } else {\n                    if (s[k] !== undefined)\n                      d[k] = v;\n                  }\n                }, error => console.log(\"Failed to set attribute\", error));\n              } else if (!isAsyncIter<unknown>(value)) {\n                // This has a real value, which might be an object\n                if (value && typeof value === 'object' && !isPromiseLike(value))\n                  assignObject(value, k);\n                else {\n                  if (s[k] !== undefined)\n                    d[k] = s[k];\n                }\n              }\n            } else {\n              // Copy the definition of the getter/setter\n              Object.defineProperty(d, k, srcDesc);\n            }\n          } catch (ex: unknown) {\n            console.warn(\"assignProps\", k, s[k], ex);\n            throw ex;\n          }\n        }\n\n        function assignIterable(value: AsyncIterable<unknown> | AsyncIterator<unknown, any, undefined>, k: string) {\n          const ap = asyncIterator(value);\n          let notYetMounted = true;\n          // DEBUG support\n          let createdAt = Date.now() + timeOutWarn;\n          const createdBy = DEBUG && new Error(\"Created by\").stack;\n          const update = (es: IteratorResult<unknown>) => {\n            if (!es.done) {\n              const value = unbox(es.value);\n              if (typeof value === 'object' && value !== null) {\n                /*\n              THIS IS JUST A HACK: `style` has to be set member by member, eg:\n                e.style.color = 'blue'        --- works\n                e.style = { color: 'blue' }   --- doesn't work\n              whereas in general when assigning to property we let the receiver\n              do any work necessary to parse the object. This might be better handled\n              by having a setter for `style` in the PoElementMethods that is sensitive\n              to the type (string|object) being passed so we can just do a straight\n              assignment all the time, or making the decsion based on the location of the\n              property in the prototype chain and assuming anything below \"PO\" must be\n              a primitive\n              */\n                const destDesc = Object.getOwnPropertyDescriptor(d, k);\n                if (k === 'style' || !destDesc?.set)\n                  assign(d[k], value);\n                else\n                  d[k] = value;\n              } else {\n                // Src is not an object (or is null) - just assign it, unless it's undefined\n                if (value !== undefined)\n                  d[k] = value;\n              }\n              const mounted = base.isConnected;\n              // If we have been mounted before, bit aren't now, remove the consumer\n              if (removedNodes(base) || (!notYetMounted && !mounted)) {\n                console.info(`Element does not exist in document when setting async attribute '${k}' to:\\n${logNode(base)}`);\n                ap.return?.();\n                return;\n              }\n              if (mounted) notYetMounted = false;\n              if (notYetMounted && createdAt && createdAt < Date.now()) {\n                createdAt = Number.MAX_SAFE_INTEGER;\n                console.warn(`Element with async attribute '${k}' not mounted after 5 seconds. If it is never mounted, it will leak.\\nElement contains: ${logNode(base)}\\n${createdBy}`);\n              }\n\n              ap.next().then(update).catch(error);\n            }\n          }\n          const error = (errorValue: any) => {\n            console.warn(\"Dynamic attribute error\", errorValue, k, d, createdBy, logNode(base));\n            ap.return?.(errorValue);\n            base.appendChild(DyamicElementError({ error: errorValue }));\n          }\n          const unboxed = value.valueOf();\n          if (unboxed !== undefined && unboxed !== value && !isAsyncIter(unboxed))\n            update({ done: false, value: unboxed });\n          else\n            ap.next().then(update).catch(error);\n        }\n\n        function assignObject(value: any, k: string) {\n          if (value instanceof Node) {\n            console.info(\"Having DOM Nodes as properties of other DOM Nodes is a bad idea as it makes the DOM tree into a cyclic graph. You should reference nodes by ID or via a collection such as .childNodes\", k, logNode(value));\n            d[k] = value;\n          } else {\n            // Note - if we're copying to ourself (or an array of different length),\n            // we're decoupling common object references, so we need a clean object to\n            // assign into\n            if (!(k in d) || d[k] === value || (Array.isArray(d[k]) && d[k].length !== value.length)) {\n              if (value.constructor === Object || value.constructor === Array) {\n                const copy = new (value.constructor);\n                assign(copy, value);\n                d[k] = copy;\n                //assign(d[k], value);\n              } else {\n                // This is some sort of constructed object, which we can't clone, so we have to copy by reference\n                d[k] = value;\n              }\n            } else {\n              if (Object.getOwnPropertyDescriptor(d, k)?.set)\n                d[k] = value;\n\n              else\n                assign(d[k], value);\n            }\n          }\n        }\n      })(base, props);\n    }\n  }\n\n  /*\n  Extend a component class with create a new component class factory:\n      const NewDiv = Div.extended({ overrides })\n          ...or...\n      const NewDic = Div.extended((instance:{ arbitrary-type }) => ({ overrides }))\n         ...later...\n      const eltNewDiv = NewDiv({attrs},...children)\n  */\n\n  type ExtendTagFunction = (attrs: TagCreationOptions & {\n    [callStackSymbol]?: Overrides[];\n    [k: string]: unknown;\n  } | ChildTags, ...children: ChildTags[]) => Element\n\n  interface ExtendTagFunctionInstance extends ExtendTagFunction {\n    super: TagCreator<Element>;\n    definition: Overrides;\n    valueOf: () => string;\n    extended: (this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) => ExtendTagFunctionInstance;\n  }\n\n  function tagHasInstance(this: ExtendTagFunctionInstance, e: any) {\n    for (let c = e.constructor; c; c = c.super) {\n      if (c === this)\n        return true;\n    }\n    return false;\n  }\n\n  function extended(this: TagCreator<Element>, _overrides: Overrides | ((instance?: Instance) => Overrides)) {\n    const instanceDefinition = (typeof _overrides !== 'function')\n      ? (instance: Instance) => Object.assign({}, _overrides, instance)\n      : _overrides\n\n    const uniqueTagID = Date.now().toString(36) + (idCount++).toString(36) + Math.random().toString(36).slice(2);\n    let staticExtensions: Overrides = instanceDefinition({ [UniqueID]: uniqueTagID });\n    /* \"Statically\" create any styles required by this widget */\n    if (staticExtensions.styles) {\n      poStyleElt.appendChild(thisDoc.createTextNode(staticExtensions.styles + '\\n'));\n      if (!thisDoc.head.contains(poStyleElt)) {\n        thisDoc.head.appendChild(poStyleElt);\n      }\n    }\n\n    // \"this\" is the tag we're being extended from, as it's always called as: `(this).extended`\n    // Here's where we actually create the tag, by accumulating all the base attributes and\n    // (finally) assigning those specified by the instantiation\n    const extendTagFn: ExtendTagFunction = (attrs, ...children) => {\n      const noAttrs = isChildTag(attrs);\n      const newCallStack: (Constructed & Overrides)[] = [];\n      const combinedAttrs = { [callStackSymbol]: (noAttrs ? newCallStack : attrs[callStackSymbol]) ?? newCallStack }\n      const e = noAttrs ? this(combinedAttrs, attrs, ...children) : this(combinedAttrs, ...children);\n      e.constructor = extendTag;\n      const tagDefinition = instanceDefinition({ [UniqueID]: uniqueTagID });\n      combinedAttrs[callStackSymbol].push(tagDefinition);\n      if (DEBUG) {\n        // Validate declare and override\n        function isAncestral(creator: TagCreator<Element>, d: string) {\n          for (let f = creator; f; f = f.super)\n            if (f.definition?.declare && d in f.definition.declare) return true;\n          return false;\n        }\n        if (tagDefinition.declare) {\n          const clash = Object.keys(tagDefinition.declare).filter(d => (d in e) || isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Declared keys '${clash}' in ${extendTag.name} already exist in base '${this.valueOf()}'`);\n          }\n        }\n        if (tagDefinition.override) {\n          const clash = Object.keys(tagDefinition.override).filter(d => !(d in e) && !(commonProperties && d in commonProperties) && !isAncestral(this, d));\n          if (clash.length) {\n            console.log(`Overridden keys '${clash}' in ${extendTag.name} do not exist in base '${this.valueOf()}'`);\n          }\n        }\n      }\n      deepDefine(e, tagDefinition.declare, true);\n      deepDefine(e, tagDefinition.override);\n      const reAssign = new Set<string>();\n      tagDefinition.iterable && Object.keys(tagDefinition.iterable).forEach(k => {\n        if (k in e) {\n          console.log(`Ignoring attempt to re-define iterable property \"${k}\" as it could already have consumers`);\n          reAssign.add(k);\n        } else {\n          defineIterableProperty(e, k, tagDefinition.iterable![k as keyof typeof tagDefinition.iterable])\n        }\n      });\n      if (combinedAttrs[callStackSymbol] === newCallStack) {\n        if (!noAttrs)\n          assignProps(e, attrs);\n        for (const base of newCallStack) {\n          const children = base?.constructed?.call(e);\n          if (isChildTag(children)) // technically not necessary, since \"void\" is going to be undefined in 99.9% of cases.\n            e.append(...nodes(children));\n        }\n        // Once the full tree of augmented DOM elements has been constructed, fire all the iterable propeerties\n        // so the full hierarchy gets to consume the initial state, unless they have been assigned\n        // by assignProps from a future\n        const combinedInitialIterableValues = {};\n        let hasInitialValues = false;\n        for (const base of newCallStack) {\n          if (base.iterable) for (const k of Object.keys(base.iterable)) {\n            // We don't self-assign iterables that have themselves been assigned with futures\n            const attrExists = !noAttrs && k in attrs;\n            if ((reAssign.has(k) && attrExists) || !(attrExists && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e]?.valueOf();\n              if (value !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                combinedInitialIterableValues[k] = value;\n                hasInitialValues = true;\n              }\n            }\n          }\n        }\n        if (hasInitialValues)\n          Object.assign(e, combinedInitialIterableValues);\n      }\n      return e;\n    }\n\n    const extendTag: ExtendTagFunctionInstance = Object.assign(extendTagFn, {\n      super: this,\n      definition: Object.assign(staticExtensions, { [UniqueID]: uniqueTagID }),\n      extended,\n      valueOf: () => {\n        const keys = [...Object.keys(staticExtensions.declare || {}), ...Object.keys(staticExtensions.iterable || {})];\n        return `${extendTag.name}: {${keys.join(', ')}}\\n \\u21AA ${this.valueOf()}`\n      }\n    });\n    Object.defineProperty(extendTag, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    const fullProto = {};\n    (function walkProto(creator: TagCreator<Element>) {\n      if (creator?.super)\n        walkProto(creator.super);\n\n      const proto = creator.definition;\n      if (proto) {\n        deepDefine(fullProto, proto?.override);\n        deepDefine(fullProto, proto?.declare);\n      }\n    })(this);\n    deepDefine(fullProto, staticExtensions.override);\n    deepDefine(fullProto, staticExtensions.declare);\n    Object.defineProperties(extendTag, Object.getOwnPropertyDescriptors(fullProto));\n\n    // Attempt to make up a meaningfu;l name for this extended tag\n    const creatorName = fullProto\n      && 'className' in fullProto\n      && typeof fullProto.className === 'string'\n      ? fullProto.className\n      : uniqueTagID;\n    const callSite = DEBUG ? (new Error().stack?.split('\\n')[2] ?? '') : '';\n\n    Object.defineProperty(extendTag, \"name\", {\n      value: \"<ai-\" + creatorName.replace(/\\s+/g, '-') + callSite + \">\"\n    });\n\n    if (DEBUG) {\n      const extraUnknownProps = Object.keys(staticExtensions).filter(k => !['styles', 'ids', 'constructed', 'declare', 'override', 'iterable'].includes(k));\n      if (extraUnknownProps.length) {\n        console.log(`${extendTag.name} defines extraneous keys '${extraUnknownProps}', which are unknown`);\n      }\n    }\n    return extendTag;\n  }\n\n  // @ts-ignore\n  const baseTagCreators: CreateElement & {\n    [K in keyof HTMLElementTagNameMap]?: TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>\n  } & {\n    [n: string]: TagCreator<Q & Element & PoElementMethods>\n  } = {\n    createElement(\n      name: TagCreatorFunction<Element> | Node | keyof HTMLElementTagNameMap,\n      attrs: any,\n      ...children: ChildTags[]): Node {\n      return (name === baseTagCreators.createElement ? nodes(...children)\n        : typeof name === 'function' ? name(attrs, children)\n        : typeof name === 'string' && name in baseTagCreators ?\n        // @ts-ignore: Expression produces a union type that is too complex to represent.ts(2590)\n            baseTagCreators[name](attrs, children)\n        : name instanceof Node ? name\n        : DyamicElementError({ error: new Error(\"Illegal type in createElement:\" + name) })) as Node\n    }\n  }\n\n  function createTag<K extends keyof HTMLElementTagNameMap>(k: K): TagCreator<Q & HTMLElementTagNameMap[K] & PoElementMethods>;\n  function createTag<E extends Element>(k: string): TagCreator<Q & E & PoElementMethods>;\n  function createTag(k: string): TagCreator<Q & NamespacedElementBase & PoElementMethods> {\n    if (baseTagCreators[k])\n      // @ts-ignore\n      return baseTagCreators[k];\n\n    const tagCreator = (attrs: Q & PoElementMethods & TagCreationOptions | ChildTags, ...children: ChildTags[]) => {\n      if (isChildTag(attrs)) {\n        children.unshift(attrs);\n        attrs = {} as any;\n      }\n\n      // This test is always true, but narrows the type of attrs to avoid further errors\n      if (!isChildTag(attrs)) {\n        if (attrs.debugger) {\n          debugger;\n          delete attrs.debugger;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? thisDoc.createElementNS(nameSpace as string, k.toLowerCase())\n          : thisDoc.createElement(k);\n        e.constructor = tagCreator;\n\n        deepDefine(e, tagPrototypes);\n        assignProps(e, attrs);\n\n        // Append any children\n        e.append(...nodes(...children));\n        return e;\n      }\n    }\n\n    const includingExtender = <TagCreator<Element>><unknown>Object.assign(tagCreator, {\n      super: () => { throw new Error(\"Can't invoke native elemenet constructors directly. Use document.createElement().\") },\n      extended, // How to extend this (base) tag\n      valueOf() { return `TagCreator: <${nameSpace || ''}${nameSpace ? '::' : ''}${k}>` }\n    });\n\n    Object.defineProperty(tagCreator, Symbol.hasInstance, {\n      value: tagHasInstance,\n      writable: true,\n      configurable: true\n    })\n\n    Object.defineProperty(tagCreator, \"name\", { value: '<' + k + '>' });\n    // @ts-ignore\n    return baseTagCreators[k] = includingExtender;\n  }\n\n  tags.forEach(createTag);\n\n  // @ts-ignore\n  return baseTagCreators;\n}\n\n/* DOM node removal logic */\ntype PickByType<T, Value> = {\n  [P in keyof T as T[P] extends Value | undefined ? P : never]: T[P]\n}\nfunction mutationTracker(root: Node, track: keyof PickByType<MutationRecord, NodeList>, enableOnRemovedFromDOM?: boolean) {\n  const tracked = new WeakSet<Node>();\n  function walk(nodes: NodeList) {\n    for (const node of nodes) {\n      // In case it's be re-added/moved\n      if ((track === 'addedNodes') === node.isConnected) {\n        walk(node.childNodes);\n        tracked.add(node);\n        // Legacy onRemovedFromDOM support\n        if (enableOnRemovedFromDOM && 'onRemovedFromDOM' in node && typeof node.onRemovedFromDOM === 'function') node.onRemovedFromDOM();\n      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m[track].length) {\n        walk(m[track])\n      }\n    });\n  }).observe(root, { subtree: true, childList: true });\n\n  return function (node: Node) {\n    return tracked.has(node);\n  }\n}\n"],
  "mappings": "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",
  "names": ["v", "a", "result", "ex", "ir", "isMissing", "merged", "unique", "c", "n", "value", "isAncestral", "children"]
}
 diff --git a/module/esm/ai-ui.js b/module/esm/ai-ui.js index 3cec31d..ffaf1b0 100644 --- a/module/esm/ai-ui.js +++ b/module/esm/ai-ui.js @@ -123,9 +123,12 @@ export const tag = function (_1, _2, _3) { }, get: (target, p, receiver) => { if (typeof p === 'string') { + // Check if we've cached this ID already if (p in target) { - if (this.contains(target[p])) - return target[p]; + // Check the element is still contained within this element with the same ID + const ref = target[p].deref(); + if (ref && ref.id === p && this.contains(ref)) + return ref; delete target[p]; } let e; @@ -143,7 +146,7 @@ export const tag = function (_1, _2, _3) { e = this.querySelector('#' + CSS.escape(p)) ?? undefined; } if (e) - target[p] = e; + target[p] = new WeakRef(e); return e; } } diff --git a/module/package.json b/module/package.json index 2ea6599..02d9d82 100644 --- a/module/package.json +++ b/module/package.json @@ -59,5 +59,5 @@ }, "type": "module", "types": "./esm/ai-ui.d.ts", - "version": "0.15.1" + "version": "0.15.2" } diff --git a/module/src/ai-ui.ts b/module/src/ai-ui.ts index 628d262..a96497d 100644 --- a/module/src/ai-ui.ts +++ b/module/src/ai-ui.ts @@ -184,7 +184,7 @@ export const tag = function >, { apply: idsInaccessible, construct: idsInaccessible, defineProperty: idsInaccessible, @@ -211,9 +211,12 @@ export const tag = function { if (typeof p === 'string') { + // Check if we've cached this ID already if (p in target) { - if (this.contains(target[p])) - return target[p]; + // Check the element is still contained within this element with the same ID + const ref = target[p].deref(); + if (ref && ref.id === p && this.contains(ref)) + return ref; delete target[p]; } let e: Element | undefined; @@ -229,7 +232,7 @@ export const tag = function