unicode-input-toolconverter 0.2.0 → 0.2.2

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

@@ -1,40 +1,830 @@
-var _win;
+/**
+ * The recognized keys on the optional leading options object passed to `jml()`.
+ *
+ * An object in first-argument position is only treated as an options object
+ * when it carries at least one of these keys.
+ *
+ * `$mode` (reserved for a future SVG/XML mode) and `$state` (the internal
+ * traversal marker) are deliberately absent: they are reserved names that
+ * `jml()` rejects when author-supplied. Templating dialects layered on Jamilih
+ * may use any other `$`-prefixed key freely; `validateJamilih`'s
+ * `allowableOptions` governs validation of those.
+ * @type {string[]}
+ */
+const possibleOptions = ['$plugins', '$Map'];
+
+/**
+ * Structural + policy validator for Jamilih input.
+ *
+ * Window-free and dependency-free: it re-implements the `jml()` argument
+ * grammar as a non-mutating recursive checker and never calls `jml()` or
+ * touches a DOM. Its only import is the shared {@link possibleOptions} list.
+ */
+
+
+/**
+ * @typedef {"javascript"|"json"} ValidateJamilihFormat
+ */
+
+/**
+ * @typedef {object} ValidateJamilihOptions
+ * @property {ValidateJamilihFormat} [format] Default `"javascript"`. `"json"`
+ *   additionally requires every value to be losslessly JSON round-trippable.
+ * @property {boolean} [allowInnerHTML] Default `true`. When `false`, an
+ *   `innerHTML` attribute key is rejected.
+ * @property {boolean} [allowDOM] Default `true`; forced `false` when
+ *   `format` is `"json"`. When effectively `false`, raw DOM nodes are rejected.
+ * @property {string[]} [allowableOptions] Whitelist of extensible
+ *   `$`-prefixed properties accepted wherever `$` magic is read. Sentinels:
+ *   `"default"` expands to the builtin option keys, `"any"` / `"*"` permits
+ *   any unknown `$`-key. Omitting the option is equivalent to `["default"]`.
+ * @property {boolean} [failFast] Default `false`. When `true`, stop at the
+ *   first error.
+ */
+
+/**
+ * @typedef {object} JamilihValidationError
+ * @property {string} code Stable enum, e.g. `"BAD_CHILD"`.
+ * @property {string} message Human-readable description.
+ * @property {string} path JSON-pointer-ish location, e.g. `"/2/0/1"`.
+ */
+
+/**
+ * @typedef {object} JamilihValidationResult
+ * @property {boolean} valid
+ * @property {JamilihValidationError[]} errors
+ */
+
+const FAIL_FAST = Symbol('validateJamilih.failFast');
+const RESERVED_NAMES = ['$state', '$mode'];
+
+// Node-producing keys a first-argument object may carry (mirrors `jml()`).
+const FIRST_ARG_NODE_KEYS = ['#', '$text', '$document', '$DOCTYPE', '$attribute'];
+
+// `$`-keys `_checkAtts` / the first-argument object handling recognize. Valid
+// only as an attributes object or an array-wrapped first-argument object, not
+// as a bare object child.
+const MAGIC_ATTR_BUILTINS = ['$on', '$symbol', '$define', '$data', '$custom', '$shadow', '$attribute', '$text', '$document', '$DOCTYPE'];
+const TEXTUAL_TYPES = ['string', 'number', 'boolean'];
+const NON_NODE_PRIMITIVE_TYPES = ['function', 'symbol', 'bigint'];
+
+// First-argument special strings and how many following string args they take.
+const SPECIAL_STRING_ARGC = {
+  '!': 1,
+  '&': 1,
+  '#': 1,
+  '#x': 1,
+  '?': 2,
+  '![': 1
+};
+
+/**
+ * @param {unknown} v
+ * @returns {boolean}
+ */
+function isDOMNode(v) {
+  return Boolean(v && typeof v === 'object' && typeof (/** @type {{nodeType?: unknown}} */v).nodeType === 'number');
+}
+
+/**
+ * @param {unknown} v
+ * @returns {boolean}
+ */
+function isMapLike(v) {
+  return /^\[object (?:Weak)?Map\]$/u.test(Object.prototype.toString.call(v));
+}
+
+/**
+ * @param {unknown} v
+ * @returns {boolean}
+ */
+function isPlainObject(v) {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isPluginKey(key) {
+  return key.startsWith('$_');
+}
+
+/**
+ * @param {unknown} v
+ * @returns {boolean}
+ */
+function isNullish(v) {
+  return v === null || v === undefined;
+}
+
+/**
+ * @param {ValidateJamilihOptions} options
+ * @throws {TypeError} If `allowableOptions` is not an array.
+ * @returns {{allowAny: boolean, allowable: Set<string>, emptyPolicy: boolean}}
+ */
+function resolveAllowable(options) {
+  const provided = Object.hasOwn(options, 'allowableOptions');
+  const raw = provided ? options.allowableOptions : ['default'];
+  if (!Array.isArray(raw)) {
+    throw new TypeError('`allowableOptions` must be an array of strings');
+  }
+  let allowAny = false;
+  const allowable = new Set();
+  for (const entry of raw) {
+    if (entry === 'any' || entry === '*') {
+      allowAny = true;
+    } else if (entry === 'default') {
+      for (const k of possibleOptions) {
+        allowable.add(k);
+      }
+    } else {
+      allowable.add(entry);
+    }
+  }
+  return {
+    allowAny,
+    allowable,
+    emptyPolicy: provided && raw.length === 0
+  };
+}
+
+/**
+ * Validate a single-array Jamilih structure against structural and policy
+ * rules.
+ * @param {unknown} structure The JSON-serializable Jamilih array form.
+ * @param {ValidateJamilihOptions} [options]
+ * @throws {TypeError} If `format` or `allowableOptions` is invalid.
+ * @returns {JamilihValidationResult}
+ */
+const validateJamilih = (structure, options = {}) => {
+  const format = options.format ?? 'javascript';
+  if (format !== 'javascript' && format !== 'json') {
+    throw new TypeError(`Unknown \`format\`: ${JSON.stringify(format)}`);
+  }
+  const allowInnerHTML = options.allowInnerHTML !== false;
+  const failFast = options.failFast === true;
+  const {
+    allowAny,
+    allowable,
+    emptyPolicy
+  } = resolveAllowable(options);
+
+  // `json` can never carry a DOM node; the explicit combination is a conflict.
+  const domConflict = format === 'json' && options.allowDOM === true;
+  const allowDOM = format === 'json' ? false : options.allowDOM !== false;
+
+  /** @type {JamilihValidationError[]} */
+  const errors = [];
+
+  /**
+   * @param {string} code
+   * @param {string} message
+   * @param {(string|number)[]} pathParts
+   * @returns {void}
+   */
+  const err = (code, message, pathParts) => {
+    errors.push({
+      code,
+      message,
+      path: pathParts.length ? '/' + pathParts.join('/') : '/'
+    });
+    if (failFast) {
+      throw FAIL_FAST;
+    }
+  };
+
+  /**
+   * @param {string} key
+   * @returns {boolean}
+   */
+  const isReserved = key => RESERVED_NAMES.includes(key);
+
+  /**
+   * @param {string} key
+   * @returns {boolean}
+   */
+  const isOptionKey = key => possibleOptions.includes(key);
+
+  /**
+   * Deep JSON round-trippability check for `format: "json"`.
+   * @param {unknown} v
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const checkJSONValue = (v, path) => {
+    if (v === null) {
+      return;
+    }
+    const t = typeof v;
+    if (t === 'string' || t === 'boolean') {
+      return;
+    }
+    if (t === 'number') {
+      if (!Number.isFinite(v)) {
+        err('NON_JSON_VALUE', '`NaN`/`Infinity` is not valid JSON', path);
+      }
+      return;
+    }
+    if (t === 'undefined') {
+      err('NON_JSON_VALUE', '`undefined` is not valid JSON', path);
+      return;
+    }
+    if (NON_NODE_PRIMITIVE_TYPES.includes(t)) {
+      err('NON_JSON_VALUE', `A ${t} value is not valid JSON`, path);
+      return;
+    }
+    if (isDOMNode(v)) {
+      err('NON_JSON_VALUE', 'A DOM node is not valid JSON', path);
+      return;
+    }
+    if (isMapLike(v)) {
+      err('NON_JSON_VALUE', 'A Map/WeakMap is not valid JSON', path);
+      return;
+    }
+    if (Array.isArray(v)) {
+      v.forEach((item, i) => checkJSONValue(item, [...path, i]));
+      return;
+    }
+    if (!isPlainObject(v)) {
+      err('NON_JSON_VALUE', 'A non-plain object (Date/RegExp/class instance) is not valid JSON', path);
+      return;
+    }
+    for (const [k, item] of Object.entries(/** @type {Record<string, unknown>} */v)) {
+      checkJSONValue(item, [...path, k]);
+    }
+  };
+
+  /**
+   * @param {string} key
+   * @param {unknown} val
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const checkExtensibleMagicKey = (key, val, path) => {
+    if (allowAny || allowable.has(key)) {
+      if (format === 'json') {
+        checkJSONValue(val, path);
+      }
+      return;
+    }
+    err('UNKNOWN_MAGIC_PROPERTY', `Unknown \`$\`-prefixed property \`${key}\` is not permitted by \`allowableOptions\``, path);
+  };
+
+  /**
+   * @param {Record<string, unknown>} obj
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const flagMisplacedOptions = (obj, path) => {
+    for (const k of Object.keys(obj)) {
+      if (k === '$state' || isOptionKey(k)) {
+        err('MISPLACED_OPTIONS_OBJECT', `\`${k}\` is a root-only option and cannot appear on a nested array head`, [...path, k]);
+      }
+    }
+  };
+
+  /**
+   * @param {unknown} val
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const validatePluginsOption = (val, path) => {
+    if (!Array.isArray(val)) {
+      err('BAD_ATTRIBUTES_OBJECT', '`$plugins` must be an array', path);
+      return;
+    }
+    val.forEach((p, i) => {
+      if (!p || typeof p !== 'object') {
+        err('BAD_ATTRIBUTES_OBJECT', '`$plugins` entries must be objects', [...path, i]);
+        return;
+      }
+      const plugin = /** @type {{name?: unknown, set?: unknown}} */p;
+      if (typeof plugin.name !== 'string' || !plugin.name.startsWith('$_')) {
+        err('BAD_ATTRIBUTES_OBJECT', 'Plugin `name` must be a string beginning with `$_`', [...path, i, 'name']);
+      }
+      if (format === 'json') {
+        err('NON_JSON_CONSTRUCT', 'Plugins require a `set` function; not valid in `format: "json"`', [...path, i, 'set']);
+      } else if (typeof plugin.set !== 'function') {
+        err('BAD_ATTRIBUTES_OBJECT', 'Plugin `set` must be a function', [...path, i, 'set']);
+      }
+    });
+  };
+
+  /**
+   * @param {unknown} val
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const validateMapOption = (val, path) => {
+    if (format === 'json') {
+      err('NON_JSON_CONSTRUCT', '`$Map` carries a Map/WeakMap; not valid in `format: "json"`', path);
+      return;
+    }
+    const ok = isMapLike(val) || Array.isArray(val) && (val[0] === undefined || isMapLike(val[0])) || isPlainObject(val) && Object.hasOwn(/** @type {object} */val, 'root');
+    if (!ok) {
+      err('BAD_DATA', '`$Map` must be `[map, value]` or `{root: [...], ...}`', path);
+    }
+  };
+
+  /**
+   * @param {unknown} val
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const validateOnObject = (val, path) => {
+    if (!isPlainObject(val)) {
+      err('BAD_ON_HANDLER', '`$on` must be an object of event handlers', path);
+      return;
+    }
+    const entries = Object.entries(/** @type {Record<string, unknown>} */val);
+    if (entries.length === 0) {
+      return; // documented no-op
+    }
+    if (format === 'json') {
+      err('NON_JSON_CONSTRUCT', '`$on` handlers are functions; not valid in `format: "json"`', path);
+      return;
+    }
+    for (const [evt, handler] of entries) {
+      const okHandler = typeof handler === 'function' || Array.isArray(handler) && typeof handler[0] === 'function';
+      if (!okHandler) {
+        err('BAD_ON_HANDLER', `\`$on.${evt}\` must be a function or \`[function, capturing]\``, [...path, evt]);
+      }
+    }
+  };
+
+  /**
+   * @param {unknown} val
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const validateShadowObject = (val, path) => {
+    if (!isPlainObject(val)) {
+      err('BAD_SHADOW', '`$shadow` must be an object', path);
+      return;
+    }
+    const obj = /** @type {Record<string, unknown>} */val;
+    for (const slot of ['template', 'content']) {
+      if (!Object.hasOwn(obj, slot)) {
+        continue;
+      }
+      const v = obj[slot];
+      if (Array.isArray(v)) {
+        validateChildrenContainer(v, [...path, slot]);
+      } else if (isDOMNode(v)) {
+        if (!allowDOM) {
+          err('DOM_NODE_NOT_ALLOWED', `\`$shadow.${slot}\` DOM node is not allowed`, [...path, slot]);
+        }
+      } else if (typeof v !== 'string' && typeof v !== 'boolean' && !isNullish(v)) {
+        err('BAD_SHADOW', `\`$shadow.${slot}\` must be a Jamilih array, selector string, or DOM node`, [...path, slot]);
+      }
+    }
+  };
+
+  /**
+   * @param {unknown} val
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const validateDocumentObject = (val, path) => {
+    if (!isPlainObject(val)) {
+      err('BAD_ATTRIBUTES_OBJECT', '`$document` must be an object', path);
+      return;
+    }
+    const obj = /** @type {Record<string, unknown>} */val;
+    for (const slot of ['childNodes', 'head', 'body']) {
+      if (Array.isArray(obj[slot])) {
+        validateChildrenContainer(/** @type {unknown[]} */obj[slot], [...path, slot]);
+      }
+    }
+  };
+
+  /**
+   * @param {Record<string, unknown>} obj
+   * @param {(string|number)[]} path
+   * @param {boolean} isChildHead
+   * @returns {void}
+   */
+  const validateAttributesObject = (obj, path, isChildHead) => {
+    for (const [key, val] of Object.entries(obj)) {
+      const at = [...path, key];
+      if (key === '#') {
+        if (Array.isArray(val)) {
+          validateChildrenContainer(val, at);
+        } else {
+          err('BAD_ATTRIBUTES_OBJECT', '`#` must hold an array of children', at);
+        }
+        continue;
+      }
+      if (isReserved(key)) {
+        err('RESERVED_OPTION', `\`${key}\` is reserved by Jamilih and may not be supplied`, at);
+        continue;
+      }
+      if (isOptionKey(key)) {
+        err('MISPLACED_OPTIONS_OBJECT', `\`${key}\` is a root-only option and cannot appear ${isChildHead ? 'on a nested array head' : 'in an attributes object'}`, at);
+        continue;
+      }
+      if (key === 'innerHTML') {
+        if (!allowInnerHTML) {
+          err('INNERHTML_NOT_ALLOWED', '`innerHTML` is not allowed (`allowInnerHTML: false`)', at);
+        } else if (typeof val !== 'string' && !isNullish(val)) {
+          err('BAD_ATTRIBUTES_OBJECT', '`innerHTML` must be a string', at);
+        }
+        continue;
+      }
+      if (key === '$text') {
+        if (typeof val !== 'string') {
+          err('BAD_ATTRIBUTES_OBJECT', '`$text` must be a string', at);
+        }
+        continue;
+      }
+      if (key === '$attribute') {
+        const bad = !Array.isArray(val) || val.length < 2 || val.length > 3 || val.slice(1).some(s => !isNullish(s) && typeof s !== 'string');
+        if (bad) {
+          err('BAD_ATTRIBUTE_NODE', '`$attribute` must be `[namespace, name, value?]`', at);
+        }
+        continue;
+      }
+      if (key === '$DOCTYPE') {
+        if (!isPlainObject(val) || typeof (/** @type {{name?: unknown}} */val).name !== 'string') {
+          err('BAD_DOCTYPE', '`$DOCTYPE` must be an object with a string `name`', at);
+        }
+        continue;
+      }
+      if (key === '$document') {
+        validateDocumentObject(val, at);
+        continue;
+      }
+      if (key === '$on') {
+        validateOnObject(val, at);
+        continue;
+      }
+      if (key === '$symbol') {
+        if (format === 'json') {
+          err('NON_JSON_CONSTRUCT', '`$symbol` is not valid in `format: "json"`', at);
+        } else {
+          const bad = !Array.isArray(val) || val.length !== 2 || typeof val[0] !== 'string' && typeof val[0] !== 'symbol' || typeof val[1] !== 'function' && !isPlainObject(val[1]);
+          if (bad) {
+            err('BAD_SYMBOL', '`$symbol` must be `[symbol|string, function|object]`', at);
+          }
+        }
+        continue;
+      }
+      if (key === '$define') {
+        if (format === 'json') {
+          err('NON_JSON_CONSTRUCT', '`$define` is not valid in `format: "json"`', at);
+        } else if (typeof val !== 'function' && !isPlainObject(val) && !Array.isArray(val)) {
+          err('BAD_DEFINE', '`$define` must be a function, mixin object, or array', at);
+        }
+        continue;
+      }
+      if (key === '$data') {
+        if (format === 'json') {
+          err('NON_JSON_CONSTRUCT', '`$data` requires an options `Map`; not valid in `format: "json"`', at);
+        } else if (val !== true && !Array.isArray(val) && !isMapLike(val) && !isPlainObject(val)) {
+          err('BAD_DATA', '`$data` must be `true`, an array, a Map, or a data object', at);
+        }
+        continue;
+      }
+      if (key === '$custom') {
+        if (val && (typeof val === 'object' || typeof val === 'function') && Object.prototype.propertyIsEnumerable.call(val, '__proto__')) {
+          err('BAD_CUSTOM_PROTO', '`$custom` may not define `__proto__`', at);
+        }
+        if (format === 'json') {
+          checkJSONValue(val, at);
+        }
+        continue;
+      }
+      if (key === '$shadow') {
+        validateShadowObject(val, at);
+        continue;
+      }
+      if (isPluginKey(key)) {
+        if (format === 'json') {
+          checkJSONValue(val, at);
+        }
+        continue;
+      }
+      if (!key.startsWith('$') && key.startsWith('on')) {
+        if (format === 'json' && typeof val === 'function') {
+          err('NON_JSON_CONSTRUCT', `\`${key}\` handler function is not valid in \`format: "json"\``, at);
+        }
+        continue;
+      }
+      if (key.startsWith('$')) {
+        checkExtensibleMagicKey(key, val, at);
+        continue;
+      }
+      // Ordinary attribute (including `class`, `style`, `dataset`, ...). In
+      // `javascript` mode jml() coerces the value via `setAttribute`, so
+      // nothing further is enforced here.
+      if (format === 'json') {
+        checkJSONValue(val, at);
+      }
+    }
+  };
+
+  /**
+   * A children-array container: each entry is a child node.
+   * @param {unknown[]} arr
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const validateChildrenContainer = (arr, path) => {
+    arr.forEach((child, j) => {
+      const at = [...path, j];
+      if (isNullish(child)) {
+        err('BAD_CHILD', '`null`/`undefined` is not a valid child', at);
+        return;
+      }
+      const t = typeof child;
+      if (TEXTUAL_TYPES.includes(t)) {
+        if (format === 'json' && t === 'number' && !Number.isFinite(child)) {
+          err('NON_JSON_VALUE', '`NaN`/`Infinity` text child is not valid JSON', at);
+        }
+        return;
+      }
+      if (NON_NODE_PRIMITIVE_TYPES.includes(t)) {
+        err('BAD_CHILD', `A bare ${t} is not a valid child`, at);
+        return;
+      }
+      if (isDOMNode(child)) {
+        if (!allowDOM) {
+          err('DOM_NODE_NOT_ALLOWED', 'Raw DOM node children are not allowed', at);
+        }
+        return;
+      }
+      if (Array.isArray(child)) {
+        if (child.length === 0) {
+          err('BAD_CHILD', 'A child array must not be empty', at);
+          return;
+        }
+        const head = child[0];
+        if (typeof head !== 'string' && !isPlainObject(head)) {
+          err('BAD_CHILD', 'A child array must be headed by a string or object', at);
+          return;
+        }
+        validateArgSequence(child, 0, at, true);
+        return;
+      }
+      if (isPlainObject(child)) {
+        const obj = /** @type {Record<string, unknown>} */child;
+        if (Object.hasOwn(obj, '#')) {
+          if (Array.isArray(obj['#'])) {
+            validateChildrenContainer(/** @type {unknown[]} */obj['#'], [...at, '#']);
+          } else {
+            err('BAD_CHILD', 'A `#` fragment child must hold an array', [...at, '#']);
+          }
+          return;
+        }
+        const keys = Object.keys(obj);
+        if (keys.length > 0 && keys.every(k => k.startsWith('$'))) {
+          // Templating-dialect placeholder child; policy-checked, opaque value.
+          flagMisplacedOptions(obj, at);
+          for (const k of keys) {
+            if (MAGIC_ATTR_BUILTINS.includes(k)) {
+              err('BAD_CHILD', `\`${k}\` produces a node and must be array-wrapped (\`[{${k}: ...}]\`), not a bare object child`, [...at, k]);
+            } else if (!isReserved(k) && !isOptionKey(k)) {
+              checkExtensibleMagicKey(k, obj[k], [...at, k]);
+            }
+          }
+          return;
+        }
+        err('BAD_CHILD', 'A plain object child must be a `#` fragment or `$`-magic placeholder', at);
+        return;
+      }
+      if (isMapLike(child)) {
+        err('BAD_CHILD', 'A Map/WeakMap is not a valid child', at);
+        return;
+      }
+      err('BAD_CHILD', 'Unrecognized child value', at);
+    });
+  };
+
+  /**
+   * @param {unknown[]} args
+   * @param {number} i
+   * @param {(string|number)[]} path
+   * @returns {number} Number of *additional* args consumed after `i`.
+   */
+  const validateStringArg = (args, i, path) => {
+    const arg = /** @type {string} */args[i];
+    if (arg === '' || !Object.hasOwn(SPECIAL_STRING_ARGC, arg)) {
+      // Fragment marker or an ordinary element name; nothing to consume here.
+      return 0;
+    }
+    const need = SPECIAL_STRING_ARGC[(/** @type {keyof typeof SPECIAL_STRING_ARGC} */arg)];
+    for (let k = 1; k <= need; k++) {
+      const follow = args[i + k];
+      if (isNullish(follow) || typeof follow !== 'string' && typeof follow !== 'number') {
+        err(arg === '?' ? 'BAD_PROCESSING_INSTRUCTION' : 'BAD_SPECIAL_ARG', `\`${arg}\` must be followed by ${need} string argument${need > 1 ? 's' : ''}`, [...path, i]);
+        return 0;
+      }
+    }
+    return need;
+  };
+
+  /**
+   * @param {unknown[]} args
+   * @param {number} start
+   * @param {(string|number)[]} path
+   * @param {boolean} [headIsChild] The object at `start`, if any, is the head
+   *   of a nested child array (so root-only options there are misplaced).
+   * @returns {void}
+   */
+  const validateArgSequence = (args, start, path, headIsChild = false) => {
+    let i = start;
+    while (i < args.length) {
+      const arg = args[i];
+      const at = [...path, i];
+      if (arg === null) {
+        if (i !== args.length - 1) {
+          err('MISPLACED_NULL', '`null` is only allowed as the final argument', at);
+        }
+        i += 1;
+        continue;
+      }
+      if (arg === undefined) {
+        err('BAD_FIRST_ARG', '`undefined` is not a valid Jamilih argument', at);
+        i += 1;
+        continue;
+      }
+      const t = typeof arg;
+      if (t === 'string') {
+        i += 1 + validateStringArg(args, i, path);
+        continue;
+      }
+      if (t !== 'object') {
+        err('UNKNOWN_TYPE', `Unexpected ${t} in argument position`, at);
+        i += 1;
+        continue;
+      }
+      if (isDOMNode(arg)) {
+        if (!allowDOM) {
+          err('DOM_NODE_NOT_ALLOWED', 'Raw DOM nodes are not allowed here', at);
+        }
+      } else if (Array.isArray(arg)) {
+        validateChildrenContainer(arg, at);
+      } else if (isMapLike(arg)) {
+        err('DOM_NODE_NOT_ALLOWED', 'A Map/WeakMap is not a valid Jamilih argument', at);
+      } else if (isPlainObject(arg)) {
+        validateAttributesObject(/** @type {Record<string, unknown>} */arg, at, headIsChild && i === start);
+      } else {
+        err('UNKNOWN_TYPE', 'Unrecognized argument type', at);
+      }
+      i += 1;
+    }
+  };
+
+  /**
+   * @param {Record<string, unknown>} obj
+   * @param {(string|number)[]} path
+   * @returns {void}
+   */
+  const validateOptionsObject = (obj, path) => {
+    if (emptyPolicy) {
+      err('OPTIONS_OBJECT_NOT_ALLOWED', 'A leading options object is not permitted (`allowableOptions: []`)', path);
+      return;
+    }
+    for (const [key, val] of Object.entries(obj)) {
+      if (isReserved(key)) {
+        err('RESERVED_OPTION', `\`${key}\` is reserved by Jamilih and may not be supplied`, [...path, key]);
+        continue;
+      }
+      if (isOptionKey(key)) {
+        if (!allowAny && !allowable.has(key)) {
+          err('DISALLOWED_OPTION', `Option \`${key}\` is not permitted by \`allowableOptions\``, [...path, key]);
+        } else if (key === '$plugins') {
+          validatePluginsOption(val, [...path, key]);
+        } else if (key === '$Map') {
+          validateMapOption(val, [...path, key]);
+        }
+        continue;
+      }
+      if (!key.startsWith('$')) {
+        err('ATTRIBUTES_BEFORE_ELEMENT', 'A genuine attribute may not appear on an object before an element', [...path, key]);
+        continue;
+      }
+      checkExtensibleMagicKey(key, val, [...path, key]);
+    }
+  };
+
+  /**
+   * @param {unknown} struct
+   * @returns {void}
+   */
+  const validateStructure = struct => {
+    if (!Array.isArray(struct)) {
+      err('NOT_ARRAY', 'Jamilih structure must be an array', []);
+      return;
+    }
+    if (struct.length === 0) {
+      err('EMPTY_ARRAY', 'Jamilih structure must not be empty', []);
+      return;
+    }
+    let argStart = 0;
+    const first = struct[0];
+    if (isPlainObject(first) && !isDOMNode(first)) {
+      const firstObj = /** @type {Record<string, unknown>} */first;
+      const keys = Object.keys(firstObj);
+      if (possibleOptions.some(k => keys.includes(k))) {
+        validateOptionsObject(firstObj, ['0']);
+        argStart = 1;
+      } else if (keys.some(k => RESERVED_NAMES.includes(k))) {
+        for (const k of keys) {
+          if (RESERVED_NAMES.includes(k)) {
+            err('RESERVED_OPTION', `\`${k}\` is reserved by Jamilih and may not be supplied`, ['0', k]);
+          }
+        }
+        argStart = 1;
+      } else if (keys.some(k => FIRST_ARG_NODE_KEYS.includes(k))) ; else if (keys.every(k => k.startsWith('$'))) {
+        // Dialect-only / empty object: base Jamilih skips it.
+        argStart = 1;
+      } else {
+        err('ATTRIBUTES_BEFORE_ELEMENT', 'A genuine attribute may not appear on an object before an element', ['0']);
+        argStart = 1;
+      }
+    }
+    validateArgSequence(struct, argStart, []);
+  };
+  try {
+    if (domConflict) {
+      err('OPTION_CONFLICT', '`allowDOM: true` conflicts with `format: "json"`; DOM nodes stay rejected', []);
+    }
+    validateStructure(structure);
+  } catch (e) {
+    /* c8 ignore next 3 -- defensive: only the fail-fast sentinel is caught here */
+    if (e !== FAIL_FAST) {
+      throw e;
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+/**
+ * Boolean predicate wrapper around {@link validateJamilih}.
+ * @param {unknown} structure
+ * @param {ValidateJamilihOptions} [options]
+ * @returns {boolean}
+ */
+const isValidJamilih = (structure, options) => validateJamilih(structure, options).valid;
+
+/* 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: typeof DocumentFragment}} HTMLWindow
+ */
+
+/**
+ * @typedef {unknown} ArbitraryValue
+ */
+
+/**
+ * @typedef {unknown} StoredValue
+ */
+
+/* eslint-disable jsdoc/reject-any-type -- user-defined callback arguments */
 /**
- * @typedef {Window & {DocumentFragment: any}} HTMLWindow
+ * @typedef {any} UserArg
  */
+/**
+ * @typedef {any} ElementExpando
+ */
+/* eslint-enable jsdoc/reject-any-type */
 
 /**
- * @typedef {any} ArbitraryValue
+ * @typedef {HTMLElement & {[key: string]: ElementExpando}} ExpandoHTMLElement
  */
 
 /**
@@ -56,7 +846,7 @@ Other Todos:
  */
 
 /**
- * @type {import('jsdom').DOMWindow|HTMLWindow|undefined}
+ * @type {import('jsdom').DOMWindow|HTMLWindow|typeof globalThis|undefined}
  */
 let win;
 
@@ -66,16 +856,17 @@ if (typeof window !== 'undefined' && window) {
 }
 
 /* c8 ignore next */
-let doc = typeof document !== 'undefined' && document || ((_win = win) === null || _win === void 0 ? void 0 : _win.document);
+let doc = typeof document !== 'undefined' && document || win?.document;
 
 // STATIC PROPERTIES
 
-const possibleOptions = ['$plugins',
-// '$mode', // Todo (SVG/XML)
-// '$state', // Used internally
-'$map' // Add any other options here
-];
-
+/**
+ * Brands `opts` objects that `jml()` created or adopted internally, so a
+ * user-supplied `$state` (which would corrupt root detection) can be told
+ * apart from the internal traversal marker of the same name.
+ * @type {WeakSet<object>}
+ */
+const internalOpts = new WeakSet();
 const NS_HTML = 'http://www.w3.org/1999/xhtml',
   hyphenForCamelCase = /-([a-z])/gu;
 const ATTR_MAP = new Map([['maxlength', 'maxLength'], ['minlength', 'minLength'], ['readonly', 'readOnly']]);
@@ -88,7 +879,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
@@ -106,17 +897,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
@@ -137,19 +928,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
@@ -159,7 +940,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;
@@ -170,9 +951,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}
@@ -183,13 +965,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) {
@@ -204,14 +986,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();
 }
