@design-edito/tools 0.1.70 → 0.1.72

package/chunks/{chunk-NZLE2WMY.js → chunk-KH45J4DC.js}

@@ -4,7 +4,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -27,9 +36,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 export {
+  __require,
+  __esm,
   __commonJS,
   __export,
-  __toESM
+  __toESM,
+  __toCommonJS
 };

package/chunks/chunk-KNE7WIIW.js

@@ -0,0 +1 @@
+function e(n,r){return typeof r=="string"?n===r:n.match(r)!==null}function g(n,r){return Array.isArray(r)?r.some(t=>e(n,t)):e(n,r)}function i(n,r){return Array.isArray(r)?r.every(t=>e(n,t)):e(n,r)}export{e as a,g as b,i as c};

package/chunks/{chunk-5TRAENM3.js → chunk-KOBZRZBX.js}

@@ -3,17 +3,14 @@ import {
   randomPickMany
 } from "./chunk-AQBJ6HNB.js";
 import {
-  make
-} from "./chunk-RLAZR3NL.js";
-import {
-  shuffle
-} from "./chunk-VJJIYJMY.js";
+  isArrayOf
+} from "./chunk-6RGDWX4A.js";
 import {
   findDuplicates
 } from "./chunk-YS6WMSWC.js";
 import {
-  isArrayOf
-} from "./chunk-6RGDWX4A.js";
+  make
+} from "./chunk-RLAZR3NL.js";
 
 // src/agnostic/arrays/index.tsx
 var Arrays;
@@ -23,7 +20,6 @@ var Arrays;
   Arrays2.make = make;
   Arrays2.randomPick = randomPick;
   Arrays2.randomPickMany = randomPickMany;
