@design-edito/tools 0.0.33 → 0.1.2

package/chunks/chunk-5LNUCDQ6.js

@@ -0,0 +1,132 @@
+// src/agnostic/misc/logs/index.ts
+import chalk from "chalk";
+var Logs;
+((Logs2) => {
+  function makeTextBlock(text, vPadding = 1, hPadding = vPadding) {
+    const lines = text.split("\n");
+    const longestLine = Math.max(...lines.map((line) => line.length));
+    const textBlockArr = new Array(lines.length + 2 * vPadding).fill(null).map(() => new Array(longestLine + hPadding * 2).fill(" "));
+    lines.forEach((line, linePos) => {
+      const chars = line.split("");
+      textBlockArr[linePos + vPadding]?.splice(hPadding, chars.length, ...chars);
+    });
+    return textBlockArr.map((lineArr) => lineArr.join("")).join("\n");
+  }
+  Logs2.makeTextBlock = makeTextBlock;
+  Logs2.styles = {
+    regular: (text) => text,
+    light: (text) => chalk.grey(text),
+    danger: (text) => chalk.bold.bgRed.whiteBright(makeTextBlock(`/!\\
+
+${text}
+`, 2, 6)),
+    important: (text) => chalk.bold(text),
+    title: (text) => `# ${chalk.bold.underline(`${text}
+`)}`,
+    info: (text) => chalk.blueBright(text),
+    error: (text) => chalk.red(text),
+    warning: (text) => chalk.yellow(text)
+  };
+  const logsTimeOrigin = /* @__PURE__ */ new Date();
+  class Log {
+    type;
+    data;
+    time;
+    stack;
+    constructor(type, data) {
+      this.type = type;
+      this.data = data;
+      this.time = /* @__PURE__ */ new Date();
+      this.stack = new Error().stack ?? "";
+    }
+    get displayTime() {
+      return this.time.toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        weekday: "short",
+        hour: "numeric",
+        minute: "numeric",
+        second: "numeric"
+      }) + `:${this.time.getMilliseconds()}`;
+    }
+    get elapsedTimeMs() {
+      return (this.time.getTime() - logsTimeOrigin.getTime()) / 1e3;
+    }
+    get displayStack() {
+      return this.stack.split("\n").map((line) => line.trim()).slice(4).join("\n");
+    }
+  }
+  class Logger {
+    _private_threads = /* @__PURE__ */ new Map();
+    constructor() {
+      this.dir = this.dir.bind(this);
+      this.error = this.error.bind(this);
+      this.log = this.log.bind(this);
+      this.warn = this.warn.bind(this);
+      this.setLog = this.setLog.bind(this);
+      this.print = this.print.bind(this);
+      this.printThreads = this.printThreads.bind(this);
+    }
+    // assert         (thread: string = '', ...args: ConsoleMethodsParams['assert'])         { this.setLog(thread, 'assert', args) }
+    // count          (thread: string = '', ...args: ConsoleMethodsParams['count'])          { this.setLog(thread, 'count', args) }
+    // countReset     (thread: string = '', ...args: ConsoleMethodsParams['countReset'])     { this.setLog(thread, 'countReset', args) }
+    // debug          (thread: string = '', ...args: ConsoleMethodsParams['debug'])          { this.setLog(thread, 'debug', args) }
+    dir(thread = "", ...args) {
+      this.setLog(thread, "dir", args);
+    }
+    // dirxml         (thread: string = '', ...args: ConsoleMethodsParams['dirxml'])         { this.setLog(thread, 'dirxml', args) }
+    error(thread = "", ...args) {
+      this.setLog(thread, "error", args);
+    }
+    // group          (thread: string = '', ...args: ConsoleMethodsParams['group'])          { this.setLog(thread, 'group', args) }
+    // groupCollapsed (thread: string = '', ...args: ConsoleMethodsParams['groupCollapsed']) { this.setLog(thread, 'groupCollapsed', args) }
+    // groupEnd       (thread: string = '', ...args: ConsoleMethodsParams['groupEnd'])       { this.setLog(thread, 'groupEnd', args) }
+    // info           (thread: string = '', ...args: ConsoleMethodsParams['info'])           { this.setLog(thread, 'info', args) }
+    log(thread = "", ...args) {
+      this.setLog(thread, "log", args);
+    }
+    // table          (thread: string = '', ...args: ConsoleMethodsParams['table'])          { this.setLog(thread, 'table', args) }
+    // time           (thread: string = '', ...args: ConsoleMethodsParams['time'])           { this.setLog(thread, 'time', args) }
+    // timeEnd        (thread: string = '', ...args: ConsoleMethodsParams['timeEnd'])        { this.setLog(thread, 'timeEnd', args) }
+    // trace          (thread: string = '', ...args: ConsoleMethodsParams['trace'])          { this.setLog(thread, 'trace', args) }
+    warn(thread = "", ...args) {
+      this.setLog(thread, "warn", args);
+    }
+    setLog(threadName, type, data) {
+      const log = new Log(type, data);
+      const thread = this._private_threads.get(threadName) ?? [];
+      this._private_threads.set(threadName, [...thread, log]);
+      return this;
+    }
+    print(threadFilter, withStack) {
+      const allLogs = Array.from(this._private_threads.entries()).map(([threadName, logs]) => logs.map((log) => ({ threadName, log }))).flat().sort((eltA, eltB) => eltA.log.time.getTime() - eltB.log.time.getTime()).filter(({ threadName }) => {
+        if (threadFilter === void 0) return true;
+        return threadName === threadFilter;
+      });
+      allLogs.forEach(({ threadName, log }) => {
+        console.log(`%c${threadName}`, "font-weight: 800; color: white; background: black; padding: 4px;", `+${log.elapsedTimeMs}s \u2013`, log.displayTime);
+        if (withStack === true) console.log(`%c${log.displayStack}`, "color: grey; font-size: inherit;");
+        console[log.type](...log.data);
+        console.log("");
+      });
+    }
+    printThreads(withStack) {
+      Array.from(this._private_threads.entries()).forEach(([threadName, logs]) => {
+        console.group(`%c${threadName}`, "font-weight: 800; color: white; background: black; padding: 4px;");
+        logs.forEach((log) => {
+          console.log(`+${log.elapsedTimeMs}s \u2013`, log.displayTime);
+          if (withStack === true) console.log(`%c${log.displayStack}`, "color: grey; font-size: inherit;");
+          console[log.type](...log.data);
+          console.log("");
+        });
+        console.groupEnd();
+      });
+    }
+  }
+  Logs2.Logger = Logger;
+})(Logs || (Logs = {}));
+
+export {
+  Logs
+};