@@ -225,24 +1008,32 @@ 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|JamilihDialectObject|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) {
@@ -255,6 +1046,8 @@ function _getType(item) {
         switch (item.nodeType) {
           case 1:
             return 'element';
+          case 7:
+            return 'processing-instruction';
           case 9:
             return 'document';
           case 11:
@@ -270,23 +1063,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
@@ -294,10 +1095,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;
@@ -320,38 +1121,49 @@ 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);
   };
 }
 
+/**
+ * The `$`-prefixed properties a templating dialect has registered on the
+ * globally augmentable {@link JamilihDialectProperties} interface (see
+ * `src/jamilih-dialect.d.ts`). This is the escape hatch that lets those keys
+ * appear on a leading Jamilih object and as a bare `$`-only child; a `$`-key
+ * that has not been registered (and any non-`$` attribute) stays a type
+ * error. Resolves to `never` until the interface is augmented, so it adds
+ * nothing to a union in the default (strict) case.
+ * @typedef {[keyof JamilihDialectProperties] extends [never] ? never : Partial<JamilihDialectProperties>} JamilihDialectObject
+ */
+
 /**
  * Keep this in sync with `JamilihArray`'s first argument (minus `Document`).
  * @typedef {JamilihDoc|JamilihDoctype|JamilihTextNode|
-*   JamilihAttributeNode|JamilihOptions|ElementName|HTMLElement|
-*   JamilihDocumentFragment
-* } JamilihFirstArg
-*/
+ *   JamilihAttributeNode|JamilihOptions|JamilihDialectObject|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 {
@@ -361,23 +1173,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 {
@@ -387,9 +1199,9 @@ function _appendJMLOrText(node) {
 }
 
 /**
-* @private
-* @static
-*/
+ * @private
+ * @static
+ */
 /*
 function _DOMfromJMLOrString (childNodeJML) {
   if (typeof childNodeJML === 'string') {
@@ -400,9 +1212,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)[]
 
 /**
@@ -419,11 +1231,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
  */
 
 /**
@@ -445,18 +1257,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
  */
 
@@ -468,7 +1283,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
@@ -492,23 +1306,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
  */
 
 /**
@@ -516,11 +1329,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
  */
 
 /**
@@ -528,7 +1357,7 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
- * @typedef {[string, object]|string|{[key: string]: any}} PluginValue
+ * @typedef {[string, object]|string|object} PluginValue
  */
 
 /**
@@ -543,15 +1372,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
  */
 
@@ -573,18 +1402,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
  */
 
@@ -614,6 +1441,11 @@ function _DOMfromJMLOrString (childNodeJML) {
 /**
  * @typedef {{
  *   title?: string,
+ *   xmlDeclaration?: {
+ *     version: string,
+ *     encoding: string,
+ *     standalone: boolean
+ *   },
  *   childNodes?: JamilihChildType[],
  *   $DOCTYPE?: JamilihDocumentType,
  *   head?: JamilihChildren
@@ -652,21 +1484,33 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
+ * `JamilihDialectObject` is deliberately absent: this type is reused for the
+ * attributes position, where every recognized `$`-magic key must keep its
+ * specific value type.
+ * @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|JamilihDialectObject
+ * )[]} JamilihChildren
  */
 
+// Todo: DocumentType, Comment, ProcessingInstruction, Text
+// Todo: JamilihCDATANode, JamilihComment, JamilihProcessingInstruction
 /**
  * This would be clearer with overrides, but using as typedef.
  *
@@ -687,7 +1531,7 @@ function _DOMfromJMLOrString (childNodeJML) {
  * The sixth last optional argument is null, used to indicate an array of elements
  *   should be returned.
  * @typedef {[
- *   JamilihOptions|JamilihFirstArgument,
+ *   JamilihOptions|JamilihFirstArgument|JamilihDialectObject,
  *   (JamilihFirstArgument|
  *     JamilihAttributes|
  *     JamilihChildren|
@@ -712,8 +1556,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
  */
 
@@ -722,10 +1566,17 @@ function _DOMfromJMLOrString (childNodeJML) {
  */
 
 /**
- * @typedef {object} JamilihOptions
- * @property {TraversalState} [$state]
- * @property {JamilihPlugin[]} [$plugins]
- * @property {MapWithRoot|[Map<HTMLElement,any>|WeakMap<HTMLElement,any>, any]} [$map]
+ * The optional leading object. `$state` is internal and `$mode` is reserved
+ * (both throw when author-supplied). A templating dialect's own `$`-keys are
+ * accepted here only after they are registered on the globally augmentable
+ * {@link JamilihDialectProperties} interface (see `src/jamilih-dialect.d.ts`);
+ * an unregistered `$`-key — and any genuine non-`$` attribute — stays a
+ * compile error.
+ * @typedef {{
+ *   $state?: TraversalState,
+ *   $plugins?: JamilihPlugin[],
+ *   $Map?: MapWithRoot|[Map<HTMLElement,UserArg>|WeakMap<HTMLElement,UserArg>, UserArg]
+ * }} JamilihOptions
  */
 
 /**
@@ -737,7 +1588,7 @@ function _DOMfromJMLOrString (childNodeJML) {
  * @returns {Promise<void>|string|null}
  */
 function checkPluginValue(elem, att, attVal, opts, state) {
-  opts.$state = state !== null && state !== void 0 ? state : 'attributeValue';
+  opts.$state = state ?? 'attributeValue';
   if (attVal && typeof attVal === 'object') {
     const matchingPlugin = getMatchingPlugin(opts, Object.keys(attVal)[0]);
     if (matchingPlugin) {
@@ -751,8 +1602,7 @@ function checkPluginValue(elem, att, attVal, opts, state) {
       });
     }
   }
-  return (/** @type {string} */attVal
-  );
+  return /** @type {string} */attVal;
 }
 
 /**
@@ -766,27 +1616,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');
   }
@@ -794,7 +1830,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();
   /**
    *
@@ -808,22 +1844,16 @@ const jml = function jml(...args) {
       throw new Error('No document object');
     }
     for (let [att, attVal] of Object.entries(atts)) {
-      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)) {
+      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;
       }
@@ -861,13 +1891,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}
                  */
@@ -875,7 +1905,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) {
@@ -897,9 +1927,16 @@ const jml = function jml(...args) {
           }
         case '$state':
           {
-            // Handled internally
+            // Handled internally; only valid on a jml-created `opts` object
+            if (!internalOpts.has(atts)) {
+              throw new TypeError(`\`$state\` is set internally by Jamilih and may not be supplied; args: ${JSON.stringify(args)}`);
+            }
             break;
           }
+        case '$mode':
+          {
+            throw new TypeError(`\`$mode\` is reserved for future use and not yet implemented; args: ${JSON.stringify(args)}`);
+          }
         case 'is':
           {
             // Currently only in Chrome
@@ -908,6 +1945,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;
           }
@@ -936,7 +1976,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;
             }
@@ -950,7 +1990,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.
@@ -978,7 +2018,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
@@ -1008,7 +2049,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 = {
@@ -1017,7 +2058,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);
@@ -1026,9 +2067,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;
@@ -1038,7 +2083,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;
@@ -1051,7 +2096,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;
           }
@@ -1059,58 +2104,55 @@ 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) {
-                var _docNode$firstChild;
                 const dt = {
                   $DOCTYPE: jamlihDoc.$DOCTYPE
                 };
                 const doctype = jml(dt);
-                (_docNode$firstChild = docNode.firstChild) === null || _docNode$firstChild === void 0 ? void 0 : _docNode$firstChild.replaceWith(doctype);
+                docNode.firstChild?.replaceWith(doctype);
               }
               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');
