@design-edito/tools 0.1.70 → 0.1.72

package/chunks/chunk-SSJ5YQMJ.js

@@ -0,0 +1,45 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/sftp/file/copy/index.ts
+var copy_exports = {};
+__export(copy_exports, {
+  copy: () => copy
+});
+import { PassThrough } from "node:stream";
+async function copy(sftp, sourcePath, targetPath, options) {
+  const {
+    overwrite = false,
+    ensureDir = true,
+    ...transferOptions
+  } = options ?? {};
+  try {
+    if (!overwrite) {
+      const exists = await sftp.exists(targetPath);
+      if (exists) return Outcome.makeFailure(`File already exists at ${targetPath}.`);
+    }
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      if (dirPath) await sftp.mkdir(dirPath, true);
+    }
+    const pass = new PassThrough();
+    const uploadPromise = sftp.put(pass, targetPath, transferOptions);
+    await sftp.get(sourcePath, pass, transferOptions);
+    await uploadPromise;
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copy,
+  copy_exports
+};

package/chunks/{chunk-YE67BQQN.js → chunk-T4KFB6QN.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-NZLE2WMY.js";
+} from "./chunk-KH45J4DC.js";
 
 // node_modules/zod/dist/esm/v3/external.js
 var external_exports = {};

package/chunks/chunk-TEQE3HY3.js

@@ -0,0 +1,40 @@
+import {
+  move_exports
+} from "./chunk-54B7VIY6.js";
+import {
+  remove_exports
+} from "./chunk-5CYREVPP.js";
+import {
+  upload_exports
+} from "./chunk-FTOEQNF6.js";
+import {
+  stat_exports
+} from "./chunk-FR3BXMR5.js";
+import {
+  download_exports
+} from "./chunk-QKK6WQDI.js";
+import {
+  copy_exports
+} from "./chunk-Z2VDSEND.js";
+import {
+  exists_exports
+} from "./chunk-B7E3DQ4Z.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/ftps/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Copy: () => copy_exports,
+  Download: () => download_exports,
+  Exists: () => exists_exports,
+  Move: () => move_exports,
+  Remove: () => remove_exports,
+  Stat: () => stat_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  file_exports
+};

package/chunks/{chunk-Z4PVE6SR.js → chunk-TLYXVMR5.js}

@@ -1,12 +1,12 @@
 import {
   colorSchema
-} from "./chunk-U7R6TPHR.js";
+} from "./chunk-45S766KF.js";
 import {
   OperationNames
 } from "./chunk-MOVLLUDL.js";
 import {
   esm_default
-} from "./chunk-YE67BQQN.js";
+} from "./chunk-T4KFB6QN.js";
 
 // src/node/images/transform/flatten/index.ts
 var flattenSchema = esm_default.object({

package/chunks/chunk-TOGOF74B.js

@@ -0,0 +1,42 @@
+import {
+  copy as copy4
+} from "./chunk-4XS5UIQF.js";
+import {
+  copy as copy3
+} from "./chunk-3G4NTP23.js";
+import {
+  copy as copy2
+} from "./chunk-SSJ5YQMJ.js";
+import {
+  copy
+} from "./chunk-Z2VDSEND.js";
+import {
+  isFtpClient,
+  isGcsBucket,
+  isS3ClientWithBucket,
+  isSftpClient
+} from "./chunk-4IHBBNAG.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/cloud-storage/operations/copy-file/index.ts
+var copy_file_exports = {};
+__export(copy_file_exports, {
+  copyFile: () => copyFile
+});
+async function copyFile(client, sourcePath, targetPath, options) {
+  if (isGcsBucket(client)) return copy4(client, sourcePath, targetPath, options);
+  if (isS3ClientWithBucket(client)) return copy3(client.client, client.bucketName, sourcePath, targetPath, options);
+  if (isFtpClient(client)) return copy(client, sourcePath, targetPath, options);
+  if (isSftpClient(client)) return copy2(client, sourcePath, targetPath, options);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  copyFile,
+  copy_file_exports
+};

package/chunks/chunk-TQZ46CBX.js

@@ -0,0 +1,43 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/@google-cloud/storage/directory/move-dir/index.ts
+var move_dir_exports = {};
+__export(move_dir_exports, {
+  moveDir: () => moveDir
+});
+async function moveDir(bucket, sourceDir, targetDir, options) {
+  const { fileOptions, copyOptions, deleteOptions, overwrite = false } = options ?? {};
+  const from = sourceDir.endsWith("/") ? sourceDir : `${sourceDir}/`;
+  const to = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  try {
+    const [files] = await bucket.getFiles({ prefix: from });
+    for (const f of files) {
+      const rel = f.name.substring(from.length);
+      const dest = `${to}${rel}`;
+      const srcFile = bucket.file(f.name, fileOptions);
+      const destFile = bucket.file(dest, fileOptions);
+      if (!overwrite) {
+        const [exists] = await destFile.exists();
+        if (exists) throw new Error(`File already exists at ${dest}.`);
+      }
+      await srcFile.copy(dest, copyOptions);
+      await srcFile.delete(deleteOptions);
+    }
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  moveDir,
+  move_dir_exports
+};

package/chunks/{chunk-LXZULGNN.js → chunk-UBJACMOZ.js}

@@ -1,32 +1,32 @@
 import {
-  erase
-} from "./chunk-G66DWXF3.js";
-import {
-  download
-} from "./chunk-6WVNJVBE.js";
+  remove
+} from "./chunk-2RFYHF6F.js";
 import {
   upload
-} from "./chunk-KH5JTC2N.js";
+} from "./chunk-MP6CL7F7.js";
+import {
+  download
+} from "./chunk-MPYCQ5IF.js";
 import {
   Outcome
 } from "./chunk-JMU5PDBD.js";
 import {
   __export
-} from "./chunk-WSFCRVEQ.js";
+} from "./chunk-KH45J4DC.js";
 
 // src/node/@google-cloud/storage/file/revoke-signed-urls/index.ts
 var revoke_signed_urls_exports = {};
 __export(revoke_signed_urls_exports, {
   revokeSignedUrls: () => revokeSignedUrls
 });
