@quilted/create 0.1.90 → 0.2.1

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

@@ -1,30 +1,32 @@
 import { __exports as settings } from '../../../../../../../_virtual/settings2.mjs';
-import path__default from 'node:path';
+import path__default from 'path';
 import '../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.mjs';
-import { __exports as out } from '../../../../../../../_virtual/index7.mjs';
+import { __exports as out } from '../../../../../../../_virtual/index6.mjs';
 
-Object.defineProperty(settings, "__esModule", { value: true });
+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;
-    }
+  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;

package/build/esm/node_modules/.pnpm/arg@5.0.2/node_modules/arg/index.mjs

@@ -1,191 +1,118 @@
 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);
-	}
+  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'
-			);
-		}
-
-		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;
-		}
-
-		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'
-						);
-					}
-				}
-
-				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]);
-				}
-			}
-		} else {
-			result._.push(wholeArg);
-		}
-	}
-
-	return result;
+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');
+    }
+    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;
+    }
+    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');
+          }
+        }
+        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]);
+        }
+      }
+    } else {
+      result._.push(wholeArg);
+    }
+  }
+  return result;
 }
-
-arg.flag = (fn) => {
-	fn[flagSymbol] = true;
-	return fn;
+arg.flag = fn => {
+  fn[flagSymbol] = true;
+  return fn;
 };
 
 // Utility types
@@ -193,9 +120,7 @@ arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
 
 // Expose error class
 arg.ArgError = ArgError;
-
 var arg_1 = arg;
+var parseArguments = /*@__PURE__*/getDefaultExportFromCjs(arg_1);
 
-var arg$1 = /*@__PURE__*/getDefaultExportFromCjs(arg_1);
-
-export { arg$1 as default };
+export { parseArguments as default };

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

@@ -2,9 +2,7 @@ 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],
@@ -13,50 +11,42 @@ function balanced(a, b, str) {
     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) {
+    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 ];
+        result = [begs.pop(), bi];
       } else {
         beg = begs.pop();
         if (beg < left) {
           left = beg;
           right = bi;
         }
-
         bi = str.indexOf(b, i + 1);
       }
-
       i = ai < bi && ai >= 0 ? ai : bi;
     }
-
     if (begs.length) {
-      result = [ left, right ];
+      result = [left, right];
     }
   }
-
   return result;
 }
 

package/build/esm/node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.mjs

@@ -1,71 +1,45 @@
 import { b as balancedMatch } from '../../../balanced-match@1.0.2/node_modules/balanced-match/index.mjs';
 
 var balanced = balancedMatch;
-
 var braceExpansion = expandTop;
-
-var escSlash = '\0SLASH'+Math.random()+'\0';
-var escOpen = '\0OPEN'+Math.random()+'\0';
-var escClose = '\0CLOSE'+Math.random()+'\0';
-var escComma = '\0COMMA'+Math.random()+'\0';
-var escPeriod = '\0PERIOD'+Math.random()+'\0';
-
+var escSlash = '\0SLASH' + Math.random() + '\0';
+var escOpen = '\0OPEN' + Math.random() + '\0';
+var escClose = '\0CLOSE' + Math.random() + '\0';
+var escComma = '\0COMMA' + Math.random() + '\0';
+var escPeriod = '\0PERIOD' + Math.random() + '\0';
 function numeric(str) {
-  return parseInt(str, 10) == str
-    ? parseInt(str, 10)
-    : str.charCodeAt(0);
+  return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
 }
-
 function escapeBraces(str) {
-  return str.split('\\\\').join(escSlash)
-            .split('\\{').join(escOpen)
-            .split('\\}').join(escClose)
-            .split('\\,').join(escComma)
-            .split('\\.').join(escPeriod);
+  return str.split('\\\\').join(escSlash).split('\\{').join(escOpen).split('\\}').join(escClose).split('\\,').join(escComma).split('\\.').join(escPeriod);
 }
-
 function unescapeBraces(str) {
-  return str.split(escSlash).join('\\')
-            .split(escOpen).join('{')
-            .split(escClose).join('}')
-            .split(escComma).join(',')
-            .split(escPeriod).join('.');
+  return str.split(escSlash).join('\\').split(escOpen).join('{').split(escClose).join('}').split(escComma).join(',').split(escPeriod).join('.');
 }
 
