@design-edito/tools 0.1.71 → 0.1.72

package/chunks/chunk-FWR7ZA4M.js

@@ -0,0 +1,44 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/sftp/directory/remove-dir/index.ts
+var remove_dir_exports = {};
+__export(remove_dir_exports, {
+  removeDir: () => removeDir
+});
+async function removeDir(sftp, directoryPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  async function recurse(dir) {
+    const list = await sftp.list(dir);
+    for (const entry of list) {
+      const full = dir.endsWith("/") ? dir + entry.name : `${dir}/${entry.name}`;
+      if (entry.type === "d") {
+        await recurse(full);
+      } else if (entry.type === "-") {
+        await sftp.delete(full);
+      }
+    }
+    await sftp.rmdir(dir);
+  }
+  try {
+    await recurse(directoryPath);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    if (ignoreMissing && (err.code === 2 || err.code === "ENOENT")) {
+      return Outcome.makeSuccess(true);
+    }
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  removeDir,
+  remove_dir_exports
+};

package/chunks/chunk-G2XDDBWE.js

@@ -0,0 +1,31 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/@google-cloud/storage/file/update-metadata/index.ts
+var update_metadata_exports = {};
+__export(update_metadata_exports, {
+  updateFileMetadata: () => updateFileMetadata
+});
+async function updateFileMetadata(bucket, targetPath, metadata, options) {
+  const { fileOptions, metadataOptions } = options ?? {};
+  try {
+    const file = bucket.file(targetPath, fileOptions);
+    await file.setMetadata(metadata, metadataOptions);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  updateFileMetadata,
+  update_metadata_exports
+};

package/chunks/chunk-GDYVCEWA.js

@@ -0,0 +1,38 @@
+import {
+  getDocument
+} from "./chunk-73V5RDSG.js";
+import {
+  getWindow
+} from "./chunk-4GUDL44X.js";
+
+// 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;
+  Crossenv2.getWindow = getWindow;
+  Crossenv2.getDocument = getDocument;
+})(Crossenv || (Crossenv = {}));
+
+export {
+  Crossenv
+};

package/chunks/chunk-GKTDEHC6.js

@@ -0,0 +1,39 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/sftp/directory/move-dir/index.ts
+var move_dir_exports = {};
+__export(move_dir_exports, {
+  moveDir: () => moveDir
+});
+async function moveDir(sftp, sourceDir, targetDir, options) {
+  const { overwrite = false, ensureDir = true } = options ?? {};
+  try {
+    if (ensureDir) {
+      const parentDir = targetDir.substring(0, targetDir.lastIndexOf("/"));
+      if (parentDir) {
+        await sftp.mkdir(parentDir, true);
+      }
+    }
+    if (!overwrite) {
+      const exists = await sftp.exists(targetDir);
+      if (exists) return Outcome.makeFailure(`Target ${targetDir} already exists.`);
+    }
+    await sftp.rename(sourceDir, targetDir);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  moveDir,
+  move_dir_exports
+};

package/chunks/chunk-GZWZ5SSG.js

@@ -0,0 +1,60 @@
+import {
+  revoke_signed_urls_exports
+} from "./chunk-UBJACMOZ.js";
+import {
+  update_metadata_exports
+} from "./chunk-G2XDDBWE.js";
+import {
+  generate_signed_url_exports
+} from "./chunk-6NZOSESD.js";
+import {
+  get_permissions_exports
+} from "./chunk-NXV33ZSC.js";
+import {
+  get_metadata_exports
+} from "./chunk-6STIUASQ.js";
+import {
+  remove_exports
+} from "./chunk-2RFYHF6F.js";
+import {
+  stat_exports
+} from "./chunk-JKAHSFJD.js";
+import {
+  upload_exports
+} from "./chunk-MP6CL7F7.js";
+import {
+  copy_exports
+} from "./chunk-4XS5UIQF.js";
+import {
+  download_exports
+} from "./chunk-MPYCQ5IF.js";
+import {
+  move_exports
+} from "./chunk-XIMUZN5X.js";
+import {
+  exists_exports
+} from "./chunk-BTJ2JXDV.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/@google-cloud/storage/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Copy: () => copy_exports,
+  Download: () => download_exports,
+  Exists: () => exists_exports,
+  GenerateSignedUrl: () => generate_signed_url_exports,
+  GetMetaData: () => get_metadata_exports,
+  GetPermissions: () => get_permissions_exports,
+  Move: () => move_exports,
+  Remove: () => remove_exports,
+  RevokeSignedUrls: () => revoke_signed_urls_exports,
+  Stat: () => stat_exports,
+  UpdateMetadata: () => update_metadata_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  file_exports
+};

package/chunks/chunk-H4NHF72W.js