-async function revokeSignedUrls(sourcePath, bucket, options) {
-  const { downloadOptions, eraseOptions, uploadOptions } = options ?? {};
-  const downloadAttempt = await download(sourcePath, bucket, downloadOptions);
+async function revokeSignedUrls(bucket, targetPath, options) {
+  const { downloadOptions, removeOptions, uploadOptions } = options ?? {};
+  const downloadAttempt = await download(bucket, targetPath, downloadOptions);
   if (!downloadAttempt.success) return downloadAttempt;
-  const deletionAttempt = await erase(sourcePath, bucket, eraseOptions);
+  const deletionAttempt = await remove(bucket, targetPath, removeOptions);
   if (!deletionAttempt.success) return deletionAttempt;
   const downloaded = downloadAttempt.payload;
-  const reuploadAttempt = await upload(downloaded, sourcePath, bucket, uploadOptions);
+  const reuploadAttempt = await upload(bucket, targetPath, downloaded, uploadOptions);
   if (!reuploadAttempt.success) return reuploadAttempt;
   return Outcome.makeSuccess(true);
 }

package/chunks/chunk-UOWPJDWO.js

@@ -0,0 +1,37 @@
+import {
+  Cast,
+  Tree,
+  Utils
+} from "./chunk-33GNX62K.js";
+import {
+  Types
+} from "./chunk-XEQ2PBT2.js";
+import {
+  SmartTags
+} from "./chunk-UT2J62LH.js";
+import {
+  Serialize
+} from "./chunk-SXRWMH3U.js";
+import {
+  Transformer
+} from "./chunk-BKO7GLC2.js";
+import {
+  Method
+} from "./chunk-RW7VAKJW.js";
+
+// src/agnostic/html/hyper-json/index.ts
+var HyperJson;
+((HyperJson2) => {
+  HyperJson2.Cast = Cast;
+  HyperJson2.Method = Method;
+  HyperJson2.Serialize = Serialize;
+  HyperJson2.SmartTags = SmartTags;
+  HyperJson2.Transformer = Transformer;
+  HyperJson2.Tree = Tree;
+  HyperJson2.Types = Types;
+  HyperJson2.Utils = Utils;
+})(HyperJson || (HyperJson = {}));
+
+export {
+  HyperJson
+};

package/chunks/{chunk-GVS2ZPGJ.js → chunk-UQVDRQ77.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-XEQ2PBT2.js";
 import {
   array
-} from "./chunk-QAQZEKIF.js";
+} from "./chunk-VDNIN3V5.js";
 import {
   any
 } from "./chunk-FHLCPVND.js";
@@ -26,24 +26,20 @@ import {
   insertNode
 } from "./chunk-XA4HVHJ4.js";
 import {
-  isInEnum
-} from "./chunk-E6MSDKON.js";
+  Outcome
+} from "./chunk-JMU5PDBD.js";
 import {
-  isRecord
-} from "./chunk-YDIBNEGA.js";
+  replaceAll
+} from "./chunk-ZTDVUXPR.js";
 import {
   recordMap
 } from "./chunk-XNF5MLCQ.js";
 import {
-  trimEnd,
-  trimStart
-} from "./chunk-6XL25OZX.js";
-import {
-  replaceAll
-} from "./chunk-ZTDVUXPR.js";
+  isInEnum
+} from "./chunk-E6MSDKON.js";
 import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  isRecord
