@quilted/create 0.1.90 → 0.2.1

package/build/esnext/node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.esnext

@@ -1,70 +1,53 @@
 import Queue from '../../../yocto-queue@1.0.0/node_modules/yocto-queue/index.esnext';
 
 function pLimit(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
-	}
-
-	const queue = new Queue();
-	let activeCount = 0;
-
-	const next = () => {
-		activeCount--;
-
-		if (queue.size > 0) {
-			queue.dequeue()();
-		}
-	};
-
-	const run = async (fn, resolve, args) => {
-		activeCount++;
-
-		const result = (async () => fn(...args))();
-
-		resolve(result);
-
-		try {
-			await result;
-		} catch {}
-
-		next();
-	};
-
-	const enqueue = (fn, resolve, args) => {
-		queue.enqueue(run.bind(undefined, fn, resolve, args));
-
-		(async () => {
-			// This function needs to wait until the next microtask before comparing
-			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-			// when the run function is dequeued and called. The comparison in the if-statement
-			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-			await Promise.resolve();
-
-			if (activeCount < concurrency && queue.size > 0) {
-				queue.dequeue()();
-			}
-		})();
-	};
-
-	const generator = (fn, ...args) => new Promise(resolve => {
-		enqueue(fn, resolve, args);
-	});
-
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount,
-		},
-		pendingCount: {
-			get: () => queue.size,
-		},
-		clearQueue: {
-			value: () => {
-				queue.clear();
-			},
-		},
-	});
-
-	return generator;
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve) => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
 }
 
 export { pLimit as default };

package/build/esnext/node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.esnext

@@ -1,50 +1,34 @@
 import pLimit from '../../../p-limit@4.0.0/node_modules/p-limit/index.esnext';
 
 class EndError extends Error {
-	constructor(value) {
-		super();
-		this.value = value;
-	}
+  constructor(value) {
+    super();
+    this.value = value;
+  }
 }
-
-// The input can also be a promise, so we await it.
 const testElement = async (element, tester) => tester(await element);
