@es-joy/jsoe 0.2.0 → 0.4.0

package/vendor/jamilih/dist/jml-es.js

@@ -1,3 +1,4 @@
+var _win;
 /*
 Possible todos:
 0. Add XSLT to JML-string stylesheet (or even vice versa)
@@ -28,10 +29,44 @@ Other Todos:
 0. Redo browser testing of jml (including ensuring IE7 can work even if test framework can't work)
 */
 
-// istanbul ignore next
-let win = typeof window !== 'undefined' && window;
-// istanbul ignore next
-let doc = typeof document !== 'undefined' && document || win && win.document;
+/**
+ * @typedef {Window & {DocumentFragment: any}} HTMLWindow
+ */
+
+/**
+ * @typedef {any} ArbitraryValue
+ */
+
+/**
+ * @typedef {number} Integer
+ */
+
+/**
+ * @typedef {{
+ *   element: Document|Element|DocumentFragment,
+ *   attribute: {name: string|null, value: JamilihAttValue},
+ *   opts: JamilihOptions
+ * }} PluginSettings
+ */
+
+/**
+ * @typedef {object} JamilihPlugin
+ * @property {string} name
+ * @property {(opts: PluginSettings) => string} set
+ */
+
+/**
+ * @type {import('jsdom').DOMWindow|HTMLWindow|undefined}
+ */
+let win;
+
+/* c8 ignore next */
+if (typeof window !== 'undefined' && window) {
+  win = window;
+}
+
+/* c8 ignore next */
+let doc = typeof document !== 'undefined' && document || ((_win = win) === null || _win === void 0 ? void 0 : _win.document);
 
 // STATIC PROPERTIES
 