+} from "./chunk-YDIBNEGA.js";
 import {
   Window
 } from "./chunk-RLJOYG64.js";
@@ -92,10 +88,10 @@ var Cast;
     if (input instanceof Text2) return input.cloneNode(true);
     return document2.createTextNode((0, Cast2.toString)(input));
   };
-  Cast2.toElement = (input, tagName) => {
+  Cast2.toElement = (input) => {
     const { Element: Element2, Text: Text2, NodeList, document: document2 } = Window.get();
     if (input instanceof Element2) return input.cloneNode(true);
-    const returned = document2.createElement(tagName ?? "div");
+    const returned = document2.createElement("div");
     if (input instanceof Text2) {
       returned.append(input.cloneNode(true));
       return returned;
@@ -377,25 +373,11 @@ var addclass = SmartTags.makeSmartTag({
   name: "addclass",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
+  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    const { Element: Element2 } = Window.get();
-    if (main instanceof Element2) {
-      main.classList.add(...args.map((arg) => Cast.toString(arg)));
-      return Outcome.makeSuccess(main);
-    }
-    const children = Array.from(main).map((child) => {
-      if (child instanceof Element2) {
-        child.classList.add(...args.map((arg) => Cast.toString(arg)));
-        return child;
-      }
-      return child;
-    });
-    const frag = document.createDocumentFragment();
-    frag.append(...children);
-    const nodelist2 = frag.childNodes;
-    return Outcome.makeSuccess(nodelist2);
+    main.classList.add(...args.map((arg) => Cast.toString(arg)));
+    return Outcome.makeSuccess(main);
   }
 });
 
@@ -1005,7 +987,7 @@ var removeattribute = SmartTags.makeSmartTag({
   mainValueCheck: (m) => {
     const { typeCheck, typeCheckMany } = Utils.Tree.TypeChecks;
     if (Array.isArray(m)) return typeCheckMany(m, "element");
-    return typeCheck(m, "element", "nodelist");
+    return typeCheck(m, "element");
   },
   argsValueCheck: (a) => {
     const { makeFailure, makeSuccess } = Outcome;
@@ -1018,26 +1000,13 @@ var removeattribute = SmartTags.makeSmartTag({
     return checked;
   },
   func: (main, args) => {
-    const argsStr = args.map((e) => Cast.toString(e));
-    const [name] = argsStr;
-    const { NodeList } = Window.get();
-    if (main instanceof NodeList) {
-      const children = Array.from(main).map((child) => {
-        const cloned = Utils.clone(child);
-        if (cloned instanceof Element) cloned.removeAttribute(name);
-        return cloned;
-      });
-      const frag = document.createDocumentFragment();
-      frag.append(...children);
-      const nodelist2 = frag.childNodes;
-      return Outcome.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]);
-    }
+    const { makeSuccess } = Outcome;
+    const mainArr = Array.isArray(main) ? main : [main];
+    const mainArrCloned = mainArr.map((e) => Utils.clone(e));
+    const name = Cast.toString(args[0]);
+    mainArrCloned.forEach((e) => e.removeAttribute(name));
+    if (Array.isArray(main)) return makeSuccess(mainArrCloned);
+    return makeSuccess(mainArrCloned[0]);
   }
 });
 
@@ -1046,25 +1015,11 @@ var removeclass = SmartTags.makeSmartTag({
   name: "removeclass",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
+  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    const { Element: Element2 } = Window.get();
-    if (main instanceof Element2) {
-      main.classList.remove(...args.map((arg) => Cast.toString(arg)));
-      return Outcome.makeSuccess(main);
-    }
-    const children = Array.from(main).map((child) => {
-      if (child instanceof Element2) {
-        child.classList.remove(...args.map((arg) => Cast.toString(arg)));
-        return child;
-      }
-      return child;
-    });
-    const frag = document.createDocumentFragment();
-    frag.append(...children);
-    const nodelist2 = frag.childNodes;
-    return Outcome.makeSuccess(nodelist2);
+    main.classList.remove(...args.map((arg) => Cast.toString(arg)));
+    return Outcome.makeSuccess(main);
   }
 });
 
@@ -1205,7 +1160,7 @@ var setattribute = SmartTags.makeSmartTag({
   mainValueCheck: (m) => {
     const { typeCheck, typeCheckMany } = Utils.Tree.TypeChecks;
     if (Array.isArray(m)) return typeCheckMany(m, "element");
-    return typeCheck(m, "element", "nodelist");
+    return typeCheck(m, "element");
   },
   argsValueCheck: (a) => {
     const { makeFailure, makeSuccess } = Outcome;
@@ -1218,26 +1173,13 @@ var setattribute = SmartTags.makeSmartTag({
     return checked;
   },
   func: (main, args) => {
+    const mainArr = Array.isArray(main) ? main : [main];
+    const mainArrCloned = mainArr.map((e) => Utils.clone(e));
     const argsStr = args.map((e) => Cast.toString(e));
     const [name, value = ""] = argsStr;
-    const { NodeList } = Window.get();
-    if (main instanceof NodeList) {
-      const children = Array.from(main).map((child) => {
-        const cloned = Utils.clone(child);
-        if (cloned instanceof Element) cloned.setAttribute(name, value);
-        return cloned;
-      });
-      const frag = document.createDocumentFragment();
-      frag.append(...children);
-      const nodelist2 = frag.childNodes;
-      return Outcome.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]);
-    }
+    mainArrCloned.forEach((e) => e.setAttribute(name, value));
+    if (Array.isArray(main)) return Outcome.makeSuccess(mainArrCloned);
+    return Outcome.makeSuccess(mainArrCloned[0]);
   }
 });
 
@@ -1428,13 +1370,8 @@ var toelement = SmartTags.makeSmartTag({
   defaultMode: "coalescion",
   isolationInitType: "array",
   mainValueCheck: (m) => Outcome.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()));
-  }
+  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
+  func: (m) => Outcome.makeSuccess(Cast.toElement(m))
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/toggleclass/index.ts
@@ -1442,25 +1379,11 @@ var toggleclass = SmartTags.makeSmartTag({
   name: "toggleclass",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
+  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    const { Element: Element2 } = Window.get();
-    if (main instanceof Element2) {
-      args.forEach((arg) => main.classList.toggle(Cast.toString(arg)));
-      return Outcome.makeSuccess(main);
-    }
-    const children = Array.from(main).map((child) => {
-      if (child instanceof Element2) {
-        args.forEach((arg) => child.classList.toggle(Cast.toString(arg)));
-        return child;
-      }
-      return child;
-    });
-    const frag = document.createDocumentFragment();
-    frag.append(...children);
-    const nodelist2 = frag.childNodes;
-    return Outcome.makeSuccess(nodelist2);
+    for (const arg of args) main.classList.toggle(Cast.toString(arg));
+    return Outcome.makeSuccess(main);
   }
 });
 