-  Arrays2.shuffle = shuffle;
 })(Arrays || (Arrays = {}));
 
 export {

package/chunks/chunk-KPYPESIY.js

@@ -0,0 +1,40 @@
+import {
+  move_exports
+} from "./chunk-NX2FQWHA.js";
+import {
+  remove_exports
+} from "./chunk-J467ZNXE.js";
+import {
+  upload_exports
+} from "./chunk-IOZR2LGL.js";
+import {
+  stat_exports
+} from "./chunk-PPJYUWHH.js";
+import {
+  download_exports
+} from "./chunk-5RA25FYM.js";
+import {
+  copy_exports
+} from "./chunk-SSJ5YQMJ.js";
+import {
+  exists_exports
+} from "./chunk-ZO5FRL3M.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/sftp/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-LBDZQNBM.js

@@ -0,0 +1,44 @@
+import {
+  require_dist_cjs4 as require_dist_cjs
+} from "./chunk-IZP4VIFZ.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export,
+  __toESM
+} from "./chunk-KH45J4DC.js";
+
+// src/node/@aws-s3/storage/file/remove/index.ts
+var remove_exports = {};
+__export(remove_exports, {
+  remove: () => remove
+});
+var import_client_s3 = __toESM(require_dist_cjs(), 1);
+async function remove(s3, bucketName, targetPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  try {
+    try {
+      await s3.send(new import_client_s3.HeadObjectCommand({ Bucket: bucketName, Key: targetPath }));
+    } catch (err) {
+      const code = err?.name ?? err?.Code ?? err?.code;
+      if (code === "NotFound" || code === "NoSuchKey" || code === "NotFoundException") {
+        if (ignoreMissing) return Outcome.makeSuccess(true);
+        return Outcome.makeFailure(`File not found at ${targetPath}.`);
+      }
+      return Outcome.makeFailure(unknownToString(err));
+    }
+    await s3.send(new import_client_s3.DeleteObjectCommand({ Bucket: bucketName, Key: targetPath }));
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  remove,
+  remove_exports
+};

package/chunks/chunk-LCFDDWJR.js

@@ -0,0 +1,278 @@
+import {
+  isRecord
+} from "./chunk-YDIBNEGA.js";
+import {
+  isInEnum
+} from "./chunk-E6MSDKON.js";
+import {
+  isFalsy
+} from "./chunk-QXAJXTXV.js";
+
+// src/agnostic/html/hyper-json/index.ts
+var HyperJson;
+((HyperJson2) => {
+  const crossenvWindow = window;
+  const document = crossenvWindow.document;
+  const Element = crossenvWindow.Element;
+  const Text = crossenvWindow.Text;
+  const Node = crossenvWindow.Node;
+  const isElement = (node) => node.nodeType === Node.ELEMENT_NODE;
+  const isText = (node) => node.nodeType === Node.TEXT_NODE;
+  let TyperTagName;
+  ((TyperTagName2) => {
+    TyperTagName2["NULL"] = "null";
+    TyperTagName2["BOOLEAN"] = "boolean";
+    TyperTagName2["NUMBER"] = "number";
+    TyperTagName2["STRING"] = "string";
+    TyperTagName2["TEXT"] = "text";
+    TyperTagName2["NODELIST"] = "nodelist";
+    TyperTagName2["ARRAY"] = "array";
+    TyperTagName2["RECORD"] = "record";
+  })(TyperTagName = HyperJson2.TyperTagName || (HyperJson2.TyperTagName = {}));
+  let TransformerTagName;
+  ((TransformerTagName2) => {
+    TransformerTagName2["MAP"] = "map";
+    TransformerTagName2["REF"] = "ref";
+    TransformerTagName2["ADD"] = "add";
+    TransformerTagName2["MULT"] = "mult";
+    TransformerTagName2["APPEND"] = "append";
+  })(TransformerTagName = HyperJson2.TransformerTagName || (HyperJson2.TransformerTagName = {}));
+  class Tree {
+    node;
+    name;
+    parent;
+    root;
+    path;
+    pathString;
+    tagName;
+    attributes;
+    subtrees = /* @__PURE__ */ new Map();
+    children;
+    type;
+    constructor(node, parent, pathFromParent) {
+      this.initValue = this.initValue.bind(this);
+      this.getInnerValue = this.getInnerValue.bind(this);
+      this.wrapInnerValue = this.wrapInnerValue.bind(this);
+      this.evaluate = this.evaluate.bind(this);
+      this.node = node;
+      this.name = this.node instanceof Element ? this.node.getAttribute("_name") : null;
+      this.parent = parent ?? null;
+      this.root = this.parent === null ? this : this.parent.root;
+      if (this.parent === null) this.path = [];
+      else if (pathFromParent === void 0) {
+        this.path = [...this.parent.path, 0];
+      } else {
+        this.path = [...this.parent.path, pathFromParent];
+      }
+      this.pathString = `/${this.path.join("/")}`;
+      this.tagName = node instanceof Element ? node.tagName.toLowerCase() : null;
+      this.attributes = isElement(node) ? Array.from(node.attributes) : null;
+      const { childNodes } = node;
+      let positionnedChildrenCount = 0;
+      const mutableSubtrees = /* @__PURE__ */ new Map();
+      Array.from(childNodes).filter((node2) => {
+        if (isElement(node2)) return true;
+        if (isText(node2)) return true;
+        return false;
+      }).forEach((childNode) => {
+        if (childNode instanceof Text) {
+          mutableSubtrees.set(
+            positionnedChildrenCount,
+            new Tree(childNode, this, positionnedChildrenCount)
+          );
+          positionnedChildrenCount += 1;
+        } else {
+          const propertyName = childNode.getAttribute("_name");
+          if (propertyName === null) {
+            mutableSubtrees.set(
+              positionnedChildrenCount,
+              new Tree(childNode, this, positionnedChildrenCount)
+            );
+            positionnedChildrenCount += 1;
+          } else {
+            mutableSubtrees.set(
+              propertyName,
+              new Tree(childNode, this, propertyName)
+            );
+          }
+        }
+      });
+      this.subtrees = mutableSubtrees;
+      this.children = Array.from(this.subtrees.values());
+      if (this.tagName === null) {
+        this.type = "text";
+      } else if (this.tagName === "null" /* NULL */) {
+        this.type = "null";
+      } else if (this.tagName === "boolean" /* BOOLEAN */) {
+        this.type = "boolean";
+      } else if (this.tagName === "number" /* NUMBER */) {
+        this.type = "number";
+      } else if (this.tagName === "string" /* STRING */) {
+        this.type = "string";
+      } else if (this.tagName === "text" /* TEXT */) {
+        this.type = "text";
+      } else if (this.tagName === "nodelist" /* NODELIST */) {
+        this.type = "nodelist";
+      } else if (this.tagName === "array" /* ARRAY */) {
+        this.type = "array";
+      } else if (this.tagName === "record" /* RECORD */) {
+        this.type = "record";
+      } else if (isInEnum(TransformerTagName, this.tagName)) {
+        this.type = "transformer";
+      } else {
+        this.type = "element";
+      }
+    }
+    initValue() {
+      const { type } = this;
+      let currentValue;
+      if (type === "null") {
+        currentValue = null;
+      } else if (type === "boolean") {
+        currentValue = false;
+      } else if (type === "number") {
+        currentValue = 0;
+      } else if (type === "string") {
+        currentValue = "";
+      } else if (type === "text") {
+        currentValue = this.node.textContent;
+      } else if (type === "element") {
+        currentValue = document.createDocumentFragment().childNodes;
+      } else if (type === "nodelist") {
+        currentValue = document.createDocumentFragment().childNodes;
+      } else if (type === "array") {
+        currentValue = [];
+      } else if (type === "record") {
+        currentValue = {};
+      } else if (type === "transformer") {
+        currentValue = [];
+      } else {
+        currentValue = null;
+      }
+      return currentValue;
+    }
+    getInnerValue(initialValue) {
+      const { subtrees } = this;
+      const innerValue = Array.from(subtrees.entries()).reduce((currentValue, [subpath, subTree]) => {
+        if (subTree.type === "transformer") {
+          const evaluated = subTree.evaluate();
+          return evaluated(currentValue);
+        }
+        if (currentValue === null || typeof currentValue === "boolean" || typeof currentValue === "number" || typeof currentValue === "string" || currentValue instanceof Text || currentValue instanceof Element) {
+          const evaluated = subTree.evaluate();
+          if (evaluated === null || typeof evaluated === "boolean" || typeof evaluated === "number" || typeof evaluated === "string" || Array.isArray(evaluated) || isRecord(evaluated)) {
+            return evaluated;
+          }
+          const frag = document.createDocumentFragment();
+          frag.append(`${currentValue}`);
+          if (evaluated instanceof Element || evaluated instanceof Text) {
+            frag.append(evaluated);
+            return frag.childNodes;
+          }
+          frag.append(...Array.from(evaluated));
+          return frag.childNodes;
+        }
+        if (Array.isArray(currentValue)) {
+          if (typeof subpath === "string") return currentValue;
+          return [...currentValue, subTree.evaluate()];
+        }
+        if (currentValue instanceof NodeList) {
+          const evaluated = subTree.evaluate();
+          if (evaluated instanceof Element || evaluated instanceof Text) {
+            const frag = document.createDocumentFragment();
+            frag.append(...Array.from(currentValue), evaluated);
+            return frag.childNodes;
+          }
+          if (evaluated instanceof NodeList) {
+            const frag = document.createDocumentFragment();
+            frag.append(
+              ...Array.from(currentValue),
+              ...Array.from(evaluated)
+            );
+            return frag.childNodes;
+          }
+          if (evaluated === null || typeof evaluated === "string" || typeof evaluated === "number" || typeof evaluated === "boolean") {
+            const frag = document.createDocumentFragment();
+            frag.append(...Array.from(currentValue), `${evaluated}`);
+            return frag.childNodes;
+          }
+          if (Array.isArray(evaluated)) return [...Array.from(currentValue), ...evaluated];
+          return { ...evaluated };
+        }
+        if (typeof subpath === "number") return currentValue;
+        return {
+          ...currentValue,
+          [subpath]: subTree.evaluate()
+        };
+      }, initialValue);
+      return innerValue;
+    }
+    wrapInnerValue(innerValue) {
+      const { type, node } = this;
+      if (type === "transformer") return (contextValue) => {
+        console.log(`I am a transformer. My name is ${this.tagName}.`);
+        console.log("I have this innerValue (these are my params):");
+        console.log(innerValue);
+        console.log("And this context value:");
+        console.log(contextValue);
+        return contextValue;
+      };
+      if (type === "null") return null;
+      if (type === "boolean") return !isFalsy(innerValue);
+      if (type === "number") return parseFloat(`${innerValue}`);
+      if (type === "string") return `${innerValue}`;
+      if (type === "array") {
+        if (Array.isArray(innerValue)) return innerValue;
+        if (innerValue instanceof NodeList) {
+          return [...Array.from(innerValue)];
+        }
+        return [innerValue];
+      }
+      if (type === "record") {
+        if (isRecord(innerValue)) return innerValue;
+        return {};
+      }
+      if (type === "text") return document.createTextNode(`${innerValue}`);
+      if (type === "element") {
+        const wrapper = node.cloneNode();
+        if (innerValue instanceof NodeList) {
+          wrapper.append(...Array.from(innerValue));
+          return wrapper;
+        }
+        if (innerValue instanceof Element || innerValue instanceof Text || typeof innerValue === "string") {
+          wrapper.append(innerValue);
+          return wrapper;
+        }
+        if (innerValue === null || typeof innerValue === "number" || typeof innerValue === "boolean") {
+          wrapper.append(`${innerValue}`);
+          return wrapper;
+        }
+        return wrapper;
+      }
+      if (innerValue instanceof NodeList) return innerValue;
+      if (innerValue instanceof Element || innerValue instanceof Text || typeof innerValue === "string") {
+        const frag2 = document.createDocumentFragment();
+        frag2.append(innerValue);
+        return frag2.childNodes;
+      }
+      if (innerValue === null || typeof innerValue === "string" || typeof innerValue === "number" || typeof innerValue === "boolean") {
+        const frag2 = document.createDocumentFragment();
+        frag2.append(`${innerValue}`);
+        return frag2.childNodes;
+      }
+      const frag = document.createDocumentFragment();
+      return frag.childNodes;
+    }
+    evaluate() {
+      const init = this.initValue();
+      const inner = this.getInnerValue(init);
+      const wrapped = this.wrapInnerValue(inner);
+      return wrapped;
+    }
+  }
+  HyperJson2.Tree = Tree;
+})(HyperJson || (HyperJson = {}));
+
+export {
+  HyperJson
+};

package/chunks/chunk-LCLAV6Q2.js

@@ -0,0 +1 @@
+var t=(e=>(e.NODE="Node.js",e.BROWSER="Browser",e.DENO="Deno",e.REACT_NATIVE="React Native",e.ELECTRON="Electron",e.CLOUDFLARE="Cloudflare Workers",e.AWS_LAMBDA="AWS Lambda",e))(t||{});function o(){return typeof process<"u"&&typeof process.versions<"u"&&typeof process.versions.node<"u"?"Node.js":typeof window<"u"&&typeof window.document<"u"?"Browser":typeof Deno<"u"?"Deno":typeof process<"u"&&typeof navigator.userAgent=="string"&&/ReactNative/.test(navigator.userAgent)?"React Native":typeof process<"u"&&typeof process.versions<"u"&&typeof process.version.electron<"u"?"Electron":typeof self<"u"&&typeof self.addEventListener=="function"&&typeof Headers<"u"?"Cloudflare Workers":typeof AWS<"u"&&typeof AWS.Lambda<"u"?"AWS Lambda":null}async function u(){let n=o();return["Browser","Electron"].includes(n)?window.document:new(await import("jsdom")).JSDOM().window.document}export{t as a,o as b,u as c};

package/chunks/chunk-LF4VYSOT.js

@@ -0,0 +1,68 @@
+import {
+  require_dist_cjs4 as require_dist_cjs
+} from "./chunk-IZP4VIFZ.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export,
+  __toESM
+} from "./chunk-KH45J4DC.js";
+
+// src/node/@aws-s3/storage/directory/remove-dir/index.ts
+var remove_dir_exports = {};
+__export(remove_dir_exports, {
+  removeDir: () => removeDir
+});
+var import_client_s3 = __toESM(require_dist_cjs(), 1);
+async function removeDir(client, bucketName, directoryPath, options) {
+  const {
+    listObjectsOptions,
+    deleteObjectsOptions,
+    ignoreMissing = true
+  } = options ?? {};
+  const prefix = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+  let continuationToken;
+  let anyFound = false;
+  try {
+    do {
+      const listResp = await client.send(
+        new import_client_s3.ListObjectsV2Command({
+          Bucket: bucketName,
+          Prefix: prefix,
+          ContinuationToken: continuationToken,
+          ...listObjectsOptions
+        })
+      );
+      const keys = (listResp.Contents ?? []).map((o) => o.Key).filter(Boolean);
+      if (keys.length) {
+        anyFound = true;
+        for (let i = 0; i < keys.length; i += 1e3) {
+          const chunk = keys.slice(i, i + 1e3);
+          await client.send(
+            new import_client_s3.DeleteObjectsCommand({
+              Bucket: bucketName,
+              Delete: { Objects: chunk.map((Key) => ({ Key })) },
+              ...deleteObjectsOptions
+            })
+          );
+        }
+      }
+      continuationToken = listResp.IsTruncated ? listResp.NextContinuationToken : void 0;
+    } while (continuationToken);
+    if (!anyFound && !ignoreMissing) {
+      return Outcome.makeFailure(`No objects found for prefix "${prefix}".`);
+    }
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  removeDir,
+  remove_dir_exports
+};

package/chunks/{chunk-2JKV6KXE.js → chunk-LUETT72P.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-S32K7POB.js";
 import {
   Arrays
-} from "./chunk-FVFYLT5T.js";
+} from "./chunk-H5HM5EBO.js";
 
 // src/agnostic/misc/lorem-ipsum/index.ts
 var LoremIpsum;

package/chunks/chunk-LUZ7ZWWJ.js

@@ -0,0 +1,40 @@
+import {
+  remove_exports
+} from "./chunk-5CYREVPP.js";
+import {
+  stat_exports
+} from "./chunk-FR3BXMR5.js";
+import {
+  upload_exports
+} from "./chunk-FTOEQNF6.js";
+import {
+  copy_exports
+} from "./chunk-Z2VDSEND.js";
+import {
+  download_exports
+} from "./chunk-QKK6WQDI.js";
+import {
+  move_exports
+} from "./chunk-54B7VIY6.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-5B7VSD44.js → chunk-LVPFSXKA.js}

@@ -2,16 +2,16 @@ import {
   Cast,
   Tree,
   Utils
-} from "./chunk-HFH6DXXC.js";
+} from "./chunk-6LY5FJXY.js";
+import {
+  Serialize
+} from "./chunk-SXRWMH3U.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";

