@quilted/create 0.2.43 → 0.2.45

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/sync.esnext

@@ -1,65 +1,70 @@
 import { __exports as sync } from '../../../../../../../../_virtual/sync5.esnext';
-import '../../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
-import './common.esnext';
-import './reader.esnext';
-import { __exports as out } from '../../../../../../../../_virtual/index6.esnext';
-import { __exports as common$1 } from '../../../../../../../../_virtual/common.esnext';
-import { __exports as reader } from '../../../../../../../../_virtual/reader2.esnext';
+import { __require as requireOut } from '../../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
+import { __require as requireCommon } from './common.esnext';
+import { __require as requireReader } from './reader.esnext';
 
-Object.defineProperty(sync, "__esModule", { value: true });
-const fsScandir = out;
-const common = common$1;
-const reader_1 = reader;
-class SyncReader extends reader_1.default {
-  constructor() {
-    super(...arguments);
-    this._scandir = fsScandir.scandirSync;
-    this._storage = [];
-    this._queue = /* @__PURE__ */ new Set();
-  }
-  read() {
-    this._pushToQueue(this._root, this._settings.basePath);
-    this._handleQueue();
-    return this._storage;
-  }
-  _pushToQueue(directory, base) {
-    this._queue.add({ directory, base });
-  }
-  _handleQueue() {
-    for (const item of this._queue.values()) {
-      this._handleDirectory(item.directory, item.base);
+var hasRequiredSync;
+function requireSync() {
+  if (hasRequiredSync) return sync;
+  hasRequiredSync = 1;
+  Object.defineProperty(sync, "__esModule", { value: true });
+  const fsScandir = requireOut();
+  const common = requireCommon();
+  const reader_1 = requireReader();
+  class SyncReader extends reader_1.default {
+    constructor() {
+      super(...arguments);
+      this._scandir = fsScandir.scandirSync;
+      this._storage = [];
+      this._queue = /* @__PURE__ */ new Set();
     }
-  }
-  _handleDirectory(directory, base) {
-    try {
-      const entries = this._scandir(directory, this._settings.fsScandirSettings);
-      for (const entry of entries) {
-        this._handleEntry(entry, base);
+    read() {
+      this._pushToQueue(this._root, this._settings.basePath);
+      this._handleQueue();
+      return this._storage;
+    }
+    _pushToQueue(directory, base) {
+      this._queue.add({ directory, base });
+    }
+    _handleQueue() {
+      for (const item of this._queue.values()) {
+        this._handleDirectory(item.directory, item.base);
       }
-    } catch (error) {
-      this._handleError(error);
     }
-  }
-  _handleError(error) {
-    if (!common.isFatalError(this._settings, error)) {
-      return;
+    _handleDirectory(directory, base) {
+      try {
+        const entries = this._scandir(directory, this._settings.fsScandirSettings);
+        for (const entry of entries) {
+          this._handleEntry(entry, base);
+        }
+      } catch (error) {
+        this._handleError(error);
+      }
     }
-    throw error;
-  }
-  _handleEntry(entry, base) {
-    const fullpath = entry.path;
-    if (base !== void 0) {
-      entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+    _handleError(error) {
+      if (!common.isFatalError(this._settings, error)) {
+        return;
+      }
+      throw error;
     }
-    if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
-      this._pushToStorage(entry);
+    _handleEntry(entry, base) {
+      const fullpath = entry.path;
+      if (base !== void 0) {
+        entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+      }
+      if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+        this._pushToStorage(entry);
+      }
+      if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+        this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
+      }
     }
-    if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
-      this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
+    _pushToStorage(entry) {
+      this._storage.push(entry);
     }
   }
-  _pushToStorage(entry) {
-    this._storage.push(entry);
-  }
+  sync.default = SyncReader;
+  return sync;
 }
-sync.default = SyncReader;
+
+export { requireSync as __require };

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.esnext

@@ -1,30 +1,37 @@
 import { __exports as settings } from '../../../../../../../_virtual/settings2.esnext';
 import path__default from 'node:path';
-import '../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
-import { __exports as out } from '../../../../../../../_virtual/index6.esnext';
+import { __require as requireOut } from '../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
 
-Object.defineProperty(settings, "__esModule", { value: true });
-const path = path__default;
-const fsScandir = out;
-class Settings {
-  constructor(_options = {}) {
-    this._options = _options;
-    this.basePath = this._getValue(this._options.basePath, void 0);
-    this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
-    this.deepFilter = this._getValue(this._options.deepFilter, null);
-    this.entryFilter = this._getValue(this._options.entryFilter, null);
-    this.errorFilter = this._getValue(this._options.errorFilter, null);
-    this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
-    this.fsScandirSettings = new fsScandir.Settings({
-      followSymbolicLinks: this._options.followSymbolicLinks,
-      fs: this._options.fs,
-      pathSegmentSeparator: this._options.pathSegmentSeparator,
-      stats: this._options.stats,
-      throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
-    });
-  }
-  _getValue(option, value) {
-    return option !== null && option !== void 0 ? option : value;
+var hasRequiredSettings;
+function requireSettings() {
+  if (hasRequiredSettings) return settings;
+  hasRequiredSettings = 1;
+  Object.defineProperty(settings, "__esModule", { value: true });
+  const path = path__default;
+  const fsScandir = requireOut();
+  class Settings {
+    constructor(_options = {}) {
+      this._options = _options;
+      this.basePath = this._getValue(this._options.basePath, void 0);
+      this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
+      this.deepFilter = this._getValue(this._options.deepFilter, null);
+      this.entryFilter = this._getValue(this._options.entryFilter, null);
+      this.errorFilter = this._getValue(this._options.errorFilter, null);
+      this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
+      this.fsScandirSettings = new fsScandir.Settings({
+        followSymbolicLinks: this._options.followSymbolicLinks,
+        fs: this._options.fs,
+        pathSegmentSeparator: this._options.pathSegmentSeparator,
+        stats: this._options.stats,
+        throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+      });
+    }
+    _getValue(option, value) {
+      return option !== null && option !== void 0 ? option : value;
+    }
   }
+  settings.default = Settings;
+  return settings;
 }
-settings.default = Settings;
+
+export { requireSettings as __require };

package/build/esnext/node_modules/.pnpm/arg@5.0.2/node_modules/arg/index.esnext

@@ -1,143 +1,147 @@
-import { getDefaultExportFromCjs } from '../../../../../_virtual/_commonjsHelpers.esnext';
-
-const flagSymbol = Symbol("arg flag");
-class ArgError extends Error {
-  constructor(msg, code) {
-    super(msg);
-    this.name = "ArgError";
-    this.code = code;
-    Object.setPrototypeOf(this, ArgError.prototype);
-  }
-}
-function arg(opts, {
-  argv = process.argv.slice(2),
-  permissive = false,
-  stopAtPositional = false
-} = {}) {
-  if (!opts) {
-    throw new ArgError(
-      "argument specification object is required",
-      "ARG_CONFIG_NO_SPEC"
-    );
-  }
-  const result = { _: [] };
-  const aliases = {};
-  const handlers = {};
-  for (const key of Object.keys(opts)) {
-    if (!key) {
-      throw new ArgError(
-        "argument key cannot be an empty string",
-        "ARG_CONFIG_EMPTY_KEY"
-      );
-    }
-    if (key[0] !== "-") {
-      throw new ArgError(
-        `argument key must start with '-' but found: '${key}'`,
-        "ARG_CONFIG_NONOPT_KEY"
-      );
+var arg_1;
+var hasRequiredArg;
+function requireArg() {
+  if (hasRequiredArg) return arg_1;
+  hasRequiredArg = 1;
+  const flagSymbol = Symbol("arg flag");
+  class ArgError extends Error {
+    constructor(msg, code) {
+      super(msg);
+      this.name = "ArgError";
+      this.code = code;
+      Object.setPrototypeOf(this, ArgError.prototype);
     }
-    if (key.length === 1) {
-      throw new ArgError(
-        `argument key must have a name; singular '-' keys are not allowed: ${key}`,
-        "ARG_CONFIG_NONAME_KEY"
-      );
-    }
-    if (typeof opts[key] === "string") {
-      aliases[key] = opts[key];
-      continue;
-    }
-    let type = opts[key];
-    let isFlag = false;
-    if (Array.isArray(type) && type.length === 1 && typeof type[0] === "function") {
-      const [fn] = type;
-      type = (value, name, prev = []) => {
-        prev.push(fn(value, name, prev[prev.length - 1]));
-        return prev;
-      };
-      isFlag = fn === Boolean || fn[flagSymbol] === true;
-    } else if (typeof type === "function") {
-      isFlag = type === Boolean || type[flagSymbol] === true;
-    } else {
-      throw new ArgError(
-        `type missing or not a function or valid array type: ${key}`,
-        "ARG_CONFIG_VAD_TYPE"
-      );
-    }
-    if (key[1] !== "-" && key.length > 2) {
+  }
+  function arg(opts, {
+    argv = process.argv.slice(2),
+    permissive = false,
+    stopAtPositional = false
+  } = {}) {
+    if (!opts) {
       throw new ArgError(
-        `short argument keys (with a single hyphen) must have only one character: ${key}`,
-        "ARG_CONFIG_SHORTOPT_TOOLONG"
+        "argument specification object is required",
+        "ARG_CONFIG_NO_SPEC"
       );
     }
-    handlers[key] = [type, isFlag];
-  }
-  for (let i = 0, len = argv.length; i < len; i++) {
-    const wholeArg = argv[i];
-    if (stopAtPositional && result._.length > 0) {
-      result._ = result._.concat(argv.slice(i));
-      break;
-    }
-    if (wholeArg === "--") {
-      result._ = result._.concat(argv.slice(i + 1));
-      break;
+    const result = { _: [] };
+    const aliases = {};
+    const handlers = {};
+    for (const key of Object.keys(opts)) {
+      if (!key) {
+        throw new ArgError(
+          "argument key cannot be an empty string",
+          "ARG_CONFIG_EMPTY_KEY"
+        );
+      }
+      if (key[0] !== "-") {
+        throw new ArgError(
+          `argument key must start with '-' but found: '${key}'`,
+          "ARG_CONFIG_NONOPT_KEY"
+        );
+      }
+      if (key.length === 1) {
+        throw new ArgError(
+          `argument key must have a name; singular '-' keys are not allowed: ${key}`,
+          "ARG_CONFIG_NONAME_KEY"
+        );
+      }
+      if (typeof opts[key] === "string") {
+        aliases[key] = opts[key];
+        continue;
+      }
+      let type = opts[key];
+      let isFlag = false;
+      if (Array.isArray(type) && type.length === 1 && typeof type[0] === "function") {
+        const [fn] = type;
+        type = (value, name, prev = []) => {
+          prev.push(fn(value, name, prev[prev.length - 1]));
+          return prev;
+        };
+        isFlag = fn === Boolean || fn[flagSymbol] === true;
+      } else if (typeof type === "function") {
+        isFlag = type === Boolean || type[flagSymbol] === true;
+      } else {
+        throw new ArgError(
+          `type missing or not a function or valid array type: ${key}`,
+          "ARG_CONFIG_VAD_TYPE"
+        );
+      }
+      if (key[1] !== "-" && key.length > 2) {
+        throw new ArgError(
+          `short argument keys (with a single hyphen) must have only one character: ${key}`,
+          "ARG_CONFIG_SHORTOPT_TOOLONG"
+        );
+      }
+      handlers[key] = [type, isFlag];
     }
-    if (wholeArg.length > 1 && wholeArg[0] === "-") {
-      const separatedArguments = wholeArg[1] === "-" || wholeArg.length === 2 ? [wholeArg] : wholeArg.slice(1).split("").map((a) => `-${a}`);
-      for (let j = 0; j < separatedArguments.length; j++) {
-        const arg2 = separatedArguments[j];
-        const [originalArgName, argStr] = arg2[1] === "-" ? arg2.split(/=(.*)/, 2) : [arg2, void 0];
-        let argName = originalArgName;
-        while (argName in aliases) {
-          argName = aliases[argName];
-        }
-        if (!(argName in handlers)) {
-          if (permissive) {
-            result._.push(arg2);
-            continue;
-          } else {
-            throw new ArgError(
-              `unknown or unexpected option: ${originalArgName}`,
-              "ARG_UNKNOWN_OPTION"
-            );
+    for (let i = 0, len = argv.length; i < len; i++) {
+      const wholeArg = argv[i];
+      if (stopAtPositional && result._.length > 0) {
+        result._ = result._.concat(argv.slice(i));
+        break;
+      }
+      if (wholeArg === "--") {
+        result._ = result._.concat(argv.slice(i + 1));
+        break;
+      }
+      if (wholeArg.length > 1 && wholeArg[0] === "-") {
+        const separatedArguments = wholeArg[1] === "-" || wholeArg.length === 2 ? [wholeArg] : wholeArg.slice(1).split("").map((a) => `-${a}`);
+        for (let j = 0; j < separatedArguments.length; j++) {
+          const arg2 = separatedArguments[j];
+          const [originalArgName, argStr] = arg2[1] === "-" ? arg2.split(/=(.*)/, 2) : [arg2, void 0];
+          let argName = originalArgName;
+          while (argName in aliases) {
+            argName = aliases[argName];
           }
-        }
-        const [type, isFlag] = handlers[argName];
-        if (!isFlag && j + 1 < separatedArguments.length) {
-          throw new ArgError(
-            `option requires argument (but was followed by another short argument): ${originalArgName}`,
-            "ARG_MISSING_REQUIRED_SHORTARG"
-          );
-        }
-        if (isFlag) {
-          result[argName] = type(true, argName, result[argName]);
-        } else if (argStr === void 0) {
-          if (argv.length < i + 2 || argv[i + 1].length > 1 && argv[i + 1][0] === "-" && !(argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) && (type === Number || // eslint-disable-next-line no-undef
-          typeof BigInt !== "undefined" && type === BigInt))) {
-            const extended = originalArgName === argName ? "" : ` (alias for ${argName})`;
+          if (!(argName in handlers)) {
+            if (permissive) {
+              result._.push(arg2);
+              continue;
+            } else {
+              throw new ArgError(
+                `unknown or unexpected option: ${originalArgName}`,
+                "ARG_UNKNOWN_OPTION"
+              );
+            }
+          }
+          const [type, isFlag] = handlers[argName];
+          if (!isFlag && j + 1 < separatedArguments.length) {
             throw new ArgError(
-              `option requires argument: ${originalArgName}${extended}`,
-              "ARG_MISSING_REQUIRED_LONGARG"
+              `option requires argument (but was followed by another short argument): ${originalArgName}`,
+              "ARG_MISSING_REQUIRED_SHORTARG"
             );
           }
-          result[argName] = type(argv[i + 1], argName, result[argName]);
-          ++i;
-        } else {
-          result[argName] = type(argStr, argName, result[argName]);
+          if (isFlag) {
+            result[argName] = type(true, argName, result[argName]);
+          } else if (argStr === void 0) {
+            if (argv.length < i + 2 || argv[i + 1].length > 1 && argv[i + 1][0] === "-" && !(argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) && (type === Number || // eslint-disable-next-line no-undef
+            typeof BigInt !== "undefined" && type === BigInt))) {
+              const extended = originalArgName === argName ? "" : ` (alias for ${argName})`;
+              throw new ArgError(
+                `option requires argument: ${originalArgName}${extended}`,
+                "ARG_MISSING_REQUIRED_LONGARG"
+              );
+            }
+            result[argName] = type(argv[i + 1], argName, result[argName]);
+            ++i;
+          } else {
+            result[argName] = type(argStr, argName, result[argName]);
+          }
         }
+      } else {
+        result._.push(wholeArg);
       }
-    } else {
-      result._.push(wholeArg);
     }
+    return result;
   }
-  return result;
+  arg.flag = (fn) => {
+    fn[flagSymbol] = true;
+    return fn;
+  };
+  arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
+  arg.ArgError = ArgError;
+  arg_1 = arg;
+  return arg_1;
 }
-arg.flag = (fn) => {
-  fn[flagSymbol] = true;
-  return fn;
-};
-arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
-arg.ArgError = ArgError;
-var arg_1 = arg;
-const arg$1 = /* @__PURE__ */ getDefaultExportFromCjs(arg_1);
 
-export { arg$1 as default };
+export { requireArg as __require };

package/build/esnext/node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.esnext

@@ -1,53 +1,60 @@
-var balancedMatch = balanced;
-function balanced(a, b, str) {
-  if (a instanceof RegExp) a = maybeMatch(a, str);
-  if (b instanceof RegExp) b = maybeMatch(b, str);
-  var r = range(a, b, str);
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + a.length, r[1]),
-    post: str.slice(r[1] + b.length)
-  };
-}
-function maybeMatch(reg, str) {
-  var m = str.match(reg);
-  return m ? m[0] : null;
-}
-balanced.range = range;
-function range(a, b, str) {
-  var begs, beg, left, right, result;
-  var ai = str.indexOf(a);
-  var bi = str.indexOf(b, ai + 1);
-  var i = ai;
-  if (ai >= 0 && bi > 0) {
-    if (a === b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str.length;
-    while (i >= 0 && !result) {
-      if (i == ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length == 1) {
-        result = [begs.pop(), bi];
-      } else {
-        beg = begs.pop();
-        if (beg < left) {
-          left = beg;
-          right = bi;
+var balancedMatch;
+var hasRequiredBalancedMatch;
+function requireBalancedMatch() {
+  if (hasRequiredBalancedMatch) return balancedMatch;
+  hasRequiredBalancedMatch = 1;
+  balancedMatch = balanced;
+  function balanced(a, b, str) {
+    if (a instanceof RegExp) a = maybeMatch(a, str);
+    if (b instanceof RegExp) b = maybeMatch(b, str);
+    var r = range(a, b, str);
+    return r && {
+      start: r[0],
+      end: r[1],
+      pre: str.slice(0, r[0]),
+      body: str.slice(r[0] + a.length, r[1]),
+      post: str.slice(r[1] + b.length)
+    };
+  }
+  function maybeMatch(reg, str) {
+    var m = str.match(reg);
+    return m ? m[0] : null;
+  }
+  balanced.range = range;
+  function range(a, b, str) {
+    var begs, beg, left, right, result;
+    var ai = str.indexOf(a);
+    var bi = str.indexOf(b, ai + 1);
+    var i = ai;
+    if (ai >= 0 && bi > 0) {
+      if (a === b) {
+        return [ai, bi];
+      }
+      begs = [];
+      left = str.length;
+      while (i >= 0 && !result) {
+        if (i == ai) {
+          begs.push(i);
+          ai = str.indexOf(a, i + 1);
+        } else if (begs.length == 1) {
+          result = [begs.pop(), bi];
+        } else {
+          beg = begs.pop();
+          if (beg < left) {
+            left = beg;
+            right = bi;
+          }
+          bi = str.indexOf(b, i + 1);
         }
-        bi = str.indexOf(b, i + 1);
+        i = ai < bi && ai >= 0 ? ai : bi;
+      }
+      if (begs.length) {
+        result = [left, right];
       }
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-    if (begs.length) {
-      result = [left, right];
     }
+    return result;
   }
-  return result;
+  return balancedMatch;
 }
 
-export { balancedMatch as b };
+export { requireBalancedMatch as __require };