minimatch 6.2.0 → 7.0.1

package/dist/cjs/mini.js

@@ -0,0 +1,799 @@
+"use strict";
+// this is a much more "mini" minimatch, optimized for use in a recursive
+// glob walk.
+//
+// String parts of the pattern set are only parsed and used on demand,
+// so that we don't have to bother parsing parts of the pattern that
+// don't ever end up being used.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = exports.compile = exports.parsePattern = exports.Pattern = exports.braceExpand = exports.Mini = void 0;
+const brace_expansion_1 = __importDefault(require("brace-expansion"));
+const index_js_1 = require("./index.js");
+/* c8 ignore start */
+const defaultPlatform = typeof process === 'object' &&
+    !!process &&
+    typeof process.platform === 'string'
+    ? process.platform
+    : 'linux';
+/* c8 ignore stop */
+class Mini {
+    options;
+    globLists;
+    patterns;
+    dot;
+    nocase;
+    noext;
+    noglobstar;
+    nobrace;
+    windowsPathsNoEscape;
+    platform;
+    isWindows;
+    constructor(patterns, opts = {}) {
+        const { dot = false, nocase, noext = false, noglobstar = false, nobrace = false, windowsPathsNoEscape = false, platform = defaultPlatform, } = opts;
+        this.dot = dot;
+        this.noext = noext;
+        this.noglobstar = noglobstar;
+        this.nobrace = nobrace;
+        this.windowsPathsNoEscape = windowsPathsNoEscape;
+        this.platform = platform;
+        this.nocase =
+            nocase !== undefined
+                ? nocase
+                : this.platform === 'win32' || this.platform === 'darwin';
+        this.isWindows = this.platform === 'win32';
+        opts = {
+            dot: this.dot,
+            nocase: this.nocase,
+            noext: this.noext,
+            noglobstar: this.noglobstar,
+            nobrace: this.nobrace,
+            windowsPathsNoEscape: this.windowsPathsNoEscape,
+            platform: this.platform,
+        };
+        this.options = opts;
+        if (!patterns)
+            throw new TypeError('pattern required');
+        if (!Array.isArray(patterns))
+            patterns = [patterns];
+        if (opts.windowsPathsNoEscape) {
+            patterns = patterns.map(p => p.replace(/\\/g, '/'));
+        }
+        this.globLists = this.preprocess(patterns
+            .map(p => (0, exports.braceExpand)(p, this.options))
+            .reduce((ps, p) => ps.concat(p), [])
+            .map(p => this.splitGlobString(p))
+            .filter(gl => !!gl.length));
+        const parsed = new Map();
+        this.patterns = this.globLists.map(gl => new Pattern(gl, 0, parsed, opts));
+    }
+    splitGlobString(globString) {
+        const parts = globString.split('/');
+        // canonincalize UNC paths and drives, make the first
+        // pattern the whole root ending in / for absolute patterns.
+        if (this.isUNC(parts)) {
+            const [p0, p1, p2] = parts;
+            parts.shift();
+            parts.shift();
+            parts.shift();
+            parts.unshift([p0, p1, p2, ''].join('/').toUpperCase());
+        }
+        else if (this.isDrive(parts)) {
+            const drive = parts[0].toUpperCase() + '/';
+            parts.shift();
+            parts.unshift(drive);
+        }
+        else if (parts[0] === '') {
+            parts[0] = '/';
+        }
+        // now strip any empty parts
+        return parts.filter(p => !!p);
+    }
+    isDrive(pl) {
+        return (this.isWindows && typeof pl[0] === 'string' && /^[a-z]:$/i.test(pl[0]));
+    }
+    isUNC(pl) {
+        return (this.isWindows &&
+            pl[0] === '' &&
+            pl[1] === '' &&
+            typeof pl[2] === 'string' &&
+            !!pl[2] &&
+            typeof pl[3] === 'string' &&
+            !!pl[3]);
+    }
+    preprocess(globParts) {
+        // if we're not in globstar mode, then turn all ** into *
+        if (this.noglobstar) {
+            for (let i = 0; i < globParts.length; i++) {
+                for (let j = 0; j < globParts[i].length; j++) {
+                    if (globParts[i][j] === '**') {
+                        globParts[i][j] = '*';
+                    }
+                }
+            }
+        }
+        globParts = this.firstPhasePreProcess(globParts);
+        globParts = this.secondPhasePreProcess(globParts);
+        return globParts;
+    }
+    // First phase: single-pattern processing
+    // <pre> is 1 or more portions
+    // <rest> is 1 or more portions
+    // <p> is any portion other than ., .., '', or **
+    // <e> is . or ''
+    //
+    // **/.. is *brutal* for filesystem walking performance, because
+    // it effectively resets the recursive walk each time it occurs,
+    // and ** cannot be reduced out by a .. pattern part like a regexp
+    // or most strings (other than .., ., and '') can be.
+    //
+    // <pre>/**/../<p>/<rest> -> {<pre>/../<p>/<rest>,<pre>/**/<p>/<rest>}
+    // <pre>/<e>/<rest> -> <pre>/<rest>
+    // <pre>/<p>/../<rest> -> <pre>/<rest>
+    // **/**/<rest> -> **/<rest>
+    //
+    // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+    // this WOULD be allowed if ** did follow symlinks, or * didn't
+    firstPhasePreProcess(globParts) {
+        let didSomething = false;
+        do {
+            didSomething = false;
+            // <pre>/**/../<p>/<rest> -> {<pre>/../<p>/<rest>,<pre>/**/<p>/<rest>}
+            for (let parts of globParts) {
+                let gs = -1;
+                while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
+                    let gss = gs;
+                    while (parts[gss + 1] === '**') {
+                        // <pre>/**/**/<rest> -> <pre>/**/<rest>
+                        gss++;
+                    }
+                    // eg, if gs is 2 and gss is 4, that means we have 3 **
+                    // parts, and can remove 2 of them.
+                    if (gss > gs) {
+                        parts.splice(gs + 1, gss - gs);
+                    }
+                    let next = parts[gs + 1];
+                    const p = parts[gs + 2];
+                    if (next !== '..')
+                        continue;
+                    if (!p || p === '.' || p === '..')
+                        continue;
+                    didSomething = true;
+                    // edit parts in place, and push the new one
+                    parts.splice(gs, 1);
+                    const other = parts.slice(0);
+                    other[gs] = '**';
+                    globParts.push(other);
+                    gs--;
+                }
+                // <pre>/<e>/<rest> -> <pre>/<rest>
+                for (let i = 1; i < parts.length - 1; i++) {
+                    const p = parts[i];
+                    // don't squeeze out UNC patterns
+                    if (i === 1 && p === '' && parts[0] === '')
+                        continue;
+                    if (p === '.' || p === '') {
+                        didSomething = true;
+                        parts.splice(i, 1);
+                        i--;
+                    }
+                }
+                if (parts[0] === '.') {
+                    didSomething = true;
+                    parts.shift();
+                }
+                // <pre>/<p>/../<rest> -> <pre>/<rest>
+                let dd = 0;
+                while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+                    const p = parts[dd - 1];
+                    if (p && p !== '.' && p !== '..' && p !== '**') {
+                        didSomething = true;
+                        parts.splice(dd - 1, 2);
+                        if (parts.length === 0)
+                            parts.push('');
+                        dd -= 2;
+                    }
+                }
+            }
+        } while (didSomething);
+        return globParts;
+    }
+    // second phase: multi-pattern dedupes
+    // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+    // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+    // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+    //
+    // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+    // ^-- not valid because ** doens't follow symlinks
+    secondPhasePreProcess(globParts) {
+        for (let i = 0; i < globParts.length - 1; i++) {
+            for (let j = i + 1; j < globParts.length; j++) {
+                const matched = this.partsMatch(globParts[i], globParts[j]);
+                if (!matched)
+                    continue;
+                globParts[i] = matched;
+                globParts[j] = [];
+            }
+        }
+        return globParts.filter(gs => gs.length);
+    }
+    partsMatch(a, b) {
+        let ai = 0;
+        let bi = 0;
+        let result = [];
+        let which = '';
+        while (ai < a.length && bi < b.length) {
+            if (a[ai] === b[bi]) {
+                result.push(which === 'b' ? b[bi] : a[ai]);
+                ai++;
+                bi++;
+            }
+            else if (a[ai] === '**' && b[bi] === a[ai + 1]) {
+                result.push(a[ai]);
+                ai++;
+            }
+            else if (b[bi] === '**' && a[ai] === b[bi + 1]) {
+                result.push(b[bi]);
+                bi++;
+            }
+            else if (a[ai] === '*' &&
+                b[bi] &&
+                !b[bi].startsWith('.') &&
+                b[bi] !== '**') {
+                if (which === 'b')
+                    return false;
+                which = 'a';
+                result.push(a[ai]);
+                ai++;
+                bi++;
+            }
+            else if (b[bi] === '*' &&
+                a[ai] &&
+                (this.dot || !a[ai].startsWith('.')) &&
+                a[ai] !== '**') {
+                if (which === 'a')
+                    return false;
+                which = 'b';
+                result.push(b[bi]);
+                ai++;
+                bi++;
+            }
+            else {
+                return false;
+            }
+        }
+        // if we fall out of the loop, it means they two are identical
+        // as long as their lengths match
+        return a.length === b.length && result;
+    }
+}
+exports.Mini = Mini;
+const braceExpand = (pattern, options = {}) => {
+    assertValidPattern(pattern);
+    // Thanks to Yeting Li <https://github.com/yetingli> for
+    // improving this regexp to avoid a ReDOS vulnerability.
+    if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+        // shortcut. no need to expand.
+        return [pattern];
+    }
+    return (0, brace_expansion_1.default)(pattern);
+};
+exports.braceExpand = braceExpand;
+const MAX_PATTERN_LENGTH = 1024 * 64;
+const assertValidPattern = (pattern) => {
+    if (typeof pattern !== 'string') {
+        throw new TypeError('invalid pattern');
+    }
+    if (pattern.length > MAX_PATTERN_LENGTH) {
+        throw new TypeError('pattern is too long');
+    }
+};
+const isGlobList = (gl) => gl.length >= 1;
+class Pattern {
+    #options;
+    #globList;
+    length;
+    #index;
+    #parsed;
+    // memoizing
+    #pattern;
+    #rest;
+    constructor(globList, index, parsed, options) {
+        if (!isGlobList(globList)) {
+            throw new TypeError('empty glob list');
+        }
+        this.#globList = globList;
+        if (index >= globList.length) {
+            throw new TypeError('index out of range');
+        }
+        this.length = globList.length;
+        this.#options = options;
+        this.#index = index;
+        this.#parsed = parsed;
+    }
+    glob() {
+        return this.#globList[this.#index];
+    }
+    pattern() {
+        if (this.#pattern !== undefined) {
+            return this.#pattern;
+        }
+        const glob = this.glob();
+        if (glob.endsWith('/')) {
+            return (this.#pattern = glob);
+        }
+        const cached = this.#parsed.get(glob);
+        if (cached !== undefined) {
+            return (this.#pattern = cached);
+        }
+        const pattern = parse(glob, this.#options);
+        this.#parsed.set(glob, pattern);
+        return (this.#pattern = pattern);
+    }
+    isAbsolute() {
+        return this.#globList[0].endsWith('/');
+    }
+    root() {
+        return this.#index === 0 && this.isAbsolute() ? this.#globList[0] : '';
+    }
+    rest() {
+        if (this.#rest !== undefined)
+            return this.#rest;
+        if (this.#index >= this.length - 1)
+            return (this.#rest = null);
+        const rest = new Pattern(this.#globList, this.#index + 1, this.#parsed, this.#options);
+        this.#rest = rest;
+        return rest;
+    }
+    hasMore() {
+        return this.#index < this.length - 1;
+    }
+}
+exports.Pattern = Pattern;
+const parsePattern = (pattern, options) => {
+    const ast = (0, exports.tokenize)(pattern, options);
+    if (ast.length === 1 && ast[0][TokenField.TYPE] === TokenType.STRING) {
+        return ast[0][TokenField.VALUE];
+    }
+    const re = (0, exports.compile)(ast, options, true);
+    try {
+        return new RegExp(re, options.nocase ? 'i' : '');
+    }
+    catch (er) {
+        return /$./;
+    }
+};
+exports.parsePattern = parsePattern;
+const compile = (ast, options, isTop = false, isStart = true) => {
+    const negativeExts = [];
+    const re = [];
+    let stillStart = isStart;
+    let maybeEmpty = true;
+    for (let i = 0; i < ast.length; i++) {
+        const token = ast[i];
+        if (isStringToken(token)) {
+            if (token[TokenField.VALUE] !== '') {
+                maybeEmpty = false;
+            }
+            re.push(compileNonMagic(token, options));
+        }
+        else if (isClassToken(token)) {
+            maybeEmpty = false;
+            re.push(compileClass(token, options));
+        }
+        else if (isExtToken(token)) {
+            if (token[TokenField.VALUE] === '!') {
+                negativeExts.push(i);
+            }
+            re.push(compileExt(token, options, stillStart));
+        }
+        else if (isQmarkToken(token)) {
+            maybeEmpty = false;
+            re.push(compileQmark(token, options));
+        }
+        else if (isStarToken(token)) {
+            re.push(compileStar(token, options));
+            /* c8 ignore start */
+        }
+        else {
+            throw new TypeError('unknown token type: ' + token);
+        }
+        /* c8 ignore stop */
+        stillStart = false;
+    }
+    if (isTop) {
+        re.push('$');
+    }
+    // a negative extglob is:
+    // ((?!(sub|patterns)<rest of the pattern>).*?)
+    // so we need to do it in two passes.
+    for (let i = negativeExts.length - 1; i >= 0; i--) {
+        const n = negativeExts[i];
+        re[n] += compileNegativeExtClose(re, n);
+    }
+    if (isTop) {
+        if (!options.dot && needDotProtection(ast)) {
+            re.unshift('(?!^\\.)');
+        }
+        if (maybeEmpty) {
+            re.unshift('(?=.)');
+        }
+        re.unshift('^');
+    }
+    else if (isStart) {
+        if (!options.dot && needDotProtection(ast)) {
+            re.unshift('(?!^\\.)');
+        }
+    }
+    return re.join('');
+};
+exports.compile = compile;
+const needDotProtection = (ast) => {
+    const first = ast[0];
+    return isClassToken(first) || isStarToken(first) || isQmarkToken(first);
+};
+const compileQmark = (_, __) => '.';
+const compileStar = (_, __) => '.*?';
+const compileNonMagic = (token, _) => regExpEscape(token[TokenField.VALUE]);
+const compileClass = (token, _) => {
+    // TODO: posix classes
+    const cls = braceEscape(charUnescape(token[TokenField.VALUE]));
+    const re = `[${cls}]`;
+    // handle out of order classes, like `[z-a]`, which throw
+    // in javascript, but just match nothing in glob syntax.
+    try {
+        RegExp(re);
+        return re;
+    }
+    catch (_) {
+        return '$.';
+    }
+};
+const charUnescape = (s) => s.replace(/\\([^-\]])/g, '$1');
+const braceEscape = (s) => s.replace(/[[\]\\]/g, '\\$&');
+const globSpecialChars = new Set(['?', '*', '+', '@', '!', '[', '(']);
+const escapeInClass = new Set(['-', ']']);
+const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+const isExtToken = (t) => t[TokenField.TYPE] === TokenType.EXT;
+const isStringToken = (t) => t[TokenField.TYPE] === TokenType.STRING;
+const isStarToken = (t) => t[TokenField.TYPE] === TokenType.STAR;
+const isQmarkToken = (t) => t[TokenField.TYPE] === TokenType.QMARK;
+const isClassToken = (t) => t[TokenField.TYPE] === TokenType.CLASS;
+var TokenField;
+(function (TokenField) {
+    TokenField[TokenField["TYPE"] = 0] = "TYPE";
+    TokenField[TokenField["VALUE"] = 1] = "VALUE";
+    TokenField[TokenField["CHILDREN"] = 2] = "CHILDREN";
+})(TokenField || (TokenField = {}));
+var TokenType;
+(function (TokenType) {
+    TokenType["STRING"] = "string";
+    TokenType["STAR"] = "star";
+    TokenType["EXT"] = "ext";
+    TokenType["QMARK"] = "qmark";
+    TokenType["CLASS"] = "class";
+})(TokenType || (TokenType = {}));
+const extGlobTypes = new Set(['?', '*', '+', '@', '!']);
+const isExtGlobType = (s) => extGlobTypes.has(s);
+const extTypes = {
+    '!': { open: '(?:(?!(?:', close: ').*?))' },
+    '?': { open: '(?:', close: ')?' },
+    '+': { open: '(?:', close: ')+' },
+    '*': { open: '(?:', close: ')*' },
+    '@': { open: '(?:', close: ')' },
+};
+const compileExt = (token, options, isStart) => {
+    const t = token[TokenField.VALUE];
+    const open = extTypes[t].open;
+    const close = t === '!' ? '' : extTypes[t].close;
+    const subs = token[TokenField.CHILDREN];
+    const body = subs.map(ast => (0, exports.compile)(ast, options, false, isStart)).join('|');
+    return open + body + close;
+};
+const compileNegativeExtClose = (re, n) => {
+    // walk the AST from i onwards, collecting the regexp
+    // then add the end bit:
+    // ((?!(sub|patterns)<rest of the pattern>).*?)
+    //                  ^-- from here on
+    let s = ')';
+    for (let i = n + 1; i < re.length; i++) {
+        s += re[i];
+    }
+    s += ').*?)';
+    return s;
+};
+const tokenize = (pattern, options, ast = []) => {
+    // tokenize the string up into chunks first
+    // sort of like an AST of the pattern
+    // each node is [type, value, [...children]]
+    // root, or children of extglobs, are an array of nodes
+    // so 'i\?jk?*.@(xy[a-c]|!(foo|ba*r))baz*bo' becomes:
+    // [
+    //  [STRING, 'i?jk'],
+    //  [QMARK, '?'],
+    //  [STAR, '*'],
+    //  [STRING, '.'],
+    //  [EXT, '@', [
+    //    [[STRING, 'xy'], [CLASS, 'a-c']],
+    //    [[EXT, '!', [
+    //      [[STRING, 'foo']],
+    //      [[STRING, 'ba'], [STAR, '*'], [STRING, 'r']]
+    //    ]]],
+    //  ]],
+    //  [STRING, 'baz'],
+    //  [STAR, '*'],
+    //  [STRING, 'bo'],
+    // ]
+    //
+    // which turns into the regexp:
+    // ^i\?jk..*?\.(?:xy[a-c]|(?:(?!(?:foo|ba.*?r).*$)))baz.*?bo$
+    // Place the "no dot allowed" if the AST starts at position 0,
+    // and is a *, ?, or class at the start
+    let i = 0;
+    const length = pattern.length;
+    while (i < length) {
+        let c = pattern.charAt(i);
+        // take our best guess as to what it is
+        // the other tokenizers will append to the AST and return
+        // the amount of string that was consumed.
+        if (!options.noext && isExtGlobType(c) && pattern.charAt(i + 1) === '(') {
+            const consumed = tokenizeExt(pattern, options, i, ast);
+            if (consumed) {
+                i += consumed;
+                c = pattern.charAt(i);
+                continue;
+            }
+        }
+        if (c === '[') {
+            const consumed = tokenizeClass(pattern, options, i, ast);
+            if (consumed) {
+                i += consumed;
+                continue;
+            }
+        }
+        if (c === '*') {
+            ast.push([TokenType.STAR, '*']);
+        }
+        else if (c === '?') {
+            ast.push([TokenType.QMARK, '?']);
+        }
+        else {
+            const consumed = tokenizeNonMagic(pattern, options, i, ast);
+            if (consumed) {
+                i += consumed;
+                c = pattern.charAt(i);
+                continue;
+            }
+        }
+        i++;
+    }
+    return ast;
+};
+exports.tokenize = tokenize;
+const tokenizeExt = (pattern, options, i, ast) => {
+    const extType = pattern.charAt(i);
+    if (!isExtGlobType(extType)) {
+        throw new Error('invalid extglob type: ' + extType);
+    }
+    const matchStack = [];
+    const pipes = [];
+    let p;
+    const length = pattern.length;
+    let end = -1;
+    let escaping = false;
+    // first split out the top-level set of strings
+    // if we can't do that, it's not a valid extglob
+    for (p = i + 2; p < length; p++) {
+        const c = pattern.charAt(p);
+        if (escaping) {
+            escaping = false;
+            continue;
+        }
+        if (c === '\\') {
+            escaping = true;
+            continue;
+        }
+        if (c === ']') {
+            if (matchStack[0] === '[' && pattern.charAt(p - 1) !== '[') {
+                matchStack.shift();
+            }
+        }
+        else if (c === ')') {
+            if (!matchStack.length) {
+                // finished!
+                end = p;
+                break;
+            }
+            else if (matchStack[0] === '(') {
+                matchStack.shift();
+            }
+        }
+        else if (c === '(') {
+            if (matchStack[0] !== '[' && isExtGlobType(pattern.charAt(p - 1))) {
+                matchStack.unshift(c);
+            }
+        }
+        else if (c === '|' && matchStack.length === 0) {
+            pipes.push(p);
+        }
+    }
+    if (!end || matchStack.length) {
+        return 0;
+    }
+    // i + 1, pipes, and end define the outside boundaries of the subs
+    const subPatterns = [];
+    let start = i + 2;
+    for (const pipe of pipes) {
+        subPatterns.push(pattern.substring(start, pipe));
+        start = pipe + 1;
+    }
+    subPatterns.push(pattern.substring(start, end));
+    const subTokenized = subPatterns.map(p => (0, exports.tokenize)(p, options));
+    ast.push([TokenType.EXT, extType, subTokenized]);
+    return end - i + 1;
+};
+const tokenizeClass = (pattern, _, i, ast) => {
+    // walk until we find the closing ] that is not escaped or the first char
+    // return 0 if it's not a valid class (basically, just if it's left open)
+    let p;
+    let escaping = false;
+    const length = pattern.length;
+    let s = '';
+    for (p = i + 1; p < length; p++) {
+        const c = pattern.charAt(p);
+        if (c === '\\' && !escaping) {
+            escaping = true;
+            continue;
+        }
+        if (p === i + 1 && c === ']') {
+            s += c;
+            continue;
+        }
+        if (escaping) {
+            escaping = false;
+            if (escapeInClass.has(c)) {
+                s += '\\';
+            }
+            s += c;
+            continue;
+        }
+        if (c === ']') {
+            ast.push([TokenType.CLASS, s]);
+            return p - i + 1;
+        }
+        s += c;
+    }
+    return 0;
+};
+const tokenizeNonMagic = (pattern, _, i, ast) => {
+    let escaping = false;
+    let p = i;
+    let sawFirst = false;
+    const length = pattern.length;
+    let s = '';
+    for (p = i; p < length; p++) {
+        let c = pattern.charAt(p);
+        if (c === '\\' && !escaping) {
+            escaping = true;
+            continue;
+        }
+        if (escaping) {
+            escaping = false;
+            s += c;
+            continue;
+        }
+        // this is only called when we KNOW the first char is not magic,
+        // so no need to stop for that at the outset.
+        if (!sawFirst) {
+            sawFirst = true;
+            s += c;
+            continue;
+        }
+        if (globSpecialChars.has(c)) {
+            break;
+        }
+        s += c;
+    }
+    ast.push([TokenType.STRING, s]);
+    return p - i;
+};
+const parse = (pattern, options) => {
+    if (pattern === '**')
+        return index_js_1.GLOBSTAR;
+    let m;
+    let fastTest = null;
+    if ((m = pattern.match(starRE))) {
+        fastTest = options.dot ? starTestDot : starTest;
+    }
+    else if ((m = pattern.match(starDotExtRE))) {
+        fastTest = (options.nocase
+            ? options.dot
+                ? starDotExtTestNocaseDot
+                : starDotExtTestNocase
+            : options.dot
+                ? starDotExtTestDot
+                : starDotExtTest)(m[1]);
+    }
+    else if ((m = pattern.match(qmarksRE))) {
+        fastTest = (options.nocase
+            ? options.dot
+                ? qmarksTestNocaseDot
+                : qmarksTestNocase
+            : options.dot
+                ? qmarksTestDot
+                : qmarksTest)(m);
+    }
+    else if ((m = pattern.match(starDotStarRE))) {
+        fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+    }
+    else if ((m = pattern.match(dotStarRE))) {
+        fastTest = dotStarTest;
+    }
+    if (fastTest) {
+        return Object.assign(/$./, {
+            _glob: pattern,
+            test: fastTest,
+        });
+    }
+    else {
+        // ok we have to actually parse it
+        const re = (0, exports.parsePattern)(pattern, options);
+        return typeof re === 'string' ? re : Object.assign(re, {
+            _glob: pattern,
+        });
+    }
+};
+// Optimized checking for the most common glob patterns.
+const starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+const starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);
+const starDotExtTestDot = (ext) => (f) => f.endsWith(ext);
+const starDotExtTestNocase = (ext) => {
+    ext = ext.toLowerCase();
+    return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);
+};
+const starDotExtTestNocaseDot = (ext) => {
+    ext = ext.toLowerCase();
+    return (f) => f.toLowerCase().endsWith(ext);
+};
+const starDotStarRE = /^\*+\.\*+$/;
+const starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');
+const starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');
+const dotStarRE = /^\.\*+$/;
+const dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');
+const starRE = /^\*+$/;
+const starTest = (f) => f.length !== 0 && !f.startsWith('.');
+const starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';
+const qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+const qmarksTestNocase = ([$0, ext = '']) => {
+    const noext = qmarksTestNoExt([$0]);
+    if (!ext)
+        return noext;
+    ext = ext.toLowerCase();
+    return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+const qmarksTestNocaseDot = ([$0, ext = '']) => {
+    const noext = qmarksTestNoExtDot([$0]);
+    if (!ext)
+        return noext;
+    ext = ext.toLowerCase();
+    return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+const qmarksTestDot = ([$0, ext = '']) => {
+    const noext = qmarksTestNoExtDot([$0]);
+    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+const qmarksTest = ([$0, ext = '']) => {
+    const noext = qmarksTestNoExt([$0]);
+    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+const qmarksTestNoExt = ([$0]) => {
+    const len = $0.length;
+    return (f) => f.length === len && !f.startsWith('.');
+};
+const qmarksTestNoExtDot = ([$0]) => {
+    const len = $0.length;
+    return (f) => f.length === len && f !== '.' && f !== '..';
+};
+//# sourceMappingURL=mini.js.map