Mini Shell

"use strict";
// parse a single path portion
Object.defineProperty(exports, "__esModule", { value: true });
exports.AST = void 0;
const brace_expressions_1 = require("./brace-expressions");
const types = new Set(['!', '?', '+', '*', '@']);
const isExtglobType = (c) => types.has(c);
// characters that indicate a start of pattern needs the "no dots" bit
const addPatternStart = new Set(['[', '.']);
const justDots = new Set(['..', '.']);
const reSpecials = new Set('().*{}+?[]^$\\!');
const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
// any single thing other than /
// don't need to escape / when using new RegExp()
const qmark = '[^/]';
// * => any number of characters
const star = qmark + '*?';
class AST {
    type;
    #root;
    #parts = [];
    #parent;
    #parentIndex;
    #negs;
    #filledNegs = false;
    #options;
    constructor(type, parent, options = {}) {
        this.type = type;
        this.#parent = parent;
        this.#root = this.#parent ? this.#parent.#root : this;
        this.#options = this.#root === this ? options : this.#root.#options;
        this.#negs = this.#root === this ? [] : this.#root.#negs;
        if (type === '!' && !this.#root.#filledNegs)
            this.#negs.push(this);
        this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
    }
    fillNegs() {
        if (this !== this.#root) {
            this.#root.fillNegs();
            return this;
        }
        if (this.#filledNegs)
            return this;
        this.#filledNegs = true;
        let n;
        while ((n = this.#negs.pop())) {
            if (n.type !== '!')
                continue;
            // walk up the tree, appending everthing that comes AFTER parentIndex
            let p = n;
            let pp = p.#parent;
            while (pp) {
                for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
                    for (const part of n.#parts) {
                        /* c8 ignore start */
                        if (typeof part === 'string') {
                            throw new Error('string part in extglob AST??');
                        }
                        /* c8 ignore stop */
                        part.copyIn(pp.#parts[i]);
                    }
                }
                p = pp;
                pp = p.#parent;
            }
        }
        return this;
    }
    push(...parts) {
        for (const p of parts) {
            if (p === '')
                continue;
            /* c8 ignore start */
            if (typeof p !== 'string' && !(p instanceof AST && p.#parent === this)) {
                throw new Error('invalid part: ' + p);
            }
            /* c8 ignore stop */
            this.#parts.push(p);
        }
    }
    toJSON() {
        const ret = this.type === null ? this.#parts.slice() : [this.type, ...this.#parts];
        if (this.isStart() && !this.type)
            ret.unshift([]);
        if (this.isEnd() &&
            (this === this.#root ||
                (this.#root.#filledNegs && this.#parent?.type === '!'))) {
            ret.push({});
        }
        return ret;
    }
    isStart() {
        if (this.#root === this)
            return true;
        // if (this.type) return !!this.#parent?.isStart()
        if (!this.#parent?.isStart())
            return false;
        return this.#parentIndex === 0;
    }
    isEnd() {
        if (this.#root === this)
            return true;
        if (this.#parent?.type === '!')
            return true;
        if (!this.#parent?.isEnd())
            return false;
        if (!this.type)
            return this.#parent?.isEnd();
        return (this.#parentIndex === (this.#parent ? this.#parent.#parts.length : 0) - 1);
    }
    copyIn(part) {
        if (typeof part === 'string')
            this.push(part);
        else
            this.push(part.clone(this));
    }
    clone(parent) {
        const c = new AST(this.type, parent);
        for (const p of this.#parts) {
            c.copyIn(p);
        }
        return c;
    }
    static #parseAST(str, ast, pos, opt) {
        let escaping = false;
        if (ast.type === null) {
            // outside of a extglob, append until we find a start
            let i = pos;
            let acc = '';
            while (i < str.length) {
                const c = str.charAt(i++);
                // still accumulate escapes at this point, but we do ignore
                // starts that are escaped
                if (escaping || c === '\\') {
                    escaping = !escaping;
                    acc += c;
                    continue;
                }
                if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {
                    ast.push(acc);
                    acc = '';
                    const ext = new AST(c, ast);
                    i = AST.#parseAST(str, ext, i, opt);
                    ast.push(ext);
                    continue;
                }
                acc += c;
            }
            ast.push(acc);
            return i;
        }
        // some kind of extglob, pos is at the (
        // find the next | or )
        let i = pos + 1;
        let part = new AST(null, ast);
        const parts = [];
        let acc = '';
        while (i < str.length) {
            const c = str.charAt(i++);
            // still accumulate escapes at this point, but we do ignore
            // starts that are escaped
            if (escaping || c === '\\') {
                escaping = !escaping;
                acc += c;
                continue;
            }
            if (isExtglobType(c) && str.charAt(i) === '(') {
                part.push(acc);
                acc = '';
                const ext = new AST(c, part);
                part.push(ext);
                i = AST.#parseAST(str, ext, i, opt);
                continue;
            }
            if (c === '|') {
                part.push(acc);
                acc = '';
                parts.push(part);
                part = new AST(null, ast);
                continue;
            }
            if (c === ')') {
                part.push(acc);
                acc = '';
                ast.push(...parts, part);
                return i;
            }
            acc += c;
        }
        // if we got here, it was a malformed extglob! not an extglob, but
        // maybe something else in there.
        ast.type = null;
        ast.#parts = [str.substring(pos)];
        return i;
    }
    static fromGlob(pattern, options = {}) {
        const ast = new AST(null, undefined, options);
        AST.#parseAST(pattern, ast, 0, options);
        console.log('parsed', pattern, JSON.stringify(ast));
        return ast;
    }
    toRegExpSource() {
        if (this.#root === this)
            this.fillNegs();
        if (!this.type) {
            const src = this.#parts
                .map(p => {
                if (typeof p === 'string')
                    return AST.#parseGlob(p, this.#options);
                else
                    return p.toRegExpSource();
            })
                .join('');
            let start = '';
            if (this.isStart() && typeof this.#parts[0] === 'string') {
                // '.' and '..' cannot match unless the pattern is that exactly
                const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
                if (dotTravAllowed) {
                    start = '(?:^|\\/)';
                }
                else {
                    const dotsAllowed = this.#options.dot ||
                        // no need to prevent dots if it can't match a dot, or if a sub-pattern
                        // will be preventing it anyway.
                        !addPatternStart.has(src.charAt(0));
                    start = dotsAllowed ? '(?!(?:^|\\/)\\.{1,2}(?:$|\\/))' : '(?!\\.)';
                }
            }
            let end = '';
            if (this.isEnd() &&
                (this === this.#root ||
                    (this.#root.#filledNegs && this.#parent?.type === '!'))) {
                end = '(?:$|\\/)';
            }
            return start + src + end;
        }
        // some kind of extglob
        const start = this.type === '!' ? '(?:(?!(?:' : '(?:';
        const body = this.#parts
            .map(p => {
            /* c8 ignore start */
            if (typeof p === 'string') {
                throw new Error('string type in extglob ast??');
            }
            /* c8 ignore stop */
            return p.toRegExpSource();
        })
            .join('|');
        const close = this.type === '!'
            ? '))[^/]*?)'
            : this.type === '@'
                ? ')'
                : `)${this.type}`;
        return start + body + close;
    }
    static #parseGlob(glob, options) {
        let escaping = false;
        let re = '';
        let uflag = false;
        let hasMagic = false;
        for (let i = 0; i < glob.length; i++) {
            const c = glob.charAt(i);
            if (escaping) {
                escaping = false;
                re += (reSpecials.has(c) ? '\\' : '') + c;
                continue;
            }
            if (c === '\\') {
                if (i === glob.length - 1) {
                    re += '\\\\';
                }
                else {
                    escaping = true;
                }
                continue;
            }
            if (c === '[') {
                const [src, needUflag, consumed, magic] = (0, brace_expressions_1.parseClass)(glob, i);
                if (consumed) {
                    re += src;
                    uflag = uflag || needUflag;
                    i += consumed - 1;
                    hasMagic = hasMagic || magic;
                    continue;
                }
            }
            if (c === '*') {
                re += star;
                hasMagic = true;
                continue;
            }
            if (c === '?') {
                re += qmark;
                hasMagic = true;
                continue;
            }
            re += regExpEscape(c);
        }
        return re;
    }
}
exports.AST = AST;
const pattern = 'a@(i|w!(x|y)z+(l|m)|j)';
const ast = AST.fromGlob(pattern).fillNegs();
console.log('negged', pattern, JSON.stringify(ast));
console.log('to re src', pattern, ast.toRegExpSource());
// // the type (exttype or null for strings), and array of children tokens
//
// // append everything after a negative extglob to each of the parts
// // of the negative extglob node.  So, eg, [a, [!, x, y], z]
//
// //
// //
// //
// //
//
// const globUnescape = (s: string) => s.replace(/\\(.)/g, '$1')
// const regExpEscape = (s: string) =>
//   s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
//
// // "abc" -> { a:true, b:true, c:true }
// const charSet = (s: string) =>
//   s.split('').reduce((set: { [k: string]: boolean }, c) => {
//     set[c] = true
//     return set
//   }, {})
//
// // characters that need to be escaped in RegExp.
// const reSpecials = charSet('().*{}+?[]^$\\!')
//
// // characters that indicate we have to add the pattern start
// const addPatternStartSet = charSet('[.(')
//
// // any single thing other than /
// // don't need to escape / when using new RegExp()
// const qmark = '[^/]'
//
// // * => any number of characters
// const star = qmark + '*?'
//
// // TODO: take an offset and length, so we can sub-parse the extglobs
// const parse = (
//   options: MinimatchOptions,
//   pattern: string,
//   debug: (...a: any[]) => void
// ): false | string => {
//   assertValidPattern(pattern)
//
//   if (pattern === '') return ''
//
//   let re = ''
//   let hasMagic = false
//   let escaping = false
//   // ? => one single character
//   let uflag = false
//
//   // . and .. never match anything that doesn't start with .,
//   // even when options.dot is set.  However, if the pattern
//   // starts with ., then traversal patterns can match.
//   let dotTravAllowed = pattern.charAt(0) === '.'
//   let dotFileAllowed = options.dot || dotTravAllowed
//   const patternStart = () =>
//     dotTravAllowed
//       ? ''
//       : dotFileAllowed
//       ? '(?!(?:^|\\/)\\.{1,2}(?:$|\\/))'
//       : '(?!\\.)'
//   const subPatternStart = (p: string) =>
//     p.charAt(0) === '.'
//       ? ''
//       : options.dot
//       ? '(?!(?:^|\\/)\\.{1,2}(?:$|\\/))'
//       : '(?!\\.)'
//
//   const clearStateChar = () => {
//     if (stateChar) {
//       // we had some state-tracking character
//       // that wasn't consumed by this pass.
//       switch (stateChar) {
//         case '*':
//           re += star
//           hasMagic = true
//           break
//         case '?':
//           re += qmark
//           hasMagic = true
//           break
//         default:
//           re += '\\' + stateChar
//           break
//       }
//       debug('clearStateChar %j %j', stateChar, re)
//       stateChar = false
//     }
//   }
//
//   for (
//     let i = 0, c: string;
//     i < pattern.length && (c = pattern.charAt(i));
//     i++
//   ) {
//     debug('%s\t%s %s %j', pattern, i, re, c)
//
//     // skip over any that are escaped.
//     if (escaping) {
//       // completely not allowed, even escaped.
//       // should be impossible.
//       /* c8 ignore start */
//       if (c === '/') {
//         return false
//       }
//       /* c8 ignore stop */
//
//       if (reSpecials[c]) {
//         re += '\\'
//       }
//       re += c
//       escaping = false
//       continue
//     }
//
//     switch (c) {
//       // Should already be path-split by now.
//       /* c8 ignore start */
//       case '/': {
//         return false
//       }
//       /* c8 ignore stop */
//
//       case '\\':
//         clearStateChar()
//         escaping = true
//         continue
//
//       // the various stateChar values
//       // for the "extglob" stuff.
//       case '?':
//       case '*':
//       case '+':
//       case '@':
//       case '!':
//         debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
//
//         // if we already have a stateChar, then it means
//         // that there was something like ** or +? in there.
//         // Handle the stateChar, then proceed with this one.
//         debug('call clearStateChar %j', stateChar)
//         clearStateChar()
//         stateChar = c
//         // if extglob is disabled, then +(asdf|foo) isn't a thing.
//         // just clear the statechar *now*, rather than even diving into
//         // the patternList stuff.
//         if (options.noext) clearStateChar()
//         continue
//
//       case '(': {
//         if (!stateChar) {
//           re += '\\('
//           continue
//         }
//
//         const plEntry: PatternListEntry = {
//           type: stateChar,
//           start: i - 1,
//           reStart: re.length,
//           open: plTypes[stateChar].open,
//           close: plTypes[stateChar].close,
//         }
//         debug(pattern, '\t', plEntry)
//         patternListStack.push(plEntry)
//         // negation is (?:(?!(?:js)(?:<rest>))[^/]*)
//         re += plEntry.open
//         // next entry starts with a dot maybe?
//         if (plEntry.start === 0 && plEntry.type !== '!') {
//           dotTravAllowed = true
//           re += subPatternStart(pattern.slice(i + 1))
//         }
//         debug('plType %j %j', stateChar, re)
//         stateChar = false
//         continue
//       }
//
//       case ')': {
//         const plEntry = patternListStack[patternListStack.length - 1]
//         if (!plEntry) {
//           re += '\\)'
//           continue
//         }
//         patternListStack.pop()
//
//         // closing an extglob
//         clearStateChar()
//         hasMagic = true
//         pl = plEntry
//         // negation is (?:(?!js)[^/]*)
//         // The others are (?:<pattern>)<type>
//         re += pl.close
//         if (pl.type === '!') {
//           negativeLists.push(Object.assign(pl, { reEnd: re.length }))
//         }
//         continue
//       }
//
//       case '|': {
//         const plEntry = patternListStack[patternListStack.length - 1]
//         if (!plEntry) {
//           re += '\\|'
//           continue
//         }
//
//         clearStateChar()
//         re += '|'
//         // next subpattern can start with a dot?
//         if (plEntry.start === 0 && plEntry.type !== '!') {
//           dotTravAllowed = true
//           re += subPatternStart(pattern.slice(i + 1))
//         }
//         continue
//       }
//
//       // these are mostly the same in regexp and glob
//       case '[':
//         // swallow any state-tracking char before the [
//         clearStateChar()
//         const [src, needUflag, consumed, magic] = parseClass(pattern, i)
//         if (consumed) {
//           re += src
//           uflag = uflag || needUflag
//           i += consumed - 1
//           hasMagic = hasMagic || magic
//         } else {
//           re += '\\['
//         }
//         continue
//
//       case ']':
//         re += '\\' + c
//         continue
//
//       default:
//         // swallow any state char that wasn't consumed
//         clearStateChar()
//
//         re += regExpEscape(c)
//         break
//     } // switch
//   } // for
//
//   // handle the case where we had a +( thing at the *end*
//   // of the pattern.
//   // each pattern list stack adds 3 chars, and we need to go through
//   // and escape any | chars that were passed through as-is for the regexp.
//   // Go through and escape them, taking care not to double-escape any
//   // | chars that were already escaped.
//   for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
//     let tail: string
//     tail = re.slice(pl.reStart + pl.open.length)
//     debug(pattern, 'setting tail', re, pl)
//     // maybe some even number of \, then maybe 1 \, followed by a |
//     tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
//       if (!$2) {
//         // the | isn't already escaped, so escape it.
//         $2 = '\\'
//         // should already be done
//         /* c8 ignore start */
//       }
//       /* c8 ignore stop */
//
//       // need to escape all those slashes *again*, without escaping the
//       // one that we need for escaping the | character.  As it works out,
//       // escaping an even number of slashes can be done by simply repeating
//       // it exactly after itself.  That's why this trick works.
//       //
//       // I am sorry that you have to see this.
//       return $1 + $1 + $2 + '|'
//     })
//
//     debug('tail=%j\n   %s', tail, tail, pl, re)
//     const t = pl.type === '*' ? star : pl.type === '?' ? qmark : '\\' + pl.type
//
//     hasMagic = true
//     re = re.slice(0, pl.reStart) + t + '\\(' + tail
//   }
//
//   // handle trailing things that only matter at the very end.
//   clearStateChar()
//   if (escaping) {
//     // trailing \\
//     re += '\\\\'
//   }
//
//   // only need to apply the nodot start if the re starts with
//   // something that could conceivably capture a dot
//   const addPatternStart = addPatternStartSet[re.charAt(0)]
//
//   // Hack to work around lack of negative lookbehind in JS
//   // A pattern like: *.!(x).!(y|z) needs to ensure that a name
//   // like 'a.xyz.yz' doesn't match.  So, the first negative
//   // lookahead, has to look ALL the way ahead, to the end of
//   // the pattern.
//   for (let n = negativeLists.length - 1; n > -1; n--) {
//     const nl = negativeLists[n]
//
//     const nlBefore = re.slice(0, nl.reStart)
//     const nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
//     let nlAfter = re.slice(nl.reEnd)
//     const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter
//
//     // Handle nested stuff like *(*.js|!(*.json)), where open parens
//     // mean that we should *not* include the ) in the bit that is considered
//     // "after" the negated section.
//     const closeParensBefore = nlBefore.split(')').length
//     const openParensBefore = nlBefore.split('(').length - closeParensBefore
//     let cleanAfter = nlAfter
//     for (let i = 0; i < openParensBefore; i++) {
//       cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
//     }
//     nlAfter = cleanAfter
//
//     const dollar = nlAfter === '' ? '(?:$|\\/)' : ''
//
//     re = nlBefore + nlFirst + nlAfter + dollar + nlLast
//   }
//
//   // if the re is not "" at this point, then we need to make sure
//   // it doesn't match against an empty path part.
//   // Otherwise a/* will match a/, which it should not.
//   if (re !== '' && hasMagic) {
//     re = '(?=.)' + re
//   }
//
//   if (addPatternStart) {
//     re = patternStart() + re
//   }
//
//   // if it's nocase, and the lcase/uppercase don't match, it's magic
//   if (options.nocase && !hasMagic && !options.nocaseMagicOnly) {
//     hasMagic = pattern.toUpperCase() !== pattern.toLowerCase()
//   }
//
//   // skip the regexp for non-magical patterns
//   // unescape anything in it, though, so that it'll be
//   // an exact match against a file etc.
//   if (!hasMagic) {
//     return globUnescape(re)
//   }
//
//   return re
// }
//# sourceMappingURL=parse.js.map