@quilted/create 0.2.43 → 0.2.45

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

@@ -1,190 +1,254 @@
-import './utils.mjs';
-import { constants } from './constants.mjs';
-import { __exports as utils$1 } from '../../../../../../_virtual/utils.mjs';
+import { __require as requireUtils } from './utils.mjs';
+import { __require as requireConstants } from './constants.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 /* ] */
-} = 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;
-  }
-};
-
-/**
- * Quickly scans a glob pattern and returns an object with a handful of
- * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
- * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
- * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
- *
- * ```js
- * const pm = require('picomatch');
- * console.log(pm.scan('foo/bar/*.js'));
- * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {Object} Returns an object with tokens and regex source string.
- * @api public
- */
-
-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;
-  let lastIndex = 0;
-  let isBrace = false;
-  let isBracket = false;
-  let isGlob = false;
-  let isExtglob = false;
-  let isGlobstar = false;
-  let braceEscaped = false;
-  let backslashes = false;
-  let negated = false;
-  let negatedExtglob = false;
-  let finished = false;
-  let braces = 0;
-  let prev;
-  let code;
-  let token = {
-    value: '',
-    depth: 0,
-    isGlob: false
+var scan_1;
+var hasRequiredScan;
+function requireScan() {
+  if (hasRequiredScan) return scan_1;
+  hasRequiredScan = 1;
+  const utils = requireUtils();
+  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 /* ] */
+  } = requireConstants();
+  const isPathSeparator = code => {
+    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
   };
-  const eos = () => index >= length;
-  const peek = () => str.charCodeAt(index + 1);
-  const advance = () => {
-    prev = code;
-    return str.charCodeAt(++index);
+  const depth = token => {
+    if (token.isPrefix !== true) {
+      token.depth = token.isGlobstar ? Infinity : 1;
+    }
   };
-  while (index < length) {
-    code = advance();
-    let next;
-    if (code === CHAR_BACKWARD_SLASH) {
-      backslashes = token.backslashes = true;
+
+  /**
+   * Quickly scans a glob pattern and returns an object with a handful of
+   * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+   * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+   * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+   *
+   * ```js
+   * const pm = require('picomatch');
+   * console.log(pm.scan('foo/bar/*.js'));
+   * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+   * ```
+   * @param {String} `str`
+   * @param {Object} `options`
+   * @return {Object} Returns an object with tokens and regex source string.
+   * @api public
+   */
+
+  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;
+    let lastIndex = 0;
+    let isBrace = false;
+    let isBracket = false;
+    let isGlob = false;
+    let isExtglob = false;
+    let isGlobstar = false;
+    let braceEscaped = false;
+    let backslashes = false;
+    let negated = false;
+    let negatedExtglob = false;
+    let finished = false;
+    let braces = 0;
+    let prev;
+    let code;
+    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();
-      if (code === CHAR_LEFT_CURLY_BRACE) {
-        braceEscaped = true;
+      let next;
+      if (code === CHAR_BACKWARD_SLASH) {
+        backslashes = token.backslashes = true;
+        code = advance();
+        if (code === CHAR_LEFT_CURLY_BRACE) {
+          braceEscaped = true;
+        }
+        continue;
       }
-      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();
+      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;
+              finished = true;
+              break;
+            }
+          }
+        }
+        if (scanToEnd === true) {
           continue;
         }
-        if (code === CHAR_LEFT_CURLY_BRACE) {
-          braces++;
+        break;
+      }
+      if (code === CHAR_FORWARD_SLASH) {
+        slashes.push(index);
+        tokens.push(token);
+        token = {
+          value: '',
+          depth: 0,
+          isGlob: false
+        };
+        if (finished === true) continue;
+        if (prev === CHAR_DOT && index === start + 1) {
+          start += 2;
           continue;
         }
-        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-          isBrace = token.isBrace = true;
+        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;
+        if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
           isGlob = token.isGlob = true;
+          isExtglob = token.isExtglob = true;
           finished = true;
+          if (code === CHAR_EXCLAMATION_MARK && index === start) {
+            negatedExtglob = true;
+          }
           if (scanToEnd === true) {
+            while (eos() !== true && (code = advance())) {
+              if (code === CHAR_BACKWARD_SLASH) {
+                backslashes = token.backslashes = true;
+                code = advance();
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES) {
+                isGlob = token.isGlob = true;
+                finished = true;
+                break;
+              }
+            }
             continue;
           }
           break;
         }
-        if (braceEscaped !== true && code === CHAR_COMMA) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          if (scanToEnd === true) {
+      }
+      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) {
+            backslashes = token.backslashes = true;
+            advance();
             continue;
           }
-          break;
-        }
-        if (code === CHAR_RIGHT_CURLY_BRACE) {
-          braces--;
-          if (braces === 0) {
-            braceEscaped = false;
-            isBrace = token.isBrace = true;
+          if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+            isBracket = token.isBracket = true;
+            isGlob = token.isGlob = true;
             finished = true;
             break;
           }
         }
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
       }
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-    if (code === CHAR_FORWARD_SLASH) {
-      slashes.push(index);
-      tokens.push(token);
-      token = {
-        value: '',
-        depth: 0,
-        isGlob: false
-      };
-      if (finished === true) continue;
-      if (prev === CHAR_DOT && index === start + 1) {
-        start += 2;
+      if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+        negated = token.negated = true;
+        start++;
         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;
-      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+      if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
         isGlob = token.isGlob = true;
-        isExtglob = token.isExtglob = true;
-        finished = true;
-        if (code === CHAR_EXCLAMATION_MARK && index === start) {
-          negatedExtglob = true;
-        }
         if (scanToEnd === true) {
           while (eos() !== true && (code = advance())) {
-            if (code === CHAR_BACKWARD_SLASH) {
+            if (code === CHAR_LEFT_PARENTHESES) {
               backslashes = token.backslashes = true;
               code = advance();
               continue;
             }
             if (code === CHAR_RIGHT_PARENTHESES) {
-              isGlob = token.isGlob = true;
               finished = true;
               break;
             }
@@ -193,162 +257,104 @@ 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) {
-          backslashes = token.backslashes = true;
-          advance();
+      if (isGlob === true) {
+        finished = true;
+        if (scanToEnd === true) {
           continue;
         }
-        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-          isBracket = token.isBracket = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          break;
-        }
-      }
-      if (scanToEnd === true) {
-        continue;
+        break;
       }
-      break;
     }
-    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
-      negated = token.negated = true;
-      start++;
-      continue;
+    if (opts.noext === true) {
+      isExtglob = false;
+      isGlob = false;
     }
-    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) {
-            backslashes = token.backslashes = true;
-            code = advance();
-            continue;
-          }
-          if (code === CHAR_RIGHT_PARENTHESES) {
-            finished = true;
-            break;
-          }
-        }
-        continue;
-      }
-      break;
+    let base = str;
+    let prefix = '';
+    let glob = '';
+    if (start > 0) {
+      prefix = str.slice(0, start);
+      str = str.slice(start);
+      lastIndex -= start;
     }
