@quilted/create 0.2.43 → 0.2.44

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

@@ -1,359 +1,365 @@
 import path__default from 'node:path';
-import { scan_1 } from './scan.mjs';
-import { parse_1 } from './parse.mjs';
-import './utils.mjs';
-import { constants as constants$1 } from './constants.mjs';
-import { __exports as utils$1 } from '../../../../../../_virtual/utils.mjs';
+import { __require as requireScan } from './scan.mjs';
+import { __require as requireParse } from './parse.mjs';
+import { __require as requireUtils } from './utils.mjs';
+import { __require as requireConstants } from './constants.mjs';
 
-const path = path__default;
-const scan = scan_1;
-const parse = parse_1;
-const utils = utils$1;
-const constants = constants$1;
-const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+var picomatch_1;
+var hasRequiredPicomatch;
+function requirePicomatch() {
+  if (hasRequiredPicomatch) return picomatch_1;
+  hasRequiredPicomatch = 1;
+  const path = path__default;
+  const scan = requireScan();
+  const parse = requireParse();
+  const utils = requireUtils();
+  const constants = requireConstants();
+  const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
 
-/**
- * Creates a matcher function from one or more glob patterns. The
- * returned function takes a string to match as its first argument,
- * and returns true if the string is a match. The returned matcher
- * function also takes a boolean as the second argument that, when true,
- * returns an object with additional information.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch(glob[, options]);
- *
- * const isMatch = picomatch('*.!(*a)');
- * console.log(isMatch('a.a')); //=> false
- * console.log(isMatch('a.b')); //=> true
- * ```
- * @name picomatch
- * @param {String|Array} `globs` One or more glob patterns.
- * @param {Object=} `options`
- * @return {Function=} Returns a matcher function.
- * @api public
- */
+  /**
+   * Creates a matcher function from one or more glob patterns. The
+   * returned function takes a string to match as its first argument,
+   * and returns true if the string is a match. The returned matcher
+   * function also takes a boolean as the second argument that, when true,
+   * returns an object with additional information.
+   *
+   * ```js
+   * const picomatch = require('picomatch');
+   * // picomatch(glob[, options]);
+   *
+   * const isMatch = picomatch('*.!(*a)');
+   * console.log(isMatch('a.a')); //=> false
+   * console.log(isMatch('a.b')); //=> true
+   * ```
+   * @name picomatch
+   * @param {String|Array} `globs` One or more glob patterns.
+   * @param {Object=} `options`
+   * @return {Function=} Returns a matcher function.
+   * @api public
+   */
 
-const picomatch = (glob, options, returnState = false) => {
-  if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch(input, options, returnState));
-    const arrayMatcher = str => {
-      for (const isMatch of fns) {
-        const state = isMatch(str);
-        if (state) return state;
-      }
-      return false;
-    };
-    return arrayMatcher;
-  }
-  const isState = isObject(glob) && glob.tokens && glob.input;
-  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 state = regex.state;
-  delete regex.state;
-  let isIgnored = () => false;
-  if (opts.ignore) {
-    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
-    };
-    if (typeof opts.onResult === 'function') {
-      opts.onResult(result);
+  const picomatch = (glob, options, returnState = false) => {
+    if (Array.isArray(glob)) {
+      const fns = glob.map(input => picomatch(input, options, returnState));
+      const arrayMatcher = str => {
+        for (const isMatch of fns) {
+          const state = isMatch(str);
+          if (state) return state;
+        }
+        return false;
+      };
+      return arrayMatcher;
     }
-    if (isMatch === false) {
-      result.isMatch = false;
-      return returnObject ? result : false;
+    const isState = isObject(glob) && glob.tokens && glob.input;
+    if (glob === '' || typeof glob !== 'string' && !isState) {
+      throw new TypeError('Expected pattern to be a non-empty string');
     }
-    if (isIgnored(input)) {
-      if (typeof opts.onIgnore === 'function') {
-        opts.onIgnore(result);
-      }
-      result.isMatch = false;
-      return returnObject ? result : false;
+    const opts = options || {};
+    const posix = utils.isWindows(options);
+    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
+      };
+      isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
     }
-    if (typeof opts.onMatch === 'function') {
-      opts.onMatch(result);
+    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
+      };
+      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);
+        }
+        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 returnObject ? result : true;
+    return matcher;
   };
-  if (returnState) {
-    matcher.state = state;
-  }
-  return matcher;
-};
 
