@design-edito/tools 0.2.37 → 0.2.40

package/chunks/{chunk-NGIZKJDJ.js → chunk-SGGJJ46D.js}

@@ -1,30 +1,33 @@
 import {
   array
-} from "./chunk-QAQZEKIF.js";
-import {
-  any
-} from "./chunk-FHLCPVND.js";
+} from "./chunk-USIYKRNX.js";
 import {
   nullFunc
-} from "./chunk-QAVYONH6.js";
+} from "./chunk-AKNR3U25.js";
 import {
-  Serialize
-} from "./chunk-SXRWMH3U.js";
+  any
+} from "./chunk-ZKIQ753F.js";
 import {
   Types
 } from "./chunk-XEQ2PBT2.js";
 import {
   SmartTags
-} from "./chunk-UT2J62LH.js";
+} from "./chunk-HEY7J6GI.js";
+import {
+  Serialize
+} from "./chunk-DUCLFPGE.js";
 import {
   Transformer
-} from "./chunk-BKO7GLC2.js";
+} from "./chunk-JVMFT3IT.js";
 import {
   Method
 } from "./chunk-RW7VAKJW.js";
 import {
   insertNode
 } from "./chunk-XA4HVHJ4.js";
+import {
+  recordMap
+} from "./chunk-XNF5MLCQ.js";
 import {
   isInEnum
 } from "./chunk-E6MSDKON.js";
@@ -32,24 +35,23 @@ import {
   isRecord
 } from "./chunk-YDIBNEGA.js";
 import {
-  recordMap
-} from "./chunk-XNF5MLCQ.js";
+  trimEnd,
+  trimStart
+} from "./chunk-6XL25OZX.js";
 import {
   replaceAll
-} from "./chunk-ZTDVUXPR.js";
+} from "./chunk-EPUHVR7J.js";
 import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  makeFailure,
+  makeSuccess,
+  outcome_exports
+} from "./chunk-QEKI6WGQ.js";
 import {
-  trimEnd,
-  trimStart
-} from "./chunk-6XL25OZX.js";
+  get
+} from "./chunk-ROWPCMQY.js";
 import {
   isNonNullObject
 } from "./chunk-HQLRJ7XW.js";
-import {
-  Window
-} from "./chunk-RLJOYG64.js";
 import {
   unknownToString
 } from "./chunk-FENXVJYO.js";
@@ -59,7 +61,7 @@ var Cast;
 ((Cast2) => {
   Cast2.toNull = () => null;
   Cast2.toBoolean = (input) => {
-    const { Text: Text2 } = Window.get();
+    const { Text: Text2 } = get();
     if (input === null) return false;
     if (typeof input === "boolean") return input;
     if (typeof input === "number") return input !== 0;
@@ -72,7 +74,7 @@ var Cast;
     return true;
   };
   Cast2.toNumber = (input) => {
-    const { Text: Text2 } = Window.get();
+    const { Text: Text2 } = get();
     if (typeof input === "boolean") return input ? 1 : 0;
     if (typeof input === "number") return input;
     if (typeof input === "string") return parseFloat(`${input}`);
@@ -82,7 +84,7 @@ var Cast;
   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: NodeList2 } = Window.get();
+    const { Element: Element2, Text: Text2, NodeList: NodeList2 } = get();
     if (input instanceof Element2) return input.outerHTML;
     if (input instanceof Text2) return input.textContent ?? "";
     if (input instanceof NodeList2) return Array.from(input).map((e) => {
@@ -94,12 +96,12 @@ var Cast;
     return `{${Object.entries(input).map(([key, val]) => `${key}:"${(0, Cast2.toString)(val)}"`).join(",")}}`;
   };
   Cast2.toText = (input) => {
-    const { Text: Text2, document } = Window.get();
+    const { Text: Text2, document } = get();
     if (input instanceof Text2) return input.cloneNode(true);
     return document.createTextNode((0, Cast2.toString)(input));
   };
   Cast2.toElement = (input, tagName) => {
-    const { Element: Element2, Text: Text2, NodeList: NodeList2, document } = Window.get();
+    const { Element: Element2, Text: Text2, NodeList: NodeList2, document } = get();
     if (input instanceof Element2) return input.cloneNode(true);
     const returned = document.createElement(tagName ?? "div");
     if (input instanceof Text2) {
@@ -116,7 +118,7 @@ var Cast;
     return returned;
   };
   Cast2.toNodeList = (input) => {
-    const { Element: Element2, Text: Text2, NodeList: NodeList2, document } = Window.get();
+    const { Element: Element2, Text: Text2, NodeList: NodeList2, document } = get();
     const parentDiv = document.createElement("div");
     if (input instanceof NodeList2) {
       parentDiv.append(...Array.from(input).map((i) => i.cloneNode(true)));
@@ -144,7 +146,7 @@ var Cast;
     return parentDiv.childNodes;
   };
   Cast2.toArray = (input) => {
-    const { NodeList: NodeList2 } = Window.get();
+    const { NodeList: NodeList2 } = get();
     if (Array.isArray(input)) return [...input];
     if (input instanceof NodeList2) return Array.from(input);
     return [input];
@@ -165,31 +167,31 @@ var element = SmartTags.makeSmartTag({
   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, NodeList: NodeList2 } = Window.get();
+    const { document, NodeList: NodeList2 } = get();
     const elt = document.createElement(tagName);
     for (const argVal of args) {
       if (argVal instanceof NodeList2) elt.append(...Array.from(argVal));
       else if (argVal instanceof Element) elt.append(argVal);
       else elt.append(Cast.toText(argVal));
     }
-    return Outcome.makeSuccess(elt);
+    return makeSuccess(elt);
   }
 });
 
 // src/agnostic/html/hyper-json/smart-tags/isolated/get/index.ts
-var get = SmartTags.makeSmartTag({
+var get2 = 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 { makeSuccess: makeSuccess2, makeFailure: makeFailure2 } = outcome_exports;
     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);
+    if (found === void 0) return makeFailure2(makeTransformationError(`No variable stored under the name '${strName}'`));
+    return makeSuccess2(found);
   }
 });
 
@@ -198,11 +200,11 @@ var global = SmartTags.makeSmartTag({
   name: "global",
   defaultMode: "isolation",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
   func: (_m, _a, { sourceTree }) => {
     const globalObject = sourceTree.options.globalObject ?? {};
-    return Outcome.makeSuccess({ ...globalObject });
+    return makeSuccess({ ...globalObject });
   }
 });
 
@@ -211,41 +213,41 @@ var guess = SmartTags.makeSmartTag({
   name: "guess",
   defaultMode: "isolation",
   isolationInitType: "string",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
+  mainValueCheck: (m) => makeSuccess(m),
+  argsValueCheck: (a) => makeSuccess(a),
   func: (main, args) => {
     const { typeCheck } = Utils.Tree.TypeChecks;
-    const { makeSuccess } = Outcome;
+    const { makeSuccess: makeSuccess2 } = outcome_exports;
     let coalesced = main;
     for (const arg of args) coalesced = Utils.coalesceValues(coalesced, 0, arg);
-    const { Text: Text2, Element: Element2, document } = Window.get();
-    if (typeof coalesced !== "string" && !(coalesced instanceof Text2)) return makeSuccess(coalesced);
+    const { Text: Text2, Element: Element2, document } = get();
+    if (typeof coalesced !== "string" && !(coalesced instanceof Text2)) return makeSuccess2(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);
+    if (strCoalesced.trim().toLowerCase() === "true") return makeSuccess2(true);
+    if (strCoalesced.trim().toLowerCase() === "false") return makeSuccess2(false);
+    if (strCoalesced.trim().toLowerCase().match(/^\s*-?\s*(\d+(\.\d*)?|\.\d+)\s*$/)) return makeSuccess2(parseFloat(strCoalesced));
+    if (strCoalesced.trim().toLowerCase() === "null") return makeSuccess2(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);
+      if (arrayChecked.success) return makeSuccess2(arrayChecked.payload);
+      if (recordChecked.success) return makeSuccess2(recordChecked.payload);
     } catch (err) {
     }
     const div = document.createElement("div");
     div.innerHTML = strCoalesced;
     const divChildren = div.childNodes;
-    if (divChildren.length === 0) return makeSuccess(coalesced);
+    if (divChildren.length === 0) return makeSuccess2(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);
+    if (validDivChildren.length > 1) return makeSuccess2(validDivChildren);
     const validDivFirstchild = validDivChildren.item(0);
-    if (validDivChildren.length === 1 && validDivFirstchild instanceof Element2) return makeSuccess(validDivFirstchild);
-    return makeSuccess(coalesced);
+    if (validDivChildren.length === 1 && validDivFirstchild instanceof Element2) return makeSuccess2(validDivFirstchild);
+    return makeSuccess2(coalesced);
   }
 });
 
@@ -254,17 +256,17 @@ var nodelist = SmartTags.makeSmartTag({
   name: "nodelist",
   defaultMode: "isolation",
   isolationInitType: "nodelist",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
+  mainValueCheck: (m) => makeSuccess(m),
+  argsValueCheck: (a) => makeSuccess(a),
   func: (main, args) => {
-    const { document } = Window.get();
+    const { document } = get();
     const returnedParent = document.createDocumentFragment();
     returnedParent.append(
       ...Array.from(Cast.toNodeList(main)),
       ...Array.from(Cast.toNodeList(args))
     );
     const returned = returnedParent.childNodes;
-    return Outcome.makeSuccess(returned);
+    return makeSuccess(returned);
   }
 });
 
@@ -280,7 +282,7 @@ var number = SmartTags.makeSmartTag({
     const reduced = all.reduce((reduced2, curr) => {
       return reduced2 + Cast.toNumber(curr);
     }, 0);
-    return Outcome.makeSuccess(reduced);
+    return makeSuccess(reduced);
   }
 });
 