@@ -1660,7 +1583,7 @@ var Tree;
       return new Tree2(merged, null, null, options);
     }
     constructor(node, parent, pathFromParent, options) {
-      const { Element: Element2, Text: Text2, document: document2 } = Window.get();
+      const { Element: Element2, Text: Text2 } = Window.get();
       this.resolve = this.resolve.bind(this);
       this.setVariable = this.setVariable.bind(this);
       this.getVariable = this.getVariable.bind(this);
@@ -1669,6 +1592,7 @@ var Tree;
       this.enforceEvaluation = this.enforceEvaluation.bind(this);
       this.getCachedValue = this.getCachedValue.bind(this);
       this.setCachedValue = this.setCachedValue.bind(this);
+      this.getPerformanceData = this.getPerformanceData.bind(this);
       this.evaluate = this.evaluate.bind(this);
       this.node = node;
       this.options = options ?? Tree2.defaultOptions;
@@ -1805,32 +1729,20 @@ var Tree;
       const mutableSubtrees = /* @__PURE__ */ new Map();
       Array.from(childNodes).filter((child, _, childNodes2) => {
         if (child instanceof Element2) return true;
-        if (child instanceof Text2) return true;
-        return false;
-      }).reduce((reduced, child) => {
-        if (reduced.length === 0) return [child];
-        if (child instanceof Element2) return [...reduced, child];
-        const lastReducedItem = reduced[reduced.length - 1];
-        if (lastReducedItem instanceof Element2) return [...reduced, child];
-        const lastReducedTrimmed = trimEnd(lastReducedItem.textContent ?? "");
-        const childTrimmed = trimStart(child.textContent ?? "");
-        const merged = document2.createTextNode(`${lastReducedTrimmed}${childTrimmed}`);
-        const returned = [...reduced];
-        returned.pop();
-        returned.push(merged);
-        return returned;
-      }, []).filter((child) => {
-        if (child instanceof Element2) return true;
-        const textContent = child.textContent ?? "";
-        return textContent.trim() !== "";
+        if (!(child instanceof Text2)) return false;
+        const hasContent = (child.textContent ?? "").trim() !== "";
+        if (hasContent) return true;
+        if (childNodes2.some((n) => n instanceof Element2)) return false;
+        return true;
       }).forEach((childNode) => {
         if (childNode instanceof Text2) {
-          const rawTextContent = childNode.textContent ?? "";
-          const textContent = rawTextContent.replace(/^\s*\n+\s*/, "").replace(/\s*\n+\s*$/, "");
-          const returnedChildNode = document2.createTextNode(textContent);
+          const hasContent = (childNode.textContent ?? "").trim() !== "";
+          if (hasContent) {
+            childNode.textContent = childNode.textContent?.trim() ?? "";
+          }
           mutableSubtrees.set(
             positionnedChildrenCount,
-            new Tree2(returnedChildNode, this, positionnedChildrenCount, this.options)
+            new Tree2(childNode, this, positionnedChildrenCount, this.options)
           );
           positionnedChildrenCount += 1;
         } else {
@@ -1949,20 +1861,57 @@ var Tree;
     setCachedValue(evaluated) {
       this.cachedValue = Serialize.serialize(evaluated);
     }
+    perfCounters = {
+      evaluations: 0,
+      computeTime: 0,
+      computeTimeAvg: 0,
+      cached: 0,
+      cacheTime: 0,
+      cacheTimeAvg: 0,
+      totalTime: 0
+    };
+    // [WIP] bind this
+    getPerformanceData() {
+      const { subtrees, cachedValue, tagName, perfCounters } = this;
+      const subCounters = [];
+      subCounters.push([this.pathString, {
+        ...perfCounters,
+        tagName: tagName ?? "#text",
+        evaluated: cachedValue
+      }]);
+      subtrees.forEach((subtree) => subCounters.push(...subtree.getPerformanceData()));
+      return subCounters.sort((a, b) => {
+        const aCalls = a[1].evaluations + a[1].cached;
+        const bCalls = b[1].evaluations + b[1].cached;
+        return bCalls - aCalls;
+      });
+    }
     evaluate() {
       const start = Date.now();
       const {
         getCachedValue,
         setCachedValue,
-        enforceEvaluation
+        enforceEvaluation,
+        perfCounters
       } = this;
       const cached = getCachedValue();
-      if (cached !== void 0) return cached;
+      if (cached !== void 0) {
+        const end2 = Date.now();
+        const time2 = end2 - start;
+        perfCounters.cached++;
+        perfCounters.cacheTime += time2;
+        perfCounters.cacheTimeAvg = perfCounters.cacheTime / perfCounters.cached;
+        perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
+        return cached;
+      }
       const evaluated = enforceEvaluation();
       setCachedValue(evaluated);
       const end = Date.now();
       const time = end - start;
-      if (time > 20) console.warn(`${this.pathString} took ${time}ms to evaluate, maybe there's something wrong here`);
+      perfCounters.evaluations++;
+      perfCounters.computeTime += time;
+      perfCounters.computeTimeAvg = perfCounters.computeTime / perfCounters.evaluations;
+      perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
       return evaluated;
     }
   }
@@ -2328,20 +2277,6 @@ var Utils;
         return Outcome.makeSuccess(values);
       }
       TypeChecks2.typeCheckMany = typeCheckMany;
-      function typeCheckManyWithLength(values, minLength, maxLength, ...types) {
-        if (minLength !== void 0 && values.length < minLength) return Outcome.makeFailure({
-          position: values.length + 1,
-          expected: `min length: ${minLength}`,
-          found: `length: ${values.length}`
-        });
-        if (maxLength !== void 0 && values.length > maxLength) return Outcome.makeFailure({
-          position: maxLength + 1,
-          expected: `max length: ${maxLength}`,
-          found: `length: ${values.length}`
-        });
-        return typeCheckMany(values, ...types);
-      }
-      TypeChecks2.typeCheckManyWithLength = typeCheckManyWithLength;
       TypeChecks2.isTreeMode = (name) => name === "isolation" || name === "coalescion";
       TypeChecks2.isValueTypeName = (name) => {
         const list = [