-
-// The input can also be a promise, so we `Promise.all()` them both.
-const finder = async element => {
-	const values = await Promise.all(element);
-	if (values[1] === true) {
-		throw new EndError(values[0]);
-	}
-
-	return false;
+const finder = async (element) => {
+  const values = await Promise.all(element);
+  if (values[1] === true) {
+    throw new EndError(values[0]);
+  }
+  return false;
 };
-
-async function pLocate(
-	iterable,
-	tester,
-	{
-		concurrency = Number.POSITIVE_INFINITY,
-		preserveOrder = true,
-	} = {},
-) {
-	const limit = pLimit(concurrency);
-
-	// Start all the promises concurrently with optional limit.
-	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
-
-	// Check the promises either serially or concurrently.
-	const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
-
-	try {
-		await Promise.all(items.map(element => checkLimit(finder, element)));
-	} catch (error) {
-		if (error instanceof EndError) {
-			return error.value;
-		}
-
-		throw error;
-	}
+async function pLocate(iterable, tester, {
+  concurrency = Number.POSITIVE_INFINITY,
+  preserveOrder = true
+} = {}) {
+  const limit = pLimit(concurrency);
+  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(items.map((element) => checkLimit(finder, element)));
+  } catch (error) {
+    if (error instanceof EndError) {
+      return error.value;
+    }
+    throw error;
+  }
 }
 
 export { pLocate as default };

package/build/esnext/node_modules/.pnpm/path-type@4.0.0/node_modules/path-type/index.esnext

@@ -1,48 +1,41 @@
-import { __exports as pathType } from '../../../../../_virtual/index4.esnext';
-import require$$0 from 'node:util';
-import fs__default from 'node:fs';
+import { __exports as pathType } from '../../../../../_virtual/index3.esnext';
+import require$$0 from 'util';
+import fs__default from 'fs';
 
-const {promisify} = require$$0;
+const { promisify } = require$$0;
 const fs = fs__default;
-
 async function isType(fsStatType, statsMethodName, filePath) {
-	if (typeof filePath !== 'string') {
-		throw new TypeError(`Expected a string, got ${typeof filePath}`);
-	}
-
-	try {
-		const stats = await promisify(fs[fsStatType])(filePath);
-		return stats[statsMethodName]();
-	} catch (error) {
-		if (error.code === 'ENOENT') {
-			return false;
-		}
-
-		throw error;
-	}
+  if (typeof filePath !== "string") {
+    throw new TypeError(`Expected a string, got ${typeof filePath}`);
+  }
+  try {
+    const stats = await promisify(fs[fsStatType])(filePath);
+    return stats[statsMethodName]();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
 }
-
 function isTypeSync(fsStatType, statsMethodName, filePath) {
-	if (typeof filePath !== 'string') {
-		throw new TypeError(`Expected a string, got ${typeof filePath}`);
-	}
-
-	try {
-		return fs[fsStatType](filePath)[statsMethodName]();
-	} catch (error) {
-		if (error.code === 'ENOENT') {
-			return false;
-		}
-
-		throw error;
-	}
+  if (typeof filePath !== "string") {
+    throw new TypeError(`Expected a string, got ${typeof filePath}`);
+  }
+  try {
+    return fs[fsStatType](filePath)[statsMethodName]();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
 }
-
-pathType.isFile = isType.bind(null, 'stat', 'isFile');
-pathType.isDirectory = isType.bind(null, 'stat', 'isDirectory');
-pathType.isSymlink = isType.bind(null, 'lstat', 'isSymbolicLink');
-pathType.isFileSync = isTypeSync.bind(null, 'statSync', 'isFile');
-pathType.isDirectorySync = isTypeSync.bind(null, 'statSync', 'isDirectory');
-pathType.isSymlinkSync = isTypeSync.bind(null, 'lstatSync', 'isSymbolicLink');
+pathType.isFile = isType.bind(null, "stat", "isFile");
+pathType.isDirectory = isType.bind(null, "stat", "isDirectory");
+pathType.isSymlink = isType.bind(null, "lstat", "isSymbolicLink");
+pathType.isFileSync = isTypeSync.bind(null, "statSync", "isFile");
+pathType.isDirectorySync = isTypeSync.bind(null, "statSync", "isDirectory");
+pathType.isSymlinkSync = isTypeSync.bind(null, "lstatSync", "isSymbolicLink");
 
 export { pathType as default };

package/build/esnext/node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.esnext

@@ -1,19 +1,14 @@
-import path__default from 'node:path';
+import path__default from 'path';
 
 const path = path__default;
-const WIN_SLASH = '\\\\/';
+const WIN_SLASH = "\\\\/";
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-
-/**
- * Posix glob regex
- */
-
-const DOT_LITERAL = '\\.';
-const PLUS_LITERAL = '\\+';
-const QMARK_LITERAL = '\\?';
-const SLASH_LITERAL = '\\/';
-const ONE_CHAR = '(?=.)';
-const QMARK = '[^/]';
+const DOT_LITERAL = "\\.";
+const PLUS_LITERAL = "\\+";
+const QMARK_LITERAL = "\\?";
+const SLASH_LITERAL = "\\/";
+const ONE_CHAR = "(?=.)";
+const QMARK = "[^/]";
 const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
 const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
 const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
@@ -23,7 +18,6 @@ const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
 const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
 const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
 const STAR = `${QMARK}*?`;
-
 const POSIX_CHARS = {
   DOT_LITERAL,
   PLUS_LITERAL,
@@ -41,14 +35,8 @@ const POSIX_CHARS = {
   STAR,
   START_ANCHOR
 };
-
-/**
- * Windows glob regex
- */
-
 const WINDOWS_CHARS = {
   ...POSIX_CHARS,
-
   SLASH_LITERAL: `[${WIN_SLASH}]`,
   QMARK: WIN_NO_SLASH,
   STAR: `${WIN_NO_SLASH}*?`,
@@ -61,32 +49,25 @@ const WINDOWS_CHARS = {
   START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
   END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
 };
-
-/**
- * POSIX Bracket Regex
- */
-
 const POSIX_REGEX_SOURCE = {
-  alnum: 'a-zA-Z0-9',
-  alpha: 'a-zA-Z',
-  ascii: '\\x00-\\x7F',
-  blank: ' \\t',
-  cntrl: '\\x00-\\x1F\\x7F',
-  digit: '0-9',
-  graph: '\\x21-\\x7E',
-  lower: 'a-z',
-  print: '\\x20-\\x7E ',
-  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
-  space: ' \\t\\r\\n\\v\\f',
-  upper: 'A-Z',
-  word: 'A-Za-z0-9_',
-  xdigit: 'A-Fa-f0-9'
+  alnum: "a-zA-Z0-9",
+  alpha: "a-zA-Z",
+  ascii: "\\x00-\\x7F",
+  blank: " \\t",
+  cntrl: "\\x00-\\x1F\\x7F",
+  digit: "0-9",
+  graph: "\\x21-\\x7E",
+  lower: "a-z",
+  print: "\\x20-\\x7E ",
+  punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+  space: " \\t\\r\\n\\v\\f",
+  upper: "A-Z",
+  word: "A-Za-z0-9_",
+  xdigit: "A-Fa-f0-9"
 };
-
 var constants = {
   MAX_LENGTH: 1024 * 64,
   POSIX_REGEX_SOURCE,
-
   // regular expressions
   REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
   REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
@@ -94,85 +75,117 @@ var constants = {
   REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
   REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
   REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-
   // Replace globs with equivalent patterns to reduce parsing time.
   REPLACEMENTS: {
-    '***': '*',
-    '**/**': '**',
-    '**/**/**': '**'
+    "***": "*",
+    "**/**": "**",
+    "**/**/**": "**"
   },
-
   // Digits
-  CHAR_0: 48, /* 0 */
-  CHAR_9: 57, /* 9 */
-
+  CHAR_0: 48,
+  /* 0 */
+  CHAR_9: 57,
+  /* 9 */
   // Alphabet chars.
-  CHAR_UPPERCASE_A: 65, /* A */
-  CHAR_LOWERCASE_A: 97, /* a */
-  CHAR_UPPERCASE_Z: 90, /* Z */
-  CHAR_LOWERCASE_Z: 122, /* z */
-
-  CHAR_LEFT_PARENTHESES: 40, /* ( */
-  CHAR_RIGHT_PARENTHESES: 41, /* ) */
-
-  CHAR_ASTERISK: 42, /* * */
-
+  CHAR_UPPERCASE_A: 65,
+  /* A */
+  CHAR_LOWERCASE_A: 97,
+  /* a */
+  CHAR_UPPERCASE_Z: 90,
+  /* Z */
+  CHAR_LOWERCASE_Z: 122,
+  /* z */
+  CHAR_LEFT_PARENTHESES: 40,
+  /* ( */
+  CHAR_RIGHT_PARENTHESES: 41,
+  /* ) */
+  CHAR_ASTERISK: 42,
+  /* * */
   // Non-alphabetic chars.
-  CHAR_AMPERSAND: 38, /* & */
-  CHAR_AT: 64, /* @ */
-  CHAR_BACKWARD_SLASH: 92, /* \ */
-  CHAR_CARRIAGE_RETURN: 13, /* \r */
-  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
-  CHAR_COLON: 58, /* : */
-  CHAR_COMMA: 44, /* , */
-  CHAR_DOT: 46, /* . */
-  CHAR_DOUBLE_QUOTE: 34, /* " */
-  CHAR_EQUAL: 61, /* = */
-  CHAR_EXCLAMATION_MARK: 33, /* ! */
-  CHAR_FORM_FEED: 12, /* \f */
-  CHAR_FORWARD_SLASH: 47, /* / */
-  CHAR_GRAVE_ACCENT: 96, /* ` */
-  CHAR_HASH: 35, /* # */
-  CHAR_HYPHEN_MINUS: 45, /* - */
-  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
-  CHAR_LEFT_CURLY_BRACE: 123, /* { */
-  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
-  CHAR_LINE_FEED: 10, /* \n */
-  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
-  CHAR_PERCENT: 37, /* % */
-  CHAR_PLUS: 43, /* + */
-  CHAR_QUESTION_MARK: 63, /* ? */
-  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
-  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
-  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
-  CHAR_SEMICOLON: 59, /* ; */
-  CHAR_SINGLE_QUOTE: 39, /* ' */
-  CHAR_SPACE: 32, /*   */
-  CHAR_TAB: 9, /* \t */
-  CHAR_UNDERSCORE: 95, /* _ */
-  CHAR_VERTICAL_LINE: 124, /* | */
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
-
+  CHAR_AMPERSAND: 38,
+  /* & */
+  CHAR_AT: 64,
+  /* @ */
+  CHAR_BACKWARD_SLASH: 92,
+  /* \ */
+  CHAR_CARRIAGE_RETURN: 13,
+  /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: 94,
+  /* ^ */
+  CHAR_COLON: 58,
+  /* : */
+  CHAR_COMMA: 44,
+  /* , */
+  CHAR_DOT: 46,
+  /* . */
+  CHAR_DOUBLE_QUOTE: 34,
+  /* " */
+  CHAR_EQUAL: 61,
+  /* = */
+  CHAR_EXCLAMATION_MARK: 33,
+  /* ! */
+  CHAR_FORM_FEED: 12,
+  /* \f */
+  CHAR_FORWARD_SLASH: 47,
+  /* / */
+  CHAR_GRAVE_ACCENT: 96,
+  /* ` */
+  CHAR_HASH: 35,
+  /* # */
+  CHAR_HYPHEN_MINUS: 45,
+  /* - */
+  CHAR_LEFT_ANGLE_BRACKET: 60,
+  /* < */
+  CHAR_LEFT_CURLY_BRACE: 123,
+  /* { */
+  CHAR_LEFT_SQUARE_BRACKET: 91,
+  /* [ */
+  CHAR_LINE_FEED: 10,
+  /* \n */
+  CHAR_NO_BREAK_SPACE: 160,
+  /* \u00A0 */
+  CHAR_PERCENT: 37,
+  /* % */
+  CHAR_PLUS: 43,
+  /* + */
+  CHAR_QUESTION_MARK: 63,
+  /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: 62,
+  /* > */
+  CHAR_RIGHT_CURLY_BRACE: 125,
+  /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: 93,
+  /* ] */
+  CHAR_SEMICOLON: 59,
+  /* ; */
+  CHAR_SINGLE_QUOTE: 39,
+  /* ' */
+  CHAR_SPACE: 32,
+  /*   */
+  CHAR_TAB: 9,
+  /* \t */
+  CHAR_UNDERSCORE: 95,
+  /* _ */
+  CHAR_VERTICAL_LINE: 124,
+  /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+  /* \uFEFF */
   SEP: path.sep,
-
   /**
    * Create EXTGLOB_CHARS
    */
-
   extglobChars(chars) {
     return {
-      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
-      '?': { type: 'qmark', open: '(?:', close: ')?' },
-      '+': { type: 'plus', open: '(?:', close: ')+' },
-      '*': { type: 'star', open: '(?:', close: ')*' },
-      '@': { type: 'at', open: '(?:', close: ')' }
+      "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+      "?": { type: "qmark", open: "(?:", close: ")?" },
+      "+": { type: "plus", open: "(?:", close: ")+" },
+      "*": { type: "star", open: "(?:", close: ")*" },
+      "@": { type: "at", open: "(?:", close: ")" }
     };
   },
-
   /**
    * Create GLOB_CHARS
    */
-
   globChars(win32) {
     return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
   }