package/chunks/chunk-7AWTHZLY.js

@@ -0,0 +1,12 @@
+// src/agnostic/misc/get-current-downlink/index.ts
+function getCurrentDownlink() {
+  if (typeof window !== "object") return void 0;
+  if (typeof window.navigator !== "object") return void 0;
+  const navigator = window.navigator;
+  const connection = navigator?.connection ?? navigator?.mozConnection ?? navigator?.webkitConnection;
+  return connection?.downlink;
+}
+
+export {
+  getCurrentDownlink
+};

package/chunks/chunk-7DBNMU6N.js

@@ -0,0 +1,14 @@
+// src/node/files/read-write/index.ts
+import { promises as fs } from "node:fs";
+async function readWrite(path, editor, ...options) {
+  const [readOptions, writeOptions] = options;
+  const read = await fs.readFile(path, readOptions);
+  const edited = editor(read);
+  const actualWriteOptions = options.length === 2 ? writeOptions : readOptions;
+  await fs.writeFile(path, edited, actualWriteOptions);
+  return edited;
+}
+
+export {
+  readWrite
+};

package/chunks/chunk-COVPTTAD.js

@@ -0,0 +1,10 @@
+// src/agnostic/strings/to-alphanum/index.ts
+function toAlphanum(string, replacer = "") {
+  const replaced = string.replace(/[^a-z0-9]/igm, replacer);
+  if (replacer.length === 0) return replaced;
+  return replaced.replace(new RegExp(`${replacer}+`, "igm"), replacer);
+}
+
+export {
+  toAlphanum
+};