+              const head = html?.querySelector('head');
+              const body = 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 === null || head === void 0 ? void 0 : head.append(meta);
+                head?.append(meta);
                 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)
@@ -1124,10 +2166,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;
           }
@@ -1141,17 +2193,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':
@@ -1174,7 +2227,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;
@@ -1185,12 +2242,15 @@ 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)
           }
         // #if IS_REMOVE
         // Don't remove this `if` block (for sake of no-innerHTML build)
+        // Security: this assigns `innerHTML` directly, so its value must be
+        //   trusted or sanitized by the caller. The `jamilih` package also
+        //   publishes a `jml-noinnerh` build with this sink removed, and
+        //   `validateJamilih({allowInnerHTML: false})` rejects the key.
         case 'innerHTML':
           if (!_isNullish(attVal)) {
             // eslint-disable-next-line no-unsanitized/property
@@ -1235,7 +2295,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;
                     }
                   }
                 }
@@ -1259,14 +2320,21 @@ 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;
             }
+            if (att.startsWith('$')) {
+              // Unrecognized `$`-prefixed key: reserved for templating dialects
+              //   layered on Jamilih (and for future Jamilih use); base Jamilih
+              //   ignores it rather than attempting `setAttribute` (which would
+              //   throw on the invalid `$` name character).
+              break;
+            }
             attVal = checkPluginValue(elem, att, /** @type {string} */attVal, opts);
             elem.setAttribute(att, attVal);
             break;
