diff --git a/module/dist/ai-ui.cjs b/module/dist/ai-ui.cjs
index 90e2a0b..cc23f28 100644
--- a/module/dist/ai-ui.cjs
+++ b/module/dist/ai-ui.cjs
@@ -119,11 +119,10 @@ var asyncExtras = {
   }
 };
 var extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)];
-function assignHidden(d, ...srcs) {
-  for (const s of srcs) {
-    for (const [k, pd] of Object.entries(Object.getOwnPropertyDescriptors(s))) {
-      Object.defineProperty(d, k, { ...pd, enumerable: false });
-    }
+function assignHidden(d, s) {
+  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];
+  for (const k of keys) {
+    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });
   }
   return d;
 }
@@ -1523,4 +1522,4 @@ function getElementIdMap(node, ids) {
   }
   return ids;
 }
-//# 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 { ChildTags, Constructed, Instance, Overrides, TagCreator, TagCreatorFunction } from './tags.js';\nimport { DEBUG, console, timeOutWarn } from './debug.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 {} = {}> = {\n  commonProperties: OtherMembers\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  /* also\n  set attributes(...possible attributes); // has to be enclosed by tag() to access assignProps\n  */\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 */\ninterface 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\nconst elementProtype = Object.getOwnPropertyDescriptors({\n  get ids() {\n    return getElementIdMap(this);\n  },\n  set ids(v: any) {\n    throw new Error('Cannot set ids on ' + this.valueOf());\n  },\n  when: function (...what) {\n    return when(this, ...what)\n  }\n} as PoElementMethods & ThisType<Element & PoElementMethods>);\n\nconst poStyleElt = document.createElement(\"STYLE\");\npoStyleElt.id = \"--ai-ui-extended-tag-styles-\";\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 removedNodes = mutationTracker(document,'removedNodes');\n\n  const commonProperties = options?.commonProperties;\n  /* Note: we use property defintion (and not object spread) so getters (like `ids`)\n    are not evaluated until called */\n  const tagPrototypes = Object.create(\n    null,\n    elementProtype\n  );\n\n  // We do this here and not in elementProtype as there's no syntax\n  // to copy a getter/setter pair from another object\n  Object.defineProperty(tagPrototypes, '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\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        appended.push(...dpm);\n\n        let t = dpm;\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); //appendBefore(n[0], ...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?.(error);\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(document.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,b) => {\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 0.5;\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          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:{\n    debugger?: unknown;\n    document?: Document;\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(document.createTextNode(staticExtensions.styles + '\\n'));\n      if (!document.head.contains(poStyleElt)) {\n        document.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      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        } 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        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            if (!(!noAttrs && k in attrs && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e];\n              if (value?.valueOf() !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                e[k] = value;\n              }\n            }\n          }\n        }\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 & Partial<{\n      debugger?: any;\n      document?: Document;\n    }> | ChildTags, ...children: ChildTags[]) => {\n      let doc = document;\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        if (attrs.document) {\n          doc = attrs.document;\n          delete attrs.document;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? doc.createElementNS(nameSpace as string, k.toLowerCase())\n          : doc.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\nfunction DomPromiseContainer() {\n  return document.createComment(DEBUG ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\" : \"promise\")\n}\n\nfunction DyamicElementError({ error }:{ error: Error | IteratorResult<Error>}) {\n  return document.createComment(error instanceof Error ? error.toString() : 'Error:\\n'+JSON.stringify(error,null,2));\n}\n\nexport let enableOnRemovedFromDOM = function () {\n  enableOnRemovedFromDOM = function () {} // Only create the observer once\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList') {\n        m.removedNodes.forEach(\n          removed => removed && removed instanceof Element &&\n            [...removed.getElementsByTagName(\"*\"), removed].filter(elt => !elt.isConnected).forEach(\n              elt => {\n                'onRemovedFromDOM' in elt && typeof elt.onRemovedFromDOM === 'function' && elt.onRemovedFromDOM()\n              }\n            ));\n      }\n    });\n  }).observe(document.body, { subtree: true, childList: true });\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>){\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      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m.removedNodes.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\nconst warned = new Set<string>();\nexport function getElementIdMap(node?: Element | Document, ids?: Record<string, Element>) {\n  node = node || document;\n  ids = ids || Object.create(null);\n  if (node.querySelectorAll) {\n    node.querySelectorAll(\"[id]\").forEach(function (elt) {\n      if (elt.id) {\n        if (!ids![elt.id])\n          ids![elt.id] = elt;\n        else if (DEBUG) {\n          if (!warned.has(elt.id)) {\n            warned.add(elt.id)\n            console.info(\"Shadowed multiple element IDs\", elt.id /*, elt, ids![elt.id]*/);\n          }\n        }\n      }\n    });\n  }\n  return ids;\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)\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args)\n  },\n  info(...args: any) {\n    if (DEBUG) console.debug('(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 declaratiin\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 (not the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts when *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 currently implementation does a one-level 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);\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>>;\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]: (IP[K] extends object ? IterableProperties<IP[K]> : IP[K]) & IterableType<IP[K]>\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 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 (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  if (isAsyncIterator(o)) return o;\n  throw new Error(\"Not as async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nconst 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, ...srcs: S[]) {\n  for (const s of srcs) {\n    for (const [k,pd] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      Object.defineProperty(d, k, {...pd, enumerable: false});\n    }\n  }\n  return d as D & S; \n}\n\nconst queue_pending = Symbol('pending');\nconst queue_items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [queue_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [queue_items]: [] as T[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[queue_items]?.length) {\n        return Promise.resolve({ done: false, value: q[queue_items].shift()! });\n      }\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[queue_pending]!.unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.resolve(value);\n        q[queue_items] = q[queue_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[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.reject(value);\n        q[queue_items] = q[queue_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[queue_items]) return -1; // The queue has no consumers and has terminated.\n      return q[queue_items].length;\n    },\n\n    push(value: T) {\n      if (!q[queue_pending])\n        return false;\n\n      if (q[queue_pending].length) {\n        q[queue_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[queue_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[queue_items].push(value)\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst queue_inflight = Symbol('inflight');\n\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [queue_inflight]: Set<T> };\n  q[queue_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[queue_pending])\n      return false;\n\n    // Debounce\n    if (q[queue_inflight].has(value))\n      return true;\n\n    q[queue_inflight].add(value);\n    if (q[queue_pending].length) {\n      const p = q[queue_pending].pop()!;\n      p.finally(() => q[queue_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[queue_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[queue_items].find(v => v === value)) {\n        q[queue_items].push(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\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] = {\n      value: mi[Symbol.asyncIterator],\n      enumerable: false,\n      writable: false\n    };\n    push = bi.push;\n    extraKeys.forEach(k =>\n      extras[k] = {\n        // @ts-ignore - Fix\n        value: b[k as keyof typeof b],\n        enumerable: false,\n        writable: false\n      }\n    )\n    Object.defineProperties(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 = {\n    [Symbol.asyncIterator]: {\n      enumerable: false,\n      writable: true,\n      value: initIterator\n    }\n  } as HelperDescriptors<V>;\n\n  extraKeys.forEach((k) =>\n    extras[k] = {\n      enumerable: false,\n      writable: true,\n      // @ts-ignore - Fix\n      value: lazyAsyncMethod(k)\n    }\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  if (typeof v === 'object' && v && Iterability in v) {\n    extras[Iterability] = Object.getOwnPropertyDescriptor(v, Iterability)!;\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<unknown> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: 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) {\n            throw new Error(`Iterable \"${name.toString()}\" is already piped from another iterator`)\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: HelperDescriptors<V>): V & AsyncExtraIterable<V> {\n    let boxedObject = Ignore as unknown as (V & AsyncExtraIterable<V> & Partial<Iterability>);\n    if (a === null || a === undefined) {\n      return Object.create(null, {\n        ...pds,\n        valueOf: { value() { return a }, writable: true },\n        toJSON: { value() { return a }, writable: true }\n      });\n    }\n    switch (typeof a) {\n      case 'object':\n        /* TODO: This is problematic as the object might have clashing keys and nested members.\n          The current implementation:\n          * Spreads iterable objects in to a shallow copy of the original object, and overrites clashing members like `map`\n          *     this.iterableObj.map(o => o.field);\n          * The iterator will yield on\n          *     this.iterableObj = newValue;\n\n          * Members access is proxied, so that:\n          *     (set) this.iterableObj.field = newValue;\n          * ...causes the underlying object to yield by re-assignment (therefore calling the setter)\n          * Similarly:\n          *     (get) this.iterableObj.field\n          * ...causes the iterator for the base object to be mapped, like\n          *     this.iterableObject.map(o => o[field])\n        */\n        if (!(Symbol.asyncIterator in a)) {\n          // @ts-expect-error - Ignore is the INITIAL value\n          if (boxedObject === Ignore) {\n            if (DEBUG)\n              console.info(`The iterable property '${name.toString()}' of type \"object\" will be spread to prevent re-initialisation.\\n${new Error().stack?.slice(6)}`);\n            if (Array.isArray(a))\n              boxedObject = Object.defineProperties([...a] as V, pds);\n            else\n              boxedObject = Object.defineProperties({ ...(a as V) }, pds);\n          } else {\n            Object.assign(boxedObject, a);\n          }\n          if (boxedObject[Iterability] === 'shallow') {\n            boxedObject = Object.defineProperties(boxedObject, pds);\n            return boxedObject;\n          }\n\n          // Proxy the result so we can track members of the iterable object\n          const extraBoxed: typeof boxedObject = new Proxy(boxedObject, {\n            deleteProperty(target, key) {\n              if (Reflect.deleteProperty(target, key)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that fires the iterator by re-assigning the iterable via it's setter\n            set(target, key, value, receiver) {\n              if (Reflect.set(target, key, value, receiver)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that returns a mapped iterator for the specified field\n            get(target, key, receiver) {\n              if (key === 'valueOf')\n                return ()=>boxedObject;\n\n              const targetProp = Reflect.getOwnPropertyDescriptor(target,key);\n              // We include `targetProp === undefined` so we can monitor nested properties that aren't actually defined (yet)\n              // Note: this only applies to object iterables (since the root ones aren't proxied), but it does allow us to have\n              // defintions like:\n              //   iterable: { stuff: {} as Record<string, string | number ... }\n              if ((targetProp === undefined && !(key in target)) || targetProp?.enumerable) {\n                if (targetProp === undefined) {\n                  // @ts-ignore - Fix: this \"redefines\" V as having an optional member called `key`\n                  target[key] = undefined;\n                }\n                const realValue = Reflect.get(boxedObject as Exclude<typeof boxedObject, typeof Ignore>, key, receiver);\n                const props = Object.getOwnPropertyDescriptors(\n                    boxedObject.map((o,p) => {\n                    const ov = o?.[key as keyof typeof o]?.valueOf();\n                    const pv = p?.valueOf();\n                    if (typeof ov === typeof pv && ov == pv)\n                      return Ignore;\n                    return ov;\n                  })\n                );\n                (Reflect.ownKeys(props) as (keyof typeof props)[]).forEach(k => props[k].enumerable = false);\n                const aib = box(realValue, props);\n                Reflect.set(target, key, aib);\n                return aib;\n              }\n              return Reflect.get(target, key, receiver);\n            },\n          });\n          return extraBoxed;\n        }\n        return a as (V & AsyncExtraIterable<V>);\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return Object.defineProperties(Object(a), {\n          ...pds,\n          toJSON: { value() { return a.valueOf() }, writable: true }\n        });\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\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  const forever = new Promise<any>(() => { });\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 forever = new Promise<any>(() => {});\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, And = {}, Or = never> =\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): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  let prev: R | typeof Ignore = Ignore;\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 SpecialWhenEvents = {\n  \"@start\": { [k: string]: undefined },  // Always fires when referenced\n  \"@ready\": { [k: string]: undefined }  // 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 Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  const observations = eventObservations.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(eventName)) {\n    document.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.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(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(document.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", "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 { ChildTags, Constructed, Instance, Overrides, TagCreator, TagCreatorFunction } from './tags.js';\nimport { DEBUG, console, timeOutWarn } from './debug.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 {} = {}> = {\n  commonProperties: OtherMembers\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  /* also\n  set attributes(...possible attributes); // has to be enclosed by tag() to access assignProps\n  */\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 */\ninterface 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\nconst elementProtype = Object.getOwnPropertyDescriptors({\n  get ids() {\n    return getElementIdMap(this);\n  },\n  set ids(v: any) {\n    throw new Error('Cannot set ids on ' + this.valueOf());\n  },\n  when: function (...what) {\n    return when(this, ...what)\n  }\n} as PoElementMethods & ThisType<Element & PoElementMethods>);\n\nconst poStyleElt = document.createElement(\"STYLE\");\npoStyleElt.id = \"--ai-ui-extended-tag-styles-\";\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 removedNodes = mutationTracker(document,'removedNodes');\n\n  const commonProperties = options?.commonProperties;\n  /* Note: we use property defintion (and not object spread) so getters (like `ids`)\n    are not evaluated until called */\n  const tagPrototypes = Object.create(\n    null,\n    elementProtype\n  );\n\n  // We do this here and not in elementProtype as there's no syntax\n  // to copy a getter/setter pair from another object\n  Object.defineProperty(tagPrototypes, '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\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        appended.push(...dpm);\n\n        let t = dpm;\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); //appendBefore(n[0], ...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?.(error);\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(document.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,b) => {\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 0.5;\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          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:{\n    debugger?: unknown;\n    document?: Document;\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(document.createTextNode(staticExtensions.styles + '\\n'));\n      if (!document.head.contains(poStyleElt)) {\n        document.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      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        } 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        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            if (!(!noAttrs && k in attrs && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e];\n              if (value?.valueOf() !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                e[k] = value;\n              }\n            }\n          }\n        }\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 & Partial<{\n      debugger?: any;\n      document?: Document;\n    }> | ChildTags, ...children: ChildTags[]) => {\n      let doc = document;\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        if (attrs.document) {\n          doc = attrs.document;\n          delete attrs.document;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? doc.createElementNS(nameSpace as string, k.toLowerCase())\n          : doc.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\nfunction DomPromiseContainer() {\n  return document.createComment(DEBUG ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\" : \"promise\")\n}\n\nfunction DyamicElementError({ error }:{ error: Error | IteratorResult<Error>}) {\n  return document.createComment(error instanceof Error ? error.toString() : 'Error:\\n'+JSON.stringify(error,null,2));\n}\n\nexport let enableOnRemovedFromDOM = function () {\n  enableOnRemovedFromDOM = function () {} // Only create the observer once\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList') {\n        m.removedNodes.forEach(\n          removed => removed && removed instanceof Element &&\n            [...removed.getElementsByTagName(\"*\"), removed].filter(elt => !elt.isConnected).forEach(\n              elt => {\n                'onRemovedFromDOM' in elt && typeof elt.onRemovedFromDOM === 'function' && elt.onRemovedFromDOM()\n              }\n            ));\n      }\n    });\n  }).observe(document.body, { subtree: true, childList: true });\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>){\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      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m.removedNodes.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\nconst warned = new Set<string>();\nexport function getElementIdMap(node?: Element | Document, ids?: Record<string, Element>) {\n  node = node || document;\n  ids = ids || Object.create(null);\n  if (node.querySelectorAll) {\n    node.querySelectorAll(\"[id]\").forEach(function (elt) {\n      if (elt.id) {\n        if (!ids![elt.id])\n          ids![elt.id] = elt;\n        else if (DEBUG) {\n          if (!warned.has(elt.id)) {\n            warned.add(elt.id)\n            console.info(\"Shadowed multiple element IDs\", elt.id /*, elt, ids![elt.id]*/);\n          }\n        }\n      }\n    });\n  }\n  return ids;\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)\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args)\n  },\n  info(...args: any) {\n    if (DEBUG) console.debug('(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 declaratiin\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 (not the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts when *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 currently implementation does a one-level 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);\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>>;\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]: (IP[K] extends object ? IterableProperties<IP[K]> : IP[K]) & IterableType<IP[K]>\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 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 (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  if (isAsyncIterator(o)) return o;\n  throw new Error(\"Not as async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nconst 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 queue_pending = Symbol('pending');\nconst queue_items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [queue_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [queue_items]: [] as T[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[queue_items]?.length) {\n        return Promise.resolve({ done: false, value: q[queue_items].shift()! });\n      }\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[queue_pending]!.unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.resolve(value);\n        q[queue_items] = q[queue_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[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.reject(value);\n        q[queue_items] = q[queue_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[queue_items]) return -1; // The queue has no consumers and has terminated.\n      return q[queue_items].length;\n    },\n\n    push(value: T) {\n      if (!q[queue_pending])\n        return false;\n\n      if (q[queue_pending].length) {\n        q[queue_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[queue_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[queue_items].push(value)\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst queue_inflight = Symbol('inflight');\n\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [queue_inflight]: Set<T> };\n  q[queue_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[queue_pending])\n      return false;\n\n    // Debounce\n    if (q[queue_inflight].has(value))\n      return true;\n\n    q[queue_inflight].add(value);\n    if (q[queue_pending].length) {\n      const p = q[queue_pending].pop()!;\n      p.finally(() => q[queue_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[queue_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[queue_items].find(v => v === value)) {\n        q[queue_items].push(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\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] = {\n      value: mi[Symbol.asyncIterator],\n      enumerable: false,\n      writable: false\n    };\n    push = bi.push;\n    extraKeys.forEach(k =>\n      extras[k] = {\n        // @ts-ignore - Fix\n        value: b[k as keyof typeof b],\n        enumerable: false,\n        writable: false\n      }\n    )\n    Object.defineProperties(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 = {\n    [Symbol.asyncIterator]: {\n      enumerable: false,\n      writable: true,\n      value: initIterator\n    }\n  } as HelperDescriptors<V>;\n\n  extraKeys.forEach((k) =>\n    extras[k] = {\n      enumerable: false,\n      writable: true,\n      // @ts-ignore - Fix\n      value: lazyAsyncMethod(k)\n    }\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  if (typeof v === 'object' && v && Iterability in v) {\n    extras[Iterability] = Object.getOwnPropertyDescriptor(v, Iterability)!;\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<unknown> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: 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) {\n            throw new Error(`Iterable \"${name.toString()}\" is already piped from another iterator`)\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: HelperDescriptors<V>): V & AsyncExtraIterable<V> {\n    let boxedObject = Ignore as unknown as (V & AsyncExtraIterable<V> & Partial<Iterability>);\n    if (a === null || a === undefined) {\n      return Object.create(null, {\n        ...pds,\n        valueOf: { value() { return a }, writable: true },\n        toJSON: { value() { return a }, writable: true }\n      });\n    }\n    switch (typeof a) {\n      case 'object':\n        /* TODO: This is problematic as the object might have clashing keys and nested members.\n          The current implementation:\n          * Spreads iterable objects in to a shallow copy of the original object, and overrites clashing members like `map`\n          *     this.iterableObj.map(o => o.field);\n          * The iterator will yield on\n          *     this.iterableObj = newValue;\n\n          * Members access is proxied, so that:\n          *     (set) this.iterableObj.field = newValue;\n          * ...causes the underlying object to yield by re-assignment (therefore calling the setter)\n          * Similarly:\n          *     (get) this.iterableObj.field\n          * ...causes the iterator for the base object to be mapped, like\n          *     this.iterableObject.map(o => o[field])\n        */\n        if (!(Symbol.asyncIterator in a)) {\n          // @ts-expect-error - Ignore is the INITIAL value\n          if (boxedObject === Ignore) {\n            if (DEBUG)\n              console.info(`The iterable property '${name.toString()}' of type \"object\" will be spread to prevent re-initialisation.\\n${new Error().stack?.slice(6)}`);\n            if (Array.isArray(a))\n              boxedObject = Object.defineProperties([...a] as V, pds);\n            else\n              boxedObject = Object.defineProperties({ ...(a as V) }, pds);\n          } else {\n            Object.assign(boxedObject, a);\n          }\n          if (boxedObject[Iterability] === 'shallow') {\n            boxedObject = Object.defineProperties(boxedObject, pds);\n            return boxedObject;\n          }\n\n          // Proxy the result so we can track members of the iterable object\n          const extraBoxed: typeof boxedObject = new Proxy(boxedObject, {\n            deleteProperty(target, key) {\n              if (Reflect.deleteProperty(target, key)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that fires the iterator by re-assigning the iterable via it's setter\n            set(target, key, value, receiver) {\n              if (Reflect.set(target, key, value, receiver)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that returns a mapped iterator for the specified field\n            get(target, key, receiver) {\n              if (key === 'valueOf')\n                return ()=>boxedObject;\n\n              const targetProp = Reflect.getOwnPropertyDescriptor(target,key);\n              // We include `targetProp === undefined` so we can monitor nested properties that aren't actually defined (yet)\n              // Note: this only applies to object iterables (since the root ones aren't proxied), but it does allow us to have\n              // defintions like:\n              //   iterable: { stuff: {} as Record<string, string | number ... }\n              if ((targetProp === undefined && !(key in target)) || targetProp?.enumerable) {\n                if (targetProp === undefined) {\n                  // @ts-ignore - Fix: this \"redefines\" V as having an optional member called `key`\n                  target[key] = undefined;\n                }\n                const realValue = Reflect.get(boxedObject as Exclude<typeof boxedObject, typeof Ignore>, key, receiver);\n                const props = Object.getOwnPropertyDescriptors(\n                    boxedObject.map((o,p) => {\n                    const ov = o?.[key as keyof typeof o]?.valueOf();\n                    const pv = p?.valueOf();\n                    if (typeof ov === typeof pv && ov == pv)\n                      return Ignore;\n                    return ov;\n                  })\n                );\n                (Reflect.ownKeys(props) as (keyof typeof props)[]).forEach(k => props[k].enumerable = false);\n                const aib = box(realValue, props);\n                Reflect.set(target, key, aib);\n                return aib;\n              }\n              return Reflect.get(target, key, receiver);\n            },\n          });\n          return extraBoxed;\n        }\n        return a as (V & AsyncExtraIterable<V>);\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return Object.defineProperties(Object(a), {\n          ...pds,\n          toJSON: { value() { return a.valueOf() }, writable: true }\n        });\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\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  const forever = new Promise<any>(() => { });\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 forever = new Promise<any>(() => {});\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, And = {}, Or = never> =\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): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  let prev: R | typeof Ignore = Ignore;\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 SpecialWhenEvents = {\n  \"@start\": { [k: string]: undefined },  // Always fires when referenced\n  \"@ready\": { [k: string]: undefined }  // 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 Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  const observations = eventObservations.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(eventName)) {\n    document.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.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(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(document.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", "c", "n", "value", "isAncestral", "children"]
}

diff --git a/module/dist/ai-ui.js b/module/dist/ai-ui.js
index 10ceaf2..7d33ac3 100644
--- a/module/dist/ai-ui.js
+++ b/module/dist/ai-ui.js
@@ -119,11 +119,10 @@ var AIUI = (() => {
     }
   };
   var extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)];
-  function assignHidden(d, ...srcs) {
-    for (const s of srcs) {
-      for (const [k, pd] of Object.entries(Object.getOwnPropertyDescriptors(s))) {
-        Object.defineProperty(d, k, { ...pd, enumerable: false });
-      }
+  function assignHidden(d, s) {
+    const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];
+    for (const k of keys) {
+      Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });
     }
     return d;
   }