-/**
- * Test `input` with the given `regex`. This is used by the main
- * `picomatch()` function to test the input string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.test(input, regex[, options]);
- *
- * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
- * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp} `regex`
- * @return {Object} Returns an object with matching info.
- * @api public
- */
+  /**
+   * Test `input` with the given `regex`. This is used by the main
+   * `picomatch()` function to test the input string.
+   *
+   * ```js
+   * const picomatch = require('picomatch');
+   * // picomatch.test(input, regex[, options]);
+   *
+   * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+   * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+   * ```
+   * @param {String} `input` String to test.
+   * @param {RegExp} `regex`
+   * @return {Object} Returns an object with matching info.
+   * @api public
+   */
 
-picomatch.test = (input, regex, options, {
-  glob,
-  posix
-} = {}) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected input to be a string');
-  }
-  if (input === '') {
+  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: ''
+      };
+    }
+    const opts = options || {};
+    const format = opts.format || (posix ? utils.toPosixSlashes : null);
+    let match = input === glob;
+    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);
+      } else {
+        match = regex.exec(output);
+      }
+    }
     return {
-      isMatch: false,
-      output: ''
+      isMatch: Boolean(match),
+      match,
+      output
     };
-  }
-  const opts = options || {};
-  const format = opts.format || (posix ? utils.toPosixSlashes : null);
-  let match = input === glob;
-  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);
-    } else {
-      match = regex.exec(output);
-    }
-  }
-  return {
-    isMatch: Boolean(match),
-    match,
-    output
   };
-};
 
-/**
- * Match the basename of a filepath.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.matchBase(input, glob[, options]);
- * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
- * @return {Boolean}
- * @api public
- */
+  /**
+   * Match the basename of a filepath.
+   *
+   * ```js
+   * const picomatch = require('picomatch');
+   * // picomatch.matchBase(input, glob[, options]);
+   * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+   * ```
+   * @param {String} `input` String to test.
+   * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+   * @return {Boolean}
+   * @api public
+   */
 
-picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-  return regex.test(path.basename(input));
-};
+  picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+    const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+    return regex.test(path.basename(input));
+  };
 
-/**
- * Returns true if **any** of the given glob `patterns` match the specified `string`.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.isMatch(string, patterns[, options]);
- *
- * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
- * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
- * ```
- * @param {String|Array} str The string to test.
- * @param {String|Array} patterns One or more glob patterns to use for matching.
- * @param {Object} [options] See available [options](#options).
- * @return {Boolean} Returns true if any patterns match `str`
- * @api public
- */
+  /**
+   * Returns true if **any** of the given glob `patterns` match the specified `string`.
+   *
+   * ```js
+   * const picomatch = require('picomatch');
+   * // picomatch.isMatch(string, patterns[, options]);
+   *
+   * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+   * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+   * ```
+   * @param {String|Array} str The string to test.
+   * @param {String|Array} patterns One or more glob patterns to use for matching.
+   * @param {Object} [options] See available [options](#options).
+   * @return {Boolean} Returns true if any patterns match `str`
+   * @api public
+   */
 
-picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+  picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
 
-/**
- * Parse a glob pattern to create the source string for a regular
- * expression.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const result = picomatch.parse(pattern[, options]);
- * ```
- * @param {String} `pattern`
- * @param {Object} `options`
- * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
- * @api public
- */
+  /**
+   * Parse a glob pattern to create the source string for a regular
+   * expression.
+   *
+   * ```js
+   * const picomatch = require('picomatch');
+   * const result = picomatch.parse(pattern[, options]);
+   * ```
+   * @param {String} `pattern`
+   * @param {Object} `options`
+   * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+   * @api public
+   */
 
-picomatch.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
-  return parse(pattern, {
-    ...options,
-    fastpaths: false
-  });
-};
+  picomatch.parse = (pattern, options) => {
+    if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+    return parse(pattern, {
+      ...options,
+      fastpaths: false
+    });
+  };
 
