@design-edito/tools 0.1.49 → 0.1.51

package/chunks/chunk-O2WG3EMN.js

@@ -0,0 +1,2369 @@
+import {
+  nullFunc
+} from "./chunk-QAVYONH6.js";
+import {
+  Serialize
+} from "./chunk-SXRWMH3U.js";
+import {
+  Types
+} from "./chunk-XEQ2PBT2.js";
+import {
+  any
+} from "./chunk-FHLCPVND.js";
+import {
+  array
+} from "./chunk-QAQZEKIF.js";
+import {
+  SmartTags
+} from "./chunk-UT2J62LH.js";
+import {
+  Transformer
+} from "./chunk-BKO7GLC2.js";
+import {
+  Method
+} from "./chunk-RW7VAKJW.js";
+import {
+  insertNode
+} from "./chunk-XA4HVHJ4.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  recordMap
+} from "./chunk-XNF5MLCQ.js";
+import {
+  isInEnum
+} from "./chunk-E6MSDKON.js";
+import {
+  isRecord
+} from "./chunk-YDIBNEGA.js";
+import {
+  replaceAll
+} from "./chunk-ZTDVUXPR.js";
+import {
+  trimEnd,
+  trimStart
+} from "./chunk-6XL25OZX.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;
+    return makeFailure(makeTransformationError({
+      message: "This smart tag should not be used."
+    }));
+  }
+});
+
+// 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/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/spread/index.ts
+var spread = SmartTags.makeSmartTag({
+  name: "spread",
+  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/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 Tree;
+((_Tree) => {
+  class Tree2 {
+    node;
+    options;
+    parent;
+    parents;
+    pathFromParent;
+    root;
+    isRoot;
+    path;
+    pathString;
+    attributes;
+    isMethod;
+    tagName;
+    smartTagName;
+    smartTagsRegister;
+    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, document: document2 } = 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.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;
+      }
+      this.smartTagsRegister = 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,
+        spread,
+        setproperty,
+        sorton,
+        split,
+        toarray,
+        toboolean,
+        toelement,
+        toggleclass,
+        tonodelist,
+        tonull,
+        tonumber,
+        toref,
+        torecord,
+        tostring,
+        totext,
+        transformselected,
+        trim
+      ]);
+      if (this.smartTagName === null) {
+        this.smartTagData = null;
+      } else {
+        this.smartTagData = this.smartTagsRegister.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 true;
+        return false;
+      }).reduce((reduced, child) => {
+        if (reduced.length === 0) return [child];
+        if (child instanceof Element2) return [...reduced, child];
+        const lastReducedItem = reduced[reduced.length - 1];
+        if (lastReducedItem instanceof Element2) return [...reduced, child];
+        const lastReducedTrimmed = trimEnd(lastReducedItem.textContent ?? "");
+        const childTrimmed = trimStart(child.textContent ?? "");
+        const merged = document2.createTextNode(`${lastReducedTrimmed}${childTrimmed}`);
+        const returned = [...reduced];
+        returned.pop();
+        returned.push(merged);
+        return returned;
+      }, []).filter((child) => {
+        if (child instanceof Element2) return true;
+        const textContent = child.textContent ?? "";
+        return textContent.trim() !== "";
+      }).forEach((childNode) => {
+        if (childNode instanceof Text2) {
+          const rawTextContent = childNode.textContent ?? "";
+          const textContent = rawTextContent.replace(/^\s*\n+\s*/, "").replace(/\s*\n+\s*$/, "");
+          const returnedChildNode = document2.createTextNode(textContent);
+          mutableSubtrees.set(
+            positionnedChildrenCount,
+            new Tree2(returnedChildNode, 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
+      } = 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);
+    }
+    evaluate() {
+      const start = Date.now();
+      const {
+        getCachedValue,
+        setCachedValue,
+        enforceEvaluation
+      } = this;
+      const cached = getCachedValue();
+      if (cached !== void 0) return cached;
+      const evaluated = enforceEvaluation();
+      setCachedValue(evaluated);
+      const end = Date.now();
+      const time = end - start;
+      if (time > 20) console.warn(`${this.pathString} took ${time}ms to evaluate, maybe there's something wrong here`);
+      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,
+  setproperty,
+  sorton,
+  split,
+  spread,
+  toarray,
+  toboolean,
+  toelement,
+  toggleclass,
+  tonodelist,
+  tonull,
+  tonumber,
+  torecord,
+  toref,
+  tostring,
+  totext,
+  transformselected,
+  trim,
+  Tree,
+  Utils,
+  Cast
+};