@@ -1525,4 +1524,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 { ChildTags, Constructed, Instance, Overrides, TagCreator, TagCreatorFunction } from './tags.js';\nimport { DEBUG, console, timeOutWarn } from './debug.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 {} = {}> = {\n  commonProperties: OtherMembers\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  /* also\n  set attributes(...possible attributes); // has to be enclosed by tag() to access assignProps\n  */\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 */\ninterface 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\nconst elementProtype = Object.getOwnPropertyDescriptors({\n  get ids() {\n    return getElementIdMap(this);\n  },\n  set ids(v: any) {\n    throw new Error('Cannot set ids on ' + this.valueOf());\n  },\n  when: function (...what) {\n    return when(this, ...what)\n  }\n} as PoElementMethods & ThisType<Element & PoElementMethods>);\n\nconst poStyleElt = document.createElement(\"STYLE\");\npoStyleElt.id = \"--ai-ui-extended-tag-styles-\";\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 removedNodes = mutationTracker(document,'removedNodes');\n\n  const commonProperties = options?.commonProperties;\n  /* Note: we use property defintion (and not object spread) so getters (like `ids`)\n    are not evaluated until called */\n  const tagPrototypes = Object.create(\n    null,\n    elementProtype\n  );\n\n  // We do this here and not in elementProtype as there's no syntax\n  // to copy a getter/setter pair from another object\n  Object.defineProperty(tagPrototypes, '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\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        appended.push(...dpm);\n\n        let t = dpm;\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); //appendBefore(n[0], ...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?.(error);\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(document.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,b) => {\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 0.5;\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          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:{\n    debugger?: unknown;\n    document?: Document;\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(document.createTextNode(staticExtensions.styles + '\\n'));\n      if (!document.head.contains(poStyleElt)) {\n        document.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      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        } 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        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            if (!(!noAttrs && k in attrs && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e];\n              if (value?.valueOf() !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                e[k] = value;\n              }\n            }\n          }\n        }\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 & Partial<{\n      debugger?: any;\n      document?: Document;\n    }> | ChildTags, ...children: ChildTags[]) => {\n      let doc = document;\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        if (attrs.document) {\n          doc = attrs.document;\n          delete attrs.document;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? doc.createElementNS(nameSpace as string, k.toLowerCase())\n          : doc.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\nfunction DomPromiseContainer() {\n  return document.createComment(DEBUG ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\" : \"promise\")\n}\n\nfunction DyamicElementError({ error }:{ error: Error | IteratorResult<Error>}) {\n  return document.createComment(error instanceof Error ? error.toString() : 'Error:\\n'+JSON.stringify(error,null,2));\n}\n\nexport let enableOnRemovedFromDOM = function () {\n  enableOnRemovedFromDOM = function () {} // Only create the observer once\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList') {\n        m.removedNodes.forEach(\n          removed => removed && removed instanceof Element &&\n            [...removed.getElementsByTagName(\"*\"), removed].filter(elt => !elt.isConnected).forEach(\n              elt => {\n                'onRemovedFromDOM' in elt && typeof elt.onRemovedFromDOM === 'function' && elt.onRemovedFromDOM()\n              }\n            ));\n      }\n    });\n  }).observe(document.body, { subtree: true, childList: true });\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>){\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      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m.removedNodes.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\nconst warned = new Set<string>();\nexport function getElementIdMap(node?: Element | Document, ids?: Record<string, Element>) {\n  node = node || document;\n  ids = ids || Object.create(null);\n  if (node.querySelectorAll) {\n    node.querySelectorAll(\"[id]\").forEach(function (elt) {\n      if (elt.id) {\n        if (!ids![elt.id])\n          ids![elt.id] = elt;\n        else if (DEBUG) {\n          if (!warned.has(elt.id)) {\n            warned.add(elt.id)\n            console.info(\"Shadowed multiple element IDs\", elt.id /*, elt, ids![elt.id]*/);\n          }\n        }\n      }\n    });\n  }\n  return ids;\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)\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args)\n  },\n  info(...args: any) {\n    if (DEBUG) console.debug('(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 declaratiin\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 (not the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts when *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 currently implementation does a one-level 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);\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>>;\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]: (IP[K] extends object ? IterableProperties<IP[K]> : IP[K]) & IterableType<IP[K]>\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 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 (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  if (isAsyncIterator(o)) return o;\n  throw new Error(\"Not as async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nconst 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, ...srcs: S[]) {\n  for (const s of srcs) {\n    for (const [k,pd] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      Object.defineProperty(d, k, {...pd, enumerable: false});\n    }\n  }\n  return d as D & S; \n}\n\nconst queue_pending = Symbol('pending');\nconst queue_items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [queue_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [queue_items]: [] as T[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[queue_items]?.length) {\n        return Promise.resolve({ done: false, value: q[queue_items].shift()! });\n      }\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[queue_pending]!.unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.resolve(value);\n        q[queue_items] = q[queue_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[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.reject(value);\n        q[queue_items] = q[queue_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[queue_items]) return -1; // The queue has no consumers and has terminated.\n      return q[queue_items].length;\n    },\n\n    push(value: T) {\n      if (!q[queue_pending])\n        return false;\n\n      if (q[queue_pending].length) {\n        q[queue_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[queue_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[queue_items].push(value)\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst queue_inflight = Symbol('inflight');\n\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [queue_inflight]: Set<T> };\n  q[queue_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[queue_pending])\n      return false;\n\n    // Debounce\n    if (q[queue_inflight].has(value))\n      return true;\n\n    q[queue_inflight].add(value);\n    if (q[queue_pending].length) {\n      const p = q[queue_pending].pop()!;\n      p.finally(() => q[queue_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[queue_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[queue_items].find(v => v === value)) {\n        q[queue_items].push(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\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] = {\n      value: mi[Symbol.asyncIterator],\n      enumerable: false,\n      writable: false\n    };\n    push = bi.push;\n    extraKeys.forEach(k =>\n      extras[k] = {\n        // @ts-ignore - Fix\n        value: b[k as keyof typeof b],\n        enumerable: false,\n        writable: false\n      }\n    )\n    Object.defineProperties(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 = {\n    [Symbol.asyncIterator]: {\n      enumerable: false,\n      writable: true,\n      value: initIterator\n    }\n  } as HelperDescriptors<V>;\n\n  extraKeys.forEach((k) =>\n    extras[k] = {\n      enumerable: false,\n      writable: true,\n      // @ts-ignore - Fix\n      value: lazyAsyncMethod(k)\n    }\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  if (typeof v === 'object' && v && Iterability in v) {\n    extras[Iterability] = Object.getOwnPropertyDescriptor(v, Iterability)!;\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<unknown> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: 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) {\n            throw new Error(`Iterable \"${name.toString()}\" is already piped from another iterator`)\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: HelperDescriptors<V>): V & AsyncExtraIterable<V> {\n    let boxedObject = Ignore as unknown as (V & AsyncExtraIterable<V> & Partial<Iterability>);\n    if (a === null || a === undefined) {\n      return Object.create(null, {\n        ...pds,\n        valueOf: { value() { return a }, writable: true },\n        toJSON: { value() { return a }, writable: true }\n      });\n    }\n    switch (typeof a) {\n      case 'object':\n        /* TODO: This is problematic as the object might have clashing keys and nested members.\n          The current implementation:\n          * Spreads iterable objects in to a shallow copy of the original object, and overrites clashing members like `map`\n          *     this.iterableObj.map(o => o.field);\n          * The iterator will yield on\n          *     this.iterableObj = newValue;\n\n          * Members access is proxied, so that:\n          *     (set) this.iterableObj.field = newValue;\n          * ...causes the underlying object to yield by re-assignment (therefore calling the setter)\n          * Similarly:\n          *     (get) this.iterableObj.field\n          * ...causes the iterator for the base object to be mapped, like\n          *     this.iterableObject.map(o => o[field])\n        */\n        if (!(Symbol.asyncIterator in a)) {\n          // @ts-expect-error - Ignore is the INITIAL value\n          if (boxedObject === Ignore) {\n            if (DEBUG)\n              console.info(`The iterable property '${name.toString()}' of type \"object\" will be spread to prevent re-initialisation.\\n${new Error().stack?.slice(6)}`);\n            if (Array.isArray(a))\n              boxedObject = Object.defineProperties([...a] as V, pds);\n            else\n              boxedObject = Object.defineProperties({ ...(a as V) }, pds);\n          } else {\n            Object.assign(boxedObject, a);\n          }\n          if (boxedObject[Iterability] === 'shallow') {\n            boxedObject = Object.defineProperties(boxedObject, pds);\n            return boxedObject;\n          }\n\n          // Proxy the result so we can track members of the iterable object\n          const extraBoxed: typeof boxedObject = new Proxy(boxedObject, {\n            deleteProperty(target, key) {\n              if (Reflect.deleteProperty(target, key)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that fires the iterator by re-assigning the iterable via it's setter\n            set(target, key, value, receiver) {\n              if (Reflect.set(target, key, value, receiver)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that returns a mapped iterator for the specified field\n            get(target, key, receiver) {\n              if (key === 'valueOf')\n                return ()=>boxedObject;\n\n              const targetProp = Reflect.getOwnPropertyDescriptor(target,key);\n              // We include `targetProp === undefined` so we can monitor nested properties that aren't actually defined (yet)\n              // Note: this only applies to object iterables (since the root ones aren't proxied), but it does allow us to have\n              // defintions like:\n              //   iterable: { stuff: {} as Record<string, string | number ... }\n              if ((targetProp === undefined && !(key in target)) || targetProp?.enumerable) {\n                if (targetProp === undefined) {\n                  // @ts-ignore - Fix: this \"redefines\" V as having an optional member called `key`\n                  target[key] = undefined;\n                }\n                const realValue = Reflect.get(boxedObject as Exclude<typeof boxedObject, typeof Ignore>, key, receiver);\n                const props = Object.getOwnPropertyDescriptors(\n                    boxedObject.map((o,p) => {\n                    const ov = o?.[key as keyof typeof o]?.valueOf();\n                    const pv = p?.valueOf();\n                    if (typeof ov === typeof pv && ov == pv)\n                      return Ignore;\n                    return ov;\n                  })\n                );\n                (Reflect.ownKeys(props) as (keyof typeof props)[]).forEach(k => props[k].enumerable = false);\n                const aib = box(realValue, props);\n                Reflect.set(target, key, aib);\n                return aib;\n              }\n              return Reflect.get(target, key, receiver);\n            },\n          });\n          return extraBoxed;\n        }\n        return a as (V & AsyncExtraIterable<V>);\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return Object.defineProperties(Object(a), {\n          ...pds,\n          toJSON: { value() { return a.valueOf() }, writable: true }\n        });\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\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  const forever = new Promise<any>(() => { });\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 forever = new Promise<any>(() => {});\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, And = {}, Or = never> =\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): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  let prev: R | typeof Ignore = Ignore;\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 SpecialWhenEvents = {\n  \"@start\": { [k: string]: undefined },  // Always fires when referenced\n  \"@ready\": { [k: string]: undefined }  // 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 Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  const observations = eventObservations.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(eventName)) {\n    document.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.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(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(document.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", "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 { ChildTags, Constructed, Instance, Overrides, TagCreator, TagCreatorFunction } from './tags.js';\nimport { DEBUG, console, timeOutWarn } from './debug.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 {} = {}> = {\n  commonProperties: OtherMembers\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  /* also\n  set attributes(...possible attributes); // has to be enclosed by tag() to access assignProps\n  */\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 */\ninterface 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\nconst elementProtype = Object.getOwnPropertyDescriptors({\n  get ids() {\n    return getElementIdMap(this);\n  },\n  set ids(v: any) {\n    throw new Error('Cannot set ids on ' + this.valueOf());\n  },\n  when: function (...what) {\n    return when(this, ...what)\n  }\n} as PoElementMethods & ThisType<Element & PoElementMethods>);\n\nconst poStyleElt = document.createElement(\"STYLE\");\npoStyleElt.id = \"--ai-ui-extended-tag-styles-\";\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 removedNodes = mutationTracker(document,'removedNodes');\n\n  const commonProperties = options?.commonProperties;\n  /* Note: we use property defintion (and not object spread) so getters (like `ids`)\n    are not evaluated until called */\n  const tagPrototypes = Object.create(\n    null,\n    elementProtype\n  );\n\n  // We do this here and not in elementProtype as there's no syntax\n  // to copy a getter/setter pair from another object\n  Object.defineProperty(tagPrototypes, '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\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        appended.push(...dpm);\n\n        let t = dpm;\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); //appendBefore(n[0], ...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?.(error);\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(document.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,b) => {\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 0.5;\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          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:{\n    debugger?: unknown;\n    document?: Document;\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(document.createTextNode(staticExtensions.styles + '\\n'));\n      if (!document.head.contains(poStyleElt)) {\n        document.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      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        } 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        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            if (!(!noAttrs && k in attrs && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e];\n              if (value?.valueOf() !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                e[k] = value;\n              }\n            }\n          }\n        }\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 & Partial<{\n      debugger?: any;\n      document?: Document;\n    }> | ChildTags, ...children: ChildTags[]) => {\n      let doc = document;\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        if (attrs.document) {\n          doc = attrs.document;\n          delete attrs.document;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? doc.createElementNS(nameSpace as string, k.toLowerCase())\n          : doc.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\nfunction DomPromiseContainer() {\n  return document.createComment(DEBUG ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\" : \"promise\")\n}\n\nfunction DyamicElementError({ error }:{ error: Error | IteratorResult<Error>}) {\n  return document.createComment(error instanceof Error ? error.toString() : 'Error:\\n'+JSON.stringify(error,null,2));\n}\n\nexport let enableOnRemovedFromDOM = function () {\n  enableOnRemovedFromDOM = function () {} // Only create the observer once\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList') {\n        m.removedNodes.forEach(\n          removed => removed && removed instanceof Element &&\n            [...removed.getElementsByTagName(\"*\"), removed].filter(elt => !elt.isConnected).forEach(\n              elt => {\n                'onRemovedFromDOM' in elt && typeof elt.onRemovedFromDOM === 'function' && elt.onRemovedFromDOM()\n              }\n            ));\n      }\n    });\n  }).observe(document.body, { subtree: true, childList: true });\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>){\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      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m.removedNodes.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\nconst warned = new Set<string>();\nexport function getElementIdMap(node?: Element | Document, ids?: Record<string, Element>) {\n  node = node || document;\n  ids = ids || Object.create(null);\n  if (node.querySelectorAll) {\n    node.querySelectorAll(\"[id]\").forEach(function (elt) {\n      if (elt.id) {\n        if (!ids![elt.id])\n          ids![elt.id] = elt;\n        else if (DEBUG) {\n          if (!warned.has(elt.id)) {\n            warned.add(elt.id)\n            console.info(\"Shadowed multiple element IDs\", elt.id /*, elt, ids![elt.id]*/);\n          }\n        }\n      }\n    });\n  }\n  return ids;\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)\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args)\n  },\n  info(...args: any) {\n    if (DEBUG) console.debug('(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 declaratiin\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 (not the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts when *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 currently implementation does a one-level 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);\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>>;\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]: (IP[K] extends object ? IterableProperties<IP[K]> : IP[K]) & IterableType<IP[K]>\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 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 (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  if (isAsyncIterator(o)) return o;\n  throw new Error(\"Not as async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nconst 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 queue_pending = Symbol('pending');\nconst queue_items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [queue_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [queue_items]: [] as T[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[queue_items]?.length) {\n        return Promise.resolve({ done: false, value: q[queue_items].shift()! });\n      }\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[queue_pending]!.unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.resolve(value);\n        q[queue_items] = q[queue_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[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.reject(value);\n        q[queue_items] = q[queue_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[queue_items]) return -1; // The queue has no consumers and has terminated.\n      return q[queue_items].length;\n    },\n\n    push(value: T) {\n      if (!q[queue_pending])\n        return false;\n\n      if (q[queue_pending].length) {\n        q[queue_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[queue_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[queue_items].push(value)\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst queue_inflight = Symbol('inflight');\n\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [queue_inflight]: Set<T> };\n  q[queue_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[queue_pending])\n      return false;\n\n    // Debounce\n    if (q[queue_inflight].has(value))\n      return true;\n\n    q[queue_inflight].add(value);\n    if (q[queue_pending].length) {\n      const p = q[queue_pending].pop()!;\n      p.finally(() => q[queue_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[queue_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[queue_items].find(v => v === value)) {\n        q[queue_items].push(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\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] = {\n      value: mi[Symbol.asyncIterator],\n      enumerable: false,\n      writable: false\n    };\n    push = bi.push;\n    extraKeys.forEach(k =>\n      extras[k] = {\n        // @ts-ignore - Fix\n        value: b[k as keyof typeof b],\n        enumerable: false,\n        writable: false\n      }\n    )\n    Object.defineProperties(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 = {\n    [Symbol.asyncIterator]: {\n      enumerable: false,\n      writable: true,\n      value: initIterator\n    }\n  } as HelperDescriptors<V>;\n\n  extraKeys.forEach((k) =>\n    extras[k] = {\n      enumerable: false,\n      writable: true,\n      // @ts-ignore - Fix\n      value: lazyAsyncMethod(k)\n    }\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  if (typeof v === 'object' && v && Iterability in v) {\n    extras[Iterability] = Object.getOwnPropertyDescriptor(v, Iterability)!;\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<unknown> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: 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) {\n            throw new Error(`Iterable \"${name.toString()}\" is already piped from another iterator`)\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: HelperDescriptors<V>): V & AsyncExtraIterable<V> {\n    let boxedObject = Ignore as unknown as (V & AsyncExtraIterable<V> & Partial<Iterability>);\n    if (a === null || a === undefined) {\n      return Object.create(null, {\n        ...pds,\n        valueOf: { value() { return a }, writable: true },\n        toJSON: { value() { return a }, writable: true }\n      });\n    }\n    switch (typeof a) {\n      case 'object':\n        /* TODO: This is problematic as the object might have clashing keys and nested members.\n          The current implementation:\n          * Spreads iterable objects in to a shallow copy of the original object, and overrites clashing members like `map`\n          *     this.iterableObj.map(o => o.field);\n          * The iterator will yield on\n          *     this.iterableObj = newValue;\n\n          * Members access is proxied, so that:\n          *     (set) this.iterableObj.field = newValue;\n          * ...causes the underlying object to yield by re-assignment (therefore calling the setter)\n          * Similarly:\n          *     (get) this.iterableObj.field\n          * ...causes the iterator for the base object to be mapped, like\n          *     this.iterableObject.map(o => o[field])\n        */\n        if (!(Symbol.asyncIterator in a)) {\n          // @ts-expect-error - Ignore is the INITIAL value\n          if (boxedObject === Ignore) {\n            if (DEBUG)\n              console.info(`The iterable property '${name.toString()}' of type \"object\" will be spread to prevent re-initialisation.\\n${new Error().stack?.slice(6)}`);\n            if (Array.isArray(a))\n              boxedObject = Object.defineProperties([...a] as V, pds);\n            else\n              boxedObject = Object.defineProperties({ ...(a as V) }, pds);\n          } else {\n            Object.assign(boxedObject, a);\n          }\n          if (boxedObject[Iterability] === 'shallow') {\n            boxedObject = Object.defineProperties(boxedObject, pds);\n            return boxedObject;\n          }\n\n          // Proxy the result so we can track members of the iterable object\n          const extraBoxed: typeof boxedObject = new Proxy(boxedObject, {\n            deleteProperty(target, key) {\n              if (Reflect.deleteProperty(target, key)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that fires the iterator by re-assigning the iterable via it's setter\n            set(target, key, value, receiver) {\n              if (Reflect.set(target, key, value, receiver)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that returns a mapped iterator for the specified field\n            get(target, key, receiver) {\n              if (key === 'valueOf')\n                return ()=>boxedObject;\n\n              const targetProp = Reflect.getOwnPropertyDescriptor(target,key);\n              // We include `targetProp === undefined` so we can monitor nested properties that aren't actually defined (yet)\n              // Note: this only applies to object iterables (since the root ones aren't proxied), but it does allow us to have\n              // defintions like:\n              //   iterable: { stuff: {} as Record<string, string | number ... }\n              if ((targetProp === undefined && !(key in target)) || targetProp?.enumerable) {\n                if (targetProp === undefined) {\n                  // @ts-ignore - Fix: this \"redefines\" V as having an optional member called `key`\n                  target[key] = undefined;\n                }\n                const realValue = Reflect.get(boxedObject as Exclude<typeof boxedObject, typeof Ignore>, key, receiver);\n                const props = Object.getOwnPropertyDescriptors(\n                    boxedObject.map((o,p) => {\n                    const ov = o?.[key as keyof typeof o]?.valueOf();\n                    const pv = p?.valueOf();\n                    if (typeof ov === typeof pv && ov == pv)\n                      return Ignore;\n                    return ov;\n                  })\n                );\n                (Reflect.ownKeys(props) as (keyof typeof props)[]).forEach(k => props[k].enumerable = false);\n                const aib = box(realValue, props);\n                Reflect.set(target, key, aib);\n                return aib;\n              }\n              return Reflect.get(target, key, receiver);\n            },\n          });\n          return extraBoxed;\n        }\n        return a as (V & AsyncExtraIterable<V>);\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return Object.defineProperties(Object(a), {\n          ...pds,\n          toJSON: { value() { return a.valueOf() }, writable: true }\n        });\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\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  const forever = new Promise<any>(() => { });\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 forever = new Promise<any>(() => {});\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, And = {}, Or = never> =\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): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  let prev: R | typeof Ignore = Ignore;\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 SpecialWhenEvents = {\n  \"@start\": { [k: string]: undefined },  // Always fires when referenced\n  \"@ready\": { [k: string]: undefined }  // 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 Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  const observations = eventObservations.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(eventName)) {\n    document.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.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(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(document.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", "c", "n", "value", "isAncestral", "children"]
}

