@design-edito/tools 0.1.21 → 0.1.23

package/chunks/chunk-IGD53YL5.js

@@ -0,0 +1,870 @@
+import {
+  Serialize
+} from "./chunk-DRNK3RLE.js";
+import {
+  Crossenv
+} from "./chunk-3LVR6KZH.js";
+import {
+  Utils
+} from "./chunk-F7EVMWVG.js";
+import {
+  Types
+} from "./chunk-6NZCBAT4.js";
+import {
+  replaceInElement
+} from "./chunk-GBMHGF7P.js";
+import {
+  isRecord
+} from "./chunk-YDIBNEGA.js";
+import {
+  replaceAll
+} from "./chunk-MF56TTC5.js";
+import {
+  isFalsy
+} from "./chunk-QXAJXTXV.js";
+
+// src/agnostic/html/hyper-json/cast/index.ts
+var getWindow = Crossenv.getWindow;
+var Cast;
+((Cast2) => {
+  Cast2.toNull = () => null;
+  Cast2.toBoolean = (input) => !isFalsy(input);
+  Cast2.toNumber = (input) => {
+    if (typeof input === "number") return input;
+    if (typeof input === "string") return parseFloat(`${input}`);
+    if (input instanceof getWindow().Text) 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}`;
+    if (input instanceof getWindow().Element) return input.outerHTML;
+    if (input instanceof getWindow().Text) return input.textContent ?? "";
+    if (input instanceof getWindow().NodeList) return Array.from(input).map((e) => {
+      if (e instanceof getWindow().Element) return e.outerHTML;
+      return e.textContent;
+    }).join("");
+    return input.toString();
+  };
+  Cast2.toText = (input) => {
+    if (input instanceof getWindow().Text) return input.cloneNode(true);
+    return getWindow().document.createTextNode((0, Cast2.toString)(input));
+  };
+  Cast2.toElement = (input) => {
+    if (input instanceof getWindow().Element) return input.cloneNode(true);
+    const elt = getWindow().document.createElement("div");
+    if (input instanceof getWindow().Text) {
+      elt.append(input.cloneNode(true));
+      return elt;
+    }
+    if (input instanceof getWindow().NodeList) {
+      elt.append(...Array.from(input).map((e) => e.cloneNode(true)));
+      return elt;
+    }
+    if (Array.isArray(input)) return elt;
+    if (isRecord(input)) return elt;
+    elt.append(`${input}`);
+    return elt;
+  };
+  Cast2.toNodeList = (input) => {
+    const elt = getWindow().document.createElement("div");
+    if (input instanceof getWindow().NodeList) {
+      elt.append(...Array.from(input).map((i) => i.cloneNode(true)));
+      return elt.childNodes;
+    }
+    if (input instanceof getWindow().Element || input instanceof getWindow().Text) {
+      elt.append(input.cloneNode(true));
+      return elt.childNodes;
+    }
+    if (Array.isArray(input)) return elt.childNodes;
+    if (isRecord(input)) return elt.childNodes;
+    elt.innerHTML = `${input}`;
+    return elt.childNodes;
+  };
+  Cast2.toArray = (input) => {
+    if (Array.isArray(input)) return [...input];
+    if (input instanceof getWindow().NodeList) return Array.from(input);
+    return [input];
+  };
+  Cast2.toRecord = (input) => {
+    if (isRecord(input)) return { ...input };
+    return {};
+  };
+  Cast2.toTransformer = (input) => {
+    return Transformers.toNamed("utils/Cast.toTransformer", () => ({
+      action: "REPLACE",
+      value: input
+    }));
+  };
+})(Cast || (Cast = {}));
+
+// src/agnostic/html/hyper-json/transformers/classList/index.ts
+var classList = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    const { Element } = Crossenv.getWindow();
+    if (!(currentValue instanceof Element)) return Utils.makeTransformerError("Current value must be an Element");
+    const [actionArg, classNameArg] = args;
+    if (actionArg === void 0 || classNameArg === void 0) return Utils.makeTransformerError(`Expecting 2 arguments: (action: 'add' | 'remove' | 'toggle', classList: string)`);
+    const action = Cast.toString(actionArg);
+    const className = Cast.toString(actionArg).trim();
+    if (action === "add" /* ADD */) {
+      const outputValue = currentValue.cloneNode(true);
+      outputValue.classList.add(className);
+      return { action: "REPLACE", value: outputValue };
+    } else if (action === "remove" /* REMOVE */) {
+      const outputValue = currentValue.cloneNode(true);
+      outputValue.classList.remove(className);
+      return { action: "REPLACE", value: outputValue };
+    } else if (action === "toggle" /* TOGGLE */) {
+      const outputValue = currentValue.cloneNode(true);
+      outputValue.classList.toggle(className);
+      return { action: "REPLACE", value: outputValue };
+    }
+    return Utils.makeTransformerError(`Unknown action: ${action}`);
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/join/index.ts
+var join = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    const joiner = Cast.toString(args.at(0) ?? ",");
+    if (!Array.isArray(currentValue)) return Utils.makeTransformerError({
+      message: `Current value must be an array`,
+      input: currentValue
+    });
+    return {
+      action: "REPLACE",
+      value: currentValue.join(joiner)
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/length/index.ts
+var length = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    const { Element, NodeList, Text } = Crossenv.getWindow();
+    if (typeof currentValue === "string" || Array.isArray(currentValue) || currentValue instanceof NodeList) return {
+      action: "REPLACE",
+      value: currentValue.length
+    };
+    if (currentValue instanceof Element) return {
+      action: "REPLACE",
+      value: Array.from(currentValue.childNodes).length
+    };
+    if (currentValue instanceof Text) return {
+      action: "REPLACE",
+      value: currentValue.data.length
+    };
+    return Utils.makeTransformerError(`Current value must be of type string, Array, NodeList, Element or Text`);
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/print/index.ts
+var print = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    if (args.length === 0) console.log(currentValue);
+    else console.log(...args);
+    return { action: null };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/push/index.ts
+var push = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    if (!Array.isArray(currentValue)) return Utils.makeTransformerError({
+      message: "Current value must be an array",
+      input: currentValue
+    });
+    const outputValue = [...currentValue, ...args];
+    return {
+      action: "REPLACE",
+      value: outputValue
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/querySelector/index.ts
+var querySelector = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    const { document, Element, NodeList } = Crossenv.getWindow();
+    const [selectorRaw] = args;
+    if (selectorRaw === void 0) return Utils.makeTransformerError("Selector argument expected.");
+    const selector = Cast.toString(selectorRaw);
+    let toQuery;
+    if (currentValue instanceof Element) {
+      toQuery = currentValue.cloneNode(true);
+    } else if (currentValue instanceof NodeList) {
+      toQuery = document.createElement("div");
+      toQuery.append(...Array.from(currentValue).map((e) => e.cloneNode(true)));
+    } else return Utils.makeTransformerError("Current value must be an Element or a NodeList");
+    const found = toQuery.querySelectorAll(selector);
+    return {
+      action: "REPLACE",
+      value: found
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/ref/index.ts
+var ref = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (_, callerTree) => {
+    const [refPathStrRaw] = args;
+    const { Text } = Crossenv.getWindow();
+    if (typeof refPathStrRaw !== "string" && !(refPathStrRaw instanceof Text)) return Utils.makeTransformerError({
+      message: "PathString must be of type string or Text",
+      input: refPathStrRaw !== void 0 ? refPathStrRaw : "<undefined>"
+    });
+    const refPathStr = Cast.toString(refPathStrRaw);
+    const refPath = Utils.pathStringToPath(Cast.toString(refPathStrRaw));
+    const foundTree = callerTree.resolve(refPath);
+    if (foundTree === void 0) return Utils.makeTransformerError({
+      message: "Referenced value has not been found",
+      input: refPathStr
+    });
+    const evaluated = foundTree.evaluate();
+    return {
+      action: "MERGE",
+      value: evaluated
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/replace/index.ts
+var replace = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    const { Text, NodeList, Element } = Crossenv.getWindow();
+    if (typeof currentValue !== "string" && !(currentValue instanceof Text) && !(currentValue instanceof Element) && !(currentValue instanceof NodeList)) return Utils.makeTransformerError("Current value must be string, Text, Element or NodeList");
+    if (args.some((arg) => typeof arg !== "string" && !(arg instanceof Text) && !(arg instanceof Element) && !(arg instanceof NodeList))) return Utils.makeTransformerError("Arguments must be of type string, Text, Element or NodeList");
+    const [first, second] = args;
+    if (first === void 0 || second === void 0) return Utils.makeTransformerError(`Expecting at least 2 arguments. Found only ${args.length}`);
+    const replacer = args.at(-1);
+    const strReplacer = Cast.toString(replacer);
+    const toReplace = args.slice(0, -1);
+    const strToReplace = toReplace.map(Cast.toString);
+    const strInput = Cast.toString(currentValue);
+    const strOutput = strToReplace.reduce((str, torpl) => replaceAll(str, torpl, strReplacer), strInput);
+    if (typeof currentValue === "string") return { action: "REPLACE", value: strOutput };
+    if (currentValue instanceof Text) return { action: "REPLACE", value: Cast.toText(strOutput) };
+    if (currentValue instanceof Element) return { action: "REPLACE", value: Cast.toElement(strOutput) };
+    if (currentValue instanceof NodeList) return { action: "REPLACE", value: Cast.toNodeList(strOutput) };
+    return { action: null };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/split/index.ts
+var split = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    const { Text } = Crossenv.getWindow();
+    const [splitter] = args;
+    if (typeof currentValue !== "string" && !(currentValue instanceof Text)) return Utils.makeTransformerError({
+      message: "Current value must be string or Text",
+      input: currentValue
+    });
+    if (typeof splitter !== "string") return Utils.makeTransformerError({
+      message: "Splitter argument must be string",
+      input: splitter !== void 0 ? splitter : "<undefined>"
+    });
+    const strCurrentValue = Cast.toString(currentValue);
+    const splitted = strCurrentValue.split(splitter).map((e) => typeof currentValue === "string" ? Cast.toString(e) : Cast.toText(e));
+    return {
+      action: "REPLACE",
+      value: splitted
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/toArray/index.ts
+var toArray = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toArray(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toBoolean/index.ts
+var toBoolean = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toBoolean(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toElement/index.ts
+var toElement = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toElement(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toNodeList/index.ts
+var toNodeList = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toNodeList(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toNull/index.ts
+var toNull = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: null
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toNumber/index.ts
+var toNumber = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toNumber(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toRecord/index.ts
+var toRecord = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toRecord(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toRef/index.ts
+var toRef = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue, callerTree) => {
+    const { Text } = Crossenv.getWindow();
+    if (typeof currentValue !== "string" && !(currentValue instanceof Text)) return Utils.makeTransformerError({
+      message: "Current value must be string or Text",
+      input: currentValue
+    });
+    const refPathStr = Cast.toString(currentValue);
+    const refPath = Utils.pathStringToPath(refPathStr);
+    const foundTree = callerTree.resolve(refPath);
+    if (foundTree === void 0) return Utils.makeTransformerError({
+      message: "Referenced value has not been found",
+      input: refPathStr
+    });
+    const evaluated = foundTree.evaluate();
+    return {
+      action: "REPLACE",
+      value: evaluated
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/toString/index.ts
+var toString = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toString(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toText/index.ts
+var toText = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toText(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/transformers/toTransformer/index.ts
+var toTransformer = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => ({
+    action: "REPLACE",
+    value: Cast.toTransformer(currentValue)
+  }));
+};
+
+// src/agnostic/html/hyper-json/tree/index.ts
+var getWindow2 = Crossenv.getWindow;
+var isElement = (node) => node.nodeType === getWindow2().Node.ELEMENT_NODE;
+var isText = (node) => node.nodeType === getWindow2().Node.TEXT_NODE;
+var Tree = class _Tree {
+  node;
+  name;
+  parent;
+  root;
+  isRoot;
+  path;
+  pathString;
+  tagName;
+  attributes;
+  subtrees = /* @__PURE__ */ new Map();
+  children;
+  type;
+  generators;
+  constructor(node, generatorsOrParent, pathFromParent) {
+    this.resolve = this.resolve.bind(this);
+    this.getGenerator = this.getGenerator.bind(this);
+    this.initValue = this.initValue.bind(this);
+    this.getInnerValue = this.getInnerValue.bind(this);
+    this.wrapInnerValue = this.wrapInnerValue.bind(this);
+    this.setCache = this.setCache.bind(this);
+    this.getPerfCounters = this.getPerfCounters.bind(this);
+    this.printPerfCounters = this.printPerfCounters.bind(this);
+    this.pushToEvalCallStack = this.pushToEvalCallStack.bind(this);
+    this.flushEvalCallStack = this.flushEvalCallStack.bind(this);
+    this.evaluate = this.evaluate.bind(this);
+    this.node = node;
+    this.name = this.node instanceof getWindow2().Element ? this.node.getAttribute("_name") : null;
+    this.parent = generatorsOrParent instanceof _Tree ? generatorsOrParent : null;
+    this.root = this.parent === null ? this : this.parent.root;
+    this.isRoot = this.root === this;
+    const generators = generatorsOrParent instanceof _Tree ? /* @__PURE__ */ new Map() : Transformers.defaultGeneratorsMap;
+    this.generators = this.isRoot ? generators : this.root.generators;
+    if (this.parent === null) this.path = [];
+    else if (pathFromParent === void 0) {
+      this.path = [...this.parent.path, 0];
+    } else {
+      this.path = [...this.parent.path, pathFromParent];
+    }
+    this.pathString = `/${this.path.join("/")}`;
+    this.tagName = node instanceof getWindow2().Element ? node.tagName.toLowerCase() : null;
+    this.attributes = isElement(node) ? Array.from(node.attributes) : null;
+    const { childNodes } = node;
+    let positionnedChildrenCount = 0;
+    const mutableSubtrees = /* @__PURE__ */ new Map();
+    Array.from(childNodes).filter((node2, _, nodes) => {
+      if (isElement(node2)) return true;
+      if (isText(node2)) {
+        const hasContent = (node2.textContent ?? "").trim() !== "";
+        if (hasContent) return true;
+        if (nodes.some((n) => n instanceof getWindow2().Element)) return false;
+        return true;
+      }
+      return false;
+    }).forEach((childNode) => {
+      if (childNode instanceof getWindow2().Text) {
+        mutableSubtrees.set(
+          positionnedChildrenCount,
+          new _Tree(childNode, this, positionnedChildrenCount)
+        );
+        positionnedChildrenCount += 1;
+      } else {
+        const propertyName = childNode.getAttribute("_name");
+        if (propertyName === null) {
+          mutableSubtrees.set(
+            positionnedChildrenCount,
+            new _Tree(childNode, this, positionnedChildrenCount)
+          );
+          positionnedChildrenCount += 1;
+        } else {
+          mutableSubtrees.set(
+            propertyName,
+            new _Tree(childNode, this, propertyName)
+          );
+        }
+      }
+    });
+    this.subtrees = mutableSubtrees;
+    this.children = Array.from(this.subtrees.values());
+    if (this.tagName === null) {
+      this.type = "text";
+    } else if (this.tagName === Types.TyperTagName.NULL) {
+      this.type = "null";
+    } else if (this.tagName === Types.TyperTagName.BOOLEAN) {
+      this.type = "boolean";
+    } else if (this.tagName === Types.TyperTagName.NUMBER) {
+      this.type = "number";
+    } else if (this.tagName === Types.TyperTagName.STRING) {
+      this.type = "string";
+    } else if (this.tagName === Types.TyperTagName.TEXT) {
+      this.type = "text";
+    } else if (this.tagName === Types.TyperTagName.NODELIST) {
+      this.type = "nodelist";
+    } else if (this.tagName === Types.TyperTagName.ARRAY) {
+      this.type = "array";
+    } else if (this.tagName === Types.TyperTagName.RECORD) {
+      this.type = "record";
+    } else if (this.generators.get(this.tagName) !== void 0) {
+      this.type = "transformer";
+    } else {
+      this.type = "element";
+    }
+  }
+  resolve = function(path) {
+    let currentTree = this.root;
+    for (const chunk of path) {
+      const { subtrees } = currentTree;
+      const foundSubtree = subtrees.get(chunk);
+      if (foundSubtree === void 0) return void 0;
+      currentTree = foundSubtree;
+    }
+    return currentTree;
+  };
+  getGenerator(name) {
+    return this.generators.get(name);
+  }
+  initValue() {
+    const { type } = this;
+    let currentValue;
+    if (type === "null") {
+      currentValue = null;
+    } else if (type === "boolean") {
+      currentValue = false;
+    } else if (type === "number") {
+      currentValue = 0;
+    } else if (type === "string") {
+      currentValue = "";
+    } else if (type === "text") {
+      currentValue = this.node.textContent;
+    } else if (type === "element") {
+      currentValue = getWindow2().document.createDocumentFragment().childNodes;
+    } else if (type === "nodelist") {
+      currentValue = getWindow2().document.createDocumentFragment().childNodes;
+    } else if (type === "array") {
+      currentValue = [];
+    } else if (type === "record") {
+      currentValue = {};
+    } else if (type === "transformer") {
+      currentValue = [];
+    } else {
+      currentValue = null;
+    }
+    return currentValue;
+  }
+  static mergeValues(currentValue, incomingValue, mergeKey, initiatorTree) {
+    const { Element, Text, NodeList, document } = getWindow2();
+    if (typeof incomingValue === "function") {
+      const evaluated = incomingValue(currentValue, initiatorTree);
+      if (evaluated.action === null) return currentValue;
+      if (evaluated.action === "REPLACE") return evaluated.value;
+      if (evaluated.action === "ERROR") {
+        const errorMessage = `Tranformer error:
+from: ${incomingValue.transformerName}
+at: ${initiatorTree.pathString.slice(1)}/${mergeKey}
+message:`;
+        console.warn(errorMessage, evaluated.value);
+        return currentValue;
+      }
+      return _Tree.mergeValues(
+        currentValue,
+        evaluated.value,
+        mergeKey,
+        initiatorTree
+      );
+    }
+    if (Array.isArray(currentValue)) {
+      if (typeof mergeKey === "string") return currentValue;
+      return [...currentValue, incomingValue];
+    }
+    if (currentValue === null || typeof currentValue === "boolean" || typeof currentValue === "number" || typeof currentValue === "string" || typeof currentValue === "function" || currentValue instanceof Text || currentValue instanceof Element) {
+      if (incomingValue === null || typeof incomingValue === "boolean" || typeof incomingValue === "number" || typeof incomingValue === "string" || Array.isArray(incomingValue) || isRecord(incomingValue)) {
+        return incomingValue;
+      }
+      const frag = document.createDocumentFragment();
+      if (currentValue instanceof Element || currentValue instanceof Text) frag.append(currentValue.cloneNode(true));
+      else frag.append(`${currentValue}`);
+      if (incomingValue instanceof Element || incomingValue instanceof Text) {
+        frag.append(incomingValue.cloneNode(true));
+        return frag.childNodes;
+      }
+      frag.append(...Array.from(incomingValue).map((e) => e.cloneNode(true)));
+      return frag.childNodes;
+    }
+    if (currentValue instanceof NodeList) {
+      if (incomingValue instanceof Element || incomingValue instanceof Text) {
+        const frag = document.createDocumentFragment();
+        frag.append(...Array.from(currentValue).map((e) => e.cloneNode(true)), incomingValue);
+        return frag.childNodes;
+      }
+      if (incomingValue instanceof NodeList) {
+        const frag = document.createDocumentFragment();
+        frag.append(
+          ...Array.from(currentValue).map((e) => e.cloneNode(true)),
+          ...Array.from(incomingValue).map((e) => e.cloneNode(true))
+        );
+        return frag.childNodes;
+      }
+      if (incomingValue === null || typeof incomingValue === "string" || typeof incomingValue === "number" || typeof incomingValue === "boolean") {
+        const frag = document.createDocumentFragment();
+        frag.append(...Array.from(currentValue).map((e) => e.cloneNode(true)), `${incomingValue}`);
+        return frag.childNodes;
+      }
+      if (Array.isArray(incomingValue)) return [
+        ...Array.from(currentValue),
+        ...incomingValue
+      ];
+      return { ...incomingValue };
+    }
+    if (typeof mergeKey === "number") return currentValue;
+    return {
+      ...currentValue,
+      [mergeKey]: incomingValue
+    };
+  }
+  getInnerValue(initialValue) {
+    const { subtrees } = this;
+    const innerValue = Array.from(subtrees.entries()).reduce((currentValue, [subpath, subtree]) => _Tree.mergeValues(
+      currentValue,
+      subtree.evaluate(),
+      subpath,
+      this
+    ), initialValue);
+    return innerValue;
+  }
+  wrapInnerValue(innerValue) {
+    const { type } = this;
+    if (type === "transformer") {
+      const transformerName = this.tagName;
+      if (transformerName === null) return innerValue;
+      const generator = this.getGenerator(transformerName);
+      if (generator === void 0) return innerValue;
+      const transformer = Array.isArray(innerValue) ? generator(transformerName, ...innerValue) : generator(transformerName, innerValue);
+      return transformer;
+    }
+    if (type === "null") return Cast.toNull();
+    if (type === "boolean") return Cast.toBoolean(innerValue);
+    if (type === "number") return Cast.toNumber(innerValue);
+    if (type === "string") return Cast.toString(innerValue);
+    if (type === "array") return Cast.toArray(innerValue);
+    if (type === "record") return Cast.toRecord(innerValue);
+    if (type === "text") return Cast.toText(innerValue);
+    if (type === "element") return Cast.toElement(innerValue);
+    if (type === "nodelist") return Cast.toNodeList(innerValue);
+    return Cast.toNull();
+  }
+  cache = void 0;
+  setCache(value) {
+    this.cache = Serialize.serialize(value);
+  }
+  perfCounters = {
+    computed: 0,
+    computeTime: 0,
+    computeTimeAvg: 0,
+    cached: 0,
+    cacheTime: 0,
+    cacheTimeAvg: 0,
+    totalTime: 0
+  };
+  getPerfCounters() {
+    const { subtrees } = this;
+    const subCounters = [];
+    subCounters.push([this.pathString, this.perfCounters]);
+    subtrees.forEach((subtree) => subCounters.push(...subtree.getPerfCounters()));
+    return subCounters;
+  }
+  printPerfCounters() {
+    const perfCounters = this.getPerfCounters().sort((a, b) => b[1].totalTime - a[1].totalTime).map((e) => ({
+      path: e[0],
+      totalMs: e[1].totalTime,
+      computeMs: e[1].computeTime,
+      cacheMs: e[1].cacheTime,
+      ops: `${e[1].computed}/${e[1].cached}`
+    }));
+    console.table(perfCounters);
+  }
+  callstack = [];
+  pushToEvalCallStack(path) {
+    this.callstack.push(path);
+    this.parent?.pushToEvalCallStack(path);
+  }
+  flushEvalCallStack() {
+    this.callstack.length = 0;
+  }
+  evaluate() {
+    const start = Date.now();
+    const circularPatternDetected = this.callstack.some((p) => p.startsWith(this.pathString));
+    if (circularPatternDetected) throw new Error(`Circular reference pattern detected @ ${this.pathString}`);
+    this.pushToEvalCallStack(this.pathString);
+    const { perfCounters, cache } = this;
+    if (cache !== void 0) {
+      const deserialized = Serialize.deserialize(cache);
+      const end2 = Date.now();
+      const time2 = end2 - start;
+      perfCounters.cached++;
+      perfCounters.cacheTime += time2;
+      perfCounters.cacheTimeAvg = perfCounters.cacheTime / perfCounters.cached;
+      perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
+      return deserialized;
+    }
+    const init = this.initValue();
+    const inner = this.getInnerValue(init);
+    const wrapped = this.wrapInnerValue(inner);
+    this.setCache(wrapped);
+    const end = Date.now();
+    const time = end - start;
+    perfCounters.computed++;
+    perfCounters.computeTime += time;
+    perfCounters.computeTimeAvg = perfCounters.computeTime / perfCounters.computed;
+    perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
+    this.flushEvalCallStack();
+    return wrapped;
+  }
+};
+
+// src/agnostic/html/hyper-json/transformers/transformSelected/index.ts
+var transformSelected = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue, callerTree) => {
+    const { NodeList, Element, Text } = Crossenv.getWindow();
+    if (!(currentValue instanceof Element) && !(currentValue instanceof NodeList)) return Utils.makeTransformerError({
+      message: "Current value must be Element or NodeList",
+      input: currentValue
+    });
+    const [selector, ...transformerDescriptors] = args;
+    if (typeof selector !== "string" && !(selector instanceof Text)) return Utils.makeTransformerError({
+      message: "Selector argument must be string or text",
+      input: selector !== void 0 ? selector : "<undefined>"
+    });
+    if (transformerDescriptors.length === 0) return Utils.makeTransformerError("No transformer descriptor provided");
+    let transformers = [];
+    for (const descriptor of transformerDescriptors) {
+      const errorResponse = Utils.makeTransformerError({
+        message: "Transformer descriptors must be of shape { name: string, arguments: Value[] }",
+        input: descriptor
+      });
+      if (!isRecord(descriptor)) return errorResponse;
+      if (!("name" in descriptor) || typeof descriptor.name !== "string") return errorResponse;
+      if (!("arguments" in descriptor) || !Array.isArray(descriptor.arguments)) return errorResponse;
+      const { name, arguments: args2 } = descriptor;
+      const generator = callerTree.getGenerator(name);
+      if (generator === void 0) return Utils.makeTransformerError(`No transformer found under the name ${name}`);
+      transformers.push(generator(name, ...args2));
+    }
+    const elementInput = Cast.toElement(currentValue);
+    const strSelector = Cast.toString(selector);
+    const selected = Array.from(elementInput.querySelectorAll(strSelector));
+    const transformationErrors = [];
+    const transformed = selected.map((input) => {
+      const output = transformers.reduce((reduced, transformer, transformerPos) => {
+        const result = transformer(reduced, callerTree);
+        if (result.action === "REPLACE") return result.value;
+        else if (result.action === "MERGE") {
+          const merged = Tree.mergeValues(
+            reduced,
+            result.value,
+            transformerPos,
+            callerTree
+          );
+          return merged;
+        }
+        if (result.action === "ERROR") transformationErrors.push({
+          message: result.value,
+          transformerName: transformer.transformerName,
+          transformerPos,
+          transforming: reduced
+        });
+        return reduced;
+      }, input);
+      return { input, output };
+    });
+    if (transformationErrors.length !== 0) return Utils.makeTransformerError({
+      message: "Some nested transformers returned an error",
+      errors: transformationErrors
+    });
+    const nonElementTransformResult = transformed.find((item) => !(item.output instanceof Element));
+    if (nonElementTransformResult !== void 0) return Utils.makeTransformerError({
+      message: "Some transformations resulted in a non Element output",
+      inputElement: nonElementTransformResult.input,
+      outputValue: nonElementTransformResult.output
+    });
+    const transformMap = new Map(transformed.map((e) => [e.input, e.output]));
+    const elementOutput = replaceInElement(elementInput, transformMap);
+    return {
+      action: "REPLACE",
+      value: elementOutput
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/trim/index.ts
+var trim = (callerTagName) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    const { Text } = Crossenv.getWindow();
+    if (typeof currentValue !== "string" && !(currentValue instanceof Text)) return Utils.makeTransformerError({
+      message: "Current value must be of type string or Text",
+      input: currentValue
+    });
+    const inputStr = Cast.toString(currentValue);
+    const trimmed = inputStr.trim();
+    return {
+      action: "REPLACE",
+      value: currentValue instanceof Text ? Cast.toText(trimmed) : trimmed
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/index.ts
+var Transformers;
+((Transformers2) => {
+  Transformers2.defaultGeneratorsMap = /* @__PURE__ */ new Map([
+    ["append", append],
+    ["classList", classList],
+    ["join", join],
+    ["length", length],
+    ["print", print],
+    ["push", push],
+    ["querySelector", querySelector],
+    ["ref", ref],
+    ["replace", replace],
+    ["split", split],
+    ["toArray", toArray],
+    ["toBoolean", toBoolean],
+    ["toElement", toElement],
+    ["toNodeList", toNodeList],
+    ["toNull", toNull],
+    ["toNumber", toNumber],
+    ["toRecord", toRecord],
+    ["toRef", toRef],
+    ["toString", toString],
+    ["toText", toText],
+    ["toTransformer", toTransformer],
+    ["transformSelected", transformSelected],
+    ["trim", trim]
+  ]);
+  Transformers2.toNamed = (name, anonymous) => {
+    const named = anonymous;
+    named.transformerName = name;
+    return named;
+  };
+})(Transformers || (Transformers = {}));
+
+// src/agnostic/html/hyper-json/transformers/append/index.ts
+var append = (callerTagName, ...args) => {
+  return Transformers.toNamed(callerTagName, (currentValue) => {
+    const { document, Element, Text, NodeList } = Crossenv.getWindow();
+    const [...toAppend] = args;
+    const frag = document.createDocumentFragment();
+    frag.append(...Array.from(Cast.toNodeList(currentValue)).map((e) => e.cloneNode(true)));
+    toAppend.forEach((item) => {
+      if (item instanceof Element) frag.append(item.cloneNode(true));
+      else if (item instanceof Text) frag.append(item.cloneNode(true));
+      else if (item instanceof NodeList) frag.append(...Array.from(item).map((e) => e.cloneNode(true)));
+      else frag.append(Cast.toString(item));
+    });
+    return {
+      action: "REPLACE",
+      value: frag.childNodes
+    };
+  });
+};
+
+export {
+  append,
+  classList,
+  join,
+  length,
+  print,
+  push,
+  querySelector,
+  ref,
+  replace,
+  split,
+  toArray,
+  toBoolean,
+  toElement,
+  toNodeList,
+  toNull,
+  toNumber,
+  toRecord,
+  toRef,
+  toString,
+  toText,
+  toTransformer,
+  Tree,
+  transformSelected,
+  trim,
+  Transformers,
+  Cast
+};