@es-joy/jsoe 0.24.3 → 0.25.1

package/vendor/jamilih/dist/{jml-es.js → jml.mjs}

@@ -1,39 +1,51 @@
+/* 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)
-0. IE problem: Add JsonML code to handle name attribute (during element creation)
-0. Element-specific: IE object-param handling
 
 Todos inspired by JsonML: https://github.com/mckamey/jsonml/blob/master/jsonml-html.js
-
-0. duplicate attributes?
 0. expand ATTR_MAP
-0. equivalent of markup, to allow strings to be embedded within an object (e.g., {$value: '<div>id</div>'}); advantage over innerHTML in that it wouldn't need to work as the entire contents (nor destroy any existing content or handlers)
-0. More validation?
-0. JsonML DOM Level 0 listener
-0. Whitespace trimming?
-
-JsonML element-specific:
-0. table appending
-0. canHaveChildren necessary? (attempts to append to script and img)
 
 Other Todos:
 0. Note to self: Integrate research from other jml notes
-0. Allow Jamilih to be seeded with an existing element, so as to be able to add/modify attributes and children
+0. Allow Jamilih to be seeded with an existing element, so as to be able to
+    add/modify attributes and children
 0. Allow array as single first argument
-0. Settle on whether need to use null as last argument to return array (or fragment) or other way to allow appending? Options object at end instead to indicate whether returning array, fragment, first element, etc.?
+0. Settle on whether need to use null as last argument to return array (or
+    fragment) or other way to allow appending? Options object at end instead
+    to indicate whether returning array, fragment, first element, etc.?
 0. Allow building of generic XML (pass configuration object)
 0. Allow building content internally as a string (though allowing DOM methods, etc.?)
 0. Support JsonML empty string element name to represent fragments?
-0. Redo browser testing of jml (including ensuring IE7 can work even if test framework can't work)
+0. Redo browser testing of jml
 */
 
 /**
- * @typedef {Window & {DocumentFragment: any}} HTMLWindow
+ * @typedef {Window & {DocumentFragment: typeof DocumentFragment}} HTMLWindow
+ */
+
+/**
+ * @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 {any} ArbitraryValue
+ * @typedef {HTMLElement & {[key: string]: ElementExpando}} ExpandoHTMLElement
  */
 
 /**
@@ -55,7 +67,7 @@ Other Todos:
  */
 
 /**
- * @type {import('jsdom').DOMWindow|HTMLWindow|undefined}
+ * @type {import('jsdom').DOMWindow|HTMLWindow|typeof globalThis|undefined}
  */
 let win;
 
@@ -74,7 +86,6 @@ const possibleOptions = ['$plugins',
 // '$state', // Used internally
 '$map' // Add any other options here
 ];
-
 const NS_HTML = 'http://www.w3.org/1999/xhtml',
   hyphenForCamelCase = /-([a-z])/gu;
 const ATTR_MAP = new Map([['maxlength', 'maxLength'], ['minlength', 'minLength'], ['readonly', 'readOnly']]);
@@ -87,7 +98,7 @@ const BOOL_ATTS = ['checked', 'defaultChecked', 'defaultSelected', 'disabled', '
 'readOnly', 'selected'];
 
 // From JsonML
-const ATTR_DOM = [...BOOL_ATTS, 'accessKey',
+const ATTR_DOM = new Set([...BOOL_ATTS, 'accessKey',
 // HTMLElement
 'async', 'autocapitalize',
 // HTMLElement
@@ -105,17 +116,17 @@ const ATTR_DOM = [...BOOL_ATTS, 'accessKey',
 // HTMLElement
 'translate',
 // HTMLElement
-'value', 'willvalidate'];
+'value', 'willvalidate']);
 // Todo: Add more to this as useful for templating
 //   to avoid setting through nullish value
-const NULLABLES = ['autocomplete', 'dir',
+const NULLABLES = new Set(['autocomplete', 'dir',
 // HTMLElement
 'integrity',
 // script, link
 'lang',
 // HTMLElement
 'max', 'min', 'minLength', 'maxLength', 'title' // HTMLElement
-];
+]);
 
 /**
  * @param {string} sel
@@ -136,19 +147,9 @@ const $$ = sel => {
   if (!doc) {
     throw new Error('No document object');
   }
-  return [... /** @type {NodeListOf<HTMLElement>} */doc.querySelectorAll(sel)];
+  return [...(/** @type {NodeListOf<HTMLElement>} */doc.querySelectorAll(sel))];
 };
 