-
 // Basically just str.split(","), but handling cases
 // where we have nested braced sections, which should be
 // treated as individual members, like {a,{b,c},d}
 function parseCommaParts(str) {
-  if (!str)
-    return [''];
-
+  if (!str) return [''];
   var parts = [];
   var m = balanced('{', '}', str);
-
-  if (!m)
-    return str.split(',');
-
+  if (!m) return str.split(',');
   var pre = m.pre;
   var body = m.body;
   var post = m.post;
   var p = pre.split(',');
-
-  p[p.length-1] += '{' + body + '}';
+  p[p.length - 1] += '{' + body + '}';
   var postParts = parseCommaParts(post);
   if (post.length) {
-    p[p.length-1] += postParts.shift();
+    p[p.length - 1] += postParts.shift();
     p.push.apply(p, postParts);
   }
-
   parts.push.apply(parts, p);
-
   return parts;
 }
-
 function expandTop(str) {
-  if (!str)
-    return [];
+  if (!str) return [];
 
   // I don't know why Bash 4.3 does this, but it does.
   // Anything starting with {} will have the first two bytes preserved
@@ -76,39 +50,31 @@ function expandTop(str) {
   if (str.substr(0, 2) === '{}') {
     str = '\\{\\}' + str.substr(2);
   }
-
   return expand(escapeBraces(str), true).map(unescapeBraces);
 }
-
 function embrace(str) {
   return '{' + str + '}';
 }
 function isPadded(el) {
   return /^-?0\d/.test(el);
 }
-
 function lte(i, y) {
   return i <= y;
 }
 function gte(i, y) {
   return i >= y;
 }
-
 function expand(str, isTop) {
   var expansions = [];
-
   var m = balanced('{', '}', str);
   if (!m) return [str];
 
   // no need to expand pre, since it is guaranteed to be free of brace-sets
   var pre = m.pre;
-  var post = m.post.length
-    ? expand(m.post, false)
-    : [''];
-
-  if (/\$$/.test(m.pre)) {    
+  var post = m.post.length ? expand(m.post, false) : [''];
+  if (/\$$/.test(m.pre)) {
     for (var k = 0; k < post.length; k++) {
-      var expansion = pre+ '{' + m.body + '}' + post[k];
+      var expansion = pre + '{' + m.body + '}' + post[k];
       expansions.push(expansion);
     }
   } else {
@@ -124,7 +90,6 @@ function expand(str, isTop) {
       }
       return [str];
     }
-
     var n;
     if (isSequence) {
       n = m.body.split(/\.\./);
@@ -134,7 +99,7 @@ function expand(str, isTop) {
         // x{{a,b}}y ==> x{a}y x{b}y
         n = expand(n[0], false).map(embrace);
         if (n.length === 1) {
-          return post.map(function(p) {
+          return post.map(function (p) {
             return m.pre + n[0] + p;
           });
         }
@@ -144,14 +109,11 @@ function expand(str, isTop) {
     // at this point, n is the parts, and we know it's not a comma set
     // with a single entry.
     var N;
-
     if (isSequence) {
       var x = numeric(n[0]);
       var y = numeric(n[1]);
       var width = Math.max(n[0].length, n[1].length);
-      var incr = n.length == 3
-        ? Math.abs(numeric(n[2]))
-        : 1;
+      var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
       var test = lte;
       var reverse = y < x;
       if (reverse) {
@@ -159,25 +121,19 @@ function expand(str, isTop) {
         test = gte;
       }
       var pad = n.some(isPadded);
-
       N = [];
-
       for (var i = x; test(i, y); i += incr) {
         var c;
         if (isAlphaSequence) {
           c = String.fromCharCode(i);
-          if (c === '\\')
-            c = '';
+          if (c === '\\') c = '';
         } else {
           c = String(i);
           if (pad) {
             var need = width - c.length;
             if (need > 0) {
               var z = new Array(need + 1).join('0');
-              if (i < 0)
-                c = '-' + z + c.slice(1);
-              else
-                c = z + c;
+              if (i < 0) c = '-' + z + c.slice(1);else c = z + c;
             }
           }
         }
@@ -185,21 +141,17 @@ function expand(str, isTop) {
       }
     } else {
       N = [];
-
       for (var j = 0; j < n.length; j++) {
         N.push.apply(N, expand(n[j], false));
       }
     }
-
     for (var j = 0; j < N.length; j++) {
       for (var k = 0; k < post.length; k++) {
         var expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion)
-          expansions.push(expansion);
+        if (!isTop || isSequence || expansion) expansions.push(expansion);
       }
     }
   }
-
   return expansions;
 }