@@ -291,7 +293,7 @@ var record = SmartTags.makeSmartTag({
   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) => ({
+  func: (main, args) => makeSuccess(args.reduce((reduced, current) => ({
     ...reduced,
     ...current
   }), main))
@@ -299,7 +301,7 @@ var record = SmartTags.makeSmartTag({
 
 // src/agnostic/html/hyper-json/smart-tags/isolated/ref/index.ts
 var func = (main, _args, { sourceTree }) => {
-  const { makeFailure, makeSuccess } = Outcome;
+  const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
   const { makeTransformationError } = Utils.SmartTags;
   const strMain = Cast.toString(main);
   const resolveFrom = strMain.startsWith("/") ? sourceTree.root : sourceTree;
@@ -311,17 +313,17 @@ var func = (main, _args, { sourceTree }) => {
     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."));
+  if (resolved === void 0) return makeFailure2(makeTransformationError(`No value was found at path: ${strMain}`));
+  if (resolved === sourceTree) return makeFailure2(makeTransformationError("A ref node cannot reference itself."));
+  if (resolved.parents.includes(sourceTree)) return makeFailure2(makeTransformationError("A ref node cannot reference one of its parents."));
+  if (sourceTree.parents.includes(resolved)) return makeFailure2(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 makeSuccess2(transformer.toMethod());
   }
-  return makeSuccess(evaluated);
+  return makeSuccess2(evaluated);
 };
 var ref = SmartTags.makeSmartTag({
   name: "ref",
@@ -344,7 +346,7 @@ var string = SmartTags.makeSmartTag({
     const reduced = all.reduce((reduced2, curr) => {
       return `${reduced2}${Cast.toString(curr)}`;
     }, "");
-    return Outcome.makeSuccess(reduced);
+    return makeSuccess(reduced);
   }
 });
 
@@ -360,7 +362,7 @@ var text = SmartTags.makeSmartTag({
     const reduced = all.reduce((reduced2, curr) => {
       return Cast.toText(`${reduced2}${Cast.toText(curr)}`);
     }, Cast.toText(""));
-    return Outcome.makeSuccess(reduced);
+    return makeSuccess(reduced);
   }
 });
 
@@ -374,7 +376,7 @@ var add = SmartTags.makeSmartTag({
   func: (main, args) => {
     const numMain = Cast.toNumber(main);
     const numArgs = args.map(Cast.toNumber);
-    return Outcome.makeSuccess(numArgs.reduce((reduced, arg) => reduced + arg, numMain));
+    return makeSuccess(numArgs.reduce((reduced, arg) => reduced + arg, numMain));
   }
 });
 
@@ -386,10 +388,10 @@ var addclass = SmartTags.makeSmartTag({
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    const { Element: Element2, document } = Window.get();
+    const { Element: Element2, document } = get();
     if (main instanceof Element2) {
       main.classList.add(...args.map((arg) => Cast.toString(arg)));
-      return Outcome.makeSuccess(main);
+      return makeSuccess(main);
     }
     const children = Array.from(main).map((child) => {
       if (child instanceof Element2) {
@@ -401,7 +403,7 @@ var addclass = SmartTags.makeSmartTag({
     const frag = document.createDocumentFragment();
     frag.append(...children);
     const nodelist2 = frag.childNodes;
-    return Outcome.makeSuccess(nodelist2);
+    return makeSuccess(nodelist2);
   }
 });
 
@@ -410,12 +412,12 @@ var and = SmartTags.makeSmartTag({
   name: "and",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
+  mainValueCheck: (m) => makeSuccess(m),
+  argsValueCheck: (a) => makeSuccess(a),
   func: (main, args) => {
     const all = [main, ...args];
     const returned = all.every(Cast.toBoolean);
-    return Outcome.makeSuccess(returned);
+    return makeSuccess(returned);
   }
 });
 
@@ -427,12 +429,12 @@ var append = SmartTags.makeSmartTag({
   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: NodeList2, document } = Window.get();
-    if (Array.isArray(main)) return makeSuccess([...main, ...args]);
+    const { makeSuccess: makeSuccess2 } = outcome_exports;
+    const { Text: Text2, Element: Element2, NodeList: NodeList2, document } = get();
+    if (Array.isArray(main)) return makeSuccess2([...main, ...args]);
     if (main instanceof Element2) {
       main.append(...Array.from(Cast.toNodeList(args)));
-      return makeSuccess(main);
+      return makeSuccess2(main);
     }
     if (main instanceof NodeList2) {
       const frag = document.createDocumentFragment();
@@ -440,15 +442,15 @@ var append = SmartTags.makeSmartTag({
         ...Array.from(main),
         ...Array.from(Cast.toNodeList(args))
       );
-      return makeSuccess(frag.childNodes);
+      return makeSuccess2(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 makeSuccess2(Cast.toText(reducedString));
     }
-    return makeSuccess(args.reduce((reduced, arg) => {
+    return makeSuccess2(args.reduce((reduced, arg) => {
       return `${reduced}${Cast.toString(arg)}`;
     }, main));
   }
@@ -461,33 +463,33 @@ var at = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text", "array", "nodelist"),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError("number | string | text", "undefined", 0));
+    if (a.length > 1) return makeFailure2(makeArgsValueError("undefined", getType(a[1]) ?? "undefined", 1));
     const checked = typeCheckMany(a, "number", "string", "text");
-    if (checked.success) return makeSuccess(a);
+    if (checked.success) return makeSuccess2(a);
     return checked;
   },
   func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     const { makeTransformationError } = Utils.SmartTags;
     const pos = args[0];
     const numPos = Cast.toNumber(pos);
     let found;
-    const { NodeList: NodeList2 } = Window.get();
+    const { NodeList: NodeList2 } = get();
     if (typeof main === "string" || Array.isArray(main) || main instanceof NodeList2) {
       found = main[numPos];
     } else {
       const strMain = Cast.toString(main);
       found = strMain[numPos];
     }
-    if (found === void 0) return makeFailure(makeTransformationError({
+    if (found === void 0) return makeFailure2(makeTransformationError({
       message: "Property does not exist"
       // [WIP] maybe more details here ?
     }));
-    return makeSuccess(found);
+    return makeSuccess2(found);
   }
 });
 
@@ -497,24 +499,24 @@ var call = SmartTags.makeSmartTag({
   defaultMode: "coalescion",
   isolationInitType: "array",
   mainValueCheck: (m) => {
-    const { makeFailure } = Outcome;
+    const { makeFailure: makeFailure2 } = outcome_exports;
     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({
+    if (!Array.isArray(m)) return makeFailure2({
       expected: "method[]",
       found: getType(m) ?? "undefined"
     });
     const isMethodsArrayCheck = typeCheckMany(m, "method");
     if (isMethodsArrayCheck.success) return isMethodsArrayCheck;
-    return makeFailure(makeMainValueError("method | method[]", getType(m) ?? "undefined"));
+    return makeFailure2(makeMainValueError("method | method[]", getType(m) ?? "undefined"));
   },
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "array"),
   func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     const { makeTransformationError } = Utils.SmartTags;
-    return makeFailure(makeTransformationError({
+    return makeFailure2(makeTransformationError({
       message: "This smart tag should not be used."
     }));
   }
@@ -525,9 +527,9 @@ var clone = SmartTags.makeSmartTag({
   name: "clone",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(Utils.clone(main))
+  func: (main) => makeSuccess(Utils.clone(main))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/deleteproperties/index.ts
@@ -538,7 +540,7 @@ var deleteproperties = SmartTags.makeSmartTag({
   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 { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     const { makeTransformationError } = Utils.SmartTags;
     let returned = Utils.clone(main);
     for (const arg of args) {
@@ -546,10 +548,10 @@ var deleteproperties = SmartTags.makeSmartTag({
       try {
         returned = deepDeleteProperty(returned, strArg);
       } catch (err) {
-        return makeFailure(makeTransformationError(`Cannot access ${strArg} from input record`));
+        return makeFailure2(makeTransformationError(`Cannot access ${strArg} from input record`));
       }
     }
-    return makeSuccess(returned);
+    return makeSuccess2(returned);
   }
 });
 function deepDeleteProperty(record2, pathString) {
@@ -573,22 +575,22 @@ var equals = SmartTags.makeSmartTag({
   name: "equals",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => {
     const [first, ...others] = a;
-    if (first === void 0) return Outcome.makeFailure(Utils.SmartTags.makeArgsValueError(
+    if (first === void 0) return makeFailure(Utils.SmartTags.makeArgsValueError(
       "value",
       "undefined",
       0
     ));
     const returned = [first, ...others];
-    return Outcome.makeSuccess(returned);
+    return makeSuccess(returned);
   },
   func: (main, args) => {
-    const { Text: Text2 } = Window.get();
+    const { Text: Text2 } = 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));
+    return makeSuccess(normalizedArgs.every((arg) => arg === normalizedMain));
   }
 });
 
@@ -599,19 +601,19 @@ var getattribute = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError("string | Text", "undefined", 0));
+    if (a.length > 1) return makeFailure2(makeArgsValueError("undefined", getType(a[2]) ?? "undefined", 1));
     const checked = typeCheckMany(a, "string", "text");
-    if (checked.success) return makeSuccess(checked.payload);
+    if (checked.success) return makeSuccess2(checked.payload);
     return checked;
   },
   func: (main, args) => {
     const name = Cast.toString(args[0]);
     const found = main.getAttribute(name);
-    return Outcome.makeSuccess(found);
+    return makeSuccess(found);
   }
 });
 
@@ -629,7 +631,7 @@ var getproperties = SmartTags.makeSmartTag({
       if (val === void 0) return { ...reduced2 };
       return { ...reduced2, [key]: val };
     }, {});
-    return Outcome.makeSuccess(reduced);
+    return makeSuccess(reduced);
   }
 });
 
@@ -640,28 +642,28 @@ var getproperty = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError("string | Text", "undefined", 0));
+    if (a.length !== 1) return makeFailure2(makeArgsValueError("undefined", getType(a.at(1)) ?? "undefined", 1));
     const checked = typeCheckMany(a, "string", "text");
     if (!checked.success) return checked;
-    return makeSuccess(checked.payload);
+    return makeSuccess2(checked.payload);
   },
   func: (main, args) => {
     const { getType } = Utils.Tree.TypeChecks;
     const { makeTransformationError } = Utils.SmartTags;
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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}'`));
+      if (foundType !== "transformer") return makeSuccess2(found);
+      return makeFailure2(makeTransformationError(`Forbidden access to key: '${strPropName}'`));
     } catch (err) {
-      return makeFailure(makeTransformationError(`Impossible to access ${strPropName}`));
+      return makeFailure2(makeTransformationError(`Impossible to access ${strPropName}`));
     }
   }
 });
@@ -689,7 +691,7 @@ var textItemSymbol = "%%-hyperjson-text-%%";
 var nodelistItemSymbol = "%%-hyperjson-nodelist-%%";
 var elementItemSymbol = "%%-hyperjson-element-%%";
 function stringify(val) {
-  const { Text: Text2, Element: Element2, NodeList: NodeList2 } = Window.get();
+  const { Text: Text2, Element: Element2, NodeList: NodeList2 } = get();
   if (typeof val === "string" || typeof val === "number" || typeof val === "boolean" || val === null) return JSON.stringify(val);
   if (val instanceof Text2) return JSON.stringify(`${textItemSymbol}${val.textContent}`);
   if (val instanceof Element2) return JSON.stringify(`${elementItemSymbol}${val.outerHTML}`);
@@ -707,7 +709,7 @@ function stringify(val) {
   );
 }
 function parse(val) {
-  const { document } = Window.get();
+  const { document } = get();
   const jsonParsed = JSON.parse(val);
   if (typeof jsonParsed === "number" || typeof jsonParsed === "boolean" || jsonParsed === null) return jsonParsed;
   if (Array.isArray(jsonParsed)) return jsonParsed.map((e) => typeof e === "string" ? parse(e) : e);
@@ -739,11 +741,11 @@ var hjstringify = SmartTags.makeSmartTag({
   name: "hjstringify",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
   func: (main) => {
     const stringified = stringify(main);
-    return Outcome.makeSuccess(stringified);
+    return makeSuccess(stringified);
   }
 });
 
@@ -757,9 +759,9 @@ var hjparse = SmartTags.makeSmartTag({
   func: (main) => {
     try {
       const parsed = parse(`${main}`);
-      return Outcome.makeSuccess(parsed);
+      return makeSuccess(parsed);
     } catch (err) {
-      return Outcome.makeFailure({
+      return makeFailure({
         details: unknownToString(err)
       });
     }
@@ -773,15 +775,15 @@ var ifFunc = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "boolean"),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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);
+    if (a.length > 2) return makeFailure2(makeArgsValueError("value", "undefined", a.length));
+    if (a.length < 2) return makeFailure2(makeArgsValueError("undefined", "value", 2));
+    return makeSuccess2(a);
   },
   func: (main, args) => {
     const [then, otherwise] = args;
-    return Outcome.makeSuccess(main ? then : otherwise);
+    return makeSuccess(main ? then : otherwise);
   }
 });
 
@@ -790,29 +792,29 @@ var initialize = SmartTags.makeSmartTag({
   name: "initialize",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (first === void 0) return makeFailure2(makeArgsValueError("string | text", "undefined", 0));
+    if (a.length > 1) return makeFailure2(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);
+    if (!firstChecked.success) return makeFailure2(makeArgsValueError(firstChecked.error.expected, firstChecked.error.found, 0));
+    return makeSuccess2(a);
   },
   func: (_main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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`));
+    if (!isValueType || strFirstArg === "transformer" || strFirstArg === "method") return makeFailure2(makeTransformationError(`${strFirstArg} is not a valid type`));
     const initialized = getInitialValueFromTypeName(strFirstArg);
-    return makeSuccess(initialized);
+    return makeSuccess2(initialized);
   }
 });
 
@@ -824,10 +826,10 @@ var join = SmartTags.makeSmartTag({
   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 { makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (Array.isArray(main)) return makeSuccess2(main.map(Cast.toString).join(joiner));
+    return makeSuccess2(Array.from(main).map(Cast.toString).join(joiner));
   }
 });
 
@@ -839,11 +841,11 @@ var length = SmartTags.makeSmartTag({
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "nodelist"),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
   func: (main) => {
-    const { makeSuccess } = Outcome;
-    const { Text: Text2, NodeList: NodeList2, Element: Element2 } = Window.get();
-    if (typeof main === "string" || main instanceof NodeList2 || 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);
+    const { makeSuccess: makeSuccess2 } = outcome_exports;
+    const { Text: Text2, NodeList: NodeList2, Element: Element2 } = get();
+    if (typeof main === "string" || main instanceof NodeList2 || main instanceof Text2 || Array.isArray(main)) return makeSuccess2(main.length);
+    if (main instanceof Element2) return makeSuccess2(main.childNodes.length);
+    return makeSuccess2(Object.keys(main).length);
   }
 });
 
@@ -862,7 +864,7 @@ var map = SmartTags.makeSmartTag({
       for (const arg of args) {
         const { transformer } = arg;
         const applied = transformer.apply(reduced);
-        if (!applied.success) return Outcome.makeFailure(makeTransformationError({
+        if (!applied.success) return makeFailure(makeTransformationError({
           message: "Subtransformation failure.",
           onTransformed: reduced,
           transformerAt: args.indexOf(arg),
@@ -874,7 +876,7 @@ var map = SmartTags.makeSmartTag({
       }
       mapped.push(reduced);
     }
-    return Outcome.makeSuccess(mapped);
+    return makeSuccess(mapped);
   }
 });
 
@@ -885,7 +887,7 @@ var negate = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "boolean"),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(!main)
+  func: (main) => makeSuccess(!main)
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/notrailing/index.ts
@@ -895,19 +897,19 @@ var notrailing = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text"),
   argsValueCheck: (a) => {
-    const { makeSuccess, makeFailure } = Outcome;
+    const { makeSuccess: makeSuccess2, makeFailure: makeFailure2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeSuccess2([]);
+    if (a.length > 1) return makeFailure2(makeArgsValueError("undefined", getType(a[1]) ?? "undefined", 1));
     const [first] = a;
     const firstChecked = typeCheck(first, "string", "text");
-    if (!firstChecked.success) return makeFailure(makeArgsValueError(
+    if (!firstChecked.success) return makeFailure2(makeArgsValueError(
       firstChecked.error.expected,
       firstChecked.error.found,
       0
     ));
-    return makeSuccess([firstChecked.payload]);
+    return makeSuccess2([firstChecked.payload]);
   },
   func: (main, args) => {
     const strMain = Cast.toString(main);
@@ -915,8 +917,8 @@ var notrailing = SmartTags.makeSmartTag({
     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));
+    if (typeof main === "string") return makeSuccess(strOutput);
+    return makeSuccess(Cast.toText(strOutput));
   }
 });
 
@@ -925,12 +927,12 @@ var or = SmartTags.makeSmartTag({
   name: "or",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
+  mainValueCheck: (m) => makeSuccess(m),
+  argsValueCheck: (a) => makeSuccess(a),
   func: (main, args) => {
     const all = [main, ...args];
     const returned = all.some(Cast.toBoolean);
-    return Outcome.makeSuccess(returned);
+    return makeSuccess(returned);
   }
 });
 
@@ -942,12 +944,12 @@ var pickrandom = SmartTags.makeSmartTag({
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "array"),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
   func: (main) => {
-    const { makeSuccess, makeFailure } = Outcome;
+    const { makeSuccess: makeSuccess2, makeFailure: makeFailure2 } = outcome_exports;
     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);
+    if (found === void 0) return makeFailure2(makeTransformationError("Cannot pick inside empty array"));
+    return makeSuccess2(found);
   }
 });
 
@@ -958,18 +960,18 @@ var print = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => {
     const { getType } = Utils.Tree.TypeChecks;
-    const { makeSuccess, makeFailure } = Outcome;
+    const { makeSuccess: makeSuccess2, makeFailure: makeFailure2 } = outcome_exports;
     const { makeMainValueError } = Utils.SmartTags;
-    return getType(m) === "transformer" ? makeFailure(makeMainValueError("Exclude<value, transformer>", "transformer")) : makeSuccess(m);
+    return getType(m) === "transformer" ? makeFailure2(makeMainValueError("Exclude<value, transformer>", "transformer")) : makeSuccess2(m);
   },
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
+  argsValueCheck: (a) => 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);
+    return makeSuccess(main);
   }
 });
 
@@ -981,17 +983,17 @@ var populate = SmartTags.makeSmartTag({
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
   argsValueCheck: (a) => {
     const [first, ...others] = a;
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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(
+    if (!firstChecked.success) return makeFailure2(makeArgsValueError(
       firstChecked.error.expected,
       firstChecked.error.found,
       0
     ));
     const othersChecked = typeCheckMany(others, "array");
-    if (!othersChecked.success) return makeFailure(makeArgsValueError(
+    if (!othersChecked.success) return makeFailure2(makeArgsValueError(
       othersChecked.error.expected,
       othersChecked.error.found,
       othersChecked.error.position + 1
@@ -1001,16 +1003,16 @@ var populate = SmartTags.makeSmartTag({
       const [first2, second] = arg;
       const firstChecked2 = typeCheck(first2, "string", "text");
       const secondChecked = typeCheck(second, "string", "text");
-      if (!firstChecked2.success || !secondChecked.success) return makeFailure(makeArgsValueError(
+      if (!firstChecked2.success || !secondChecked.success) return makeFailure2(makeArgsValueError(
         "[string | Text, string | Text]",
         `[${getType(first2)}, ${getType(second)}]`,
         argPosNum + 1
       ));
     }
-    return makeSuccess(a);
+    return makeSuccess2(a);
   },
   func: (main, args) => {
-    const { makeSuccess, makeFailure } = Outcome;
+    const { makeSuccess: makeSuccess2, makeFailure: makeFailure2 } = outcome_exports;
     const { makeTransformationError } = Utils.SmartTags;
     const record2 = main;
     const [template, ...actions] = args;
@@ -1021,17 +1023,17 @@ var populate = SmartTags.makeSmartTag({
         const replaced = replaceAll(returnedStr, Cast.toString(toReplace), Cast.toString(value));
         returnedStr = replaced;
       } catch (err) {
-        return makeFailure(makeTransformationError({
+        return makeFailure2(makeTransformationError({
           message: "Something went wrong",
           subTransformerError: err
         }));
       }
     }
-    const { Text: Text2, NodeList: NodeList2 } = Window.get();
-    if (typeof template === "string") return makeSuccess(returnedStr);
-    if (template instanceof Text2) return makeSuccess(Cast.toText(returnedStr));
-    if (template instanceof NodeList2) return makeSuccess(Cast.toNodeList(returnedStr));
-    return makeSuccess(Cast.toElement(returnedStr));
+    const { Text: Text2, NodeList: NodeList2 } = get();
+    if (typeof template === "string") return makeSuccess2(returnedStr);
+    if (template instanceof Text2) return makeSuccess2(Cast.toText(returnedStr));
+    if (template instanceof NodeList2) return makeSuccess2(Cast.toNodeList(returnedStr));
+    return makeSuccess2(Cast.toElement(returnedStr));
   }
 });
 
@@ -1041,8 +1043,8 @@ var push = SmartTags.makeSmartTag({
   defaultMode: "coalescion",
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "array"),
-  argsValueCheck: (a) => Outcome.makeSuccess(a),
-  func: (main, args) => Outcome.makeSuccess([...main, ...args])
+  argsValueCheck: (a) => makeSuccess(a),
+  func: (main, args) => makeSuccess([...main, ...args])
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/pusheach/index.ts
@@ -1052,26 +1054,26 @@ var pusheach = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "array"),
   argsValueCheck: (a) => {
-    const { makeSuccess, makeFailure } = Outcome;
+    const { makeSuccess: makeSuccess2, makeFailure: makeFailure2 } = outcome_exports;
     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(
+      if (!checked.success) return makeFailure2(makeArgsValueError(
         checked.error.expected,
         checked.error.found,
         numPos
       ));
     }
-    return makeSuccess(a);
+    return makeSuccess2(a);
   },
   func: (main, args) => {
     const returned = [...main];
     for (const arg of args) {
       returned.push(...arg);
     }
-    return Outcome.makeSuccess(returned);
+    return makeSuccess(returned);
   }
 });
 
@@ -1082,7 +1084,7 @@ var recordtoarray = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(Object.values(main))
+  func: (main) => makeSuccess(Object.values(main))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/removeattribute/index.ts
@@ -1096,19 +1098,19 @@ var removeattribute = SmartTags.makeSmartTag({
     return typeCheck(m, "element", "nodelist");
   },
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError("string | Text", "undefined", 0));
+    if (a.length > 1) return makeFailure2(makeArgsValueError("undefined", getType(a[2]) ?? "undefined", 1));
     const checked = typeCheckMany(a, "string", "text");
-    if (checked.success) return makeSuccess(checked.payload);
+    if (checked.success) return makeSuccess2(checked.payload);
     return checked;
   },
   func: (main, args) => {
     const argsStr = args.map((e) => Cast.toString(e));
     const [name] = argsStr;
-    const { Element: Element2, NodeList: NodeList2, document } = Window.get();
+    const { Element: Element2, NodeList: NodeList2, document } = get();
     if (main instanceof NodeList2) {
       const children = Array.from(main).map((child) => {
         const cloned = Utils.clone(child);
@@ -1118,13 +1120,13 @@ var removeattribute = SmartTags.makeSmartTag({
       const frag = document.createDocumentFragment();
       frag.append(...children);
       const nodelist2 = frag.childNodes;
-      return Outcome.makeSuccess(nodelist2);
+      return makeSuccess(nodelist2);
     } else {
       const mainArr = Array.isArray(main) ? main : [main];
       const mainArrCloned = mainArr.map((e) => Utils.clone(e));
       mainArrCloned.forEach((e) => e.removeAttribute(name));
-      if (Array.isArray(main)) return Outcome.makeSuccess(mainArrCloned);
-      return Outcome.makeSuccess(mainArrCloned[0]);
+      if (Array.isArray(main)) return makeSuccess(mainArrCloned);
+      return makeSuccess(mainArrCloned[0]);
     }
   }
 });
@@ -1137,10 +1139,10 @@ var removeclass = SmartTags.makeSmartTag({
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    const { Element: Element2, document } = Window.get();
+    const { Element: Element2, document } = get();
     if (main instanceof Element2) {
       main.classList.remove(...args.map((arg) => Cast.toString(arg)));
-      return Outcome.makeSuccess(main);
+      return makeSuccess(main);
     }
     const children = Array.from(main).map((child) => {
       if (child instanceof Element2) {
@@ -1152,7 +1154,7 @@ var removeclass = SmartTags.makeSmartTag({
     const frag = document.createDocumentFragment();
     frag.append(...children);
     const nodelist2 = frag.childNodes;
-    return Outcome.makeSuccess(nodelist2);
+    return makeSuccess(nodelist2);
   }
 });
 
@@ -1163,24 +1165,24 @@ var renameproperty = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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(
+    if (!firstChecked.success) return makeFailure2(Utils.SmartTags.makeArgsValueError(
       firstChecked.error.expected,
       firstChecked.error.found,
       0
     ));
     const secondChecked = typeCheck(second, "string", "text");
-    if (!secondChecked.success) return makeFailure(Utils.SmartTags.makeArgsValueError(
+    if (!secondChecked.success) return makeFailure2(Utils.SmartTags.makeArgsValueError(
       secondChecked.error.expected,
       secondChecked.error.found,
       0
     ));
-    return makeSuccess([firstChecked.payload, secondChecked.payload]);
+    return makeSuccess2([firstChecked.payload, secondChecked.payload]);
   },
   func: (main, args) => {
     const [oldKey, newKey] = args.map(Cast.toString);
@@ -1189,7 +1191,7 @@ var renameproperty = SmartTags.makeSmartTag({
       const targetKey = key === oldKey ? newKey : key;
       returned[targetKey] = value;
     });
-    return Outcome.makeSuccess(returned);
+    return makeSuccess(returned);
   }
 });
 
@@ -1198,38 +1200,43 @@ var replace = SmartTags.makeSmartTag({
   name: "replace",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "string", "text", "nodelist", "element"),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError(expectedStr, "undefined", 0));
+    if (a.length === 1) return makeFailure2(makeArgsValueError(expectedStr, "undefined", 1));
+    if (a.length > 2) return makeFailure2(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);
+    return makeSuccess2(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);
+    return makeSuccess(
+      replacerFunc(
+        main,
+        Cast.toString(toReplace),
+        Cast.toString(replacer)
+      )
+    );
   }
 });
+function replacerFunc(value, toReplace, replacer) {
+  if (typeof value === "number" || typeof value === "boolean" || value === null || value instanceof Method) return value;
+  if (typeof value === "string") return value.replaceAll(toReplace, replacer);
+  const { Text: Text2, Element: Element2, NodeList: NodeList2 } = get();
+  if (value instanceof Text2) return Cast.toText(Cast.toString(value).replaceAll(toReplace, replacer));
+  if (value instanceof Element2) return Cast.toElement(Cast.toString(value).replaceAll(toReplace, replacer));
+  if (value instanceof NodeList2) return Cast.toNodeList(Cast.toString(value).replaceAll(toReplace, replacer));
+  if (Array.isArray(value)) return value.map((val) => replacerFunc(val, toReplace, replacer));
+  return Object.entries(value).reduce((acc, [key, val]) => ({
+    ...acc,
+    [key]: replacerFunc(val, toReplace, replacer)
+  }), {});
+}
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/select/index.ts
 var select = SmartTags.makeSmartTag({
@@ -1239,7 +1246,7 @@ var select = SmartTags.makeSmartTag({
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "nodelist", "element"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    const { document, Element: Element2 } = Window.get();
+    const { document, Element: Element2 } = get();
     const selectedFragment = document.createDocumentFragment();
     if (main instanceof Element2) {
       for (const arg of args) {
@@ -1257,7 +1264,7 @@ var select = SmartTags.makeSmartTag({
       }
     }
     const selected = selectedFragment.childNodes;
-    return Outcome.makeSuccess(selected);
+    return makeSuccess(selected);
   }
 });
 
@@ -1266,23 +1273,23 @@ var set = SmartTags.makeSmartTag({
   name: "set",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (first === void 0) return makeFailure2(makeArgsValueError("string | text", "undefined", 0));
+    if (a.length > 2) return makeFailure2(makeArgsValueError("undefined", getType(a[2]) ?? "undefined", 2));
     const firstChecked = typeCheck(first, "string", "text");
     if (!firstChecked.success) return firstChecked;
-    else return makeSuccess(a);
+    else return makeSuccess2(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);
+    return makeSuccess(main);
   }
 });
 
@@ -1297,20 +1304,20 @@ var setattribute = SmartTags.makeSmartTag({
     return typeCheck(m, "element", "nodelist");
   },
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError("string | Text", "undefined", 0));
+    if (a.length > 2) return makeFailure2(makeArgsValueError("undefined", getType(a[2]) ?? "undefined", 2));
     const checked = typeCheckMany(a, "string", "text");
-    if (checked.success) return makeSuccess(checked.payload);
+    if (checked.success) return makeSuccess2(checked.payload);
     return checked;
   },
   func: (main, args) => {
     const argsStr = args.map((e) => Cast.toString(e));
     const [name, value = ""] = argsStr;
     if (main instanceof NodeList) {
-      const { document } = Window.get();
+      const { document } = get();
       const children = Array.from(main).map((child) => {
         const cloned = Utils.clone(child);
         if (cloned instanceof Element) cloned.setAttribute(name, value);
@@ -1319,13 +1326,13 @@ var setattribute = SmartTags.makeSmartTag({
       const frag = document.createDocumentFragment();
       frag.append(...children);
       const nodelist2 = frag.childNodes;
-      return Outcome.makeSuccess(nodelist2);
+      return makeSuccess(nodelist2);
     } else {
       const mainArr = Array.isArray(main) ? main : [main];
       const mainArrCloned = mainArr.map((e) => Utils.clone(e));
       mainArrCloned.forEach((e) => e.setAttribute(name, value));
-      if (Array.isArray(main)) return Outcome.makeSuccess(mainArrCloned);
-      return Outcome.makeSuccess(mainArrCloned[0]);
+      if (Array.isArray(main)) return makeSuccess(mainArrCloned);
+      return makeSuccess(mainArrCloned[0]);
     }
   }
 });
@@ -1348,20 +1355,20 @@ var setproperty = SmartTags.makeSmartTag({
     "array"
   ),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError("string | Text", "undefined", 0));
+    if (a.length === 1) return makeFailure2(makeArgsValueError("value", "undefined", 1));
+    if (a.length !== 2) return makeFailure2(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]);
+    if (!firstChecked.success) return makeFailure2(makeArgsValueError(firstChecked.error.expected, firstChecked.error.found, 0));
+    return makeSuccess2([firstChecked.payload, second]);
   },
   func: (main, args) => {
     const [key, val] = args;
-    const { makeSuccess, makeFailure } = Outcome;
+    const { makeSuccess: makeSuccess2, makeFailure: makeFailure2 } = outcome_exports;
     const { makeTransformationError } = Utils.SmartTags;
     try {
       const withPropertySet = deepSetProperty(
@@ -1369,9 +1376,9 @@ var setproperty = SmartTags.makeSmartTag({
         Cast.toString(key),
         val
       );
-      return makeSuccess(withPropertySet);
+      return makeSuccess2(withPropertySet);
     } catch (err) {
-      return makeFailure(makeTransformationError(`Impossible to access property :${key}`));
+      return makeFailure2(makeTransformationError(`Impossible to access property :${key}`));
     }
   }
 });
@@ -1381,7 +1388,7 @@ function deepSetProperty(input, pathString, value) {
   let currentItemParent = void 0;
   let currentItemPathFromParent = void 0;
   let currentItem = clone2;
-  const { Text: Text2, Element: Element2, NodeList: NodeList2, document } = Window.get();
+  const { Text: Text2, Element: Element2, NodeList: NodeList2, document } = get();
   pathChunks.forEach((chunk, pos) => {
     const isLast = pos === pathChunks.length - 1;
     const numChunk = parseInt(chunk);
@@ -1502,26 +1509,26 @@ var sorton = SmartTags.makeSmartTag({
   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"));
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
+    if (!Array.isArray(m)) return makeFailure2(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 makeFailure2(makeMainValueError("record", getType(itemVal), `At position ${parseInt(itemPos)} in main value`));
     }
-    return makeSuccess(m);
+    return makeSuccess2(m);
   },
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError("[string | text]", "[]", 0));
+    if (a.length > 1) return makeFailure2(makeArgsValueError("undefined", getType(a[1]) ?? "undefined", 2));
     const checked = typeCheckMany(a, "string", "text");
-    if (checked.success) return makeSuccess(checked.payload);
+    if (checked.success) return makeSuccess2(checked.payload);
     return checked;
   },
   func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     const strPropName = Cast.toString(args[0]);
     const { getType } = Utils.Tree.TypeChecks;
     const { makeTransformationError } = Utils.SmartTags;
@@ -1531,15 +1538,15 @@ var sorton = SmartTags.makeSmartTag({
       return { record: record2, prop, type };
     });
     const firstItem = map2[0];
-    if (firstItem === void 0) return makeSuccess([]);
+    if (firstItem === void 0) return makeSuccess2([]);
     const firstItemType = firstItem.type;
-    if (firstItemType === void 0) return makeFailure(makeTransformationError({
+    if (firstItemType === void 0) return makeFailure2(makeTransformationError({
       message: "Invalid property type",
       onItem: 0,
       found: firstItemType
     }));
     for (const [daytumPos, daytumVal] of Object.entries(map2)) {
-      if (daytumVal.type !== firstItemType) return makeFailure(makeTransformationError({
+      if (daytumVal.type !== firstItemType) return makeFailure2(makeTransformationError({
         message: "Invalid property type",
         onItem: parseInt(daytumPos),
         expected: firstItemType,
@@ -1547,7 +1554,7 @@ var sorton = SmartTags.makeSmartTag({
       }));
     }
     const sorted = main.sort((a, b) => {
-      const { Text: Text2, NodeList: NodeList2 } = Window.get();
+      const { Text: Text2, NodeList: NodeList2 } = get();
       const aProp = a[strPropName];
       const bProp = b[strPropName];
       if (aProp === null) return 0;
@@ -1563,7 +1570,7 @@ var sorton = SmartTags.makeSmartTag({
       if (aProp instanceof NodeList2) return aProp.length - Cast.toNodeList(bProp).length;
       return 0;
     });
-    return makeSuccess(sorted);
+    return makeSuccess2(sorted);
   }
 });
 
@@ -1579,8 +1586,8 @@ var split = SmartTags.makeSmartTag({
     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));
+    if (typeof main === "string") return makeSuccess(strReturnedArr);
+    return makeSuccess(strReturnedArr.map(Cast.toText));
   }
 });
 
@@ -1591,17 +1598,17 @@ var spread = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "record"),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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));
+    if (a.length === 0) return makeFailure2(makeArgsValueError("record", "undefined", 0));
+    if (a.length > 1) return makeFailure2(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]);
+    if (!firstChecked.success) return makeFailure2(makeArgsValueError(firstChecked.error.expected, firstChecked.error.found, 0));
+    return makeSuccess2([firstChecked.payload]);
   },
-  func: (main, args) => Outcome.makeSuccess({ ...main, ...args[0] })
+  func: (main, args) => makeSuccess({ ...main, ...args[0] })
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/toarray/index.ts
@@ -1609,9 +1616,9 @@ var toarray = SmartTags.makeSmartTag({
   name: "toarray",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(Cast.toArray(main))
+  func: (main) => makeSuccess(Cast.toArray(main))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/toboolean/index.ts
@@ -1619,9 +1626,9 @@ var toboolean = SmartTags.makeSmartTag({
   name: "toboolean",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toBoolean(m))
+  func: (m) => makeSuccess(Cast.toBoolean(m))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/toelement/index.ts
@@ -1629,13 +1636,13 @@ var toelement = SmartTags.makeSmartTag({
   name: "toelement",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckManyWithLength(a, 0, 1, "string", "text"),
   func: (m, a) => {
     const [rawTagName] = a;
     const castedTagName = rawTagName !== void 0 ? Cast.toString(rawTagName) : void 0;
     const tagName = castedTagName !== "" ? castedTagName : void 0;
-    return Outcome.makeSuccess(Cast.toElement(m, tagName?.trim().toLowerCase()));
+    return makeSuccess(Cast.toElement(m, tagName?.trim().toLowerCase()));
   }
 });
 
@@ -1647,10 +1654,10 @@ var toggleclass = SmartTags.makeSmartTag({
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    const { Element: Element2, document } = Window.get();
+    const { Element: Element2, document } = get();
     if (main instanceof Element2) {
       args.forEach((arg) => main.classList.toggle(Cast.toString(arg)));
-      return Outcome.makeSuccess(main);
+      return makeSuccess(main);
     }
     const children = Array.from(main).map((child) => {
       if (child instanceof Element2) {
@@ -1662,7 +1669,7 @@ var toggleclass = SmartTags.makeSmartTag({
     const frag = document.createDocumentFragment();
     frag.append(...children);
     const nodelist2 = frag.childNodes;
-    return Outcome.makeSuccess(nodelist2);
+    return makeSuccess(nodelist2);
   }
 });
 
@@ -1671,9 +1678,9 @@ var tonodelist = SmartTags.makeSmartTag({
   name: "tonodelist",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toNodeList(m))
+  func: (m) => makeSuccess(Cast.toNodeList(m))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/tonull/index.ts
@@ -1681,9 +1688,9 @@ var tonull = SmartTags.makeSmartTag({
   name: "tonull",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: () => Outcome.makeSuccess(null)
+  func: () => makeSuccess(null)
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/tonumber/index.ts
@@ -1691,9 +1698,9 @@ var tonumber = SmartTags.makeSmartTag({
   name: "tonumber",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toNumber(m))
+  func: (m) => makeSuccess(Cast.toNumber(m))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/torecord/index.ts
@@ -1701,9 +1708,9 @@ var torecord = SmartTags.makeSmartTag({
   name: "torecord",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (main) => Outcome.makeSuccess(Cast.toRecord(main))
+  func: (main) => makeSuccess(Cast.toRecord(main))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/toref/index.ts
@@ -1711,7 +1718,7 @@ var toref = SmartTags.makeSmartTag({
   name: "toref",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
   func: (main, args, details) => func(Cast.toString(main), args, details)
 });
@@ -1721,9 +1728,9 @@ var tostring = SmartTags.makeSmartTag({
   name: "tostring",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toString(m))
+  func: (m) => makeSuccess(Cast.toString(m))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/totext/index.ts
@@ -1731,9 +1738,9 @@ var totext = SmartTags.makeSmartTag({
   name: "totext",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Outcome.makeSuccess(m),
+  mainValueCheck: (m) => makeSuccess(m),
   argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toText(m))
+  func: (m) => makeSuccess(Cast.toText(m))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/transformselected/index.ts
@@ -1743,21 +1750,21 @@ var transformselected = SmartTags.makeSmartTag({
   isolationInitType: "array",
   mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
   argsValueCheck: (a) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     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 });
+    if (!firstChecked.success) return makeFailure2({ ...firstChecked.error, position: 0 });
     const othersChecked = typeCheckMany(others, "method");
-    if (!othersChecked.success) return makeFailure({
+    if (!othersChecked.success) return makeFailure2({
       ...othersChecked.error,
       position: othersChecked.error.position + 1
     });
     const returned = [firstChecked.payload, ...othersChecked.payload];
-    return makeSuccess(returned);
+    return makeSuccess2(returned);
   },
   func: (main, args) => {
-    const { makeFailure, makeSuccess } = Outcome;
+    const { makeFailure: makeFailure2, makeSuccess: makeSuccess2 } = outcome_exports;
     const { makeTransformationError } = Utils.SmartTags;
     const { typeCheck } = Utils.Tree.TypeChecks;
     const mainClone = Cast.toElement(main);
@@ -1768,7 +1775,7 @@ var transformselected = SmartTags.makeSmartTag({
       for (const [selected, value] of Array.from(transformationMap)) {
         const transformer = method.transformer;
         const applied = transformer.apply(value);
-        if (!applied.success) return makeFailure(makeTransformationError({
+        if (!applied.success) return makeFailure2(makeTransformationError({
           // [WIP] maybe a custom makeSubTransformationError ?
           message: "Subtransformation failure.",
           onSelected: selected,
@@ -1782,14 +1789,14 @@ var transformselected = SmartTags.makeSmartTag({
     }
     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({
+      if (!transformedChecked.success) return makeFailure2(makeTransformationError({
         // [WIP] maybe a custom makeBadTransformationOutputError ?
         message: "Bad transformation output",
         onSelected: selected,
         onTransformed: transformed,
         details: { ...transformedChecked.error }
       }));
-      const { Element: Element2, NodeList: NodeList2, Text: Text2 } = Window.get();
+      const { Element: Element2, NodeList: NodeList2, Text: Text2 } = get();
       const replacer = transformedChecked.payload;
       if (replacer instanceof Element2 || replacer instanceof Text2) {
         insertNode(replacer, "after", selected);
@@ -1803,9 +1810,9 @@ var transformselected = SmartTags.makeSmartTag({
       }
       transformedChecked.payload;
     }
-    if (main instanceof Element) return makeSuccess(mainClone);
+    if (main instanceof Element) return makeSuccess2(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));
+    return main instanceof Element ? makeSuccess2(mainClone) : makeSuccess2(Cast.toNodeList(safeChildren));
   }
 });
 
@@ -1817,7 +1824,7 @@ var trim = SmartTags.makeSmartTag({
   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()));
+    return typeof main === "string" ? makeSuccess(main.trim()) : makeSuccess(Cast.toText(`${main}`.trim()));
   }
 });
 
@@ -1862,7 +1869,7 @@ var Tree;
       return new Tree2(merged, null, null, options);
     }
     constructor(node, parent, pathFromParent, options) {
-      const { Element: Element2, Text: Text2, document } = Window.get();
+      const { Element: Element2, Text: Text2, document } = get();
       this.resolve = this.resolve.bind(this);
       this.setVariable = this.setVariable.bind(this);
       this.getVariable = this.getVariable.bind(this);
@@ -1908,7 +1915,7 @@ var Tree;
         array,
         boolean,
         element,
-        get,
+        get2,
         global,
         guess,
         nodelist,
@@ -2087,7 +2094,7 @@ var Tree;
     }
     performSafetyChecks() {
       const { node, smartTagData, isMethod, mode, isRoot } = this;
-      const { Text: Text2 } = Window.get();
+      const { Text: Text2 } = 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}`);
@@ -2105,7 +2112,7 @@ var Tree;
         performSafetyChecks
       } = this;
       performSafetyChecks();
-      const { Text: Text2 } = Window.get();
+      const { Text: Text2 } = get();
       if (node instanceof Text2) return node.cloneNode(true);
       const initialInnerValue = Utils.Tree.getInitialValueFromTypeName(isolationInitType);
       const innerValue = Array.from(subtrees).reduce((reduced, [subpath, subtree]) => {
@@ -2135,7 +2142,7 @@ var Tree;
     }
     enforceEvaluation() {
       const { isPreserved, node, computeValue, isLiteral, attributes } = this;
-      const { Element: Element2 } = Window.get();
+      const { Element: Element2 } = get();
       if (isPreserved) return Utils.clone(node);
       const evaluated = computeValue();
       if (!isLiteral) return evaluated;
@@ -2177,7 +2184,7 @@ var Tree;
 var Utils;
 ((Utils2) => {
   function clone2(value) {
-    const { Element: Element2, Text: Text2, NodeList: NodeList2, document } = Window.get();
+    const { Element: Element2, Text: Text2, NodeList: NodeList2, document } = 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 NodeList2) {
@@ -2195,7 +2202,7 @@ var Utils;
   }
   Utils2.clone = clone2;
   function coalesceValues(currentValue, subpath, subvalue) {
-    const { Element: Element2, Text: Text2, NodeList: NodeList2, document } = Window.get();
+    const { Element: Element2, Text: Text2, NodeList: NodeList2, document } = get();
     let actualSubvalue = subvalue;
     if (actualSubvalue instanceof Transformer) {
       const transformer = actualSubvalue;
@@ -2291,7 +2298,7 @@ var Utils;
   }
   Utils2.coalesceValues = coalesceValues;
   Utils2.toHyperJson = (value) => {
-    const { document, Element: Element2, Text: Text2, NodeList: NodeList2 } = Window.get();
+    const { document, Element: Element2, Text: Text2, NodeList: NodeList2 } = get();
     if (value instanceof Text2) {
       const elt2 = document.createElement("text");
       elt2.innerHTML = value.textContent ?? "";
@@ -2356,7 +2363,7 @@ var Utils;
         "record"
       ];
       function singleTypeCheck(value, type) {
-        const { Element: Element2, Text: Text2, NodeList: NodeList2 } = Window.get();
+        const { Element: Element2, Text: Text2, NodeList: NodeList2 } = get();
         if (type === "null" && value === null) return true;
         if (type === "boolean" && typeof value === "boolean") return true;
         if (type === "number" && typeof value === "number") return true;
@@ -2381,8 +2388,8 @@ var Utils;
       TypeChecks2.singleTypeCheck = singleTypeCheck;
       function typeCheck(value, ...types) {
         const matchesOneType = types.some((type) => singleTypeCheck(value, type));
-        if (matchesOneType) return Outcome.makeSuccess(value);
-        return Outcome.makeFailure({
+        if (matchesOneType) return makeSuccess(value);
+        return makeFailure({
           expected: types.join(" | "),
           found: getType(value) ?? "undefined"
         });
@@ -2392,9 +2399,9 @@ var Utils;
         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 makeFailure({ position: parseInt(pos), ...checked.error });
         }
-        return Outcome.makeSuccess(values);
+        return makeSuccess(values);
       }
       TypeChecks2.typeCheckMany = typeCheckMany;
     })(TypeChecks = Transformations2.TypeChecks || (Transformations2.TypeChecks = {}));
@@ -2402,7 +2409,7 @@ var Utils;
   let Tree2;
   ((Tree3) => {
     function mergeNodes(nodes) {
-      const { document, Text: Text2, Element: Element2 } = Window.get();
+      const { document, Text: Text2, Element: Element2 } = get();
       const clones = nodes.map((node) => node.cloneNode(true));
       const allChildren = [];
       clones.forEach((node) => {
@@ -2446,7 +2453,7 @@ var Utils;
     }
     Tree3.mergeNodes = mergeNodes;
     function getInitialValueFromTypeName(name) {
-      const { document } = Window.get();
+      const { document } = get();
       if (name === "null") return null;
       if (name === "boolean") return false;
       if (name === "number") return 0;
@@ -2490,7 +2497,7 @@ var Utils;
         "record"
       ];
       function singleTypeCheck(value, type) {
-        const { Element: Element2, Text: Text2, NodeList: NodeList2 } = Window.get();
+        const { Element: Element2, Text: Text2, NodeList: NodeList2 } = get();
         if (type === "null" && value === null) return true;
         if (type === "boolean" && typeof value === "boolean") return true;
         if (type === "number" && typeof value === "number") return true;
@@ -2516,8 +2523,8 @@ var Utils;
       TypeChecks2.singleTypeCheck = singleTypeCheck;
       function typeCheck(value, ...types) {
         const matchesOneType = types.some((type) => singleTypeCheck(value, type));
-        if (matchesOneType) return Outcome.makeSuccess(value);
-        return Outcome.makeFailure({
+        if (matchesOneType) return makeSuccess(value);
+        return makeFailure({
           expected: types.join(" | "),
           found: getType(value) ?? "undefined"
         });
@@ -2527,18 +2534,18 @@ var Utils;
         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 makeFailure({ position: parseInt(pos), ...checked.error });
         }
-        return Outcome.makeSuccess(values);
+        return makeSuccess(values);
       }
       TypeChecks2.typeCheckMany = typeCheckMany;
       function typeCheckManyWithLength(values, minLength, maxLength, ...types) {
-        if (minLength !== void 0 && values.length < minLength) return Outcome.makeFailure({
+        if (minLength !== void 0 && values.length < minLength) return makeFailure({
           position: values.length + 1,
           expected: `min length: ${minLength}`,
           found: `length: ${values.length}`
         });
-        if (maxLength !== void 0 && values.length > maxLength) return Outcome.makeFailure({
+        if (maxLength !== void 0 && values.length > maxLength) return makeFailure({
           position: maxLength + 1,
           expected: `max length: ${maxLength}`,
           found: `length: ${values.length}`
@@ -2568,8 +2575,8 @@ var Utils;
   let SmartTags2;
   ((SmartTags3) => {
     SmartTags3.expectEmptyArgs = (args) => {
-      if (args.length === 0) return Outcome.makeSuccess([]);
-      return Outcome.makeFailure({
+      if (args.length === 0) return makeSuccess([]);
+      return makeFailure({
         expected: "length: 0",
         found: `length: ${args.length}`
       });
@@ -2598,13 +2605,13 @@ var boolean = SmartTags.makeSmartTag({
   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)))
+  func: (main, args) => makeSuccess([main, ...args].every((item) => Cast.toBoolean(item)))
 });
 
 export {
   boolean,
   element,
-  get,
+  get2 as get,
   global,
   guess,
   nodelist,
@@ -2649,6 +2656,7 @@ export {
   removeclass,
   renameproperty,
   replace,
+  replacerFunc,
   select,
   set,
   setattribute,