summaryrefslogtreecommitdiff
path: root/deps/npm/node_modules/minimatch/dist/cjs/parse.js
diff options
context:
space:
mode:
Diffstat (limited to 'deps/npm/node_modules/minimatch/dist/cjs/parse.js')
-rw-r--r--deps/npm/node_modules/minimatch/dist/cjs/parse.js650
1 files changed, 0 insertions, 650 deletions
diff --git a/deps/npm/node_modules/minimatch/dist/cjs/parse.js b/deps/npm/node_modules/minimatch/dist/cjs/parse.js
deleted file mode 100644
index 2fff625bcb..0000000000
--- a/deps/npm/node_modules/minimatch/dist/cjs/parse.js
+++ /dev/null
@@ -1,650 +0,0 @@
-"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 \ No newline at end of file
View Lorry Controller Status