@@ -0,0 +1,40 @@
+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/download/index.ts
+var download_exports = {};
+__export(download_exports, {
+  download: () => download
+});
+var import_client_s3 = __toESM(require_dist_cjs(), 1);
+async function download(client, bucketName, sourcePath, options) {
+  try {
+    const response = await client.send(
+      new import_client_s3.GetObjectCommand({
+        Bucket: bucketName,
+        Key: sourcePath,
+        ...options
+      })
+    );
+    const stream = response.Body;
+    return Outcome.makeSuccess(stream);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  download,
+  download_exports
+};

package/chunks/chunk-H5HM5EBO.js

@@ -0,0 +1,31 @@
+import {
+  randomPick,
+  randomPickMany
+} from "./chunk-72NLUT3X.js";
+import {
+  findDuplicates
+} from "./chunk-YS6WMSWC.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.js";
+import {
+  make
+} from "./chunk-RLAZR3NL.js";
+import {
+  isArrayOf
+} from "./chunk-6RGDWX4A.js";
+
+// src/agnostic/arrays/index.tsx
+var Arrays;
+((Arrays2) => {
+  Arrays2.findDuplicates = findDuplicates;
+  Arrays2.isArrayOf = isArrayOf;
+  Arrays2.make = make;
+  Arrays2.randomPick = randomPick;
+  Arrays2.randomPickMany = randomPickMany;
+  Arrays2.shuffle = shuffle;
+})(Arrays || (Arrays = {}));
+
+export {
+  Arrays
+};

package/chunks/chunk-HCNRPWKW.js

@@ -0,0 +1,63 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  Errors
+} from "./chunk-WH6BPDAC.js";
+
+// src/agnostic/misc/assert/index.ts
+var Assert;
+((Assert2) => {
+  function makeSuccess(label) {
+    console.info(`\u2705 SUCCESS: "${label}"`);
+  }
+  function makeFailure(label) {
+    throw new Error(`\u{1F6AB} FAILURE: "${label}""`);
+  }
+  async function assert(label, assertion) {
+    if (typeof assertion === "boolean") return assertion ? Outcome.makeSuccess(label) : Outcome.makeFailure(label);
+    else if (typeof assertion === "function") {
+      try {
+        const result = await assertion();
+        if (result === false) return Outcome.makeFailure(label);
+        else return Outcome.makeSuccess(label);
+      } catch (err) {
+        const errStr = Errors.unknownToString(err);
+        return Outcome.makeFailure(`${label} / ${errStr}`);
+      }
+    } else {
+      let assertions;
+      if (Array.isArray(assertion)) {
+        assertions = [...assertion].map((a, p) => [`${p}`, a]);
+      } else if (assertion instanceof Map) {
+        assertions = Array.from(assertion);
+      } else {
+        assertions = Object.entries(assertion);
+      }
+      const allAsserted = await Promise.all(assertions.map(([innerLabel, innerAssertion]) => {
+        const fullLabel = `${label} / ${innerLabel}`;
+        const asserted = assert(fullLabel, innerAssertion);
+        return asserted;
+      }));
+      const allSuccess = allAsserted.every((asserted) => asserted.success);
+      if (allSuccess) return Outcome.makeSuccess(allAsserted.map((e) => e.payload).join("\n"));
+      const failures = allAsserted.filter((asserted) => asserted.success === false);
+      const failuresStr = failures.map((failure) => failure.error).join("\n  ");
+      return Outcome.makeFailure(failuresStr);
+    }
+  }
+  Assert2.assert = assert;
+  async function assertVerbose(label, assertion) {
+    const asserted = await assert(label, assertion);
+    if (asserted?.success) {
+      makeSuccess(asserted.payload);
+      return asserted;
+    }
+    return makeFailure(asserted.error);
+  }
+  Assert2.assertVerbose = assertVerbose;
+})(Assert || (Assert = {}));
+
+export {
+  Assert
+};

package/chunks/chunk-HDGHODNO.js

@@ -0,0 +1,28 @@
+import {
+  list_exports
+} from "./chunk-ZAIWJI6A.js";
+import {
+  move_dir_exports
+} from "./chunk-2UPQ73EE.js";
+import {
+  remove_dir_exports
+} from "./chunk-LF4VYSOT.js";
+import {
+  copy_dir_exports
+} from "./chunk-5WARYKLO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/@aws-s3/storage/directory/index.ts
+var directory_exports = {};
+__export(directory_exports, {
+  CopyDir: () => copy_dir_exports,
+  List: () => list_exports,
+  MoveDir: () => move_dir_exports,
+  RemoveDir: () => remove_dir_exports
+});
+
+export {
+  directory_exports
+};

package/chunks/chunk-HEJV6JIO.js