diff --git a/module/dist/ai-ui.min.cjs b/module/dist/ai-ui.min.cjs
index cf0cb7b..ebab268 100644
--- a/module/dist/ai-ui.min.cjs
+++ b/module/dist/ai-ui.min.cjs
@@ -1,12 +1,12 @@
-"use strict";var ce=Object.defineProperty;var Re=Object.getOwnPropertyDescriptor;var He=Object.getOwnPropertyNames;var Le=Object.prototype.hasOwnProperty;var ve=(e,t)=>{for(var n in t)ce(e,n,{get:t[n],enumerable:!0})},Ue=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let u of He(t))!Le.call(e,u)&&u!==n&&ce(e,u,{get:()=>t[u],enumerable:!(r=Re(t,u))||r.enumerable});return e};var We=e=>Ue(ce({},"__esModule",{value:!0}),e);var it={};ve(it,{Iterators:()=>me,UniqueID:()=>ne,enableOnRemovedFromDOM:()=>De,getElementIdMap:()=>je,tag:()=>Ne,when:()=>ae});module.exports=We(it);var O=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var J=5e3,E={log(...e){O&&console.log("(AI-UI) LOG:",...e)},warn(...e){O&&console.warn("(AI-UI) WARN:",...e)},info(...e){O&&console.debug("(AI-UI) INFO:",...e)}};var xe=e=>{};function ue(){let e=xe,t=xe,n=new Promise((...r)=>[e,t]=r);if(n.resolve=e,n.reject=t,O){let r=new Error().stack;n.catch(u=>u instanceof Error||u?.value instanceof Error?E.log("Deferred rejection",u,"allocated at ",r):void 0)}return n}function de(e){return e&&typeof e=="object"||typeof e=="function"}function $(e){return de(e)&&"then"in e&&typeof e.then=="function"}var me={};ve(me,{Ignore:()=>N,Iterability:()=>X,asyncIterator:()=>ye,augmentGlobalAsyncGenerators:()=>Xe,combine:()=>Ae,debounceQueueIteratableIterator:()=>we,defineIterableProperty:()=>be,filterMap:()=>V,generatorHelpers:()=>Qe,isAsyncIter:()=>G,isAsyncIterable:()=>_,isAsyncIterator:()=>Y,iterableHelpers:()=>W,merge:()=>z,queueIteratableIterator:()=>pe});var X=Symbol("Iterability");function Y(e){return typeof e?.next=="function"}function _(e){return de(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function G(e){return _(e)||Y(e)}function ye(e){if(_(e))return e[Symbol.asyncIterator]();if(Y(e))return e;throw new Error("Not as async provider")}var oe={filterMap(e,t=N){return V(this,e,t)},map:qe,filter:Ke,unique:Be,waitFor:Ze,multi:Je,initially:Ye,consume:Se,merge(...e){return z(this,...e)},combine(e){return Ae(Object.assign({_this:this},e))}},fe=[...Object.getOwnPropertySymbols(oe),...Object.keys(oe)];function $e(e,...t){for(let n of t)for(let[r,u]of Object.entries(Object.getOwnPropertyDescriptors(n)))Object.defineProperty(e,r,{...u,enumerable:!1});return e}var C=Symbol("pending"),U=Symbol("items");function Pe(e=()=>{}){let t={[C]:[],[U]:[],[Symbol.asyncIterator](){return t},next(){if(t[U]?.length)return Promise.resolve({done:!1,value:t[U].shift()});let n=ue();return n.catch(r=>{}),t[C].unshift(n),n},return(n){let r={done:!0,value:void 0};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().resolve(r);t[U]=t[C]=null}return Promise.resolve(r)},throw(...n){let r={done:!0,value:n[0]};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().reject(r);t[U]=t[C]=null}return Promise.reject(r)},get length(){return t[U]?t[U].length:-1},push(n){return t[C]?(t[C].length?t[C].pop().resolve({done:!1,value:n}):t[U]?t[U].push(n):E.log("Discarding queue push as there are no consumers"),!0):!1}};return W(t)}var re=Symbol("inflight");function Fe(e=()=>{}){let t=Pe(e);return t[re]=new Set,t.push=function(n){if(!t[C])return!1;if(t[re].has(n))return!0;if(t[re].add(n),t[C].length){let r=t[C].pop();r.finally(()=>t[re].delete(n)),r.resolve({done:!1,value:n})}else t[U]?t[U].find(r=>r===n)||t[U].push(n):E.log("Discarding queue push as there are no consumers");return!0},t}var pe=Pe,we=Fe;function be(e,t,n){let r=()=>{r=()=>v;let a=we(),g=a.multi(),v=g[Symbol.asyncIterator]();return s[Symbol.asyncIterator]={value:g[Symbol.asyncIterator],enumerable:!1,writable:!1},f=a.push,fe.forEach(Q=>s[Q]={value:v[Q],enumerable:!1,writable:!1}),Object.defineProperties(m,s),v};function u(a){return{[a]:function(...g){return r(),m[a].apply(this,g)}}[a]}let s={[Symbol.asyncIterator]:{enumerable:!1,writable:!0,value:r}};fe.forEach(a=>s[a]={enumerable:!1,writable:!0,value:u(a)});let f=a=>(r(),f(a));typeof n=="object"&&n&&X in n&&(s[X]=Object.getOwnPropertyDescriptor(n,X));let m=d(n,s),i;return Object.defineProperty(e,t,{get(){return m},set(a){if(a!==m)if(_(a)){if(i===a)return;i=a;let g=O?new Error:void 0;O&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),Se.call(a,v=>{if(a!==i)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:g});f(v?.valueOf())}).catch(v=>E.info(v)).finally(()=>a===i&&(i=void 0));return}else{if(i)throw new Error(`Iterable "${t.toString()}" is already piped from another iterator`);m=d(a,s)}f(a?.valueOf())},enumerable:!0}),e;function d(a,g){let v=N;if(a==null)return Object.create(null,{...g,valueOf:{value(){return a},writable:!0},toJSON:{value(){return a},writable:!0}});switch(typeof a){case"object":return Symbol.asyncIterator in a?a:(v===N?(O&&E.info(`The iterable property '${t.toString()}' of type "object" will be spread to prevent re-initialisation.
-${new Error().stack?.slice(6)}`),Array.isArray(a)?v=Object.defineProperties([...a],g):v=Object.defineProperties({...a},g)):Object.assign(v,a),v[X]==="shallow"?(v=Object.defineProperties(v,g),v):new Proxy(v,{deleteProperty(H,D){return Reflect.deleteProperty(H,D)?(f(e[t]),!0):!1},set(H,D,L,K){return Reflect.set(H,D,L,K)?(f(e[t]),!0):!1},get(H,D,L){if(D==="valueOf")return()=>v;let K=Reflect.getOwnPropertyDescriptor(H,D);if(K===void 0&&!(D in H)||K?.enumerable){K===void 0&&(H[D]=void 0);let l=Reflect.get(v,D,L),b=Object.getOwnPropertyDescriptors(v.map((o,I)=>{let c=o?.[D]?.valueOf(),x=I?.valueOf();return typeof c==typeof x&&c==x?N:c}));Reflect.ownKeys(b).forEach(o=>b[o].enumerable=!1);let P=d(l,b);return Reflect.set(H,D,P),P}return Reflect.get(H,D,L)}}));case"bigint":case"boolean":case"number":case"string":return Object.defineProperties(Object(a),{...g,toJSON:{value(){return a.valueOf()},writable:!0}})}throw new TypeError('Iterable properties cannot be of type "'+typeof a+'"')}}var z=(...e)=>{let t=new Array(e.length),n=new Array(e.length),r=()=>{r=()=>{};for(let i=0;i<e.length;i++){let d=e[i];n[i]=(t[i]=Symbol.asyncIterator in d?d[Symbol.asyncIterator]():d).next().then(a=>({idx:i,result:a}))}},u=[],s=new Promise(()=>{}),f=n.length,m={[Symbol.asyncIterator](){return m},next(){return r(),f?Promise.race(n).then(({idx:i,result:d})=>d.done?(f--,n[i]=s,u[i]=d.value,m.next()):(n[i]=t[i]?t[i].next().then(a=>({idx:i,result:a})).catch(a=>({idx:i,result:{done:!0,value:a}})):Promise.resolve({idx:i,result:{done:!0,value:void 0}}),d)).catch(i=>m.throw?.(i)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:u})},async return(i){for(let d=0;d<t.length;d++)n[d]!==s&&(n[d]=s,u[d]=await t[d]?.return?.({done:!0,value:i}).then(a=>a.value,a=>a));return{done:!0,value:u}},async throw(i){for(let d=0;d<t.length;d++)n[d]!==s&&(n[d]=s,u[d]=await t[d]?.throw?.(i).then(a=>a.value,a=>a));return{done:!0,value:u}}};return W(m)},Ae=(e,t={})=>{let n={},r,u=[],s=0,f=new Promise(()=>{}),m={[Symbol.asyncIterator](){return m},next(){return r===void 0&&(r=Object.entries(e).map(([i,d],a)=>(s+=1,u[a]=d[Symbol.asyncIterator](),u[a].next().then(g=>({si:u,idx:a,k:i,ir:g}))))),function i(){return Promise.race(r).then(({idx:d,k:a,ir:g})=>g.done?(r[d]=f,s-=1,s?i():{done:!0,value:void 0}):(n[a]=g.value,r[d]=u[d].next().then(v=>({idx:d,k:a,ir:v})),t.ignorePartial&&Object.keys(n).length<Object.keys(e).length?i():{done:!1,value:n}))}()},return(i){return r.forEach((d,a)=>{d!==f&&u[a].return?.(i)}),Promise.resolve({done:!0,value:i})},throw(i){return r.forEach((d,a)=>{d!==f&&u[a].throw?.(i)}),Promise.reject({done:!0,value:i})}};return W(m)};function Ge(e){return _(e)&&fe.every(t=>t in e&&e[t]===oe[t])}function W(e){return Ge(e)||$e(e,oe),e}function Qe(e){return function(...t){let n=e(...t);return W(n)}}async function Se(e){let t;for await(let n of this)t=e?.(n);await t}var N=Symbol("Ignore");function Ve(e,t,n){if($(e))return e.then(t,n);try{return t(e)}catch(r){return n(r)}}function V(e,t,n=N){let r,u=N,s={[Symbol.asyncIterator](){return s},next(...f){if(n!==N){let m=Promise.resolve({done:!1,value:n});return n=N,m}return new Promise(function m(i,d){r||(r=e[Symbol.asyncIterator]()),r.next(...f).then(a=>a.done?i(a):Ve(t(a.value,u),g=>g===N?m(i,d):i({done:!1,value:u=g}),g=>{r.throw?r.throw(g):r.return?.(g),d({done:!0,value:g})}),a=>d({done:!0,value:a})).catch(a=>{r.throw?r.throw(a):r.return?.(a),d({done:!0,value:a})})})},throw(f){return Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){return Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function qe(e){return V(this,e)}function Ke(e){return V(this,async t=>await e(t)?t:N)}function Be(e){return e?V(this,async(t,n)=>n===N||await e(t,n)?t:N):V(this,(t,n)=>t===n?N:t)}function Ye(e){return V(this,t=>t,e)}function Ze(e){return V(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function Je(){let e=this,t=0,n,r;function u(f){f&&n.resolve(f),f?.done||(n=ue(),r.next().then(u).catch(m=>n.reject({done:!0,value:m})))}let s={[Symbol.asyncIterator](){return t+=1,s},next(){return r||(r=e[Symbol.asyncIterator](),u()),n},throw(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function Xe(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){W(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var ee=new Map;function _e(e){let t=ee.get(e.type);if(t)for(let n of t)try{let{push:r,terminate:u,container:s,selector:f}=n;if(s.isConnected){if(e.target instanceof Node)if(f){let m=s.querySelectorAll(f);for(let i of m)(e.target===i||i.contains(e.target))&&s.contains(i)&&r(e)}else(e.target===s||s.contains(e.target))&&r(e)}else{let m="Container `#"+s.id+">"+(f||"")+"` removed from DOM. Removing subscription";t.delete(n),u(new Error(m))}}catch(r){E.warn("docEventHandler",r)}}function he(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function Te(e){let t=e.split(":");if(t.length===1)return he(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&he(t[1])&&!he(t[0]))return[t[1],t[0]]}function ze(e){throw new Error(e)}function ge(e,t){let[n,r]=Te(t)??ze("Invalid WhenSelector: "+t);ee.has(r)||(document.addEventListener(r,_e,{passive:!0,capture:!0}),ee.set(r,new Set));let u=pe(()=>ee.get(r)?.delete(s)),s={push:u.push,terminate(f){u.return?.(f)},container:e,selector:n||null};return Me(e,n?[n]:void 0).then(f=>ee.get(r).add(s)),u.multi()}async function*Oe(){await new Promise(()=>{}),yield void 0}function Ie(e){function t(n){return e.map(n)}return Object.assign(W(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function et(e){if(!e)throw new Error(`Falsy async source will never be ready
+"use strict";var ce=Object.defineProperty;var Re=Object.getOwnPropertyDescriptor;var He=Object.getOwnPropertyNames;var Le=Object.prototype.hasOwnProperty;var ve=(e,t)=>{for(var n in t)ce(e,n,{get:t[n],enumerable:!0})},Ue=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let u of He(t))!Le.call(e,u)&&u!==n&&ce(e,u,{get:()=>t[u],enumerable:!(r=Re(t,u))||r.enumerable});return e};var We=e=>Ue(ce({},"__esModule",{value:!0}),e);var it={};ve(it,{Iterators:()=>me,UniqueID:()=>ne,enableOnRemovedFromDOM:()=>je,getElementIdMap:()=>De,tag:()=>Ne,when:()=>ae});module.exports=We(it);var O=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var J=5e3,E={log(...e){O&&console.log("(AI-UI) LOG:",...e)},warn(...e){O&&console.warn("(AI-UI) WARN:",...e)},info(...e){O&&console.debug("(AI-UI) INFO:",...e)}};var xe=e=>{};function ue(){let e=xe,t=xe,n=new Promise((...r)=>[e,t]=r);if(n.resolve=e,n.reject=t,O){let r=new Error().stack;n.catch(u=>u instanceof Error||u?.value instanceof Error?E.log("Deferred rejection",u,"allocated at ",r):void 0)}return n}function de(e){return e&&typeof e=="object"||typeof e=="function"}function $(e){return de(e)&&"then"in e&&typeof e.then=="function"}var me={};ve(me,{Ignore:()=>N,Iterability:()=>X,asyncIterator:()=>ye,augmentGlobalAsyncGenerators:()=>Xe,combine:()=>Ae,debounceQueueIteratableIterator:()=>we,defineIterableProperty:()=>be,filterMap:()=>V,generatorHelpers:()=>Qe,isAsyncIter:()=>G,isAsyncIterable:()=>_,isAsyncIterator:()=>Y,iterableHelpers:()=>W,merge:()=>z,queueIteratableIterator:()=>pe});var X=Symbol("Iterability");function Y(e){return typeof e?.next=="function"}function _(e){return de(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function G(e){return _(e)||Y(e)}function ye(e){if(_(e))return e[Symbol.asyncIterator]();if(Y(e))return e;throw new Error("Not as async provider")}var oe={filterMap(e,t=N){return V(this,e,t)},map:qe,filter:Ke,unique:Be,waitFor:Ze,multi:Je,initially:Ye,consume:Se,merge(...e){return z(this,...e)},combine(e){return Ae(Object.assign({_this:this},e))}},fe=[...Object.getOwnPropertySymbols(oe),...Object.keys(oe)];function $e(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let r of n)Object.defineProperty(e,r,{...Object.getOwnPropertyDescriptor(t,r),enumerable:!1});return e}var C=Symbol("pending"),U=Symbol("items");function Pe(e=()=>{}){let t={[C]:[],[U]:[],[Symbol.asyncIterator](){return t},next(){if(t[U]?.length)return Promise.resolve({done:!1,value:t[U].shift()});let n=ue();return n.catch(r=>{}),t[C].unshift(n),n},return(n){let r={done:!0,value:void 0};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().resolve(r);t[U]=t[C]=null}return Promise.resolve(r)},throw(...n){let r={done:!0,value:n[0]};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().reject(r);t[U]=t[C]=null}return Promise.reject(r)},get length(){return t[U]?t[U].length:-1},push(n){return t[C]?(t[C].length?t[C].pop().resolve({done:!1,value:n}):t[U]?t[U].push(n):E.log("Discarding queue push as there are no consumers"),!0):!1}};return W(t)}var re=Symbol("inflight");function Fe(e=()=>{}){let t=Pe(e);return t[re]=new Set,t.push=function(n){if(!t[C])return!1;if(t[re].has(n))return!0;if(t[re].add(n),t[C].length){let r=t[C].pop();r.finally(()=>t[re].delete(n)),r.resolve({done:!1,value:n})}else t[U]?t[U].find(r=>r===n)||t[U].push(n):E.log("Discarding queue push as there are no consumers");return!0},t}var pe=Pe,we=Fe;function be(e,t,n){let r=()=>{r=()=>v;let a=we(),g=a.multi(),v=g[Symbol.asyncIterator]();return s[Symbol.asyncIterator]={value:g[Symbol.asyncIterator],enumerable:!1,writable:!1},f=a.push,fe.forEach(Q=>s[Q]={value:v[Q],enumerable:!1,writable:!1}),Object.defineProperties(m,s),v};function u(a){return{[a]:function(...g){return r(),m[a].apply(this,g)}}[a]}let s={[Symbol.asyncIterator]:{enumerable:!1,writable:!0,value:r}};fe.forEach(a=>s[a]={enumerable:!1,writable:!0,value:u(a)});let f=a=>(r(),f(a));typeof n=="object"&&n&&X in n&&(s[X]=Object.getOwnPropertyDescriptor(n,X));let m=d(n,s),i;return Object.defineProperty(e,t,{get(){return m},set(a){if(a!==m)if(_(a)){if(i===a)return;i=a;let g=O?new Error:void 0;O&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),Se.call(a,v=>{if(a!==i)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:g});f(v?.valueOf())}).catch(v=>E.info(v)).finally(()=>a===i&&(i=void 0));return}else{if(i)throw new Error(`Iterable "${t.toString()}" is already piped from another iterator`);m=d(a,s)}f(a?.valueOf())},enumerable:!0}),e;function d(a,g){let v=N;if(a==null)return Object.create(null,{...g,valueOf:{value(){return a},writable:!0},toJSON:{value(){return a},writable:!0}});switch(typeof a){case"object":return Symbol.asyncIterator in a?a:(v===N?(O&&E.info(`The iterable property '${t.toString()}' of type "object" will be spread to prevent re-initialisation.
+${new Error().stack?.slice(6)}`),Array.isArray(a)?v=Object.defineProperties([...a],g):v=Object.defineProperties({...a},g)):Object.assign(v,a),v[X]==="shallow"?(v=Object.defineProperties(v,g),v):new Proxy(v,{deleteProperty(H,j){return Reflect.deleteProperty(H,j)?(f(e[t]),!0):!1},set(H,j,L,K){return Reflect.set(H,j,L,K)?(f(e[t]),!0):!1},get(H,j,L){if(j==="valueOf")return()=>v;let K=Reflect.getOwnPropertyDescriptor(H,j);if(K===void 0&&!(j in H)||K?.enumerable){K===void 0&&(H[j]=void 0);let l=Reflect.get(v,j,L),b=Object.getOwnPropertyDescriptors(v.map((o,I)=>{let c=o?.[j]?.valueOf(),x=I?.valueOf();return typeof c==typeof x&&c==x?N:c}));Reflect.ownKeys(b).forEach(o=>b[o].enumerable=!1);let P=d(l,b);return Reflect.set(H,j,P),P}return Reflect.get(H,j,L)}}));case"bigint":case"boolean":case"number":case"string":return Object.defineProperties(Object(a),{...g,toJSON:{value(){return a.valueOf()},writable:!0}})}throw new TypeError('Iterable properties cannot be of type "'+typeof a+'"')}}var z=(...e)=>{let t=new Array(e.length),n=new Array(e.length),r=()=>{r=()=>{};for(let i=0;i<e.length;i++){let d=e[i];n[i]=(t[i]=Symbol.asyncIterator in d?d[Symbol.asyncIterator]():d).next().then(a=>({idx:i,result:a}))}},u=[],s=new Promise(()=>{}),f=n.length,m={[Symbol.asyncIterator](){return m},next(){return r(),f?Promise.race(n).then(({idx:i,result:d})=>d.done?(f--,n[i]=s,u[i]=d.value,m.next()):(n[i]=t[i]?t[i].next().then(a=>({idx:i,result:a})).catch(a=>({idx:i,result:{done:!0,value:a}})):Promise.resolve({idx:i,result:{done:!0,value:void 0}}),d)).catch(i=>m.throw?.(i)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:u})},async return(i){for(let d=0;d<t.length;d++)n[d]!==s&&(n[d]=s,u[d]=await t[d]?.return?.({done:!0,value:i}).then(a=>a.value,a=>a));return{done:!0,value:u}},async throw(i){for(let d=0;d<t.length;d++)n[d]!==s&&(n[d]=s,u[d]=await t[d]?.throw?.(i).then(a=>a.value,a=>a));return{done:!0,value:u}}};return W(m)},Ae=(e,t={})=>{let n={},r,u=[],s=0,f=new Promise(()=>{}),m={[Symbol.asyncIterator](){return m},next(){return r===void 0&&(r=Object.entries(e).map(([i,d],a)=>(s+=1,u[a]=d[Symbol.asyncIterator](),u[a].next().then(g=>({si:u,idx:a,k:i,ir:g}))))),function i(){return Promise.race(r).then(({idx:d,k:a,ir:g})=>g.done?(r[d]=f,s-=1,s?i():{done:!0,value:void 0}):(n[a]=g.value,r[d]=u[d].next().then(v=>({idx:d,k:a,ir:v})),t.ignorePartial&&Object.keys(n).length<Object.keys(e).length?i():{done:!1,value:n}))}()},return(i){return r.forEach((d,a)=>{d!==f&&u[a].return?.(i)}),Promise.resolve({done:!0,value:i})},throw(i){return r.forEach((d,a)=>{d!==f&&u[a].throw?.(i)}),Promise.reject({done:!0,value:i})}};return W(m)};function Ge(e){return _(e)&&fe.every(t=>t in e&&e[t]===oe[t])}function W(e){return Ge(e)||$e(e,oe),e}function Qe(e){return function(...t){let n=e(...t);return W(n)}}async function Se(e){let t;for await(let n of this)t=e?.(n);await t}var N=Symbol("Ignore");function Ve(e,t,n){if($(e))return e.then(t,n);try{return t(e)}catch(r){return n(r)}}function V(e,t,n=N){let r,u=N,s={[Symbol.asyncIterator](){return s},next(...f){if(n!==N){let m=Promise.resolve({done:!1,value:n});return n=N,m}return new Promise(function m(i,d){r||(r=e[Symbol.asyncIterator]()),r.next(...f).then(a=>a.done?i(a):Ve(t(a.value,u),g=>g===N?m(i,d):i({done:!1,value:u=g}),g=>{r.throw?r.throw(g):r.return?.(g),d({done:!0,value:g})}),a=>d({done:!0,value:a})).catch(a=>{r.throw?r.throw(a):r.return?.(a),d({done:!0,value:a})})})},throw(f){return Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){return Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function qe(e){return V(this,e)}function Ke(e){return V(this,async t=>await e(t)?t:N)}function Be(e){return e?V(this,async(t,n)=>n===N||await e(t,n)?t:N):V(this,(t,n)=>t===n?N:t)}function Ye(e){return V(this,t=>t,e)}function Ze(e){return V(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function Je(){let e=this,t=0,n,r;function u(f){f&&n.resolve(f),f?.done||(n=ue(),r.next().then(u).catch(m=>n.reject({done:!0,value:m})))}let s={[Symbol.asyncIterator](){return t+=1,s},next(){return r||(r=e[Symbol.asyncIterator](),u()),n},throw(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function Xe(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){W(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var ee=new Map;function _e(e){let t=ee.get(e.type);if(t)for(let n of t)try{let{push:r,terminate:u,container:s,selector:f}=n;if(s.isConnected){if(e.target instanceof Node)if(f){let m=s.querySelectorAll(f);for(let i of m)(e.target===i||i.contains(e.target))&&s.contains(i)&&r(e)}else(e.target===s||s.contains(e.target))&&r(e)}else{let m="Container `#"+s.id+">"+(f||"")+"` removed from DOM. Removing subscription";t.delete(n),u(new Error(m))}}catch(r){E.warn("docEventHandler",r)}}function he(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function Te(e){let t=e.split(":");if(t.length===1)return he(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&he(t[1])&&!he(t[0]))return[t[1],t[0]]}function ze(e){throw new Error(e)}function ge(e,t){let[n,r]=Te(t)??ze("Invalid WhenSelector: "+t);ee.has(r)||(document.addEventListener(r,_e,{passive:!0,capture:!0}),ee.set(r,new Set));let u=pe(()=>ee.get(r)?.delete(s)),s={push:u.push,terminate(f){u.return?.(f)},container:e,selector:n||null};return Me(e,n?[n]:void 0).then(f=>ee.get(r).add(s)),u.multi()}async function*Oe(){await new Promise(()=>{}),yield void 0}function Ie(e){function t(n){return e.map(n)}return Object.assign(W(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function et(e){if(!e)throw new Error(`Falsy async source will never be ready
 
-`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!Te(e)}async function*tt(e){yield e}function ae(e,...t){if(!t||t.length===0)return Ie(ge(e,"change"));let n=t.filter(s=>typeof s!="string"||s[0]!=="@").map(s=>typeof s=="string"?ge(e,s):s instanceof Element?ge(s,"change"):$(s)?tt(s):s);if(t.includes("@start")){let s={[Symbol.asyncIterator]:()=>s,next(){return s.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(s)}if(t.includes("@ready")){let f=function(a){return typeof a=="string"&&!e.querySelector(a)};var u=f;let m=t.filter(et).map(a=>Te(a)?.[0]).filter(f),i,d={[Symbol.asyncIterator](){return d},throw(a){return i?.throw?i.throw(a):Promise.resolve({done:!0,value:a})},return(a){return i?.return?i.return(a):Promise.resolve({done:!0,value:a})},next(){return i?i.next():Me(e,m).then(()=>(i=(n.length>1?z(...n):n.length===1?n[0]:Oe())[Symbol.asyncIterator](),i?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Ie(W(d))}let r=n.length>1?z(...n):n.length===1?n[0]:Oe();return Ie(W(r))}function ke(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,r)=>{n.some(u=>u.addedNodes?.length)&&e.isConnected&&(r.disconnect(),t())}).observe(document.body,{subtree:!0,childList:!0}))}function Me(e,t){return t?.length?Promise.all([nt(e,t),ke(e)]):ke(e)}function nt(e,t){if(t=t.filter(r=>!e.querySelector(r)),!t.length)return Promise.resolve();let n=new Promise(r=>new MutationObserver((u,s)=>{u.some(f=>f.addedNodes?.length)&&t.every(f=>e.querySelector(f))&&(s.disconnect(),r())}).observe(e,{subtree:!0,childList:!0}));if(O){let r=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),u=setTimeout(()=>{E.warn(r,t)},J);n.finally(()=>clearTimeout(u))}return n}var ne=Symbol("Unique ID"),q=O?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},rt=0,ot=["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"],at=Object.getOwnPropertyDescriptors({get ids(){return je(this)},set ids(e){throw new Error("Cannot set ids on "+this.valueOf())},when:function(...e){return ae(this,...e)}}),le=document.createElement("STYLE");le.id="--ai-ui-extended-tag-styles-";function se(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)||$(e)||G(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var te=Symbol("callStack"),Ne=function(e,t,n){let[r,u,s]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,ot,e],f=st(document,"removedNodes"),m=s?.commonProperties,i=Object.create(null,at);Object.defineProperty(i,"attributes",{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(l){if(G(l)){let b=Y(l)?l:l[Symbol.asyncIterator](),P=()=>b.next().then(({done:o,value:I})=>{Q(this,I),o||P()},o=>E.warn(o));P()}else Q(this,l)}}),m&&g(i,m);function d(...l){let b=[];return function P(o){if(!(o==null||o===N)){if($(o)){let I=Ee();b.push(I),o.then(c=>I.replaceWith(...d(c)),c=>{E.warn(c,q(I)),I.replaceWith(ie({error:c}))});return}if(o instanceof Node){b.push(o);return}if(o&&typeof o=="object"&&Symbol.iterator in o&&!(Symbol.asyncIterator in o)&&o[Symbol.iterator]){for(let I of o)P(I);return}if(G(o)){let I=O?`
-`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",c=Y(o)?o:o[Symbol.asyncIterator](),x=o.valueOf(),B=x===void 0||x===o?[Ee()]:d(x);b.push(...B);let y=B,p=!0,h=Date.now()+J,w=O&&new Error("Created by").stack,j=A=>{let S=y.filter(M=>!!M?.parentNode);S.length?(y=[ie({error:A})],S[0].replaceWith(...y),S.slice(1).forEach(M=>M?.parentNode.removeChild(M))):E.warn("Can't report error",A,w,y.map(q)),y=[],c.return?.(j)},F=A=>{if(!A.done)try{let S=y.filter(T=>T?.parentNode&&T.isConnected),M=p?y:S;if(S.length&&(p=!1),!M.length||y.every(T=>f(T))){y=[];let T="Element(s) have been removed from the document: "+I;c.return?.(new Error(T));return}O&&p&&h&&h<Date.now()&&(h=Number.MAX_SAFE_INTEGER,E.warn("Async element not mounted after 5 seconds. If it is never mounted, it will leak.",w,y.map(q))),y=d(v(A.value)),y.length||y.push(Ee()),M[0].replaceWith(...y),M.slice(1).forEach(T=>!y.includes(T)&&T.parentNode?.removeChild(T)),c.next().then(F).catch(j)}catch(S){y=[],c.return?.(S)}};c.next().then(F).catch(j);return}b.push(document.createTextNode(o.toString()))}}(l),b}r||Object.assign(Ne,{nodes:d,UniqueID:ne});let a=Object.getPrototypeOf({});function g(l,b,P){if(!(b==null||typeof b!="object"||b===l))for(let[o,I]of Object.entries(Object.getOwnPropertyDescriptors(b)))try{if("value"in I){let c=I.value;c&&G(c)?Object.defineProperty(l,o,I):c&&typeof c=="object"&&!$(c)?o in l?c 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",o,q(c)),l[o]=c):l[o]!==c&&(Array.isArray(l[o])&&l[o].length!==c.length?c.constructor===Object||c.constructor===Array?g(l[o]=new c.constructor,c):l[o]=c:g(l[o],c)):(P&&(Object.getPrototypeOf(c)===a||!Object.getPrototypeOf(c)?g(I.value={},c):Array.isArray(c)?g(I.value=[],c):E.warn(`Declared propety '${o}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,l,c)),Object.defineProperty(l,o,I)):b[o]!==void 0&&(l[o]=b[o])}else Object.defineProperty(l,o,I)}catch(c){throw E.warn("deepAssign",o,b[o],c),c}}function v(l){let b=l?.valueOf();return Array.isArray(b)?Array.prototype.map.call(b,v):b}function Q(l,b){te in b||function P(o,I){if(I==null||typeof I!="object")return;let c=Object.entries(Object.getOwnPropertyDescriptors(I));Array.isArray(I)||c.sort((y,p)=>{let h=Object.getOwnPropertyDescriptor(o,y[0]);if(h){if("value"in h)return-1;if("set"in h)return 1;if("get"in h)return .5}return 0});for(let[y,p]of c)try{if("value"in p){let h=p.value;G(h)?x(h,y):$(h)?h.then(w=>{w&&typeof w=="object"?G(w)?x(w,y):B(w,y):I[y]!==void 0&&(o[y]=w)},w=>E.log("Failed to set attribute",w)):G(h)||(h&&typeof h=="object"&&!$(h)?B(h,y):I[y]!==void 0&&(o[y]=I[y]))}else Object.defineProperty(o,y,p)}catch(h){throw E.warn("assignProps",y,I[y],h),h}function x(y,p){let h=ye(y),w=!0,j=Date.now()+J,F=O&&new Error("Created by").stack,A=M=>{if(!M.done){let T=v(M.value);if(typeof T=="object"&&T!==null){let R=Object.getOwnPropertyDescriptor(o,p);p==="style"||!R?.set?P(o[p],T):o[p]=T}else T!==void 0&&(o[p]=T);let k=l.isConnected;if(f(l)||!w&&!k){E.info(`Element does not exist in document when setting async attribute '${p}' to:
-${q(l)}`),h.return?.();return}k&&(w=!1),w&&j&&j<Date.now()&&(j=Number.MAX_SAFE_INTEGER,E.warn(`Element with async attribute '${p}' not mounted after 5 seconds. If it is never mounted, it will leak.
+`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!Te(e)}async function*tt(e){yield e}function ae(e,...t){if(!t||t.length===0)return Ie(ge(e,"change"));let n=t.filter(s=>typeof s!="string"||s[0]!=="@").map(s=>typeof s=="string"?ge(e,s):s instanceof Element?ge(s,"change"):$(s)?tt(s):s);if(t.includes("@start")){let s={[Symbol.asyncIterator]:()=>s,next(){return s.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(s)}if(t.includes("@ready")){let f=function(a){return typeof a=="string"&&!e.querySelector(a)};var u=f;let m=t.filter(et).map(a=>Te(a)?.[0]).filter(f),i,d={[Symbol.asyncIterator](){return d},throw(a){return i?.throw?i.throw(a):Promise.resolve({done:!0,value:a})},return(a){return i?.return?i.return(a):Promise.resolve({done:!0,value:a})},next(){return i?i.next():Me(e,m).then(()=>(i=(n.length>1?z(...n):n.length===1?n[0]:Oe())[Symbol.asyncIterator](),i?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Ie(W(d))}let r=n.length>1?z(...n):n.length===1?n[0]:Oe();return Ie(W(r))}function ke(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,r)=>{n.some(u=>u.addedNodes?.length)&&e.isConnected&&(r.disconnect(),t())}).observe(document.body,{subtree:!0,childList:!0}))}function Me(e,t){return t?.length?Promise.all([nt(e,t),ke(e)]):ke(e)}function nt(e,t){if(t=t.filter(r=>!e.querySelector(r)),!t.length)return Promise.resolve();let n=new Promise(r=>new MutationObserver((u,s)=>{u.some(f=>f.addedNodes?.length)&&t.every(f=>e.querySelector(f))&&(s.disconnect(),r())}).observe(e,{subtree:!0,childList:!0}));if(O){let r=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),u=setTimeout(()=>{E.warn(r,t)},J);n.finally(()=>clearTimeout(u))}return n}var ne=Symbol("Unique ID"),q=O?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},rt=0,ot=["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"],at=Object.getOwnPropertyDescriptors({get ids(){return De(this)},set ids(e){throw new Error("Cannot set ids on "+this.valueOf())},when:function(...e){return ae(this,...e)}}),le=document.createElement("STYLE");le.id="--ai-ui-extended-tag-styles-";function se(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)||$(e)||G(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var te=Symbol("callStack"),Ne=function(e,t,n){let[r,u,s]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,ot,e],f=st(document,"removedNodes"),m=s?.commonProperties,i=Object.create(null,at);Object.defineProperty(i,"attributes",{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(l){if(G(l)){let b=Y(l)?l:l[Symbol.asyncIterator](),P=()=>b.next().then(({done:o,value:I})=>{Q(this,I),o||P()},o=>E.warn(o));P()}else Q(this,l)}}),m&&g(i,m);function d(...l){let b=[];return function P(o){if(!(o==null||o===N)){if($(o)){let I=Ee();b.push(I),o.then(c=>I.replaceWith(...d(c)),c=>{E.warn(c,q(I)),I.replaceWith(ie({error:c}))});return}if(o instanceof Node){b.push(o);return}if(o&&typeof o=="object"&&Symbol.iterator in o&&!(Symbol.asyncIterator in o)&&o[Symbol.iterator]){for(let I of o)P(I);return}if(G(o)){let I=O?`
+`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",c=Y(o)?o:o[Symbol.asyncIterator](),x=o.valueOf(),B=x===void 0||x===o?[Ee()]:d(x);b.push(...B);let y=B,p=!0,h=Date.now()+J,w=O&&new Error("Created by").stack,D=A=>{let S=y.filter(M=>!!M?.parentNode);S.length?(y=[ie({error:A})],S[0].replaceWith(...y),S.slice(1).forEach(M=>M?.parentNode.removeChild(M))):E.warn("Can't report error",A,w,y.map(q)),y=[],c.return?.(D)},F=A=>{if(!A.done)try{let S=y.filter(T=>T?.parentNode&&T.isConnected),M=p?y:S;if(S.length&&(p=!1),!M.length||y.every(T=>f(T))){y=[];let T="Element(s) have been removed from the document: "+I;c.return?.(new Error(T));return}O&&p&&h&&h<Date.now()&&(h=Number.MAX_SAFE_INTEGER,E.warn("Async element not mounted after 5 seconds. If it is never mounted, it will leak.",w,y.map(q))),y=d(v(A.value)),y.length||y.push(Ee()),M[0].replaceWith(...y),M.slice(1).forEach(T=>!y.includes(T)&&T.parentNode?.removeChild(T)),c.next().then(F).catch(D)}catch(S){y=[],c.return?.(S)}};c.next().then(F).catch(D);return}b.push(document.createTextNode(o.toString()))}}(l),b}r||Object.assign(Ne,{nodes:d,UniqueID:ne});let a=Object.getPrototypeOf({});function g(l,b,P){if(!(b==null||typeof b!="object"||b===l))for(let[o,I]of Object.entries(Object.getOwnPropertyDescriptors(b)))try{if("value"in I){let c=I.value;c&&G(c)?Object.defineProperty(l,o,I):c&&typeof c=="object"&&!$(c)?o in l?c 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",o,q(c)),l[o]=c):l[o]!==c&&(Array.isArray(l[o])&&l[o].length!==c.length?c.constructor===Object||c.constructor===Array?g(l[o]=new c.constructor,c):l[o]=c:g(l[o],c)):(P&&(Object.getPrototypeOf(c)===a||!Object.getPrototypeOf(c)?g(I.value={},c):Array.isArray(c)?g(I.value=[],c):E.warn(`Declared propety '${o}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,l,c)),Object.defineProperty(l,o,I)):b[o]!==void 0&&(l[o]=b[o])}else Object.defineProperty(l,o,I)}catch(c){throw E.warn("deepAssign",o,b[o],c),c}}function v(l){let b=l?.valueOf();return Array.isArray(b)?Array.prototype.map.call(b,v):b}function Q(l,b){te in b||function P(o,I){if(I==null||typeof I!="object")return;let c=Object.entries(Object.getOwnPropertyDescriptors(I));Array.isArray(I)||c.sort((y,p)=>{let h=Object.getOwnPropertyDescriptor(o,y[0]);if(h){if("value"in h)return-1;if("set"in h)return 1;if("get"in h)return .5}return 0});for(let[y,p]of c)try{if("value"in p){let h=p.value;G(h)?x(h,y):$(h)?h.then(w=>{w&&typeof w=="object"?G(w)?x(w,y):B(w,y):I[y]!==void 0&&(o[y]=w)},w=>E.log("Failed to set attribute",w)):G(h)||(h&&typeof h=="object"&&!$(h)?B(h,y):I[y]!==void 0&&(o[y]=I[y]))}else Object.defineProperty(o,y,p)}catch(h){throw E.warn("assignProps",y,I[y],h),h}function x(y,p){let h=ye(y),w=!0,D=Date.now()+J,F=O&&new Error("Created by").stack,A=M=>{if(!M.done){let T=v(M.value);if(typeof T=="object"&&T!==null){let R=Object.getOwnPropertyDescriptor(o,p);p==="style"||!R?.set?P(o[p],T):o[p]=T}else T!==void 0&&(o[p]=T);let k=l.isConnected;if(f(l)||!w&&!k){E.info(`Element does not exist in document when setting async attribute '${p}' to:
+${q(l)}`),h.return?.();return}k&&(w=!1),w&&D&&D<Date.now()&&(D=Number.MAX_SAFE_INTEGER,E.warn(`Element with async attribute '${p}' not mounted after 5 seconds. If it is never mounted, it will leak.
 Element contains: ${q(l)}
-${F}`)),h.next().then(A).catch(S)}},S=M=>{E.warn("Dynamic attribute error",M,p,o,F,q(l)),h.return?.(M),l.appendChild(ie({error:M}))};h.next().then(A).catch(S)}function B(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,q(y)),o[p]=y;else if(!(p in o)||o[p]===y||Array.isArray(o[p])&&o[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let h=new y.constructor;P(h,y),o[p]=h}else o[p]=y;else Object.getOwnPropertyDescriptor(o,p)?.set?o[p]=y:P(o[p],y)}}(l,b)}function H(l){for(let b=l.constructor;b;b=b.super)if(b===this)return!0;return!1}function D(l){let b=typeof l!="function"?p=>Object.assign({},l,p):l,P=Date.now().toString(36)+(rt++).toString(36)+Math.random().toString(36).slice(2),o=b({[ne]:P});o.styles&&(le.appendChild(document.createTextNode(o.styles+`
-`)),document.head.contains(le)||document.head.appendChild(le));let c=Object.assign((p,...h)=>{let w=se(p),j=[],F={[te]:(w?j:p[te])??j},A=w?this(F,p,...h):this(F,...h);A.constructor=c;let S=b({[ne]:P});if(F[te].push(S),O){let T=function(k,R){for(let Z=k;Z;Z=Z.super)if(Z.definition?.declare&&R in Z.definition.declare)return!0;return!1};var M=T;if(S.declare){let k=Object.keys(S.declare).filter(R=>R in A||T(this,R));k.length&&E.log(`Declared keys '${k}' in ${c.name} already exist in base '${this.valueOf()}'`)}if(S.override){let k=Object.keys(S.override).filter(R=>!(R in A)&&!(m&&R in m)&&!T(this,R));k.length&&E.log(`Overridden keys '${k}' in ${c.name} do not exist in base '${this.valueOf()}'`)}}if(g(A,S.declare,!0),g(A,S.override),S.iterable&&Object.keys(S.iterable).forEach(T=>{T in A?E.log(`Ignoring attempt to re-define iterable property "${T}" as it could already have consumers`):be(A,T,S.iterable[T])}),F[te]===j){w||Q(A,p);for(let T of j){let k=T?.constructed?.call(A);se(k)&&A.append(...d(k))}for(let T of j)if(T.iterable){for(let k of Object.keys(T.iterable))if(!(!w&&k in p&&(!$(p[k])||!G(p[k])))){let R=A[k];R?.valueOf()!==void 0&&(A[k]=R)}}}return A},{super:this,definition:Object.assign(o,{[ne]:P}),extended:D,valueOf:()=>{let p=[...Object.keys(o.declare||{}),...Object.keys(o.iterable||{})];return`${c.name}: {${p.join(", ")}}
+${F}`)),h.next().then(A).catch(S)}},S=M=>{E.warn("Dynamic attribute error",M,p,o,F,q(l)),h.return?.(M),l.appendChild(ie({error:M}))};h.next().then(A).catch(S)}function B(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,q(y)),o[p]=y;else if(!(p in o)||o[p]===y||Array.isArray(o[p])&&o[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let h=new y.constructor;P(h,y),o[p]=h}else o[p]=y;else Object.getOwnPropertyDescriptor(o,p)?.set?o[p]=y:P(o[p],y)}}(l,b)}function H(l){for(let b=l.constructor;b;b=b.super)if(b===this)return!0;return!1}function j(l){let b=typeof l!="function"?p=>Object.assign({},l,p):l,P=Date.now().toString(36)+(rt++).toString(36)+Math.random().toString(36).slice(2),o=b({[ne]:P});o.styles&&(le.appendChild(document.createTextNode(o.styles+`
+`)),document.head.contains(le)||document.head.appendChild(le));let c=Object.assign((p,...h)=>{let w=se(p),D=[],F={[te]:(w?D:p[te])??D},A=w?this(F,p,...h):this(F,...h);A.constructor=c;let S=b({[ne]:P});if(F[te].push(S),O){let T=function(k,R){for(let Z=k;Z;Z=Z.super)if(Z.definition?.declare&&R in Z.definition.declare)return!0;return!1};var M=T;if(S.declare){let k=Object.keys(S.declare).filter(R=>R in A||T(this,R));k.length&&E.log(`Declared keys '${k}' in ${c.name} already exist in base '${this.valueOf()}'`)}if(S.override){let k=Object.keys(S.override).filter(R=>!(R in A)&&!(m&&R in m)&&!T(this,R));k.length&&E.log(`Overridden keys '${k}' in ${c.name} do not exist in base '${this.valueOf()}'`)}}if(g(A,S.declare,!0),g(A,S.override),S.iterable&&Object.keys(S.iterable).forEach(T=>{T in A?E.log(`Ignoring attempt to re-define iterable property "${T}" as it could already have consumers`):be(A,T,S.iterable[T])}),F[te]===D){w||Q(A,p);for(let T of D){let k=T?.constructed?.call(A);se(k)&&A.append(...d(k))}for(let T of D)if(T.iterable){for(let k of Object.keys(T.iterable))if(!(!w&&k in p&&(!$(p[k])||!G(p[k])))){let R=A[k];R?.valueOf()!==void 0&&(A[k]=R)}}}return A},{super:this,definition:Object.assign(o,{[ne]:P}),extended:j,valueOf:()=>{let p=[...Object.keys(o.declare||{}),...Object.keys(o.iterable||{})];return`${c.name}: {${p.join(", ")}}
  \u21AA ${this.valueOf()}`}});Object.defineProperty(c,Symbol.hasInstance,{value:H,writable:!0,configurable:!0});let x={};(function p(h){h?.super&&p(h.super);let w=h.definition;w&&(g(x,w?.override),g(x,w?.declare))})(this),g(x,o.override),g(x,o.declare),Object.defineProperties(c,Object.getOwnPropertyDescriptors(x));let B=x&&"className"in x&&typeof x.className=="string"?x.className:P,y=O?new Error().stack?.split(`
-`)[2]??"":"";if(Object.defineProperty(c,"name",{value:"<ai-"+B.replace(/\s+/g,"-")+y+">"}),O){let p=Object.keys(o).filter(h=>!["styles","ids","constructed","declare","override","iterable"].includes(h));p.length&&E.log(`${c.name} defines extraneous keys '${p}', which are unknown`)}return c}let L={createElement(l,b,...P){return l===L.createElement?d(...P):typeof l=="function"?l(b,P):typeof l=="string"&&l in L?L[l](b,P):l instanceof Node?l:ie({error:new Error("Illegal type in createElement:"+l)})}};function K(l){if(L[l])return L[l];let b=(o,...I)=>{let c=document;if(se(o)&&(I.unshift(o),o={}),!se(o)){if(o.debugger){debugger;delete o.debugger}o.document&&(c=o.document,delete o.document);let x=r?c.createElementNS(r,l.toLowerCase()):c.createElement(l);return x.constructor=b,g(x,i),Q(x,o),x.append(...d(...I)),x}},P=Object.assign(b,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:D,valueOf(){return`TagCreator: <${r||""}${r?"::":""}${l}>`}});return Object.defineProperty(b,Symbol.hasInstance,{value:H,writable:!0,configurable:!0}),Object.defineProperty(b,"name",{value:"<"+l+">"}),L[l]=P}return u.forEach(K),L};function Ee(){return document.createComment(O&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function ie({error:e}){return document.createComment(e instanceof Error?e.toString():`Error:
-`+JSON.stringify(e,null,2))}var De=function(){De=function(){},new MutationObserver(e=>{e.forEach(function(t){t.type==="childList"&&t.removedNodes.forEach(n=>n&&n instanceof Element&&[...n.getElementsByTagName("*"),n].filter(r=>!r.isConnected).forEach(r=>{"onRemovedFromDOM"in r&&typeof r.onRemovedFromDOM=="function"&&r.onRemovedFromDOM()}))})}).observe(document.body,{subtree:!0,childList:!0})};function st(e,t){let n=new WeakSet;function r(u){for(let s of u)t==="addedNodes"===s.isConnected&&(r(s.childNodes),n.add(s))}return new MutationObserver(u=>{u.forEach(function(s){s.type==="childList"&&s.removedNodes.length&&r(s[t])})}).observe(e,{subtree:!0,childList:!0}),function(u){return n.has(u)}}var Ce=new Set;function je(e,t){return e=e||document,t=t||Object.create(null),e.querySelectorAll&&e.querySelectorAll("[id]").forEach(function(n){n.id&&(t[n.id]?O&&(Ce.has(n.id)||(Ce.add(n.id),E.info("Shadowed multiple element IDs",n.id))):t[n.id]=n)}),t}
+`)[2]??"":"";if(Object.defineProperty(c,"name",{value:"<ai-"+B.replace(/\s+/g,"-")+y+">"}),O){let p=Object.keys(o).filter(h=>!["styles","ids","constructed","declare","override","iterable"].includes(h));p.length&&E.log(`${c.name} defines extraneous keys '${p}', which are unknown`)}return c}let L={createElement(l,b,...P){return l===L.createElement?d(...P):typeof l=="function"?l(b,P):typeof l=="string"&&l in L?L[l](b,P):l instanceof Node?l:ie({error:new Error("Illegal type in createElement:"+l)})}};function K(l){if(L[l])return L[l];let b=(o,...I)=>{let c=document;if(se(o)&&(I.unshift(o),o={}),!se(o)){if(o.debugger){debugger;delete o.debugger}o.document&&(c=o.document,delete o.document);let x=r?c.createElementNS(r,l.toLowerCase()):c.createElement(l);return x.constructor=b,g(x,i),Q(x,o),x.append(...d(...I)),x}},P=Object.assign(b,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:j,valueOf(){return`TagCreator: <${r||""}${r?"::":""}${l}>`}});return Object.defineProperty(b,Symbol.hasInstance,{value:H,writable:!0,configurable:!0}),Object.defineProperty(b,"name",{value:"<"+l+">"}),L[l]=P}return u.forEach(K),L};function Ee(){return document.createComment(O&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function ie({error:e}){return document.createComment(e instanceof Error?e.toString():`Error:
+`+JSON.stringify(e,null,2))}var je=function(){je=function(){},new MutationObserver(e=>{e.forEach(function(t){t.type==="childList"&&t.removedNodes.forEach(n=>n&&n instanceof Element&&[...n.getElementsByTagName("*"),n].filter(r=>!r.isConnected).forEach(r=>{"onRemovedFromDOM"in r&&typeof r.onRemovedFromDOM=="function"&&r.onRemovedFromDOM()}))})}).observe(document.body,{subtree:!0,childList:!0})};function st(e,t){let n=new WeakSet;function r(u){for(let s of u)t==="addedNodes"===s.isConnected&&(r(s.childNodes),n.add(s))}return new MutationObserver(u=>{u.forEach(function(s){s.type==="childList"&&s.removedNodes.length&&r(s[t])})}).observe(e,{subtree:!0,childList:!0}),function(u){return n.has(u)}}var Ce=new Set;function De(e,t){return e=e||document,t=t||Object.create(null),e.querySelectorAll&&e.querySelectorAll("[id]").forEach(function(n){n.id&&(t[n.id]?O&&(Ce.has(n.id)||(Ce.add(n.id),E.info("Shadowed multiple element IDs",n.id))):t[n.id]=n)}),t}
diff --git a/module/dist/ai-ui.min.js b/module/dist/ai-ui.min.js
index 1195b73..7b9898e 100644
--- a/module/dist/ai-ui.min.js
+++ b/module/dist/ai-ui.min.js
@@ -1,12 +1,12 @@
-"use strict";var AIUI=(()=>{var ce=Object.defineProperty;var Re=Object.getOwnPropertyDescriptor;var He=Object.getOwnPropertyNames;var Le=Object.prototype.hasOwnProperty;var ve=(e,t)=>{for(var n in t)ce(e,n,{get:t[n],enumerable:!0})},Ue=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let u of He(t))!Le.call(e,u)&&u!==n&&ce(e,u,{get:()=>t[u],enumerable:!(r=Re(t,u))||r.enumerable});return e};var We=e=>Ue(ce({},"__esModule",{value:!0}),e);var it={};ve(it,{Iterators:()=>me,UniqueID:()=>ne,enableOnRemovedFromDOM:()=>De,getElementIdMap:()=>je,tag:()=>Ne,when:()=>ae});var O=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var J=5e3,E={log(...e){O&&console.log("(AI-UI) LOG:",...e)},warn(...e){O&&console.warn("(AI-UI) WARN:",...e)},info(...e){O&&console.debug("(AI-UI) INFO:",...e)}};var xe=e=>{};function ue(){let e=xe,t=xe,n=new Promise((...r)=>[e,t]=r);if(n.resolve=e,n.reject=t,O){let r=new Error().stack;n.catch(u=>u instanceof Error||u?.value instanceof Error?E.log("Deferred rejection",u,"allocated at ",r):void 0)}return n}function de(e){return e&&typeof e=="object"||typeof e=="function"}function $(e){return de(e)&&"then"in e&&typeof e.then=="function"}var me={};ve(me,{Ignore:()=>N,Iterability:()=>X,asyncIterator:()=>ye,augmentGlobalAsyncGenerators:()=>Xe,combine:()=>Ae,debounceQueueIteratableIterator:()=>we,defineIterableProperty:()=>be,filterMap:()=>V,generatorHelpers:()=>Qe,isAsyncIter:()=>G,isAsyncIterable:()=>_,isAsyncIterator:()=>Y,iterableHelpers:()=>W,merge:()=>z,queueIteratableIterator:()=>pe});var X=Symbol("Iterability");function Y(e){return typeof e?.next=="function"}function _(e){return de(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function G(e){return _(e)||Y(e)}function ye(e){if(_(e))return e[Symbol.asyncIterator]();if(Y(e))return e;throw new Error("Not as async provider")}var oe={filterMap(e,t=N){return V(this,e,t)},map:qe,filter:Ke,unique:Be,waitFor:Ze,multi:Je,initially:Ye,consume:Se,merge(...e){return z(this,...e)},combine(e){return Ae(Object.assign({_this:this},e))}},fe=[...Object.getOwnPropertySymbols(oe),...Object.keys(oe)];function $e(e,...t){for(let n of t)for(let[r,u]of Object.entries(Object.getOwnPropertyDescriptors(n)))Object.defineProperty(e,r,{...u,enumerable:!1});return e}var C=Symbol("pending"),U=Symbol("items");function Pe(e=()=>{}){let t={[C]:[],[U]:[],[Symbol.asyncIterator](){return t},next(){if(t[U]?.length)return Promise.resolve({done:!1,value:t[U].shift()});let n=ue();return n.catch(r=>{}),t[C].unshift(n),n},return(n){let r={done:!0,value:void 0};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().resolve(r);t[U]=t[C]=null}return Promise.resolve(r)},throw(...n){let r={done:!0,value:n[0]};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().reject(r);t[U]=t[C]=null}return Promise.reject(r)},get length(){return t[U]?t[U].length:-1},push(n){return t[C]?(t[C].length?t[C].pop().resolve({done:!1,value:n}):t[U]?t[U].push(n):E.log("Discarding queue push as there are no consumers"),!0):!1}};return W(t)}var re=Symbol("inflight");function Fe(e=()=>{}){let t=Pe(e);return t[re]=new Set,t.push=function(n){if(!t[C])return!1;if(t[re].has(n))return!0;if(t[re].add(n),t[C].length){let r=t[C].pop();r.finally(()=>t[re].delete(n)),r.resolve({done:!1,value:n})}else t[U]?t[U].find(r=>r===n)||t[U].push(n):E.log("Discarding queue push as there are no consumers");return!0},t}var pe=Pe,we=Fe;function be(e,t,n){let r=()=>{r=()=>v;let a=we(),g=a.multi(),v=g[Symbol.asyncIterator]();return s[Symbol.asyncIterator]={value:g[Symbol.asyncIterator],enumerable:!1,writable:!1},f=a.push,fe.forEach(Q=>s[Q]={value:v[Q],enumerable:!1,writable:!1}),Object.defineProperties(m,s),v};function u(a){return{[a]:function(...g){return r(),m[a].apply(this,g)}}[a]}let s={[Symbol.asyncIterator]:{enumerable:!1,writable:!0,value:r}};fe.forEach(a=>s[a]={enumerable:!1,writable:!0,value:u(a)});let f=a=>(r(),f(a));typeof n=="object"&&n&&X in n&&(s[X]=Object.getOwnPropertyDescriptor(n,X));let m=d(n,s),i;return Object.defineProperty(e,t,{get(){return m},set(a){if(a!==m)if(_(a)){if(i===a)return;i=a;let g=O?new Error:void 0;O&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),Se.call(a,v=>{if(a!==i)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:g});f(v?.valueOf())}).catch(v=>E.info(v)).finally(()=>a===i&&(i=void 0));return}else{if(i)throw new Error(`Iterable "${t.toString()}" is already piped from another iterator`);m=d(a,s)}f(a?.valueOf())},enumerable:!0}),e;function d(a,g){let v=N;if(a==null)return Object.create(null,{...g,valueOf:{value(){return a},writable:!0},toJSON:{value(){return a},writable:!0}});switch(typeof a){case"object":return Symbol.asyncIterator in a?a:(v===N?(O&&E.info(`The iterable property '${t.toString()}' of type "object" will be spread to prevent re-initialisation.
-${new Error().stack?.slice(6)}`),Array.isArray(a)?v=Object.defineProperties([...a],g):v=Object.defineProperties({...a},g)):Object.assign(v,a),v[X]==="shallow"?(v=Object.defineProperties(v,g),v):new Proxy(v,{deleteProperty(H,D){return Reflect.deleteProperty(H,D)?(f(e[t]),!0):!1},set(H,D,L,K){return Reflect.set(H,D,L,K)?(f(e[t]),!0):!1},get(H,D,L){if(D==="valueOf")return()=>v;let K=Reflect.getOwnPropertyDescriptor(H,D);if(K===void 0&&!(D in H)||K?.enumerable){K===void 0&&(H[D]=void 0);let l=Reflect.get(v,D,L),b=Object.getOwnPropertyDescriptors(v.map((o,I)=>{let c=o?.[D]?.valueOf(),x=I?.valueOf();return typeof c==typeof x&&c==x?N:c}));Reflect.ownKeys(b).forEach(o=>b[o].enumerable=!1);let P=d(l,b);return Reflect.set(H,D,P),P}return Reflect.get(H,D,L)}}));case"bigint":case"boolean":case"number":case"string":return Object.defineProperties(Object(a),{...g,toJSON:{value(){return a.valueOf()},writable:!0}})}throw new TypeError('Iterable properties cannot be of type "'+typeof a+'"')}}var z=(...e)=>{let t=new Array(e.length),n=new Array(e.length),r=()=>{r=()=>{};for(let i=0;i<e.length;i++){let d=e[i];n[i]=(t[i]=Symbol.asyncIterator in d?d[Symbol.asyncIterator]():d).next().then(a=>({idx:i,result:a}))}},u=[],s=new Promise(()=>{}),f=n.length,m={[Symbol.asyncIterator](){return m},next(){return r(),f?Promise.race(n).then(({idx:i,result:d})=>d.done?(f--,n[i]=s,u[i]=d.value,m.next()):(n[i]=t[i]?t[i].next().then(a=>({idx:i,result:a})).catch(a=>({idx:i,result:{done:!0,value:a}})):Promise.resolve({idx:i,result:{done:!0,value:void 0}}),d)).catch(i=>m.throw?.(i)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:u})},async return(i){for(let d=0;d<t.length;d++)n[d]!==s&&(n[d]=s,u[d]=await t[d]?.return?.({done:!0,value:i}).then(a=>a.value,a=>a));return{done:!0,value:u}},async throw(i){for(let d=0;d<t.length;d++)n[d]!==s&&(n[d]=s,u[d]=await t[d]?.throw?.(i).then(a=>a.value,a=>a));return{done:!0,value:u}}};return W(m)},Ae=(e,t={})=>{let n={},r,u=[],s=0,f=new Promise(()=>{}),m={[Symbol.asyncIterator](){return m},next(){return r===void 0&&(r=Object.entries(e).map(([i,d],a)=>(s+=1,u[a]=d[Symbol.asyncIterator](),u[a].next().then(g=>({si:u,idx:a,k:i,ir:g}))))),function i(){return Promise.race(r).then(({idx:d,k:a,ir:g})=>g.done?(r[d]=f,s-=1,s?i():{done:!0,value:void 0}):(n[a]=g.value,r[d]=u[d].next().then(v=>({idx:d,k:a,ir:v})),t.ignorePartial&&Object.keys(n).length<Object.keys(e).length?i():{done:!1,value:n}))}()},return(i){return r.forEach((d,a)=>{d!==f&&u[a].return?.(i)}),Promise.resolve({done:!0,value:i})},throw(i){return r.forEach((d,a)=>{d!==f&&u[a].throw?.(i)}),Promise.reject({done:!0,value:i})}};return W(m)};function Ge(e){return _(e)&&fe.every(t=>t in e&&e[t]===oe[t])}function W(e){return Ge(e)||$e(e,oe),e}function Qe(e){return function(...t){let n=e(...t);return W(n)}}async function Se(e){let t;for await(let n of this)t=e?.(n);await t}var N=Symbol("Ignore");function Ve(e,t,n){if($(e))return e.then(t,n);try{return t(e)}catch(r){return n(r)}}function V(e,t,n=N){let r,u=N,s={[Symbol.asyncIterator](){return s},next(...f){if(n!==N){let m=Promise.resolve({done:!1,value:n});return n=N,m}return new Promise(function m(i,d){r||(r=e[Symbol.asyncIterator]()),r.next(...f).then(a=>a.done?i(a):Ve(t(a.value,u),g=>g===N?m(i,d):i({done:!1,value:u=g}),g=>{r.throw?r.throw(g):r.return?.(g),d({done:!0,value:g})}),a=>d({done:!0,value:a})).catch(a=>{r.throw?r.throw(a):r.return?.(a),d({done:!0,value:a})})})},throw(f){return Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){return Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function qe(e){return V(this,e)}function Ke(e){return V(this,async t=>await e(t)?t:N)}function Be(e){return e?V(this,async(t,n)=>n===N||await e(t,n)?t:N):V(this,(t,n)=>t===n?N:t)}function Ye(e){return V(this,t=>t,e)}function Ze(e){return V(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function Je(){let e=this,t=0,n,r;function u(f){f&&n.resolve(f),f?.done||(n=ue(),r.next().then(u).catch(m=>n.reject({done:!0,value:m})))}let s={[Symbol.asyncIterator](){return t+=1,s},next(){return r||(r=e[Symbol.asyncIterator](),u()),n},throw(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function Xe(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){W(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var ee=new Map;function _e(e){let t=ee.get(e.type);if(t)for(let n of t)try{let{push:r,terminate:u,container:s,selector:f}=n;if(s.isConnected){if(e.target instanceof Node)if(f){let m=s.querySelectorAll(f);for(let i of m)(e.target===i||i.contains(e.target))&&s.contains(i)&&r(e)}else(e.target===s||s.contains(e.target))&&r(e)}else{let m="Container `#"+s.id+">"+(f||"")+"` removed from DOM. Removing subscription";t.delete(n),u(new Error(m))}}catch(r){E.warn("docEventHandler",r)}}function he(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function Te(e){let t=e.split(":");if(t.length===1)return he(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&he(t[1])&&!he(t[0]))return[t[1],t[0]]}function ze(e){throw new Error(e)}function ge(e,t){let[n,r]=Te(t)??ze("Invalid WhenSelector: "+t);ee.has(r)||(document.addEventListener(r,_e,{passive:!0,capture:!0}),ee.set(r,new Set));let u=pe(()=>ee.get(r)?.delete(s)),s={push:u.push,terminate(f){u.return?.(f)},container:e,selector:n||null};return Me(e,n?[n]:void 0).then(f=>ee.get(r).add(s)),u.multi()}async function*Oe(){await new Promise(()=>{}),yield void 0}function Ie(e){function t(n){return e.map(n)}return Object.assign(W(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function et(e){if(!e)throw new Error(`Falsy async source will never be ready
+"use strict";var AIUI=(()=>{var ce=Object.defineProperty;var Re=Object.getOwnPropertyDescriptor;var He=Object.getOwnPropertyNames;var Le=Object.prototype.hasOwnProperty;var ve=(e,t)=>{for(var n in t)ce(e,n,{get:t[n],enumerable:!0})},Ue=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let u of He(t))!Le.call(e,u)&&u!==n&&ce(e,u,{get:()=>t[u],enumerable:!(r=Re(t,u))||r.enumerable});return e};var We=e=>Ue(ce({},"__esModule",{value:!0}),e);var it={};ve(it,{Iterators:()=>me,UniqueID:()=>ne,enableOnRemovedFromDOM:()=>je,getElementIdMap:()=>De,tag:()=>Ne,when:()=>ae});var O=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var J=5e3,E={log(...e){O&&console.log("(AI-UI) LOG:",...e)},warn(...e){O&&console.warn("(AI-UI) WARN:",...e)},info(...e){O&&console.debug("(AI-UI) INFO:",...e)}};var xe=e=>{};function ue(){let e=xe,t=xe,n=new Promise((...r)=>[e,t]=r);if(n.resolve=e,n.reject=t,O){let r=new Error().stack;n.catch(u=>u instanceof Error||u?.value instanceof Error?E.log("Deferred rejection",u,"allocated at ",r):void 0)}return n}function de(e){return e&&typeof e=="object"||typeof e=="function"}function $(e){return de(e)&&"then"in e&&typeof e.then=="function"}var me={};ve(me,{Ignore:()=>N,Iterability:()=>X,asyncIterator:()=>ye,augmentGlobalAsyncGenerators:()=>Xe,combine:()=>Ae,debounceQueueIteratableIterator:()=>we,defineIterableProperty:()=>be,filterMap:()=>V,generatorHelpers:()=>Qe,isAsyncIter:()=>G,isAsyncIterable:()=>_,isAsyncIterator:()=>Y,iterableHelpers:()=>W,merge:()=>z,queueIteratableIterator:()=>pe});var X=Symbol("Iterability");function Y(e){return typeof e?.next=="function"}function _(e){return de(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function G(e){return _(e)||Y(e)}function ye(e){if(_(e))return e[Symbol.asyncIterator]();if(Y(e))return e;throw new Error("Not as async provider")}var oe={filterMap(e,t=N){return V(this,e,t)},map:qe,filter:Ke,unique:Be,waitFor:Ze,multi:Je,initially:Ye,consume:Se,merge(...e){return z(this,...e)},combine(e){return Ae(Object.assign({_this:this},e))}},fe=[...Object.getOwnPropertySymbols(oe),...Object.keys(oe)];function $e(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let r of n)Object.defineProperty(e,r,{...Object.getOwnPropertyDescriptor(t,r),enumerable:!1});return e}var C=Symbol("pending"),U=Symbol("items");function Pe(e=()=>{}){let t={[C]:[],[U]:[],[Symbol.asyncIterator](){return t},next(){if(t[U]?.length)return Promise.resolve({done:!1,value:t[U].shift()});let n=ue();return n.catch(r=>{}),t[C].unshift(n),n},return(n){let r={done:!0,value:void 0};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().resolve(r);t[U]=t[C]=null}return Promise.resolve(r)},throw(...n){let r={done:!0,value:n[0]};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().reject(r);t[U]=t[C]=null}return Promise.reject(r)},get length(){return t[U]?t[U].length:-1},push(n){return t[C]?(t[C].length?t[C].pop().resolve({done:!1,value:n}):t[U]?t[U].push(n):E.log("Discarding queue push as there are no consumers"),!0):!1}};return W(t)}var re=Symbol("inflight");function Fe(e=()=>{}){let t=Pe(e);return t[re]=new Set,t.push=function(n){if(!t[C])return!1;if(t[re].has(n))return!0;if(t[re].add(n),t[C].length){let r=t[C].pop();r.finally(()=>t[re].delete(n)),r.resolve({done:!1,value:n})}else t[U]?t[U].find(r=>r===n)||t[U].push(n):E.log("Discarding queue push as there are no consumers");return!0},t}var pe=Pe,we=Fe;function be(e,t,n){let r=()=>{r=()=>v;let a=we(),g=a.multi(),v=g[Symbol.asyncIterator]();return s[Symbol.asyncIterator]={value:g[Symbol.asyncIterator],enumerable:!1,writable:!1},f=a.push,fe.forEach(Q=>s[Q]={value:v[Q],enumerable:!1,writable:!1}),Object.defineProperties(m,s),v};function u(a){return{[a]:function(...g){return r(),m[a].apply(this,g)}}[a]}let s={[Symbol.asyncIterator]:{enumerable:!1,writable:!0,value:r}};fe.forEach(a=>s[a]={enumerable:!1,writable:!0,value:u(a)});let f=a=>(r(),f(a));typeof n=="object"&&n&&X in n&&(s[X]=Object.getOwnPropertyDescriptor(n,X));let m=d(n,s),i;return Object.defineProperty(e,t,{get(){return m},set(a){if(a!==m)if(_(a)){if(i===a)return;i=a;let g=O?new Error:void 0;O&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),Se.call(a,v=>{if(a!==i)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:g});f(v?.valueOf())}).catch(v=>E.info(v)).finally(()=>a===i&&(i=void 0));return}else{if(i)throw new Error(`Iterable "${t.toString()}" is already piped from another iterator`);m=d(a,s)}f(a?.valueOf())},enumerable:!0}),e;function d(a,g){let v=N;if(a==null)return Object.create(null,{...g,valueOf:{value(){return a},writable:!0},toJSON:{value(){return a},writable:!0}});switch(typeof a){case"object":return Symbol.asyncIterator in a?a:(v===N?(O&&E.info(`The iterable property '${t.toString()}' of type "object" will be spread to prevent re-initialisation.
+${new Error().stack?.slice(6)}`),Array.isArray(a)?v=Object.defineProperties([...a],g):v=Object.defineProperties({...a},g)):Object.assign(v,a),v[X]==="shallow"?(v=Object.defineProperties(v,g),v):new Proxy(v,{deleteProperty(H,j){return Reflect.deleteProperty(H,j)?(f(e[t]),!0):!1},set(H,j,L,K){return Reflect.set(H,j,L,K)?(f(e[t]),!0):!1},get(H,j,L){if(j==="valueOf")return()=>v;let K=Reflect.getOwnPropertyDescriptor(H,j);if(K===void 0&&!(j in H)||K?.enumerable){K===void 0&&(H[j]=void 0);let l=Reflect.get(v,j,L),b=Object.getOwnPropertyDescriptors(v.map((o,I)=>{let c=o?.[j]?.valueOf(),x=I?.valueOf();return typeof c==typeof x&&c==x?N:c}));Reflect.ownKeys(b).forEach(o=>b[o].enumerable=!1);let P=d(l,b);return Reflect.set(H,j,P),P}return Reflect.get(H,j,L)}}));case"bigint":case"boolean":case"number":case"string":return Object.defineProperties(Object(a),{...g,toJSON:{value(){return a.valueOf()},writable:!0}})}throw new TypeError('Iterable properties cannot be of type "'+typeof a+'"')}}var z=(...e)=>{let t=new Array(e.length),n=new Array(e.length),r=()=>{r=()=>{};for(let i=0;i<e.length;i++){let d=e[i];n[i]=(t[i]=Symbol.asyncIterator in d?d[Symbol.asyncIterator]():d).next().then(a=>({idx:i,result:a}))}},u=[],s=new Promise(()=>{}),f=n.length,m={[Symbol.asyncIterator](){return m},next(){return r(),f?Promise.race(n).then(({idx:i,result:d})=>d.done?(f--,n[i]=s,u[i]=d.value,m.next()):(n[i]=t[i]?t[i].next().then(a=>({idx:i,result:a})).catch(a=>({idx:i,result:{done:!0,value:a}})):Promise.resolve({idx:i,result:{done:!0,value:void 0}}),d)).catch(i=>m.throw?.(i)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:u})},async return(i){for(let d=0;d<t.length;d++)n[d]!==s&&(n[d]=s,u[d]=await t[d]?.return?.({done:!0,value:i}).then(a=>a.value,a=>a));return{done:!0,value:u}},async throw(i){for(let d=0;d<t.length;d++)n[d]!==s&&(n[d]=s,u[d]=await t[d]?.throw?.(i).then(a=>a.value,a=>a));return{done:!0,value:u}}};return W(m)},Ae=(e,t={})=>{let n={},r,u=[],s=0,f=new Promise(()=>{}),m={[Symbol.asyncIterator](){return m},next(){return r===void 0&&(r=Object.entries(e).map(([i,d],a)=>(s+=1,u[a]=d[Symbol.asyncIterator](),u[a].next().then(g=>({si:u,idx:a,k:i,ir:g}))))),function i(){return Promise.race(r).then(({idx:d,k:a,ir:g})=>g.done?(r[d]=f,s-=1,s?i():{done:!0,value:void 0}):(n[a]=g.value,r[d]=u[d].next().then(v=>({idx:d,k:a,ir:v})),t.ignorePartial&&Object.keys(n).length<Object.keys(e).length?i():{done:!1,value:n}))}()},return(i){return r.forEach((d,a)=>{d!==f&&u[a].return?.(i)}),Promise.resolve({done:!0,value:i})},throw(i){return r.forEach((d,a)=>{d!==f&&u[a].throw?.(i)}),Promise.reject({done:!0,value:i})}};return W(m)};function Ge(e){return _(e)&&fe.every(t=>t in e&&e[t]===oe[t])}function W(e){return Ge(e)||$e(e,oe),e}function Qe(e){return function(...t){let n=e(...t);return W(n)}}async function Se(e){let t;for await(let n of this)t=e?.(n);await t}var N=Symbol("Ignore");function Ve(e,t,n){if($(e))return e.then(t,n);try{return t(e)}catch(r){return n(r)}}function V(e,t,n=N){let r,u=N,s={[Symbol.asyncIterator](){return s},next(...f){if(n!==N){let m=Promise.resolve({done:!1,value:n});return n=N,m}return new Promise(function m(i,d){r||(r=e[Symbol.asyncIterator]()),r.next(...f).then(a=>a.done?i(a):Ve(t(a.value,u),g=>g===N?m(i,d):i({done:!1,value:u=g}),g=>{r.throw?r.throw(g):r.return?.(g),d({done:!0,value:g})}),a=>d({done:!0,value:a})).catch(a=>{r.throw?r.throw(a):r.return?.(a),d({done:!0,value:a})})})},throw(f){return Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){return Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function qe(e){return V(this,e)}function Ke(e){return V(this,async t=>await e(t)?t:N)}function Be(e){return e?V(this,async(t,n)=>n===N||await e(t,n)?t:N):V(this,(t,n)=>t===n?N:t)}function Ye(e){return V(this,t=>t,e)}function Ze(e){return V(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function Je(){let e=this,t=0,n,r;function u(f){f&&n.resolve(f),f?.done||(n=ue(),r.next().then(u).catch(m=>n.reject({done:!0,value:m})))}let s={[Symbol.asyncIterator](){return t+=1,s},next(){return r||(r=e[Symbol.asyncIterator](),u()),n},throw(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function Xe(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){W(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var ee=new Map;function _e(e){let t=ee.get(e.type);if(t)for(let n of t)try{let{push:r,terminate:u,container:s,selector:f}=n;if(s.isConnected){if(e.target instanceof Node)if(f){let m=s.querySelectorAll(f);for(let i of m)(e.target===i||i.contains(e.target))&&s.contains(i)&&r(e)}else(e.target===s||s.contains(e.target))&&r(e)}else{let m="Container `#"+s.id+">"+(f||"")+"` removed from DOM. Removing subscription";t.delete(n),u(new Error(m))}}catch(r){E.warn("docEventHandler",r)}}function he(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function Te(e){let t=e.split(":");if(t.length===1)return he(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&he(t[1])&&!he(t[0]))return[t[1],t[0]]}function ze(e){throw new Error(e)}function ge(e,t){let[n,r]=Te(t)??ze("Invalid WhenSelector: "+t);ee.has(r)||(document.addEventListener(r,_e,{passive:!0,capture:!0}),ee.set(r,new Set));let u=pe(()=>ee.get(r)?.delete(s)),s={push:u.push,terminate(f){u.return?.(f)},container:e,selector:n||null};return Me(e,n?[n]:void 0).then(f=>ee.get(r).add(s)),u.multi()}async function*Oe(){await new Promise(()=>{}),yield void 0}function Ie(e){function t(n){return e.map(n)}return Object.assign(W(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function et(e){if(!e)throw new Error(`Falsy async source will never be ready
 
-`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!Te(e)}async function*tt(e){yield e}function ae(e,...t){if(!t||t.length===0)return Ie(ge(e,"change"));let n=t.filter(s=>typeof s!="string"||s[0]!=="@").map(s=>typeof s=="string"?ge(e,s):s instanceof Element?ge(s,"change"):$(s)?tt(s):s);if(t.includes("@start")){let s={[Symbol.asyncIterator]:()=>s,next(){return s.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(s)}if(t.includes("@ready")){let f=function(a){return typeof a=="string"&&!e.querySelector(a)};var u=f;let m=t.filter(et).map(a=>Te(a)?.[0]).filter(f),i,d={[Symbol.asyncIterator](){return d},throw(a){return i?.throw?i.throw(a):Promise.resolve({done:!0,value:a})},return(a){return i?.return?i.return(a):Promise.resolve({done:!0,value:a})},next(){return i?i.next():Me(e,m).then(()=>(i=(n.length>1?z(...n):n.length===1?n[0]:Oe())[Symbol.asyncIterator](),i?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Ie(W(d))}let r=n.length>1?z(...n):n.length===1?n[0]:Oe();return Ie(W(r))}function ke(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,r)=>{n.some(u=>u.addedNodes?.length)&&e.isConnected&&(r.disconnect(),t())}).observe(document.body,{subtree:!0,childList:!0}))}function Me(e,t){return t?.length?Promise.all([nt(e,t),ke(e)]):ke(e)}function nt(e,t){if(t=t.filter(r=>!e.querySelector(r)),!t.length)return Promise.resolve();let n=new Promise(r=>new MutationObserver((u,s)=>{u.some(f=>f.addedNodes?.length)&&t.every(f=>e.querySelector(f))&&(s.disconnect(),r())}).observe(e,{subtree:!0,childList:!0}));if(O){let r=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),u=setTimeout(()=>{E.warn(r,t)},J);n.finally(()=>clearTimeout(u))}return n}var ne=Symbol("Unique ID"),q=O?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},rt=0,ot=["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"],at=Object.getOwnPropertyDescriptors({get ids(){return je(this)},set ids(e){throw new Error("Cannot set ids on "+this.valueOf())},when:function(...e){return ae(this,...e)}}),le=document.createElement("STYLE");le.id="--ai-ui-extended-tag-styles-";function se(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)||$(e)||G(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var te=Symbol("callStack"),Ne=function(e,t,n){let[r,u,s]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,ot,e],f=st(document,"removedNodes"),m=s?.commonProperties,i=Object.create(null,at);Object.defineProperty(i,"attributes",{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(l){if(G(l)){let b=Y(l)?l:l[Symbol.asyncIterator](),P=()=>b.next().then(({done:o,value:I})=>{Q(this,I),o||P()},o=>E.warn(o));P()}else Q(this,l)}}),m&&g(i,m);function d(...l){let b=[];return function P(o){if(!(o==null||o===N)){if($(o)){let I=Ee();b.push(I),o.then(c=>I.replaceWith(...d(c)),c=>{E.warn(c,q(I)),I.replaceWith(ie({error:c}))});return}if(o instanceof Node){b.push(o);return}if(o&&typeof o=="object"&&Symbol.iterator in o&&!(Symbol.asyncIterator in o)&&o[Symbol.iterator]){for(let I of o)P(I);return}if(G(o)){let I=O?`
-`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",c=Y(o)?o:o[Symbol.asyncIterator](),x=o.valueOf(),B=x===void 0||x===o?[Ee()]:d(x);b.push(...B);let y=B,p=!0,h=Date.now()+J,w=O&&new Error("Created by").stack,j=A=>{let S=y.filter(M=>!!M?.parentNode);S.length?(y=[ie({error:A})],S[0].replaceWith(...y),S.slice(1).forEach(M=>M?.parentNode.removeChild(M))):E.warn("Can't report error",A,w,y.map(q)),y=[],c.return?.(j)},F=A=>{if(!A.done)try{let S=y.filter(T=>T?.parentNode&&T.isConnected),M=p?y:S;if(S.length&&(p=!1),!M.length||y.every(T=>f(T))){y=[];let T="Element(s) have been removed from the document: "+I;c.return?.(new Error(T));return}O&&p&&h&&h<Date.now()&&(h=Number.MAX_SAFE_INTEGER,E.warn("Async element not mounted after 5 seconds. If it is never mounted, it will leak.",w,y.map(q))),y=d(v(A.value)),y.length||y.push(Ee()),M[0].replaceWith(...y),M.slice(1).forEach(T=>!y.includes(T)&&T.parentNode?.removeChild(T)),c.next().then(F).catch(j)}catch(S){y=[],c.return?.(S)}};c.next().then(F).catch(j);return}b.push(document.createTextNode(o.toString()))}}(l),b}r||Object.assign(Ne,{nodes:d,UniqueID:ne});let a=Object.getPrototypeOf({});function g(l,b,P){if(!(b==null||typeof b!="object"||b===l))for(let[o,I]of Object.entries(Object.getOwnPropertyDescriptors(b)))try{if("value"in I){let c=I.value;c&&G(c)?Object.defineProperty(l,o,I):c&&typeof c=="object"&&!$(c)?o in l?c 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",o,q(c)),l[o]=c):l[o]!==c&&(Array.isArray(l[o])&&l[o].length!==c.length?c.constructor===Object||c.constructor===Array?g(l[o]=new c.constructor,c):l[o]=c:g(l[o],c)):(P&&(Object.getPrototypeOf(c)===a||!Object.getPrototypeOf(c)?g(I.value={},c):Array.isArray(c)?g(I.value=[],c):E.warn(`Declared propety '${o}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,l,c)),Object.defineProperty(l,o,I)):b[o]!==void 0&&(l[o]=b[o])}else Object.defineProperty(l,o,I)}catch(c){throw E.warn("deepAssign",o,b[o],c),c}}function v(l){let b=l?.valueOf();return Array.isArray(b)?Array.prototype.map.call(b,v):b}function Q(l,b){te in b||function P(o,I){if(I==null||typeof I!="object")return;let c=Object.entries(Object.getOwnPropertyDescriptors(I));Array.isArray(I)||c.sort((y,p)=>{let h=Object.getOwnPropertyDescriptor(o,y[0]);if(h){if("value"in h)return-1;if("set"in h)return 1;if("get"in h)return .5}return 0});for(let[y,p]of c)try{if("value"in p){let h=p.value;G(h)?x(h,y):$(h)?h.then(w=>{w&&typeof w=="object"?G(w)?x(w,y):B(w,y):I[y]!==void 0&&(o[y]=w)},w=>E.log("Failed to set attribute",w)):G(h)||(h&&typeof h=="object"&&!$(h)?B(h,y):I[y]!==void 0&&(o[y]=I[y]))}else Object.defineProperty(o,y,p)}catch(h){throw E.warn("assignProps",y,I[y],h),h}function x(y,p){let h=ye(y),w=!0,j=Date.now()+J,F=O&&new Error("Created by").stack,A=M=>{if(!M.done){let T=v(M.value);if(typeof T=="object"&&T!==null){let R=Object.getOwnPropertyDescriptor(o,p);p==="style"||!R?.set?P(o[p],T):o[p]=T}else T!==void 0&&(o[p]=T);let k=l.isConnected;if(f(l)||!w&&!k){E.info(`Element does not exist in document when setting async attribute '${p}' to:
-${q(l)}`),h.return?.();return}k&&(w=!1),w&&j&&j<Date.now()&&(j=Number.MAX_SAFE_INTEGER,E.warn(`Element with async attribute '${p}' not mounted after 5 seconds. If it is never mounted, it will leak.
+`+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!Te(e)}async function*tt(e){yield e}function ae(e,...t){if(!t||t.length===0)return Ie(ge(e,"change"));let n=t.filter(s=>typeof s!="string"||s[0]!=="@").map(s=>typeof s=="string"?ge(e,s):s instanceof Element?ge(s,"change"):$(s)?tt(s):s);if(t.includes("@start")){let s={[Symbol.asyncIterator]:()=>s,next(){return s.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(s)}if(t.includes("@ready")){let f=function(a){return typeof a=="string"&&!e.querySelector(a)};var u=f;let m=t.filter(et).map(a=>Te(a)?.[0]).filter(f),i,d={[Symbol.asyncIterator](){return d},throw(a){return i?.throw?i.throw(a):Promise.resolve({done:!0,value:a})},return(a){return i?.return?i.return(a):Promise.resolve({done:!0,value:a})},next(){return i?i.next():Me(e,m).then(()=>(i=(n.length>1?z(...n):n.length===1?n[0]:Oe())[Symbol.asyncIterator](),i?{done:!1,value:{}}:{done:!0,value:void 0}))}};return Ie(W(d))}let r=n.length>1?z(...n):n.length===1?n[0]:Oe();return Ie(W(r))}function ke(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,r)=>{n.some(u=>u.addedNodes?.length)&&e.isConnected&&(r.disconnect(),t())}).observe(document.body,{subtree:!0,childList:!0}))}function Me(e,t){return t?.length?Promise.all([nt(e,t),ke(e)]):ke(e)}function nt(e,t){if(t=t.filter(r=>!e.querySelector(r)),!t.length)return Promise.resolve();let n=new Promise(r=>new MutationObserver((u,s)=>{u.some(f=>f.addedNodes?.length)&&t.every(f=>e.querySelector(f))&&(s.disconnect(),r())}).observe(e,{subtree:!0,childList:!0}));if(O){let r=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),u=setTimeout(()=>{E.warn(r,t)},J);n.finally(()=>clearTimeout(u))}return n}var ne=Symbol("Unique ID"),q=O?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},rt=0,ot=["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"],at=Object.getOwnPropertyDescriptors({get ids(){return De(this)},set ids(e){throw new Error("Cannot set ids on "+this.valueOf())},when:function(...e){return ae(this,...e)}}),le=document.createElement("STYLE");le.id="--ai-ui-extended-tag-styles-";function se(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)||$(e)||G(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var te=Symbol("callStack"),Ne=function(e,t,n){let[r,u,s]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,ot,e],f=st(document,"removedNodes"),m=s?.commonProperties,i=Object.create(null,at);Object.defineProperty(i,"attributes",{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(l){if(G(l)){let b=Y(l)?l:l[Symbol.asyncIterator](),P=()=>b.next().then(({done:o,value:I})=>{Q(this,I),o||P()},o=>E.warn(o));P()}else Q(this,l)}}),m&&g(i,m);function d(...l){let b=[];return function P(o){if(!(o==null||o===N)){if($(o)){let I=Ee();b.push(I),o.then(c=>I.replaceWith(...d(c)),c=>{E.warn(c,q(I)),I.replaceWith(ie({error:c}))});return}if(o instanceof Node){b.push(o);return}if(o&&typeof o=="object"&&Symbol.iterator in o&&!(Symbol.asyncIterator in o)&&o[Symbol.iterator]){for(let I of o)P(I);return}if(G(o)){let I=O?`
+`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",c=Y(o)?o:o[Symbol.asyncIterator](),x=o.valueOf(),B=x===void 0||x===o?[Ee()]:d(x);b.push(...B);let y=B,p=!0,h=Date.now()+J,w=O&&new Error("Created by").stack,D=A=>{let S=y.filter(M=>!!M?.parentNode);S.length?(y=[ie({error:A})],S[0].replaceWith(...y),S.slice(1).forEach(M=>M?.parentNode.removeChild(M))):E.warn("Can't report error",A,w,y.map(q)),y=[],c.return?.(D)},F=A=>{if(!A.done)try{let S=y.filter(T=>T?.parentNode&&T.isConnected),M=p?y:S;if(S.length&&(p=!1),!M.length||y.every(T=>f(T))){y=[];let T="Element(s) have been removed from the document: "+I;c.return?.(new Error(T));return}O&&p&&h&&h<Date.now()&&(h=Number.MAX_SAFE_INTEGER,E.warn("Async element not mounted after 5 seconds. If it is never mounted, it will leak.",w,y.map(q))),y=d(v(A.value)),y.length||y.push(Ee()),M[0].replaceWith(...y),M.slice(1).forEach(T=>!y.includes(T)&&T.parentNode?.removeChild(T)),c.next().then(F).catch(D)}catch(S){y=[],c.return?.(S)}};c.next().then(F).catch(D);return}b.push(document.createTextNode(o.toString()))}}(l),b}r||Object.assign(Ne,{nodes:d,UniqueID:ne});let a=Object.getPrototypeOf({});function g(l,b,P){if(!(b==null||typeof b!="object"||b===l))for(let[o,I]of Object.entries(Object.getOwnPropertyDescriptors(b)))try{if("value"in I){let c=I.value;c&&G(c)?Object.defineProperty(l,o,I):c&&typeof c=="object"&&!$(c)?o in l?c 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",o,q(c)),l[o]=c):l[o]!==c&&(Array.isArray(l[o])&&l[o].length!==c.length?c.constructor===Object||c.constructor===Array?g(l[o]=new c.constructor,c):l[o]=c:g(l[o],c)):(P&&(Object.getPrototypeOf(c)===a||!Object.getPrototypeOf(c)?g(I.value={},c):Array.isArray(c)?g(I.value=[],c):E.warn(`Declared propety '${o}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,l,c)),Object.defineProperty(l,o,I)):b[o]!==void 0&&(l[o]=b[o])}else Object.defineProperty(l,o,I)}catch(c){throw E.warn("deepAssign",o,b[o],c),c}}function v(l){let b=l?.valueOf();return Array.isArray(b)?Array.prototype.map.call(b,v):b}function Q(l,b){te in b||function P(o,I){if(I==null||typeof I!="object")return;let c=Object.entries(Object.getOwnPropertyDescriptors(I));Array.isArray(I)||c.sort((y,p)=>{let h=Object.getOwnPropertyDescriptor(o,y[0]);if(h){if("value"in h)return-1;if("set"in h)return 1;if("get"in h)return .5}return 0});for(let[y,p]of c)try{if("value"in p){let h=p.value;G(h)?x(h,y):$(h)?h.then(w=>{w&&typeof w=="object"?G(w)?x(w,y):B(w,y):I[y]!==void 0&&(o[y]=w)},w=>E.log("Failed to set attribute",w)):G(h)||(h&&typeof h=="object"&&!$(h)?B(h,y):I[y]!==void 0&&(o[y]=I[y]))}else Object.defineProperty(o,y,p)}catch(h){throw E.warn("assignProps",y,I[y],h),h}function x(y,p){let h=ye(y),w=!0,D=Date.now()+J,F=O&&new Error("Created by").stack,A=M=>{if(!M.done){let T=v(M.value);if(typeof T=="object"&&T!==null){let R=Object.getOwnPropertyDescriptor(o,p);p==="style"||!R?.set?P(o[p],T):o[p]=T}else T!==void 0&&(o[p]=T);let k=l.isConnected;if(f(l)||!w&&!k){E.info(`Element does not exist in document when setting async attribute '${p}' to:
+${q(l)}`),h.return?.();return}k&&(w=!1),w&&D&&D<Date.now()&&(D=Number.MAX_SAFE_INTEGER,E.warn(`Element with async attribute '${p}' not mounted after 5 seconds. If it is never mounted, it will leak.
 Element contains: ${q(l)}
-${F}`)),h.next().then(A).catch(S)}},S=M=>{E.warn("Dynamic attribute error",M,p,o,F,q(l)),h.return?.(M),l.appendChild(ie({error:M}))};h.next().then(A).catch(S)}function B(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,q(y)),o[p]=y;else if(!(p in o)||o[p]===y||Array.isArray(o[p])&&o[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let h=new y.constructor;P(h,y),o[p]=h}else o[p]=y;else Object.getOwnPropertyDescriptor(o,p)?.set?o[p]=y:P(o[p],y)}}(l,b)}function H(l){for(let b=l.constructor;b;b=b.super)if(b===this)return!0;return!1}function D(l){let b=typeof l!="function"?p=>Object.assign({},l,p):l,P=Date.now().toString(36)+(rt++).toString(36)+Math.random().toString(36).slice(2),o=b({[ne]:P});o.styles&&(le.appendChild(document.createTextNode(o.styles+`
-`)),document.head.contains(le)||document.head.appendChild(le));let c=Object.assign((p,...h)=>{let w=se(p),j=[],F={[te]:(w?j:p[te])??j},A=w?this(F,p,...h):this(F,...h);A.constructor=c;let S=b({[ne]:P});if(F[te].push(S),O){let T=function(k,R){for(let Z=k;Z;Z=Z.super)if(Z.definition?.declare&&R in Z.definition.declare)return!0;return!1};var M=T;if(S.declare){let k=Object.keys(S.declare).filter(R=>R in A||T(this,R));k.length&&E.log(`Declared keys '${k}' in ${c.name} already exist in base '${this.valueOf()}'`)}if(S.override){let k=Object.keys(S.override).filter(R=>!(R in A)&&!(m&&R in m)&&!T(this,R));k.length&&E.log(`Overridden keys '${k}' in ${c.name} do not exist in base '${this.valueOf()}'`)}}if(g(A,S.declare,!0),g(A,S.override),S.iterable&&Object.keys(S.iterable).forEach(T=>{T in A?E.log(`Ignoring attempt to re-define iterable property "${T}" as it could already have consumers`):be(A,T,S.iterable[T])}),F[te]===j){w||Q(A,p);for(let T of j){let k=T?.constructed?.call(A);se(k)&&A.append(...d(k))}for(let T of j)if(T.iterable){for(let k of Object.keys(T.iterable))if(!(!w&&k in p&&(!$(p[k])||!G(p[k])))){let R=A[k];R?.valueOf()!==void 0&&(A[k]=R)}}}return A},{super:this,definition:Object.assign(o,{[ne]:P}),extended:D,valueOf:()=>{let p=[...Object.keys(o.declare||{}),...Object.keys(o.iterable||{})];return`${c.name}: {${p.join(", ")}}
+${F}`)),h.next().then(A).catch(S)}},S=M=>{E.warn("Dynamic attribute error",M,p,o,F,q(l)),h.return?.(M),l.appendChild(ie({error:M}))};h.next().then(A).catch(S)}function B(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,q(y)),o[p]=y;else if(!(p in o)||o[p]===y||Array.isArray(o[p])&&o[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let h=new y.constructor;P(h,y),o[p]=h}else o[p]=y;else Object.getOwnPropertyDescriptor(o,p)?.set?o[p]=y:P(o[p],y)}}(l,b)}function H(l){for(let b=l.constructor;b;b=b.super)if(b===this)return!0;return!1}function j(l){let b=typeof l!="function"?p=>Object.assign({},l,p):l,P=Date.now().toString(36)+(rt++).toString(36)+Math.random().toString(36).slice(2),o=b({[ne]:P});o.styles&&(le.appendChild(document.createTextNode(o.styles+`
+`)),document.head.contains(le)||document.head.appendChild(le));let c=Object.assign((p,...h)=>{let w=se(p),D=[],F={[te]:(w?D:p[te])??D},A=w?this(F,p,...h):this(F,...h);A.constructor=c;let S=b({[ne]:P});if(F[te].push(S),O){let T=function(k,R){for(let Z=k;Z;Z=Z.super)if(Z.definition?.declare&&R in Z.definition.declare)return!0;return!1};var M=T;if(S.declare){let k=Object.keys(S.declare).filter(R=>R in A||T(this,R));k.length&&E.log(`Declared keys '${k}' in ${c.name} already exist in base '${this.valueOf()}'`)}if(S.override){let k=Object.keys(S.override).filter(R=>!(R in A)&&!(m&&R in m)&&!T(this,R));k.length&&E.log(`Overridden keys '${k}' in ${c.name} do not exist in base '${this.valueOf()}'`)}}if(g(A,S.declare,!0),g(A,S.override),S.iterable&&Object.keys(S.iterable).forEach(T=>{T in A?E.log(`Ignoring attempt to re-define iterable property "${T}" as it could already have consumers`):be(A,T,S.iterable[T])}),F[te]===D){w||Q(A,p);for(let T of D){let k=T?.constructed?.call(A);se(k)&&A.append(...d(k))}for(let T of D)if(T.iterable){for(let k of Object.keys(T.iterable))if(!(!w&&k in p&&(!$(p[k])||!G(p[k])))){let R=A[k];R?.valueOf()!==void 0&&(A[k]=R)}}}return A},{super:this,definition:Object.assign(o,{[ne]:P}),extended:j,valueOf:()=>{let p=[...Object.keys(o.declare||{}),...Object.keys(o.iterable||{})];return`${c.name}: {${p.join(", ")}}
  \u21AA ${this.valueOf()}`}});Object.defineProperty(c,Symbol.hasInstance,{value:H,writable:!0,configurable:!0});let x={};(function p(h){h?.super&&p(h.super);let w=h.definition;w&&(g(x,w?.override),g(x,w?.declare))})(this),g(x,o.override),g(x,o.declare),Object.defineProperties(c,Object.getOwnPropertyDescriptors(x));let B=x&&"className"in x&&typeof x.className=="string"?x.className:P,y=O?new Error().stack?.split(`
-`)[2]??"":"";if(Object.defineProperty(c,"name",{value:"<ai-"+B.replace(/\s+/g,"-")+y+">"}),O){let p=Object.keys(o).filter(h=>!["styles","ids","constructed","declare","override","iterable"].includes(h));p.length&&E.log(`${c.name} defines extraneous keys '${p}', which are unknown`)}return c}let L={createElement(l,b,...P){return l===L.createElement?d(...P):typeof l=="function"?l(b,P):typeof l=="string"&&l in L?L[l](b,P):l instanceof Node?l:ie({error:new Error("Illegal type in createElement:"+l)})}};function K(l){if(L[l])return L[l];let b=(o,...I)=>{let c=document;if(se(o)&&(I.unshift(o),o={}),!se(o)){if(o.debugger){debugger;delete o.debugger}o.document&&(c=o.document,delete o.document);let x=r?c.createElementNS(r,l.toLowerCase()):c.createElement(l);return x.constructor=b,g(x,i),Q(x,o),x.append(...d(...I)),x}},P=Object.assign(b,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:D,valueOf(){return`TagCreator: <${r||""}${r?"::":""}${l}>`}});return Object.defineProperty(b,Symbol.hasInstance,{value:H,writable:!0,configurable:!0}),Object.defineProperty(b,"name",{value:"<"+l+">"}),L[l]=P}return u.forEach(K),L};function Ee(){return document.createComment(O&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function ie({error:e}){return document.createComment(e instanceof Error?e.toString():`Error:
-`+JSON.stringify(e,null,2))}var De=function(){De=function(){},new MutationObserver(e=>{e.forEach(function(t){t.type==="childList"&&t.removedNodes.forEach(n=>n&&n instanceof Element&&[...n.getElementsByTagName("*"),n].filter(r=>!r.isConnected).forEach(r=>{"onRemovedFromDOM"in r&&typeof r.onRemovedFromDOM=="function"&&r.onRemovedFromDOM()}))})}).observe(document.body,{subtree:!0,childList:!0})};function st(e,t){let n=new WeakSet;function r(u){for(let s of u)t==="addedNodes"===s.isConnected&&(r(s.childNodes),n.add(s))}return new MutationObserver(u=>{u.forEach(function(s){s.type==="childList"&&s.removedNodes.length&&r(s[t])})}).observe(e,{subtree:!0,childList:!0}),function(u){return n.has(u)}}var Ce=new Set;function je(e,t){return e=e||document,t=t||Object.create(null),e.querySelectorAll&&e.querySelectorAll("[id]").forEach(function(n){n.id&&(t[n.id]?O&&(Ce.has(n.id)||(Ce.add(n.id),E.info("Shadowed multiple element IDs",n.id))):t[n.id]=n)}),t}return We(it);})();
+`)[2]??"":"";if(Object.defineProperty(c,"name",{value:"<ai-"+B.replace(/\s+/g,"-")+y+">"}),O){let p=Object.keys(o).filter(h=>!["styles","ids","constructed","declare","override","iterable"].includes(h));p.length&&E.log(`${c.name} defines extraneous keys '${p}', which are unknown`)}return c}let L={createElement(l,b,...P){return l===L.createElement?d(...P):typeof l=="function"?l(b,P):typeof l=="string"&&l in L?L[l](b,P):l instanceof Node?l:ie({error:new Error("Illegal type in createElement:"+l)})}};function K(l){if(L[l])return L[l];let b=(o,...I)=>{let c=document;if(se(o)&&(I.unshift(o),o={}),!se(o)){if(o.debugger){debugger;delete o.debugger}o.document&&(c=o.document,delete o.document);let x=r?c.createElementNS(r,l.toLowerCase()):c.createElement(l);return x.constructor=b,g(x,i),Q(x,o),x.append(...d(...I)),x}},P=Object.assign(b,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:j,valueOf(){return`TagCreator: <${r||""}${r?"::":""}${l}>`}});return Object.defineProperty(b,Symbol.hasInstance,{value:H,writable:!0,configurable:!0}),Object.defineProperty(b,"name",{value:"<"+l+">"}),L[l]=P}return u.forEach(K),L};function Ee(){return document.createComment(O&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function ie({error:e}){return document.createComment(e instanceof Error?e.toString():`Error:
+`+JSON.stringify(e,null,2))}var je=function(){je=function(){},new MutationObserver(e=>{e.forEach(function(t){t.type==="childList"&&t.removedNodes.forEach(n=>n&&n instanceof Element&&[...n.getElementsByTagName("*"),n].filter(r=>!r.isConnected).forEach(r=>{"onRemovedFromDOM"in r&&typeof r.onRemovedFromDOM=="function"&&r.onRemovedFromDOM()}))})}).observe(document.body,{subtree:!0,childList:!0})};function st(e,t){let n=new WeakSet;function r(u){for(let s of u)t==="addedNodes"===s.isConnected&&(r(s.childNodes),n.add(s))}return new MutationObserver(u=>{u.forEach(function(s){s.type==="childList"&&s.removedNodes.length&&r(s[t])})}).observe(e,{subtree:!0,childList:!0}),function(u){return n.has(u)}}var Ce=new Set;function De(e,t){return e=e||document,t=t||Object.create(null),e.querySelectorAll&&e.querySelectorAll("[id]").forEach(function(n){n.id&&(t[n.id]?O&&(Ce.has(n.id)||(Ce.add(n.id),E.info("Shadowed multiple element IDs",n.id))):t[n.id]=n)}),t}return We(it);})();
diff --git a/module/dist/ai-ui.min.mjs b/module/dist/ai-ui.min.mjs
index a3464ac..c4de833 100644
--- a/module/dist/ai-ui.min.mjs
+++ b/module/dist/ai-ui.min.mjs
@@ -1,12 +1,12 @@
-var Me=Object.defineProperty;var Ce=(e,t)=>{for(var n in t)Me(e,n,{get:t[n],enumerable:!0})};var O=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var J=5e3,E={log(...e){O&&console.log("(AI-UI) LOG:",...e)},warn(...e){O&&console.warn("(AI-UI) WARN:",...e)},info(...e){O&&console.debug("(AI-UI) INFO:",...e)}};var Te=e=>{};function le(){let e=Te,t=Te,n=new Promise((...r)=>[e,t]=r);if(n.resolve=e,n.reject=t,O){let r=new Error().stack;n.catch(d=>d instanceof Error||d?.value instanceof Error?E.log("Deferred rejection",d,"allocated at ",r):void 0)}return n}function ce(e){return e&&typeof e=="object"||typeof e=="function"}function $(e){return ce(e)&&"then"in e&&typeof e.then=="function"}var we={};Ce(we,{Ignore:()=>N,Iterability:()=>X,asyncIterator:()=>de,augmentGlobalAsyncGenerators:()=>Qe,combine:()=>xe,debounceQueueIteratableIterator:()=>ve,defineIterableProperty:()=>ye,filterMap:()=>V,generatorHelpers:()=>Re,isAsyncIter:()=>G,isAsyncIterable:()=>_,isAsyncIterator:()=>Y,iterableHelpers:()=>W,merge:()=>z,queueIteratableIterator:()=>fe});var X=Symbol("Iterability");function Y(e){return typeof e?.next=="function"}function _(e){return ce(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function G(e){return _(e)||Y(e)}function de(e){if(_(e))return e[Symbol.asyncIterator]();if(Y(e))return e;throw new Error("Not as async provider")}var re={filterMap(e,t=N){return V(this,e,t)},map:Le,filter:Ue,unique:We,waitFor:Fe,multi:Ge,initially:$e,consume:Pe,merge(...e){return z(this,...e)},combine(e){return xe(Object.assign({_this:this},e))}},ue=[...Object.getOwnPropertySymbols(re),...Object.keys(re)];function Ne(e,...t){for(let n of t)for(let[r,d]of Object.entries(Object.getOwnPropertyDescriptors(n)))Object.defineProperty(e,r,{...d,enumerable:!1});return e}var C=Symbol("pending"),U=Symbol("items");function Ee(e=()=>{}){let t={[C]:[],[U]:[],[Symbol.asyncIterator](){return t},next(){if(t[U]?.length)return Promise.resolve({done:!1,value:t[U].shift()});let n=le();return n.catch(r=>{}),t[C].unshift(n),n},return(n){let r={done:!0,value:void 0};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().resolve(r);t[U]=t[C]=null}return Promise.resolve(r)},throw(...n){let r={done:!0,value:n[0]};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().reject(r);t[U]=t[C]=null}return Promise.reject(r)},get length(){return t[U]?t[U].length:-1},push(n){return t[C]?(t[C].length?t[C].pop().resolve({done:!1,value:n}):t[U]?t[U].push(n):E.log("Discarding queue push as there are no consumers"),!0):!1}};return W(t)}var ne=Symbol("inflight");function De(e=()=>{}){let t=Ee(e);return t[ne]=new Set,t.push=function(n){if(!t[C])return!1;if(t[ne].has(n))return!0;if(t[ne].add(n),t[C].length){let r=t[C].pop();r.finally(()=>t[ne].delete(n)),r.resolve({done:!1,value:n})}else t[U]?t[U].find(r=>r===n)||t[U].push(n):E.log("Discarding queue push as there are no consumers");return!0},t}var fe=Ee,ve=De;function ye(e,t,n){let r=()=>{r=()=>v;let a=ve(),g=a.multi(),v=g[Symbol.asyncIterator]();return s[Symbol.asyncIterator]={value:g[Symbol.asyncIterator],enumerable:!1,writable:!1},f=a.push,ue.forEach(Q=>s[Q]={value:v[Q],enumerable:!1,writable:!1}),Object.defineProperties(m,s),v};function d(a){return{[a]:function(...g){return r(),m[a].apply(this,g)}}[a]}let s={[Symbol.asyncIterator]:{enumerable:!1,writable:!0,value:r}};ue.forEach(a=>s[a]={enumerable:!1,writable:!0,value:d(a)});let f=a=>(r(),f(a));typeof n=="object"&&n&&X in n&&(s[X]=Object.getOwnPropertyDescriptor(n,X));let m=u(n,s),i;return Object.defineProperty(e,t,{get(){return m},set(a){if(a!==m)if(_(a)){if(i===a)return;i=a;let g=O?new Error:void 0;O&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),Pe.call(a,v=>{if(a!==i)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:g});f(v?.valueOf())}).catch(v=>E.info(v)).finally(()=>a===i&&(i=void 0));return}else{if(i)throw new Error(`Iterable "${t.toString()}" is already piped from another iterator`);m=u(a,s)}f(a?.valueOf())},enumerable:!0}),e;function u(a,g){let v=N;if(a==null)return Object.create(null,{...g,valueOf:{value(){return a},writable:!0},toJSON:{value(){return a},writable:!0}});switch(typeof a){case"object":return Symbol.asyncIterator in a?a:(v===N?(O&&E.info(`The iterable property '${t.toString()}' of type "object" will be spread to prevent re-initialisation.
-${new Error().stack?.slice(6)}`),Array.isArray(a)?v=Object.defineProperties([...a],g):v=Object.defineProperties({...a},g)):Object.assign(v,a),v[X]==="shallow"?(v=Object.defineProperties(v,g),v):new Proxy(v,{deleteProperty(H,D){return Reflect.deleteProperty(H,D)?(f(e[t]),!0):!1},set(H,D,L,K){return Reflect.set(H,D,L,K)?(f(e[t]),!0):!1},get(H,D,L){if(D==="valueOf")return()=>v;let K=Reflect.getOwnPropertyDescriptor(H,D);if(K===void 0&&!(D in H)||K?.enumerable){K===void 0&&(H[D]=void 0);let l=Reflect.get(v,D,L),b=Object.getOwnPropertyDescriptors(v.map((o,I)=>{let c=o?.[D]?.valueOf(),x=I?.valueOf();return typeof c==typeof x&&c==x?N:c}));Reflect.ownKeys(b).forEach(o=>b[o].enumerable=!1);let P=u(l,b);return Reflect.set(H,D,P),P}return Reflect.get(H,D,L)}}));case"bigint":case"boolean":case"number":case"string":return Object.defineProperties(Object(a),{...g,toJSON:{value(){return a.valueOf()},writable:!0}})}throw new TypeError('Iterable properties cannot be of type "'+typeof a+'"')}}var z=(...e)=>{let t=new Array(e.length),n=new Array(e.length),r=()=>{r=()=>{};for(let i=0;i<e.length;i++){let u=e[i];n[i]=(t[i]=Symbol.asyncIterator in u?u[Symbol.asyncIterator]():u).next().then(a=>({idx:i,result:a}))}},d=[],s=new Promise(()=>{}),f=n.length,m={[Symbol.asyncIterator](){return m},next(){return r(),f?Promise.race(n).then(({idx:i,result:u})=>u.done?(f--,n[i]=s,d[i]=u.value,m.next()):(n[i]=t[i]?t[i].next().then(a=>({idx:i,result:a})).catch(a=>({idx:i,result:{done:!0,value:a}})):Promise.resolve({idx:i,result:{done:!0,value:void 0}}),u)).catch(i=>m.throw?.(i)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:d})},async return(i){for(let u=0;u<t.length;u++)n[u]!==s&&(n[u]=s,d[u]=await t[u]?.return?.({done:!0,value:i}).then(a=>a.value,a=>a));return{done:!0,value:d}},async throw(i){for(let u=0;u<t.length;u++)n[u]!==s&&(n[u]=s,d[u]=await t[u]?.throw?.(i).then(a=>a.value,a=>a));return{done:!0,value:d}}};return W(m)},xe=(e,t={})=>{let n={},r,d=[],s=0,f=new Promise(()=>{}),m={[Symbol.asyncIterator](){return m},next(){return r===void 0&&(r=Object.entries(e).map(([i,u],a)=>(s+=1,d[a]=u[Symbol.asyncIterator](),d[a].next().then(g=>({si:d,idx:a,k:i,ir:g}))))),function i(){return Promise.race(r).then(({idx:u,k:a,ir:g})=>g.done?(r[u]=f,s-=1,s?i():{done:!0,value:void 0}):(n[a]=g.value,r[u]=d[u].next().then(v=>({idx:u,k:a,ir:v})),t.ignorePartial&&Object.keys(n).length<Object.keys(e).length?i():{done:!1,value:n}))}()},return(i){return r.forEach((u,a)=>{u!==f&&d[a].return?.(i)}),Promise.resolve({done:!0,value:i})},throw(i){return r.forEach((u,a)=>{u!==f&&d[a].throw?.(i)}),Promise.reject({done:!0,value:i})}};return W(m)};function je(e){return _(e)&&ue.every(t=>t in e&&e[t]===re[t])}function W(e){return je(e)||Ne(e,re),e}function Re(e){return function(...t){let n=e(...t);return W(n)}}async function Pe(e){let t;for await(let n of this)t=e?.(n);await t}var N=Symbol("Ignore");function He(e,t,n){if($(e))return e.then(t,n);try{return t(e)}catch(r){return n(r)}}function V(e,t,n=N){let r,d=N,s={[Symbol.asyncIterator](){return s},next(...f){if(n!==N){let m=Promise.resolve({done:!1,value:n});return n=N,m}return new Promise(function m(i,u){r||(r=e[Symbol.asyncIterator]()),r.next(...f).then(a=>a.done?i(a):He(t(a.value,d),g=>g===N?m(i,u):i({done:!1,value:d=g}),g=>{r.throw?r.throw(g):r.return?.(g),u({done:!0,value:g})}),a=>u({done:!0,value:a})).catch(a=>{r.throw?r.throw(a):r.return?.(a),u({done:!0,value:a})})})},throw(f){return Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){return Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function Le(e){return V(this,e)}function Ue(e){return V(this,async t=>await e(t)?t:N)}function We(e){return e?V(this,async(t,n)=>n===N||await e(t,n)?t:N):V(this,(t,n)=>t===n?N:t)}function $e(e){return V(this,t=>t,e)}function Fe(e){return V(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function Ge(){let e=this,t=0,n,r;function d(f){f&&n.resolve(f),f?.done||(n=le(),r.next().then(d).catch(m=>n.reject({done:!0,value:m})))}let s={[Symbol.asyncIterator](){return t+=1,s},next(){return r||(r=e[Symbol.asyncIterator](),d()),n},throw(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function Qe(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){W(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var ee=new Map;function Ve(e){let t=ee.get(e.type);if(t)for(let n of t)try{let{push:r,terminate:d,container:s,selector:f}=n;if(s.isConnected){if(e.target instanceof Node)if(f){let m=s.querySelectorAll(f);for(let i of m)(e.target===i||i.contains(e.target))&&s.contains(i)&&r(e)}else(e.target===s||s.contains(e.target))&&r(e)}else{let m="Container `#"+s.id+">"+(f||"")+"` removed from DOM. Removing subscription";t.delete(n),d(new Error(m))}}catch(r){E.warn("docEventHandler",r)}}function pe(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function he(e){let t=e.split(":");if(t.length===1)return pe(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&pe(t[1])&&!pe(t[0]))return[t[1],t[0]]}function qe(e){throw new Error(e)}function be(e,t){let[n,r]=he(t)??qe("Invalid WhenSelector: "+t);ee.has(r)||(document.addEventListener(r,Ve,{passive:!0,capture:!0}),ee.set(r,new Set));let d=fe(()=>ee.get(r)?.delete(s)),s={push:d.push,terminate(f){d.return?.(f)},container:e,selector:n||null};return Oe(e,n?[n]:void 0).then(f=>ee.get(r).add(s)),d.multi()}async function*Ae(){await new Promise(()=>{}),yield void 0}function me(e){function t(n){return e.map(n)}return Object.assign(W(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function Ke(e){if(!e)throw new Error(`Falsy async source will never be ready
+var Me=Object.defineProperty;var Ce=(e,t)=>{for(var n in t)Me(e,n,{get:t[n],enumerable:!0})};var O=globalThis.DEBUG=="*"||globalThis.DEBUG==!0||globalThis.DEBUG?.match(/(^|\W)AI-UI(\W|$)/)||!1;var J=5e3,E={log(...e){O&&console.log("(AI-UI) LOG:",...e)},warn(...e){O&&console.warn("(AI-UI) WARN:",...e)},info(...e){O&&console.debug("(AI-UI) INFO:",...e)}};var Te=e=>{};function le(){let e=Te,t=Te,n=new Promise((...r)=>[e,t]=r);if(n.resolve=e,n.reject=t,O){let r=new Error().stack;n.catch(d=>d instanceof Error||d?.value instanceof Error?E.log("Deferred rejection",d,"allocated at ",r):void 0)}return n}function ce(e){return e&&typeof e=="object"||typeof e=="function"}function $(e){return ce(e)&&"then"in e&&typeof e.then=="function"}var we={};Ce(we,{Ignore:()=>N,Iterability:()=>X,asyncIterator:()=>de,augmentGlobalAsyncGenerators:()=>Qe,combine:()=>xe,debounceQueueIteratableIterator:()=>ve,defineIterableProperty:()=>ye,filterMap:()=>V,generatorHelpers:()=>Re,isAsyncIter:()=>G,isAsyncIterable:()=>_,isAsyncIterator:()=>Y,iterableHelpers:()=>W,merge:()=>z,queueIteratableIterator:()=>fe});var X=Symbol("Iterability");function Y(e){return typeof e?.next=="function"}function _(e){return ce(e)&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]=="function"}function G(e){return _(e)||Y(e)}function de(e){if(_(e))return e[Symbol.asyncIterator]();if(Y(e))return e;throw new Error("Not as async provider")}var re={filterMap(e,t=N){return V(this,e,t)},map:Le,filter:Ue,unique:We,waitFor:Fe,multi:Ge,initially:$e,consume:Pe,merge(...e){return z(this,...e)},combine(e){return xe(Object.assign({_this:this},e))}},ue=[...Object.getOwnPropertySymbols(re),...Object.keys(re)];function Ne(e,t){let n=[...Object.getOwnPropertyNames(t),...Object.getOwnPropertySymbols(t)];for(let r of n)Object.defineProperty(e,r,{...Object.getOwnPropertyDescriptor(t,r),enumerable:!1});return e}var C=Symbol("pending"),U=Symbol("items");function Ee(e=()=>{}){let t={[C]:[],[U]:[],[Symbol.asyncIterator](){return t},next(){if(t[U]?.length)return Promise.resolve({done:!1,value:t[U].shift()});let n=le();return n.catch(r=>{}),t[C].unshift(n),n},return(n){let r={done:!0,value:void 0};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().resolve(r);t[U]=t[C]=null}return Promise.resolve(r)},throw(...n){let r={done:!0,value:n[0]};if(t[C]){try{e()}catch{}for(;t[C].length;)t[C].pop().reject(r);t[U]=t[C]=null}return Promise.reject(r)},get length(){return t[U]?t[U].length:-1},push(n){return t[C]?(t[C].length?t[C].pop().resolve({done:!1,value:n}):t[U]?t[U].push(n):E.log("Discarding queue push as there are no consumers"),!0):!1}};return W(t)}var ne=Symbol("inflight");function je(e=()=>{}){let t=Ee(e);return t[ne]=new Set,t.push=function(n){if(!t[C])return!1;if(t[ne].has(n))return!0;if(t[ne].add(n),t[C].length){let r=t[C].pop();r.finally(()=>t[ne].delete(n)),r.resolve({done:!1,value:n})}else t[U]?t[U].find(r=>r===n)||t[U].push(n):E.log("Discarding queue push as there are no consumers");return!0},t}var fe=Ee,ve=je;function ye(e,t,n){let r=()=>{r=()=>v;let a=ve(),g=a.multi(),v=g[Symbol.asyncIterator]();return s[Symbol.asyncIterator]={value:g[Symbol.asyncIterator],enumerable:!1,writable:!1},f=a.push,ue.forEach(Q=>s[Q]={value:v[Q],enumerable:!1,writable:!1}),Object.defineProperties(m,s),v};function d(a){return{[a]:function(...g){return r(),m[a].apply(this,g)}}[a]}let s={[Symbol.asyncIterator]:{enumerable:!1,writable:!0,value:r}};ue.forEach(a=>s[a]={enumerable:!1,writable:!0,value:d(a)});let f=a=>(r(),f(a));typeof n=="object"&&n&&X in n&&(s[X]=Object.getOwnPropertyDescriptor(n,X));let m=u(n,s),i;return Object.defineProperty(e,t,{get(){return m},set(a){if(a!==m)if(_(a)){if(i===a)return;i=a;let g=O?new Error:void 0;O&&E.info(new Error(`Iterable "${t.toString()}" has been assigned to consume another iterator. Did you mean to declare it?`)),Pe.call(a,v=>{if(a!==i)throw new Error(`Piped iterable "${t.toString()}" has been replaced by another iterator`,{cause:g});f(v?.valueOf())}).catch(v=>E.info(v)).finally(()=>a===i&&(i=void 0));return}else{if(i)throw new Error(`Iterable "${t.toString()}" is already piped from another iterator`);m=u(a,s)}f(a?.valueOf())},enumerable:!0}),e;function u(a,g){let v=N;if(a==null)return Object.create(null,{...g,valueOf:{value(){return a},writable:!0},toJSON:{value(){return a},writable:!0}});switch(typeof a){case"object":return Symbol.asyncIterator in a?a:(v===N?(O&&E.info(`The iterable property '${t.toString()}' of type "object" will be spread to prevent re-initialisation.
+${new Error().stack?.slice(6)}`),Array.isArray(a)?v=Object.defineProperties([...a],g):v=Object.defineProperties({...a},g)):Object.assign(v,a),v[X]==="shallow"?(v=Object.defineProperties(v,g),v):new Proxy(v,{deleteProperty(H,j){return Reflect.deleteProperty(H,j)?(f(e[t]),!0):!1},set(H,j,L,K){return Reflect.set(H,j,L,K)?(f(e[t]),!0):!1},get(H,j,L){if(j==="valueOf")return()=>v;let K=Reflect.getOwnPropertyDescriptor(H,j);if(K===void 0&&!(j in H)||K?.enumerable){K===void 0&&(H[j]=void 0);let l=Reflect.get(v,j,L),b=Object.getOwnPropertyDescriptors(v.map((o,I)=>{let c=o?.[j]?.valueOf(),x=I?.valueOf();return typeof c==typeof x&&c==x?N:c}));Reflect.ownKeys(b).forEach(o=>b[o].enumerable=!1);let P=u(l,b);return Reflect.set(H,j,P),P}return Reflect.get(H,j,L)}}));case"bigint":case"boolean":case"number":case"string":return Object.defineProperties(Object(a),{...g,toJSON:{value(){return a.valueOf()},writable:!0}})}throw new TypeError('Iterable properties cannot be of type "'+typeof a+'"')}}var z=(...e)=>{let t=new Array(e.length),n=new Array(e.length),r=()=>{r=()=>{};for(let i=0;i<e.length;i++){let u=e[i];n[i]=(t[i]=Symbol.asyncIterator in u?u[Symbol.asyncIterator]():u).next().then(a=>({idx:i,result:a}))}},d=[],s=new Promise(()=>{}),f=n.length,m={[Symbol.asyncIterator](){return m},next(){return r(),f?Promise.race(n).then(({idx:i,result:u})=>u.done?(f--,n[i]=s,d[i]=u.value,m.next()):(n[i]=t[i]?t[i].next().then(a=>({idx:i,result:a})).catch(a=>({idx:i,result:{done:!0,value:a}})):Promise.resolve({idx:i,result:{done:!0,value:void 0}}),u)).catch(i=>m.throw?.(i)??Promise.reject({done:!0,value:new Error("Iterator merge exception")})):Promise.resolve({done:!0,value:d})},async return(i){for(let u=0;u<t.length;u++)n[u]!==s&&(n[u]=s,d[u]=await t[u]?.return?.({done:!0,value:i}).then(a=>a.value,a=>a));return{done:!0,value:d}},async throw(i){for(let u=0;u<t.length;u++)n[u]!==s&&(n[u]=s,d[u]=await t[u]?.throw?.(i).then(a=>a.value,a=>a));return{done:!0,value:d}}};return W(m)},xe=(e,t={})=>{let n={},r,d=[],s=0,f=new Promise(()=>{}),m={[Symbol.asyncIterator](){return m},next(){return r===void 0&&(r=Object.entries(e).map(([i,u],a)=>(s+=1,d[a]=u[Symbol.asyncIterator](),d[a].next().then(g=>({si:d,idx:a,k:i,ir:g}))))),function i(){return Promise.race(r).then(({idx:u,k:a,ir:g})=>g.done?(r[u]=f,s-=1,s?i():{done:!0,value:void 0}):(n[a]=g.value,r[u]=d[u].next().then(v=>({idx:u,k:a,ir:v})),t.ignorePartial&&Object.keys(n).length<Object.keys(e).length?i():{done:!1,value:n}))}()},return(i){return r.forEach((u,a)=>{u!==f&&d[a].return?.(i)}),Promise.resolve({done:!0,value:i})},throw(i){return r.forEach((u,a)=>{u!==f&&d[a].throw?.(i)}),Promise.reject({done:!0,value:i})}};return W(m)};function De(e){return _(e)&&ue.every(t=>t in e&&e[t]===re[t])}function W(e){return De(e)||Ne(e,re),e}function Re(e){return function(...t){let n=e(...t);return W(n)}}async function Pe(e){let t;for await(let n of this)t=e?.(n);await t}var N=Symbol("Ignore");function He(e,t,n){if($(e))return e.then(t,n);try{return t(e)}catch(r){return n(r)}}function V(e,t,n=N){let r,d=N,s={[Symbol.asyncIterator](){return s},next(...f){if(n!==N){let m=Promise.resolve({done:!1,value:n});return n=N,m}return new Promise(function m(i,u){r||(r=e[Symbol.asyncIterator]()),r.next(...f).then(a=>a.done?i(a):He(t(a.value,d),g=>g===N?m(i,u):i({done:!1,value:d=g}),g=>{r.throw?r.throw(g):r.return?.(g),u({done:!0,value:g})}),a=>u({done:!0,value:a})).catch(a=>{r.throw?r.throw(a):r.return?.(a),u({done:!0,value:a})})})},throw(f){return Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){return Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function Le(e){return V(this,e)}function Ue(e){return V(this,async t=>await e(t)?t:N)}function We(e){return e?V(this,async(t,n)=>n===N||await e(t,n)?t:N):V(this,(t,n)=>t===n?N:t)}function $e(e){return V(this,t=>t,e)}function Fe(e){return V(this,t=>new Promise(n=>(e(()=>n(t)),t)))}function Ge(){let e=this,t=0,n,r;function d(f){f&&n.resolve(f),f?.done||(n=le(),r.next().then(d).catch(m=>n.reject({done:!0,value:m})))}let s={[Symbol.asyncIterator](){return t+=1,s},next(){return r||(r=e[Symbol.asyncIterator](),d()),n},throw(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.throw?r.throw(f):r?.return?.(f)).then(m=>({done:!0,value:m?.value}))},return(f){if(t<1)throw new Error("AsyncIterator protocol error");return t-=1,t?Promise.resolve({done:!0,value:f}):Promise.resolve(r?.return?.(f)).then(m=>({done:!0,value:m?.value}))}};return W(s)}function Qe(){let e=async function*(){}();for(;e;){if(Object.getOwnPropertyDescriptor(e,Symbol.asyncIterator)){W(e);break}e=Object.getPrototypeOf(e)}e||E.warn("Failed to augment the prototype of `(async function*())()`")}var ee=new Map;function Ve(e){let t=ee.get(e.type);if(t)for(let n of t)try{let{push:r,terminate:d,container:s,selector:f}=n;if(s.isConnected){if(e.target instanceof Node)if(f){let m=s.querySelectorAll(f);for(let i of m)(e.target===i||i.contains(e.target))&&s.contains(i)&&r(e)}else(e.target===s||s.contains(e.target))&&r(e)}else{let m="Container `#"+s.id+">"+(f||"")+"` removed from DOM. Removing subscription";t.delete(n),d(new Error(m))}}catch(r){E.warn("docEventHandler",r)}}function pe(e){return!!(e&&(e.startsWith("#")||e.startsWith(".")||e.startsWith("[")&&e.endsWith("]")))}function he(e){let t=e.split(":");if(t.length===1)return pe(t[0])?[t[0],"change"]:[null,t[0]];if(t.length===2&&pe(t[1])&&!pe(t[0]))return[t[1],t[0]]}function qe(e){throw new Error(e)}function be(e,t){let[n,r]=he(t)??qe("Invalid WhenSelector: "+t);ee.has(r)||(document.addEventListener(r,Ve,{passive:!0,capture:!0}),ee.set(r,new Set));let d=fe(()=>ee.get(r)?.delete(s)),s={push:d.push,terminate(f){d.return?.(f)},container:e,selector:n||null};return Oe(e,n?[n]:void 0).then(f=>ee.get(r).add(s)),d.multi()}async function*Ae(){await new Promise(()=>{}),yield void 0}function me(e){function t(n){return e.map(n)}return Object.assign(W(t),{[Symbol.asyncIterator]:()=>e[Symbol.asyncIterator]()})}function Ke(e){if(!e)throw new Error(`Falsy async source will never be ready
 
 `+JSON.stringify(e));return typeof e=="string"&&e[0]!=="@"&&!!he(e)}async function*Be(e){yield e}function ge(e,...t){if(!t||t.length===0)return me(be(e,"change"));let n=t.filter(s=>typeof s!="string"||s[0]!=="@").map(s=>typeof s=="string"?be(e,s):s instanceof Element?be(s,"change"):$(s)?Be(s):s);if(t.includes("@start")){let s={[Symbol.asyncIterator]:()=>s,next(){return s.next=()=>Promise.resolve({done:!0,value:void 0}),Promise.resolve({done:!1,value:{}})}};n.push(s)}if(t.includes("@ready")){let f=function(a){return typeof a=="string"&&!e.querySelector(a)};var d=f;let m=t.filter(Ke).map(a=>he(a)?.[0]).filter(f),i,u={[Symbol.asyncIterator](){return u},throw(a){return i?.throw?i.throw(a):Promise.resolve({done:!0,value:a})},return(a){return i?.return?i.return(a):Promise.resolve({done:!0,value:a})},next(){return i?i.next():Oe(e,m).then(()=>(i=(n.length>1?z(...n):n.length===1?n[0]:Ae())[Symbol.asyncIterator](),i?{done:!1,value:{}}:{done:!0,value:void 0}))}};return me(W(u))}let r=n.length>1?z(...n):n.length===1?n[0]:Ae();return me(W(r))}function Se(e){return e.isConnected?Promise.resolve():new Promise(t=>new MutationObserver((n,r)=>{n.some(d=>d.addedNodes?.length)&&e.isConnected&&(r.disconnect(),t())}).observe(document.body,{subtree:!0,childList:!0}))}function Oe(e,t){return t?.length?Promise.all([Ye(e,t),Se(e)]):Se(e)}function Ye(e,t){if(t=t.filter(r=>!e.querySelector(r)),!t.length)return Promise.resolve();let n=new Promise(r=>new MutationObserver((d,s)=>{d.some(f=>f.addedNodes?.length)&&t.every(f=>e.querySelector(f))&&(s.disconnect(),r())}).observe(e,{subtree:!0,childList:!0}));if(O){let r=new Error().stack?.replace(/^Error/,"Missing selectors after 5 seconds:"),d=setTimeout(()=>{E.warn(r,t)},J);n.finally(()=>clearTimeout(d))}return n}var oe=Symbol("Unique ID"),q=O?e=>`"${"innerHTML"in e?e.innerHTML:e.textContent}"`:e=>{},Ze=0,Je=["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"],Xe=Object.getOwnPropertyDescriptors({get ids(){return tt(this)},set ids(e){throw new Error("Cannot set ids on "+this.valueOf())},when:function(...e){return ge(this,...e)}}),ie=document.createElement("STYLE");ie.id="--ai-ui-extended-tag-styles-";function ae(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)||$(e)||G(e)||typeof e=="object"&&Symbol.iterator in e&&typeof e[Symbol.iterator]=="function"}var te=Symbol("callStack"),_e=function(e,t,n){let[r,d,s]=typeof e=="string"||e===null?[e,t,n]:Array.isArray(e)?[null,e,t]:[null,Je,e],f=et(document,"removedNodes"),m=s?.commonProperties,i=Object.create(null,Xe);Object.defineProperty(i,"attributes",{...Object.getOwnPropertyDescriptor(Element.prototype,"attributes"),set(l){if(G(l)){let b=Y(l)?l:l[Symbol.asyncIterator](),P=()=>b.next().then(({done:o,value:I})=>{Q(this,I),o||P()},o=>E.warn(o));P()}else Q(this,l)}}),m&&g(i,m);function u(...l){let b=[];return function P(o){if(!(o==null||o===N)){if($(o)){let I=Ie();b.push(I),o.then(c=>I.replaceWith(...u(c)),c=>{E.warn(c,q(I)),I.replaceWith(se({error:c}))});return}if(o instanceof Node){b.push(o);return}if(o&&typeof o=="object"&&Symbol.iterator in o&&!(Symbol.asyncIterator in o)&&o[Symbol.iterator]){for(let I of o)P(I);return}if(G(o)){let I=O?`
-`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",c=Y(o)?o:o[Symbol.asyncIterator](),x=o.valueOf(),B=x===void 0||x===o?[Ie()]:u(x);b.push(...B);let y=B,p=!0,h=Date.now()+J,w=O&&new Error("Created by").stack,j=A=>{let S=y.filter(M=>!!M?.parentNode);S.length?(y=[se({error:A})],S[0].replaceWith(...y),S.slice(1).forEach(M=>M?.parentNode.removeChild(M))):E.warn("Can't report error",A,w,y.map(q)),y=[],c.return?.(j)},F=A=>{if(!A.done)try{let S=y.filter(T=>T?.parentNode&&T.isConnected),M=p?y:S;if(S.length&&(p=!1),!M.length||y.every(T=>f(T))){y=[];let T="Element(s) have been removed from the document: "+I;c.return?.(new Error(T));return}O&&p&&h&&h<Date.now()&&(h=Number.MAX_SAFE_INTEGER,E.warn("Async element not mounted after 5 seconds. If it is never mounted, it will leak.",w,y.map(q))),y=u(v(A.value)),y.length||y.push(Ie()),M[0].replaceWith(...y),M.slice(1).forEach(T=>!y.includes(T)&&T.parentNode?.removeChild(T)),c.next().then(F).catch(j)}catch(S){y=[],c.return?.(S)}};c.next().then(F).catch(j);return}b.push(document.createTextNode(o.toString()))}}(l),b}r||Object.assign(_e,{nodes:u,UniqueID:oe});let a=Object.getPrototypeOf({});function g(l,b,P){if(!(b==null||typeof b!="object"||b===l))for(let[o,I]of Object.entries(Object.getOwnPropertyDescriptors(b)))try{if("value"in I){let c=I.value;c&&G(c)?Object.defineProperty(l,o,I):c&&typeof c=="object"&&!$(c)?o in l?c 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",o,q(c)),l[o]=c):l[o]!==c&&(Array.isArray(l[o])&&l[o].length!==c.length?c.constructor===Object||c.constructor===Array?g(l[o]=new c.constructor,c):l[o]=c:g(l[o],c)):(P&&(Object.getPrototypeOf(c)===a||!Object.getPrototypeOf(c)?g(I.value={},c):Array.isArray(c)?g(I.value=[],c):E.warn(`Declared propety '${o}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,l,c)),Object.defineProperty(l,o,I)):b[o]!==void 0&&(l[o]=b[o])}else Object.defineProperty(l,o,I)}catch(c){throw E.warn("deepAssign",o,b[o],c),c}}function v(l){let b=l?.valueOf();return Array.isArray(b)?Array.prototype.map.call(b,v):b}function Q(l,b){te in b||function P(o,I){if(I==null||typeof I!="object")return;let c=Object.entries(Object.getOwnPropertyDescriptors(I));Array.isArray(I)||c.sort((y,p)=>{let h=Object.getOwnPropertyDescriptor(o,y[0]);if(h){if("value"in h)return-1;if("set"in h)return 1;if("get"in h)return .5}return 0});for(let[y,p]of c)try{if("value"in p){let h=p.value;G(h)?x(h,y):$(h)?h.then(w=>{w&&typeof w=="object"?G(w)?x(w,y):B(w,y):I[y]!==void 0&&(o[y]=w)},w=>E.log("Failed to set attribute",w)):G(h)||(h&&typeof h=="object"&&!$(h)?B(h,y):I[y]!==void 0&&(o[y]=I[y]))}else Object.defineProperty(o,y,p)}catch(h){throw E.warn("assignProps",y,I[y],h),h}function x(y,p){let h=de(y),w=!0,j=Date.now()+J,F=O&&new Error("Created by").stack,A=M=>{if(!M.done){let T=v(M.value);if(typeof T=="object"&&T!==null){let R=Object.getOwnPropertyDescriptor(o,p);p==="style"||!R?.set?P(o[p],T):o[p]=T}else T!==void 0&&(o[p]=T);let k=l.isConnected;if(f(l)||!w&&!k){E.info(`Element does not exist in document when setting async attribute '${p}' to:
-${q(l)}`),h.return?.();return}k&&(w=!1),w&&j&&j<Date.now()&&(j=Number.MAX_SAFE_INTEGER,E.warn(`Element with async attribute '${p}' not mounted after 5 seconds. If it is never mounted, it will leak.
+`+new Error().stack?.replace(/^Error: /,"Insertion :"):"",c=Y(o)?o:o[Symbol.asyncIterator](),x=o.valueOf(),B=x===void 0||x===o?[Ie()]:u(x);b.push(...B);let y=B,p=!0,h=Date.now()+J,w=O&&new Error("Created by").stack,D=A=>{let S=y.filter(M=>!!M?.parentNode);S.length?(y=[se({error:A})],S[0].replaceWith(...y),S.slice(1).forEach(M=>M?.parentNode.removeChild(M))):E.warn("Can't report error",A,w,y.map(q)),y=[],c.return?.(D)},F=A=>{if(!A.done)try{let S=y.filter(T=>T?.parentNode&&T.isConnected),M=p?y:S;if(S.length&&(p=!1),!M.length||y.every(T=>f(T))){y=[];let T="Element(s) have been removed from the document: "+I;c.return?.(new Error(T));return}O&&p&&h&&h<Date.now()&&(h=Number.MAX_SAFE_INTEGER,E.warn("Async element not mounted after 5 seconds. If it is never mounted, it will leak.",w,y.map(q))),y=u(v(A.value)),y.length||y.push(Ie()),M[0].replaceWith(...y),M.slice(1).forEach(T=>!y.includes(T)&&T.parentNode?.removeChild(T)),c.next().then(F).catch(D)}catch(S){y=[],c.return?.(S)}};c.next().then(F).catch(D);return}b.push(document.createTextNode(o.toString()))}}(l),b}r||Object.assign(_e,{nodes:u,UniqueID:oe});let a=Object.getPrototypeOf({});function g(l,b,P){if(!(b==null||typeof b!="object"||b===l))for(let[o,I]of Object.entries(Object.getOwnPropertyDescriptors(b)))try{if("value"in I){let c=I.value;c&&G(c)?Object.defineProperty(l,o,I):c&&typeof c=="object"&&!$(c)?o in l?c 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",o,q(c)),l[o]=c):l[o]!==c&&(Array.isArray(l[o])&&l[o].length!==c.length?c.constructor===Object||c.constructor===Array?g(l[o]=new c.constructor,c):l[o]=c:g(l[o],c)):(P&&(Object.getPrototypeOf(c)===a||!Object.getPrototypeOf(c)?g(I.value={},c):Array.isArray(c)?g(I.value=[],c):E.warn(`Declared propety '${o}' is not a plain object and must be assigned by reference, possibly polluting other instances of this tag`,l,c)),Object.defineProperty(l,o,I)):b[o]!==void 0&&(l[o]=b[o])}else Object.defineProperty(l,o,I)}catch(c){throw E.warn("deepAssign",o,b[o],c),c}}function v(l){let b=l?.valueOf();return Array.isArray(b)?Array.prototype.map.call(b,v):b}function Q(l,b){te in b||function P(o,I){if(I==null||typeof I!="object")return;let c=Object.entries(Object.getOwnPropertyDescriptors(I));Array.isArray(I)||c.sort((y,p)=>{let h=Object.getOwnPropertyDescriptor(o,y[0]);if(h){if("value"in h)return-1;if("set"in h)return 1;if("get"in h)return .5}return 0});for(let[y,p]of c)try{if("value"in p){let h=p.value;G(h)?x(h,y):$(h)?h.then(w=>{w&&typeof w=="object"?G(w)?x(w,y):B(w,y):I[y]!==void 0&&(o[y]=w)},w=>E.log("Failed to set attribute",w)):G(h)||(h&&typeof h=="object"&&!$(h)?B(h,y):I[y]!==void 0&&(o[y]=I[y]))}else Object.defineProperty(o,y,p)}catch(h){throw E.warn("assignProps",y,I[y],h),h}function x(y,p){let h=de(y),w=!0,D=Date.now()+J,F=O&&new Error("Created by").stack,A=M=>{if(!M.done){let T=v(M.value);if(typeof T=="object"&&T!==null){let R=Object.getOwnPropertyDescriptor(o,p);p==="style"||!R?.set?P(o[p],T):o[p]=T}else T!==void 0&&(o[p]=T);let k=l.isConnected;if(f(l)||!w&&!k){E.info(`Element does not exist in document when setting async attribute '${p}' to:
+${q(l)}`),h.return?.();return}k&&(w=!1),w&&D&&D<Date.now()&&(D=Number.MAX_SAFE_INTEGER,E.warn(`Element with async attribute '${p}' not mounted after 5 seconds. If it is never mounted, it will leak.
 Element contains: ${q(l)}
-${F}`)),h.next().then(A).catch(S)}},S=M=>{E.warn("Dynamic attribute error",M,p,o,F,q(l)),h.return?.(M),l.appendChild(se({error:M}))};h.next().then(A).catch(S)}function B(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,q(y)),o[p]=y;else if(!(p in o)||o[p]===y||Array.isArray(o[p])&&o[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let h=new y.constructor;P(h,y),o[p]=h}else o[p]=y;else Object.getOwnPropertyDescriptor(o,p)?.set?o[p]=y:P(o[p],y)}}(l,b)}function H(l){for(let b=l.constructor;b;b=b.super)if(b===this)return!0;return!1}function D(l){let b=typeof l!="function"?p=>Object.assign({},l,p):l,P=Date.now().toString(36)+(Ze++).toString(36)+Math.random().toString(36).slice(2),o=b({[oe]:P});o.styles&&(ie.appendChild(document.createTextNode(o.styles+`
-`)),document.head.contains(ie)||document.head.appendChild(ie));let c=Object.assign((p,...h)=>{let w=ae(p),j=[],F={[te]:(w?j:p[te])??j},A=w?this(F,p,...h):this(F,...h);A.constructor=c;let S=b({[oe]:P});if(F[te].push(S),O){let T=function(k,R){for(let Z=k;Z;Z=Z.super)if(Z.definition?.declare&&R in Z.definition.declare)return!0;return!1};var M=T;if(S.declare){let k=Object.keys(S.declare).filter(R=>R in A||T(this,R));k.length&&E.log(`Declared keys '${k}' in ${c.name} already exist in base '${this.valueOf()}'`)}if(S.override){let k=Object.keys(S.override).filter(R=>!(R in A)&&!(m&&R in m)&&!T(this,R));k.length&&E.log(`Overridden keys '${k}' in ${c.name} do not exist in base '${this.valueOf()}'`)}}if(g(A,S.declare,!0),g(A,S.override),S.iterable&&Object.keys(S.iterable).forEach(T=>{T in A?E.log(`Ignoring attempt to re-define iterable property "${T}" as it could already have consumers`):ye(A,T,S.iterable[T])}),F[te]===j){w||Q(A,p);for(let T of j){let k=T?.constructed?.call(A);ae(k)&&A.append(...u(k))}for(let T of j)if(T.iterable){for(let k of Object.keys(T.iterable))if(!(!w&&k in p&&(!$(p[k])||!G(p[k])))){let R=A[k];R?.valueOf()!==void 0&&(A[k]=R)}}}return A},{super:this,definition:Object.assign(o,{[oe]:P}),extended:D,valueOf:()=>{let p=[...Object.keys(o.declare||{}),...Object.keys(o.iterable||{})];return`${c.name}: {${p.join(", ")}}
+${F}`)),h.next().then(A).catch(S)}},S=M=>{E.warn("Dynamic attribute error",M,p,o,F,q(l)),h.return?.(M),l.appendChild(se({error:M}))};h.next().then(A).catch(S)}function B(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,q(y)),o[p]=y;else if(!(p in o)||o[p]===y||Array.isArray(o[p])&&o[p].length!==y.length)if(y.constructor===Object||y.constructor===Array){let h=new y.constructor;P(h,y),o[p]=h}else o[p]=y;else Object.getOwnPropertyDescriptor(o,p)?.set?o[p]=y:P(o[p],y)}}(l,b)}function H(l){for(let b=l.constructor;b;b=b.super)if(b===this)return!0;return!1}function j(l){let b=typeof l!="function"?p=>Object.assign({},l,p):l,P=Date.now().toString(36)+(Ze++).toString(36)+Math.random().toString(36).slice(2),o=b({[oe]:P});o.styles&&(ie.appendChild(document.createTextNode(o.styles+`
+`)),document.head.contains(ie)||document.head.appendChild(ie));let c=Object.assign((p,...h)=>{let w=ae(p),D=[],F={[te]:(w?D:p[te])??D},A=w?this(F,p,...h):this(F,...h);A.constructor=c;let S=b({[oe]:P});if(F[te].push(S),O){let T=function(k,R){for(let Z=k;Z;Z=Z.super)if(Z.definition?.declare&&R in Z.definition.declare)return!0;return!1};var M=T;if(S.declare){let k=Object.keys(S.declare).filter(R=>R in A||T(this,R));k.length&&E.log(`Declared keys '${k}' in ${c.name} already exist in base '${this.valueOf()}'`)}if(S.override){let k=Object.keys(S.override).filter(R=>!(R in A)&&!(m&&R in m)&&!T(this,R));k.length&&E.log(`Overridden keys '${k}' in ${c.name} do not exist in base '${this.valueOf()}'`)}}if(g(A,S.declare,!0),g(A,S.override),S.iterable&&Object.keys(S.iterable).forEach(T=>{T in A?E.log(`Ignoring attempt to re-define iterable property "${T}" as it could already have consumers`):ye(A,T,S.iterable[T])}),F[te]===D){w||Q(A,p);for(let T of D){let k=T?.constructed?.call(A);ae(k)&&A.append(...u(k))}for(let T of D)if(T.iterable){for(let k of Object.keys(T.iterable))if(!(!w&&k in p&&(!$(p[k])||!G(p[k])))){let R=A[k];R?.valueOf()!==void 0&&(A[k]=R)}}}return A},{super:this,definition:Object.assign(o,{[oe]:P}),extended:j,valueOf:()=>{let p=[...Object.keys(o.declare||{}),...Object.keys(o.iterable||{})];return`${c.name}: {${p.join(", ")}}
  \u21AA ${this.valueOf()}`}});Object.defineProperty(c,Symbol.hasInstance,{value:H,writable:!0,configurable:!0});let x={};(function p(h){h?.super&&p(h.super);let w=h.definition;w&&(g(x,w?.override),g(x,w?.declare))})(this),g(x,o.override),g(x,o.declare),Object.defineProperties(c,Object.getOwnPropertyDescriptors(x));let B=x&&"className"in x&&typeof x.className=="string"?x.className:P,y=O?new Error().stack?.split(`
-`)[2]??"":"";if(Object.defineProperty(c,"name",{value:"<ai-"+B.replace(/\s+/g,"-")+y+">"}),O){let p=Object.keys(o).filter(h=>!["styles","ids","constructed","declare","override","iterable"].includes(h));p.length&&E.log(`${c.name} defines extraneous keys '${p}', which are unknown`)}return c}let L={createElement(l,b,...P){return l===L.createElement?u(...P):typeof l=="function"?l(b,P):typeof l=="string"&&l in L?L[l](b,P):l instanceof Node?l:se({error:new Error("Illegal type in createElement:"+l)})}};function K(l){if(L[l])return L[l];let b=(o,...I)=>{let c=document;if(ae(o)&&(I.unshift(o),o={}),!ae(o)){if(o.debugger){debugger;delete o.debugger}o.document&&(c=o.document,delete o.document);let x=r?c.createElementNS(r,l.toLowerCase()):c.createElement(l);return x.constructor=b,g(x,i),Q(x,o),x.append(...u(...I)),x}},P=Object.assign(b,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:D,valueOf(){return`TagCreator: <${r||""}${r?"::":""}${l}>`}});return Object.defineProperty(b,Symbol.hasInstance,{value:H,writable:!0,configurable:!0}),Object.defineProperty(b,"name",{value:"<"+l+">"}),L[l]=P}return d.forEach(K),L};function Ie(){return document.createComment(O&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function se({error:e}){return document.createComment(e instanceof Error?e.toString():`Error:
+`)[2]??"":"";if(Object.defineProperty(c,"name",{value:"<ai-"+B.replace(/\s+/g,"-")+y+">"}),O){let p=Object.keys(o).filter(h=>!["styles","ids","constructed","declare","override","iterable"].includes(h));p.length&&E.log(`${c.name} defines extraneous keys '${p}', which are unknown`)}return c}let L={createElement(l,b,...P){return l===L.createElement?u(...P):typeof l=="function"?l(b,P):typeof l=="string"&&l in L?L[l](b,P):l instanceof Node?l:se({error:new Error("Illegal type in createElement:"+l)})}};function K(l){if(L[l])return L[l];let b=(o,...I)=>{let c=document;if(ae(o)&&(I.unshift(o),o={}),!ae(o)){if(o.debugger){debugger;delete o.debugger}o.document&&(c=o.document,delete o.document);let x=r?c.createElementNS(r,l.toLowerCase()):c.createElement(l);return x.constructor=b,g(x,i),Q(x,o),x.append(...u(...I)),x}},P=Object.assign(b,{super:()=>{throw new Error("Can't invoke native elemenet constructors directly. Use document.createElement().")},extended:j,valueOf(){return`TagCreator: <${r||""}${r?"::":""}${l}>`}});return Object.defineProperty(b,Symbol.hasInstance,{value:H,writable:!0,configurable:!0}),Object.defineProperty(b,"name",{value:"<"+l+">"}),L[l]=P}return d.forEach(K),L};function Ie(){return document.createComment(O&&new Error("promise").stack?.replace(/^Error: /,"")||"promise")}function se({error:e}){return document.createComment(e instanceof Error?e.toString():`Error:
 `+JSON.stringify(e,null,2))}var ze=function(){ze=function(){},new MutationObserver(e=>{e.forEach(function(t){t.type==="childList"&&t.removedNodes.forEach(n=>n&&n instanceof Element&&[...n.getElementsByTagName("*"),n].filter(r=>!r.isConnected).forEach(r=>{"onRemovedFromDOM"in r&&typeof r.onRemovedFromDOM=="function"&&r.onRemovedFromDOM()}))})}).observe(document.body,{subtree:!0,childList:!0})};function et(e,t){let n=new WeakSet;function r(d){for(let s of d)t==="addedNodes"===s.isConnected&&(r(s.childNodes),n.add(s))}return new MutationObserver(d=>{d.forEach(function(s){s.type==="childList"&&s.removedNodes.length&&r(s[t])})}).observe(e,{subtree:!0,childList:!0}),function(d){return n.has(d)}}var ke=new Set;function tt(e,t){return e=e||document,t=t||Object.create(null),e.querySelectorAll&&e.querySelectorAll("[id]").forEach(function(n){n.id&&(t[n.id]?O&&(ke.has(n.id)||(ke.add(n.id),E.info("Shadowed multiple element IDs",n.id))):t[n.id]=n)}),t}export{we as Iterators,oe as UniqueID,ze as enableOnRemovedFromDOM,tt as getElementIdMap,_e as tag,ge as when};
diff --git a/module/dist/ai-ui.mjs b/module/dist/ai-ui.mjs
index 8626135..883def9 100644
--- a/module/dist/ai-ui.mjs
+++ b/module/dist/ai-ui.mjs
@@ -94,11 +94,10 @@ var asyncExtras = {
   }
 };
 var extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)];
-function assignHidden(d, ...srcs) {
-  for (const s of srcs) {
-    for (const [k, pd] of Object.entries(Object.getOwnPropertyDescriptors(s))) {
-      Object.defineProperty(d, k, { ...pd, enumerable: false });
-    }
+function assignHidden(d, s) {
+  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];
+  for (const k of keys) {
+    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });
   }
   return d;
 }
@@ -1506,4 +1505,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)\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args)\n  },\n  info(...args: any) {\n    if (DEBUG) console.debug('(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 declaratiin\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 (not the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts when *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 currently implementation does a one-level 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);\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>>;\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]: (IP[K] extends object ? IterableProperties<IP[K]> : IP[K]) & IterableType<IP[K]>\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 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 (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  if (isAsyncIterator(o)) return o;\n  throw new Error(\"Not as async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nconst 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, ...srcs: S[]) {\n  for (const s of srcs) {\n    for (const [k,pd] of Object.entries(Object.getOwnPropertyDescriptors(s))) {\n      Object.defineProperty(d, k, {...pd, enumerable: false});\n    }\n  }\n  return d as D & S; \n}\n\nconst queue_pending = Symbol('pending');\nconst queue_items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [queue_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [queue_items]: [] as T[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[queue_items]?.length) {\n        return Promise.resolve({ done: false, value: q[queue_items].shift()! });\n      }\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[queue_pending]!.unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.resolve(value);\n        q[queue_items] = q[queue_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[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.reject(value);\n        q[queue_items] = q[queue_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[queue_items]) return -1; // The queue has no consumers and has terminated.\n      return q[queue_items].length;\n    },\n\n    push(value: T) {\n      if (!q[queue_pending])\n        return false;\n\n      if (q[queue_pending].length) {\n        q[queue_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[queue_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[queue_items].push(value)\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst queue_inflight = Symbol('inflight');\n\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [queue_inflight]: Set<T> };\n  q[queue_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[queue_pending])\n      return false;\n\n    // Debounce\n    if (q[queue_inflight].has(value))\n      return true;\n\n    q[queue_inflight].add(value);\n    if (q[queue_pending].length) {\n      const p = q[queue_pending].pop()!;\n      p.finally(() => q[queue_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[queue_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[queue_items].find(v => v === value)) {\n        q[queue_items].push(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\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] = {\n      value: mi[Symbol.asyncIterator],\n      enumerable: false,\n      writable: false\n    };\n    push = bi.push;\n    extraKeys.forEach(k =>\n      extras[k] = {\n        // @ts-ignore - Fix\n        value: b[k as keyof typeof b],\n        enumerable: false,\n        writable: false\n      }\n    )\n    Object.defineProperties(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 = {\n    [Symbol.asyncIterator]: {\n      enumerable: false,\n      writable: true,\n      value: initIterator\n    }\n  } as HelperDescriptors<V>;\n\n  extraKeys.forEach((k) =>\n    extras[k] = {\n      enumerable: false,\n      writable: true,\n      // @ts-ignore - Fix\n      value: lazyAsyncMethod(k)\n    }\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  if (typeof v === 'object' && v && Iterability in v) {\n    extras[Iterability] = Object.getOwnPropertyDescriptor(v, Iterability)!;\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<unknown> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: 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) {\n            throw new Error(`Iterable \"${name.toString()}\" is already piped from another iterator`)\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: HelperDescriptors<V>): V & AsyncExtraIterable<V> {\n    let boxedObject = Ignore as unknown as (V & AsyncExtraIterable<V> & Partial<Iterability>);\n    if (a === null || a === undefined) {\n      return Object.create(null, {\n        ...pds,\n        valueOf: { value() { return a }, writable: true },\n        toJSON: { value() { return a }, writable: true }\n      });\n    }\n    switch (typeof a) {\n      case 'object':\n        /* TODO: This is problematic as the object might have clashing keys and nested members.\n          The current implementation:\n          * Spreads iterable objects in to a shallow copy of the original object, and overrites clashing members like `map`\n          *     this.iterableObj.map(o => o.field);\n          * The iterator will yield on\n          *     this.iterableObj = newValue;\n\n          * Members access is proxied, so that:\n          *     (set) this.iterableObj.field = newValue;\n          * ...causes the underlying object to yield by re-assignment (therefore calling the setter)\n          * Similarly:\n          *     (get) this.iterableObj.field\n          * ...causes the iterator for the base object to be mapped, like\n          *     this.iterableObject.map(o => o[field])\n        */\n        if (!(Symbol.asyncIterator in a)) {\n          // @ts-expect-error - Ignore is the INITIAL value\n          if (boxedObject === Ignore) {\n            if (DEBUG)\n              console.info(`The iterable property '${name.toString()}' of type \"object\" will be spread to prevent re-initialisation.\\n${new Error().stack?.slice(6)}`);\n            if (Array.isArray(a))\n              boxedObject = Object.defineProperties([...a] as V, pds);\n            else\n              boxedObject = Object.defineProperties({ ...(a as V) }, pds);\n          } else {\n            Object.assign(boxedObject, a);\n          }\n          if (boxedObject[Iterability] === 'shallow') {\n            boxedObject = Object.defineProperties(boxedObject, pds);\n            return boxedObject;\n          }\n\n          // Proxy the result so we can track members of the iterable object\n          const extraBoxed: typeof boxedObject = new Proxy(boxedObject, {\n            deleteProperty(target, key) {\n              if (Reflect.deleteProperty(target, key)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that fires the iterator by re-assigning the iterable via it's setter\n            set(target, key, value, receiver) {\n              if (Reflect.set(target, key, value, receiver)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that returns a mapped iterator for the specified field\n            get(target, key, receiver) {\n              if (key === 'valueOf')\n                return ()=>boxedObject;\n\n              const targetProp = Reflect.getOwnPropertyDescriptor(target,key);\n              // We include `targetProp === undefined` so we can monitor nested properties that aren't actually defined (yet)\n              // Note: this only applies to object iterables (since the root ones aren't proxied), but it does allow us to have\n              // defintions like:\n              //   iterable: { stuff: {} as Record<string, string | number ... }\n              if ((targetProp === undefined && !(key in target)) || targetProp?.enumerable) {\n                if (targetProp === undefined) {\n                  // @ts-ignore - Fix: this \"redefines\" V as having an optional member called `key`\n                  target[key] = undefined;\n                }\n                const realValue = Reflect.get(boxedObject as Exclude<typeof boxedObject, typeof Ignore>, key, receiver);\n                const props = Object.getOwnPropertyDescriptors(\n                    boxedObject.map((o,p) => {\n                    const ov = o?.[key as keyof typeof o]?.valueOf();\n                    const pv = p?.valueOf();\n                    if (typeof ov === typeof pv && ov == pv)\n                      return Ignore;\n                    return ov;\n                  })\n                );\n                (Reflect.ownKeys(props) as (keyof typeof props)[]).forEach(k => props[k].enumerable = false);\n                const aib = box(realValue, props);\n                Reflect.set(target, key, aib);\n                return aib;\n              }\n              return Reflect.get(target, key, receiver);\n            },\n          });\n          return extraBoxed;\n        }\n        return a as (V & AsyncExtraIterable<V>);\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return Object.defineProperties(Object(a), {\n          ...pds,\n          toJSON: { value() { return a.valueOf() }, writable: true }\n        });\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\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  const forever = new Promise<any>(() => { });\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 forever = new Promise<any>(() => {});\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, And = {}, Or = never> =\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): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  let prev: R | typeof Ignore = Ignore;\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 SpecialWhenEvents = {\n  \"@start\": { [k: string]: undefined },  // Always fires when referenced\n  \"@ready\": { [k: string]: undefined }  // 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 Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  const observations = eventObservations.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(eventName)) {\n    document.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.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(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(document.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 { ChildTags, Constructed, Instance, Overrides, TagCreator, TagCreatorFunction } from './tags.js';\nimport { DEBUG, console, timeOutWarn } from './debug.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 {} = {}> = {\n  commonProperties: OtherMembers\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  /* also\n  set attributes(...possible attributes); // has to be enclosed by tag() to access assignProps\n  */\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 */\ninterface 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\nconst elementProtype = Object.getOwnPropertyDescriptors({\n  get ids() {\n    return getElementIdMap(this);\n  },\n  set ids(v: any) {\n    throw new Error('Cannot set ids on ' + this.valueOf());\n  },\n  when: function (...what) {\n    return when(this, ...what)\n  }\n} as PoElementMethods & ThisType<Element & PoElementMethods>);\n\nconst poStyleElt = document.createElement(\"STYLE\");\npoStyleElt.id = \"--ai-ui-extended-tag-styles-\";\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 removedNodes = mutationTracker(document,'removedNodes');\n\n  const commonProperties = options?.commonProperties;\n  /* Note: we use property defintion (and not object spread) so getters (like `ids`)\n    are not evaluated until called */\n  const tagPrototypes = Object.create(\n    null,\n    elementProtype\n  );\n\n  // We do this here and not in elementProtype as there's no syntax\n  // to copy a getter/setter pair from another object\n  Object.defineProperty(tagPrototypes, '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\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        appended.push(...dpm);\n\n        let t = dpm;\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); //appendBefore(n[0], ...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?.(error);\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(document.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,b) => {\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 0.5;\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          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:{\n    debugger?: unknown;\n    document?: Document;\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(document.createTextNode(staticExtensions.styles + '\\n'));\n      if (!document.head.contains(poStyleElt)) {\n        document.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      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        } 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        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            if (!(!noAttrs && k in attrs && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e];\n              if (value?.valueOf() !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                e[k] = value;\n              }\n            }\n          }\n        }\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 & Partial<{\n      debugger?: any;\n      document?: Document;\n    }> | ChildTags, ...children: ChildTags[]) => {\n      let doc = document;\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        if (attrs.document) {\n          doc = attrs.document;\n          delete attrs.document;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? doc.createElementNS(nameSpace as string, k.toLowerCase())\n          : doc.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\nfunction DomPromiseContainer() {\n  return document.createComment(DEBUG ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\" : \"promise\")\n}\n\nfunction DyamicElementError({ error }:{ error: Error | IteratorResult<Error>}) {\n  return document.createComment(error instanceof Error ? error.toString() : 'Error:\\n'+JSON.stringify(error,null,2));\n}\n\nexport let enableOnRemovedFromDOM = function () {\n  enableOnRemovedFromDOM = function () {} // Only create the observer once\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList') {\n        m.removedNodes.forEach(\n          removed => removed && removed instanceof Element &&\n            [...removed.getElementsByTagName(\"*\"), removed].filter(elt => !elt.isConnected).forEach(\n              elt => {\n                'onRemovedFromDOM' in elt && typeof elt.onRemovedFromDOM === 'function' && elt.onRemovedFromDOM()\n              }\n            ));\n      }\n    });\n  }).observe(document.body, { subtree: true, childList: true });\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>){\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      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m.removedNodes.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\nconst warned = new Set<string>();\nexport function getElementIdMap(node?: Element | Document, ids?: Record<string, Element>) {\n  node = node || document;\n  ids = ids || Object.create(null);\n  if (node.querySelectorAll) {\n    node.querySelectorAll(\"[id]\").forEach(function (elt) {\n      if (elt.id) {\n        if (!ids![elt.id])\n          ids![elt.id] = elt;\n        else if (DEBUG) {\n          if (!warned.has(elt.id)) {\n            warned.add(elt.id)\n            console.info(\"Shadowed multiple element IDs\", elt.id /*, elt, ids![elt.id]*/);\n          }\n        }\n      }\n    });\n  }\n  return ids;\n}\n"],
  "mappings": "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",
  "names": ["v", "a", "result", "ex", "ir", "isMissing", "merged", "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)\n  },\n  warn(...args: any) {\n    if (DEBUG) console.warn('(AI-UI) WARN:', ...args)\n  },\n  info(...args: any) {\n    if (DEBUG) console.debug('(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 declaratiin\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 (not the trailing '!' to assert non-null value)\n\n  This relies on a hack to `wrapAsyncHelper` in iterators.ts when *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 currently implementation does a one-level 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);\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>>;\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]: (IP[K] extends object ? IterableProperties<IP[K]> : IP[K]) & IterableType<IP[K]>\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 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 (isAsyncIterable(o)) return o[Symbol.asyncIterator]();\n  if (isAsyncIterator(o)) return o;\n  throw new Error(\"Not as async provider\");\n}\n\ntype AsyncIterableHelpers = typeof asyncExtras;\nconst 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 queue_pending = Symbol('pending');\nconst queue_items = Symbol('items');\nfunction internalQueueIteratableIterator<T>(stop = () => { }) {\n  const q = {\n    [queue_pending]: [] as DeferredPromise<IteratorResult<T>>[] | null,\n    [queue_items]: [] as T[] | null,\n\n    [Symbol.asyncIterator]() {\n      return q as AsyncIterableIterator<T>;\n    },\n\n    next() {\n      if (q[queue_items]?.length) {\n        return Promise.resolve({ done: false, value: q[queue_items].shift()! });\n      }\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[queue_pending]!.unshift(value);\n      return value;\n    },\n\n    return(v?: unknown) {\n      const value = { done: true as const, value: undefined };\n      if (q[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.resolve(value);\n        q[queue_items] = q[queue_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[queue_pending]) {\n        try { stop() } catch (ex) { }\n        while (q[queue_pending].length)\n          q[queue_pending].pop()!.reject(value);\n        q[queue_items] = q[queue_pending] = null;\n      }\n      return Promise.reject(value);\n    },\n\n    get length() {\n      if (!q[queue_items]) return -1; // The queue has no consumers and has terminated.\n      return q[queue_items].length;\n    },\n\n    push(value: T) {\n      if (!q[queue_pending])\n        return false;\n\n      if (q[queue_pending].length) {\n        q[queue_pending].pop()!.resolve({ done: false, value });\n      } else {\n        if (!q[queue_items]) {\n          console.log('Discarding queue push as there are no consumers');\n        } else {\n          q[queue_items].push(value)\n        }\n      }\n      return true;\n    }\n  };\n  return iterableHelpers(q);\n}\n\nconst queue_inflight = Symbol('inflight');\n\nfunction internalDebounceQueueIteratableIterator<T>(stop = () => { }) {\n  const q = internalQueueIteratableIterator<T>(stop) as ReturnType<typeof internalQueueIteratableIterator<T>> & { [queue_inflight]: Set<T> };\n  q[queue_inflight] = new Set<T>();\n\n  q.push = function (value: T) {\n    if (!q[queue_pending])\n      return false;\n\n    // Debounce\n    if (q[queue_inflight].has(value))\n      return true;\n\n    q[queue_inflight].add(value);\n    if (q[queue_pending].length) {\n      const p = q[queue_pending].pop()!;\n      p.finally(() => q[queue_inflight].delete(value));\n      p.resolve({ done: false, value });\n    } else {\n      if (!q[queue_items]) {\n        console.log('Discarding queue push as there are no consumers');\n      } else if (!q[queue_items].find(v => v === value)) {\n        q[queue_items].push(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\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] = {\n      value: mi[Symbol.asyncIterator],\n      enumerable: false,\n      writable: false\n    };\n    push = bi.push;\n    extraKeys.forEach(k =>\n      extras[k] = {\n        // @ts-ignore - Fix\n        value: b[k as keyof typeof b],\n        enumerable: false,\n        writable: false\n      }\n    )\n    Object.defineProperties(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 = {\n    [Symbol.asyncIterator]: {\n      enumerable: false,\n      writable: true,\n      value: initIterator\n    }\n  } as HelperDescriptors<V>;\n\n  extraKeys.forEach((k) =>\n    extras[k] = {\n      enumerable: false,\n      writable: true,\n      // @ts-ignore - Fix\n      value: lazyAsyncMethod(k)\n    }\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  if (typeof v === 'object' && v && Iterability in v) {\n    extras[Iterability] = Object.getOwnPropertyDescriptor(v, Iterability)!;\n  }\n\n  let a = box(v, extras);\n  let piped: AsyncIterable<unknown> | undefined = undefined;\n\n  Object.defineProperty(obj, name, {\n    get(): V { return a },\n    set(v: 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) {\n            throw new Error(`Iterable \"${name.toString()}\" is already piped from another iterator`)\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: HelperDescriptors<V>): V & AsyncExtraIterable<V> {\n    let boxedObject = Ignore as unknown as (V & AsyncExtraIterable<V> & Partial<Iterability>);\n    if (a === null || a === undefined) {\n      return Object.create(null, {\n        ...pds,\n        valueOf: { value() { return a }, writable: true },\n        toJSON: { value() { return a }, writable: true }\n      });\n    }\n    switch (typeof a) {\n      case 'object':\n        /* TODO: This is problematic as the object might have clashing keys and nested members.\n          The current implementation:\n          * Spreads iterable objects in to a shallow copy of the original object, and overrites clashing members like `map`\n          *     this.iterableObj.map(o => o.field);\n          * The iterator will yield on\n          *     this.iterableObj = newValue;\n\n          * Members access is proxied, so that:\n          *     (set) this.iterableObj.field = newValue;\n          * ...causes the underlying object to yield by re-assignment (therefore calling the setter)\n          * Similarly:\n          *     (get) this.iterableObj.field\n          * ...causes the iterator for the base object to be mapped, like\n          *     this.iterableObject.map(o => o[field])\n        */\n        if (!(Symbol.asyncIterator in a)) {\n          // @ts-expect-error - Ignore is the INITIAL value\n          if (boxedObject === Ignore) {\n            if (DEBUG)\n              console.info(`The iterable property '${name.toString()}' of type \"object\" will be spread to prevent re-initialisation.\\n${new Error().stack?.slice(6)}`);\n            if (Array.isArray(a))\n              boxedObject = Object.defineProperties([...a] as V, pds);\n            else\n              boxedObject = Object.defineProperties({ ...(a as V) }, pds);\n          } else {\n            Object.assign(boxedObject, a);\n          }\n          if (boxedObject[Iterability] === 'shallow') {\n            boxedObject = Object.defineProperties(boxedObject, pds);\n            return boxedObject;\n          }\n\n          // Proxy the result so we can track members of the iterable object\n          const extraBoxed: typeof boxedObject = new Proxy(boxedObject, {\n            deleteProperty(target, key) {\n              if (Reflect.deleteProperty(target, key)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that fires the iterator by re-assigning the iterable via it's setter\n            set(target, key, value, receiver) {\n              if (Reflect.set(target, key, value, receiver)) {\n                // @ts-ignore - Fix\n                push(obj[name]);\n                return true;\n              }\n              return false;\n            },\n            // Implement the logic that returns a mapped iterator for the specified field\n            get(target, key, receiver) {\n              if (key === 'valueOf')\n                return ()=>boxedObject;\n\n              const targetProp = Reflect.getOwnPropertyDescriptor(target,key);\n              // We include `targetProp === undefined` so we can monitor nested properties that aren't actually defined (yet)\n              // Note: this only applies to object iterables (since the root ones aren't proxied), but it does allow us to have\n              // defintions like:\n              //   iterable: { stuff: {} as Record<string, string | number ... }\n              if ((targetProp === undefined && !(key in target)) || targetProp?.enumerable) {\n                if (targetProp === undefined) {\n                  // @ts-ignore - Fix: this \"redefines\" V as having an optional member called `key`\n                  target[key] = undefined;\n                }\n                const realValue = Reflect.get(boxedObject as Exclude<typeof boxedObject, typeof Ignore>, key, receiver);\n                const props = Object.getOwnPropertyDescriptors(\n                    boxedObject.map((o,p) => {\n                    const ov = o?.[key as keyof typeof o]?.valueOf();\n                    const pv = p?.valueOf();\n                    if (typeof ov === typeof pv && ov == pv)\n                      return Ignore;\n                    return ov;\n                  })\n                );\n                (Reflect.ownKeys(props) as (keyof typeof props)[]).forEach(k => props[k].enumerable = false);\n                const aib = box(realValue, props);\n                Reflect.set(target, key, aib);\n                return aib;\n              }\n              return Reflect.get(target, key, receiver);\n            },\n          });\n          return extraBoxed;\n        }\n        return a as (V & AsyncExtraIterable<V>);\n      case 'bigint':\n      case 'boolean':\n      case 'number':\n      case 'string':\n        // Boxes types, including BigInt\n        return Object.defineProperties(Object(a), {\n          ...pds,\n          toJSON: { value() { return a.valueOf() }, writable: true }\n        });\n    }\n    throw new TypeError('Iterable properties cannot be of type \"' + typeof a + '\"');\n  }\n}\n\n/*\n  Extensions to the AsyncIterable:\n*/\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  const forever = new Promise<any>(() => { });\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 forever = new Promise<any>(() => {});\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, And = {}, Or = never> =\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): AsyncExtraIterable<R> {\n  let ai: AsyncIterator<HelperAsyncIterable<U>>;\n  let prev: R | typeof Ignore = Ignore;\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 SpecialWhenEvents = {\n  \"@start\": { [k: string]: undefined },  // Always fires when referenced\n  \"@ready\": { [k: string]: undefined }  // 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 Map<keyof WhenEvents, Set<EventObservation<keyof GlobalEventHandlersEventMap>>>();\n\nfunction docEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(this: Document, ev: GlobalEventHandlersEventMap[EventName]) {\n  const observations = eventObservations.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(eventName)) {\n    document.addEventListener(eventName, docEventHandler, {\n      passive: true,\n      capture: true\n    });\n    eventObservations.set(eventName, new Set());\n  }\n\n  const queue = queueIteratableIterator<GlobalEventHandlersEventMap[keyof GlobalEventHandlersEventMap]>(() => eventObservations.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(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(document.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 { ChildTags, Constructed, Instance, Overrides, TagCreator, TagCreatorFunction } from './tags.js';\nimport { DEBUG, console, timeOutWarn } from './debug.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 {} = {}> = {\n  commonProperties: OtherMembers\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  /* also\n  set attributes(...possible attributes); // has to be enclosed by tag() to access assignProps\n  */\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 */\ninterface 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\nconst elementProtype = Object.getOwnPropertyDescriptors({\n  get ids() {\n    return getElementIdMap(this);\n  },\n  set ids(v: any) {\n    throw new Error('Cannot set ids on ' + this.valueOf());\n  },\n  when: function (...what) {\n    return when(this, ...what)\n  }\n} as PoElementMethods & ThisType<Element & PoElementMethods>);\n\nconst poStyleElt = document.createElement(\"STYLE\");\npoStyleElt.id = \"--ai-ui-extended-tag-styles-\";\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 removedNodes = mutationTracker(document,'removedNodes');\n\n  const commonProperties = options?.commonProperties;\n  /* Note: we use property defintion (and not object spread) so getters (like `ids`)\n    are not evaluated until called */\n  const tagPrototypes = Object.create(\n    null,\n    elementProtype\n  );\n\n  // We do this here and not in elementProtype as there's no syntax\n  // to copy a getter/setter pair from another object\n  Object.defineProperty(tagPrototypes, '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\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        appended.push(...dpm);\n\n        let t = dpm;\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); //appendBefore(n[0], ...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?.(error);\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(document.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,b) => {\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 0.5;\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          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:{\n    debugger?: unknown;\n    document?: Document;\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(document.createTextNode(staticExtensions.styles + '\\n'));\n      if (!document.head.contains(poStyleElt)) {\n        document.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      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        } 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        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            if (!(!noAttrs && k in attrs && (!isPromiseLike(attrs[k]) || !isAsyncIter(attrs[k])))) {\n              const value = e[k as keyof typeof e];\n              if (value?.valueOf() !== undefined) {\n                // @ts-ignore - some props of e (HTMLElement) are read-only, and we don't know if k is one of them.\n                e[k] = value;\n              }\n            }\n          }\n        }\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 & Partial<{\n      debugger?: any;\n      document?: Document;\n    }> | ChildTags, ...children: ChildTags[]) => {\n      let doc = document;\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        if (attrs.document) {\n          doc = attrs.document;\n          delete attrs.document;\n        }\n\n        // Create element\n        const e = nameSpace\n          ? doc.createElementNS(nameSpace as string, k.toLowerCase())\n          : doc.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\nfunction DomPromiseContainer() {\n  return document.createComment(DEBUG ? new Error(\"promise\").stack?.replace(/^Error: /, '') || \"promise\" : \"promise\")\n}\n\nfunction DyamicElementError({ error }:{ error: Error | IteratorResult<Error>}) {\n  return document.createComment(error instanceof Error ? error.toString() : 'Error:\\n'+JSON.stringify(error,null,2));\n}\n\nexport let enableOnRemovedFromDOM = function () {\n  enableOnRemovedFromDOM = function () {} // Only create the observer once\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList') {\n        m.removedNodes.forEach(\n          removed => removed && removed instanceof Element &&\n            [...removed.getElementsByTagName(\"*\"), removed].filter(elt => !elt.isConnected).forEach(\n              elt => {\n                'onRemovedFromDOM' in elt && typeof elt.onRemovedFromDOM === 'function' && elt.onRemovedFromDOM()\n              }\n            ));\n      }\n    });\n  }).observe(document.body, { subtree: true, childList: true });\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>){\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      }\n    }\n  }\n  new MutationObserver((mutations) => {\n    mutations.forEach(function (m) {\n      if (m.type === 'childList' && m.removedNodes.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\nconst warned = new Set<string>();\nexport function getElementIdMap(node?: Element | Document, ids?: Record<string, Element>) {\n  node = node || document;\n  ids = ids || Object.create(null);\n  if (node.querySelectorAll) {\n    node.querySelectorAll(\"[id]\").forEach(function (elt) {\n      if (elt.id) {\n        if (!ids![elt.id])\n          ids![elt.id] = elt;\n        else if (DEBUG) {\n          if (!warned.has(elt.id)) {\n            warned.add(elt.id)\n            console.info(\"Shadowed multiple element IDs\", elt.id /*, elt, ids![elt.id]*/);\n          }\n        }\n      }\n    });\n  }\n  return ids;\n}\n"],
  "mappings": "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",
  "names": ["v", "a", "result", "ex", "ir", "isMissing", "merged", "c", "n", "value", "isAncestral", "children"]
}

diff --git a/module/esm/iterators.js b/module/esm/iterators.js
index acece30..ce982bd 100644
--- a/module/esm/iterators.js
+++ b/module/esm/iterators.js
@@ -38,11 +38,10 @@ const asyncExtras = {
 };
 const extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)];
 // Like Object.assign, but the assigned properties are not enumerable
-function assignHidden(d, ...srcs) {
-    for (const s of srcs) {
-        for (const [k, pd] of Object.entries(Object.getOwnPropertyDescriptors(s))) {
-            Object.defineProperty(d, k, { ...pd, enumerable: false });
-        }
+function assignHidden(d, s) {
+    const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];
+    for (const k of keys) {
+        Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false });
     }
     return d;
 }
diff --git a/module/src/iterators.ts b/module/src/iterators.ts
index 9de9ee2..6b98a67 100644
--- a/module/src/iterators.ts
+++ b/module/src/iterators.ts
@@ -95,13 +95,12 @@ const asyncExtras = {
 const extraKeys = [...Object.getOwnPropertySymbols(asyncExtras), ...Object.keys(asyncExtras)] as (keyof typeof asyncExtras)[];
 
 // Like Object.assign, but the assigned properties are not enumerable
-function assignHidden<D extends {}, S extends {}>(d: D, ...srcs: S[]) {
-  for (const s of srcs) {
-    for (const [k,pd] of Object.entries(Object.getOwnPropertyDescriptors(s))) {
-      Object.defineProperty(d, k, {...pd, enumerable: false});
-    }
+function assignHidden<D extends {}, S extends {}>(d: D, s: S) {
+  const keys = [...Object.getOwnPropertyNames(s), ...Object.getOwnPropertySymbols(s)];
+  for (const k of keys) {
+    Object.defineProperty(d, k, { ...Object.getOwnPropertyDescriptor(s, k), enumerable: false});
   }
-  return d as D & S; 
+  return d as D & S;
 }
 
 const queue_pending = Symbol('pending');