-    if (isGlob === true) {
-      finished = true;
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
+    if (base && isGlob === true && lastIndex > 0) {
+      base = str.slice(0, lastIndex);
+      glob = str.slice(lastIndex);
+    } else if (isGlob === true) {
+      base = '';
+      glob = str;
+    } else {
+      base = str;
     }
-  }
-  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);
-  } else if (isGlob === true) {
-    base = '';
-    glob = str;
-  } else {
-    base = str;
-  }
-  if (base && base !== '' && base !== '/' && base !== str) {
-    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
-      base = base.slice(0, -1);
+    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);
+    if (opts.unescape === true) {
+      if (glob) glob = utils.removeBackslashes(glob);
+      if (base && backslashes === true) {
+        base = utils.removeBackslashes(base);
+      }
     }
-  }
-  const state = {
-    prefix,
-    input,
-    start,
-    base,
-    glob,
-    isBrace,
-    isBracket,
-    isGlob,
-    isExtglob,
-    isGlobstar,
-    negated,
-    negatedExtglob
-  };
-  if (opts.tokens === true) {
-    state.maxDepth = 0;
-    if (!isPathSeparator(code)) {
-      tokens.push(token);
+    const state = {
+      prefix,
+      input,
+      start,
+      base,
+      glob,
+      isBrace,
+      isBracket,
+      isGlob,
+      isExtglob,
+      isGlobstar,
+      negated,
+      negatedExtglob
+    };
+    if (opts.tokens === true) {
+      state.maxDepth = 0;
+      if (!isPathSeparator(code)) {
+        tokens.push(token);
+      }
+      state.tokens = tokens;
     }
-    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];
-      const value = input.slice(n, i);
-      if (opts.tokens) {
-        if (idx === 0 && start !== 0) {
-          tokens[idx].isPrefix = true;
-          tokens[idx].value = prefix;
-        } else {
-          tokens[idx].value = value;
+    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];
+        const value = input.slice(n, i);
+        if (opts.tokens) {
+          if (idx === 0 && start !== 0) {
+            tokens[idx].isPrefix = true;
+            tokens[idx].value = prefix;
+          } else {
+            tokens[idx].value = value;
+          }
+          depth(tokens[idx]);
+          state.maxDepth += tokens[idx].depth;
+        }
+        if (idx !== 0 || value !== '') {
+          parts.push(value);
         }
-        depth(tokens[idx]);
-        state.maxDepth += tokens[idx].depth;
+        prevIndex = i;
       }
-      if (idx !== 0 || value !== '') {
+      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;
+        }
       }
-      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;
     }
-    state.slashes = slashes;
-    state.parts = parts;
-  }
-  return state;
-};
-var scan_1 = scan;
+    return state;
+  };
+  scan_1 = scan;
+  return scan_1;
+}
 
-export { scan_1 };
+export { requireScan as __require };