-/**
- * Scan a glob pattern to separate the pattern into segments.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.scan(input[, options]);
- *
- * const result = picomatch.scan('!./foo/*.js');
- * console.log(result);
- * { prefix: '!./',
- *   input: '!./foo/*.js',
- *   start: 3,
- *   base: 'foo',
- *   glob: '*.js',
- *   isBrace: false,
- *   isBracket: false,
- *   isGlob: true,
- *   isExtglob: false,
- *   isGlobstar: false,
- *   negated: true }
- * ```
- * @param {String} `input` Glob pattern to scan.
- * @param {Object} `options`
- * @return {Object} Returns an object with
- * @api public
- */
+  /**
+   * Scan a glob pattern to separate the pattern into segments.
+   *
+   * ```js
+   * const picomatch = require('picomatch');
+   * // picomatch.scan(input[, options]);
+   *
+   * const result = picomatch.scan('!./foo/*.js');
+   * console.log(result);
+   * { prefix: '!./',
+   *   input: '!./foo/*.js',
+   *   start: 3,
+   *   base: 'foo',
+   *   glob: '*.js',
+   *   isBrace: false,
+   *   isBracket: false,
+   *   isGlob: true,
+   *   isExtglob: false,
+   *   isGlobstar: false,
+   *   negated: true }
+   * ```
+   * @param {String} `input` Glob pattern to scan.
+   * @param {Object} `options`
+   * @return {Object} Returns an object with
+   * @api public
+   */
 
-picomatch.scan = (input, options) => scan(input, options);
+  picomatch.scan = (input, options) => scan(input, options);
 
-/**
- * Compile a regular expression from the `state` object returned by the
- * [parse()](#parse) method.
- *
- * @param {Object} `state`
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
- * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
- * @return {RegExp}
- * @api public
- */
+  /**
+   * Compile a regular expression from the `state` object returned by the
+   * [parse()](#parse) method.
+   *
+   * @param {Object} `state`
+   * @param {Object} `options`
+   * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+   * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+   * @return {RegExp}
+   * @api public
+   */
 
-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;
-};
+  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;
+  };
 
-/**
- * Create a regular expression from a parsed glob pattern.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const state = picomatch.parse('*.js');
- * // picomatch.compileRe(state[, options]);
- *
- * console.log(picomatch.compileRe(state));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `state` The object returned from the `.parse` method.
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
- * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
- * @return {RegExp} Returns a regex created from the given pattern.
- * @api public
- */
+  /**
+   * Create a regular expression from a parsed glob pattern.
+   *
+   * ```js
+   * const picomatch = require('picomatch');
+   * const state = picomatch.parse('*.js');
+   * // picomatch.compileRe(state[, options]);
+   *
+   * console.log(picomatch.compileRe(state));
+   * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+   * ```
+   * @param {String} `state` The object returned from the `.parse` method.
+   * @param {Object} `options`
+   * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+   * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+   * @return {RegExp} Returns a regex created from the given pattern.
+   * @api public
+   */
 
-picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
-  if (!input || typeof input !== 'string') {
-    throw new TypeError('Expected a non-empty string');
-  }
-  let parsed = {
-    negated: false,
-    fastpaths: true
+  picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+    if (!input || typeof input !== 'string') {
+      throw new TypeError('Expected a non-empty string');
+    }
+    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);
   };
-  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);
-};
 
-/**
- * Create a regular expression from the given regex source string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.toRegex(source[, options]);
- *
- * const { output } = picomatch.parse('*.js');
- * console.log(picomatch.toRegex(output));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `source` Regular expression source string.
- * @param {Object} `options`
- * @return {RegExp}
- * @api public
- */
+  /**
+   * Create a regular expression from the given regex source string.
+   *
+   * ```js
+   * const picomatch = require('picomatch');
+   * // picomatch.toRegex(source[, options]);
+   *
+   * const { output } = picomatch.parse('*.js');
+   * console.log(picomatch.toRegex(output));
+   * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+   * ```
+   * @param {String} `source` Regular expression source string.
+   * @param {Object} `options`
+   * @return {RegExp}
+   * @api public
+   */
 
-picomatch.toRegex = (source, options) => {
-  try {
-    const opts = options || {};
-    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
-  } catch (err) {
-    if (options && options.debug === true) throw err;
-    return /$^/;
-  }
-};
+  picomatch.toRegex = (source, options) => {
+    try {
+      const opts = options || {};
+      return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+    } catch (err) {
+      if (options && options.debug === true) throw err;
+      return /$^/;
+    }
+  };
 
-/**
- * Picomatch constants.
- * @return {Object}
- */
+  /**
+   * Picomatch constants.
+   * @return {Object}
+   */
 
-picomatch.constants = constants;
+  picomatch.constants = constants;
 
-/**
- * Expose "picomatch"
- */
+  /**
+   * Expose "picomatch"
+   */
 
-var picomatch_1 = picomatch;
+  picomatch_1 = picomatch;
+  return picomatch_1;
+}
 
-export { picomatch_1 };
+export { requirePicomatch as __require };