@quilted/create 0.1.89 → 0.2.0

package/build/esm/node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.mjs

@@ -1,4 +1,4 @@
-import path__default from 'node:path';
+import path__default from 'path';
 import { s as scan_1 } from './scan.mjs';
 import { p as parse_1 } from './parse.mjs';
 import './utils.mjs';
@@ -46,41 +46,51 @@ const picomatch = (glob, options, returnState = false) => {
     };
     return arrayMatcher;
   }
-
   const isState = isObject(glob) && glob.tokens && glob.input;
-
-  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+  if (glob === '' || typeof glob !== 'string' && !isState) {
     throw new TypeError('Expected pattern to be a non-empty string');
   }
-
   const opts = options || {};
   const posix = utils.isWindows(options);
-  const regex = isState
-    ? picomatch.compileRe(glob, options)
-    : picomatch.makeRe(glob, options, false, true);
-
+  const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
   const state = regex.state;
   delete regex.state;
-
   let isIgnored = () => false;
   if (opts.ignore) {
-    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+    const ignoreOpts = {
+      ...options,
+      ignore: null,
+      onMatch: null,
+      onResult: null
+    };
     isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
   }
-
   const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
-    const result = { glob, state, regex, posix, input, output, match, isMatch };
-
+    const {
+      isMatch,
+      match,
+      output
+    } = picomatch.test(input, regex, options, {
+      glob,
+      posix
+    });
+    const result = {
+      glob,
+      state,
+      regex,
+      posix,
+      input,
+      output,
+      match,
+      isMatch
+    };
     if (typeof opts.onResult === 'function') {
       opts.onResult(result);
     }
-
     if (isMatch === false) {
       result.isMatch = false;
       return returnObject ? result : false;
     }
-
     if (isIgnored(input)) {
       if (typeof opts.onIgnore === 'function') {
         opts.onIgnore(result);
@@ -88,17 +98,14 @@ const picomatch = (glob, options, returnState = false) => {
       result.isMatch = false;
       return returnObject ? result : false;
     }
-
     if (typeof opts.onMatch === 'function') {
       opts.onMatch(result);
     }
     return returnObject ? result : true;
   };
-
   if (returnState) {
     matcher.state = state;
   }
-
   return matcher;
 };
 
@@ -119,25 +126,27 @@ const picomatch = (glob, options, returnState = false) => {
  * @api public
  */
 
-picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+picomatch.test = (input, regex, options, {
+  glob,
+  posix
+} = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected input to be a string');
   }
-
   if (input === '') {
-    return { isMatch: false, output: '' };
+    return {
+      isMatch: false,
+      output: ''
+    };
   }
-
   const opts = options || {};
   const format = opts.format || (posix ? utils.toPosixSlashes : null);
   let match = input === glob;
-  let output = (match && format) ? format(input) : input;
-
+  let output = match && format ? format(input) : input;
   if (match === false) {
     output = format ? format(input) : input;
     match = output === glob;
   }
-
   if (match === false || opts.capture === true) {
     if (opts.matchBase === true || opts.basename === true) {
       match = picomatch.matchBase(input, regex, options, posix);
@@ -145,8 +154,11 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
       match = regex.exec(output);
     }
   }
-
-  return { isMatch: Boolean(match), match, output };
+  return {
+    isMatch: Boolean(match),
+    match,
+    output
+  };
 };
 
 /**
@@ -203,7 +215,10 @@ picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str
 
 picomatch.parse = (pattern, options) => {
   if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
-  return parse(pattern, { ...options, fastpaths: false });
+  return parse(pattern, {
+    ...options,
+    fastpaths: false
+  });
 };
 
 /**
@@ -251,21 +266,17 @@ picomatch.compileRe = (state, options, returnOutput = false, returnState = false
   if (returnOutput === true) {
     return state.output;
   }
-
   const opts = options || {};
   const prepend = opts.contains ? '' : '^';
   const append = opts.contains ? '' : '$';
-
   let source = `${prepend}(?:${state.output})${append}`;
   if (state && state.negated === true) {
     source = `^(?!${source}).*$`;
   }
-
   const regex = picomatch.toRegex(source, options);
   if (returnState === true) {
     regex.state = state;
   }
-
   return regex;
 };
 
@@ -292,17 +303,16 @@ picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = fal
   if (!input || typeof input !== 'string') {
     throw new TypeError('Expected a non-empty string');
   }
-
-  let parsed = { negated: false, fastpaths: true };
-
+  let parsed = {
+    negated: false,
+    fastpaths: true
+  };
   if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
     parsed.output = parse.fastpaths(input, options);
   }
-
   if (!parsed.output) {
     parsed = parse(input, options);
   }
-
   return picomatch.compileRe(parsed, options, returnOutput, returnState);
 };
 

package/build/esm/node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.mjs

@@ -4,27 +4,39 @@ import { __exports as utils$1 } from '../../../../../../_virtual/utils.mjs';
 
 const utils = utils$1;
 const {
-  CHAR_ASTERISK,             /* * */
-  CHAR_AT,                   /* @ */
-  CHAR_BACKWARD_SLASH,       /* \ */
-  CHAR_COMMA,                /* , */
-  CHAR_DOT,                  /* . */
-  CHAR_EXCLAMATION_MARK,     /* ! */
-  CHAR_FORWARD_SLASH,        /* / */
-  CHAR_LEFT_CURLY_BRACE,     /* { */
-  CHAR_LEFT_PARENTHESES,     /* ( */
-  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
-  CHAR_PLUS,                 /* + */
-  CHAR_QUESTION_MARK,        /* ? */
-  CHAR_RIGHT_CURLY_BRACE,    /* } */
-  CHAR_RIGHT_PARENTHESES,    /* ) */
-  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+  CHAR_ASTERISK,
+  /* * */
+  CHAR_AT,
+  /* @ */
+  CHAR_BACKWARD_SLASH,
+  /* \ */
+  CHAR_COMMA,
+  /* , */
+  CHAR_DOT,
+  /* . */
+  CHAR_EXCLAMATION_MARK,
+  /* ! */
+  CHAR_FORWARD_SLASH,
+  /* / */
+  CHAR_LEFT_CURLY_BRACE,
+  /* { */
+  CHAR_LEFT_PARENTHESES,
+  /* ( */
+  CHAR_LEFT_SQUARE_BRACKET,
+  /* [ */
+  CHAR_PLUS,
+  /* + */
+  CHAR_QUESTION_MARK,
+  /* ? */
+  CHAR_RIGHT_CURLY_BRACE,
+  /* } */
+  CHAR_RIGHT_PARENTHESES,
+  /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET /* ] */
 } = constants;
