jtlt 0.12.0 → 0.13.0

package/demo/vendor/jamilih/dist/jml.mjs

@@ -1,6 +1,7 @@
-/* eslint-disable sonarjs/updated-loop-counter -- Ok */
 /* eslint-disable unicorn/prefer-global-this -- Easier */
+/* eslint-disable unicorn/no-break-in-nested-loop -- Performance to avoid function? */
 /* eslint-disable sonarjs/no-control-regex -- Intentional */
+/* eslint-disable unicorn/no-top-level-assignment-in-function -- Only need module level */
 /*
 Possible todos:
 0. Add XSLT to JML-string stylesheet (or even vice versa)
@@ -23,11 +24,28 @@ Other Todos:
 */
 
 /**
- * @typedef {Window & {DocumentFragment: any}} HTMLWindow
+ * @typedef {Window & {DocumentFragment: typeof DocumentFragment}} HTMLWindow
  */
 
 /**
- * @typedef {any} ArbitraryValue
+ * @typedef {unknown} ArbitraryValue
+ */
+
+/**
+ * @typedef {unknown} StoredValue
+ */
+
+/* eslint-disable jsdoc/reject-any-type -- user-defined callback arguments */
+/**
+ * @typedef {any} UserArg
+ */
+/**
+ * @typedef {any} ElementExpando
+ */
+/* eslint-enable jsdoc/reject-any-type */
+
+/**
+ * @typedef {HTMLElement & {[key: string]: ElementExpando}} ExpandoHTMLElement
  */
 
 /**
@@ -49,7 +67,7 @@ Other Todos:
  */
 
 /**
- * @type {import('jsdom').DOMWindow|HTMLWindow|undefined}
+ * @type {import('jsdom').DOMWindow|HTMLWindow|typeof globalThis|undefined}
  */
 let win;
 