package/chunks/chunk-DNIOWD7K.js

@@ -0,0 +1,8 @@
+// src/agnostic/numbers/absolute-modulo/index.ts
+function absoluteModulo(nbr, modulo) {
+  return (nbr % modulo + modulo) % modulo;
+}
+
+export {
+  absoluteModulo
+};

package/chunks/chunk-DQNJQBC6.js

@@ -0,0 +1,10 @@
+// src/agnostic/async/wait/index.ts
+async function wait(durationMs) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(true), durationMs);
+  });
+}
+
+export {
+  wait
+};

package/chunks/chunk-E6MSDKON.js

@@ -0,0 +1,13 @@
+// src/agnostic/objects/enums/is-in-enum/index.ts
+function isInEnum(enumObj, value) {
+  const keys = Object.keys(enumObj);
+  const values = Object.values(enumObj);
+  const numericValues = values.filter((val) => typeof val === "number");
+  const cleanKeys = keys.filter((key) => !numericValues.includes(parseInt(key, 10)));
+  const cleanValues = cleanKeys.map((cleanKey) => enumObj[cleanKey]);
+  return cleanValues.includes(value);
+}
+
+export {
+  isInEnum
+};

package/chunks/chunk-EDVNAV3G.js

@@ -0,0 +1,72 @@
+// src/agnostic/css/generate-nice-color/index.ts
+var niceColors = [
+  "fuchsia",
+  "teal",
+  "aliceblue",
+  "bisque",
+  "blueviolet",
+  "burlywood",
+  "chocolate",
+  "coral",
+  "cornflowerblue",
+  "crimson",
+  "darkblue",
+  "darkgoldenrod",
+  "darkkhaki",
+  "darkmagenta",
+  "darkolivegreen",
+  "darkorange",
+  "darkorchid",
+  "darkred",
+  "darksalmon",
+  "darkslateblue",
+  "darkslategray",
+  "darkviolet",
+  "deeppink",
+  "deepskyblue",
+  "dodgerblue",
+  "firebrick",
+  "floralwhite",
+  "gainsboro",
+  "gold",
+  "hotpink",
+  "indianred",
+  "indigo",
+  "khaki",
+  "lavender",
+  "lightcoral",
+  "lightgreen",
+  "lightsalmon",
+  "lightsteelblue",
+  "limegreen",
+  "magenta",
+  "mediumseagreen",
+  "mediumspringgreen",
+  "mediumvioletred",
+  "moccasin",
+  "orangered",
+  "orchid",
+  "palegoldenrod",
+  "palevioletred",
+  "peachpuff",
+  "peru",
+  "plum",
+  "royalblue",
+  "sandybrown",
+  "springgreen",
+  "tan",
+  "thistle",
+  "tomato",
+  "violet",
+  "wheat",
+  "yellowgreen"
+];
+var generateNiceColor = () => {
+  const pos = Math.floor(Math.random() * niceColors.length);
+  return niceColors[pos];
+};
+
+export {
+  niceColors,
+  generateNiceColor
+};

package/chunks/chunk-EW46EXFB.js

@@ -0,0 +1,8 @@
+// src/agnostic/numbers/interpolate/index.ts
+function interpolate(ratio, bound1, bound2) {
+  return bound1 + ratio * (bound2 - bound1);
+}
+
+export {
+  interpolate
+};

package/chunks/chunk-FPEW3A27.js

@@ -0,0 +1,14 @@
+// src/agnostic/objects/validation/index.ts
+var Validation;
+((Validation2) => {
+  function fromPartial(obj, partial) {
+    return Object.entries(partial).every(([key, val]) => {
+      return obj[key] === val;
+    });
+  }
+  Validation2.fromPartial = fromPartial;
+})(Validation || (Validation = {}));
+
+export {
+  Validation
+};