-
 const isPathSeparator = code => {
   return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
 };
-
 const depth = token => {
   if (token.isPrefix !== true) {
     token.depth = token.isGlobstar ? Infinity : 1;
@@ -50,13 +62,11 @@ const depth = token => {
 
 const scan = (input, options) => {
   const opts = options || {};
-
   const length = input.length - 1;
   const scanToEnd = opts.parts === true || opts.scanToEnd === true;
   const slashes = [];
   const tokens = [];
   const parts = [];
-
   let str = input;
   let index = -1;
   let start = 0;
@@ -74,71 +84,60 @@ const scan = (input, options) => {
   let braces = 0;
   let prev;
   let code;
-  let token = { value: '', depth: 0, isGlob: false };
-
+  let token = {
+    value: '',
+    depth: 0,
+    isGlob: false
+  };
   const eos = () => index >= length;
   const peek = () => str.charCodeAt(index + 1);
   const advance = () => {
     prev = code;
     return str.charCodeAt(++index);
   };
-
   while (index < length) {
     code = advance();
     let next;
-
     if (code === CHAR_BACKWARD_SLASH) {
       backslashes = token.backslashes = true;
       code = advance();
-
       if (code === CHAR_LEFT_CURLY_BRACE) {
         braceEscaped = true;
       }
       continue;
     }
-
     if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
       braces++;
-
       while (eos() !== true && (code = advance())) {
         if (code === CHAR_BACKWARD_SLASH) {
           backslashes = token.backslashes = true;
           advance();
           continue;
         }
-
         if (code === CHAR_LEFT_CURLY_BRACE) {
           braces++;
           continue;
         }
-
         if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
           isBrace = token.isBrace = true;
           isGlob = token.isGlob = true;
           finished = true;
-
           if (scanToEnd === true) {
             continue;
           }
-
           break;
         }
-
         if (braceEscaped !== true && code === CHAR_COMMA) {
           isBrace = token.isBrace = true;
           isGlob = token.isGlob = true;
           finished = true;
-
           if (scanToEnd === true) {
             continue;
           }
-
           break;
         }
-
         if (code === CHAR_RIGHT_CURLY_BRACE) {
           braces--;
-
           if (braces === 0) {
             braceEscaped = false;
             isBrace = token.isBrace = true;
@@ -147,36 +146,29 @@ const scan = (input, options) => {
           }
         }
       }
-
       if (scanToEnd === true) {
         continue;
       }
-
       break;
     }
-
     if (code === CHAR_FORWARD_SLASH) {
       slashes.push(index);
       tokens.push(token);
-      token = { value: '', depth: 0, isGlob: false };
-
+      token = {
+        value: '',
+        depth: 0,
+        isGlob: false
+      };
       if (finished === true) continue;
-      if (prev === CHAR_DOT && index === (start + 1)) {
+      if (prev === CHAR_DOT && index === start + 1) {
         start += 2;
         continue;
       }
-
       lastIndex = index + 1;
       continue;
     }
-
     if (opts.noext !== true) {
-      const isExtglobChar = code === CHAR_PLUS
-        || code === CHAR_AT
-        || code === CHAR_ASTERISK
-        || code === CHAR_QUESTION_MARK
-        || code === CHAR_EXCLAMATION_MARK;
-
+      const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
       if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
         isGlob = token.isGlob = true;
         isExtglob = token.isExtglob = true;
@@ -184,7 +176,6 @@ const scan = (input, options) => {
         if (code === CHAR_EXCLAMATION_MARK && index === start) {
           negatedExtglob = true;
         }
-
         if (scanToEnd === true) {
           while (eos() !== true && (code = advance())) {
             if (code === CHAR_BACKWARD_SLASH) {
@@ -192,7 +183,6 @@ const scan = (input, options) => {
               code = advance();
               continue;
             }
-
             if (code === CHAR_RIGHT_PARENTHESES) {
               isGlob = token.isGlob = true;
               finished = true;
@@ -204,28 +194,23 @@ const scan = (input, options) => {
         break;
       }
     }
-
     if (code === CHAR_ASTERISK) {
       if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
       isGlob = token.isGlob = true;
       finished = true;
-
       if (scanToEnd === true) {
         continue;
       }
       break;
     }
-
     if (code === CHAR_QUESTION_MARK) {
       isGlob = token.isGlob = true;
       finished = true;
-
       if (scanToEnd === true) {
         continue;
       }
       break;
     }
-
     if (code === CHAR_LEFT_SQUARE_BRACKET) {
       while (eos() !== true && (next = advance())) {
         if (next === CHAR_BACKWARD_SLASH) {
@@ -233,7 +218,6 @@ const scan = (input, options) => {
           advance();
           continue;
         }
-
         if (next === CHAR_RIGHT_SQUARE_BRACKET) {
           isBracket = token.isBracket = true;
           isGlob = token.isGlob = true;
@@ -241,23 +225,18 @@ const scan = (input, options) => {
           break;
         }
       }
-
       if (scanToEnd === true) {
         continue;
       }
-
       break;
     }
-
     if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
       negated = token.negated = true;
       start++;
       continue;
     }
-
     if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
       isGlob = token.isGlob = true;
-
       if (scanToEnd === true) {
         while (eos() !== true && (code = advance())) {
           if (code === CHAR_LEFT_PARENTHESES) {
@@ -265,7 +244,6 @@ const scan = (input, options) => {
             code = advance();
             continue;
           }
-
           if (code === CHAR_RIGHT_PARENTHESES) {
             finished = true;
             break;
@@ -275,33 +253,26 @@ const scan = (input, options) => {
       }
       break;
     }
-
     if (isGlob === true) {
       finished = true;
-
       if (scanToEnd === true) {
         continue;
       }
-
       break;
     }
   }
-
   if (opts.noext === true) {
     isExtglob = false;
     isGlob = false;
   }
-
   let base = str;
   let prefix = '';
   let glob = '';
-
   if (start > 0) {
     prefix = str.slice(0, start);
     str = str.slice(start);
     lastIndex -= start;
   }
-
   if (base && isGlob === true && lastIndex > 0) {
     base = str.slice(0, lastIndex);
     glob = str.slice(lastIndex);
@@ -311,21 +282,17 @@ const scan = (input, options) => {
   } else {
     base = str;
   }
-
   if (base && base !== '' && base !== '/' && base !== str) {
     if (isPathSeparator(base.charCodeAt(base.length - 1))) {
       base = base.slice(0, -1);
     }
   }
-
   if (opts.unescape === true) {
     if (glob) glob = utils.removeBackslashes(glob);
-
     if (base && backslashes === true) {
       base = utils.removeBackslashes(base);
     }
   }
-
   const state = {
     prefix,
     input,
@@ -340,7 +307,6 @@ const scan = (input, options) => {
     negated,
     negatedExtglob
   };
-
   if (opts.tokens === true) {
     state.maxDepth = 0;
     if (!isPathSeparator(code)) {
@@ -348,10 +314,8 @@ const scan = (input, options) => {
     }
     state.tokens = tokens;
   }
-
   if (opts.parts === true || opts.tokens === true) {
     let prevIndex;
-
     for (let idx = 0; idx < slashes.length; idx++) {
       const n = prevIndex ? prevIndex + 1 : start;
       const i = slashes[idx];
@@ -371,25 +335,20 @@ const scan = (input, options) => {
       }
       prevIndex = i;
     }
-
     if (prevIndex && prevIndex + 1 < input.length) {
       const value = input.slice(prevIndex + 1);
       parts.push(value);
-
       if (opts.tokens) {
         tokens[tokens.length - 1].value = value;
         depth(tokens[tokens.length - 1]);
         state.maxDepth += tokens[tokens.length - 1].depth;
       }
     }
-
     state.slashes = slashes;
     state.parts = parts;
   }
-
   return state;
 };
-
 var scan_1 = scan;
 
 export { scan_1 as s };

package/build/esm/node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.mjs

@@ -1,69 +1,61 @@
 import { __exports as utils } from '../../../../../../_virtual/utils.mjs';
-import path__default from 'node:path';
+import path__default from 'path';
 import { c as constants } from './constants.mjs';
 
 (function (exports) {
 
-	const path = path__default;
-	const win32 = process.platform === 'win32';
-	const {
-	  REGEX_BACKSLASH,
-	  REGEX_REMOVE_BACKSLASH,
-	  REGEX_SPECIAL_CHARS,
-	  REGEX_SPECIAL_CHARS_GLOBAL
-	} = constants;
-
-	exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
-	exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
-	exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
-	exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
-	exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
-
-	exports.removeBackslashes = str => {
-	  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
-	    return match === '\\' ? '' : match;
-	  });
-	};
-
-	exports.supportsLookbehinds = () => {
-	  const segs = process.version.slice(1).split('.').map(Number);
-	  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
-	    return true;
-	  }
-	  return false;
-	};
-
-	exports.isWindows = options => {
-	  if (options && typeof options.windows === 'boolean') {
-	    return options.windows;
-	  }
-	  return win32 === true || path.sep === '\\';
-	};
-
-	exports.escapeLast = (input, char, lastIdx) => {
-	  const idx = input.lastIndexOf(char, lastIdx);
-	  if (idx === -1) return input;
-	  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
-	  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-	};
-
-	exports.removePrefix = (input, state = {}) => {
-	  let output = input;
-	  if (output.startsWith('./')) {
-	    output = output.slice(2);
-	    state.prefix = './';
-	  }
-	  return output;
-	};
-
-	exports.wrapOutput = (input, state = {}, options = {}) => {
-	  const prepend = options.contains ? '' : '^';
-	  const append = options.contains ? '' : '$';
-
-	  let output = `${prepend}(?:${input})${append}`;
-	  if (state.negated === true) {
-	    output = `(?:^(?!${output}).*$)`;
-	  }
-	  return output;
-	}; 
-} (utils));
+  const path = path__default;
+  const win32 = process.platform === 'win32';
+  const {
+    REGEX_BACKSLASH,
+    REGEX_REMOVE_BACKSLASH,
+    REGEX_SPECIAL_CHARS,
+    REGEX_SPECIAL_CHARS_GLOBAL
+  } = constants;
+  exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+  exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+  exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+  exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+  exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+  exports.removeBackslashes = str => {
+    return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+      return match === '\\' ? '' : match;
+    });
+  };
+  exports.supportsLookbehinds = () => {
+    const segs = process.version.slice(1).split('.').map(Number);
+    if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) {
+      return true;
+    }
+    return false;
+  };
+  exports.isWindows = options => {
+    if (options && typeof options.windows === 'boolean') {
+      return options.windows;
+    }
+    return win32 === true || path.sep === '\\';
+  };
+  exports.escapeLast = (input, char, lastIdx) => {
+    const idx = input.lastIndexOf(char, lastIdx);
+    if (idx === -1) return input;
+    if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+    return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+  };
+  exports.removePrefix = (input, state = {}) => {
+    let output = input;
+    if (output.startsWith('./')) {
+      output = output.slice(2);
+      state.prefix = './';
+    }
+    return output;
+  };
+  exports.wrapOutput = (input, state = {}, options = {}) => {
+    const prepend = options.contains ? '' : '^';
+    const append = options.contains ? '' : '$';
+    let output = `${prepend}(?:${input})${append}`;
+    if (state.negated === true) {
+      output = `(?:^(?!${output}).*$)`;
+    }
+    return output;
+  };
+})(utils);