@@ -152,9 +170,10 @@ function _appendNode(parent, child) {
 /**
  * Attach event in a cross-browser fashion.
  * @static
- * @param {HTMLElement} el DOM element to which to attach the event
+ * @template {HTMLElement} T
+ * @param {T} el DOM element to which to attach the event
  * @param {string} type The DOM event (without 'on') to attach to the element
- * @param {(evt: Event & {target: HTMLElement}) => void} handler The event handler to attach to the element
+ * @param {(evt: Event & {target: T}) => void} handler The event handler to attach to the element
  * @param {boolean} [capturing] Whether or not the event should be
  *   capturing (W3C-browsers only); default is false; NOT IN USE
  * @returns {void}
@@ -165,13 +184,13 @@ function _addEvent(el, type, handler, capturing) {
 }
 
 /**
-* Creates a text node of the result of resolving an entity or character reference.
-* @param {'entity'|'decimal'|'hexadecimal'} type Type of reference
-* @param {string} prefix Text to prefix immediately after the "&"
-* @param {string} arg The body of the reference
-* @throws {TypeError}
-* @returns {Text} The text node of the resolved reference
-*/
+ * Creates a text node of the result of resolving an entity or character reference.
+ * @param {'entity'|'decimal'|'hexadecimal'} type Type of reference
+ * @param {string} prefix Text to prefix immediately after the "&"
+ * @param {string} arg The body of the reference
+ * @throws {TypeError}
+ * @returns {Text} The text node of the resolved reference
+ */
 function _createSafeReference(type, prefix, arg) {
   /* c8 ignore next 3 */
   if (!doc) {
@@ -184,16 +203,17 @@ function _createSafeReference(type, prefix, arg) {
   }
   const elContainer = doc.createElement('div');
   // Todo: No workaround for XML?
-  // // eslint-disable-next-line no-unsanitized/property
+  // eslint-disable-next-line no-unsanitized/property
   elContainer.innerHTML = '&' + prefix + arg + ';';
+  // eslint-disable-next-line unicorn/prefer-dom-node-html-methods -- No Safari support
   return doc.createTextNode(elContainer.innerHTML);
 }
 
 /**
-* @param {string} n0 Whole expression match (including "-")
-* @param {string} n1 Lower-case letter match
-* @returns {string} Uppercased letter
-*/
+ * @param {string} n0 Whole expression match (including "-")
+ * @param {string} n1 Lower-case letter match
+ * @returns {string} Uppercased letter
+ */
 function _upperCase(n0, n1) {
   return n1.toUpperCase();
 }
@@ -207,24 +227,31 @@ function _isNullish(o) {
   return o === null || o === undefined;
 }
 
+/**
+ * @param {unknown} item
+ * @returns {item is HTMLElement}
+ */
+function _isHTMLElement(item) {
+  return Boolean(item && typeof item === 'object' && 'nodeType' in item && item.nodeType === 1);
+}
+
 // Todo: Make as public utility, but also return types for undefined, boolean, number, document, etc.
 /**
-* @private
-* @static
-* @param {string|JamilihAttributes|JamilihArray|JamilihChildren|
-*   JamilihDocumentFragment|JamilihAttributeNode|
-*   JamilihOptions|HTMLElement|Document|DocumentFragment|null|undefined} item
-* @returns {"string"|"null"|"array"|"element"|"fragment"|"object"|
-*   "symbol"|"bigint"|"function"|"number"|"boolean"|"undefined"|
-*   "document"|"processing-instruction"|"non-container node"}
-*/
+ * @private
+ * @static
+ * @param {string|JamilihAttributes|JamilihArray|JamilihChildren|
+ *   JamilihDocumentFragment|JamilihAttributeNode|
+ *   JamilihOptions|HTMLElement|Document|DocumentFragment|null|undefined} item
+ * @returns {"string"|"null"|"array"|"element"|"fragment"|"object"|
+ *   "symbol"|"bigint"|"function"|"number"|"boolean"|"undefined"|
+ *   "document"|"processing-instruction"|"non-container node"}
+ */
 function _getType(item) {
-  const type = typeof item;
-
   // Appease TS
   if (typeof item === 'string' || typeof item === 'undefined') {
     return 'string';
   }
+  const type = typeof item;
   switch (type) {
     case 'object':
       if (item === null) {
@@ -254,23 +281,31 @@ function _getType(item) {
 }
 
 /**
-* @private
-* @static
-* @param {DocumentFragment} frag
-* @param {Node} node
-* @returns {DocumentFragment}
-*/
+ * @private
+ * @static
+ * @param {DocumentFragment} frag
+ * @param {Node} node
+ * @returns {DocumentFragment}
+ */
 function _fragReducer(frag, node) {
   frag.append(node);
   return frag;
 }
 
 /**
-* @private
-* @static
-* @param {Object<string, string>} xmlnsObj
-* @returns {(...n: string[]) => string}
-*/
+ * @param {string} str
+ * @returns {string}
+ */
+function escapeReplacer(str) {
+  return str.replaceAll('$', '$$$$');
+}
+
+/**
+ * @private
+ * @static
+ * @param {Object<string, string>} xmlnsObj
+ * @returns {(...n: string[]) => string}
+ */
 function _replaceDefiner(xmlnsObj) {
   /**
    * @param {string[]} n
@@ -278,10 +313,10 @@ function _replaceDefiner(xmlnsObj) {
    */
   return function (...n) {
     const n0 = n[0];
-    let retStr = xmlnsObj[''] ? ' xmlns="' + xmlnsObj[''] + '"' : n0; // Preserve XHTML
+    let retStr = xmlnsObj[''] ? ' xmlns="' + escapeReplacer(xmlnsObj['']) + '"' : n0; // Preserve XHTML
     for (const [ns, xmlnsVal] of Object.entries(xmlnsObj)) {
       if (ns !== '') {
-        retStr += ' xmlns:' + ns + '="' + xmlnsVal + '"';
+        retStr += ' xmlns:' + ns + '="' + escapeReplacer(xmlnsVal) + '"';
       }
     }
     return retStr;
@@ -312,30 +347,30 @@ function _childrenToJML(node) {
 /**
  * Keep this in sync with `JamilihArray`'s first argument (minus `Document`).
  * @typedef {JamilihDoc|JamilihDoctype|JamilihTextNode|
-*   JamilihAttributeNode|JamilihOptions|ElementName|HTMLElement|
-*   JamilihDocumentFragment
-* } JamilihFirstArg
-*/
+ *   JamilihAttributeNode|JamilihOptions|ElementName|HTMLElement|
+ *   JamilihDocumentFragment
+ * } JamilihFirstArg
+ */
 
 /**
-* @callback JamilihAppender
-* @param {JamilihArray|JamilihFirstArg|Node|TextNodeString} childJML
-* @returns {void}
-*/
+ * @callback JamilihAppender
+ * @param {JamilihArray|JamilihArrayLike|JamilihFirstArg|Node|TextNodeString} childJML
+ * @returns {void}
+ */
 
 /**
-* @private
-* @static
-* @param {ParentNode} node
-* @returns {JamilihAppender}
-*/
+ * @private
+ * @static
+ * @param {ParentNode} node
+ * @returns {JamilihAppender}
+ */
 function _appendJML(node) {
   return function (childJML) {
     if (typeof childJML === 'string' || typeof childJML === 'number') {
       throw new TypeError('Unexpected text string/number in the head');
     }
     if (Array.isArray(childJML)) {
-      node.append(jml(...childJML));
+      node.append(jml(...(/** @type {JamilihArray} */childJML)));
     } else if (typeof childJML === 'object' && 'nodeType' in childJML) {
       node.append(childJML);
     } else {
@@ -345,23 +380,23 @@ function _appendJML(node) {
 }
 
 /**
-* @callback appender
-* @param {JamilihArray|JamilihFirstArg|Node|TextNodeString} childJML
-* @returns {void}
-*/
+ * @callback appender
+ * @param {JamilihArray|JamilihArrayLike|JamilihFirstArg|Node|TextNodeString} childJML
+ * @returns {void}
+ */
 
 /**
-* @private
-* @static
-* @param {ParentNode} node
-* @returns {appender}
-*/
+ * @private
+ * @static
+ * @param {ParentNode} node
+ * @returns {appender}
+ */
 function _appendJMLOrText(node) {
   return function (childJML) {
     if (typeof childJML === 'string' || typeof childJML === 'number') {
       node.append(String(childJML));
     } else if (Array.isArray(childJML)) {
-      node.append(jml(...childJML));
+      node.append(jml(...(/** @type {JamilihArray} */childJML)));
     } else if (typeof childJML === 'object' && 'nodeType' in childJML) {
       node.append(childJML);
     } else {
@@ -371,9 +406,9 @@ function _appendJMLOrText(node) {
 }
 
 /**
-* @private
-* @static
-*/
+ * @private
+ * @static
+ */
 /*
 function _DOMfromJMLOrString (childNodeJML) {
   if (typeof childNodeJML === 'string') {
@@ -384,9 +419,9 @@ function _DOMfromJMLOrString (childNodeJML) {
 */
 
 /**
-* @typedef {HTMLElement|DocumentFragment|Comment|Attr|
-*    Text|Document|DocumentType|ProcessingInstruction|CDATASection} JamilihReturn
-*/
+ * @typedef {HTMLElement|DocumentFragment|Comment|Attr|
+ *    Text|Document|DocumentType|ProcessingInstruction|CDATASection} JamilihReturn
+ */
 // 'string|JamilihOptions|JamilihDocumentFragment|JamilihAttributes|(string|JamilihArray)[]
 
 /**
@@ -403,11 +438,11 @@ function _DOMfromJMLOrString (childNodeJML) {
 
 /**
  * @typedef {{
-*   open?: boolean|ShadowRootJamilihArrayContainer,
-*   closed?: boolean|ShadowRootJamilihArrayContainer,
-*   template?: string|HTMLTemplateElement|TemplateJamilihArray,
-*   content?: ShadowRootJamilihArrayContainer|DocumentFragment
-* }} JamilihShadowRootObject
+ *   open?: boolean|ShadowRootJamilihArrayContainer,
+ *   closed?: boolean|ShadowRootJamilihArrayContainer,
+ *   template?: string|HTMLTemplateElement|TemplateJamilihArray,
+ *   content?: ShadowRootJamilihArrayContainer|DocumentFragment
+ * }} JamilihShadowRootObject
  */
 
 /**
@@ -429,18 +464,21 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
- * @typedef {(this: HTMLElement, event: Event & {target: HTMLElement}) => void} EventHandler
+ * @template {HTMLElement} [T=HTMLElement]
+ * @typedef {(this: T, event: Event & {target: T}) => void} EventHandler
  */
 
 /**
+ * @template {HTMLElement} [T=HTMLElement]
  * @typedef {{
- *   [key: string]: EventHandler|[EventHandler, boolean]
+ *   [key: string]: EventHandler<T>|[EventHandler<T>, boolean]
  * }} OnAttributeObject
  */
 
 /**
+ * @template {HTMLElement} [T=HTMLElement]
  * @typedef {{
- *   $on?: OnAttributeObject|null
+ *   $on?: OnAttributeObject<T>|null
  * }} OnAttribute
  */
 
@@ -452,7 +490,6 @@ function _DOMfromJMLOrString (childNodeJML) {
  * @typedef {((this: HTMLElement, event?: Event) => void)} HandlerAttributeValue
  */
 
-/* eslint-disable jsdoc/valid-types -- jsdoc-type-pratt-parser Bug */
 /**
  * @typedef {{
  *   [key: string]: HandlerAttributeValue
@@ -476,23 +513,22 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
- * @typedef {{[key: string]: string|number|boolean|((this: DefineMixin, ...args: any[]) => any)}} DefineMixin
+ * @typedef {{[key: string]: unknown}} DefineMixin
  */
 
 /**
  * @typedef {{
  *   new (): HTMLElement;
- *   prototype: HTMLElement & {[key: string]: any}
+ *   prototype: HTMLElement
  * }} DefineConstructor
  */
-/* eslint-enable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/131 */
 
 /**
  * @typedef {(this: HTMLElement) => void} DefineUserConstructor
  */
 
 /**
- * @typedef {[DefineConstructor|DefineUserConstructor|DefineMixin, DefineOptions?]|[DefineConstructor|DefineUserConstructor, DefineMixin?, DefineOptions?]} DefineObjectArray
+ * @typedef {[DefineConstructor|DefineUserConstructor|DefineMixin, DefineOptions?]|[DefineMixin, DefineConstructor]|[DefineConstructor|DefineUserConstructor, DefineMixin?, DefineOptions?]} DefineObjectArray
  */
 
 /**
@@ -500,11 +536,27 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
- * @typedef {{elem?: HTMLElement, [key: string]: any}} SymbolObject
+ * @template [T=ArbitraryValue]
+ * @template {HTMLElement} [U=HTMLElement]
+ * @typedef {T & {elem?: U}} SymbolObject
+ */
+
+/**
+ * @template {HTMLElement} [T=HTMLElement]
+ * @typedef {(this: T, ...args: UserArg[]) => UserArg} SymbolMethod
+ */
+
+/**
+ * @typedef {(...args: UserArg[]) => UserArg} BoundSymbolMethod
  */
 
 /**
- * @typedef {[symbol|string, ((this: HTMLElement, ...args: any[]) => any)|SymbolObject]} SymbolArray
+ * @template {HTMLElement} [T=HTMLElement]
+ * @typedef {[symbol|string, SymbolMethod<T>|SymbolObject<ArbitraryValue, T>]} SymbolArray
+ */
+
+/**
+ * @typedef {BoundSymbolMethod|SymbolObject|ArbitraryValue} SymbolResult
  */
 
 /**
@@ -512,7 +564,7 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
- * @typedef {[string, object]|string|{[key: string]: any}} PluginValue
+ * @typedef {[string, object]|string|object} PluginValue
  */
 
 /**
@@ -527,15 +579,15 @@ function _DOMfromJMLOrString (childNodeJML) {
 
 /**
  * @typedef {{
-*   [key: string]: string|number|((this: HTMLElement, ...args: any[]) => any)
-* }} DataAttributeObject
-*/
+ *   [key: string]: string|number|((this: HTMLElement, ...args: UserArg[]) => UserArg)
+ * }} DataAttributeObject
+ */
 
 /**
  * @typedef {{
- *   $data?: true|string[]|Map<any, any>|WeakMap<any, any>|DataAttributeObject|
+ *   $data?: true|string[]|Map<HTMLElement, UserArg>|WeakMap<HTMLElement, UserArg>|DataAttributeObject|
  *     [undefined, DataAttributeObject]|
- *     [Map<any, any>|WeakMap<any, any>|undefined, DataAttributeObject]
+ *     [Map<HTMLElement, UserArg>|WeakMap<HTMLElement, UserArg>|undefined, DataAttributeObject]
  * }} DataAttribute
  */
 
@@ -557,18 +609,16 @@ function _DOMfromJMLOrString (childNodeJML) {
  * }} JamilihShadowRootAttribute
  */
 
-/* eslint-disable jsdoc/valid-types -- jsdoc-type-pratt-parser Bug */
 /**
  * @typedef {{
  *   is?: string|null,
  *   $define?: DefineObject
  * }} DefineAttribute
  */
-/* eslint-enable jsdoc/valid-types -- jsdoc-type-pratt-parser Bug */
 
 /**
  * @typedef {{
- *   $custom?: {[key: string]: any}
+ *   $custom?: {[key: string]: unknown}
  * }} CustomAttribute
  */
 
@@ -641,21 +691,30 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
+ * @typedef {Document|ElementName|HTMLElement|DocumentFragment|
+ *   JamilihDocumentFragment|JamilihDoc|JamilihDoctype|JamilihTextNode|
+ *   JamilihAttributeNode} JamilihFirstArgument
+ */
+
+/**
+ * Array-form Jamilih input whose tuple positions were widened by operations
+ * such as `Array#map`.
  * @typedef {(
- *   JamilihArray|TextNodeString|HTMLElement|Comment|ProcessingInstruction|
- *   Text|DocumentFragment|JamilihProcessingInstruction|JamilihDocumentFragment|
- *   PluginReference
- * )[]} JamilihChildren
+ *   JamilihFirstArg|JamilihAttributes|JamilihArrayLike|TextNodeString|
+ *   ShadowRoot|null
+ * )[]} JamilihArrayLike
  */
 
-// Todo: DocumentType, Comment, ProcessingInstruction, Text
-// Todo: JamilihCDATANode, JamilihComment, JamilihProcessingInstruction
 /**
- * @typedef {Document|ElementName|HTMLElement|DocumentFragment|
- *   JamilihDocumentFragment|JamilihDoc|JamilihDoctype|JamilihTextNode|
- *   JamilihAttributeNode} JamilihFirstArgument
+ * @typedef {(
+ *   JamilihArray|JamilihArrayLike|TextNodeString|HTMLElement|Comment|
+ *   ProcessingInstruction|Text|DocumentFragment|JamilihProcessingInstruction|
+ *   JamilihDocumentFragment|PluginReference
+ * )[]} JamilihChildren
  */
 
+// Todo: DocumentType, Comment, ProcessingInstruction, Text
+// Todo: JamilihCDATANode, JamilihComment, JamilihProcessingInstruction
 /**
  * This would be clearer with overrides, but using as typedef.
  *
@@ -701,8 +760,8 @@ function _DOMfromJMLOrString (childNodeJML) {
 
 /**
  * @typedef {{
- *   root: [Map<HTMLElement,any>|WeakMap<HTMLElement,any>, any],
- *   [key: string]: [Map<HTMLElement,any>|WeakMap<HTMLElement,any>, any]
+ *   root: [Map<HTMLElement,UserArg>|WeakMap<HTMLElement,UserArg>, UserArg],
+ *   [key: string]: [Map<HTMLElement,UserArg>|WeakMap<HTMLElement,UserArg>, UserArg]
  * }} MapWithRoot
  */
 
@@ -714,7 +773,7 @@ function _DOMfromJMLOrString (childNodeJML) {
  * @typedef {object} JamilihOptions
  * @property {TraversalState} [$state]
  * @property {JamilihPlugin[]} [$plugins]
- * @property {MapWithRoot|[Map<HTMLElement,any>|WeakMap<HTMLElement,any>, any]} [$map]
+ * @property {MapWithRoot|[Map<HTMLElement,UserArg>|WeakMap<HTMLElement,UserArg>, UserArg]} [$map]
  */
 
 /**
@@ -754,27 +813,213 @@ function getMatchingPlugin(opts, pluginName) {
   });
 }
 
-/* eslint-disable jsdoc/valid-types -- pratt parser bug  */
 /**
  * @template T
  * @typedef {T[keyof T]} ValueOf
  */
-/* eslint-enable jsdoc/valid-types -- pratt parser bug  */
 
-/* eslint-disable jsdoc/valid-types -- pratt parser bug  */
+/**
+ * @template {JamilihArray} T
+ * @typedef {Extract<Extract<T[number], {$custom?: {[key: string]: unknown}}>['$custom'], object>} RawCustomFromJamilihArray
+ */
+
+/**
+ * @template M
+ * @typedef {M extends object
+ *   ? string extends keyof M
+ *     ? object
+ *     : M
+ *   : object} SpecificDefineMixin
+ */
+
+/**
+ * @template D
+ * @typedef {D extends [infer First, infer Second, ...ArbitraryValue[]]
+ *   ? (First extends DefineMixin
+ *     ? SpecificDefineMixin<First>
+ *     : Second extends DefineMixin
+ *       ? SpecificDefineMixin<Second>
+ *       : object)
+ *   : D extends [infer First]
+ *     ? First extends DefineMixin
+ *       ? SpecificDefineMixin<First>
+ *       : object
+ *   : D extends DefineMixin
+ *     ? SpecificDefineMixin<D>
+ *     : object} DefineMixinFromValue
+ */
+
+/**
+ * @template {JamilihArray} T
+ * @typedef {T[number] extends infer Item
+ *   ? Item extends {$define: infer D}
+ *     ? DefineMixinFromValue<D>
+ *     : never
+ *   : never} RawDefineMixinFromJamilihArray
+ */
+
+/**
+ * @template D
+ * @typedef {D extends [infer First, infer Second, ...ArbitraryValue[]]
+ *   ? First extends DefineConstructor
+ *     ? First['prototype']
+ *     : Second extends DefineConstructor
+ *       ? Second['prototype']
+ *       : never
+ *   : D extends DefineConstructor
+ *     ? D['prototype']
+ *     : never} ElementFromDefineValue
+ */
+
+/**
+ * @template {JamilihArray} T
+ * @typedef {T[number] extends infer Item
+ *   ? Item extends {$define: infer D}
+ *     ? ElementFromDefineValue<D>
+ *     : never
+ *   : never} ElementFromJamilihDefine
+ */
+
+/**
+ * @template {JamilihArray} T
+ * @typedef {Extract<T[number], {xmlns: unknown}> extends never ? false : true} HasXmlnsFromJamilihArray
+ */
+
+/**
+ * @template {JamilihArray} T
+ * @typedef {T extends [infer K, ...ArbitraryValue[]]
+ *   ? (HasXmlnsFromJamilihArray<T> extends true
+ *     ? Element
+ *     : ElementFromJamilihDefine<T> extends never
+ *       ? K extends keyof HTMLElementTagNameMap
+ *         ? HTMLElementTagNameMap[K]
+ *         : HTMLElement
+ *       : ElementFromJamilihDefine<T>)
+ *   : Element} ElementFromJamilihArray
+ */
+
+/**
+ * @template A
+ * @template {Element} E
+ * @template X
+ * @typedef {A extends {$custom: infer C}
+ *   ? (C extends object
+ *     ? Omit<A, '$custom'> & {$custom?: C & ThisType<E & C & X>}
+ *     : A)
+ *   : A} WithCustomThis
+ */
+
+/**
+ * @template D
+ * @template {Element} E
+ * @template X
+ * @typedef {D extends [infer First, infer Second, ...infer Rest]
+ *   ? (First extends DefineMixin
+ *     ? [First & ThisType<E & First & X>, Second, ...Rest]
+ *     : Second extends DefineMixin
+ *       ? [First, Second & ThisType<E & Second & X>, ...Rest]
+ *       : D)
+ *   : D extends [infer First]
+ *     ? First extends DefineMixin
+ *       ? [First & ThisType<E & First & X>]
+ *       : D
+ *   : D extends DefineMixin
+ *     ? D & ThisType<E & D & X>
+ *     : D} WithDefineThisValue
+ */
+
+/**
+ * @template A
+ * @template {Element} E
+ * @template X
+ * @typedef {A extends {$define: infer D}
+ *   ? Omit<A, '$define'> & {$define?: WithDefineThisValue<D, E, X>}
+ *   : A} WithDefineThis
+ */
+
+/**
+ * @template A
+ * @typedef {A extends {$custom: infer C}
+ *   ? C extends object ? C : object
+ *   : object} CustomFromJamilihItem
+ */
+
+/**
+ * @template A
+ * @typedef {A extends {$define: infer D}
+ *   ? DefineMixinFromValue<D>
+ *   : object} DefineMixinFromJamilihItem
+ */
+
+/**
+ * @template {JamilihArray} T
+ * @template {Element} E
+ * @typedef {{[K in keyof T]: WithCustomThis<
+ *   WithDefineThis<T[K], E, CustomFromJamilihItem<T[K]>>,
+ *   E,
+ *   DefineMixinFromJamilihItem<T[K]>
+ * >}} JamilihArrayWithCustomThis
+ */
+
+/**
+ * @template A
+ * @typedef {A extends (infer Item)[]
+ *   ? (Extract<Item, JamilihFirstArg> extends never ? never : A)
+ *   : A} ValidateJamilihArrayLike
+ */
+
+/**
+ * @template A
+ * @typedef {A extends (infer Child)[]
+ *   ? A & (Child extends unknown[] ? ValidateJamilihArrayLike<Child> : Child)[]
+ *   : A} ValidateJamilihChildContainer
+ */
+
+/**
+ * @template {JamilihArray} T
+ * @typedef {{[K in keyof T]: ValidateJamilihChildContainer<T[K]>}} ValidateJamilihArrayLikes
+ */
+
+/**
+ * @template {JamilihArray} T
+ * @typedef {(
+ *   RawCustomFromJamilihArray<T> extends never
+ *     ? object
+ *     : RawCustomFromJamilihArray<T>
+ * )} CustomFromJamilihArray
+ */
+
+/**
+ * @template {JamilihArray} T
+ * @typedef {(
+ *   RawDefineMixinFromJamilihArray<T> extends never
+ *     ? object
+ *     : RawDefineMixinFromJamilihArray<T>
+ * )} DefineMixinFromJamilihArray
+ */
+
+/**
+ * @template U
+ * @template W
+ * @typedef {U extends void ? (ExpandoHTMLElement & W) : (U & W)} ResolvedElement
+ */
+
 /**
  * Creates an XHTML or HTML element (XHTML is preferred, but only in browsers
  * that support); any element after element can be omitted, and any subsequent
  * type or types added afterwards.
  * @template {JamilihArray} T
- * @param {T} args
- * @returns {T extends [keyof HTMLElementTagNameMap, any?, any?, any?]
- *   ? HTMLElementTagNameMap[T[0]] : JamilihReturn}
+ * @template {T extends [infer K, ...ArbitraryValue[]] ? (HasXmlnsFromJamilihArray<T> extends true ? Element : ElementFromJamilihDefine<T> extends never ? K extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[K] : K extends string ? HTMLElement : void : ElementFromJamilihDefine<T>) : void} U
+ * @template {ElementFromJamilihArray<T>} E
+ * @template {CustomFromJamilihArray<T>} W
+ * @template {DefineMixinFromJamilihArray<T>} D
+ * @param {JamilihArrayWithCustomThis<T, E> & ValidateJamilihArrayLikes<T>} args
+ * @returns {U extends void ? JamilihReturn : ResolvedElement<U, W & D>}
  * The newly created (and possibly already appended)
  *   element or array of elements
  */
+
 const jml = function jml(...args) {
-  /* eslint-enable jsdoc/valid-types -- pratt parser bug  */
   if (!win) {
     throw new Error('No window object');
   }
@@ -782,7 +1027,7 @@ const jml = function jml(...args) {
     throw new Error('No document object');
   }
 
-  /** @type {(Document|DocumentFragment|HTMLElement) & {[key: string]: any}} */
+  /** @type {(Document|DocumentFragment|HTMLElement) & {[key: string]: ElementExpando}} */
   let elem = doc.createDocumentFragment();
   /**
    *
@@ -797,20 +1042,15 @@ const jml = function jml(...args) {
     }
     for (let [att, attVal] of Object.entries(atts)) {
       att = ATTR_MAP.has(att) ? String(ATTR_MAP.get(att)) : att;
-
-      /**
-       * @typedef {any} ElementExpando
-       */
-
       if (NULLABLES.has(att)) {
         attVal = checkPluginValue(elem, att, /** @type {string|JamilihArray} */attVal, opts);
         if (!_isNullish(attVal)) {
-          /** @type {ElementExpando} */elem[att] = attVal;
+          elem[att] = attVal;
         }
         continue;
-      } else if (ATTR_DOM.has(att)) {
+      }
+      if (ATTR_DOM.has(att)) {
         attVal = checkPluginValue(elem, att, /** @type {string|JamilihArray} */attVal, opts);
-        /** @type {ElementExpando} */
         elem[att] = attVal;
         continue;
       }
@@ -895,6 +1135,9 @@ const jml = function jml(...args) {
           }
         case '$custom':
           {
+            if (attVal !== null && (typeof attVal === 'object' || typeof attVal === 'function') && Object.prototype.propertyIsEnumerable.call(attVal, '__proto__')) {
+              throw new TypeError('`$custom` may not define `__proto__`');
+            }
             Object.assign(elem, attVal);
             break;
           }
@@ -965,7 +1208,8 @@ const jml = function jml(...args) {
             const defineObj = /** @type {DefineObject} */attVal;
             if (Array.isArray(defineObj)) {
               if (defineObj.length <= 2) {
-                [cnstrctr, options] = defineObj;
+                [cnstrctr] = defineObj;
+                options = /** @type {DefineOptions|undefined} */defineObj[1];
                 if (typeof options === 'string') {
                   // Todo: Allow creating a definition without using it;
                   //  that may be the only reason to have a string here which
@@ -1004,7 +1248,7 @@ const jml = function jml(...args) {
             }
             if (mixin) {
               Object.entries(mixin).forEach(([methodName, method]) => {
-                /** @type {DefineConstructor} */cnstrctr.prototype[methodName] = method;
+                Reflect.set(/** @type {DefineConstructor} */cnstrctr.prototype, methodName, method);
               });
             }
             // console.log('def', def, '::', typeof options === 'object' ? options : undefined);
@@ -1013,9 +1257,13 @@ const jml = function jml(...args) {
           }
         case '$symbol':
           {
-            const [symbol, func] = /** @type {SymbolArray} */attVal;
+            if (!_isHTMLElement(elem)) {
+              throw new TypeError('Element expected for `$symbol`');
+            }
+            const symbolElem = /** @type {ResolvedElement<U, W>} */elem;
+            const [symbol, func] = /** @type {SymbolArray<ResolvedElement<U, W>>} */attVal;
             if (typeof func === 'function') {
-              const funcBound = func.bind(/** @type {HTMLElement} */elem);
+              const funcBound = func.bind(symbolElem);
               if (typeof symbol === 'string') {
                 // @ts-expect-error
                 elem[Symbol.for(symbol)] = funcBound;
@@ -1025,7 +1273,7 @@ const jml = function jml(...args) {
               }
             } else {
               const obj = func;
-              obj.elem = /** @type {HTMLElement} */elem;
+              obj.elem = symbolElem;
               if (typeof symbol === 'string') {
                 // @ts-expect-error
                 elem[Symbol.for(symbol)] = obj;
@@ -1038,7 +1286,7 @@ const jml = function jml(...args) {
           }
         case '$data':
           {
-            setMap(/** @type {true|string[]|Map<any, any>|WeakMap<any, any>|DataAttributeObject} */
+            setMap(/** @type {true|string[]|Map<HTMLElement, unknown>|WeakMap<HTMLElement, unknown>|DataAttributeObject} */
             attVal);
             break;
           }
@@ -1061,15 +1309,15 @@ const jml = function jml(...args) {
         case '$document':
           {
             // Todo: Conditionally create XML document
-            const docNode = doc.implementation.createHTMLDocument();
             if (!attVal) {
               throw new Error('Bad attribute value');
             }
+            const docNode = doc.implementation.createHTMLDocument();
             const jamlihDoc = /** @type {JamilihDocument} */attVal;
             if (jamlihDoc.childNodes) {
               // Remove any extra nodes created by createHTMLDocument().
               const j = jamlihDoc.childNodes.length;
-              while (docNode.childNodes[j]) {
+              while (Object.hasOwn(docNode.childNodes, j)) {
                 const cn = docNode.childNodes[j];
                 cn.remove();
                 // `j` should stay the same as removing will cause node to be present
@@ -1094,7 +1342,7 @@ const jml = function jml(...args) {
                 if (jamlihDoc.title) {
                   docNode.title = jamlihDoc.title; // Appends after meta
                 }
-                if (jamlihDoc.head && head) {
+                if (head && jamlihDoc.head) {
                   // each child of `head` is:
                   //  (JamilihArray|TextNodeString|HTMLElement|Comment|ProcessingInstruction|
                   //  Text|DocumentFragment|JamilihProcessingInstruction|JamilihDocumentFragment)
@@ -1108,7 +1356,7 @@ const jml = function jml(...args) {
                   jamlihDoc.head.forEach(_appendJML(head));
                 }
               }
-              if (jamlihDoc.body && body) {
+              if (body && jamlihDoc.body) {
                 jamlihDoc.body.forEach(_appendJMLOrText(body));
               }
             }
@@ -1135,16 +1383,17 @@ const jml = function jml(...args) {
         case '$on':
           {
             // Events
+            const onElem = /** @type {ResolvedElement<U, W>} */elem;
             // Allow for no-op by defaulting to `{}`
-            // eslint-disable-next-line prefer-const -- Ok as mixed
-            for (let [p2, val] of Object.entries(/** @type {OnAttributeObject} */attVal || {})) {
+            // eslint-disable-next-line prefer-const, unicorn/no-unreadable-for-of-expression -- Ok as mixed
+            for (let [p2, val] of Object.entries(/** @type {OnAttributeObject<ResolvedElement<U, W>>} */attVal || {})) {
               if (typeof val === 'function') {
                 val = [val, false];
               }
               if (typeof val[0] !== 'function') {
                 throw new TypeError(`Expect a function for \`$on\`; args: ${JSON.stringify(args)}`);
               }
-              _addEvent(/** @type {HTMLElement} */elem, p2, val[0], val[1]); // element, event name, handler, capturing
+              _addEvent(onElem, p2, val[0], val[1]); // element, event name, handler, capturing
             }
             break;
           }
@@ -1168,7 +1417,11 @@ const jml = function jml(...args) {
               const pastInitialProp = startProp !== '';
               Object.keys(atVal).forEach(key => {
                 const value = atVal[key];
-                prop = pastInitialProp ? startProp + key.replaceAll(hyphenForCamelCase, _upperCase).replace(/^([a-z])/u, _upperCase) : startProp + key.replaceAll(hyphenForCamelCase, _upperCase);
+                prop = startProp + (pastInitialProp
+                // eslint-disable-next-line unicorn/no-unsafe-string-replacement -- Function
+                ? key.replaceAll(hyphenForCamelCase, _upperCase).replace(/^([a-z])/u, _upperCase)
+                // eslint-disable-next-line unicorn/no-unsafe-string-replacement -- Function
+                : key.replaceAll(hyphenForCamelCase, _upperCase));
                 if (value === null || typeof value !== 'object') {
                   if (!_isNullish(value)) {
                     elem.dataset[prop] = value;
@@ -1187,7 +1440,7 @@ const jml = function jml(...args) {
         // Don't remove this `if` block (for sake of no-innerHTML build)
         case 'innerHTML':
           if (!_isNullish(attVal)) {
-            // // eslint-disable-next-line no-unsanitized/property
+            // eslint-disable-next-line no-unsanitized/property
             elem.innerHTML = attVal;
           }
           break;
@@ -1229,6 +1482,7 @@ const jml = function jml(...args) {
                       elem.style.cssFloat = styleVal;
                       elem.style.styleFloat = styleVal; // Harmless though we could make conditional on older IE instead
                     } else {
+                      // eslint-disable-next-line unicorn/no-unsafe-string-replacement -- Function
                       elem.style[p2.replaceAll(hyphenForCamelCase, _upperCase)] = styleVal;
                     }
                   }
@@ -1318,12 +1572,12 @@ const jml = function jml(...args) {
   const defaultMap = opts.$map && /** @type {MapWithRoot} */opts.$map.root;
 
   /**
-   * @param {true|string[]|Map<any, any>|WeakMap<any, any>|DataAttributeObject} dataVal
+   * @param {true|string[]|Map<HTMLElement, UserArg>|WeakMap<HTMLElement, UserArg>|DataAttributeObject|[Map<HTMLElement, UserArg>|WeakMap<HTMLElement, UserArg>|undefined, DataAttributeObject|UserArg]} dataVal
    * @returns {void}
    */
   const setMap = dataVal => {
     let map, obj;
-    const defMap = /** @type {[Map<HTMLElement, any> | WeakMap<HTMLElement, any>, any]} */defaultMap;
+    const defMap = /** @type {[Map<HTMLElement, UserArg> | WeakMap<HTMLElement, UserArg>, UserArg]} */defaultMap;
     // Boolean indicating use of default map and object
     if (dataVal === true) {
       [map, obj] = defMap;
@@ -1347,7 +1601,7 @@ const jml = function jml(...args) {
       map = defMap[0];
       obj = dataVal;
     }
-    /** @type {Map<HTMLElement, any> | WeakMap<HTMLElement, any>} */
+    /** @type {Map<HTMLElement, UserArg> | WeakMap<HTMLElement, UserArg>} */
     map.set(/** @type {HTMLElement} */
     elem, obj);
   };
@@ -1359,7 +1613,7 @@ const jml = function jml(...args) {
         // null always indicates a place-holder (only needed for last argument if want array returned)
         if (i === argc - 1) {
           // Casting needing unless changing `jml()` signature with overloads
-          return /** @type {ArbitraryValue} */nodes.length <= 1 ? nodes[0]
+          return /** @type {U extends void ? JamilihReturn : ResolvedElement<U, W & D>} */nodes.length <= 1 ? nodes[0]
           // eslint-disable-next-line unicorn/no-array-callback-reference
           : nodes.reduce(_fragReducer, doc.createDocumentFragment()); // nodes;
         }
@@ -1378,7 +1632,7 @@ const jml = function jml(...args) {
               if (val && typeof val === 'object') {
                 const procValues = [];
                 for (const [p, procInstVal] of Object.entries(val)) {
-                  procValues.push(p + '=' + '"' +
+                  procValues.push(p + '="' +
                   // https://www.w3.org/TR/xml-stylesheet/#NT-PseudoAttValue
                   procInstVal.replaceAll('"', '&quot;') + '"');
                 }
@@ -1440,13 +1694,12 @@ const jml = function jml(...args) {
                 /* c8 ignore next 4 */
                 elem = doc.createElementNS
                 // Should create separate file for this
-                /* eslint-disable object-shorthand -- Casting */ ? (/** @type {HTMLElement} */doc.createElementNS(NS_HTML, elStr, {
+                ? (/** @type {HTMLElement} */doc.createElementNS(NS_HTML, elStr, {
                   is: (/** @type {string} */is)
                 })
                 /* c8 ignore next 1 */) : doc.createElement(elStr, {
                   is: (/** @type {string} */is)
                 });
-                /* eslint-enable object-shorthand -- Casting */
               } else /* c8 ignore next */if (doc.createElementNS) {
                   elem = doc.createElementNS(NS_HTML, elStr);
                   /* c8 ignore next 3 */
@@ -1474,15 +1727,16 @@ const jml = function jml(...args) {
             // elem.setAttribute('xmlns', atts.xmlns); // Doesn't work
             // Can't set namespaceURI dynamically, renameNode() is not supported, and setAttribute() doesn't work to change the namespace, so we resort to this hack
             const xmlnsObj = /** @type {XmlnsAttributeObject} */atts;
-            const replacer = xmlnsObj.xmlns && typeof xmlnsObj.xmlns === 'object' ? _replaceDefiner(xmlnsObj.xmlns) : ' xmlns="' + xmlnsObj.xmlns + '"';
+            const replacer = xmlnsObj.xmlns && typeof xmlnsObj.xmlns === 'object' ? _replaceDefiner(xmlnsObj.xmlns) : ' xmlns="' + escapeReplacer(xmlnsObj.xmlns) + '"';
             // try {
             // Also fix DOMParser to work with text/html
             elem = nodes[nodes.length - 1] =
             // Why doesn't `HTMLWindow` have `DOMParser`?
             new /** @type {import('jsdom').DOMWindow} */win.DOMParser().parseFromString(new /** @type {import('jsdom').DOMWindow} */win.XMLSerializer().serializeToString(elem).
             // Mozilla adds XHTML namespace
-            replace(' xmlns="' + NS_HTML + '"',
+            replace(' xmlns="' + escapeReplacer(NS_HTML) + '"',
             // Needed to cast here, despite either overload working
+            // eslint-disable-next-line unicorn/no-unsafe-string-replacement -- Escaped
             /** @type {string} */
             replacer), 'application/xml').documentElement;
             // Todo: Report to plugins
@@ -1521,12 +1775,19 @@ const jml = function jml(...args) {
           // Arrays or arrays of arrays indicate child nodes
           const child = /** @type {JamilihChildren} */arg;
           const cl = child.length;
+          /**
+           * @param {number} childIndex
+           * @returns {TypeError}
+           */
+          const getBadChildrenError = childIndex => {
+            return new TypeError(`Bad children (parent array: ${JSON.stringify(args)}; index ${childIndex} of child: ${JSON.stringify(child)})`);
+          };
           for (let j = 0; j < cl; j++) {
             // Go through children array container to handle elements
             const childContent = child[j];
             const childContentType = typeof childContent;
             if (childContent === null || _isNullish(childContent)) {
-              throw new TypeError(`Bad children (parent array: ${JSON.stringify(args)}; index ${j} of child: ${JSON.stringify(child)})`);
+              throw getBadChildrenError(j);
             }
             switch (childContentType) {
               // Todo: determine whether null or function should have special handling or be converted to text
@@ -1538,12 +1799,17 @@ const jml = function jml(...args) {
               default:
                 // bigint, symbol, function
                 if (typeof childContent !== 'object') {
-                  throw new TypeError(`Bad children (parent array: ${JSON.stringify(args)}; index ${j} of child: ${JSON.stringify(child)})`);
+                  throw getBadChildrenError(j);
                 }
                 if (Array.isArray(childContent)) {
                   // Arrays representing child elements
+                  const childHeadType = typeof childContent[0];
+                  if (childContent.length === 0 || childHeadType !== 'string' && childHeadType !== 'object' || childContent[0] === null) {
+                    throw getBadChildrenError(j);
+                  }
                   opts.$state = 'children';
-                  _appendNode(elem, jml(opts, ...childContent));
+                  const childArgs = /** @type {JamilihArray} */[opts, ...childContent];
+                  _appendNode(elem, jml(...childArgs));
                 } else if ('#' in childContent) {
                   // Fragment
                   opts.$state = 'fragmentChildren';
@@ -1573,7 +1839,7 @@ const jml = function jml(...args) {
   }
 
   // Casting needing unless changing `jml()` signature with overloads
-  return /** @type {ArbitraryValue} */ret;
+  return /** @type {U extends void ? JamilihReturn : ResolvedElement<U, W & D>} */ret;
 };
 
 /**
@@ -1643,8 +1909,8 @@ class DOMException extends Error {
 
 /**
  * @typedef {JamilihArray|JamilihDoctype|
-*    JamilihCDATANode|JamilihEntityReference|JamilihProcessingInstruction|
-*    JamilihComment|JamilihDocumentFragment} JamilihChildType
+ *    JamilihCDATANode|JamilihEntityReference|JamilihProcessingInstruction|
+ *    JamilihComment|JamilihDocumentFragment} JamilihChildType
  */
 
 /**
@@ -1652,15 +1918,15 @@ class DOMException extends Error {
  */
 
 /**
-* Converts a DOM object or a string of HTML into a Jamilih object (or string).
-* @param {string|HTMLElement|Node|Entity} nde If a string, will parse as document
-* @param {ToJmlConfig} [config] Configuration object
-* @throws {TypeError}
-* @returns {JamilihType|string} Array containing the elements which represent
-* a Jamilih object, or, if `stringOutput` is true, it will be the stringified
-* version of such an object
-*/
-jml.toJML = function (nde, {
+ * Converts a DOM object or a string of HTML into a Jamilih object (or string).
+ * @param {string|HTMLElement|Node|Entity} nde If a string, will parse as document
+ * @param {ToJmlConfig} [config] Configuration object
+ * @throws {TypeError}
+ * @returns {JamilihType|string} Array containing the elements which represent
+ * a Jamilih object, or, if `stringOutput` is true, it will be the stringified
+ * version of such an object
+ */
+const toJML = function (nde, {
   stringOutput = false,
   reportInvalidState = true,
   stripWhitespace = false
@@ -1675,7 +1941,7 @@ jml.toJML = function (nde, {
 
   /**
    * @todo Find more specific type than `any`
-   * @typedef {{[key: (number|string)]: any}} IndexableObject
+   * @typedef {{[key: (number|string)]: UserArg}} IndexableObject
    */
 
   const ret = /** @type {IndexableObject} */[];
@@ -1689,12 +1955,14 @@ jml.toJML = function (nde, {
    */
   function invalidStateError(msg) {
     // These are probably only necessary if working with text/html
-    if (reportInvalidState) {
-      // INVALID_STATE_ERR per section 9.3 XHTML 5: http://www.w3.org/TR/html5/the-xhtml-syntax.html
-      const e = new DOMException(msg, 'INVALID_STATE_ERR');
-      e.code = 11;
-      throw e;
+    if (!reportInvalidState) {
+      return;
     }
+
+    // INVALID_STATE_ERR per section 9.3 XHTML 5: https://www.w3.org/TR/html5/the-xhtml-syntax.html
+    const e = new DOMException(msg, 'INVALID_STATE_ERR');
+    e.code = 11;
+    throw e;
   }
 
   /**
@@ -1781,8 +2049,13 @@ jml.toJML = function (nde, {
     namespaces = {
       ...namespaces
     };
-    const xmlChars = /^([\u0009\u000A\u000D\u0020-\uD7FF\uE000-\uFFFD]|[\uD800-\uDBFF][\uDC00-\uDFFF])*$/u; // eslint-disable-line no-control-regex
-    if ([2, 3, 4, 7, 8].includes(type) && /** @type {Node} */nodeOrEntity.nodeValue && !xmlChars.test(/** @type {Node} */nodeOrEntity.nodeValue)) {
+    const xmlChars = /^([\u{9}\u{A}\u{D}\u{20}-\u{D7FF}\u{E000}-\u{FFFD}]|[\uD800-\uDBFF][\uDC00-\uDFFF])*$/u; // eslint-disable-line no-control-regex
+
+    // eslint-disable-next-line prefer-destructuring -- TS
+    const nodeValue = /** @type {Node} */nodeOrEntity.nodeValue;
+    if ([2, 3, 4, 7, 8].includes(type) &&
+    // eslint-disable-next-line unicorn/prefer-simple-condition-first -- Safer
+    nodeValue && !xmlChars.test(nodeValue)) {
       invalidStateError('Node has bad XML character value');
     }
 
@@ -1886,6 +2159,7 @@ jml.toJML = function (nde, {
         {
           // CDATA
           const node = /** @type {CDATASection} */nodeOrEntity;
+          // eslint-disable-next-line unicorn/no-useless-concat -- Safer if pasting
           if (node.nodeValue?.includes(']]' + '>')) {
             invalidStateError('CDATA cannot end with closing ]]>');
           }
@@ -1969,7 +2243,7 @@ jml.toJML = function (nde, {
               name: /** @type {DocumentType} */node.name
             }
           };
-          const pubIdChar = /^(\u0020|\u000D|\u000A|[a-zA-Z0-9]|[-'()+,./:=?;!*#@$_%])*$/u; // eslint-disable-line no-control-regex
+          const pubIdChar = /^(\u{20}|\u{D}|\u{A}|[a-zA-Z0-9]|[-'()+,./:=?;!*#@$_%])*$/u; // eslint-disable-line no-control-regex
           if (!pubIdChar.test(/** @type {DocumentType} */node.publicId)) {
             invalidStateError('A publicId must have valid characters.');
           }
@@ -2011,34 +2285,37 @@ jml.toJML = function (nde, {
   }
   return ret[0];
 };
+jml.toJML = toJML;
 
 /**
  * @param {string|HTMLElement} dom
  * @param {ToJmlConfig} [config]
  * @returns {string}
  */
-jml.toJMLString = function (dom, config) {
-  return /** @type {string} */jml.toJML(dom, Object.assign(config || {}, {
+const toJMLString = function (dom, config) {
+  return /** @type {string} */toJML(dom, Object.assign(config || {}, {
     stringOutput: true
   }));
 };
+jml.toJMLString = toJMLString;
 
 /**
  *
  * @param {JamilihArray} args
  * @returns {JamilihReturn}
  */
-jml.toDOM = function (...args) {
+const toDOM = function (...args) {
   // Alias for jml()
   return jml(...args);
 };
+jml.toDOM = toDOM;
 
 /**
  *
  * @param {JamilihArray} args
  * @returns {string}
  */
-jml.toHTML = function (...args) {
+const toHTML = function (...args) {
   // Todo: Replace this with version of jml() that directly builds a string
   const ret = jml(...args);
   switch (ret.nodeType) {
@@ -2053,18 +2330,20 @@ jml.toHTML = function (...args) {
     case 2:
       {
         // ATTR
-        return `${/** @type {Attr} */ret.name}="${/** @type {Attr} */ret.value.replaceAll('"', '&quot;')}"`;
+        return `${ /** @type {Attr} */ret.name}="${ /** @type {Attr} */ret.value.replaceAll('"', '&quot;')}"`;
       }
     case 3:
       {
         // TEXT
         // Fallthrough
         // } case 4: { // CDATA
+        // eslint-disable-next-line prefer-destructuring -- TS
+        const nodeValue = /** @type {Text|CDATASection} */ret.nodeValue;
         /* c8 ignore next 3 */
-        if (!ret.nodeValue) {
+        if (!nodeValue) {
           throw new TypeError('Unexpected null Text node');
         }
-        return /** @type {Text|CDATASection} */ret.nodeValue;
+        return nodeValue;
         // case 5: // Entity Reference Node
         //  No 6: Entity Node
         //  No 12: Notation Node
@@ -2076,7 +2355,6 @@ jml.toHTML = function (...args) {
         return `<?${node.target} ${node.data}?>`;
         // } case 8: { // Comment
         //   return `<!--${ret.nodeValue}-->`;
-        // eslint-disable-next-line sonarjs/no-fallthrough
       }
     case 9:
     case 11:
@@ -2084,7 +2362,7 @@ jml.toHTML = function (...args) {
         // DOCUMENT FRAGMENT
         const node = /** @type {DocumentFragment} */ret;
         return [...node.childNodes].map(childNode => {
-          return jml.toHTML(/** @type {JamilihFirstArgument} */childNode);
+          return toHTML(/** @type {JamilihFirstArgument} */childNode);
         }).join('');
       }
     case 10:
@@ -2098,47 +2376,52 @@ jml.toHTML = function (...args) {
       throw new Error('Unexpected node type');
   }
 };
+jml.toHTML = toHTML;
 
 /**
  *
  * @param {JamilihArray} args
  * @returns {string}
  */
-jml.toDOMString = function (...args) {
+const toDOMString = function (...args) {
   // Alias for jml.toHTML for parity with jml.toJMLString
-  return jml.toHTML(...args);
+  return toHTML(...args);
 };
+jml.toDOMString = toDOMString;
 
 /**
  *
  * @param {JamilihArray} args
  * @returns {string}
  */
-jml.toXML = function (...args) {
+const toXML = function (...args) {
   if (!win) {
     throw new Error('No window object set');
   }
   const ret = jml(...args);
   return new /** @type {import('jsdom').DOMWindow} */win.XMLSerializer().serializeToString(ret);
 };
+jml.toXML = toXML;
 
 /**
  *
  * @param {JamilihArray} args
  * @returns {string}
  */
-jml.toXMLDOMString = function (...args) {
+const toXMLDOMString = function (...args) {
   // Alias for jml.toXML for parity with jml.toJMLString
-  return jml.toXML(...args);
+  return toXML(...args);
 };
+jml.toXMLDOMString = toXMLDOMString;
 
 /**
  * Element-aware wrapper for `Map`.
+ * @template V
  */
 class JamilihMap extends Map {
   /**
    * @param {?(string|HTMLElement)} element
-   * @returns {ArbitraryValue}
+   * @returns {V}
    */
   get(element) {
     const elem = typeof element === 'string' ? $(element) : element;
@@ -2146,78 +2429,82 @@ class JamilihMap extends Map {
   }
   /**
    * @param {string|HTMLElement} element
-   * @param {ArbitraryValue} value
-   * @returns {ArbitraryValue}
+   * @param {V} value
+   * @returns {this}
    */
   set(element, value) {
     const elem = typeof element === 'string' ? $(element) : element;
-    return super.set.call(this, elem, value);
+    super.set.call(this, elem, value);
+    return this;
   }
   /**
    * @param {string|HTMLElement} element
    * @param {string} methodName
-   * @param {...ArbitraryValue} args
-   * @returns {ArbitraryValue}
+   * @param {...UserArg} args
+   * @returns {StoredValue}
    */
   invoke(element, methodName, ...args) {
     const elem = typeof element === 'string' ? $(element) : element;
-    return this.get(elem)[methodName](elem, ...args);
+    return /** @type {UserArg} */this.get(elem)[methodName](elem, ...args);
   }
 }
 
 /**
  * Element-aware wrapper for `WeakMap`.
- * @extends {WeakMap<any>}
+ * @template V
  */
 class JamilihWeakMap extends WeakMap {
   /**
-   * @param {HTMLElement} element
-   * @returns {ArbitraryValue}
+   * @param {?(string|object|symbol)} element
+   * @returns {V}
    */
   get(element) {
     const elem = typeof element === 'string' ? $(element) : element;
     if (!elem) {
       throw new Error("Can't find the element");
     }
-    return super.get.call(this, elem);
+    return super.get.call(this, /** @type {object} */elem);
   }
   /**
-   * @param {HTMLElement} element
-   * @param {ArbitraryValue} value
-   * @returns {ArbitraryValue}
+   * @param {?(string|object|symbol)} element
+   * @param {V} value
+   * @returns {this}
    */
   set(element, value) {
     const elem = typeof element === 'string' ? $(element) : element;
     if (!elem) {
       throw new Error("Can't find the element");
     }
-    return super.set.call(this, elem, value);
+    super.set.call(this, /** @type {object} */elem, value);
+    return this;
   }
   /**
    * @param {string|HTMLElement} element
    * @param {string} methodName
-   * @param {...ArbitraryValue} args
-   * @returns {ArbitraryValue}
+   * @param {...UserArg} args
+   * @returns {StoredValue}
    */
   invoke(element, methodName, ...args) {
     const elem = typeof element === 'string' ? $(element) : element;
     if (!elem) {
       throw new Error("Can't find the element");
     }
-    return this.get(elem)[methodName](elem, ...args);
+    return /** @type {UserArg} */this.get(elem)[methodName](elem, ...args);
   }
 }
 jml.Map = JamilihMap;
 jml.WeakMap = JamilihWeakMap;
 
 /**
- * @typedef {[JamilihWeakMap|JamilihMap, HTMLElement]} MapAndElementArray
+ * @template V
+ * @typedef {[JamilihWeakMap<V>|JamilihMap<V>, HTMLElement]} MapAndElementArray
  */
 
 /**
- * @param {{[key: string]: any}} obj
+ * @template V
+ * @param {V} obj
  * @param {JamilihArrayPostOptions} args
- * @returns {MapAndElementArray}
+ * @returns {MapAndElementArray<V>}
  */
 jml.weak = function (obj, ...args) {
   const map = new JamilihWeakMap();
@@ -2228,9 +2515,10 @@ jml.weak = function (obj, ...args) {
 };
 
 /**
- * @param {ArbitraryValue} obj
+ * @template V
+ * @param {V} obj
  * @param {JamilihArrayPostOptions} args
- * @returns {MapAndElementArray}
+ * @returns {MapAndElementArray<V>}
  */
 jml.strong = function (obj, ...args) {
   const map = new JamilihMap();
@@ -2243,7 +2531,7 @@ jml.strong = function (obj, ...args) {
 /**
  * @param {string|HTMLElement} element If a string, will be interpreted as a selector
  * @param {symbol|string} sym If a string, will be used with `Symbol.for`
- * @returns {ArbitraryValue} The value associated with the symbol
+ * @returns {SymbolResult} The value associated with the symbol
  */
 jml.symbol = jml.sym = jml.for = function (element, sym) {
   const elem = typeof element === 'string' ? $(element) : element;
@@ -2253,16 +2541,16 @@ jml.symbol = jml.sym = jml.for = function (element, sym) {
 };
 
 /**
- * @typedef {((elem: HTMLElement, ...args: any[]) => void)|{[key: string]: (elem: HTMLElement, ...args: any[]) => void}} MapCommand
+ * @typedef {((elem: HTMLElement, ...args: UserArg[]) => void)|{[key: string]: (elem: HTMLElement, ...args: UserArg[]) => void}} MapCommand
  */
 
 /**
  * @param {?(string|HTMLElement)} elem If a string, will be interpreted as a selector
  * @param {symbol|string|Map<HTMLElement, MapCommand>|WeakMap<HTMLElement, MapCommand>} symOrMap If a string, will be used with `Symbol.for`
- * @param {string|any} methodName Can be `any` if the symbol or map directly
+ * @param {string|UserArg} methodName Can be `UserArg` if the symbol or map directly
  *   points to a function (it is then used as the first argument).
- * @param {ArbitraryValue[]} args
- * @returns {ArbitraryValue}
+ * @param {UserArg[]} args
+ * @returns {StoredValue}
  */
 jml.command = function (elem, symOrMap, methodName, ...args) {
   elem = typeof elem === 'string' ? $(elem) : elem;
@@ -2275,7 +2563,7 @@ jml.command = function (elem, symOrMap, methodName, ...args) {
     if (typeof func === 'function') {
       return func(methodName, ...args); // Already has `this` bound to `elem`
     }
-    return func[methodName](...args);
+    return /** @type {UserArg} */func[methodName](...args);
   }
   func = /** @type {Map<HTMLElement, MapCommand>|WeakMap<HTMLElement, MapCommand>} */symOrMap.get(elem);
   if (!func) {
@@ -2291,10 +2579,10 @@ jml.command = function (elem, symOrMap, methodName, ...args) {
 /**
  * Expects properties `document`, `XMLSerializer`, and `DOMParser`.
  * Also updates `body` with `document.body`.
- * @param {import('jsdom').DOMWindow|HTMLWindow|undefined} wind
+ * @param {import('jsdom').DOMWindow|HTMLWindow|typeof globalThis|undefined} wind
  * @returns {void}
  */
-jml.setWindow = wind => {
+const setWindow = wind => {
   win = wind;
   doc = win?.document;
   if (doc && doc.body) {
@@ -2302,28 +2590,31 @@ jml.setWindow = wind => {
     body = /** @type {HTMLBodyElement} */doc.body;
   }
 };
+jml.setWindow = setWindow;
 
 /**
- * @returns {import('jsdom').DOMWindow|HTMLWindow}
+ * @returns {import('jsdom').DOMWindow|HTMLWindow|typeof globalThis}
  */
-jml.getWindow = () => {
+const getWindow = () => {
   if (!win) {
     throw new Error('No window object set');
   }
   return win;
 };
+jml.getWindow = getWindow;
 
 /**
  * Does not run Jamilih so can be further processed.
- * @param {ArbitraryValue[]} array
- * @param {ArbitraryValue} glu
- * @returns {ArbitraryValue[]}
+ * @template T
+ * @param {T[]} array
+ * @param {T} glu
+ * @returns {T[]}
  */
 function glue(array, glu) {
   return [...array].reduce((arr, item) => {
     arr.push(item, glu);
     return arr;
-  }, []).slice(0, -1);
+  }, /** @type {T[]} */[]).slice(0, -1);
 }
 
 /**
@@ -2336,6 +2627,6 @@ if (doc && doc.body) {
   // eslint-disable-next-line prefer-destructuring -- Needed for type
   body = /** @type {HTMLBodyElement} */doc.body;
 }
-const nbsp = '\u00A0'; // Very commonly needed in templates
+const nbsp = '\u{A0}'; // Very commonly needed in templates
 
-export { $, $$, DOMException, body, jml as default, glue, jml, nbsp };
+export { $, $$, DOMException, body, getWindow, glue, jml, nbsp, setWindow, toDOM, toDOMString, toHTML, toJML, toJMLString, toXML, toXMLDOMString };