@@ -1289,13 +2357,30 @@ const jml = function jml(...args) {
   let argStart = 0;
   if (_getType(args[0]) === 'object' && Object.keys(args[0]).some(key => possibleOptions.includes(key))) {
     opts = /** @type {JamilihOptions} */args[0];
+    if (!internalOpts.has(opts)) {
+      // `$mode` is reserved for a future SVG/XML mode and does nothing yet;
+      //   `$state` is set internally and would corrupt root detection.
+      if (Object.hasOwn(opts, '$mode')) {
+        throw new TypeError(`\`$mode\` is reserved for future use and not yet implemented; args: ${JSON.stringify(args)}`);
+      }
+      if (Object.hasOwn(opts, '$state')) {
+        throw new TypeError(`\`$state\` is set internally by Jamilih and may not be supplied; args: ${JSON.stringify(args)}`);
+      }
+      // The options object may carry only `$`-prefixed keys (recognized
+      //   options or dialect magic Jamilih ignores); a plain key is a
+      //   misplaced attribute with no element to receive it.
+      if (Object.keys(opts).some(k => !k.startsWith('$'))) {
+        throw new TypeError(`Attributes may not be supplied before an element; args: ${JSON.stringify(args)}`);
+      }
+      internalOpts.add(opts);
+    }
     if (opts.$state === undefined) {
       isRoot = true;
       opts.$state = 'root';
     }
-    if (Array.isArray(opts.$map)) {
-      opts.$map = {
-        root: opts.$map
+    if (Array.isArray(opts.$Map)) {
+      opts.$Map = {
+        root: opts.$Map
       };
     }
     if ('$plugins' in opts) {
@@ -1319,17 +2404,43 @@ const jml = function jml(...args) {
     opts = {
       $state: undefined
     };
+    internalOpts.add(opts);
+    // A user-supplied plain object in first-argument position that is *not*
+    //   an options object (handled above). It may only be a node-producing
+    //   first-arg object (`#`, `$text`, `$document`, `$DOCTYPE`, `$attribute`)
+    //   or a purely `$`-prefixed object (dialect magic Jamilih skips); a
+    //   genuine attribute there has no element to attach to.
+    const leading = /** @type {Record<string, unknown>} */args[0];
+    if (_getType(args[0]) === 'object' && !internalOpts.has(leading)) {
+      if (Object.hasOwn(leading, '$mode')) {
+        throw new TypeError(`\`$mode\` is reserved for future use and not yet implemented; args: ${JSON.stringify(args)}`);
+      }
+      if (Object.hasOwn(leading, '$state')) {
+        throw new TypeError(`\`$state\` is set internally by Jamilih and may not be supplied; args: ${JSON.stringify(args)}`);
+      }
+      const leadingKeys = Object.keys(leading);
+      const firstArgNodeObject = leadingKeys.some(k => {
+        return ['#', '$text', '$document', '$DOCTYPE', '$attribute'].includes(k);
+      });
+      if (!firstArgNodeObject) {
+        if (leadingKeys.every(k => k.startsWith('$'))) {
+          argStart = 1;
+        } else {
+          throw new TypeError(`Attributes may not be supplied before an element; args: ${JSON.stringify(args)}`);
+        }
+      }
+    }
   }
   const argc = args.length;
-  const defaultMap = opts.$map && /** @type {MapWithRoot} */opts.$map.root;
+  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;
@@ -1337,12 +2448,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
@@ -1354,8 +2464,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++) {
@@ -1366,18 +2476,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 '?':
             {
@@ -1387,9 +2495,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(' ');
               }
@@ -1426,12 +2534,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();
@@ -1450,13 +2557,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 */
@@ -1484,25 +2590,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':
@@ -1520,7 +2627,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;
@@ -1531,12 +2638,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
@@ -1548,12 +2662,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';
@@ -1564,6 +2683,15 @@ const jml = function jml(...args) {
                   if (!('nodeType' in childContent)) {
                     newChildContent = /** @type {string} */
                     checkPluginValue(elem, null, childContent, opts, 'children');
+                    const pluginClaimed = newChildContent !== undefined && /** @type {unknown} */newChildContent !== childContent;
+                    const childKeys = Object.keys(childContent);
+                    if (
+                    // No plugin claimed the object, and every key is `$`-prefixed
+                    //   magic Jamilih does not know: treat as a no-op
+                    //   (templating-dialect placeholder).
+                    !pluginClaimed && childKeys.length > 0 && childKeys.every(k => k.startsWith('$'))) {
+                      break;
+                    }
                   }
                   _appendNode(elem, /** @type {string|HTMLElement|DocumentFragment|Comment} */
                   newChildContent || childContent);
@@ -1578,13 +2706,12 @@ const jml = function jml(...args) {
     }
   }
   const ret = nodes[0] || elem;
-  if (isRoot && opts.$map && /** @type {MapWithRoot} */opts.$map.root) {
+  if (isRoot && opts.$Map && /** @type {MapWithRoot} */opts.$Map.root) {
     setMap(true);
   }
 
   // Casting needing unless changing `jml()` signature with overloads
-  return (/** @type {ArbitraryValue} */ret
-  );
+  return /** @type {U extends void ? JamilihReturn : ResolvedElement<U, W & D>} */ret;
 };
 
 /**
@@ -1654,8 +2781,8 @@ class DOMException extends Error {
 
 /**
  * @typedef {JamilihArray|JamilihDoctype|
-*    JamilihCDATANode|JamilihEntityReference|JamilihProcessingInstruction|
-*    JamilihComment|JamilihDocumentFragment} JamilihChildType
+ *    JamilihCDATANode|JamilihEntityReference|JamilihProcessingInstruction|
+ *    JamilihComment|JamilihDocumentFragment} JamilihChildType
  */
 
 /**
@@ -1663,15 +2790,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
@@ -1682,12 +2809,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} */[];
@@ -1701,12 +2827,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;
   }
 
   /**
@@ -1793,8 +2921,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');
     }
 
@@ -1823,7 +2956,6 @@ jml.toJML = function (nde, {
       parentIdx = tmpParentIdx;
       parentIdx++; // Increment index in parent container of this element
     }
-
     switch (type) {
       case 1:
         {
@@ -1897,10 +3029,10 @@ jml.toJML = function (nde, {
         }
       case 4:
         {
-          var _node$nodeValue;
           // CDATA
           const node = /** @type {CDATASection} */nodeOrEntity;
-          if ((_node$nodeValue = node.nodeValue) !== null && _node$nodeValue !== void 0 && _node$nodeValue.includes(']]' + '>')) {
+          // eslint-disable-next-line unicorn/no-useless-concat -- Safer if pasting
+          if (node.nodeValue?.includes(']]' + '>')) {
             invalidStateError('CDATA cannot end with closing ]]>');
           }
           set(['![', node.nodeValue]);
@@ -1983,8 +3115,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);
@@ -2025,36 +3157,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) {
@@ -2064,33 +3197,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}-->`;
       }
@@ -2100,7 +3234,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:
@@ -2114,47 +3248,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;
@@ -2162,104 +3301,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]
+    $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]
+    $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;
@@ -2269,16 +3413,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;
@@ -2291,8 +3435,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) {
@@ -2308,52 +3451,55 @@ 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 => {
-  var _win2;
+const setWindow = wind => {
   win = wind;
-  doc = (_win2 = win) === null || _win2 === void 0 ? void 0 : _win2.document;
+  doc = win?.document;
   if (doc && doc.body) {
     // eslint-disable-next-line prefer-destructuring -- Needed for typing
     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;
+jml.validateJamilih = validateJamilih;
 
 /**
  * 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, isValidJamilih, jml, nbsp, setWindow, toDOM, toDOMString, toHTML, toJML, toJMLString, toXML, toXMLDOMString, validateJamilih };