@@ -43,11 +78,7 @@ const possibleOptions = ['$plugins',
 
 const NS_HTML = 'http://www.w3.org/1999/xhtml',
   hyphenForCamelCase = /-([a-z])/gu;
-const ATTR_MAP = {
-  maxlength: 'maxLength',
-  minlength: 'minLength',
-  readonly: 'readOnly'
-};
+const ATTR_MAP = new Map([['maxlength', 'maxLength'], ['minlength', 'minLength'], ['readonly', 'readOnly']]);
 
 // We define separately from ATTR_DOM for clarity (and parity with JsonML) but no current need
 // We don't set attribute esp. for boolean atts as we want to allow setting of `undefined`
@@ -87,8 +118,27 @@ const NULLABLES = ['autocomplete', 'dir',
 'max', 'min', 'minLength', 'maxLength', 'title' // HTMLElement
 ];
 
-const $ = sel => doc.querySelector(sel);
-const $$ = sel => [...doc.querySelectorAll(sel)];
+/**
+ * @param {string} sel
+ * @returns {Element|null}
+ */
+const $ = sel => {
+  if (!doc) {
+    throw new Error('No document object');
+  }
+  return doc.querySelector(sel);
+};
+
+/**
+ * @param {string} sel
+ * @returns {Element[]}
+ */
+const $$ = sel => {
+  if (!doc) {
+    return [];
+  }
+  return [...doc.querySelectorAll(sel)];
+};
 
 /**
 * Retrieve the (lower-cased) HTML name of a node.
@@ -101,74 +151,20 @@ function _getHTMLNodeName(node) {
 }
 
 /**
-* Apply styles if this is a style tag.
-* @static
-* @param {Node} node The element to check whether it is a style tag
-* @returns {void}
-*/
-function _applyAnyStylesheet(node) {
-  // Only used in IE
-  // istanbul ignore else
-  if (!doc.createStyleSheet) {
-    return;
-  }
-  // istanbul ignore next
-  if (_getHTMLNodeName(node) === 'style') {
-    // IE
-    const ss = doc.createStyleSheet(); // Create a stylesheet to actually do something useful
-    ss.cssText = node.cssText;
-    // We continue to add the style tag, however
-  }
-}
-
-/**
- * Need this function for IE since options weren't otherwise getting added.
  * @private
  * @static
- * @param {Element} parent The parent to which to append the element
- * @param {Node} child The element or other node to append to the parent
+ * @param {Document|DocumentFragment|Element} parent The parent to which to append the element
+ * @param {Node|string} child The element or other node to append to the parent
  * @throws {Error} Rethrow if problem with `append` and unhandled
  * @returns {void}
  */
 function _appendNode(parent, child) {
   const parentName = _getHTMLNodeName(parent);
-
-  // IE only
-  // istanbul ignore if
-  if (doc.createStyleSheet) {
-    if (parentName === 'script') {
-      parent.text = child.nodeValue;
-      return;
-    }
-    if (parentName === 'style') {
-      parent.cssText = child.nodeValue; // This will not apply it--just make it available within the DOM cotents
-      return;
-    }
-  }
   if (parentName === 'template') {
-    parent.content.append(child);
+    /** @type {HTMLTemplateElement} */parent.content.append(child);
     return;
   }
-  try {
-    parent.append(child); // IE9 is now ok with this
-  } catch (e) {
-    // istanbul ignore next
-    const childName = _getHTMLNodeName(child);
-    // istanbul ignore next
-    if (parentName === 'select' && childName === 'option') {
-      try {
-        // Since this is now DOM Level 4 standard behavior (and what IE7+ can handle), we try it first
-        parent.add(child);
-      } catch (err) {
-        // DOM Level 2 did require a second argument, so we try it too just in case the user is using an older version of Firefox, etc.
-        parent.add(child, null); // IE7 has a problem with this, but IE8+ is ok
-      }
-
-      return;
-    }
-    // istanbul ignore next
-    throw e;
-  }
+  parent.append(child); // IE9 is now ok with this
 }
 
 /**
@@ -194,6 +190,9 @@ function _addEvent(el, type, handler, capturing) {
 * @returns {Text} The text node of the resolved reference
 */
 function _createSafeReference(type, prefix, arg) {
+  if (!doc) {
+    throw new Error('No document defined');
+  }
   // For security reasons related to innerHTML, we ensure this string only
   //  contains potential entity characters
   if (!/^\w+$/u.test(arg)) {
@@ -228,11 +227,20 @@ function _isNullish(o) {
 /**
 * @private
 * @static
-* @param {string|JamilihAttributes|JamilihArray|Element|DocumentFragment} item
-* @returns {"string"|"null"|"array"|"element"|"fragment"|"object"|"symbol"|"function"|"number"|"boolean"}
+* @param {string|JamilihAttributes|JamilihArray|JamilihChildren|
+*   JamilihDocumentFragment|JamilihAttributeNode|
+*   JamilihOptions|Element|Document|DocumentFragment|null|undefined} item
+* @returns {"string"|"null"|"array"|"element"|"fragment"|"object"|
+*   "symbol"|"bigint"|"function"|"number"|"boolean"|"undefined"|
+*   "document"|"non-container node"}
 */
 function _getType(item) {
   const type = typeof item;
+
+  // Appease TS
+  if (typeof item === 'string' || typeof item === 'undefined') {
+    return 'string';
+  }
   switch (type) {
     case 'object':
       if (item === null) {
@@ -274,11 +282,16 @@ function _fragReducer(frag, node) {
 /**
 * @private
 * @static
-* @param {Object<{string:string}>} xmlnsObj
-* @returns {string}
+* @param {Object<string, string>} xmlnsObj
+* @returns {(...n: string[]) => string}
 */
 function _replaceDefiner(xmlnsObj) {
-  return function (n0) {
+  /**
+   * @param {string[]} n
+   * @returns {string}
+   */
+  return function (...n) {
+    const n0 = n[0];
     let retStr = xmlnsObj[''] ? ' xmlns="' + xmlnsObj[''] + '"' : n0; // Preserve XHTML
     for (const [ns, xmlnsVal] of Object.entries(xmlnsObj)) {
       if (ns !== '') {
@@ -290,48 +303,52 @@ function _replaceDefiner(xmlnsObj) {
 }
 
 /**
-* @typedef {JamilihAttributes} AttributeArray
-* @property {string} 0 The key
-* @property {string} 1 The value
-*/
-
-/**
-* @callback ChildrenToJMLCallback
-* @param {JamilihArray|Jamilih} childNodeJML
-* @param {Integer} i
-* @returns {void}
-*/
+ * @callback ChildrenToJMLCallback
+ * @param {JamilihArray|JamilihChildType|string} childNodeJML
+ * @param {Integer} i
+ * @returns {void}
+ */
 
 /**
-* @private
-* @static
-* @param {Node} node
-* @returns {ChildrenToJMLCallback}
-*/
+ * @private
+ * @static
+ * @param {Node} node
+ * @returns {ChildrenToJMLCallback}
+ */
 function _childrenToJML(node) {
   return function (childNodeJML, i) {
     const cn = node.childNodes[i];
-    const j = Array.isArray(childNodeJML) ? jml(...childNodeJML) : jml(childNodeJML);
+    const j = Array.isArray(childNodeJML) ? jml(... /** @type {JamilihArray} */childNodeJML) : jml(childNodeJML);
     cn.replaceWith(j);
   };
 }
 
+/**
+ * Keep this in sync with `JamilihArray`'s first argument (minus `Document`).
+ * @typedef {JamilihDoc|JamilihDoctype|JamilihTextNode|
+*   JamilihAttributeNode|JamilihOptions|ElementName|Element|
+*   JamilihDocumentFragment
+* } JamilihFirstArg
+*/
+
 /**
 * @callback JamilihAppender
-* @param {JamilihArray} childJML
+* @param {JamilihArray|JamilihFirstArg|Node} childJML
 * @returns {void}
 */
 
 /**
 * @private
 * @static
-* @param {Node} node
+* @param {ParentNode} node
 * @returns {JamilihAppender}
 */
 function _appendJML(node) {
   return function (childJML) {
     if (Array.isArray(childJML)) {
       node.append(jml(...childJML));
+    } else if (typeof childJML === 'object' && 'nodeType' in childJML) {
+      node.append(childJML);
     } else {
       node.append(jml(childJML));
     }
@@ -340,14 +357,14 @@ function _appendJML(node) {
 
 /**
 * @callback appender
-* @param {string|JamilihArray} childJML
+* @param {JamilihArray|JamilihFirstArg|Node} childJML
 * @returns {void}
 */
 
 /**
 * @private
 * @static
-* @param {Node} node
+* @param {ParentNode} node
 * @returns {appender}
 */
 function _appendJMLOrText(node) {
@@ -356,6 +373,8 @@ function _appendJMLOrText(node) {
       node.append(childJML);
     } else if (Array.isArray(childJML)) {
       node.append(jml(...childJML));
+    } else if (typeof childJML === 'object' && 'nodeType' in childJML) {
+      node.append(childJML);
     } else {
       node.append(jml(childJML));
     }
@@ -376,43 +395,333 @@ function _DOMfromJMLOrString (childNodeJML) {
 */
 
 /**
-* @typedef {Element|DocumentFragment} JamilihReturn
+* @typedef {Element|DocumentFragment|Comment|Attr|
+*    Text|Document|DocumentType|ProcessingInstruction|CDATASection} JamilihReturn
 */
+// 'string|JamilihOptions|JamilihDocumentFragment|JamilihAttributes|(string|JamilihArray)[]
 
 /**
-* @typedef {PlainObject<string, string>} JamilihAttributes
-*/
+ * Can either be an array of:
+ * 1. JamilihAttributes followed by an array of JamilihArrays or Elements.
+ *     (Cannot be multiple single JamilihArrays despite TS type).
+ * 2. Any number of JamilihArrays.
+ * @typedef {[(JamilihAttributes|JamilihArray|JamilihArray[]|Element), ...(JamilihArray|JamilihArray[]|Element)[]]} TemplateJamilihArray
+ */
 
 /**
-* @typedef {GenericArray} JamilihArray
-* @property {string} 0 The element to create (by lower-case name)
-* @property {JamilihAttributes} [1] Attributes to add with the key as the
-*   attribute name and value as the attribute value; important for IE where
-*   the input element's type cannot be added later after already added to the page
-* @param {Element[]} [children] The optional children of this element
-*   (but raw DOM elements required to be specified within arrays since
-*   could not otherwise be distinguished from siblings being added)
-* @param {Element} [parent] The optional parent to which to attach the element
-*   (always the last unless followed by null, in which case it is the
-*   second-to-last)
-* @param {null} [returning] Can use null to indicate an array of elements
-*   should be returned
-*/
+ * @typedef {(JamilihArray|Element)[]} ShadowRootJamilihArrayContainer
+ */
+
+/**
+ * @typedef {{
+*   open?: boolean|ShadowRootJamilihArrayContainer,
+*   closed?: boolean|ShadowRootJamilihArrayContainer,
+*   template?: string|HTMLTemplateElement|TemplateJamilihArray,
+*   content?: ShadowRootJamilihArrayContainer|DocumentFragment
+* }} JamilihShadowRootObject
+ */
+
+/**
+ * @typedef {{[key: string]: string}} XmlnsAttributeObject
+ */
+
+/**
+ * @typedef {null|XmlnsAttributeObject} XmlnsAttributeValue
+ */
+
+/**
+ * @typedef {{
+ *   [key: string]: string|number|null|DatasetAttributeObject
+ * }} DatasetAttributeObject
+ */
+
+/**
+ * @typedef {string|undefined|{[key: string]: string|null}} StyleAttributeValue
+ */
+
+/**
+ * @typedef {(this: Element, event?: Event) => void} EventHandler
+ */
 
 /**
-* @typedef {PlainObject} JamilihOptions
-* @property {"root"|"attributeValue"|"fragment"|"children"|"fragmentChildren"} $state
+ * @typedef {{
+ *   [key: string]: EventHandler|[EventHandler, boolean]
+ * }} OnAttributeObject
+ */
+
+/**
+ * @typedef {{
+ *   $on?: OnAttributeObject|null
+ * }} OnAttribute
+ */
+
+/**
+ * @typedef {boolean} BooleanAttribute
+ */
+
+/**
+ * @typedef {((this: Element, event?: Event) => void)} HandlerAttributeValue
+ */
+
+/* eslint-disable jsdoc/valid-types -- jsdoc-type-pratt-parser Bug */
+/**
+ * @typedef {{
+ *   [key: string]: HandlerAttributeValue
+ * }} OnHandlerObject
+ */
+
+/**
+ * @typedef {number} StringifiableNumber
+ */
+
+/**
+ * @typedef {{
+ *   name: string,
+ *   systemId?: string,
+ *   publicId?: string
+ * }} JamilihDocumentType
+ */
+
+/**
+ * @typedef {string|{extends?: string}} DefineOptions
+ */
+
+/**
+ * @typedef {{[key: string]: string|number|boolean|((this: DefineMixin, ...args: any[]) => any)}} DefineMixin
+ */
+
+/**
+ * @typedef {{
+ *   new (): HTMLElement;
+ *   prototype: HTMLElement & {[key: string]: any}
+ * }} 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 {DefineObjectArray|DefineConstructor|DefineMixin|DefineUserConstructor} DefineObject
+ */
+
+/**
+ * @typedef {{elem?: Element, [key: string]: any}} SymbolObject
+ */
+
+/**
+ * @typedef {[symbol|string, ((this: Element, ...args: any[]) => any)|SymbolObject]} SymbolArray
+ */
+
+/**
+ * @typedef {null|undefined} NullableAttributeValue
+ */
+
+/**
+ * @typedef {(string|NullableAttributeValue|BooleanAttribute|
+ *   JamilihArray|JamilihShadowRootObject|StringifiableNumber|
+ *   JamilihDocumentType|JamilihDocument|XmlnsAttributeValue|
+ *   OnAttributeObject|
+ *   HandlerAttributeValue|DefineObject|SymbolArray|PluginReference
+ * )} JamilihAttValue
+ */
+
+/**
+ * @typedef {{
+*   [key: string]: string|number|((this: Element, ...args: any[]) => any)
+* }} DataAttributeObject
 */
 
 /**
- * @param {Element} elem
- * @param {string} att
- * @param {string} attVal
+ * @typedef {{
+ *   $data?: true|string[]|Map<any, any>|WeakMap<any, any>|DataAttributeObject|
+ *     [undefined, DataAttributeObject]|
+ *     [Map<any, any>|WeakMap<any, any>|undefined, DataAttributeObject]
+ * }} DataAttribute
+ */
+
+/**
+ * @typedef {{
+ *   dataset?: DatasetAttributeObject
+ * }} DatasetAttribute
+ */
+
+/**
+ * @typedef {{
+ *   style?: StyleAttributeValue
+ * }} StyleAttribute
+ */
+
+/**
+ * @typedef {{
+ *   $shadow?: JamilihShadowRootObject
+ * }} 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}
+ * }} CustomAttribute
+ */
+
+/**
+ * @typedef {{
+ *   $symbol?: SymbolArray
+ * }} SymbolAttribute
+ */
+
+/**
+ * @typedef {{
+ *   xmlns?: string|null|XmlnsAttributeObject
+ * }} XmlnsAttribute
+ */
+
+/**
+ * `OnHandlerObject &` wasn't working, so added `HandlerAttributeValue`.
+ * @typedef {DataAttribute & StyleAttribute & JamilihShadowRootAttribute &
+ * DefineAttribute & DatasetAttribute & CustomAttribute & SymbolAttribute &
+ * OnAttribute & XmlnsAttribute &
+ * Partial<JamilihAttributeNode> & Partial<JamilihTextNode> &
+ * Partial<JamilihDoc> & Partial<JamilihDoctype> & {
+ *   [key: string]: JamilihAttValue|HandlerAttributeValue,
+ * }} JamilihAttributes
+ */
+
+/**
+ * @typedef {{
+ *   title?: string,
+ *   childNodes?: JamilihChildType[],
+ *   $DOCTYPE?: JamilihDocumentType,
+ *   head?: JamilihChildren
+ *   body?: JamilihChildren
+ * }} JamilihDocument
+ */
+
+/**
+ * @typedef {{
+ *   $document: JamilihDocument
+ * }} JamilihDoc
+ */
+
+/**
+ * @typedef {{$DOCTYPE: JamilihDocumentType}} JamilihDoctype
+ */
+
+/**
+ * @typedef {{'#': (JamilihArray|TextNodeString|Element)[]}} JamilihDocumentFragment
+ */
+
+/**
+ * @typedef {string} ElementName
+ */
+
+/**
+ * @typedef {string} TextNodeString
+ */
+
+/**
+ * @typedef {{[key: string]: string}} PluginReference
+ */
+
+/**
+ * @typedef {(
+ *   JamilihArray|TextNodeString|Element|Comment|ProcessingInstruction|
+ *   Text|DocumentFragment|JamilihProcessingInstruction|JamilihDocumentFragment|
+ *   PluginReference
+ * )[]} JamilihChildren
+ */
+
+/**
+ * @typedef {Document|ElementName|Element|DocumentFragment|
+ *   JamilihDocumentFragment|JamilihDoc|JamilihDoctype|JamilihTextNode|
+ *   JamilihAttributeNode} JamilihFirstArgument
+ */
+
+/**
+ * This would be clearer with overrides, but using as typedef.
+ *
+ * The optional 0th argument is an Jamilih options object or fragment.
+ *
+ * The first argument is the element to create (by lower-case name) or DOM element.
+ *
+ * The second optional argument are attributes to add with the key as the
+ *   attribute name and value as the attribute value.
+ * The third optional argument are an array of children for this element
+ *   (but raw DOM elements are required to be specified within arrays since
+ *   could not otherwise be distinguished from siblings being added).
+ * The fourth optional argument are a sequence of sibling Elements, represented
+ *   as DOM elements, or string/attributes/children sequences.
+ * The fifth optional argument is the parent to which to attach the element
+ *   (always the last unless followed by null, in which case it is the
+ *   second-to-last).
+ * The sixth last optional argument is null, used to indicate an array of elements
+ *   should be returned.
+ * @typedef {[
+ *   JamilihOptions|JamilihFirstArgument,
+ *   (JamilihFirstArgument|
+ *     JamilihAttributes|
+ *     JamilihChildren|
+ *     Element|ShadowRoot|
+ *     null)?,
+ *   (JamilihAttributes|
+ *     JamilihChildren|
+ *     Element|ShadowRoot|
+ *     ElementName|null)?,
+ *   ...(JamilihAttributes|
+ *     JamilihChildren|
+ *     Element|ShadowRoot|
+ *     ElementName|null)[]
+ * ]} JamilihArray
+ */
+
+/**
+ * @typedef {[
+ *   (string|Element|ShadowRoot), (JamilihArray[]|JamilihAttributes|Element|ShadowRoot|null)?, ...(JamilihArray[]|Element|JamilihAttributes|ShadowRoot|null)[]
+ * ]} JamilihArrayPostOptions
+ */
+
+/**
+ * @typedef {{
+ *   root: [Map<Element,any>|WeakMap<Element,any>, any],
+ *   [key: string]: [Map<Element,any>|WeakMap<Element,any>, any]
+ * }} MapWithRoot
+ */
+
+/**
+ * @typedef {"root"|"attributeValue"|"element"|"fragment"|"children"|"fragmentChildren"} TraversalState
+ */
+
+/**
+ * @typedef {object} JamilihOptions
+ * @property {TraversalState} [$state]
+ * @property {JamilihPlugin[]} [$plugins]
+ * @property {MapWithRoot|[Map<Element,any>|WeakMap<Element,any>, any]} [$map]
+ */
+
+/**
+ * @param {Document|Element|DocumentFragment} elem
+ * @param {string|null} att
+ * @param {JamilihAttValue} attVal
  * @param {JamilihOptions} opts
- * @returns {void}
+ * @param {TraversalState} [state]
+ * @returns {string|null}
  */
-function checkPluginValue(elem, att, attVal, opts) {
-  opts.$state = 'attributeValue';
+function checkPluginValue(elem, att, attVal, opts, state) {
+  opts.$state = state !== null && state !== void 0 ? state : 'attributeValue';
   if (attVal && typeof attVal === 'object') {
     const matchingPlugin = getMatchingPlugin(opts, Object.keys(attVal)[0]);
     if (matchingPlugin) {
@@ -426,17 +735,18 @@ function checkPluginValue(elem, att, attVal, opts) {
       });
     }
   }
-  return attVal;
+  return (/** @type {string} */attVal
+  );
 }
 
 /**
  * @param {JamilihOptions} opts
- * @param {string} item
- * @returns {JamilihPlugin}
+ * @param {string} pluginName
+ * @returns {JamilihPlugin|undefined}
  */
-function getMatchingPlugin(opts, item) {
+function getMatchingPlugin(opts, pluginName) {
   return opts.$plugins && opts.$plugins.find(p => {
-    return p.name === item;
+    return p.name === pluginName;
   });
 }
 
@@ -444,29 +754,47 @@ function getMatchingPlugin(opts, item) {
  * 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.
- * @param {...JamilihArray} args
+ * @param {JamilihArray} args
  * @returns {JamilihReturn} The newly created (and possibly already appended)
  *   element or array of elements
  */
 const jml = function jml(...args) {
+  if (!win) {
+    throw new Error('No window object');
+  }
+  if (!doc) {
+    throw new Error('No document object');
+  }
+
+  /** @type {(Document|DocumentFragment|Element) & {[key: string]: any}} */
   let elem = doc.createDocumentFragment();
   /**
    *
-   * @param {Object<{string: string}>} atts
+   * @param {JamilihAttributes} atts
    * @throws {TypeError}
    * @returns {void}
    */
   function _checkAtts(atts) {
+    if (!doc) {
+      throw new Error('No document object');
+    }
     for (let [att, attVal] of Object.entries(atts)) {
-      att = att in ATTR_MAP ? ATTR_MAP[att] : att;
+      var _ATTR_MAP$get;
+      att = (_ATTR_MAP$get = ATTR_MAP.get(att)) !== null && _ATTR_MAP$get !== void 0 ? _ATTR_MAP$get : att;
+
+      /**
+       * @typedef {any} ElementExpando
+       */
+
       if (NULLABLES.includes(att)) {
-        attVal = checkPluginValue(elem, att, attVal, opts);
+        attVal = checkPluginValue(elem, att, /** @type {string|JamilihArray} */attVal, opts);
         if (!_isNullish(attVal)) {
-          elem[att] = attVal;
+          /** @type {ElementExpando} */elem[att] = attVal;
         }
         continue;
       } else if (ATTR_DOM.includes(att)) {
-        attVal = checkPluginValue(elem, att, attVal, opts);
+        attVal = checkPluginValue(elem, att, /** @type {string|JamilihArray} */attVal, opts);
+        /** @type {ElementExpando} */
         elem[att] = attVal;
         continue;
       }
@@ -484,8 +812,8 @@ const jml = function jml(...args) {
         case '#':
           {
             // Document fragment
-            opts.$state = 'fragmentChilden';
-            nodes[nodes.length] = jml(opts, attVal);
+            opts.$state = 'fragmentChildren';
+            nodes[nodes.length] = jml(opts, /** @type {JamilihArray[]} */attVal);
             break;
           }
         case '$shadow':
@@ -493,24 +821,38 @@ const jml = function jml(...args) {
             const {
               open,
               closed
-            } = attVal;
+            } = /** @type {JamilihShadowRootObject} */attVal;
             let {
               content,
               template
-            } = attVal;
-            const shadowRoot = elem.attachShadow({
+            } = /** @type {JamilihShadowRootObject} */attVal;
+            const shadowRoot = /** @type {Element} */elem.attachShadow({
               mode: closed || open === false ? 'closed' : 'open'
             });
             if (template) {
               if (Array.isArray(template)) {
-                template = _getType(template[0]) === 'object' ? jml('template', ...template, doc.body) : jml('template', template, doc.body);
+                template = /** @type {HTMLTemplateElement} */
+                _getType(template[0]) === 'object' ? jml('template', ...
+                /**
+                 * @type {[
+                 *   JamilihAttributes, ...(JamilihArray[]|Element)[]
+                 * ]}
+                 */
+                template, doc.body) : jml('template',
+                /**
+                 * @type {JamilihArray[]|Element}
+                 */
+                template, doc.body);
               } else if (typeof template === 'string') {
-                template = $(template);
+                template = /** @type {HTMLTemplateElement} */$(template);
               }
-              jml(template.content.cloneNode(true), shadowRoot);
+              jml( /** @type {HTMLTemplateElement} */
+              /** @type {HTMLTemplateElement} */template.content.cloneNode(true), shadowRoot);
             } else {
               if (!content) {
-                content = open || closed;
+                if (open !== true) {
+                  content = open || typeof closed === 'boolean' ? content : closed;
+                }
               }
               if (content && typeof content !== 'boolean') {
                 if (Array.isArray(content)) {
@@ -540,9 +882,11 @@ const jml = function jml(...args) {
             Object.assign(elem, attVal);
             break;
           }
-        /* istanbul ignore next */
         case '$define':
           {
+            if (!('localName' in elem)) {
+              throw new Error('Element expected for `$define`');
+            }
             const localName = elem.localName.toLowerCase();
             // Note: customized built-ins sadly not working yet
             const customizedBuiltIn = !localName.includes('-');
@@ -553,7 +897,7 @@ const jml = function jml(...args) {
             if (customizedBuiltIn) {
               is = elem.getAttribute('is');
               if (!is) {
-                if (!{}.hasOwnProperty.call(atts, 'is')) {
+                if (!Object.hasOwn(atts, 'is')) {
                   throw new TypeError(`Expected \`is\` with \`$define\` on built-in; args: ${JSON.stringify(args)}`);
                 }
                 atts.is = checkPluginValue(elem, 'is', atts.is, opts);
@@ -563,12 +907,20 @@ const jml = function jml(...args) {
                 } = atts);
               }
             }
-            const def = customizedBuiltIn ? is : localName;
+            const def = customizedBuiltIn ? /** @type {string} */is : localName;
             if (window.customElements.get(def)) {
               break;
             }
+
+            /**
+             * @param {DefineUserConstructor} [cnstrct]
+             * @returns {DefineConstructor}
+             */
             const getConstructor = cnstrct => {
-              const baseClass = options && options.extends ? doc.createElement(options.extends).constructor : customizedBuiltIn ? doc.createElement(localName).constructor : window.HTMLElement;
+              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;
 
               /**
                * Class wrapping base class.
@@ -579,14 +931,24 @@ const jml = function jml(...args) {
                  */
                 constructor() {
                   super();
+                  /** @type {DefineUserConstructor} */
                   cnstrct.call(this);
                 }
               } : class extends baseClass {};
             };
-            let cnstrctr, options, mixin;
-            if (Array.isArray(attVal)) {
-              if (attVal.length <= 2) {
-                [cnstrctr, options] = attVal;
+
+            /** @type {DefineConstructor|DefineUserConstructor|DefineMixin} */
+            let cnstrctr;
+
+            /**
+             * @type {DefineOptions|undefined}
+             */
+            let options;
+            let mixin;
+            const defineObj = /** @type {DefineObject} */attVal;
+            if (Array.isArray(defineObj)) {
+              if (defineObj.length <= 2) {
+                [cnstrctr, options] = defineObj;
                 if (typeof options === 'string') {
                   // Todo: Allow creating a definition without using it;
                   //  that may be the only reason to have a string here which
@@ -594,7 +956,7 @@ const jml = function jml(...args) {
                   options = {
                     extends: options
                   };
-                } else if (options && !{}.hasOwnProperty.call(options, 'extends')) {
+                } else if (options && !Object.hasOwn(options, 'extends')) {
                   mixin = options;
                 }
                 if (typeof cnstrctr === 'object') {
@@ -602,21 +964,21 @@ const jml = function jml(...args) {
                   cnstrctr = getConstructor();
                 }
               } else {
-                [cnstrctr, mixin, options] = attVal;
+                [cnstrctr, mixin, options] = defineObj;
                 if (typeof options === 'string') {
                   options = {
                     extends: options
                   };
                 }
               }
-            } else if (typeof attVal === 'function') {
-              cnstrctr = attVal;
+            } else if (typeof defineObj === 'function') {
+              cnstrctr = /** @type {DefineConstructor} */defineObj;
             } else {
-              mixin = attVal;
+              mixin = defineObj;
               cnstrctr = getConstructor();
             }
             if (!cnstrctr.toString().startsWith('class')) {
-              cnstrctr = getConstructor(cnstrctr);
+              cnstrctr = getConstructor( /** @type {DefineUserConstructor} */cnstrctr);
             }
             if (!options && customizedBuiltIn) {
               options = {
@@ -625,29 +987,33 @@ const jml = function jml(...args) {
             }
             if (mixin) {
               Object.entries(mixin).forEach(([methodName, method]) => {
-                cnstrctr.prototype[methodName] = method;
+                /** @type {DefineConstructor} */cnstrctr.prototype[methodName] = method;
               });
             }
             // console.log('def', def, '::', typeof options === 'object' ? options : undefined);
-            window.customElements.define(def, cnstrctr, typeof options === 'object' ? options : undefined);
+            window.customElements.define(def, /** @type {DefineConstructor} */cnstrctr, typeof options === 'object' ? options : undefined);
             break;
           }
         case '$symbol':
           {
-            const [symbol, func] = attVal;
+            const [symbol, func] = /** @type {SymbolArray} */attVal;
             if (typeof func === 'function') {
-              const funcBound = func.bind(elem);
+              const funcBound = func.bind( /** @type {Element} */elem);
               if (typeof symbol === 'string') {
+                // @ts-expect-error
                 elem[Symbol.for(symbol)] = funcBound;
               } else {
+                // @ts-expect-error
                 elem[symbol] = funcBound;
               }
             } else {
               const obj = func;
-              obj.elem = elem;
+              obj.elem = /** @type {Element} */elem;
               if (typeof symbol === 'string') {
+                // @ts-expect-error
                 elem[Symbol.for(symbol)] = obj;
               } else {
+                // @ts-expect-error
                 elem[symbol] = obj;
               }
             }
@@ -655,72 +1021,90 @@ const jml = function jml(...args) {
           }
         case '$data':
           {
-            setMap(attVal);
+            setMap( /** @type {true|string[]|Map<any, any>|WeakMap<any, any>|DataAttributeObject} */
+            attVal);
             break;
           }
         case '$attribute':
           {
             // Attribute node
-            const node = attVal.length === 3 ? doc.createAttributeNS(attVal[0], attVal[1]) : doc.createAttribute(attVal[0]);
-            node.value = attVal[attVal.length - 1];
+            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];
             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(attVal);
+            const node = doc.createTextNode( /** @type {string} */attVal);
             nodes[nodes.length] = node;
             break;
           }
         case '$document':
           {
             // Todo: Conditionally create XML document
-            const node = doc.implementation.createHTMLDocument();
-            if (attVal.childNodes) {
+            const docNode = doc.implementation.createHTMLDocument();
+            if (!attVal) {
+              throw new Error('Bad attribute value');
+            }
+            const jamlihDoc = /** @type {JamilihDocument} */attVal;
+            if (jamlihDoc.childNodes) {
               // Remove any extra nodes created by createHTMLDocument().
-              const j = attVal.childNodes.length;
-              while (node.childNodes[j]) {
-                const cn = node.childNodes[j];
+              const j = jamlihDoc.childNodes.length;
+              while (docNode.childNodes[j]) {
+                const cn = docNode.childNodes[j];
                 cn.remove();
                 // `j` should stay the same as removing will cause node to be present
               }
 
-              attVal.childNodes.forEach(_childrenToJML(node));
+              jamlihDoc.childNodes.forEach(_childrenToJML(docNode));
             } else {
-              if (attVal.$DOCTYPE) {
+              if (jamlihDoc.$DOCTYPE) {
+                var _docNode$firstChild;
                 const dt = {
-                  $DOCTYPE: attVal.$DOCTYPE
+                  $DOCTYPE: jamlihDoc.$DOCTYPE
                 };
                 const doctype = jml(dt);
-                node.firstChild.replaceWith(doctype);
+                (_docNode$firstChild = docNode.firstChild) === null || _docNode$firstChild === void 0 ? void 0 : _docNode$firstChild.replaceWith(doctype);
               }
-              const html = node.childNodes[1];
-              const head = html.childNodes[0];
-              const body = html.childNodes[1];
-              if (attVal.title || attVal.head) {
+              const html = docNode.querySelector('html');
+              const head = html === null || html === void 0 ? void 0 : html.querySelector('head');
+              const body = html === null || html === void 0 ? void 0 : html.querySelector('body');
+              if (jamlihDoc.title || jamlihDoc.head) {
                 const meta = doc.createElement('meta');
                 // eslint-disable-next-line unicorn/text-encoding-identifier-case -- HTML
                 meta.setAttribute('charset', 'utf-8');
-                head.append(meta);
-                if (attVal.title) {
-                  node.title = attVal.title; // Appends after meta
+                head === null || head === void 0 ? void 0 : head.append(meta);
+                if (jamlihDoc.title) {
+                  docNode.title = jamlihDoc.title; // Appends after meta
                 }
 
-                if (attVal.head) {
-                  attVal.head.forEach(_appendJML(head));
+                if (jamlihDoc.head && head) {
+                  // each child of `head` is:
+                  //  (JamilihArray|TextNodeString|Element|Comment|ProcessingInstruction|
+                  //  Text|DocumentFragment|JamilihProcessingInstruction|JamilihDocumentFragment)
+
+                  //   * @typedef {JamilihDoc|JamilihDoctype|JamilihTextNode|
+                  //  *   JamilihAttributeNode|JamilihOptions|ElementName|Element|
+                  //  *   JamilihDocumentFragment
+                  //  * } JamilihFirstArg
+                  // appender childJML param is: JamilihArray|JamilihFirstArg
+
+                  jamlihDoc.head.forEach(_appendJML(head));
                 }
               }
-              if (attVal.body) {
-                attVal.body.forEach(_appendJMLOrText(body));
+              if (jamlihDoc.body && body) {
+                jamlihDoc.body.forEach(_appendJMLOrText(body));
               }
             }
-            nodes[nodes.length] = node;
+            nodes[nodes.length] = docNode;
             break;
           }
         case '$DOCTYPE':
           {
-            const node = doc.implementation.createDocumentType(attVal.name, attVal.publicId || '', attVal.systemId || '');
+            const doctype = /** @type {JamilihDocumentType} */attVal;
+            const node = doc.implementation.createDocumentType(doctype.name, doctype.publicId || '', doctype.systemId || '');
             nodes[nodes.length] = node;
             break;
           }
@@ -728,21 +1112,21 @@ const jml = function jml(...args) {
           {
             // Events
             // Allow for no-op by defaulting to `{}`
-            for (let [p2, val] of Object.entries(attVal || {})) {
+            for (let [p2, val] of Object.entries( /** @type {OnAttributeObject} */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(elem, p2, val[0], val[1]); // element, event name, handler, capturing
+              _addEvent( /** @type {Element} */elem, p2, val[0], val[1]); // element, event name, handler, capturing
             }
 
             break;
           }
         case 'className':
         case 'class':
-          attVal = checkPluginValue(elem, att, attVal, opts);
+          attVal = checkPluginValue(elem, att, /** @type {string} */attVal, opts);
           if (!_isNullish(attVal)) {
             elem.className = attVal;
           }
@@ -750,6 +1134,11 @@ const jml = function jml(...args) {
         case 'dataset':
           {
             // Map can be keyed with hyphenated or camel-cased properties
+            /**
+             * @param {DatasetAttributeObject} atVal
+             * @param {string} startProp
+             * @returns {void}
+             */
             const recurse = (atVal, startProp) => {
               let prop = '';
               const pastInitialProp = startProp !== '';
@@ -766,7 +1155,7 @@ const jml = function jml(...args) {
                 recurse(value, prop);
               });
             };
-            recurse(attVal, '');
+            recurse( /** @type {DatasetAttributeObject} */attVal, '');
             break;
             // Todo: Disable this by default unless configuration explicitly allows (for security)
           }
@@ -782,13 +1171,13 @@ const jml = function jml(...args) {
         case 'htmlFor':
         case 'for':
           if (elStr === 'label') {
-            attVal = checkPluginValue(elem, att, attVal, opts);
+            attVal = checkPluginValue(elem, att, /** @type {string} */attVal, opts);
             if (!_isNullish(attVal)) {
               elem.htmlFor = attVal;
             }
             break;
           }
-          attVal = checkPluginValue(elem, att, attVal, opts);
+          attVal = checkPluginValue(elem, att, /** @type {string} */attVal, opts);
           elem.setAttribute(att, attVal);
           break;
         case 'xmlns':
@@ -797,13 +1186,14 @@ const jml = function jml(...args) {
         default:
           {
             if (att.startsWith('on')) {
-              attVal = checkPluginValue(elem, att, attVal, opts);
+              attVal = checkPluginValue(elem, att, /** @type {HandlerAttributeValue} */attVal, opts);
               elem[att] = attVal;
               // _addEvent(elem, att.slice(2), attVal, false); // This worked, but perhaps the user wishes only one event
               break;
             }
             if (att === 'style') {
-              attVal = checkPluginValue(elem, att, attVal, opts);
+              attVal = /** @type {string} */
+              checkPluginValue(elem, att, /** @type {StyleAttributeValue} */attVal, opts);
               if (_isNullish(attVal)) {
                 break;
               }
@@ -834,36 +1224,46 @@ const jml = function jml(...args) {
               */
               break;
             }
-            const matchingPlugin = getMatchingPlugin(opts, att);
+            const pluginName = att;
+            const matchingPlugin = getMatchingPlugin(opts, pluginName);
             if (matchingPlugin) {
               matchingPlugin.set({
                 opts,
                 element: elem,
                 attribute: {
-                  name: att,
-                  value: attVal
+                  name: pluginName,
+                  value: /** @type {PluginReference} */attVal
                 }
               });
               break;
             }
-            attVal = checkPluginValue(elem, att, attVal, opts);
+            attVal = checkPluginValue(elem, att, /** @type {string} */attVal, opts);
             elem.setAttribute(att, attVal);
             break;
           }
       }
     }
   }
+
+  /**
+   * @type {JamilihReturn[]}
+   */
   const nodes = [];
+
+  /** @type {string} */
   let elStr;
+
+  /** @type {JamilihOptions} */
   let opts;
   let isRoot = false;
+  let argStart = 0;
   if (_getType(args[0]) === 'object' && Object.keys(args[0]).some(key => possibleOptions.includes(key))) {
-    opts = args[0];
+    opts = /** @type {JamilihOptions} */args[0];
     if (opts.$state === undefined) {
       isRoot = true;
       opts.$state = 'root';
     }
-    if (opts.$map && !opts.$map.root && opts.$map.root !== false) {
+    if (Array.isArray(opts.$map)) {
       opts.$map = {
         root: opts.$map
       };
@@ -884,51 +1284,57 @@ const jml = function jml(...args) {
         }
       });
     }
-    args = args.slice(1);
+    argStart = 1;
   } else {
     opts = {
       $state: undefined
     };
   }
   const argc = args.length;
-  const defaultMap = opts.$map && opts.$map.root;
+  const defaultMap = opts.$map && /** @type {MapWithRoot} */opts.$map.root;
+
+  /**
+   * @param {true|string[]|Map<any, any>|WeakMap<any, any>|DataAttributeObject} dataVal
+   * @returns {void}
+   */
   const setMap = dataVal => {
     let map, obj;
+    const defMap = /** @type {[Map<Element, any> | WeakMap<Element, any>, any]} */defaultMap;
     // Boolean indicating use of default map and object
     if (dataVal === true) {
-      [map, obj] = defaultMap;
+      [map, obj] = defMap;
     } else if (Array.isArray(dataVal)) {
       // Array of strings mapping to default
       if (typeof dataVal[0] === 'string') {
         dataVal.forEach(dVal => {
-          setMap(opts.$map[dVal]);
+          setMap( /** @type {MapWithRoot} */opts.$map[dVal]);
         });
         return;
         // Array of Map and non-map data object
       }
 
-      map = dataVal[0] || defaultMap[0];
-      obj = dataVal[1] || defaultMap[1];
+      map = dataVal[0] || defMap[0];
+      obj = dataVal[1] || defMap[1];
       // Map
     } else if (/^\[object (?:Weak)?Map\]$/u.test([].toString.call(dataVal))) {
       map = dataVal;
-      obj = defaultMap[1];
+      obj = defMap[1];
       // Non-map data object
     } else {
-      map = defaultMap[0];
+      map = defMap[0];
       obj = dataVal;
     }
-    map.set(elem, obj);
+    /** @type {Map<Element, any> | WeakMap<Element, any>} */
+    map.set( /** @type {Element} */
+    elem, obj);
   };
-  for (let i = 0; i < argc; i++) {
+  for (let i = argStart; i < argc; i++) {
     let arg = args[i];
     const type = _getType(arg);
     switch (type) {
       case 'null':
         // null always indicates a place-holder (only needed for last argument if want array returned)
         if (i === argc - 1) {
-          _applyAnyStylesheet(nodes[0]); // We have to execute any stylesheets even if not appending or otherwise IE will never apply them
-          // Todo: Fix to allow application of stylesheets of style tags within fragments?
           return nodes.length <= 1 ? nodes[0]
           // eslint-disable-next-line unicorn/no-array-callback-reference
           : nodes.reduce(_fragReducer, doc.createDocumentFragment()); // nodes;
@@ -939,21 +1345,21 @@ const jml = function jml(...args) {
         // Strings normally indicate elements
         switch (arg) {
           case '!':
-            nodes[nodes.length] = doc.createComment(args[++i]);
+            nodes[nodes.length] = doc.createComment( /** @type {string} */args[++i]);
             break;
           case '?':
             {
-              arg = args[++i];
-              let procValue = args[++i];
+              arg = /** @type {string} */args[++i];
+              let procValue = /** @type {string} */args[++i];
               const val = procValue;
               if (val && typeof val === 'object') {
-                procValue = [];
+                const procValues = [];
                 for (const [p, procInstVal] of Object.entries(val)) {
-                  procValue.push(p + '=' + '"' +
+                  procValues.push(p + '=' + '"' +
                   // https://www.w3.org/TR/xml-stylesheet/#NT-PseudoAttValue
                   procInstVal.replace(/"/gu, '&quot;') + '"');
                 }
-                procValue = procValue.join(' ');
+                procValue = procValues.join(' ');
               }
               // Firefox allows instructions with ">" in this method, but not if placed directly!
               try {
@@ -971,7 +1377,8 @@ const jml = function jml(...args) {
               // Browsers don't support doc.createEntityReference, so we just use this as a convenience
             }
           case '&':
-            nodes[nodes.length] = _createSafeReference('entity', '', args[++i]);
+            nodes[nodes.length] = _createSafeReference('entity', '', /** @type {string} */
+            args[++i]);
             break;
           case '#':
             // // Decimal character reference - ['#', '01234'] // &#01234; // probably easier to use JavaScript Unicode escapes
@@ -979,16 +1386,18 @@ const jml = function jml(...args) {
             break;
           case '#x':
             // Hex character reference - ['#x', '123a'] // &#x123a; // probably easier to use JavaScript Unicode escapes
-            nodes[nodes.length] = _createSafeReference('hexadecimal', arg, args[++i]);
+            nodes[nodes.length] = _createSafeReference('hexadecimal', arg, /** @type {string} */
+            args[++i]);
             break;
           case '![':
             // '![', ['escaped <&> text'] // <![CDATA[escaped <&> text]]>
             // 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(args[++i]);
+              nodes[nodes.length] = doc.createCDATASection( /** @type {string} */args[++i]);
             } catch (e2) {
-              nodes[nodes.length] = doc.createTextNode(args[i]); // i already incremented
+              nodes[nodes.length] = doc.createTextNode( /** @type {string} */
+              args[i]); // i already incremented
             }
 
             break;
@@ -1000,19 +1409,21 @@ const jml = function jml(...args) {
           default:
             {
               // An element
-              elStr = arg;
+              elStr = /** @type {string} */arg;
               const atts = args[i + 1];
-              if (_getType(atts) === 'object' && atts.is) {
+              if (atts && _getType(atts) === 'object' && /** @type {JamilihAttributes} */atts.is) {
                 const {
                   is
-                } = atts;
-                // istanbul ignore next
-                elem = doc.createElementNS ? doc.createElementNS(NS_HTML, elStr, {
-                  is
+                } = /** @type {JamilihAttributes} */atts;
+                /* c8 ignore next */
+                elem = doc.createElementNS
+                /* eslint-disable object-shorthand -- Casting */ ? doc.createElementNS(NS_HTML, elStr, {
+                  is: /** @type {string} */is
                 }) : doc.createElement(elStr, {
-                  is
+                  is: /** @type {string} */is
                 });
-              } else /* istanbul ignore else */if (doc.createElementNS) {
+                /* eslint-enable object-shorthand -- Casting */
+              } else /* c8 ignore next */if (doc.createElementNS) {
                   elem = doc.createElementNS(NS_HTML, elStr);
                 } else {
                   elem = doc.createElement(elStr);
@@ -1027,24 +1438,33 @@ const jml = function jml(...args) {
       case 'object':
         {
           // Non-DOM-element objects indicate attribute-value pairs
+          if (!arg || typeof arg !== 'object') {
+            throw new Error('Null should not reach here');
+          }
           const atts = arg;
-          if (atts.xmlns !== undefined) {
+          if ('xmlns' in atts) {
             // We handle this here, as otherwise may lose events, etc.
             // As namespace of element already set as XHTML, we need to change the namespace
             // 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 replacer = typeof atts.xmlns === 'object' ? _replaceDefiner(atts.xmlns) : ' xmlns="' + atts.xmlns + '"';
+            const xmlnsObj = /** @type {XmlnsAttributeObject} */atts;
+            const replacer = xmlnsObj.xmlns && typeof xmlnsObj.xmlns === 'object' ? _replaceDefiner(xmlnsObj.xmlns) : ' xmlns="' + xmlnsObj.xmlns + '"';
             // try {
             // Also fix DOMParser to work with text/html
-            elem = nodes[nodes.length - 1] = new win.DOMParser().parseFromString(new win.XMLSerializer().serializeToString(elem)
+            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 + '"', replacer), 'application/xml').documentElement;
+            .replace(' xmlns="' + NS_HTML + '"',
+            // Needed to cast here, despite either overload working
+            /** @type {string} */
+            replacer), 'application/xml').documentElement;
             // Todo: Report to plugins
             opts.$state = 'element';
             // }catch(e) {alert(elem.outerHTML);throw e;}
           }
 
-          _checkAtts(atts);
+          _checkAtts( /** @type {JamilihAttributes} */atts);
           break;
         }
       case 'document':
@@ -1056,26 +1476,24 @@ const jml = function jml(...args) {
         */
         if (i === 0) {
           // Allow wrapping of element, fragment, or document
-          elem = arg;
-          // Todo: Report to plugins
+          elem = /** @type {Document|DocumentFragment|Element} */arg;
+          // Todo: Report to plugins and change for document/fragment
           opts.$state = 'element';
         }
         if (i === argc - 1 || i === argc - 2 && args[i + 1] === null) {
           // parent
           const elsl = nodes.length;
           for (let k = 0; k < elsl; k++) {
-            _appendNode(arg, nodes[k]);
+            _appendNode( /** @type {Document|DocumentFragment|Element} */arg, nodes[k]);
           }
-          // Todo: Apply stylesheets if any style tags were added elsewhere besides the first element?
-          _applyAnyStylesheet(nodes[0]); // We have to execute any stylesheets even if not appending or otherwise IE will never apply them
         } else {
-          nodes[nodes.length] = arg;
+          nodes[nodes.length] = /** @type {Document|DocumentFragment|Element} */arg;
         }
         break;
       case 'array':
         {
           // Arrays or arrays of arrays indicate child nodes
-          const child = arg;
+          const child = /** @type {JamilihChildren} */arg;
           const cl = child.length;
           for (let j = 0; j < cl; j++) {
             // Go through children array container to handle elements
@@ -1089,21 +1507,30 @@ const jml = function jml(...args) {
               case 'string':
               case 'number':
               case 'boolean':
-                _appendNode(elem, doc.createTextNode(childContent));
+                _appendNode(elem, doc.createTextNode(String(childContent)));
                 break;
               default:
+                if (!childContent || typeof childContent !== 'object') {
+                  throw new Error('Unexpected type');
+                }
                 if (Array.isArray(childContent)) {
                   // Arrays representing child elements
                   opts.$state = 'children';
+                  // @ts-expect-error Should be ok
                   _appendNode(elem, jml(opts, ...childContent));
-                } else if (childContent['#']) {
+                } else if ('#' in childContent) {
                   // Fragment
                   opts.$state = 'fragmentChildren';
                   _appendNode(elem, jml(opts, childContent['#']));
                 } else {
-                  // Single DOM element children
-                  const newChildContent = checkPluginValue(elem, null, childContent, opts);
-                  _appendNode(elem, newChildContent);
+                  // Single DOM element children or plugin
+                  let newChildContent;
+                  if (!('nodeType' in childContent)) {
+                    newChildContent = /** @type {string} */
+                    checkPluginValue(elem, null, childContent, opts, 'children');
+                  }
+                  _appendNode(elem, /** @type {string | Element | DocumentFragment | Comment} */
+                  newChildContent || childContent);
                 }
                 break;
             }
@@ -1115,34 +1542,116 @@ const jml = function jml(...args) {
     }
   }
   const ret = nodes[0] || elem;
-  if (isRoot && opts.$map && opts.$map.root) {
+  if (isRoot && opts.$map && /** @type {MapWithRoot} */opts.$map.root) {
     setMap(true);
   }
   return ret;
 };
 
+/**
+ * Configuration object.
+ * @typedef {object} ToJmlConfig
+ * @property {boolean} [stringOutput=false] Whether to output the Jamilih object as a string.
+ * @property {boolean} [reportInvalidState=true] If true (the default), will report invalid state errors
+ * @property {boolean} [stripWhitespace=false] Strip whitespace for text nodes
+ */
+
+/**
+ * @typedef {[namespace: string|null, name: string, value?: string]} JamilihAttributeNodeValue
+ */
+
+/**
+ * @typedef {{
+ *   $attribute: JamilihAttributeNodeValue
+ * }} JamilihAttributeNode
+ */
+
+/**
+ * @typedef {{
+ *   $text: string
+ * }} JamilihTextNode
+ */
+
+/**
+ * @typedef {['![', string]} JamilihCDATANode
+ */
+
+/**
+ * @typedef {['&', string]} JamilihEntityReference
+ */
+
+/**
+ * @typedef {[code: '?', target: string, value: string]} JamilihProcessingInstruction
+ */
+
+/**
+ * @typedef {[code: '!', value: string]} JamilihComment
+ */
+
+/**
+ * @typedef {{
+ *   nodeType: number,
+ *   nodeName: string
+ * }} Entity
+ */
+
+/* eslint-disable no-shadow, unicorn/custom-error-definition */
+/**
+ * Polyfill for `DOMException`.
+ */
+class DOMException extends Error {
+  /* eslint-enable no-shadow, unicorn/custom-error-definition */
+  /**
+   * @param {string} message
+   * @param {string} name
+   */
+  constructor(message, name) {
+    super(message);
+    this.code = 0;
+    // eslint-disable-next-line unicorn/custom-error-definition
+    this.name = name;
+  }
+}
+
+/**
+ * @typedef {JamilihArray|JamilihDoctype|
+*    JamilihCDATANode|JamilihEntityReference|JamilihProcessingInstruction|
+*    JamilihComment|JamilihDocumentFragment} JamilihChildType
+ */
+
+/**
+ * @typedef {JamilihDoc|JamilihAttributeNode|JamilihChildType} JamilihType
+ */
+
 /**
 * Converts a DOM object or a string of HTML into a Jamilih object (or string).
-* @param {string|HTMLElement} dom If a string, will parse as document
-* @param {PlainObject} [config] Configuration object
-* @param {boolean} [config.stringOutput=false] Whether to output the Jamilih object as a string.
-* @param {boolean} [config.reportInvalidState=true] If true (the default), will report invalid state errors
-* @param {boolean} [config.stripWhitespace=false] Strip whitespace for text nodes
+* @param {string|HTMLElement|Node|Entity} nde If a string, will parse as document
+* @param {ToJmlConfig} [config] Configuration object
 * @throws {TypeError}
-* @returns {JamilihArray|string} Array containing the elements which represent
+* @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 (dom, {
+jml.toJML = function (nde, {
   stringOutput = false,
   reportInvalidState = true,
   stripWhitespace = false
 } = {}) {
-  if (typeof dom === 'string') {
-    dom = new win.DOMParser().parseFromString(dom, 'text/html'); // todo: Give option for XML once implemented and change JSDoc to allow for Element
+  if (!win) {
+    throw new Error('No window object set');
+  }
+  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 ret = [];
+  const dom = /** @type {HTMLElement|Node|Entity} */nde;
+
+  /**
+   * @todo Find more specific type than `any`
+   * @typedef {{[key: (number|string)]: any}} IndexableObject
+   */
+
+  const ret = /** @type {IndexableObject} */[];
   let parent = ret;
   let parentIdx = 0;
 
@@ -1153,22 +1662,6 @@ jml.toJML = function (dom, {
    */
   function invalidStateError(msg) {
     // These are probably only necessary if working with text/html
-    /* eslint-disable no-shadow, unicorn/custom-error-definition */
-    /**
-     * Polyfill for `DOMException`.
-     */
-    class DOMException extends Error {
-      /* eslint-enable no-shadow, unicorn/custom-error-definition */
-      /**
-       * @param {string} message
-       * @param {string} name
-       */
-      constructor(message, name) {
-        super(message);
-        // eslint-disable-next-line unicorn/custom-error-definition
-        this.name = name;
-      }
-    }
     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');
@@ -1179,8 +1672,8 @@ jml.toJML = function (dom, {
 
   /**
    *
-   * @param {DocumentType|Entity} obj
-   * @param {Node} node
+   * @param {JamilihDocumentType} obj
+   * @param {DocumentType} node
    * @returns {void}
    */
   function addExternalID(obj, node) {
@@ -1199,10 +1692,6 @@ jml.toJML = function (dom, {
     }
   }
 
-  /**
-   * @typedef {any} ArbitraryValue
-   */
-
   /**
    *
    * @param {ArbitraryValue} val
@@ -1225,7 +1714,7 @@ jml.toJML = function (dom, {
   /**
    *
    * @param {string} prop1
-   * @param {string} prop2
+   * @param {string} [prop2]
    * @returns {void}
    */
   function setObj(prop1, prop2) {
@@ -1238,29 +1727,47 @@ jml.toJML = function (dom, {
 
   /**
    *
-   * @param {Node} node
-   * @param {Object<{string: string}>} namespaces
+   * @param {Node|Entity} nodeOrEntity
+   * @param {Object<string, string|null>} namespaces
    * @throws {TypeError}
    * @returns {void}
    */
-  function parseDOM(node, namespaces) {
+  function parseDOM(nodeOrEntity, namespaces) {
     // namespaces = clone(namespaces) || {}; // Ensure we're working with a copy, so different levels in the hierarchy can treat it differently
 
     /*
-    if ((node.prefix && node.prefix.includes(':')) || (node.localName && node.localName.includes(':'))) {
+    if ((nodeOrEntity.prefix && nodeOrEntity.prefix.includes(':')) || (nodeOrEntity.localName && nodeOrEntity.localName.includes(':'))) {
       invalidStateError('Prefix cannot have a colon');
     }
     */
 
-    const type = 'nodeType' in node ? node.nodeType : null;
+    const type = 'nodeType' in nodeOrEntity ? nodeOrEntity.nodeType : null;
+    if (!type) {
+      throw new TypeError('Not an XML type');
+    }
+    if (type === 5) {
+      // ENTITY REFERENCE (though not in browsers (was already resolved
+      //  anyways), ok to keep for parity with our "entity" shorthand)
+      set(['&', nodeOrEntity.nodeName]);
+      return;
+    }
     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) && !xmlChars.test(node.nodeValue)) {
+    if ([2, 3, 4, 7, 8].includes(type) && /** @type {Node} */nodeOrEntity.nodeValue && !xmlChars.test( /** @type {Node} */nodeOrEntity.nodeValue)) {
       invalidStateError('Node has bad XML character value');
     }
-    let tmpParent, tmpParentIdx;
+
+    /**
+     * @type {IndexableObject}
+     */
+    let tmpParent;
+
+    /**
+     * @type {Integer}
+     */
+    let tmpParentIdx;
 
     /**
      * @returns {void}
@@ -1282,11 +1789,16 @@ jml.toJML = function (dom, {
       case 1:
         {
           // ELEMENT
+          const node = /** @type {Element} */nodeOrEntity;
           setTemp();
           const nodeName = node.nodeName.toLowerCase(); // Todo: for XML, should not lower-case
 
           setChildren(); // Build child array since elements are, except at the top level, encapsulated in arrays
           set(nodeName);
+
+          /**
+           * @type {{[key: string]: string|null} & {xmlns?: string|null}}
+           */
           const start = {};
           let hasNamespaceDeclaration = false;
           if (namespaces[node.prefix || ''] !== node.namespaceURI) {
@@ -1322,57 +1834,79 @@ jml.toJML = function (dom, {
         }
       case undefined: // Treat as attribute node until this is fixed: https://github.com/jsdom/jsdom/issues/1641 / https://github.com/jsdom/jsdom/pull/1822
       case 2:
-        // ATTRIBUTE (should only get here if passing in an attribute node)
-        set({
-          $attribute: [node.namespaceURI, node.name, node.value]
-        });
-        break;
+        {
+          // ATTRIBUTE (should only get here if passing in an attribute node)
+          const node = /** @type {Attr} */nodeOrEntity;
+          set({
+            $attribute: [node.namespaceURI, node.name, node.value]
+          });
+          break;
+        }
       case 3:
-        // TEXT
-        if (stripWhitespace && /^\s+$/u.test(node.nodeValue)) {
-          set('');
-          return;
+        {
+          // TEXT
+          const node = /** @type {Text} */nodeOrEntity;
+          /* c8 ignore next 3 */
+          if (!node.nodeValue) {
+            throw new Error('Unexpected null comment value');
+          }
+          if (stripWhitespace && /^\s+$/u.test(node.nodeValue)) {
+            set('');
+            return;
+          }
+          set(node.nodeValue);
+          break;
         }
-        set(node.nodeValue);
-        break;
       case 4:
-        // CDATA
-        if (node.nodeValue.includes(']]' + '>')) {
-          invalidStateError('CDATA cannot end with closing ]]>');
+        {
+          var _node$nodeValue;
+          // CDATA
+          const node = /** @type {CDATASection} */nodeOrEntity;
+          if ((_node$nodeValue = node.nodeValue) !== null && _node$nodeValue !== void 0 && _node$nodeValue.includes(']]' + '>')) {
+            invalidStateError('CDATA cannot end with closing ]]>');
+          }
+          set(['![', node.nodeValue]);
+          break;
         }
-        set(['![', node.nodeValue]);
-        break;
-      case 5:
-        // ENTITY REFERENCE (though not in browsers (was already resolved
-        //  anyways), ok to keep for parity with our "entity" shorthand)
-        set(['&', node.nodeName]);
-        break;
+      // case 5:
+      // Handled earlier
       case 7:
-        // PROCESSING INSTRUCTION
-        if (/^xml$/iu.test(node.target)) {
-          invalidStateError('Processing instructions cannot be "xml".');
-        }
-        if (node.target.includes('?>')) {
-          invalidStateError('Processing instruction targets cannot include ?>');
-        }
-        if (node.target.includes(':')) {
-          invalidStateError('The processing instruction target cannot include ":"');
-        }
-        if (node.data.includes('?>')) {
-          invalidStateError('Processing instruction data cannot include ?>');
+        {
+          // PROCESSING INSTRUCTION
+          const node = /** @type {ProcessingInstruction} */nodeOrEntity;
+          if (/^xml$/iu.test(node.target)) {
+            invalidStateError('Processing instructions cannot be "xml".');
+          }
+          if (node.target.includes('?>')) {
+            invalidStateError('Processing instruction targets cannot include ?>');
+          }
+          if (node.target.includes(':')) {
+            invalidStateError('The processing instruction target cannot include ":"');
+          }
+          if (node.data.includes('?>')) {
+            invalidStateError('Processing instruction data cannot include ?>');
+          }
+          set(['?', node.target, node.data]); // Todo: Could give option to attempt to convert value back into object if has pseudo-attributes
+          break;
         }
-        set(['?', node.target, node.data]); // Todo: Could give option to attempt to convert value back into object if has pseudo-attributes
-        break;
       case 8:
-        // COMMENT
-        if (node.nodeValue.includes('--') || node.nodeValue.length && node.nodeValue.lastIndexOf('-') === node.nodeValue.length - 1) {
-          invalidStateError('Comments cannot include --');
+        {
+          // COMMENT
+          const node = /** @type {Comment} */nodeOrEntity;
+          /* c8 ignore next 3 */
+          if (!node.nodeValue) {
+            throw new Error('Unexpected null comment value');
+          }
+          if (node.nodeValue.includes('--') || node.nodeValue.length && node.nodeValue.lastIndexOf('-') === node.nodeValue.length - 1) {
+            invalidStateError('Comments cannot include --');
+          }
+          set(['!', node.nodeValue]);
+          break;
         }
-        set(['!', node.nodeValue]);
-        break;
       case 9:
         {
           // DOCUMENT
+          const node = /** @type {Document} */nodeOrEntity;
           setTemp();
           const docObj = {
             $document: {
@@ -1402,16 +1936,17 @@ jml.toJML = function (dom, {
       case 10:
         {
           // DOCUMENT TYPE
+          const node = /** @type {DocumentType} */nodeOrEntity;
           setTemp();
 
           // Can create directly by doc.implementation.createDocumentType
           const start = {
             $DOCTYPE: {
-              name: node.name
+              name: /** @type {DocumentType} */node.name
             }
           };
           const pubIdChar = /^(\u0020|\u000D|\u000A|[a-zA-Z0-9]|[-'()+,./:=?;!*#@$_%])*$/u; // eslint-disable-line no-control-regex
-          if (!pubIdChar.test(node.publicId)) {
+          if (!pubIdChar.test( /** @type {DocumentType} */node.publicId)) {
             invalidStateError('A publicId must have valid characters.');
           }
           addExternalID(start.$DOCTYPE, node);
@@ -1424,6 +1959,7 @@ jml.toJML = function (dom, {
       case 11:
         {
           // DOCUMENT FRAGMENT
+          const node = /** @type {DocumentFragment} */nodeOrEntity;
           setTemp();
           set({
             '#': []
@@ -1451,15 +1987,23 @@ jml.toJML = function (dom, {
   }
   return ret[0];
 };
+
+/**
+ * @param {string|HTMLElement} dom
+ * @param {ToJmlConfig} [config]
+ * @returns {string}
+ */
 jml.toJMLString = function (dom, config) {
-  return jml.toJML(dom, Object.assign(config || {}, {
-    stringOutput: true
-  }));
+  return (/** @type {string} */
+    jml.toJML(dom, Object.assign(config || {}, {
+      stringOutput: true
+    }))
+  );
 };
 
 /**
  *
- * @param {...JamilihArray} args
+ * @param {JamilihArray} args
  * @returns {JamilihReturn}
  */
 jml.toDOM = function (...args) {
@@ -1469,21 +2013,75 @@ jml.toDOM = function (...args) {
 
 /**
  *
- * @param {...JamilihArray} args
+ * @param {JamilihArray} args
  * @returns {string}
  */
 jml.toHTML = function (...args) {
   // Todo: Replace this with version of jml() that directly builds a string
   const ret = jml(...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 ret.outerHTML;
+  switch (ret.nodeType) {
+    case 1:
+      {
+        // Element
+        // 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 {Element} */ret.outerHTML
+        );
+      }
+    case 2:
+      {
+        // ATTR
+        return `${
+        /** @type {Attr} */ret.name}="${
+        /** @type {Attr} */ret.value.replace(/"/gu, '&quot;')}"`;
+      }
+    case 3:
+    case 4:
+      {
+        // CDATA
+        if (!ret.nodeValue) {
+          throw new TypeError('Unexpected null Text node');
+        }
+        return (/** @type {Text|CDATASection} */ret.nodeValue
+        );
+        // case 5: // Entity
+      }
+    case 7:
+      {
+        // PROCESSING INSTRUCTION
+        const node = /** @type {ProcessingInstruction} */ret;
+        return `<?${node.target} ${node.data}?>`;
+      }
+    case 8:
+      {
+        // Comment
+        return `<!--${ret.nodeValue}-->`;
+      }
+    case 9:
+      {
+        // Document
+        throw new Error('Document serialization not yet implemented');
+      }
+    case 10:
+      {
+        // DOCUMENT TYPE
+        const node = /** @type {DocumentType} */ret;
+        return `<!DOCTYPE ${node.name}${node.publicId ? `PUBLIC "${node.publicId}" "${node.systemId}"` : node.systemId ? `SYSTEM "${node.systemId}"` : ``}>`;
+      }
+    case 11:
+      {
+        // DOCUMENT FRAGMENT
+        throw new Error('Document fragment serialization not yet implemented');
+      }
+    default:
+      throw new Error('Unexpected node type');
+  }
 };
 
 /**
  *
- * @param {...JamilihArray} args
+ * @param {JamilihArray} args
  * @returns {string}
  */
 jml.toDOMString = function (...args) {
@@ -1493,17 +2091,20 @@ jml.toDOMString = function (...args) {
 
 /**
  *
- * @param {...JamilihArray} args
+ * @param {JamilihArray} args
  * @returns {string}
  */
 jml.toXML = function (...args) {
+  if (!win) {
+    throw new Error('No window object set');
+  }
   const ret = jml(...args);
-  return new win.XMLSerializer().serializeToString(ret);
+  return new /** @type {import('jsdom').DOMWindow} */win.XMLSerializer().serializeToString(ret);
 };
 
 /**
  *
- * @param {...JamilihArray} args
+ * @param {JamilihArray} args
  * @returns {string}
  */
 jml.toXMLDOMString = function (...args) {
@@ -1516,63 +2117,73 @@ jml.toXMLDOMString = function (...args) {
  */
 class JamilihMap extends Map {
   /**
-   * @param {string|Element} elem
+   * @param {?(string|Element)} element
    * @returns {ArbitraryValue}
    */
-  get(elem) {
-    elem = typeof elem === 'string' ? $(elem) : elem;
+  get(element) {
+    const elem = typeof element === 'string' ? $(element) : element;
     return super.get.call(this, elem);
   }
   /**
-   * @param {string|Element} elem
+   * @param {string|Element} element
    * @param {ArbitraryValue} value
    * @returns {ArbitraryValue}
    */
-  set(elem, value) {
-    elem = typeof elem === 'string' ? $(elem) : elem;
+  set(element, value) {
+    const elem = typeof element === 'string' ? $(element) : element;
     return super.set.call(this, elem, value);
   }
   /**
-   * @param {string|Element} elem
+   * @param {string|Element} element
    * @param {string} methodName
    * @param {...ArbitraryValue} args
    * @returns {ArbitraryValue}
    */
-  invoke(elem, methodName, ...args) {
-    elem = typeof elem === 'string' ? $(elem) : elem;
+  invoke(element, methodName, ...args) {
+    const elem = typeof element === 'string' ? $(element) : element;
     return this.get(elem)[methodName](elem, ...args);
   }
 }
 
 /**
  * Element-aware wrapper for `WeakMap`.
+ * @extends {WeakMap<any>}
  */
 class JamilihWeakMap extends WeakMap {
   /**
-   * @param {string|Element} elem
+   * @param {Element} element
    * @returns {ArbitraryValue}
    */
-  get(elem) {
-    elem = typeof elem === 'string' ? $(elem) : elem;
+  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);
   }
   /**
-   * @param {string|Element} elem
+   * @param {Element} element
    * @param {ArbitraryValue} value
    * @returns {ArbitraryValue}
    */
-  set(elem, value) {
-    elem = typeof elem === 'string' ? $(elem) : elem;
+  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);
   }
   /**
-   * @param {string|Element} elem
+   * @param {string|Element} element
    * @param {string} methodName
    * @param {...ArbitraryValue} args
    * @returns {ArbitraryValue}
    */
-  invoke(elem, methodName, ...args) {
-    elem = typeof elem === 'string' ? $(elem) : elem;
+  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);
   }
 }
@@ -1580,14 +2191,12 @@ jml.Map = JamilihMap;
 jml.WeakMap = JamilihWeakMap;
 
 /**
-* @typedef {GenericArray} MapAndElementArray
-* @property {JamilihWeakMap|JamilihMap} 0
-* @property {Element} 1
-*/
+ * @typedef {[JamilihWeakMap|JamilihMap, Element]} MapAndElementArray
+ */
 
 /**
- * @param {GenericObject} obj
- * @param {...JamilihArray} args
+ * @param {{[key: string]: any}} obj
+ * @param {JamilihArrayPostOptions} args
  * @returns {MapAndElementArray}
  */
 jml.weak = function (obj, ...args) {
@@ -1595,12 +2204,12 @@ jml.weak = function (obj, ...args) {
   const elem = jml({
     $map: [map, obj]
   }, ...args);
-  return [map, elem];
+  return [map, /** @type {Element} */elem];
 };
 
 /**
  * @param {ArbitraryValue} obj
- * @param {...JamilihArray} args
+ * @param {JamilihArrayPostOptions} args
  * @returns {MapAndElementArray}
  */
 jml.strong = function (obj, ...args) {
@@ -1608,22 +2217,28 @@ jml.strong = function (obj, ...args) {
   const elem = jml({
     $map: [map, obj]
   }, ...args);
-  return [map, elem];
+  return [map, /** @type {Element} */elem];
 };
 
 /**
- * @param {string|Element} elem If a string, will be interpreted as a selector
+ * @param {string|Element} 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
  */
-jml.symbol = jml.sym = jml.for = function (elem, sym) {
-  elem = typeof elem === 'string' ? $(elem) : elem;
+jml.symbol = jml.sym = jml.for = function (element, sym) {
+  const elem = typeof element === 'string' ? $(element) : element;
+
+  // @ts-expect-error Should be ok
   return elem[typeof sym === 'symbol' ? sym : Symbol.for(sym)];
 };
 
 /**
- * @param {string|Element} elem If a string, will be interpreted as a selector
- * @param {symbol|string|Map|WeakMap} symOrMap If a string, will be used with `Symbol.for`
+ * @typedef {((elem: Element, ...args: any[]) => void)|{[key: string]: (elem: Element, ...args: any[]) => void}} MapCommand
+ */
+
+/**
+ * @param {?(string|Element)} elem If a string, will be interpreted as a selector
+ * @param {symbol|string|Map<Element, MapCommand>|WeakMap<Element, MapCommand>} symOrMap If a string, will be used with `Symbol.for`
  * @param {string|any} methodName Can be `any` if the symbol or map directly
  *   points to a function (it is then used as the first argument).
  * @param {ArbitraryValue[]} args
@@ -1631,16 +2246,22 @@ jml.symbol = jml.sym = jml.for = function (elem, sym) {
  */
 jml.command = function (elem, symOrMap, methodName, ...args) {
   elem = typeof elem === 'string' ? $(elem) : elem;
+  if (!elem) {
+    throw new Error('No element found');
+  }
   let func;
   if (['symbol', 'string'].includes(typeof symOrMap)) {
-    func = jml.sym(elem, symOrMap);
+    func = jml.sym(elem, /** @type {symbol|string} */symOrMap);
     if (typeof func === 'function') {
       return func(methodName, ...args); // Already has `this` bound to `elem`
     }
 
     return func[methodName](...args);
   }
-  func = symOrMap.get(elem);
+  func = /** @type {Map<Element, MapCommand>|WeakMap<Element, MapCommand>} */symOrMap.get(elem);
+  if (!func) {
+    throw new Error('No map found');
+  }
   if (typeof func === 'function') {
     return func.call(elem, methodName, ...args);
   }
@@ -1651,42 +2272,51 @@ jml.command = function (elem, symOrMap, methodName, ...args) {
 /**
  * Expects properties `document`, `XMLSerializer`, and `DOMParser`.
  * Also updates `body` with `document.body`.
- * @param {Window} wind
+ * @param {import('jsdom').DOMWindow|HTMLWindow} wind
  * @returns {void}
  */
 jml.setWindow = wind => {
   win = wind;
   doc = win.document;
   if (doc && doc.body) {
-    ({
-      body
-    } = doc);
+    // eslint-disable-next-line prefer-destructuring -- Needed for typing
+    body = /** @type {HTMLBodyElement} */doc.body;
   }
 };
 
 /**
- * @returns {Window}
+ * @returns {import('jsdom').DOMWindow|HTMLWindow}
  */
 jml.getWindow = () => {
+  if (!win) {
+    throw new Error('No window object set');
+  }
   return win;
 };
 
 /**
  * Does not run Jamilih so can be further processed.
- * @param {JamilihArray} jmlArray
- * @param {string|JamilihArray|Element} glu
- * @returns {Element}
+ * @param {ArbitraryValue[]} array
+ * @param {ArbitraryValue} glu
+ * @returns {ArbitraryValue[]}
  */
-function glue(jmlArray, glu) {
-  return [...jmlArray].reduce((arr, item) => {
+function glue(array, glu) {
+  return [...array].reduce((arr, item) => {
     arr.push(item, glu);
     return arr;
   }, []).slice(0, -1);
 }
 
-// istanbul ignore next
-let body = doc && doc.body; // eslint-disable-line import/no-mutable-exports
+/**
+ * @type {HTMLBodyElement}
+ */
+let body; // eslint-disable-line import/no-mutable-exports
 
+/* c8 ignore next 3 */
+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
 
-export { $, $$, body, jml as default, glue, jml, nbsp };
+export { $, $$, DOMException, body, jml as default, glue, jml, nbsp };