@quilted/create 0.2.43 → 0.2.44

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

@@ -1,70 +1,75 @@
-import { __exports as sync } from '../../../../../../../../_virtual/sync4.mjs';
-import '../../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.mjs';
-import './common.mjs';
-import './reader.mjs';
-import { __exports as out } from '../../../../../../../../_virtual/index6.mjs';
-import { __exports as common$1 } from '../../../../../../../../_virtual/common.mjs';
-import { __exports as reader } from '../../../../../../../../_virtual/reader2.mjs';
+import { __exports as sync } from '../../../../../../../../_virtual/sync5.mjs';
+import { __require as requireOut } from '../../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.mjs';
+import { __require as requireCommon } from './common.mjs';
+import { __require as requireReader } from './reader.mjs';
 
-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 = 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 = 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 !== undefined) {
-      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 !== undefined) {
+        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 === undefined ? undefined : entry.path);
+      }
     }
-    if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
-      this._pushToQueue(fullpath, base === undefined ? undefined : 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/esm/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.mjs

@@ -1,32 +1,39 @@
 import { __exports as settings } from '../../../../../../../_virtual/settings2.mjs';
 import path__default from 'node:path';
-import '../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.mjs';
-import { __exports as out } from '../../../../../../../_virtual/index6.mjs';
+import { __require as requireOut } from '../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.mjs';
 
-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, undefined);
-    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, undefined);
+      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/esm/node_modules/.pnpm/arg@5.0.2/node_modules/arg/index.mjs

@@ -1,126 +1,130 @@
-import { getDefaultExportFromCjs } from '../../../../../_virtual/_commonjsHelpers.mjs';
-
-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');
-    }
-    if (key.length === 1) {
-      throw new ArgError(`argument key must have a name; singular '-' keys are not allowed: ${key}`, 'ARG_CONFIG_NONAME_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 (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];
   }
-  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;
+  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');
     }
-    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] === '-') {
-      /* eslint-disable operator-linebreak */
-      const separatedArguments = wholeArg[1] === '-' || wholeArg.length === 2 ? [wholeArg] : wholeArg.slice(1).split('').map(a => `-${a}`);
-      /* eslint-enable operator-linebreak */
+    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] === '-') {
+        /* eslint-disable operator-linebreak */
+        const separatedArguments = wholeArg[1] === '-' || wholeArg.length === 2 ? [wholeArg] : wholeArg.slice(1).split('').map(a => `-${a}`);
+        /* eslint-enable operator-linebreak */
 
-      for (let j = 0; j < separatedArguments.length; j++) {
-        const arg = separatedArguments[j];
-        const [originalArgName, argStr] = arg[1] === '-' ? arg.split(/=(.*)/, 2) : [arg, undefined];
-        let argName = originalArgName;
-        while (argName in aliases) {
-          argName = aliases[argName];
-        }
-        if (!(argName in handlers)) {
-          if (permissive) {
-            result._.push(arg);
-            continue;
-          } else {
-            throw new ArgError(`unknown or unexpected option: ${originalArgName}`, 'ARG_UNKNOWN_OPTION');
+        for (let j = 0; j < separatedArguments.length; j++) {
+          const arg = separatedArguments[j];
+          const [originalArgName, argStr] = arg[1] === '-' ? arg.split(/=(.*)/, 2) : [arg, undefined];
+          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 === undefined) {
-          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');
+          if (!(argName in handlers)) {
+            if (permissive) {
+              result._.push(arg);
+              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 (but was followed by another short argument): ${originalArgName}`, 'ARG_MISSING_REQUIRED_SHORTARG');
+          }
+          if (isFlag) {
+            result[argName] = type(true, argName, result[argName]);
+          } else if (argStr === undefined) {
+            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]);
           }
-          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.flag = fn => {
+    fn[flagSymbol] = true;
+    return fn;
+  };
 
-// Utility types
-arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
+  // Utility types
+  arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
 
-// Expose error class
-arg.ArgError = ArgError;
-var arg_1 = arg;
-const parseArguments = /*@__PURE__*/getDefaultExportFromCjs(arg_1);
+  // Expose error class
+  arg.ArgError = ArgError;
+  arg_1 = arg;
+  return arg_1;
+}
 
-export { parseArguments as default };
+export { requireArg as __require };

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

@@ -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 };
+export { requireBalancedMatch as __require };