@design-edito/tools 0.1.60 → 0.1.62

package/chunks/chunk-2G5MFJ66.js

@@ -1,2420 +0,0 @@
-import {
-  nullFunc
-} from "./chunk-QAVYONH6.js";
-import {
-  Types
-} from "./chunk-XEQ2PBT2.js";
-import {
-  array
-} from "./chunk-VDNIN3V5.js";
-import {
-  any
-} from "./chunk-FHLCPVND.js";
-import {
-  SmartTags
-} from "./chunk-UT2J62LH.js";
-import {
-  Serialize
-} from "./chunk-SXRWMH3U.js";
-import {
-  Transformer
-} from "./chunk-BKO7GLC2.js";
-import {
-  Method
-} from "./chunk-RW7VAKJW.js";
-import {
-  insertNode
-} from "./chunk-XA4HVHJ4.js";
-import {
-  isInEnum
-} from "./chunk-E6MSDKON.js";
-import {
-  recordMap
-} from "./chunk-XNF5MLCQ.js";
-import {
-  isRecord
-} from "./chunk-YDIBNEGA.js";
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  replaceAll
-} from "./chunk-ZTDVUXPR.js";
-import {
-  Window
-} from "./chunk-RLJOYG64.js";
-
-// src/agnostic/html/hyper-json/cast/index.ts
-var Cast;
-((Cast2) => {
-  Cast2.toNull = () => null;
-  Cast2.toBoolean = (input) => {
-    const { Text: Text2 } = Window.get();
-    if (input === null) return false;
-    if (typeof input === "boolean") return input;
-    if (typeof input === "number") return input !== 0;
-    if (typeof input === "string" || input instanceof Text2) {
-      const strInput = (0, Cast2.toString)(input);
-      if (strInput.trim() === "") return false;
-      if (strInput.trim().toLowerCase() === "false") return false;
-      return true;
-    }
-    return true;
-  };
-  Cast2.toNumber = (input) => {
-    const { Text: Text2 } = Window.get();
-    if (typeof input === "boolean") return input ? 1 : 0;
-    if (typeof input === "number") return input;
-    if (typeof input === "string") return parseFloat(`${input}`);
-    if (input instanceof Text2) return parseFloat(`${input.textContent}`);
-    return 0;
-  };
-  Cast2.toString = (input) => {
-    if (typeof input === "string") return input;
-    if (typeof input === "number" || typeof input === "boolean" || input === null) return `${input}`;
-    const { Element: Element2, Text: Text2, NodeList } = Window.get();
-    if (input instanceof Element2) return input.outerHTML;
-    if (input instanceof Text2) return input.textContent ?? "";
-    if (input instanceof NodeList) return Array.from(input).map((e) => {
-      if (e instanceof Element2) return e.outerHTML;
-      return e.textContent;
-    }).join("");
-    if (Array.isArray(input)) return input.map(Cast2.toString).join("");
-    if (input instanceof Method) return `[Method:${input.transformer.name}]`;
-    return `{${Object.entries(input).map(([key, val]) => `${key}:"${(0, Cast2.toString)(val)}"`).join(",")}}`;
-  };
-  Cast2.toText = (input) => {
-    const { Text: Text2, document: document2 } = Window.get();
-    if (input instanceof Text2) return input.cloneNode(true);
-    return document2.createTextNode((0, Cast2.toString)(input));
-  };
-  Cast2.toElement = (input) => {
-    const { Element: Element2, Text: Text2, NodeList, document: document2 } = Window.get();
-    if (input instanceof Element2) return input.cloneNode(true);
-    const returned = document2.createElement("div");
-    if (input instanceof Text2) {
-      returned.append(input.cloneNode(true));
-      return returned;
-    }
-    if (input instanceof NodeList) {
-      returned.append(...Array.from(input).map((e) => e.cloneNode(true)));
-      return returned;
-    }
-    if (Array.isArray(input)) return returned;
-    if (isRecord(input)) return returned;
-    returned.innerHTML = `${input}`;
-    return returned;
-  };
-  Cast2.toNodeList = (input) => {
-    const { Element: Element2, Text: Text2, NodeList, document: document2 } = Window.get();
-    const parentDiv = document2.createElement("div");
-    if (input instanceof NodeList) {
-      parentDiv.append(...Array.from(input).map((i) => i.cloneNode(true)));
-      return parentDiv.childNodes;
-    }
-    if (input instanceof Element2 || input instanceof Text2) {
-      parentDiv.append(input.cloneNode(true));
-      return parentDiv.childNodes;
-    }
-    if (Array.isArray(input)) {
-      input.forEach((item) => {
-        if (typeof item === "number" || typeof item === "boolean" || item === null) parentDiv.append(`${item}`);
-        else if (typeof item === "string" || item instanceof Text2 || item instanceof Element2) parentDiv.append(item);
-        else if (item instanceof NodeList) parentDiv.append(...Array.from(item));
-        else if (Array.isArray(item)) parentDiv.append(...Array.from((0, Cast2.toNodeList)(item)));
-        else parentDiv.append((0, Cast2.toString)(item));
-      });
-      return parentDiv.childNodes;
-    }
-    if (isRecord(input)) {
-      parentDiv.append((0, Cast2.toString)(input));
-      return parentDiv.childNodes;
-    }
-    parentDiv.innerHTML = `${input}`;
-    return parentDiv.childNodes;
-  };
-  Cast2.toArray = (input) => {
-    const { NodeList } = Window.get();
-    if (Array.isArray(input)) return [...input];
-    if (input instanceof NodeList) return Array.from(input);
-    return [input];
-  };
-  Cast2.toRecord = (input) => {
-    const isRecord2 = Utils.Tree.TypeChecks.typeCheck(input, "record");
-    if (isRecord2.success) return { ...isRecord2.payload };
-    return {};
-  };
-})(Cast || (Cast = {}));
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/element/index.ts
-var element = SmartTags.makeSmartTag({
-  name: "element",
-  defaultMode: "isolation",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "null", "boolean", "number", "string", "text", "element", "nodelist"),
-  func: (main, args) => {
-    const tagName = Cast.toString(main).trim().toLowerCase();
-    const { document: document2, NodeList } = Window.get();
-    const elt = document2.createElement(tagName);
-    for (const argVal of args) {
-      if (argVal instanceof NodeList) elt.append(...Array.from(argVal));
-      else if (argVal instanceof Element) elt.append(argVal);
-      else elt.append(Cast.toText(argVal));
-    }
-    return Outcome.makeSuccess(elt);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/get/index.ts
-var get = SmartTags.makeSmartTag({
-  name: "get",
-  defaultMode: "isolation",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text"),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main, _args, { sourceTree }) => {
-    const { makeSuccess, makeFailure } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    const strName = Cast.toString(main);
-    const found = sourceTree.getVariable(strName);
-    if (found === void 0) return makeFailure(makeTransformationError(`No variable stored under the name '${strName}'`));
-    return makeSuccess(found);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/global/index.ts
-var global = SmartTags.makeSmartTag({
-  name: "global",
-  defaultMode: "isolation",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (_m, _a, { sourceTree }) => {
-    const globalObject = sourceTree.options.globalObject ?? {};
-    return Outcome.makeSuccess({ ...globalObject });
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/guess/index.ts
-var guess = SmartTags.makeSmartTag({
-  name: "guess",
-  defaultMode: "isolation",
-  isolationInitType: "string",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
-  func: (main, args) => {
-    const { typeCheck } = Utils.Tree.TypeChecks;
-    const { makeSuccess } = Outcome;
-    let coalesced = main;
-    for (const arg of args) coalesced = Utils.coalesceValues(coalesced, 0, arg);
-    const { Text: Text2, Element: Element2, document: document2 } = Window.get();
-    if (typeof coalesced !== "string" && !(coalesced instanceof Text2)) return makeSuccess(coalesced);
-    const strCoalesced = Cast.toString(coalesced);
-    if (strCoalesced.trim().toLowerCase() === "true") return makeSuccess(true);
-    if (strCoalesced.trim().toLowerCase() === "false") return makeSuccess(false);
-    if (strCoalesced.trim().toLowerCase().match(/^\s*-?\s*(\d+(\.\d*)?|\.\d+)\s*$/)) return makeSuccess(parseFloat(strCoalesced));
-    if (strCoalesced.trim().toLowerCase() === "null") return makeSuccess(null);
-    try {
-      const parsed = JSON.parse(strCoalesced);
-      const arrayChecked = typeCheck(parsed, "array");
-      const recordChecked = typeCheck(parsed, "record");
-      if (arrayChecked.success) return makeSuccess(arrayChecked.payload);
-      if (recordChecked.success) return makeSuccess(recordChecked.payload);
-    } catch (err) {
-    }
-    const div = document2.createElement("div");
-    div.innerHTML = strCoalesced;
-    const divChildren = div.childNodes;
-    if (divChildren.length === 0) return makeSuccess(coalesced);
-    const validDivChildren = Cast.toNodeList(Array.from(divChildren).filter((e) => {
-      if (e instanceof Element2) return true;
-      if (e instanceof Text2) return true;
-      return false;
-    }));
-    if (validDivChildren.length > 1) return makeSuccess(validDivChildren);
-    const validDivFirstchild = validDivChildren.item(0);
-    if (validDivChildren.length === 1 && validDivFirstchild instanceof Element2) return makeSuccess(validDivFirstchild);
-    return makeSuccess(coalesced);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/nodelist/index.ts
-var nodelist = SmartTags.makeSmartTag({
-  name: "nodelist",
-  defaultMode: "isolation",
-  isolationInitType: "nodelist",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
-  func: (main, args) => {
-    const { document: document2 } = Window.get();
-    const returnedParent = document2.createDocumentFragment();
-    returnedParent.append(
-      ...Array.from(Cast.toNodeList(main)),
-      ...Array.from(Cast.toNodeList(args))
-    );
-    const returned = returnedParent.childNodes;
-    return Outcome.makeSuccess(returned);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/number/index.ts
-var number = SmartTags.makeSmartTag({
-  name: "number",
-  defaultMode: "isolation",
-  isolationInitType: "number",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "null", "boolean", "number", "string", "text"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "null", "boolean", "number", "string", "text"),
-  func: (main, args) => {
-    const all = [main, ...args];
-    const reduced = all.reduce((reduced2, curr) => {
-      return reduced2 + Cast.toNumber(curr);
-    }, 0);
-    return Outcome.makeSuccess(reduced);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/record/index.ts
-var record = SmartTags.makeSmartTag({
-  name: "record",
-  defaultMode: "isolation",
-  isolationInitType: "record",
-  mainValueCheck: (i) => Utils.Tree.TypeChecks.typeCheck(i, "record"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "record"),
-  func: (main, args) => Outcome.makeSuccess(args.reduce((reduced, current) => ({
-    ...reduced,
-    ...current
-  }), main))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/ref/index.ts
-var func = (main, _args, { sourceTree }) => {
-  const { makeFailure, makeSuccess } = Outcome;
-  const { makeTransformationError } = Utils.SmartTags;
-  const strMain = Cast.toString(main);
-  const resolveFrom = strMain.startsWith("/") ? sourceTree.root : sourceTree;
-  const splitted = strMain.split("/").filter((e) => e.trim() !== "").map((e) => {
-    const looksLikeNumber = e.match(/^\d+$/igm);
-    if (looksLikeNumber === null) return e;
-    const parsed = parseInt(e);
-    if (Number.isNaN(parsed)) return e;
-    return parsed;
-  });
-  const resolved = resolveFrom.resolve(splitted);
-  if (resolved === void 0) return makeFailure(makeTransformationError(`No value was found at path: ${strMain}`));
-  if (resolved === sourceTree) return makeFailure(makeTransformationError("A ref node cannot reference itself."));
-  if (resolved.parents.includes(sourceTree)) return makeFailure(makeTransformationError("A ref node cannot reference one of its parents."));
-  if (sourceTree.parents.includes(resolved)) return makeFailure(makeTransformationError("A ref node cannot reference one of its children."));
-  const evaluated = resolved.evaluate();
-  const { getType } = Utils.Tree.TypeChecks;
-  if (getType(evaluated) === "transformer") {
-    const transformer = evaluated;
-    return makeSuccess(transformer.toMethod());
-  }
-  return makeSuccess(evaluated);
-};
-var ref = SmartTags.makeSmartTag({
-  name: "ref",
-  defaultMode: "isolation",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text"),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/string/index.ts
-var string = SmartTags.makeSmartTag({
-  name: "string",
-  defaultMode: "isolation",
-  isolationInitType: "string",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "null", "boolean", "number", "string", "text", "element", "nodelist"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "null", "boolean", "number", "string", "text", "element", "nodelist"),
-  func: (main, args) => {
-    const all = [main, ...args];
-    const reduced = all.reduce((reduced2, curr) => {
-      return `${reduced2}${Cast.toString(curr)}`;
-    }, "");
-    return Outcome.makeSuccess(reduced);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/text/index.ts
-var text = SmartTags.makeSmartTag({
-  name: "text",
-  defaultMode: "isolation",
-  isolationInitType: "text",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "null", "boolean", "number", "string", "text", "element", "nodelist"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "null", "boolean", "number", "string", "text", "element", "nodelist"),
-  func: (main, args) => {
-    const all = [main, ...args];
-    const reduced = all.reduce((reduced2, curr) => {
-      return Cast.toText(`${reduced2}${Cast.toText(curr)}`);
-    }, Cast.toText(""));
-    return Outcome.makeSuccess(reduced);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/add/index.ts
-var add = SmartTags.makeSmartTag({
-  name: "add",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "number", "string", "text"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "number", "string", "text"),
-  func: (main, args) => {
-    const numMain = Cast.toNumber(main);
-    const numArgs = args.map(Cast.toNumber);
-    return Outcome.makeSuccess(numArgs.reduce((reduced, arg) => reduced + arg, numMain));
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/addclass/index.ts
-var addclass = SmartTags.makeSmartTag({
-  name: "addclass",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
-  func: (main, args) => {
-    main.classList.add(...args.map((arg) => Cast.toString(arg)));
-    return Outcome.makeSuccess(main);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/and/index.ts
-var and = SmartTags.makeSmartTag({
-  name: "and",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
-  func: (main, args) => {
-    const all = [main, ...args];
-    const returned = all.every(Cast.toBoolean);
-    return Outcome.makeSuccess(returned);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/append/index.ts
-var append = SmartTags.makeSmartTag({
-  name: "append",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text", "nodelist", "element", "array"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text", "nodelist", "element", "array"),
-  func: (main, args) => {
-    const { makeSuccess } = Outcome;
-    const { Text: Text2, Element: Element2, NodeList, document: document2 } = Window.get();
-    if (Array.isArray(main)) return makeSuccess([...main, ...args]);
-    if (main instanceof Element2) {
-      main.append(...Array.from(Cast.toNodeList(args)));
-      return makeSuccess(main);
-    }
-    if (main instanceof NodeList) {
-      const frag = document2.createDocumentFragment();
-      frag.append(
-        ...Array.from(main),
-        ...Array.from(Cast.toNodeList(args))
-      );
-      return makeSuccess(frag.childNodes);
-    }
-    if (main instanceof Text2) {
-      const reducedString = args.reduce((reduced, arg) => {
-        return `${reduced}${Cast.toString(arg)}`;
-      }, Cast.toString(main));
-      return makeSuccess(Cast.toText(reducedString));
-    }
-    return makeSuccess(args.reduce((reduced, arg) => {
-      return `${reduced}${Cast.toString(arg)}`;
-    }, main));
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/at/index.ts
-var at = SmartTags.makeSmartTag({
-  name: "at",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text", "array", "nodelist"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const { getType, typeCheckMany } = Utils.Tree.TypeChecks;
-    if (a.length === 0) return makeFailure(makeArgsValueError("number | string | text", "undefined", 0));
-    if (a.length > 1) return makeFailure(makeArgsValueError("undefined", getType(a[1]) ?? "undefined", 1));
-    const checked = typeCheckMany(a, "number", "string", "text");
-    if (checked.success) return makeSuccess(a);
-    return checked;
-  },
-  func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    const pos = args[0];
-    const numPos = Cast.toNumber(pos);
-    let found;
-    const { NodeList } = Window.get();
-    if (typeof main === "string" || Array.isArray(main) || main instanceof NodeList) {
-      found = main[numPos];
-    } else {
-      const strMain = Cast.toString(main);
-      found = strMain[numPos];
-    }
-    if (found === void 0) return makeFailure(makeTransformationError({
-      message: "Property does not exist"
-      // [WIP] maybe more details here ?
-    }));
-    return makeSuccess(found);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/call/index.ts
-var call = SmartTags.makeSmartTag({
-  name: "call",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => {
-    const { makeFailure } = Outcome;
-    const { typeCheck, typeCheckMany, getType } = Utils.Tree.TypeChecks;
-    const { makeMainValueError } = Utils.SmartTags;
-    const isMethodCheck = typeCheck(m, "method");
-    if (isMethodCheck.success) return isMethodCheck;
-    if (!Array.isArray(m)) return makeFailure({
-      expected: "method[]",
-      found: getType(m) ?? "undefined"
-    });
-    const isMethodsArrayCheck = typeCheckMany(m, "method");
-    if (isMethodsArrayCheck.success) return isMethodsArrayCheck;
-    return makeFailure(makeMainValueError("method | method[]", getType(m) ?? "undefined"));
-  },
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "array"),
-  func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    const mainArr = Array.isArray(main) ? main : [main];
-    let reduced = args;
-    for (const method of mainArr) {
-      const { transformer } = method;
-      const applied = transformer.apply(reduced);
-      if (applied.success) {
-        reduced = applied.payload;
-      }
-      return makeFailure(makeTransformationError({
-        message: "Subtransformation failure.",
-        onTransformed: reduced,
-        transformerAt: mainArr.indexOf(method),
-        transformerName: transformer.name,
-        transformerOutput: applied
-      }));
-    }
-    return makeSuccess(reduced);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/clone/index.ts
-var clone = SmartTags.makeSmartTag({
-  name: "clone",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(Utils.clone(main))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/deleteproperties/index.ts
-var deleteproperties = SmartTags.makeSmartTag({
-  name: "deleteproperties",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
-  func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    let returned = Utils.clone(main);
-    for (const arg of args) {
-      const strArg = Cast.toString(arg);
-      try {
-        returned = deepDeleteProperty(returned, strArg);
-      } catch (err) {
-        return makeFailure(makeTransformationError(`Cannot access ${strArg} from input record`));
-      }
-    }
-    return makeSuccess(returned);
-  }
-});
-function deepDeleteProperty(record2, pathString) {
-  const cloned = Utils.clone(record2);
-  const pathChunks = pathString.split(".");
-  let currentRecord = cloned;
-  pathChunks.forEach((chunk, pos) => {
-    const isLast = pos === pathChunks.length - 1;
-    if (isLast) delete currentRecord[chunk];
-    else {
-      const found = currentRecord[chunk];
-      if (isRecord(found)) currentRecord = found;
-      else throw "not a record";
-    }
-  });
-  return cloned;
-}
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/equals/index.ts
-var equals = SmartTags.makeSmartTag({
-  name: "equals",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => {
-    const [first, ...others] = a;
-    if (first === void 0) return Outcome.makeFailure(Utils.SmartTags.makeArgsValueError(
-      "value",
-      "undefined",
-      0
-    ));
-    const returned = [first, ...others];
-    return Outcome.makeSuccess(returned);
-  },
-  func: (main, args) => {
-    const { Text: Text2 } = Window.get();
-    const normalizedMain = main instanceof Text2 ? Cast.toString(main) : main;
-    const normalizedArgs = args.map((a) => a instanceof Text2 ? Cast.toString(a) : a);
-    return Outcome.makeSuccess(normalizedArgs.every((arg) => arg === normalizedMain));
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/getattribute/index.ts
-var getattribute = SmartTags.makeSmartTag({
-  name: "getattribute",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { typeCheckMany, getType } = Utils.Tree.TypeChecks;
-    const { makeArgsValueError } = Utils.SmartTags;
-    if (a.length === 0) return makeFailure(makeArgsValueError("string | Text", "undefined", 0));
-    if (a.length > 1) return makeFailure(makeArgsValueError("undefined", getType(a[2]) ?? "undefined", 1));
-    const checked = typeCheckMany(a, "string", "text");
-    if (checked.success) return makeSuccess(checked.payload);
-    return checked;
-  },
-  func: (main, args) => {
-    const name = Cast.toString(args[0]);
-    const found = main.getAttribute(name);
-    return Outcome.makeSuccess(found);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/getproperties/index.ts
-var getproperties = SmartTags.makeSmartTag({
-  name: "getproperties",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
-  func: (main, args) => {
-    const reduced = args.reduce((reduced2, curr) => {
-      const key = Cast.toString(curr);
-      const val = main[key];
-      if (val === void 0) return { ...reduced2 };
-      return { ...reduced2, [key]: val };
-    }, {});
-    return Outcome.makeSuccess(reduced);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/getproperty/index.ts
-var getproperty = SmartTags.makeSmartTag({
-  name: "getproperty",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const { getType, typeCheckMany } = Utils.Tree.TypeChecks;
-    if (a.length === 0) return makeFailure(makeArgsValueError("string | Text", "undefined", 0));
-    if (a.length !== 1) return makeFailure(makeArgsValueError("undefined", getType(a.at(1)) ?? "undefined", 1));
-    const checked = typeCheckMany(a, "string", "text");
-    if (!checked.success) return checked;
-    return makeSuccess(checked.payload);
-  },
-  func: (main, args) => {
-    const { getType } = Utils.Tree.TypeChecks;
-    const { makeTransformationError } = Utils.SmartTags;
-    const { makeFailure, makeSuccess } = Outcome;
-    const [propName] = args;
-    const strPropName = Cast.toString(propName);
-    try {
-      const found = deepGetProperty(main, strPropName);
-      const foundType = getType(found);
-      if (foundType !== "transformer") return makeSuccess(found);
-      return makeFailure(makeTransformationError(`Forbidden access to key: '${strPropName}'`));
-    } catch (err) {
-      return makeFailure(makeTransformationError(`Impossible to access ${strPropName}`));
-    }
-  }
-});
-function deepGetProperty(record2, pathString) {
-  const pathChunks = pathString.split(".").map((e) => e.trim()).filter((e) => e !== "");
-  let currentRecord = record2;
-  let returned = currentRecord;
-  pathChunks.forEach((chunk, pos) => {
-    const isLast = pos === pathChunks.length - 1;
-    if (isLast) {
-      const val = currentRecord[chunk];
-      if (val === void 0) throw "PROP_UNDEFINED";
-      returned = val;
-    } else {
-      const found = currentRecord[chunk];
-      if (isRecord(found)) currentRecord = found;
-      else throw "NOT_A_RECORD";
-    }
-  });
-  return returned;
-}
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/if/index.ts
-var ifFunc = SmartTags.makeSmartTag({
-  name: "if",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "boolean"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    if (a.length > 2) return makeFailure(makeArgsValueError("value", "undefined", a.length));
-    if (a.length < 2) return makeFailure(makeArgsValueError("undefined", "value", 2));
-    return makeSuccess(a);
-  },
-  func: (main, args) => {
-    const [then, otherwise] = args;
-    return Outcome.makeSuccess(main ? then : otherwise);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/initialize/index.ts
-var initialize = SmartTags.makeSmartTag({
-  name: "initialize",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { getType, typeCheck } = Utils.Tree.TypeChecks;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const first = a[0];
-    if (first === void 0) return makeFailure(makeArgsValueError("string | text", "undefined", 0));
-    if (a.length > 1) return makeFailure(makeArgsValueError("undefined", getType(a[1]) ?? "undefined", 1));
-    const firstChecked = typeCheck(first, "string", "text");
-    if (!firstChecked.success) return makeFailure(makeArgsValueError(firstChecked.error.expected, firstChecked.error.found, 0));
-    return makeSuccess(a);
-  },
-  func: (_main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    const { getInitialValueFromTypeName } = Utils.Tree;
-    const { isValueTypeName } = Utils.Tree.TypeChecks;
-    const firstArg = args[0];
-    const strFirstArg = Cast.toString(firstArg).trim().toLowerCase();
-    const isValueType = isValueTypeName(strFirstArg);
-    if (!isValueType || strFirstArg === "transformer" || strFirstArg === "method") return makeFailure(makeTransformationError(`${strFirstArg} is not a valid type`));
-    const initialized = getInitialValueFromTypeName(strFirstArg);
-    return makeSuccess(initialized);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/join/index.ts
-var join = SmartTags.makeSmartTag({
-  name: "join",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "array", "nodelist"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
-  func: (main, args) => {
-    const { makeSuccess } = Outcome;
-    const joiner = Cast.toString(args);
-    if (Array.isArray(main)) return makeSuccess(main.map(Cast.toString).join(joiner));
-    return makeSuccess(Array.from(main).map(Cast.toString).join(joiner));
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/length/index.ts
-var length = SmartTags.makeSmartTag({
-  name: "length",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "nodelist"),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => {
-    const { makeSuccess } = Outcome;
-    const { Text: Text2, NodeList, Element: Element2 } = Window.get();
-    if (typeof main === "string" || main instanceof NodeList || main instanceof Text2 || Array.isArray(main)) return makeSuccess(main.length);
-    if (main instanceof Element2) return makeSuccess(main.childNodes.length);
-    return makeSuccess(Object.keys(main).length);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/map/index.ts
-var map = SmartTags.makeSmartTag({
-  name: "map",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "array"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "method"),
-  func: (main, args) => {
-    const { makeTransformationError } = Utils.SmartTags;
-    let mapped = [];
-    for (const val of main) {
-      let reduced = val;
-      for (const arg of args) {
-        const { transformer } = arg;
-        const applied = transformer.apply(reduced);
-        if (!applied.success) return Outcome.makeFailure(makeTransformationError({
-          message: "Subtransformation failure.",
-          onTransformed: reduced,
-          transformerAt: args.indexOf(arg),
-          transformerName: transformer.name,
-          transformerInput: reduced,
-          transformerOutput: applied
-        }));
-        reduced = applied.payload;
-      }
-      mapped.push(reduced);
-    }
-    return Outcome.makeSuccess(mapped);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/negate/index.ts
-var negate = SmartTags.makeSmartTag({
-  name: "negate",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "boolean"),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(!main)
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/notrailing/index.ts
-var notrailing = SmartTags.makeSmartTag({
-  name: "notrailing",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text"),
-  argsValueCheck: (a) => {
-    const { makeSuccess, makeFailure } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const { getType, typeCheck } = Utils.Tree.TypeChecks;
-    if (a.length === 0) return makeSuccess([]);
-    if (a.length > 1) return makeFailure(makeArgsValueError("undefined", getType(a[1]) ?? "undefined", 1));
-    const [first] = a;
-    const firstChecked = typeCheck(first, "string", "text");
-    if (!firstChecked.success) return makeFailure(makeArgsValueError(
-      firstChecked.error.expected,
-      firstChecked.error.found,
-      0
-    ));
-    return makeSuccess([firstChecked.payload]);
-  },
-  func: (main, args) => {
-    const strMain = Cast.toString(main);
-    const firstArg = args[0];
-    const strFirstArg = Cast.toString(firstArg ?? "/");
-    let strOutput = strMain;
-    while (strOutput.endsWith(strFirstArg)) strOutput = strOutput.slice(0, -1);
-    if (typeof main === "string") return Outcome.makeSuccess(strOutput);
-    return Outcome.makeSuccess(Cast.toText(strOutput));
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/or/index.ts
-var or = SmartTags.makeSmartTag({
-  name: "or",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
-  func: (main, args) => {
-    const all = [main, ...args];
-    const returned = all.some(Cast.toBoolean);
-    return Outcome.makeSuccess(returned);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/pickrandom/index.ts
-var pickrandom = SmartTags.makeSmartTag({
-  name: "pickrandom",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "array"),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => {
-    const { makeSuccess, makeFailure } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    const pos = Math.floor(Math.random() * main.length);
-    const found = main[pos];
-    if (found === void 0) return makeFailure(makeTransformationError("Cannot pick inside empty array"));
-    return makeSuccess(found);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/print/index.ts
-var print = SmartTags.makeSmartTag({
-  name: "print",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => {
-    const { getType } = Utils.Tree.TypeChecks;
-    const { makeSuccess, makeFailure } = Outcome;
-    const { makeMainValueError } = Utils.SmartTags;
-    return getType(m) === "transformer" ? makeFailure(makeMainValueError("Exclude<value, transformer>", "transformer")) : makeSuccess(m);
-  },
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
-  func: (main, args, details) => {
-    console.group("print");
-    console.log("Main:", main);
-    console.log("Args:", ...args);
-    console.log("Tree:", details.sourceTree);
-    console.groupEnd();
-    return Outcome.makeSuccess(main);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/populate/index.ts
-var populate = SmartTags.makeSmartTag({
-  name: "populate",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
-  argsValueCheck: (a) => {
-    const [first, ...others] = a;
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const { typeCheck, typeCheckMany, getType } = Utils.Tree.TypeChecks;
-    const firstChecked = typeCheck(first, "string", "text", "nodelist", "element");
-    if (!firstChecked.success) return makeFailure(makeArgsValueError(
-      firstChecked.error.expected,
-      firstChecked.error.found,
-      0
-    ));
-    const othersChecked = typeCheckMany(others, "array");
-    if (!othersChecked.success) return makeFailure(makeArgsValueError(
-      othersChecked.error.expected,
-      othersChecked.error.found,
-      othersChecked.error.position + 1
-    ));
-    for (const [argPos, arg] of Object.entries(othersChecked.payload)) {
-      const argPosNum = parseInt(argPos);
-      const [first2, second] = arg;
-      const firstChecked2 = typeCheck(first2, "string", "text");
-      const secondChecked = typeCheck(second, "string", "text");
-      if (!firstChecked2.success || !secondChecked.success) return makeFailure(makeArgsValueError(
-        "[string | Text, string | Text]",
-        `[${getType(first2)}, ${getType(second)}]`,
-        argPosNum + 1
-      ));
-    }
-    return makeSuccess(a);
-  },
-  func: (main, args) => {
-    const { makeSuccess, makeFailure } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    const record2 = main;
-    const [template, ...actions] = args;
-    let returnedStr = Cast.toString(template);
-    for (const [propName, toReplace] of actions) {
-      try {
-        const value = deepGetProperty(record2, Cast.toString(propName));
-        const replaced = replaceAll(returnedStr, Cast.toString(toReplace), Cast.toString(value));
-        returnedStr = replaced;
-      } catch (err) {
-        return makeFailure(makeTransformationError({
-          message: "Something went wrong",
-          subTransformerError: err
-        }));
-      }
-    }
-    const { Text: Text2, NodeList } = Window.get();
-    if (typeof template === "string") return makeSuccess(returnedStr);
-    if (template instanceof Text2) return makeSuccess(Cast.toText(returnedStr));
-    if (template instanceof NodeList) return makeSuccess(Cast.toNodeList(returnedStr));
-    return makeSuccess(Cast.toElement(returnedStr));
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/push/index.ts
-var push = SmartTags.makeSmartTag({
-  name: "push",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "array"),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
-  func: (main, args) => Outcome.makeSuccess([...main, ...args])
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/pusheach/index.ts
-var pusheach = SmartTags.makeSmartTag({
-  name: "pusheach",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "array"),
-  argsValueCheck: (a) => {
-    const { makeSuccess, makeFailure } = Outcome;
-    const { typeCheck } = Utils.Tree.TypeChecks;
-    const { makeArgsValueError } = Utils.SmartTags;
-    for (const [argPos, arg] of Object.entries(a)) {
-      const numPos = parseInt(argPos);
-      const checked = typeCheck(arg, "array");
-      if (!checked.success) return makeFailure(makeArgsValueError(
-        checked.error.expected,
-        checked.error.found,
-        numPos
-      ));
-    }
-    return makeSuccess(a);
-  },
-  func: (main, args) => {
-    const returned = [...main];
-    for (const arg of args) {
-      returned.push(...arg);
-    }
-    return Outcome.makeSuccess(returned);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/recordtoarray/index.ts
-var recordtoarray = SmartTags.makeSmartTag({
-  name: "recordtoarray",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(Object.values(main))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/removeattribute/index.ts
-var removeattribute = SmartTags.makeSmartTag({
-  name: "removeattribute",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => {
-    const { typeCheck, typeCheckMany } = Utils.Tree.TypeChecks;
-    if (Array.isArray(m)) return typeCheckMany(m, "element");
-    return typeCheck(m, "element");
-  },
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { typeCheckMany, getType } = Utils.Tree.TypeChecks;
-    const { makeArgsValueError } = Utils.SmartTags;
-    if (a.length === 0) return makeFailure(makeArgsValueError("string | Text", "undefined", 0));
-    if (a.length > 1) return makeFailure(makeArgsValueError("undefined", getType(a[2]) ?? "undefined", 1));
-    const checked = typeCheckMany(a, "string", "text");
-    if (checked.success) return makeSuccess(checked.payload);
-    return checked;
-  },
-  func: (main, args) => {
-    const { makeSuccess } = Outcome;
-    const mainArr = Array.isArray(main) ? main : [main];
-    const mainArrCloned = mainArr.map((e) => Utils.clone(e));
-    const name = Cast.toString(args[0]);
-    mainArrCloned.forEach((e) => e.removeAttribute(name));
-    if (Array.isArray(main)) return makeSuccess(mainArrCloned);
-    return makeSuccess(mainArrCloned[0]);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/removeclass/index.ts
-var removeclass = SmartTags.makeSmartTag({
-  name: "removeclass",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
-  func: (main, args) => {
-    main.classList.remove(...args.map((arg) => Cast.toString(arg)));
-    return Outcome.makeSuccess(main);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/renameproperty/index.ts
-var renameproperty = SmartTags.makeSmartTag({
-  name: "renameproperty",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { typeCheck, typeCheckMany } = Utils.Tree.TypeChecks;
-    const checked = typeCheckMany(a, "string", "text");
-    if (!checked.success) return checked;
-    const [first, second] = a;
-    const firstChecked = typeCheck(first, "string", "text");
-    if (!firstChecked.success) return makeFailure(Utils.SmartTags.makeArgsValueError(
-      firstChecked.error.expected,
-      firstChecked.error.found,
-      0
-    ));
-    const secondChecked = typeCheck(second, "string", "text");
-    if (!secondChecked.success) return makeFailure(Utils.SmartTags.makeArgsValueError(
-      secondChecked.error.expected,
-      secondChecked.error.found,
-      0
-    ));
-    return makeSuccess([firstChecked.payload, secondChecked.payload]);
-  },
-  func: (main, args) => {
-    const [oldKey, newKey] = args.map(Cast.toString);
-    const returned = {};
-    Object.entries(main).forEach(([key, value]) => {
-      const targetKey = key === oldKey ? newKey : key;
-      returned[targetKey] = value;
-    });
-    return Outcome.makeSuccess(returned);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/replace/index.ts
-var replace = SmartTags.makeSmartTag({
-  name: "replace",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text", "nodelist", "element"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { getType, typeCheckMany } = Utils.Tree.TypeChecks;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const expectedStr = "string | Text | NodeListOf<Element | Text> | Element";
-    if (a.length === 0) return makeFailure(makeArgsValueError(expectedStr, "undefined", 0));
-    if (a.length === 1) return makeFailure(makeArgsValueError(expectedStr, "undefined", 1));
-    if (a.length > 2) return makeFailure(makeArgsValueError("undefined", getType(a.at(2)) ?? "undefined", 3));
-    const checked = typeCheckMany(a, "string", "text", "nodelist", "element");
-    if (!checked.success) return checked;
-    return makeSuccess(checked.payload);
-  },
-  func: (main, args) => {
-    const [toReplace, replacer] = args;
-    const strMain = Cast.toString(main);
-    const strToReplace = Cast.toString(toReplace);
-    const strReplacer = Cast.toString(replacer);
-    const strReplaced = replaceAll(strMain, strToReplace, strReplacer);
-    let returned;
-    if (typeof main === "string") {
-      returned = strReplaced;
-    } else if (main instanceof Text) {
-      returned = Cast.toText(strReplaced);
-    } else if (main instanceof Element) {
-      returned = Cast.toElement(strReplaced);
-    } else {
-      returned = Cast.toNodeList(strReplaced);
-    }
-    return Outcome.makeSuccess(returned);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/select/index.ts
-var select = SmartTags.makeSmartTag({
-  name: "select",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "nodelist", "element"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
-  func: (main, args) => {
-    const selectedFragment = document.createDocumentFragment();
-    if (main instanceof Window.get().Element) {
-      for (const arg of args) {
-        const selector = Cast.toString(arg);
-        const found = main.querySelectorAll(selector);
-        selectedFragment.append(...Array.from(found));
-      }
-    } else {
-      const divWrapper = Window.get().document.createElement("div");
-      divWrapper.append(...Array.from(main));
-      for (const arg of args) {
-        const selector = Cast.toString(arg);
-        const found = divWrapper.querySelectorAll(selector);
-        selectedFragment.append(...Array.from(found));
-      }
-    }
-    const selected = selectedFragment.childNodes;
-    return Outcome.makeSuccess(selected);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/set/index.ts
-var set = SmartTags.makeSmartTag({
-  name: "set",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const { getType, typeCheck } = Utils.Tree.TypeChecks;
-    const first = a[0];
-    if (first === void 0) return makeFailure(makeArgsValueError("string | text", "undefined", 0));
-    if (a.length > 2) return makeFailure(makeArgsValueError("undefined", getType(a[2]) ?? "undefined", 2));
-    const firstChecked = typeCheck(first, "string", "text");
-    if (!firstChecked.success) return firstChecked;
-    else return makeSuccess(a);
-  },
-  func: (main, args, { sourceTree }) => {
-    const [first, second] = args;
-    const strFirst = Cast.toString(first);
-    sourceTree.setVariable(strFirst, second === void 0 ? main : second);
-    return Outcome.makeSuccess(main);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/setattribute/index.ts
-var setattribute = SmartTags.makeSmartTag({
-  name: "setattribute",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => {
-    const { typeCheck, typeCheckMany } = Utils.Tree.TypeChecks;
-    if (Array.isArray(m)) return typeCheckMany(m, "element");
-    return typeCheck(m, "element");
-  },
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { typeCheckMany, getType } = Utils.Tree.TypeChecks;
-    const { makeArgsValueError } = Utils.SmartTags;
-    if (a.length === 0) return makeFailure(makeArgsValueError("string | Text", "undefined", 0));
-    if (a.length > 2) return makeFailure(makeArgsValueError("undefined", getType(a[2]) ?? "undefined", 2));
-    const checked = typeCheckMany(a, "string", "text");
-    if (checked.success) return makeSuccess(checked.payload);
-    return checked;
-  },
-  func: (main, args) => {
-    const mainArr = Array.isArray(main) ? main : [main];
-    const mainArrCloned = mainArr.map((e) => Utils.clone(e));
-    const argsStr = args.map((e) => Cast.toString(e));
-    const [name, value = ""] = argsStr;
-    mainArrCloned.forEach((e) => e.setAttribute(name, value));
-    if (Array.isArray(main)) return Outcome.makeSuccess(mainArrCloned);
-    return Outcome.makeSuccess(mainArrCloned[0]);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/setproperties/index.ts
-var setproperties = SmartTags.makeSmartTag({
-  name: "setproperties",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const { getType, typeCheck } = Utils.Tree.TypeChecks;
-    if (a.length === 0) return makeFailure(makeArgsValueError("record", "undefined", 0));
-    if (a.length > 1) return makeFailure(makeArgsValueError("undefined", getType(a.at(1)) ?? "undefined", 1));
-    const [first] = a;
-    const firstChecked = typeCheck(first, "record");
-    if (!firstChecked.success) return makeFailure(makeArgsValueError(firstChecked.error.expected, firstChecked.error.found, 0));
-    return makeSuccess([firstChecked.payload]);
-  },
-  func: (main, args) => Outcome.makeSuccess({ ...main, ...args[0] })
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/setproperty/index.ts
-var setproperty = SmartTags.makeSmartTag({
-  name: "setproperty",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const { getType, typeCheck } = Utils.Tree.TypeChecks;
-    if (a.length === 0) return makeFailure(makeArgsValueError("string | Text", "undefined", 0));
-    if (a.length === 1) return makeFailure(makeArgsValueError("value", "undefined", 1));
-    if (a.length !== 2) return makeFailure(makeArgsValueError("undefined", getType(a.at(2)) ?? "undefined", 2));
-    const [first, second] = a;
-    const firstChecked = typeCheck(first, "string", "text");
-    if (!firstChecked.success) return makeFailure(makeArgsValueError(firstChecked.error.expected, firstChecked.error.found, 0));
-    return makeSuccess([firstChecked.payload, second]);
-  },
-  func: (main, args) => {
-    const [key, val] = args;
-    const { makeSuccess, makeFailure } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    try {
-      const withPropertySet = deepSetProperty(
-        Utils.clone(main),
-        Cast.toString(key),
-        val
-      );
-      return makeSuccess(withPropertySet);
-    } catch (err) {
-      return makeFailure(makeTransformationError(`Impossible to access property :${key}`));
-    }
-  }
-});
-function deepSetProperty(record2, pathString, value) {
-  const pathChunks = pathString.split(".");
-  const clone2 = Utils.clone(record2);
-  let currentRecord = clone2;
-  pathChunks.forEach((chunk, pos) => {
-    const isLast = pos === pathChunks.length - 1;
-    if (isLast) {
-      currentRecord[chunk] = value;
-    } else {
-      const found = currentRecord[chunk];
-      if (isRecord(found)) currentRecord = found;
-      else throw "NOT_A_RECORD";
-    }
-  });
-  return clone2;
-}
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/sorton/index.ts
-var sorton = SmartTags.makeSmartTag({
-  name: "sorton",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => {
-    const { makeMainValueError } = Utils.SmartTags;
-    const { getType } = Utils.Tree.TypeChecks;
-    const { makeFailure, makeSuccess } = Outcome;
-    if (!Array.isArray(m)) return makeFailure(makeMainValueError("array<record>", getType(m) ?? "undefined"));
-    for (const [itemPos, itemVal] of Object.entries(m)) {
-      if (isRecord(itemVal)) continue;
-      return makeFailure(makeMainValueError("record", getType(itemVal), `At position ${parseInt(itemPos)} in main value`));
-    }
-    return makeSuccess(m);
-  },
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeArgsValueError } = Utils.SmartTags;
-    const { getType, typeCheckMany } = Utils.Tree.TypeChecks;
-    if (a.length === 0) return makeFailure(makeArgsValueError("[string | text]", "[]", 0));
-    if (a.length > 1) return makeFailure(makeArgsValueError("undefined", getType(a[1]) ?? "undefined", 2));
-    const checked = typeCheckMany(a, "string", "text");
-    if (checked.success) return makeSuccess(checked.payload);
-    return checked;
-  },
-  func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const strPropName = Cast.toString(args[0]);
-    const { getType } = Utils.Tree.TypeChecks;
-    const { makeTransformationError } = Utils.SmartTags;
-    const map2 = main.map((record2) => {
-      const prop = record2[strPropName];
-      const type = getType(prop);
-      return { record: record2, prop, type };
-    });
-    const firstItem = map2[0];
-    if (firstItem === void 0) return makeSuccess([]);
-    const firstItemType = firstItem.type;
-    if (firstItemType === void 0) return makeFailure(makeTransformationError({
-      message: "Invalid property type",
-      onItem: 0,
-      found: firstItemType
-    }));
-    for (const [daytumPos, daytumVal] of Object.entries(map2)) {
-      if (daytumVal.type !== firstItemType) return makeFailure(makeTransformationError({
-        message: "Invalid property type",
-        onItem: parseInt(daytumPos),
-        expected: firstItemType,
-        found: daytumVal.type
-      }));
-    }
-    const sorted = main.sort((a, b) => {
-      const { Text: Text2, NodeList } = Window.get();
-      const aProp = a[strPropName];
-      const bProp = b[strPropName];
-      if (aProp === null) return 0;
-      if (typeof aProp === "boolean") {
-        if (aProp === bProp) return 0;
-        if (aProp) return 1;
-        return -1;
-      }
-      if (typeof aProp === "string") return aProp.localeCompare(Cast.toString(bProp));
-      if (aProp instanceof Text2) return Cast.toString(aProp).localeCompare(Cast.toString(bProp));
-      if (typeof aProp === "number") return aProp - Cast.toNumber(bProp);
-      if (Array.isArray(aProp)) return aProp.length - Cast.toArray(bProp).length;
-      if (aProp instanceof NodeList) return aProp.length - Cast.toNodeList(bProp).length;
-      return 0;
-    });
-    return makeSuccess(sorted);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/split/index.ts
-var split = SmartTags.makeSmartTag({
-  name: "split",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
-  func: (main, args) => {
-    let strReturnedArr = [Cast.toString(main)];
-    for (const arg of args) {
-      strReturnedArr = strReturnedArr.map((e) => e.split(Cast.toString(arg))).flat();
-    }
-    if (typeof main === "string") return Outcome.makeSuccess(strReturnedArr);
-    return Outcome.makeSuccess(strReturnedArr.map(Cast.toText));
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/toarray/index.ts
-var toarray = SmartTags.makeSmartTag({
-  name: "toarray",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(Cast.toArray(main))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/toboolean/index.ts
-var toboolean = SmartTags.makeSmartTag({
-  name: "toboolean",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toBoolean(m))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/toelement/index.ts
-var toelement = SmartTags.makeSmartTag({
-  name: "toelement",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toElement(m))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/toggleclass/index.ts
-var toggleclass = SmartTags.makeSmartTag({
-  name: "toggleclass",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
-  func: (main, args) => {
-    for (const arg of args) main.classList.toggle(Cast.toString(arg));
-    return Outcome.makeSuccess(main);
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/tonodelist/index.ts
-var tonodelist = SmartTags.makeSmartTag({
-  name: "tonodelist",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toNodeList(m))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/tonull/index.ts
-var tonull = SmartTags.makeSmartTag({
-  name: "tonull",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: () => Outcome.makeSuccess(null)
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/tonumber/index.ts
-var tonumber = SmartTags.makeSmartTag({
-  name: "tonumber",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toNumber(m))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/torecord/index.ts
-var torecord = SmartTags.makeSmartTag({
-  name: "torecord",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(Cast.toRecord(main))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/toref/index.ts
-var toref = SmartTags.makeSmartTag({
-  name: "toref",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main, args, details) => func(Cast.toString(main), args, details)
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/tostring/index.ts
-var tostring = SmartTags.makeSmartTag({
-  name: "tostring",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toString(m))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/totext/index.ts
-var totext = SmartTags.makeSmartTag({
-  name: "totext",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toText(m))
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/transformselected/index.ts
-var transformselected = SmartTags.makeSmartTag({
-  name: "transformselected",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
-  argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { typeCheck, typeCheckMany } = Utils.Tree.TypeChecks;
-    const [first, ...others] = a;
-    const firstChecked = typeCheck(first, "string", "text");
-    if (!firstChecked.success) return makeFailure({ ...firstChecked.error, position: 0 });
-    const othersChecked = typeCheckMany(others, "method");
-    if (!othersChecked.success) return makeFailure({
-      ...othersChecked.error,
-      position: othersChecked.error.position + 1
-    });
-    const returned = [firstChecked.payload, ...othersChecked.payload];
-    return makeSuccess(returned);
-  },
-  func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
-    const { makeTransformationError } = Utils.SmartTags;
-    const { typeCheck } = Utils.Tree.TypeChecks;
-    const mainClone = Cast.toElement(main);
-    const [selector, ...methods] = args;
-    const selectedElements = Array.from(mainClone.querySelectorAll(Cast.toString(selector)));
-    const transformationMap = new Map(selectedElements.map((s) => [s, Utils.clone(s)]));
-    for (const method of methods) {
-      for (const [selected, value] of Array.from(transformationMap)) {
-        const transformer = method.transformer;
-        const applied = transformer.apply(value);
-        if (!applied.success) return makeFailure(makeTransformationError({
-          // [WIP] maybe a custom makeSubTransformationError ?
-          message: "Subtransformation failure.",
-          onSelected: selected,
-          onTransformed: value,
-          transformerAt: methods.indexOf(method),
-          transformerName: transformer.name,
-          transformerOutput: applied
-        }));
-        transformationMap.set(selected, applied.payload);
-      }
-    }
-    for (const [selected, transformed] of Array.from(transformationMap)) {
-      const transformedChecked = typeCheck(transformed, "element", "nodelist", "text", "string", "number", "boolean", "null");
-      if (!transformedChecked.success) return makeFailure(makeTransformationError({
-        // [WIP] maybe a custom makeBadTransformationOutputError ?
-        message: "Bad transformation output",
-        onSelected: selected,
-        onTransformed: transformed,
-        details: { ...transformedChecked.error }
-      }));
-      const { Element: Element2, NodeList, Text: Text2 } = Window.get();
-      const replacer = transformedChecked.payload;
-      if (replacer instanceof Element2 || replacer instanceof Text2) {
-        insertNode(replacer, "after", selected);
-        selected.remove();
-      } else if (replacer instanceof NodeList) {
-        replacer.forEach((item) => insertNode(item, "before", selected));
-        selected.remove();
-      } else {
-        insertNode(Cast.toText(replacer), "after", selected);
-        selected.remove();
-      }
-      transformedChecked.payload;
-    }
-    if (main instanceof Element) return makeSuccess(mainClone);
-    const safeChildren = Array.from(mainClone.childNodes).filter((e) => e instanceof Element || e instanceof Text);
-    return main instanceof Element ? makeSuccess(mainClone) : makeSuccess(Cast.toNodeList(safeChildren));
-  }
-});
-
-// src/agnostic/html/hyper-json/smart-tags/coalesced/trim/index.ts
-var trim = SmartTags.makeSmartTag({
-  name: "trim",
-  defaultMode: "coalescion",
-  isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text"),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => {
-    return typeof main === "string" ? Outcome.makeSuccess(main.trim()) : Outcome.makeSuccess(Cast.toText(`${main}`.trim()));
-  }
-});
-
-// src/agnostic/html/hyper-json/tree/index.ts
-var SMART_TAGS_REGISTER = new Map([
-  any,
-  array,
-  boolean,
-  element,
-  get,
-  global,
-  guess,
-  nodelist,
-  nullFunc,
-  number,
-  record,
-  ref,
-  string,
-  text,
-  add,
-  addclass,
-  and,
-  append,
-  at,
-  call,
-  clone,
-  deleteproperties,
-  equals,
-  getattribute,
-  getproperties,
-  getproperty,
-  ifFunc,
-  initialize,
-  join,
-  length,
-  map,
-  negate,
-  notrailing,
-  or,
-  pickrandom,
-  print,
-  populate,
-  push,
-  pusheach,
-  recordtoarray,
-  removeattribute,
-  removeclass,
-  renameproperty,
-  replace,
-  select,
-  set,
-  setattribute,
-  setproperties,
-  setproperty,
-  sorton,
-  split,
-  toarray,
-  toboolean,
-  toelement,
-  toggleclass,
-  tonodelist,
-  tonull,
-  tonumber,
-  toref,
-  torecord,
-  tostring,
-  totext,
-  transformselected,
-  trim
-]);
-var Tree;
-((_Tree) => {
-  class Tree2 {
-    node;
-    options;
-    parent;
-    parents;
-    pathFromParent;
-    root;
-    isRoot;
-    path;
-    pathString;
-    attributes;
-    isMethod;
-    tagName;
-    smartTagName;
-    smartTagData;
-    mode;
-    isPreserved;
-    isLiteral;
-    isolationInitType;
-    subtrees = /* @__PURE__ */ new Map();
-    static actionAttribute = "_action";
-    static keyAttribute = "_key";
-    static methodAttribute = "_method";
-    static initAttribute = "_init";
-    static modeAttribute = "_mode";
-    static preserveAttribute = "_preserve";
-    static literalAttribute = "_literal";
-    static defaultOptions = {
-      globalObject: {},
-      logger: null,
-      loggerThread: "hyperjson"
-    };
-    static from(nodes, options) {
-      const merged = Utils.Tree.mergeNodes(nodes);
-      return new Tree2(merged, null, null, options);
-    }
-    constructor(node, parent, pathFromParent, options) {
-      const { Element: Element2, Text: Text2 } = Window.get();
-      this.resolve = this.resolve.bind(this);
-      this.setVariable = this.setVariable.bind(this);
-      this.getVariable = this.getVariable.bind(this);
-      this.performSafetyChecks = this.performSafetyChecks.bind(this);
-      this.computeValue = this.computeValue.bind(this);
-      this.enforceEvaluation = this.enforceEvaluation.bind(this);
-      this.getCachedValue = this.getCachedValue.bind(this);
-      this.setCachedValue = this.setCachedValue.bind(this);
-      this.getPerfCounters = this.getPerfCounters.bind(this);
-      this.printPerfCounters = this.printPerfCounters.bind(this);
-      this.evaluate = this.evaluate.bind(this);
-      this.node = node;
-      this.options = options ?? Tree2.defaultOptions;
-      if (parent !== null && pathFromParent !== null) {
-        this.isRoot = false;
-        this.parent = parent;
-        this.parents = [parent, ...parent.parents];
-        this.pathFromParent = pathFromParent;
-        this.root = this.parent.root;
-      } else {
-        this.isRoot = true;
-        this.parent = null;
-        this.parents = [];
-        this.pathFromParent = null;
-        this.root = this;
-      }
-      this.path = this.isRoot ? [] : [...this.parent.path, this.pathFromParent];
-      this.pathString = `/${this.path.join("/")}`;
-      this.attributes = node instanceof Element2 ? Array.from(node.attributes) : null;
-      if (node instanceof Element2) {
-        const rawTagName = node.tagName.trim().toLowerCase();
-        const hasTrailingUnderscore = rawTagName.endsWith("_");
-        const hasMethodAttribute = this.attributes?.find((attr) => attr.name === Tree2.methodAttribute) !== void 0;
-        const isMethod = hasTrailingUnderscore || hasMethodAttribute;
-        this.isMethod = isMethod;
-        this.tagName = rawTagName;
-        this.smartTagName = hasTrailingUnderscore ? rawTagName.replace(/_+$/g, "") : rawTagName;
-      } else {
-        this.isMethod = false;
-        this.tagName = null;
-        this.smartTagName = null;
-      }
-      if (this.smartTagName === null) {
-        this.smartTagData = null;
-      } else {
-        this.smartTagData = SMART_TAGS_REGISTER.get(this.smartTagName) ?? null;
-      }
-      const hasModeAttribute = this.attributes?.find((attr) => {
-        return attr.name === Tree2.modeAttribute && Utils.Tree.TypeChecks.isTreeMode(attr.value);
-      });
-      this.mode = hasModeAttribute?.value ?? this.smartTagData?.defaultMode ?? "isolation";
-      const hasLiteralAttribute = this.attributes?.find((attr) => attr.name === Tree2.literalAttribute) !== void 0;
-      this.isLiteral = hasLiteralAttribute;
-      const hasPreservedAttribute = this.attributes?.find((attr) => attr.name === Tree2.preserveAttribute) !== void 0;
-      this.isPreserved = hasPreservedAttribute;
-      const hasInitAttribute = this.attributes?.find((attr) => {
-        if (attr.name !== Tree2.initAttribute) return false;
-        const val = attr.value.trim().toLowerCase();
-        if (!Utils.Tree.TypeChecks.isValueTypeName(val)) return false;
-        if (val === "transformer") return false;
-        if (val === "method") return false;
-        return true;
-      });
-      if (this.mode === "coalescion") {
-        this.isolationInitType = "array";
-      } else {
-        const initAttributeValue = hasInitAttribute?.value;
-        if (initAttributeValue !== void 0) {
-          this.isolationInitType = initAttributeValue;
-        } else if (this.smartTagData !== null) {
-          this.isolationInitType = this.smartTagData?.isolationInitType ?? "array";
-        } else {
-          this.isolationInitType = "nodelist";
-        }
-      }
-      const { childNodes } = node;
-      let positionnedChildrenCount = 0;
-      const mutableSubtrees = /* @__PURE__ */ new Map();
-      Array.from(childNodes).filter((child, _, childNodes2) => {
-        if (child instanceof Element2) return true;
-        if (!(child instanceof Text2)) return false;
-        const hasContent = (child.textContent ?? "").trim() !== "";
-        if (hasContent) return true;
-        if (childNodes2.some((n) => n instanceof Element2)) return false;
-        return true;
-      }).forEach((childNode) => {
-        if (childNode instanceof Text2) {
-          const hasContent = (childNode.textContent ?? "").trim() !== "";
-          if (hasContent) {
-            childNode.textContent = childNode.textContent?.trim() ?? "";
-          }
-          mutableSubtrees.set(
-            positionnedChildrenCount,
-            new Tree2(childNode, this, positionnedChildrenCount, this.options)
-          );
-          positionnedChildrenCount += 1;
-        } else {
-          const propertyName = childNode.getAttribute(Tree2.keyAttribute);
-          if (propertyName === null) {
-            mutableSubtrees.set(
-              positionnedChildrenCount,
-              new Tree2(childNode, this, positionnedChildrenCount, this.options)
-            );
-            positionnedChildrenCount += 1;
-          } else {
-            mutableSubtrees.set(
-              propertyName,
-              new Tree2(childNode, this, propertyName, this.options)
-            );
-          }
-        }
-      });
-      this.subtrees = mutableSubtrees;
-    }
-    resolve = function(path) {
-      let currentTree = this;
-      for (const chunk of path) {
-        if (chunk === ".") continue;
-        if (chunk === "..") {
-          currentTree = currentTree.parent ?? this;
-          continue;
-        }
-        const { subtrees } = currentTree;
-        const foundSubtree = subtrees.get(chunk);
-        if (foundSubtree === void 0) return void 0;
-        currentTree = foundSubtree;
-      }
-      return currentTree;
-    };
-    // [WIP] variablesStore is actually only used on root Tree
-    variablesStore = /* @__PURE__ */ new Map();
-    setVariable(name, value) {
-      const { root, isRoot, variablesStore } = this;
-      if (!isRoot) return root.setVariable(name, value);
-      variablesStore.set(name, Serialize.serialize(value));
-    }
-    getVariable(name) {
-      const { root } = this;
-      const found = root.variablesStore.get(name);
-      if (found === void 0) return void 0;
-      const deserialized = Serialize.deserialize(found);
-      if (deserialized instanceof Transformer) throw "A transformer should not be stored as a variable, this happening denotes an implementation error.";
-      return deserialized;
-    }
-    performSafetyChecks() {
-      const { node, smartTagData, isMethod, mode, isRoot } = this;
-      const { Text: Text2 } = Window.get();
-      if (node instanceof Text2 || smartTagData === null) {
-        if (isMethod) throw new Error(`A Text or HTMLElement node cannot be used as a method @ ${this.pathString}`);
-        if (mode === "coalescion") throw new Error(`A Text or HTMLElement node cannot be used in coalescion mode @ ${this.pathString}`);
-      }
-      if (isRoot && mode === "coalescion") throw new Error(`The root node cannot be used in coalescion mode @ ${this.pathString}`);
-    }
-    computeValue() {
-      const {
-        isolationInitType,
-        subtrees,
-        node,
-        smartTagData,
-        isMethod,
-        mode,
-        performSafetyChecks,
-        options
-      } = this;
-      performSafetyChecks();
-      const { Text: Text2 } = Window.get();
-      if (node instanceof Text2) return node.cloneNode(true);
-      const initialInnerValue = Utils.Tree.getInitialValueFromTypeName(isolationInitType);
-      const innerValue = Array.from(subtrees).reduce((reduced, [subpath, subtree]) => {
-        const subvalue = subtree.evaluate();
-        const coalesced = Utils.coalesceValues(reduced, subpath, subvalue);
-        return coalesced;
-      }, initialInnerValue);
-      if (smartTagData === null) {
-        const nodelist2 = Cast.toNodeList(innerValue);
-        const clone2 = node.cloneNode();
-        clone2.append(...Array.from(nodelist2));
-        return clone2;
-      }
-      const { transformer, method } = smartTagData.generator(innerValue, mode, this);
-      if (isMethod) return method;
-      if (mode === "isolation") {
-        const applied = transformer.apply(null);
-        if (applied.success) return applied.payload;
-        throw {
-          error: "Transformation error",
-          details: applied.error,
-          transformer: transformer.name,
-          path: this.pathString
-        };
-      }
-      return transformer;
-    }
-    enforceEvaluation() {
-      const { isPreserved, node, computeValue, isLiteral, attributes } = this;
-      const { Element: Element2 } = Window.get();
-      if (isPreserved) return Utils.clone(node);
-      const evaluated = computeValue();
-      if (!isLiteral) return evaluated;
-      const asLiteral = Utils.toHyperJson(evaluated);
-      if (asLiteral instanceof Element2) attributes?.forEach(({ name, value }) => asLiteral.setAttribute(name, value));
-      return asLiteral;
-    }
-    cachedValue = void 0;
-    getCachedValue() {
-      const { cachedValue } = this;
-      if (cachedValue === void 0) return void 0;
-      const deserialized = Serialize.deserialize(cachedValue);
-      return deserialized;
-    }
-    setCachedValue(evaluated) {
-      this.cachedValue = Serialize.serialize(evaluated);
-    }
-    perfCounters = {
-      computed: 0,
-      computeTime: 0,
-      computeTimeAvg: 0,
-      cached: 0,
-      cacheTime: 0,
-      cacheTimeAvg: 0,
-      totalTime: 0
-    };
-    // [WIP] bind this
-    getPerfCounters() {
-      const { subtrees, cachedValue, tagName, perfCounters } = this;
-      const subCounters = [];
-      subCounters.push([this.pathString, {
-        ...perfCounters,
-        tagName: tagName ?? "#text",
-        evaluated: cachedValue
-      }]);
-      subtrees.forEach((subtree) => subCounters.push(...subtree.getPerfCounters()));
-      return subCounters;
-    }
-    // [WIP] bind this
-    printPerfCounters() {
-      const perfCounters = this.getPerfCounters().sort((a, b) => {
-        const aCalls = a[1].computed + a[1].cached;
-        const bCalls = b[1].computed + b[1].cached;
-        return bCalls - aCalls;
-      }).map((e) => ({
-        tagName: e[1].tagName,
-        path: e[0],
-        totalMs: e[1].totalTime,
-        computeMs: e[1].computeTime,
-        cacheMs: e[1].cacheTime,
-        ops: `${e[1].computed}/${e[1].cached}`,
-        evaluated: e[1].evaluated
-      }));
-      console.table(perfCounters);
-    }
-    evaluate() {
-      const start = Date.now();
-      const {
-        getCachedValue,
-        setCachedValue,
-        enforceEvaluation,
-        perfCounters
-      } = this;
-      const cached = getCachedValue();
-      if (cached !== void 0) {
-        const end2 = Date.now();
-        const time2 = end2 - start;
-        perfCounters.cached++;
-        perfCounters.cacheTime += time2;
-        perfCounters.cacheTimeAvg = perfCounters.cacheTime / perfCounters.cached;
-        perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
-        return cached;
-      }
-      const evaluated = enforceEvaluation();
-      setCachedValue(evaluated);
-      const end = Date.now();
-      const time = end - start;
-      perfCounters.computed++;
-      perfCounters.computeTime += time;
-      perfCounters.computeTimeAvg = perfCounters.computeTime / perfCounters.computed;
-      perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
-      return evaluated;
-    }
-  }
-  _Tree.Tree = Tree2;
-})(Tree || (Tree = {}));
-
-// src/agnostic/html/hyper-json/utils/index.ts
-var Utils;
-((Utils2) => {
-  function clone2(value) {
-    const { Element: Element2, Text: Text2, NodeList, document: document2 } = Window.get();
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) return value;
-    if (value instanceof Text2) return value.cloneNode(true);
-    if (value instanceof NodeList) {
-      const frag = document2.createDocumentFragment();
-      const nodes = Array.from(value).map((e) => e.cloneNode(true));
-      frag.append(...nodes);
-      return frag.childNodes;
-    }
-    if (value instanceof Element2) return value.cloneNode(true);
-    if (value instanceof Transformer) return Transformer.clone(value);
-    if (value instanceof Method) return Method.clone(value);
-    if (Array.isArray(value)) return [...value.map(clone2)];
-    if (isRecord(value)) return recordMap(value, (prop) => clone2(prop));
-    throw new Error(`Cannot clone value: ${value}`);
-  }
-  Utils2.clone = clone2;
-  function coalesceValues(currentValue, subpath, subvalue) {
-    const { Element: Element2, Text: Text2, NodeList, document: document2 } = Window.get();
-    let actualSubvalue = subvalue;
-    if (actualSubvalue instanceof Transformer) {
-      const transformer = actualSubvalue;
-      const transformationResult = transformer.apply(currentValue);
-      if (!transformationResult.success) {
-        console.warn({ ...transformationResult.error });
-        return currentValue;
-      }
-      const evaluated = transformationResult.payload;
-      if (transformer.mode === "isolation") {
-        actualSubvalue = evaluated;
-      } else {
-        return evaluated;
-      }
-    }
-    if (Array.isArray(currentValue)) return [...currentValue, actualSubvalue];
-    if (currentValue === null) return actualSubvalue;
-    if (typeof currentValue === "boolean") return actualSubvalue;
-    if (typeof currentValue === "number") return actualSubvalue;
-    if (currentValue instanceof Transformer) return actualSubvalue;
-    if (currentValue instanceof Method) return actualSubvalue;
-    if (typeof currentValue === "string") {
-      if (actualSubvalue === null || typeof actualSubvalue === "boolean" || typeof actualSubvalue === "number" || typeof actualSubvalue === "string") return `${currentValue}${actualSubvalue}`;
-      if (actualSubvalue instanceof Text2) return `${currentValue}${actualSubvalue.textContent}`;
-      if (actualSubvalue instanceof Element2) {
-        const frag = document2.createDocumentFragment();
-        frag.append(currentValue, Utils2.clone(actualSubvalue));
-        return frag.childNodes;
-      }
-      if (actualSubvalue instanceof NodeList) {
-        const frag = document2.createDocumentFragment();
-        frag.append(currentValue, ...Array.from(Utils2.clone(actualSubvalue)));
-        return frag.childNodes;
-      }
-      return actualSubvalue;
-    }
-    if (currentValue instanceof Text2) {
-      if (actualSubvalue === null || typeof actualSubvalue === "boolean" || typeof actualSubvalue === "number" || typeof actualSubvalue === "string") return document2.createTextNode(`${currentValue.textContent}${actualSubvalue}`);
-      if (actualSubvalue instanceof Text2) return document2.createTextNode(`${currentValue.textContent}${actualSubvalue.textContent}`);
-      if (actualSubvalue instanceof Element2) {
-        const frag = document2.createDocumentFragment();
-        frag.append(clone2(currentValue), clone2(actualSubvalue));
-        return frag.childNodes;
-      }
-      if (actualSubvalue instanceof NodeList) {
-        const frag = document2.createDocumentFragment();
-        frag.append(clone2(currentValue), ...Array.from(clone2(actualSubvalue)));
-        return frag.childNodes;
-      }
-      return actualSubvalue;
-    }
-    if (currentValue instanceof Element2) {
-      if (actualSubvalue === null || typeof actualSubvalue === "boolean" || typeof actualSubvalue === "number" || typeof actualSubvalue === "string") {
-        const frag = document2.createDocumentFragment();
-        frag.append(clone2(currentValue), `${actualSubvalue}`);
-        return frag.childNodes;
-      }
-      if (actualSubvalue instanceof Text2 || actualSubvalue instanceof Element2) {
-        const frag = document2.createDocumentFragment();
-        frag.append(clone2(currentValue), clone2(actualSubvalue));
-        return frag.childNodes;
-      }
-      if (actualSubvalue instanceof NodeList) {
-        const frag = document2.createDocumentFragment();
-        frag.append(clone2(currentValue), ...Array.from(clone2(actualSubvalue)));
-        return frag.childNodes;
-      }
-      return actualSubvalue;
-    }
-    if (currentValue instanceof NodeList) {
-      if (actualSubvalue === null || typeof actualSubvalue === "boolean" || typeof actualSubvalue === "number" || typeof actualSubvalue === "string") {
-        const frag = document2.createDocumentFragment();
-        frag.append(...Array.from(clone2(currentValue)), `${actualSubvalue}`);
-        return frag.childNodes;
-      }
-      if (actualSubvalue instanceof Text2 || actualSubvalue instanceof Element2) {
-        const frag = document2.createDocumentFragment();
-        frag.append(...Array.from(clone2(currentValue)), clone2(actualSubvalue));
-        return frag.childNodes;
-      }
-      if (actualSubvalue instanceof NodeList) {
-        const frag = document2.createDocumentFragment();
-        frag.append(...Array.from(clone2(currentValue)), ...Array.from(clone2(actualSubvalue)));
-        return frag.childNodes;
-      }
-      return actualSubvalue;
-    }
-    if (typeof subpath === "number") return { ...currentValue };
-    return {
-      ...currentValue,
-      [subpath]: actualSubvalue
-    };
-  }
-  Utils2.coalesceValues = coalesceValues;
-  Utils2.toHyperJson = (value) => {
-    const { document: document2, Element: Element2, Text: Text2, NodeList } = Window.get();
-    if (value instanceof Text2) {
-      const elt2 = document2.createElement("text");
-      elt2.innerHTML = value.textContent ?? "";
-      return elt2;
-    }
-    if (value instanceof Element2) return value.cloneNode(true);
-    if (value instanceof NodeList) {
-      const elt2 = document2.createElement("nodelist");
-      elt2.append(...Array.from(value).map((e) => e.cloneNode(true)));
-      return elt2;
-    }
-    if (value === null) return document2.createElement("null");
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      const elt2 = document2.createElement(typeof value);
-      elt2.innerHTML = `${value}`;
-      return elt2;
-    }
-    if (Array.isArray(value)) {
-      const elt2 = document2.createElement("array");
-      elt2.append(...value.map((e) => (0, Utils2.toHyperJson)(e)));
-      return elt2;
-    }
-    if (value instanceof Transformer) return clone2(value.sourceTree.node);
-    if (value instanceof Method) return clone2(value.transformer.sourceTree.node);
-    const elt = document2.createElement("record");
-    Object.entries(value).forEach(([key, val]) => {
-      const hjVal = (0, Utils2.toHyperJson)(val);
-      if (hjVal instanceof Text2) return;
-      hjVal.setAttribute(Tree.Tree.keyAttribute, key);
-      elt.append(hjVal);
-    });
-    return elt;
-  };
-  let Transformations;
-  ((Transformations2) => {
-    let TypeChecks;
-    ((TypeChecks2) => {
-      function getType(value) {
-        if (singleTypeCheck(value, "null")) return "null";
-        if (singleTypeCheck(value, "boolean")) return "boolean";
-        if (singleTypeCheck(value, "number")) return "number";
-        if (singleTypeCheck(value, "string")) return "string";
-        if (singleTypeCheck(value, "element")) return "element";
-        if (singleTypeCheck(value, "text")) return "text";
-        if (singleTypeCheck(value, "nodelist")) return "nodelist";
-        if (singleTypeCheck(value, "method")) return "method";
-        if (singleTypeCheck(value, "array")) return "array";
-        if (singleTypeCheck(value, "record")) return "record";
-        return void 0;
-      }
-      TypeChecks2.getType = getType;
-      TypeChecks2.everyTypeName = [
-        "null",
-        "boolean",
-        "number",
-        "string",
-        "text",
-        "nodelist",
-        "element",
-        "method",
-        "array",
-        "record"
-      ];
-      function singleTypeCheck(value, type) {
-        const { Element: Element2, Text: Text2, NodeList } = Window.get();
-        if (type === "null" && value === null) return true;
-        if (type === "boolean" && typeof value === "boolean") return true;
-        if (type === "number" && typeof value === "number") return true;
-        if (type === "string" && typeof value === "string") return true;
-        if (type === "element" && value instanceof Element2) return true;
-        if (type === "text" && value instanceof Text2) return true;
-        if (type === "nodelist" && value instanceof NodeList) {
-          const children = Array.from(value);
-          return children.every((child) => child instanceof Element2 || child instanceof Text2);
-        }
-        if (type === "method" && value instanceof Method) return true;
-        if (type === "array" && Array.isArray(value)) {
-          const childrenOk = value.every((child) => typeCheck(child, ...TypeChecks2.everyTypeName).success);
-          return childrenOk;
-        }
-        if (type === "record" && isRecord(value)) {
-          const childrenOk = Object.values(value).every((child) => typeCheck(child, ...TypeChecks2.everyTypeName).success);
-          return childrenOk;
-        }
-        return false;
-      }
-      TypeChecks2.singleTypeCheck = singleTypeCheck;
-      function typeCheck(value, ...types) {
-        const matchesOneType = types.some((type) => singleTypeCheck(value, type));
-        if (matchesOneType) return Outcome.makeSuccess(value);
-        return Outcome.makeFailure({
-          expected: types.join(" | "),
-          found: getType(value) ?? "undefined"
-        });
-      }
-      TypeChecks2.typeCheck = typeCheck;
-      function typeCheckMany(values, ...types) {
-        for (const [pos, val] of Object.entries(values)) {
-          const checked = typeCheck(val, ...types);
-          if (checked.success) continue;
-          return Outcome.makeFailure({ position: parseInt(pos), ...checked.error });
-        }
-        return Outcome.makeSuccess(values);
-      }
-      TypeChecks2.typeCheckMany = typeCheckMany;
-    })(TypeChecks = Transformations2.TypeChecks || (Transformations2.TypeChecks = {}));
-  })(Transformations = Utils2.Transformations || (Utils2.Transformations = {}));
-  let Tree2;
-  ((Tree3) => {
-    function mergeNodes(nodes) {
-      const clones = nodes.map((node) => node.cloneNode(true));
-      const allChildren = [];
-      clones.forEach((node) => {
-        const actionAttribute = node.getAttribute(Tree.Tree.actionAttribute)?.trim().toLowerCase();
-        const actionAttrIsValid = isInEnum(Types.Tree.Merge.Action, actionAttribute ?? "");
-        const nodeAction = actionAttrIsValid ? actionAttribute : Types.Tree.Merge.Action.APPEND;
-        const { Element: Element2, Text: Text2 } = Window.get();
-        const children = Array.from(node.childNodes).filter((child) => child instanceof Text2 || child instanceof Element2).map((child) => {
-          if (child instanceof Text2) return { node: child, key: void 0 };
-          const childKey = child.getAttribute(Tree.Tree.keyAttribute) ?? void 0;
-          return { node: child, key: childKey };
-        });
-        if (nodeAction === Types.Tree.Merge.Action.REPLACE) {
-          allChildren.splice(0, allChildren.length);
-        } else if (nodeAction === Types.Tree.Merge.Action.PREPEND) {
-          allChildren.unshift(...children);
-        } else {
-          allChildren.push(...children);
-        }
-      });
-      const mergedChildren = [];
-      allChildren.forEach((childData) => {
-        if (childData.key === void 0) mergedChildren.push(childData);
-        else {
-          const childKey = childData.key;
-          const alreadyMerged = mergedChildren.find((dat) => dat.key === childKey);
-          if (alreadyMerged) return;
-          const toMerge = allChildren.filter((dat) => dat.key === childKey);
-          if (toMerge.length === 0) return;
-          const merged = mergeNodes(toMerge.map((dat) => dat.node));
-          mergedChildren.push({ node: merged, key: childKey });
-        }
-      });
-      const allAttributes = clones.reduce((attributes, node) => [
-        ...Array.from(attributes),
-        ...Array.from(node.attributes)
-      ], []);
-      const outWrapper = clones[0]?.cloneNode() ?? document.createElement("div");
-      allAttributes.forEach((attr) => outWrapper.setAttribute(attr.name, attr.value));
-      outWrapper.append(...mergedChildren.map((e) => e.node));
-      return outWrapper;
-    }
-    Tree3.mergeNodes = mergeNodes;
-    function getInitialValueFromTypeName(name) {
-      const { document: document2 } = Window.get();
-      if (name === "null") return null;
-      if (name === "boolean") return false;
-      if (name === "number") return 0;
-      if (name === "string") return "";
-      if (name === "text") return document2.createTextNode("");
-      if (name === "nodelist") return document2.createDocumentFragment().childNodes;
-      if (name === "element") return document2.createElement("div");
-      if (name === "array") return [];
-      if (name === "record") return {};
-      throw new Error(`Unknown value type name: ${name}`);
-    }
-    Tree3.getInitialValueFromTypeName = getInitialValueFromTypeName;
-    let TypeChecks;
-    ((TypeChecks2) => {
-      function getType(value) {
-        if (singleTypeCheck(value, "null")) return "null";
-        if (singleTypeCheck(value, "boolean")) return "boolean";
-        if (singleTypeCheck(value, "number")) return "number";
-        if (singleTypeCheck(value, "string")) return "string";
-        if (singleTypeCheck(value, "element")) return "element";
-        if (singleTypeCheck(value, "text")) return "text";
-        if (singleTypeCheck(value, "nodelist")) return "nodelist";
-        if (singleTypeCheck(value, "transformer")) return "transformer";
-        if (singleTypeCheck(value, "method")) return "method";
-        if (singleTypeCheck(value, "array")) return "array";
-        if (singleTypeCheck(value, "record")) return "record";
-        return void 0;
-      }
-      TypeChecks2.getType = getType;
-      TypeChecks2.everyTypeName = [
-        "null",
-        "boolean",
-        "number",
-        "string",
-        "text",
-        "nodelist",
-        "element",
-        "transformer",
-        "method",
-        "array",
-        "record"
-      ];
-      function singleTypeCheck(value, type) {
-        const { Element: Element2, Text: Text2, NodeList } = Window.get();
-        if (type === "null" && value === null) return true;
-        if (type === "boolean" && typeof value === "boolean") return true;
-        if (type === "number" && typeof value === "number") return true;
-        if (type === "string" && typeof value === "string") return true;
-        if (type === "element" && value instanceof Element2) return true;
-        if (type === "text" && value instanceof Text2) return true;
-        if (type === "nodelist" && value instanceof NodeList) {
-          const children = Array.from(value);
-          return children.every((child) => child instanceof Element2 || child instanceof Text2);
-        }
-        if (type === "transformer" && value instanceof Transformer) return true;
-        if (type === "method" && value instanceof Method) return true;
-        if (type === "array" && Array.isArray(value)) {
-          const childrenOk = value.every((child) => typeCheck(child, ...TypeChecks2.everyTypeName).success);
-          return childrenOk;
-        }
-        if (type === "record" && isRecord(value)) {
-          const childrenOk = Object.values(value).every((child) => typeCheck(child, ...TypeChecks2.everyTypeName).success);
-          return childrenOk;
-        }
-        return false;
-      }
-      TypeChecks2.singleTypeCheck = singleTypeCheck;
-      function typeCheck(value, ...types) {
-        const matchesOneType = types.some((type) => singleTypeCheck(value, type));
-        if (matchesOneType) return Outcome.makeSuccess(value);
-        return Outcome.makeFailure({
-          expected: types.join(" | "),
-          found: getType(value) ?? "undefined"
-        });
-      }
-      TypeChecks2.typeCheck = typeCheck;
-      function typeCheckMany(values, ...types) {
-        for (const [pos, val] of Object.entries(values)) {
-          const checked = typeCheck(val, ...types);
-          if (checked.success) continue;
-          return Outcome.makeFailure({ position: parseInt(pos), ...checked.error });
-        }
-        return Outcome.makeSuccess(values);
-      }
-      TypeChecks2.typeCheckMany = typeCheckMany;
-      TypeChecks2.isTreeMode = (name) => name === "isolation" || name === "coalescion";
-      TypeChecks2.isValueTypeName = (name) => {
-        const list = [
-          "null",
-          "boolean",
-          "number",
-          "string",
-          "text",
-          "nodelist",
-          "element",
-          "transformer",
-          "method",
-          "array",
-          "record"
-        ];
-        return list.includes(name);
-      };
-    })(TypeChecks = Tree3.TypeChecks || (Tree3.TypeChecks = {}));
-  })(Tree2 = Utils2.Tree || (Utils2.Tree = {}));
-  let SmartTags2;
-  ((SmartTags3) => {
-    SmartTags3.expectEmptyArgs = (args) => {
-      if (args.length === 0) return Outcome.makeSuccess([]);
-      return Outcome.makeFailure({
-        expected: "length: 0",
-        found: `length: ${args.length}`
-      });
-    };
-    SmartTags3.makeMainValueError = (expected, found, details) => ({ expected, found, details });
-    SmartTags3.makeArgsValueError = (expected, found, position, details) => ({ expected, found, position, details });
-    SmartTags3.makeTransformationError = (details) => ({ details });
-  })(SmartTags2 = Utils2.SmartTags || (Utils2.SmartTags = {}));
-})(Utils || (Utils = {}));
-
-// src/agnostic/html/hyper-json/smart-tags/isolated/boolean/index.ts
-var boolean = SmartTags.makeSmartTag({
-  name: "boolean",
-  defaultMode: "isolation",
-  isolationInitType: "boolean",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "null", "boolean", "number", "string", "text"),
-  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "null", "boolean", "number", "string", "text"),
-  func: (main, args) => Outcome.makeSuccess([main, ...args].every((item) => Cast.toBoolean(item)))
-});
-
-export {
-  boolean,
-  element,
-  get,
-  global,
-  guess,
-  nodelist,
-  number,
-  record,
-  func,
-  ref,
-  string,
-  text,
-  add,
-  addclass,
-  and,
-  append,
-  at,
-  call,
-  clone,
-  deleteproperties,
-  equals,
-  getattribute,
-  getproperties,
-  getproperty,
-  deepGetProperty,
-  ifFunc,
-  initialize,
-  join,
-  length,
-  map,
-  negate,
-  notrailing,
-  or,
-  pickrandom,
-  print,
-  populate,
-  push,
-  pusheach,
-  recordtoarray,
-  removeattribute,
-  removeclass,
-  renameproperty,
-  replace,
-  select,
-  set,
-  setattribute,
-  setproperties,
-  setproperty,
-  sorton,
-  split,
-  toarray,
-  toboolean,
-  toelement,
-  toggleclass,
-  tonodelist,
-  tonull,
-  tonumber,
-  torecord,
-  toref,
-  tostring,
-  totext,
-  transformselected,
-  trim,
-  SMART_TAGS_REGISTER,
-  Tree,
-  Utils,
-  Cast
-};