-/**
-* Retrieve the (lower-cased) HTML name of a node.
-* @static
-* @param {Node} node The HTML node
-* @returns {string} The lower-cased node name
-*/
-function _getHTMLNodeName(node) {
-  return node.nodeName && node.nodeName.toLowerCase();
-}
-
 /**
  * @private
  * @static
@@ -158,7 +159,7 @@ function _getHTMLNodeName(node) {
  * @returns {void}
  */
 function _appendNode(parent, child) {
-  const parentName = _getHTMLNodeName(parent);
+  const parentName = parent.nodeName?.toLowerCase();
   if (parentName === 'template') {
     /** @type {HTMLTemplateElement} */parent.content.append(child);
     return;
@@ -169,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}
@@ -182,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) {
@@ -203,14 +205,15 @@ function _createSafeReference(type, prefix, arg) {
   // Todo: No workaround for XML?
   // 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();
 }
@@ -224,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"|"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,6 +264,8 @@ function _getType(item) {
         switch (item.nodeType) {
           case 1:
             return 'element';
+          case 7:
+            return 'processing-instruction';
           case 9:
             return 'document';
           case 11:
@@ -269,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
@@ -293,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;
@@ -319,7 +339,7 @@ function _replaceDefiner(xmlnsObj) {
 function _childrenToJML(node) {
   return function (childNodeJML, i) {
     const cn = node.childNodes[i];
-    const j = Array.isArray(childNodeJML) ? jml(... /** @type {JamilihArray} */childNodeJML) : jml(childNodeJML);
+    const j = Array.isArray(childNodeJML) ? jml(...(/** @type {JamilihArray} */childNodeJML)) : jml(childNodeJML);
     cn.replaceWith(j);
   };
 }
@@ -327,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 {
@@ -360,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 {
@@ -386,9 +406,9 @@ function _appendJMLOrText(node) {
 }
 
 /**
-* @private
-* @static
-*/
+ * @private
+ * @static
+ */
 /*
 function _DOMfromJMLOrString (childNodeJML) {
   if (typeof childNodeJML === 'string') {
@@ -399,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)[]
 
 /**
@@ -418,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
  */
 
 /**
@@ -444,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
  */
 
@@ -467,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
@@ -491,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
  */
 
 /**
@@ -515,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
+ */
+
+/**
+ * @template {HTMLElement} [T=HTMLElement]
+ * @typedef {[symbol|string, SymbolMethod<T>|SymbolObject<ArbitraryValue, T>]} SymbolArray
  */
 
 /**
- * @typedef {[symbol|string, ((this: HTMLElement, ...args: any[]) => any)|SymbolObject]} SymbolArray
+ * @typedef {BoundSymbolMethod|SymbolObject|ArbitraryValue} SymbolResult
  */
 
 /**
@@ -527,7 +564,7 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
- * @typedef {[string, object]|string|{[key: string]: any}} PluginValue
+ * @typedef {[string, object]|string|object} PluginValue
  */
 
 /**
@@ -542,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
  */
 
@@ -572,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
  */
 
@@ -613,6 +648,11 @@ function _DOMfromJMLOrString (childNodeJML) {
 /**
  * @typedef {{
  *   title?: string,
+ *   xmlDeclaration?: {
+ *     version: string,
+ *     encoding: string,
+ *     standalone: boolean
+ *   },
  *   childNodes?: JamilihChildType[],
  *   $DOCTYPE?: JamilihDocumentType,
  *   head?: JamilihChildren
@@ -651,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.
  *
@@ -711,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
  */
 
@@ -724,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]
  */
 
 /**
@@ -750,8 +799,7 @@ function checkPluginValue(elem, att, attVal, opts, state) {
       });
     }
   }
-  return (/** @type {string} */attVal
-  );
+  return /** @type {string} */attVal;
 }
 
 /**
@@ -765,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');
   }
@@ -793,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();
   /**
    *
@@ -807,21 +1041,16 @@ const jml = function jml(...args) {
       throw new Error('No document object');
     }
     for (let [att, attVal] of Object.entries(atts)) {
-      att = ATTR_MAP.get(att) ?? att;
-
-      /**
-       * @typedef {any} ElementExpando
-       */
-
-      if (NULLABLES.includes(att)) {
+      att = ATTR_MAP.has(att) ? String(ATTR_MAP.get(att)) : att;
+      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.includes(att)) {
+      }
+      if (ATTR_DOM.has(att)) {
         attVal = checkPluginValue(elem, att, /** @type {string|JamilihArray} */attVal, opts);
-        /** @type {ElementExpando} */
         elem[att] = attVal;
         continue;
       }
@@ -859,13 +1088,13 @@ const jml = function jml(...args) {
             if (template) {
               if (Array.isArray(template)) {
                 template = /** @type {HTMLTemplateElement} */
-                _getType(template[0]) === 'object' ? jml('template', ...
+                _getType(template[0]) === 'object' ? jml('template', ...(
                 /**
                  * @type {[
                  *   JamilihAttributes, ...(JamilihArray[]|HTMLElement)[]
                  * ]}
                  */
-                template, doc.body) : jml('template',
+                template), doc.body) : jml('template',
                 /**
                  * @type {JamilihArray[]|HTMLElement}
                  */
@@ -873,7 +1102,7 @@ const jml = function jml(...args) {
               } else if (typeof template === 'string') {
                 template = /** @type {HTMLTemplateElement} */$(template);
               }
-              jml( /** @type {HTMLTemplateElement} */
+              jml(/** @type {HTMLTemplateElement} */
               /** @type {HTMLTemplateElement} */template.content.cloneNode(true), shadowRoot);
             } else {
               if (!content) {
@@ -906,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;
           }
@@ -934,7 +1166,7 @@ const jml = function jml(...args) {
                 } = atts);
               }
             }
-            const def = customizedBuiltIn ? /** @type {string} */is : localName;
+            const def = customizedBuiltIn ? (/** @type {string} */is) : localName;
             if (window.customElements.get(def)) {
               break;
             }
@@ -948,7 +1180,7 @@ const jml = function jml(...args) {
               if (!doc) {
                 throw new Error('No document object');
               }
-              const baseClass = typeof options === 'object' && typeof options.extends === 'string' ? /** @type {typeof HTMLElement} */doc.createElement(options.extends).constructor : customizedBuiltIn ? /** @type {typeof HTMLElement} */doc.createElement(localName).constructor : window.HTMLElement;
+              const baseClass = typeof options === 'object' && typeof options.extends === 'string' ? (/** @type {typeof HTMLElement} */doc.createElement(options.extends).constructor) : customizedBuiltIn ? (/** @type {typeof HTMLElement} */doc.createElement(localName).constructor) : window.HTMLElement;
 
               /**
                * Class wrapping base class.
@@ -976,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
@@ -1006,7 +1239,7 @@ const jml = function jml(...args) {
               cnstrctr = getConstructor();
             }
             if (!cnstrctr.toString().startsWith('class')) {
-              cnstrctr = getConstructor( /** @type {DefineUserConstructor} */cnstrctr);
+              cnstrctr = getConstructor(/** @type {DefineUserConstructor} */cnstrctr);
             }
             if (!options && customizedBuiltIn) {
               options = {
@@ -1015,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);
@@ -1024,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;
@@ -1036,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;
@@ -1049,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;
           }
@@ -1057,35 +1294,34 @@ const jml = function jml(...args) {
           {
             // Attribute node
             const attr = /** @type {JamilihAttributeNodeValue} */attVal;
-            const node = attr.length === 3 ? doc.createAttributeNS(attr[0], attr[1]) : doc.createAttribute( /** @type {string} */attr[0]);
-            node.value = /** @type {string} */attr[attr.length - 1];
+            const node = attr.length === 3 ? doc.createAttributeNS(attr[0], attr[1]) : doc.createAttribute(/** @type {string} */attr[0]);
+            node.value = /** @type {string} */attr.at(-1);
             nodes[nodes.length] = node;
             break;
           }
         case '$text':
           {
             // Todo: Also allow as jml(['a text node']) (or should that become a fragment)?
-            const node = doc.createTextNode( /** @type {string} */attVal);
+            const node = doc.createTextNode(/** @type {string} */attVal);
             nodes[nodes.length] = node;
             break;
           }
         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
               }
-
               jamlihDoc.childNodes.forEach(_childrenToJML(docNode));
             } else {
               if (jamlihDoc.$DOCTYPE) {
@@ -1106,8 +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)
@@ -1121,10 +1356,20 @@ const jml = function jml(...args) {
                   jamlihDoc.head.forEach(_appendJML(head));
                 }
               }
-              if (jamlihDoc.body && body) {
+              if (body && jamlihDoc.body) {
                 jamlihDoc.body.forEach(_appendJMLOrText(body));
               }
             }
+            if (jamlihDoc.xmlDeclaration) {
+              const {
+                version,
+                encoding,
+                standalone
+              } = jamlihDoc.xmlDeclaration;
+              const xmlDeclarationData = `${version ? ` version="${version}"` : ''}${encoding ? ` encoding="${encoding}"` : ''}${standalone ? ` standalone="yes"` : ''}`.slice(1);
+              const xmlDeclaration = doc.createProcessingInstruction('xml', xmlDeclarationData);
+              docNode.insertBefore(xmlDeclaration, docNode.firstChild);
+            }
             nodes[nodes.length] = docNode;
             break;
           }
@@ -1138,17 +1383,18 @@ const jml = function jml(...args) {
         case '$on':
           {
             // Events
+            const onElem = /** @type {ResolvedElement<U, W>} */elem;
             // Allow for no-op by defaulting to `{}`
-            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;
           }
         case 'className':
@@ -1171,7 +1417,11 @@ const jml = function jml(...args) {
               const pastInitialProp = startProp !== '';
               Object.keys(atVal).forEach(key => {
                 const value = atVal[key];
-                prop = pastInitialProp ? startProp + key.replace(hyphenForCamelCase, _upperCase).replace(/^([a-z])/u, _upperCase) : startProp + key.replace(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;
@@ -1182,7 +1432,7 @@ const jml = function jml(...args) {
                 recurse(value, prop);
               });
             };
-            recurse( /** @type {DatasetAttributeObject} */attVal, '');
+            recurse(/** @type {DatasetAttributeObject} */attVal, '');
             break;
             // Todo: Disable this by default unless configuration explicitly allows (for security)
           }
@@ -1232,7 +1482,8 @@ const jml = function jml(...args) {
                       elem.style.cssFloat = styleVal;
                       elem.style.styleFloat = styleVal; // Harmless though we could make conditional on older IE instead
                     } else {
-                      elem.style[p2.replace(hyphenForCamelCase, _upperCase)] = styleVal;
+                      // eslint-disable-next-line unicorn/no-unsafe-string-replacement -- Function
+                      elem.style[p2.replaceAll(hyphenForCamelCase, _upperCase)] = styleVal;
                     }
                   }
                 }
@@ -1256,10 +1507,10 @@ const jml = function jml(...args) {
             if (matchingPlugin) {
               matchingPlugin.set({
                 opts,
-                element: /** @type {HTMLElement} */nodes[0],
+                element: (/** @type {HTMLElement} */nodes[0]),
                 attribute: {
                   name: pluginName,
-                  value: /** @type {PluginReference} */attVal
+                  value: (/** @type {PluginReference} */attVal)
                 }
               });
               break;
@@ -1321,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;
@@ -1334,12 +1585,11 @@ const jml = function jml(...args) {
       // Array of strings mapping to default
       if (typeof dataVal[0] === 'string') {
         dataVal.forEach(dVal => {
-          setMap( /** @type {MapWithRoot} */opts.$map[dVal]);
+          setMap(/** @type {MapWithRoot} */opts.$map[dVal]);
         });
         return;
         // Array of Map and non-map data object
       }
-
       map = dataVal[0] || defMap[0];
       obj = dataVal[1] || defMap[1];
       // Map
@@ -1351,8 +1601,8 @@ const jml = function jml(...args) {
       map = defMap[0];
       obj = dataVal;
     }
-    /** @type {Map<HTMLElement, any> | WeakMap<HTMLElement, any>} */
-    map.set( /** @type {HTMLElement} */
+    /** @type {Map<HTMLElement, UserArg> | WeakMap<HTMLElement, UserArg>} */
+    map.set(/** @type {HTMLElement} */
     elem, obj);
   };
   for (let i = argStart; i < argc; i++) {
@@ -1363,18 +1613,16 @@ 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]
-            // eslint-disable-next-line unicorn/no-array-callback-reference
-            : nodes.reduce(_fragReducer, doc.createDocumentFragment())
-          ); // nodes;
+          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;
         }
-
         throw new TypeError(`\`null\` values not allowed except as final Jamilih argument; index ${i} on args: ${JSON.stringify(args)}`);
       case 'string':
         // Strings normally indicate elements
         switch (arg) {
           case '!':
-            nodes[nodes.length] = doc.createComment( /** @type {string} */args[++i]);
+            nodes[nodes.length] = doc.createComment(/** @type {string} */args[++i]);
             break;
           case '?':
             {
@@ -1384,9 +1632,9 @@ 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.replace(/"/gu, '&quot;') + '"');
+                  procInstVal.replaceAll('"', '&quot;') + '"');
                 }
                 procValue = procValues.join(' ');
               }
@@ -1423,12 +1671,11 @@ const jml = function jml(...args) {
             // CDATA valid in XML only, so we'll just treat as text for mutual compatibility
             // Todo: config (or detection via some kind of doc.documentType property?) of whether in XML
             try {
-              nodes[nodes.length] = doc.createCDATASection( /** @type {string} */args[++i]);
+              nodes[nodes.length] = doc.createCDATASection(/** @type {string} */args[++i]);
             } catch (e2) {
-              nodes[nodes.length] = doc.createTextNode( /** @type {string} */
+              nodes[nodes.length] = doc.createTextNode(/** @type {string} */
               args[i]); // i already incremented
             }
-
             break;
           case '':
             nodes[nodes.length] = elem = doc.createDocumentFragment();
@@ -1447,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, {
-                  is: /** @type {string} */is
+                ? (/** @type {HTMLElement} */doc.createElementNS(NS_HTML, elStr, {
+                  is: (/** @type {string} */is)
                 })
-                /* c8 ignore next 1 */ : doc.createElement(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 */
@@ -1481,25 +1727,26 @@ 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)
+            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
             opts.$state = 'element';
             // }catch(e) {alert(elem.outerHTML);throw e;}
           }
-
-          _checkAtts( /** @type {JamilihAttributes} */atts);
+          _checkAtts(/** @type {JamilihAttributes} */atts);
           break;
         }
+      case 'processing-instruction':
       case 'document':
       case 'fragment':
       case 'element':
@@ -1517,7 +1764,7 @@ const jml = function jml(...args) {
           // parent
           const elsl = nodes.length;
           for (let k = 0; k < elsl; k++) {
-            _appendNode( /** @type {Document|DocumentFragment|HTMLElement} */arg, nodes[k]);
+            _appendNode(/** @type {Document|DocumentFragment|HTMLElement} */arg, nodes[k]);
           }
         } else {
           nodes[nodes.length] = /** @type {Document|DocumentFragment|HTMLElement} */arg;
@@ -1528,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
@@ -1545,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';
@@ -1580,8 +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;
 };
 
 /**
@@ -1651,8 +1909,8 @@ class DOMException extends Error {
 
 /**
  * @typedef {JamilihArray|JamilihDoctype|
-*    JamilihCDATANode|JamilihEntityReference|JamilihProcessingInstruction|
-*    JamilihComment|JamilihDocumentFragment} JamilihChildType
+ *    JamilihCDATANode|JamilihEntityReference|JamilihProcessingInstruction|
+ *    JamilihComment|JamilihDocumentFragment} JamilihChildType
  */
 
 /**
@@ -1660,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
@@ -1679,12 +1937,11 @@ jml.toJML = function (nde, {
   if (typeof nde === 'string') {
     nde = new /** @type {import('jsdom').DOMWindow} */win.DOMParser().parseFromString(nde, 'text/html'); // todo: Give option for XML once implemented and change JSDoc to allow for Element
   }
-
   const dom = /** @type {HTMLElement|Node|Entity} */nde;
 
   /**
    * @todo Find more specific type than `any`
-   * @typedef {{[key: (number|string)]: any}} IndexableObject
+   * @typedef {{[key: (number|string)]: UserArg}} IndexableObject
    */
 
   const ret = /** @type {IndexableObject} */[];
@@ -1698,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;
   }
 
   /**
@@ -1790,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');
     }
 
@@ -1820,7 +2084,6 @@ jml.toJML = function (nde, {
       parentIdx = tmpParentIdx;
       parentIdx++; // Increment index in parent container of this element
     }
-
     switch (type) {
       case 1:
         {
@@ -1896,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 ]]>');
           }
@@ -1979,8 +2243,8 @@ 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
-          if (!pubIdChar.test( /** @type {DocumentType} */node.publicId)) {
+          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.');
           }
           addExternalID(start.$DOCTYPE, node);
@@ -2021,36 +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 || {}, {
-      stringOutput: true
-    }))
-  );
+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) {
@@ -2060,33 +2325,34 @@ jml.toHTML = function (...args) {
         // Todo: deal with serialization of properties like 'selected',
         //  'checked', 'value', 'defaultValue', 'for', 'dataset', 'on*',
         //  'style'! (i.e., need to build a string ourselves)
-        return (/** @type {HTMLElement} */ret.outerHTML
-        );
+        return /** @type {HTMLElement} */ret.outerHTML;
       }
     case 2:
       {
         // ATTR
-        return `${
-        /** @type {Attr} */ret.name}="${
-        /** @type {Attr} */ret.value.replace(/"/gu, '&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
-        // } case 7: { // PROCESSING INSTRUCTION
-        //   const node = /** @type {ProcessingInstruction} */ (ret);
-        //   return `<?${node.target} ${node.data}?>`;
+      }
+    case 7:
+      {
+        // PROCESSING INSTRUCTION
+        const node = /** @type {ProcessingInstruction} */ret;
+        return `<?${node.target} ${node.data}?>`;
         // } case 8: { // Comment
         //   return `<!--${ret.nodeValue}-->`;
       }
@@ -2096,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:
@@ -2110,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;
@@ -2158,104 +2429,109 @@ 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();
   const elem = jml({
     $map: [map, obj]
   }, ...args);
-  return [map, /** @type {HTMLElement} */elem];
+  return [map, (/** @type {HTMLElement} */elem)];
 };
 
 /**
- * @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();
   const elem = jml({
     $map: [map, obj]
   }, ...args);
-  return [map, /** @type {HTMLElement} */elem];
+  return [map, (/** @type {HTMLElement} */elem)];
 };
 
 /**
  * @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;
@@ -2265,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;
@@ -2287,8 +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) {
@@ -2304,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) {
@@ -2315,40 +2590,43 @@ 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);
 }
 
 /**
  * @type {HTMLBodyElement}
  */
-let body; // eslint-disable-line import/no-mutable-exports
+let body; // // eslint-disable-line import/no-mutable-exports
 
 /* c8 ignore next 4 */
 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 };