package/chunks/chunk-GJOU3UAL.js

@@ -0,0 +1,36 @@
+// src/agnostic/misc/crossenv/index.ts
+var Crossenv;
+((Crossenv2) => {
+  let RuntimeName;
+  ((RuntimeName2) => {
+    RuntimeName2["NODE"] = "Node.js";
+    RuntimeName2["BROWSER"] = "Browser";
+    RuntimeName2["DENO"] = "Deno";
+    RuntimeName2["REACT_NATIVE"] = "React Native";
+    RuntimeName2["ELECTRON"] = "Electron";
+    RuntimeName2["CLOUDFLARE"] = "Cloudflare Workers";
+    RuntimeName2["AWS_LAMBDA"] = "AWS Lambda";
+  })(RuntimeName = Crossenv2.RuntimeName || (Crossenv2.RuntimeName = {}));
+  function detectRuntime() {
+    if (typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined") return "Node.js" /* NODE */;
+    if (typeof window !== "undefined" && typeof window.document !== "undefined") return "Browser" /* BROWSER */;
+    if (typeof Deno !== "undefined") return "Deno" /* DENO */;
+    if (typeof process !== "undefined" && typeof navigator.userAgent === "string" && /ReactNative/.test(navigator.userAgent)) return "React Native" /* REACT_NATIVE */;
+    if (typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.version.electron !== "undefined") return "Electron" /* ELECTRON */;
+    if (typeof self !== "undefined" && typeof self.addEventListener === "function" && typeof Headers !== "undefined") return "Cloudflare Workers" /* CLOUDFLARE */;
+    if (typeof AWS !== "undefined" && typeof AWS.Lambda !== "undefined") return "AWS Lambda" /* AWS_LAMBDA */;
+    return null;
+  }
+  Crossenv2.detectRuntime = detectRuntime;
+  function getDocument() {
+    const runtime = detectRuntime();
+    const runtimesWithGlobalWindow = ["Browser" /* BROWSER */, "Electron" /* ELECTRON */];
+    const runtimeHasGlobalWindow = runtimesWithGlobalWindow.includes(runtime);
+    return runtimeHasGlobalWindow ? window.document : null;
+  }
+  Crossenv2.getDocument = getDocument;
+})(Crossenv || (Crossenv = {}));
+
+export {
+  Crossenv
+};

package/chunks/chunk-HC6ZOHCS.js

@@ -0,0 +1,14 @@
+// src/agnostic/misc/is-nullish/index.ts
+var nullishValues = [null, void 0];
+function isNullish(val) {
+  return nullishValues.includes(val);
+}
+function isNotNullish(val) {
+  return !isNullish(val);
+}
+
+export {
+  nullishValues,
+  isNullish,
+  isNotNullish
+};

package/chunks/chunk-HGCG2J77.js

@@ -0,0 +1,122 @@
+import {
+  matchesSome
+} from "./chunk-LQFKUNVQ.js";
+
+// src/node/files/subpaths/index.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+var Subpaths;
+((Subpaths2) => {
+  Subpaths2.defaultListContext = {
+    depth: 0,
+    lstats: null,
+    rootPath: null
+  };
+  Subpaths2.fillListContext = (input) => {
+    return {
+      ...Subpaths2.defaultListContext,
+      ...input
+    };
+  };
+  Subpaths2.defaultListOptions = {
+    directories: true,
+    files: true,
+    symlinks: true,
+    hidden: true,
+    followSimlinks: false,
+    dedupeSimlinksContents: false,
+    maxDepth: Infinity,
+    returnRelative: false,
+    exclude: null,
+    include: null,
+    filter: () => true
+  };
+  Subpaths2.fillOptions = (input) => {
+    return {
+      ...Subpaths2.defaultListOptions,
+      ...input
+    };
+  };
+  async function list(...args) {
+    const [inputPath, _options] = args;
+    const options = (0, Subpaths2.fillOptions)(_options ?? {});
+    const subpaths = await listAbsoluteSubpaths(...args);
+    return options.returnRelative ? subpaths.map((subpath) => path.relative(inputPath, subpath)) : subpaths;
+  }
+  Subpaths2.list = list;
+  async function listAbsoluteSubpaths(inputPath, _options = {}, __private_context = {}) {
+    const options = (0, Subpaths2.fillOptions)(_options);
+    const _private_context = (0, Subpaths2.fillListContext)(__private_context);
+    if (_private_context.rootPath === null) {
+      _private_context.rootPath = inputPath;
+    }
+    const subpaths = [];
+    if (_private_context.depth > options.maxDepth) return subpaths;
+    try {
+      const pathStat = _private_context.lstats ?? await fs.lstat(inputPath);
+      if (!pathStat.isDirectory()) return subpaths;
+    } catch (err) {
+      return subpaths;
+    }
+    const childrenRelPaths = await fs.readdir(inputPath);
+    await Promise.all(childrenRelPaths.map(async (childRelPath) => {
+      const childAbsPath = path.join(inputPath, childRelPath);
+      const childRelFromRootPath = path.relative(_private_context.rootPath ?? inputPath, childAbsPath);
+      const childLstats = await fs.lstat(childAbsPath);
+      try {
+        const isDirectory = childLstats.isDirectory();
+        const isSymlink = childLstats.isSymbolicLink();
+        const isFile = !isDirectory && !isSymlink;
+        const isHidden = path.basename(childAbsPath).startsWith(".");
+        const type = isDirectory ? "directory" : isSymlink ? "symlink" : "file";
+        if (isDirectory && options.directories === false) throw true;
+        if (isSymlink && options.symlinks === false) throw false;
+        if (isFile && options.files === false) throw false;
+        if (isHidden && options.hidden === false) throw false;
+        const realPath = isSymlink ? await fs.realpath(childAbsPath) : childAbsPath;
+        const childPathForFilters = options.returnRelative ? childRelFromRootPath : childAbsPath;
+        const isInExclude = matchesSome(childPathForFilters, options.exclude ?? []);
+        const isInInclude = matchesSome(childPathForFilters, options.include ?? []);
+        if (isInExclude && !isInInclude) throw false;
+        const isInFilter = await options.filter(childPathForFilters, { type, hidden: isHidden, realPath });
+        if (!isInFilter) throw true;
+        if (isSymlink) {
+          if (options.followSimlinks === false) subpaths.push(childAbsPath);
+          else {
+            const childSubpaths = await listAbsoluteSubpaths(realPath, options, {
+              ..._private_context,
+              depth: _private_context.depth + 1
+            });
+            subpaths.push(realPath, ...childSubpaths);
+          }
+        } else {
+          if (isDirectory) {
+            const childSubpaths = await listAbsoluteSubpaths(childAbsPath, options, {
+              ..._private_context,
+              depth: _private_context.depth + 1,
+              lstats: childLstats
+            });
+            subpaths.push(childAbsPath, ...childSubpaths);
+          } else {
+            subpaths.push(childAbsPath);
+          }
+        }
+      } catch (err) {
+        if (typeof err !== "boolean") throw new Error(`This try/catch block should only throw booleans`);
+        const shouldDiveDeeper = err;
+        if (!shouldDiveDeeper) return [];
+        const childSubpaths = await listAbsoluteSubpaths(childAbsPath, options, {
+          ..._private_context,
+          depth: _private_context.depth + 1,
+          lstats: childLstats
+        });
+        subpaths.push(...childSubpaths);
+      }
+    }));
+    return options.dedupeSimlinksContents ? Array.from(new Set(subpaths)) : subpaths;
+  }
+})(Subpaths || (Subpaths = {}));
+
+export {
+  Subpaths
+};

package/chunks/chunk-IFD7GSGK.js

@@ -0,0 +1,130 @@
+import {
+  register
+} from "./chunk-KQT5CTGF.js";
+import {
+  Crossenv
+} from "./chunk-GJOU3UAL.js";
+
+// src/agnostic/html/sanitize/index.ts
+var Sanitize;
+((Sanitize2) => {
+  Sanitize2.defaultOptions = { depth: 20 };
+  function sanitize(inputStr, options = Sanitize2.defaultOptions) {
+    const actualDocument = options.documentObj ?? Crossenv.getDocument();
+    if (actualDocument === null) throw register.getError("no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */, "See documentObj in the options object");
+    const wrapperDiv = actualDocument.createElement("div");
+    const { inputFreeTransform } = options;
+    wrapperDiv.innerHTML = inputFreeTransform !== void 0 ? inputFreeTransform(inputStr) : inputStr;
+    const sanitizedWrapper = sanitizeElement(wrapperDiv, options);
+    const returned = sanitizedWrapper?.innerHTML;
+    return returned ?? "";
+  }
+  Sanitize2.sanitize = sanitize;
+  function sanitizeElement(element, options = Sanitize2.defaultOptions) {
+    const actualDocument = options.documentObj ?? Crossenv.getDocument();
+    if (actualDocument === null) throw register.getError("no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */, "See documentObj in the options object");
+    const { tagName, attributes, childNodes } = element;
+    const {
+      allowedTags = [],
+      allowedAttributes = {},
+      forbiddenTags = [],
+      forbiddenAttributes = {},
+      depth = 20,
+      verbose = false
+    } = options;
+    if (depth <= 0) {
+      console.warn("Max depth reached");
+      return null;
+    }
+    const normalizedTagName = tagName.toLowerCase().trim();
+    const tagIsInForbidden = forbiddenTags.includes("*") || forbiddenTags.includes(normalizedTagName);
+    if (tagIsInForbidden) {
+      if (verbose === true) console.warn(tagName, "tag is forbidden");
+      return null;
+    }
+    const tagIsInAllowed = allowedTags.includes("*") || allowedTags.includes(normalizedTagName);
+    if (!tagIsInAllowed) {
+      if (verbose === true) console.warn(tagName, "tag is not allowed");
+      return null;
+    }
+    const returnedElement = actualDocument.createElement(tagName);
+    const returnedAttributes = Array.from(attributes).filter(({ name: attributeName, value: attributeValue }) => {
+      const allTagsForbiddenAttributes = forbiddenAttributes["*"] ?? [];
+      const thisTagForbiddenAttributes = forbiddenAttributes[normalizedTagName] ?? [];
+      const mergedForbiddenAttributes = [...allTagsForbiddenAttributes, ...thisTagForbiddenAttributes];
+      const isInForbidden = mergedForbiddenAttributes.some(({
+        attributeName: nameTester,
+        attributeValues: valTesters
+      }) => {
+        if (typeof nameTester === "string" && nameTester !== "*" && attributeName !== nameTester) return false;
+        if (typeof nameTester !== "string" && !nameTester.test(attributeName)) return false;
+        if (valTesters === void 0) {
+          if (verbose === true) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
+          return true;
+        }
+        if (valTesters.includes("*")) {
+          if (verbose === true) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
+          return true;
+        }
+        return valTesters.some((valTester) => {
+          if (typeof valTester === "string" && attributeValue === valTester) {
+            if (verbose === true) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
+            return true;
+          }
+          if (typeof valTester !== "string" && valTester.test(attributeValue)) {
+            if (verbose === true) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
+            return true;
+          }
+          return false;
+        });
+      });
+      if (isInForbidden) return false;
+      const allTagsAllowedAttributes = allowedAttributes["*"] ?? [];
+      const thisTagAllowedAttributes = allowedAttributes[normalizedTagName] ?? [];
+      const mergedAllowedAttributes = [...allTagsAllowedAttributes, ...thisTagAllowedAttributes];
+      let latestNotAllowedReason = [tagName, "has no allowed attributes"];
+      const isInAllowed = mergedAllowedAttributes.some(({
+        attributeName: nameTester,
+        attributeValues: valTesters
+      }) => {
+        if (typeof nameTester === "string" && nameTester !== "*" && attributeName !== nameTester) {
+          latestNotAllowedReason = [attributeName, "attribute on", tagName, "tag is not allowed"];
+          return false;
+        }
+        if (typeof nameTester !== "string" && !nameTester.test(attributeName)) {
+          latestNotAllowedReason = [attributeName, "attribute on", tagName, "tag is not allowed"];
+          return false;
+        }
+        if (valTesters === void 0) return true;
+        if (valTesters.includes("*")) return true;
+        return valTesters.some((valTester) => {
+          if (typeof valTester === "string" && attributeValue === valTester) return true;
+          if (typeof valTester !== "string" && valTester.test(attributeValue)) return true;
+          latestNotAllowedReason = [attributeValue, "value for", attributeName, "attribute on", tagName, "tag is not allowed"];
+          return false;
+        });
+      });
+      if (!isInAllowed) {
+        if (verbose === true) console.warn(...latestNotAllowedReason);
+        return false;
+      }
+      return true;
+    });
+    returnedAttributes.forEach(({ name, value }) => {
+      returnedElement.setAttribute(name, value);
+    });
+    const sanitizedChildNodes = Array.from(childNodes).map((node) => {
+      if (node.nodeType === Node.ELEMENT_NODE) return sanitizeElement(node, { ...options, depth: depth - 1 });
+      else if (node.nodeType === Node.TEXT_NODE) return node;
+      else if (options.keepComments === true && node.nodeType === Node.COMMENT_NODE) return node;
+      return null;
+    }).filter((elt) => elt !== null);
+    returnedElement.replaceChildren(...sanitizedChildNodes);
+    return returnedElement;
+  }
+  Sanitize2.sanitizeElement = sanitizeElement;
+})(Sanitize || (Sanitize = {}));
+
+export {
+  Sanitize
+};

package/chunks/chunk-JQXNEJAP.js

@@ -0,0 +1,18 @@
+// src/agnostic/strings/normalize-indent/index.ts
+function normalizeIndent(input, indentLevel = 0) {
+  const indent = " ".repeat(indentLevel);
+  const lines = input.split("\n");
+  const noIndentLines = lines.map((line) => line.replace(/^\s*/igm, ""));
+  const pipeReplacedLines = noIndentLines.map((line) => {
+    const nbPipeCharsOnLineStart = line.match(/^\|+/igm)?.[0].length ?? 0;
+    const noPipeLine = line.slice(nbPipeCharsOnLineStart);
+    const replacedPipes = " ".repeat(nbPipeCharsOnLineStart);
+    return replacedPipes + noPipeLine;
+  });
+  const normalizedLines = pipeReplacedLines.map((line) => indent + line);
+  return normalizedLines.join("\n");
+}
+
+export {
+  normalizeIndent
+};

package/chunks/chunk-JWBDZPQG.js

@@ -0,0 +1,18 @@
+// src/agnostic/optim/memoize/index.ts
+function memoize(toMemoizeFunc) {
+  let cachedArgs = void 0;
+  let cachedResult = void 0;
+  return function memoized(...args) {
+    const allArgsAreInCache = cachedArgs !== void 0 && args.every((arg, argPos) => cachedArgs[argPos] === arg);
+    const allCachedAreInArgs = cachedArgs !== void 0 && cachedArgs.every((arg, argPos) => args[argPos] === arg);
+    const returnCache = allArgsAreInCache && allCachedAreInArgs;
+    if (returnCache) return cachedResult;
+    const result = toMemoizeFunc(...args);
+    cachedResult = result;
+    return result;
+  };
+}
+
+export {
+  memoize
+};

package/chunks/chunk-K37RALUX.js

@@ -0,0 +1,8 @@
+// src/agnostic/objects/is-object/index.ts
+function isObject(unk) {
+  return typeof unk === "object" && unk !== null;
+}
+
+export {
+  isObject
+};