package/chunks/chunk-LYMZZ4BB.js

@@ -0,0 +1,22 @@
+import {
+  Crossenv
+} from "./chunk-GDYVCEWA.js";
+import {
+  Errors
+} from "./chunk-WH6BPDAC.js";
+
+// src/shared/errors/index.ts
+var register = Errors.Register.from({
+  ["no-window-document-on-runtime" /* NO_DOCUMENT */]: {
+    message: `Runtime '${Crossenv.detectRuntime()}' does not provide a Document object, cannot complete.`,
+    detailsMaker: () => void 0
+  },
+  ["no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */]: {
+    message: `Please provide a Document object since none are found on runtime '${Crossenv.detectRuntime()}'`,
+    detailsMaker: (tips) => tips
+  }
+});
+
+export {
+  register
+};

package/chunks/{chunk-7U5NS3AR.js → chunk-M6B5J46K.js}

@@ -1,12 +1,12 @@
 import {
   formatImage
-} from "./chunk-SJFY537W.js";
+} from "./chunk-ME7RF24X.js";
 import {
   transform
-} from "./chunk-XEMFIV2W.js";
+} from "./chunk-KBOL3LMK.js";
 import {
   __export
-} from "./chunk-NZLE2WMY.js";
+} from "./chunk-KH45J4DC.js";
 
 // src/node/images/prepare/index.ts
 var prepare_exports = {};