@@ -0,0 +1,133 @@
+// 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),
+    success: (text) => chalk.greenBright(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-HGDSHJEX.js

@@ -0,0 +1,60 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/sftp/directory/copy-dir/index.ts
+var copy_dir_exports = {};
+__export(copy_dir_exports, {
+  copyDir: () => copyDir
+});
+import { PassThrough } from "node:stream";
+async function copyDir(sftp, sourceDir, targetDir, options) {
+  const {
+    overwrite = false,
+    ensureDir = true,
+    ...transferOptions
+  } = options ?? {};
+  async function recurse(dir) {
+    const list = await sftp.list(dir);
+    for (const entry of list) {
+      const src = dir.endsWith("/") ? dir + entry.name : dir + "/" + entry.name;
+      const rel = src.substring(sourceDir.length + (sourceDir.endsWith("/") ? 0 : 1));
+      const dst = targetDir.endsWith("/") ? targetDir + rel : `${targetDir}/${rel}`;
+      if (entry.type === "d") {
+        if (ensureDir) await sftp.mkdir(dst, true);
+        await recurse(src);
+      } else if (entry.type === "-") {
+        if (!overwrite) {
+          const exists = await sftp.exists(dst);
+          if (exists) throw new Error(`File already exists at ${dst}.`);
+        }
+        if (ensureDir) {
+          const dirPath = dst.substring(0, dst.lastIndexOf("/"));
+          if (dirPath) await sftp.mkdir(dirPath, true);
+        }
+        const pass = new PassThrough();
+        const upload = sftp.put(pass, dst, transferOptions);
+        await sftp.get(src, pass, transferOptions);
+        await upload;
+      }
+    }
+  }
+  try {
+    if (ensureDir) await sftp.mkdir(targetDir, true);
+    await recurse(sourceDir);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copyDir,
+  copy_dir_exports
+};

package/chunks/chunk-HL6LO6QF.js

@@ -0,0 +1,28 @@
+import {
+  list_exports
+} from "./chunk-26V5RC4U.js";
+import {
+  remove_dir_exports
+} from "./chunk-EHLTUOGZ.js";
+import {
+  copy_dir_exports
+} from "./chunk-A3VTK5UF.js";
+import {
+  move_dir_exports
+} from "./chunk-5HE6JLK7.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/ftps/directory/index.ts
+var directory_exports = {};
+__export(directory_exports, {
+  CopyDir: () => copy_dir_exports,
+  List: () => list_exports,
+  MoveDir: () => move_dir_exports,
+  RemoveDir: () => remove_dir_exports
+});
+
+export {
+  directory_exports
+};

package/chunks/chunk-HLUWFMD7.js

@@ -0,0 +1,67 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  Errors
+} from "./chunk-WH6BPDAC.js";
+
+// src/agnostic/misc/assert/index.ts
+var Assert;
+((Assert2) => {
+  function makeSuccess(label) {
+    const formattedLabel = label.split("\n").join("  \n");
+    console.info(`\u2705 SUCCESS:
+${formattedLabel}`);
+  }
+  function makeFailure(label) {
+    const formattedLabel = label.split("\n").join("  \n");
+    throw new Error(`\u{1F6AB} FAILURE:
+${formattedLabel}`);
+  }
+  async function assert(label, assertion) {
+    if (typeof assertion === "boolean") return assertion ? Outcome.makeSuccess(label) : Outcome.makeFailure(label);
+    else if (typeof assertion === "function") {
+      try {
+        const result = await assertion();
+        if (result === false) return Outcome.makeFailure(label);
+        else return Outcome.makeSuccess(label);
+      } catch (err) {
+        const errStr = Errors.unknownToString(err);
+        return Outcome.makeFailure(`${label} / ${errStr}`);
+      }
+    } else {
+      let assertions;
+      if (Array.isArray(assertion)) {
+        assertions = [...assertion].map((a, p) => [`${p}`, a]);
+      } else if (assertion instanceof Map) {
+        assertions = Array.from(assertion);
+      } else {
+        assertions = Object.entries(assertion);
+      }
+      const allAsserted = await Promise.all(assertions.map(([innerLabel, innerAssertion]) => {
+        const fullLabel = `${label} / ${innerLabel}`;
+        const asserted = assert(fullLabel, innerAssertion);
+        return asserted;
+      }));
+      const allSuccess = allAsserted.every((asserted) => asserted.success);
+      if (allSuccess) return Outcome.makeSuccess(allAsserted.map((e) => e.payload).join("\n"));
+      const failures = allAsserted.filter((asserted) => asserted.success === false);
+      const failuresStr = failures.map((failure) => failure.error).join("\n  ");
+      return Outcome.makeFailure(failuresStr);
+    }
+  }
+  Assert2.assert = assert;
+  async function assertVerbose(label, assertion) {
+    const asserted = await assert(label, assertion);
+    if (asserted?.success) {
+      makeSuccess(asserted.payload);
+      return asserted;
+    }
+    return makeFailure(asserted.error);
+  }
+  Assert2.assertVerbose = assertVerbose;
+})(Assert || (Assert = {}));
+
+export {
+  Assert
+};