Brunobkr/llama.cpp_AlgMor24_github

1"use strict";2Object.defineProperty(exports, "__esModule", { value: true });3exports.unescape = exports.escape = exports.AST = exports.Minimatch = exports.match = exports.makeRe = exports.braceExpand = exports.defaults = exports.filter = exports.GLOBSTAR = exports.sep = exports.minimatch = void 0;4const brace_expansion_1 = require("brace-expansion");5const assert_valid_pattern_js_1 = require("./assert-valid-pattern.js");6const ast_js_1 = require("./ast.js");7const escape_js_1 = require("./escape.js");8const unescape_js_1 = require("./unescape.js");9const minimatch = (p, pattern, options = {}) => {10    (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);11    // shortcut: comments match nothing.12    if (!options.nocomment && pattern.charAt(0) === '#') {13        return false;14    }15    return new Minimatch(pattern, options).match(p);16};17exports.minimatch = minimatch;18// Optimized checking for the most common glob patterns.19const starDotExtRE = /^\*+([^+@!?*[(]*)$/;20const starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);21const starDotExtTestDot = (ext) => (f) => f.endsWith(ext);22const starDotExtTestNocase = (ext) => {23    ext = ext.toLowerCase();24    return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);25};26const starDotExtTestNocaseDot = (ext) => {27    ext = ext.toLowerCase();28    return (f) => f.toLowerCase().endsWith(ext);29};30const starDotStarRE = /^\*+\.\*+$/;31const starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');32const starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');33const dotStarRE = /^\.\*+$/;34const dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');35const starRE = /^\*+$/;36const starTest = (f) => f.length !== 0 && !f.startsWith('.');37const starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';38const qmarksRE = /^\?+([^+@!?*[(]*)?$/;39const qmarksTestNocase = ([$0, ext = '']) => {40    const noext = qmarksTestNoExt([$0]);41    if (!ext)42        return noext;43    ext = ext.toLowerCase();44    return (f) => noext(f) && f.toLowerCase().endsWith(ext);45};46const qmarksTestNocaseDot = ([$0, ext = '']) => {47    const noext = qmarksTestNoExtDot([$0]);48    if (!ext)49        return noext;50    ext = ext.toLowerCase();51    return (f) => noext(f) && f.toLowerCase().endsWith(ext);52};53const qmarksTestDot = ([$0, ext = '']) => {54    const noext = qmarksTestNoExtDot([$0]);55    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);56};57const qmarksTest = ([$0, ext = '']) => {58    const noext = qmarksTestNoExt([$0]);59    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);60};61const qmarksTestNoExt = ([$0]) => {62    const len = $0.length;63    return (f) => f.length === len && !f.startsWith('.');64};65const qmarksTestNoExtDot = ([$0]) => {66    const len = $0.length;67    return (f) => f.length === len && f !== '.' && f !== '..';68};69/* c8 ignore start */70const defaultPlatform = (typeof process === 'object' && process ?71    (typeof process.env === 'object' &&72        process.env &&73        process.env.__MINIMATCH_TESTING_PLATFORM__) ||74        process.platform75    : 'posix');76const path = {77    win32: { sep: '\\' },78    posix: { sep: '/' },79};80/* c8 ignore stop */81exports.sep = defaultPlatform === 'win32' ? path.win32.sep : path.posix.sep;82exports.minimatch.sep = exports.sep;83exports.GLOBSTAR = Symbol('globstar **');84exports.minimatch.GLOBSTAR = exports.GLOBSTAR;85// any single thing other than /86// don't need to escape / when using new RegExp()87const qmark = '[^/]';88// * => any number of characters89const star = qmark + '*?';90// ** when dots are allowed.  Anything goes, except .. and .91// not (^ or / followed by one or two dots followed by $ or /),92// followed by anything, any number of times.93const twoStarDot = '(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?';94// not a ^ or / followed by a dot,95// followed by anything, any number of times.96const twoStarNoDot = '(?:(?!(?:\\/|^)\\.).)*?';97const filter = (pattern, options = {}) => (p) => (0, exports.minimatch)(p, pattern, options);98exports.filter = filter;99exports.minimatch.filter = exports.filter;100const ext = (a, b = {}) => Object.assign({}, a, b);101const defaults = (def) => {102    if (!def || typeof def !== 'object' || !Object.keys(def).length) {103        return exports.minimatch;104    }105    const orig = exports.minimatch;106    const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));107    return Object.assign(m, {108        Minimatch: class Minimatch extends orig.Minimatch {109            constructor(pattern, options = {}) {110                super(pattern, ext(def, options));111            }112            static defaults(options) {113                return orig.defaults(ext(def, options)).Minimatch;114            }115        },116        AST: class AST extends orig.AST {117            /* c8 ignore start */118            constructor(type, parent, options = {}) {119                super(type, parent, ext(def, options));120            }121            /* c8 ignore stop */122            static fromGlob(pattern, options = {}) {123                return orig.AST.fromGlob(pattern, ext(def, options));124            }125        },126        unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),127        escape: (s, options = {}) => orig.escape(s, ext(def, options)),128        filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),129        defaults: (options) => orig.defaults(ext(def, options)),130        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),131        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),132        match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),133        sep: orig.sep,134        GLOBSTAR: exports.GLOBSTAR,135    });136};137exports.defaults = defaults;138exports.minimatch.defaults = exports.defaults;139// Brace expansion:140// a{b,c}d -> abd acd141// a{b,}c -> abc ac142// a{0..3}d -> a0d a1d a2d a3d143// a{b,c{d,e}f}g -> abg acdfg acefg144// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg145//146// Invalid sets are not expanded.147// a{2..}b -> a{2..}b148// a{b}c -> a{b}c149const braceExpand = (pattern, options = {}) => {150    (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);151    // Thanks to Yeting Li <https://github.com/yetingli> for152    // improving this regexp to avoid a ReDOS vulnerability.153    if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {154        // shortcut. no need to expand.155        return [pattern];156    }157    return (0, brace_expansion_1.expand)(pattern, { max: options.braceExpandMax });158};159exports.braceExpand = braceExpand;160exports.minimatch.braceExpand = exports.braceExpand;161// parse a component of the expanded set.162// At this point, no pattern may contain "/" in it163// so we're going to return a 2d array, where each entry is the full164// pattern, split on '/', and then turned into a regular expression.165// A regexp is made at the end which joins each array with an166// escaped /, and another full one which joins each regexp with |.167//168// Following the lead of Bash 4.1, note that "**" only has special meaning169// when it is the *only* thing in a path portion.  Otherwise, any series170// of * is equivalent to a single *.  Globstar behavior is enabled by171// default, and can be disabled by setting options.noglobstar.172const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();173exports.makeRe = makeRe;174exports.minimatch.makeRe = exports.makeRe;175const match = (list, pattern, options = {}) => {176    const mm = new Minimatch(pattern, options);177    list = list.filter(f => mm.match(f));178    if (mm.options.nonull && !list.length) {179        list.push(pattern);180    }181    return list;182};183exports.match = match;184exports.minimatch.match = exports.match;185// replace stuff like \* with *186const globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;187const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');188class Minimatch {189    options;190    set;191    pattern;192    windowsPathsNoEscape;193    nonegate;194    negate;195    comment;196    empty;197    preserveMultipleSlashes;198    partial;199    globSet;200    globParts;201    nocase;202    isWindows;203    platform;204    windowsNoMagicRoot;205    maxGlobstarRecursion;206    regexp;207    constructor(pattern, options = {}) {208        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);209        options = options || {};210        this.options = options;211        this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;212        this.pattern = pattern;213        this.platform = options.platform || defaultPlatform;214        this.isWindows = this.platform === 'win32';215        // avoid the annoying deprecation flag lol216        const awe = ('allowWindow' + 'sEscape');217        this.windowsPathsNoEscape =218            !!options.windowsPathsNoEscape || options[awe] === false;219        if (this.windowsPathsNoEscape) {220            this.pattern = this.pattern.replace(/\\/g, '/');221        }222        this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;223        this.regexp = null;224        this.negate = false;225        this.nonegate = !!options.nonegate;226        this.comment = false;227        this.empty = false;228        this.partial = !!options.partial;229        this.nocase = !!this.options.nocase;230        this.windowsNoMagicRoot =231            options.windowsNoMagicRoot !== undefined ?232                options.windowsNoMagicRoot233                : !!(this.isWindows && this.nocase);234        this.globSet = [];235        this.globParts = [];236        this.set = [];237        // make the set of regexps etc.238        this.make();239    }240    hasMagic() {241        if (this.options.magicalBraces && this.set.length > 1) {242            return true;243        }244        for (const pattern of this.set) {245            for (const part of pattern) {246                if (typeof part !== 'string')247                    return true;248            }249        }250        return false;251    }252    debug(..._) { }253    make() {254        const pattern = this.pattern;255        const options = this.options;256        // empty patterns and comments match nothing.257        if (!options.nocomment && pattern.charAt(0) === '#') {258            this.comment = true;259            return;260        }261        if (!pattern) {262            this.empty = true;263            return;264        }265        // step 1: figure out negation, etc.266        this.parseNegate();267        // step 2: expand braces268        this.globSet = [...new Set(this.braceExpand())];269        if (options.debug) {270            //oxlint-disable-next-line no-console271            this.debug = (...args) => console.error(...args);272        }273        this.debug(this.pattern, this.globSet);274        // step 3: now we have a set, so turn each one into a series of275        // path-portion matching patterns.276        // These will be regexps, except in the case of "**", which is277        // set to the GLOBSTAR object for globstar behavior,278        // and will not contain any / characters279        //280        // First, we preprocess to make the glob pattern sets a bit simpler281        // and deduped.  There are some perf-killing patterns that can cause282        // problems with a glob walk, but we can simplify them down a bit.283        const rawGlobParts = this.globSet.map(s => this.slashSplit(s));284        this.globParts = this.preprocess(rawGlobParts);285        this.debug(this.pattern, this.globParts);286        // glob --> regexps287        let set = this.globParts.map((s, _, __) => {288            if (this.isWindows && this.windowsNoMagicRoot) {289                // check if it's a drive or unc path.290                const isUNC = s[0] === '' &&291                    s[1] === '' &&292                    (s[2] === '?' || !globMagic.test(s[2])) &&293                    !globMagic.test(s[3]);294                const isDrive = /^[a-z]:/i.test(s[0]);295                if (isUNC) {296                    return [297                        ...s.slice(0, 4),298                        ...s.slice(4).map(ss => this.parse(ss)),299                    ];300                }301                else if (isDrive) {302                    return [s[0], ...s.slice(1).map(ss => this.parse(ss))];303                }304            }305            return s.map(ss => this.parse(ss));306        });307        this.debug(this.pattern, set);308        // filter out everything that didn't compile properly.309        this.set = set.filter(s => s.indexOf(false) === -1);310        // do not treat the ? in UNC paths as magic311        if (this.isWindows) {312            for (let i = 0; i < this.set.length; i++) {313                const p = this.set[i];314                if (p[0] === '' &&315                    p[1] === '' &&316                    this.globParts[i][2] === '?' &&317                    typeof p[3] === 'string' &&318                    /^[a-z]:$/i.test(p[3])) {319                    p[2] = '?';320                }321            }322        }323        this.debug(this.pattern, this.set);324    }325    // various transforms to equivalent pattern sets that are326    // faster to process in a filesystem walk.  The goal is to327    // eliminate what we can, and push all ** patterns as far328    // to the right as possible, even if it increases the number329    // of patterns that we have to process.330    preprocess(globParts) {331        // if we're not in globstar mode, then turn ** into *332        if (this.options.noglobstar) {333            for (const partset of globParts) {334                for (let j = 0; j < partset.length; j++) {335                    if (partset[j] === '**') {336                        partset[j] = '*';337                    }338                }339            }340        }341        const { optimizationLevel = 1 } = this.options;342        if (optimizationLevel >= 2) {343            // aggressive optimization for the purpose of fs walking344            globParts = this.firstPhasePreProcess(globParts);345            globParts = this.secondPhasePreProcess(globParts);346        }347        else if (optimizationLevel >= 1) {348            // just basic optimizations to remove some .. parts349            globParts = this.levelOneOptimize(globParts);350        }351        else {352            // just collapse multiple ** portions into one353            globParts = this.adjascentGlobstarOptimize(globParts);354        }355        return globParts;356    }357    // just get rid of adjascent ** portions358    adjascentGlobstarOptimize(globParts) {359        return globParts.map(parts => {360            let gs = -1;361            while (-1 !== (gs = parts.indexOf('**', gs + 1))) {362                let i = gs;363                while (parts[i + 1] === '**') {364                    i++;365                }366                if (i !== gs) {367                    parts.splice(gs, i - gs);368                }369            }370            return parts;371        });372    }373    // get rid of adjascent ** and resolve .. portions374    levelOneOptimize(globParts) {375        return globParts.map(parts => {376            parts = parts.reduce((set, part) => {377                const prev = set[set.length - 1];378                if (part === '**' && prev === '**') {379                    return set;380                }381                if (part === '..') {382                    if (prev && prev !== '..' && prev !== '.' && prev !== '**') {383                        set.pop();384                        return set;385                    }386                }387                set.push(part);388                return set;389            }, []);390            return parts.length === 0 ? [''] : parts;391        });392    }393    levelTwoFileOptimize(parts) {394        if (!Array.isArray(parts)) {395            parts = this.slashSplit(parts);396        }397        let didSomething = false;398        do {399            didSomething = false;400            // <pre>/<e>/<rest> -> <pre>/<rest>401            if (!this.preserveMultipleSlashes) {402                for (let i = 1; i < parts.length - 1; i++) {403                    const p = parts[i];404                    // don't squeeze out UNC patterns405                    if (i === 1 && p === '' && parts[0] === '')406                        continue;407                    if (p === '.' || p === '') {408                        didSomething = true;409                        parts.splice(i, 1);410                        i--;411                    }412                }413                if (parts[0] === '.' &&414                    parts.length === 2 &&415                    (parts[1] === '.' || parts[1] === '')) {416                    didSomething = true;417                    parts.pop();418                }419            }420            // <pre>/<p>/../<rest> -> <pre>/<rest>421            let dd = 0;422            while (-1 !== (dd = parts.indexOf('..', dd + 1))) {423                const p = parts[dd - 1];424                if (p &&425                    p !== '.' &&426                    p !== '..' &&427                    p !== '**' &&428                    !(this.isWindows && /^[a-z]:$/i.test(p))) {429                    didSomething = true;430                    parts.splice(dd - 1, 2);431                    dd -= 2;432                }433            }434        } while (didSomething);435        return parts.length === 0 ? [''] : parts;436    }437    // First phase: single-pattern processing438    // <pre> is 1 or more portions439    // <rest> is 1 or more portions440    // <p> is any portion other than ., .., '', or **441    // <e> is . or ''442    //443    // **/.. is *brutal* for filesystem walking performance, because444    // it effectively resets the recursive walk each time it occurs,445    // and ** cannot be reduced out by a .. pattern part like a regexp446    // or most strings (other than .., ., and '') can be.447    //448    // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}449    // <pre>/<e>/<rest> -> <pre>/<rest>450    // <pre>/<p>/../<rest> -> <pre>/<rest>451    // **/**/<rest> -> **/<rest>452    //453    // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow454    // this WOULD be allowed if ** did follow symlinks, or * didn't455    firstPhasePreProcess(globParts) {456        let didSomething = false;457        do {458            didSomething = false;459            // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}460            for (let parts of globParts) {461                let gs = -1;462                while (-1 !== (gs = parts.indexOf('**', gs + 1))) {463                    let gss = gs;464                    while (parts[gss + 1] === '**') {465                        // <pre>/**/**/<rest> -> <pre>/**/<rest>466                        gss++;467                    }468                    // eg, if gs is 2 and gss is 4, that means we have 3 **469                    // parts, and can remove 2 of them.470                    if (gss > gs) {471                        parts.splice(gs + 1, gss - gs);472                    }473                    let next = parts[gs + 1];474                    const p = parts[gs + 2];475                    const p2 = parts[gs + 3];476                    if (next !== '..')477                        continue;478                    if (!p ||479                        p === '.' ||480                        p === '..' ||481                        !p2 ||482                        p2 === '.' ||483                        p2 === '..') {484                        continue;485                    }486                    didSomething = true;487                    // edit parts in place, and push the new one488                    parts.splice(gs, 1);489                    const other = parts.slice(0);490                    other[gs] = '**';491                    globParts.push(other);492                    gs--;493                }494                // <pre>/<e>/<rest> -> <pre>/<rest>495                if (!this.preserveMultipleSlashes) {496                    for (let i = 1; i < parts.length - 1; i++) {497                        const p = parts[i];498                        // don't squeeze out UNC patterns499                        if (i === 1 && p === '' && parts[0] === '')500                            continue;501                        if (p === '.' || p === '') {502                            didSomething = true;503                            parts.splice(i, 1);504                            i--;505                        }506                    }507                    if (parts[0] === '.' &&508                        parts.length === 2 &&509                        (parts[1] === '.' || parts[1] === '')) {510                        didSomething = true;511                        parts.pop();512                    }513                }514                // <pre>/<p>/../<rest> -> <pre>/<rest>515                let dd = 0;516                while (-1 !== (dd = parts.indexOf('..', dd + 1))) {517                    const p = parts[dd - 1];518                    if (p && p !== '.' && p !== '..' && p !== '**') {519                        didSomething = true;520                        const needDot = dd === 1 && parts[dd + 1] === '**';521                        const splin = needDot ? ['.'] : [];522                        parts.splice(dd - 1, 2, ...splin);523                        if (parts.length === 0)524                            parts.push('');525                        dd -= 2;526                    }527                }528            }529        } while (didSomething);530        return globParts;531    }532    // second phase: multi-pattern dedupes533    // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>534    // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>535    // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>536    //537    // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>538    // ^-- not valid because ** doens't follow symlinks539    secondPhasePreProcess(globParts) {540        for (let i = 0; i < globParts.length - 1; i++) {541            for (let j = i + 1; j < globParts.length; j++) {542                const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);543                if (matched) {544                    globParts[i] = [];545                    globParts[j] = matched;546                    break;547                }548            }549        }550        return globParts.filter(gs => gs.length);551    }552    partsMatch(a, b, emptyGSMatch = false) {553        let ai = 0;554        let bi = 0;555        let result = [];556        let which = '';557        while (ai < a.length && bi < b.length) {558            if (a[ai] === b[bi]) {559                result.push(which === 'b' ? b[bi] : a[ai]);560                ai++;561                bi++;562            }563            else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {564                result.push(a[ai]);565                ai++;566            }567            else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {568                result.push(b[bi]);569                bi++;570            }571            else if (a[ai] === '*' &&572                b[bi] &&573                (this.options.dot || !b[bi].startsWith('.')) &&574                b[bi] !== '**') {575                if (which === 'b')576                    return false;577                which = 'a';578                result.push(a[ai]);579                ai++;580                bi++;581            }582            else if (b[bi] === '*' &&583                a[ai] &&584                (this.options.dot || !a[ai].startsWith('.')) &&585                a[ai] !== '**') {586                if (which === 'a')587                    return false;588                which = 'b';589                result.push(b[bi]);590                ai++;591                bi++;592            }593            else {594                return false;595            }596        }597        // if we fall out of the loop, it means they two are identical598        // as long as their lengths match599        return a.length === b.length && result;600    }601    parseNegate() {602        if (this.nonegate)603            return;604        const pattern = this.pattern;605        let negate = false;606        let negateOffset = 0;607        for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {608            negate = !negate;609            negateOffset++;610        }611        if (negateOffset)612            this.pattern = pattern.slice(negateOffset);613        this.negate = negate;614    }615    // set partial to true to test if, for example,616    // "/a/b" matches the start of "/*/b/*/d"617    // Partial means, if you run out of file before you run618    // out of pattern, then that's fine, as long as all619    // the parts match.620    matchOne(file, pattern, partial = false) {621        let fileStartIndex = 0;622        let patternStartIndex = 0;623        // UNC paths like //?/X:/... can match X:/... and vice versa624        // Drive letters in absolute drive or unc paths are always compared625        // case-insensitively.626        if (this.isWindows) {627            const fileDrive = typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0]);628            const fileUNC = !fileDrive &&629                file[0] === '' &&630                file[1] === '' &&631                file[2] === '?' &&632                /^[a-z]:$/i.test(file[3]);633            const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);634            const patternUNC = !patternDrive &&635                pattern[0] === '' &&636                pattern[1] === '' &&637                pattern[2] === '?' &&638                typeof pattern[3] === 'string' &&639                /^[a-z]:$/i.test(pattern[3]);640            const fdi = fileUNC ? 3641                : fileDrive ? 0642                    : undefined;643            const pdi = patternUNC ? 3644                : patternDrive ? 0645                    : undefined;646            if (typeof fdi === 'number' && typeof pdi === 'number') {647                const [fd, pd] = [648                    file[fdi],649                    pattern[pdi],650                ];651                // start matching at the drive letter index of each652                if (fd.toLowerCase() === pd.toLowerCase()) {653                    pattern[pdi] = fd;654                    patternStartIndex = pdi;655                    fileStartIndex = fdi;656                }657            }658        }659        // resolve and reduce . and .. portions in the file as well.660        // don't need to do the second phase, because it's only one string[]661        const { optimizationLevel = 1 } = this.options;662        if (optimizationLevel >= 2) {663            file = this.levelTwoFileOptimize(file);664        }665        if (pattern.includes(exports.GLOBSTAR)) {666            return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);667        }668        return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);669    }670    #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {671        // split the pattern into head, tail, and middle of ** delimited parts672        const firstgs = pattern.indexOf(exports.GLOBSTAR, patternIndex);673        const lastgs = pattern.lastIndexOf(exports.GLOBSTAR);674        // split the pattern up into globstar-delimited sections675        // the tail has to be at the end, and the others just have676        // to be found in order from the head.677        const [head, body, tail] = partial ?678            [679                pattern.slice(patternIndex, firstgs),680                pattern.slice(firstgs + 1),681                [],682            ]683            : [684                pattern.slice(patternIndex, firstgs),685                pattern.slice(firstgs + 1, lastgs),686                pattern.slice(lastgs + 1),687            ];688        // check the head, from the current file/pattern index.689        if (head.length) {690            const fileHead = file.slice(fileIndex, fileIndex + head.length);691            if (!this.#matchOne(fileHead, head, partial, 0, 0)) {692                return false;693            }694            fileIndex += head.length;695            patternIndex += head.length;696        }697        // now we know the head matches!698        // if the last portion is not empty, it MUST match the end699        // check the tail700        let fileTailMatch = 0;701        if (tail.length) {702            // if head + tail > file, then we cannot possibly match703            if (tail.length + fileIndex > file.length)704                return false;705            // try to match the tail706            let tailStart = file.length - tail.length;707            if (this.#matchOne(file, tail, partial, tailStart, 0)) {708                fileTailMatch = tail.length;709            }710            else {711                // affordance for stuff like a/**/* matching a/b/712                // if the last file portion is '', and there's more to the pattern713                // then try without the '' bit.714                if (file[file.length - 1] !== '' ||715                    fileIndex + tail.length === file.length) {716                    return false;717                }718                tailStart--;719                if (!this.#matchOne(file, tail, partial, tailStart, 0)) {720                    return false;721                }722                fileTailMatch = tail.length + 1;723            }724        }725        // now we know the tail matches!726        // the middle is zero or more portions wrapped in **, possibly727        // containing more ** sections.728        // so a/**/b/**/c/**/d has become **/b/**/c/**729        // if it's empty, it means a/**/b, just verify we have no bad dots730        // if there's no tail, so it ends on /**, then we must have *something*731        // after the head, or it's not a matc732        if (!body.length) {733            let sawSome = !!fileTailMatch;734            for (let i = fileIndex; i < file.length - fileTailMatch; i++) {735                const f = String(file[i]);736                sawSome = true;737                if (f === '.' ||738                    f === '..' ||739                    (!this.options.dot && f.startsWith('.'))) {740                    return false;741                }742            }743            // in partial mode, we just need to get past all file parts744            return partial || sawSome;745        }746        // now we know that there's one or more body sections, which can747        // be matched anywhere from the 0 index (because the head was pruned)748        // through to the length-fileTailMatch index.749        // split the body up into sections, and note the minimum index it can750        // be found at (start with the length of all previous segments)751        // [section, before, after]752        const bodySegments = [[[], 0]];753        let currentBody = bodySegments[0];754        let nonGsParts = 0;755        const nonGsPartsSums = [0];756        for (const b of body) {757            if (b === exports.GLOBSTAR) {758                nonGsPartsSums.push(nonGsParts);759                currentBody = [[], 0];760                bodySegments.push(currentBody);761            }762            else {763                currentBody[0].push(b);764                nonGsParts++;765            }766        }767        let i = bodySegments.length - 1;768        const fileLength = file.length - fileTailMatch;769        for (const b of bodySegments) {770            b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);771        }772        return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);773    }774    // return false for "nope, not matching"775    // return null for "not matching, cannot keep trying"776    #matchGlobStarBodySections(file, 777    // pattern section, last possible position for it778    bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {779        // take the first body segment, and walk from fileIndex to its "after"780        // value at the end781        // If it doesn't match at that position, we increment, until we hit782        // that final possible position, and give up.783        // If it does match, then advance and try to rest.784        // If any of them fail we keep walking forward.785        // this is still a bit recursively painful, but it's more constrained786        // than previous implementations, because we never test something that787        // can't possibly be a valid matching condition.788        const bs = bodySegments[bodyIndex];789        if (!bs) {790            // just make sure that there's no bad dots791            for (let i = fileIndex; i < file.length; i++) {792                sawTail = true;793                const f = file[i];794                if (f === '.' ||795                    f === '..' ||796                    (!this.options.dot && f.startsWith('.'))) {797                    return false;798                }799            }800            return sawTail;801        }802        // have a non-globstar body section to test803        const [body, after] = bs;804        while (fileIndex <= after) {805            const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);806            // if limit exceeded, no match. intentional false negative,807            // acceptable break in correctness for security.808            if (m && globStarDepth < this.maxGlobstarRecursion) {809                // match! see if the rest match. if so, we're done!810                const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);811                if (sub !== false) {812                    return sub;813                }814            }815            const f = file[fileIndex];816            if (f === '.' ||817                f === '..' ||818                (!this.options.dot && f.startsWith('.'))) {819                return false;820            }821            fileIndex++;822        }823        // walked off. no point continuing824        return partial || null;825    }826    #matchOne(file, pattern, partial, fileIndex, patternIndex) {827        let fi;828        let pi;829        let pl;830        let fl;831        for (fi = fileIndex,832            pi = patternIndex,833            fl = file.length,834            pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {835            this.debug('matchOne loop');836            let p = pattern[pi];837            let f = file[fi];838            this.debug(pattern, p, f);839            // should be impossible.840            // some invalid regexp stuff in the set.841            /* c8 ignore start */842            if (p === false || p === exports.GLOBSTAR) {843                return false;844            }845            /* c8 ignore stop */846            // something other than **847            // non-magic patterns just have to match exactly848            // patterns with magic have been turned into regexps.849            let hit;850            if (typeof p === 'string') {851                hit = f === p;852                this.debug('string match', p, f, hit);853            }854            else {855                hit = p.test(f);856                this.debug('pattern match', p, f, hit);857            }858            if (!hit)859                return false;860        }861        // Note: ending in / means that we'll get a final ""862        // at the end of the pattern.  This can only match a863        // corresponding "" at the end of the file.864        // If the file ends in /, then it can only match a865        // a pattern that ends in /, unless the pattern just866        // doesn't have any more for it. But, a/b/ should *not*867        // match "a/b/*", even though "" matches against the868        // [^/]*? pattern, except in partial mode, where it might869        // simply not be reached yet.870        // However, a/b/ should still satisfy a/*871        // now either we fell off the end of the pattern, or we're done.872        if (fi === fl && pi === pl) {873            // ran out of pattern and filename at the same time.874            // an exact hit!875            return true;876        }877        else if (fi === fl) {878            // ran out of file, but still had pattern left.879            // this is ok if we're doing the match as part of880            // a glob fs traversal.881            return partial;882        }883        else if (pi === pl) {884            // ran out of pattern, still have file left.885            // this is only acceptable if we're on the very last886            // empty segment of a file with a trailing slash.887            // a/* should match a/b/888            return fi === fl - 1 && file[fi] === '';889            /* c8 ignore start */890        }891        else {892            // should be unreachable.893            throw new Error('wtf?');894        }895        /* c8 ignore stop */896    }897    braceExpand() {898        return (0, exports.braceExpand)(this.pattern, this.options);899    }900    parse(pattern) {901        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);902        const options = this.options;903        // shortcuts904        if (pattern === '**')905            return exports.GLOBSTAR;906        if (pattern === '')907            return '';908        // far and away, the most common glob pattern parts are909        // *, *.*, and *.<ext>  Add a fast check method for those.910        let m;911        let fastTest = null;912        if ((m = pattern.match(starRE))) {913            fastTest = options.dot ? starTestDot : starTest;914        }915        else if ((m = pattern.match(starDotExtRE))) {916            fastTest = (options.nocase ?917                options.dot ?918                    starDotExtTestNocaseDot919                    : starDotExtTestNocase920                : options.dot ? starDotExtTestDot921                    : starDotExtTest)(m[1]);922        }923        else if ((m = pattern.match(qmarksRE))) {924            fastTest = (options.nocase ?925                options.dot ?926                    qmarksTestNocaseDot927                    : qmarksTestNocase928                : options.dot ? qmarksTestDot929                    : qmarksTest)(m);930        }931        else if ((m = pattern.match(starDotStarRE))) {932            fastTest = options.dot ? starDotStarTestDot : starDotStarTest;933        }934        else if ((m = pattern.match(dotStarRE))) {935            fastTest = dotStarTest;936        }937        const re = ast_js_1.AST.fromGlob(pattern, this.options).toMMPattern();938        if (fastTest && typeof re === 'object') {939            // Avoids overriding in frozen environments940            Reflect.defineProperty(re, 'test', { value: fastTest });941        }942        return re;943    }944    makeRe() {945        if (this.regexp || this.regexp === false)946            return this.regexp;947        // at this point, this.set is a 2d array of partial948        // pattern strings, or "**".949        //950        // It's better to use .match().  This function shouldn't951        // be used, really, but it's pretty convenient sometimes,952        // when you just want to work with a regex.953        const set = this.set;954        if (!set.length) {955            this.regexp = false;956            return this.regexp;957        }958        const options = this.options;959        const twoStar = options.noglobstar ? star960            : options.dot ? twoStarDot961                : twoStarNoDot;962        const flags = new Set(options.nocase ? ['i'] : []);963        // regexpify non-globstar patterns964        // if ** is only item, then we just do one twoStar965        // if ** is first, and there are more, prepend (\/|twoStar\/)? to next966        // if ** is last, append (\/twoStar|) to previous967        // if ** is in the middle, append (\/|\/twoStar\/) to previous968        // then filter out GLOBSTAR symbols969        let re = set970            .map(pattern => {971            const pp = pattern.map(p => {972                if (p instanceof RegExp) {973                    for (const f of p.flags.split(''))974                        flags.add(f);975                }976                return (typeof p === 'string' ? regExpEscape(p)977                    : p === exports.GLOBSTAR ? exports.GLOBSTAR978                        : p._src);979            });980            pp.forEach((p, i) => {981                const next = pp[i + 1];982                const prev = pp[i - 1];983                if (p !== exports.GLOBSTAR || prev === exports.GLOBSTAR) {984                    return;985                }986                if (prev === undefined) {987                    if (next !== undefined && next !== exports.GLOBSTAR) {988                        pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next;989                    }990                    else {991                        pp[i] = twoStar;992                    }993                }994                else if (next === undefined) {995                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + ')?';996                }997                else if (next !== exports.GLOBSTAR) {998                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;999                    pp[i + 1] = exports.GLOBSTAR;1000                }1001            });1002            const filtered = pp.filter(p => p !== exports.GLOBSTAR);1003            // For partial matches, we need to make the pattern match1004            // any prefix of the full path. We do this by generating1005            // alternative patterns that match progressively longer prefixes.1006            if (this.partial && filtered.length >= 1) {1007                const prefixes = [];1008                for (let i = 1; i <= filtered.length; i++) {1009                    prefixes.push(filtered.slice(0, i).join('/'));1010                }1011                return '(?:' + prefixes.join('|') + ')';1012            }1013            return filtered.join('/');1014        })1015            .join('|');1016        // need to wrap in parens if we had more than one thing with |,1017        // otherwise only the first will be anchored to ^ and the last to $1018        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];1019        // must match entire pattern1020        // ending in a * or ** will make it less strict.1021        re = '^' + open + re + close + '$';1022        // In partial mode, '/' should always match as it's a valid prefix for any pattern1023        if (this.partial) {1024            re = '^(?:\\/|' + open + re.slice(1, -1) + close + ')$';1025        }1026        // can match anything, as long as it's not this.1027        if (this.negate)1028            re = '^(?!' + re + ').+$';1029        try {1030            this.regexp = new RegExp(re, [...flags].join(''));1031            /* c8 ignore start */1032        }1033        catch {1034            // should be impossible1035            this.regexp = false;1036        }1037        /* c8 ignore stop */1038        return this.regexp;1039    }1040    slashSplit(p) {1041        // if p starts with // on windows, we preserve that1042        // so that UNC paths aren't broken.  Otherwise, any number of1043        // / characters are coalesced into one, unless1044        // preserveMultipleSlashes is set to true.1045        if (this.preserveMultipleSlashes) {1046            return p.split('/');1047        }1048        else if (this.isWindows && /^\/\/[^/]+/.test(p)) {1049            // add an extra '' for the one we lose1050            return ['', ...p.split(/\/+/)];1051        }1052        else {1053            return p.split(/\/+/);1054        }1055    }1056    match(f, partial = this.partial) {1057        this.debug('match', f, this.pattern);1058        // short-circuit in the case of busted things.1059        // comments, etc.1060        if (this.comment) {1061            return false;1062        }1063        if (this.empty) {1064            return f === '';1065        }1066        if (f === '/' && partial) {1067            return true;1068        }1069        const options = this.options;1070        // windows: need to use /, not \1071        if (this.isWindows) {1072            f = f.split('\\').join('/');1073        }1074        // treat the test path as a set of pathparts.1075        const ff = this.slashSplit(f);1076        this.debug(this.pattern, 'split', ff);1077        // just ONE of the pattern sets in this.set needs to match1078        // in order for it to be valid.  If negating, then just one1079        // match means that we have failed.1080        // Either way, return on the first hit.1081        const set = this.set;1082        this.debug(this.pattern, 'set', set);1083        // Find the basename of the path by looking for the last non-empty segment1084        let filename = ff[ff.length - 1];1085        if (!filename) {1086            for (let i = ff.length - 2; !filename && i >= 0; i--) {1087                filename = ff[i];1088            }1089        }1090        for (const pattern of set) {1091            let file = ff;1092            if (options.matchBase && pattern.length === 1) {1093                file = [filename];1094            }1095            const hit = this.matchOne(file, pattern, partial);1096            if (hit) {1097                if (options.flipNegate) {1098                    return true;1099                }1100                return !this.negate;1101            }1102        }1103        // didn't get any hits.  this is success if it's a negative1104        // pattern, failure otherwise.1105        if (options.flipNegate) {1106            return false;1107        }1108        return this.negate;1109    }1110    static defaults(def) {1111        return exports.minimatch.defaults(def).Minimatch;1112    }1113}1114exports.Minimatch = Minimatch;1115/* c8 ignore start */1116var ast_js_2 = require("./ast.js");1117Object.defineProperty(exports, "AST", { enumerable: true, get: function () { return ast_js_2.AST; } });1118var escape_js_2 = require("./escape.js");1119Object.defineProperty(exports, "escape", { enumerable: true, get: function () { return escape_js_2.escape; } });1120var unescape_js_2 = require("./unescape.js");1121Object.defineProperty(exports, "unescape", { enumerable: true, get: function () { return unescape_js_2.unescape; } });1122/* c8 ignore stop */1123exports.minimatch.AST = ast_js_1.AST;1124exports.minimatch.Minimatch = Minimatch;1125exports.minimatch.escape = escape_js_1.escape;1126exports.minimatch.unescape = unescape_js_1.unescape;1127//# sourceMappingURL=index.js.map