@catheadowl/pathscope 0.2.0 → 0.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +124 -0
- package/README.md +18 -3
- package/dist/cascade.d.ts +4 -0
- package/dist/cascade.js +7 -3
- package/dist/cascade.js.map +1 -1
- package/dist/cjs/cascade.d.ts +4 -0
- package/dist/cjs/engine.d.ts +4 -0
- package/dist/cjs/exclusion-engine.d.ts +67 -10
- package/dist/cjs/index.js +2128 -88
- package/dist/cjs/presets.d.ts +11 -3
- package/dist/cjs/types.d.ts +99 -8
- package/dist/cjs/walk-hidden.d.ts +41 -0
- package/dist/cjs/walk-links.d.ts +63 -0
- package/dist/cjs/win-attr.d.ts +27 -0
- package/dist/engine.d.ts +4 -0
- package/dist/engine.js +91 -7
- package/dist/engine.js.map +1 -1
- package/dist/exclusion-engine.d.ts +67 -10
- package/dist/exclusion-engine.js +156 -71
- package/dist/exclusion-engine.js.map +1 -1
- package/dist/explain.js +18 -3
- package/dist/explain.js.map +1 -1
- package/dist/presets.d.ts +11 -3
- package/dist/presets.js +17 -7
- package/dist/presets.js.map +1 -1
- package/dist/types.d.ts +99 -8
- package/dist/types.js.map +1 -1
- package/dist/walk-hidden.d.ts +41 -0
- package/dist/walk-hidden.js +96 -0
- package/dist/walk-hidden.js.map +1 -0
- package/dist/walk-links.d.ts +63 -0
- package/dist/walk-links.js +124 -0
- package/dist/walk-links.js.map +1 -0
- package/dist/win-attr.d.ts +27 -0
- package/dist/win-attr.js +81 -0
- package/dist/win-attr.js.map +1 -0
- package/docs/glossary.md +4 -0
- package/docs/semantics.md +25 -5
- package/package.json +4 -1
- package/prebuilds/win32-x64/pathscope_win_attr.node +0 -0
package/dist/cjs/index.js
CHANGED
|
@@ -34,9 +34,1785 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
34
34
|
));
|
|
35
35
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
36
36
|
|
|
37
|
-
// node_modules/.pnpm/
|
|
37
|
+
// node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/constants.js
|
|
38
|
+
var require_constants = __commonJS({
|
|
39
|
+
"node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/constants.js"(exports2, module2) {
|
|
40
|
+
"use strict";
|
|
41
|
+
var WIN_SLASH = "\\\\/";
|
|
42
|
+
var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
|
|
43
|
+
var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
|
|
44
|
+
var DOT_LITERAL = "\\.";
|
|
45
|
+
var PLUS_LITERAL = "\\+";
|
|
46
|
+
var QMARK_LITERAL = "\\?";
|
|
47
|
+
var SLASH_LITERAL = "\\/";
|
|
48
|
+
var ONE_CHAR = "(?=.)";
|
|
49
|
+
var QMARK = "[^/]";
|
|
50
|
+
var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
|
|
51
|
+
var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
|
|
52
|
+
var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
|
|
53
|
+
var NO_DOT = `(?!${DOT_LITERAL})`;
|
|
54
|
+
var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
|
|
55
|
+
var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
|
|
56
|
+
var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
|
|
57
|
+
var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
|
|
58
|
+
var STAR = `${QMARK}*?`;
|
|
59
|
+
var SEP = "/";
|
|
60
|
+
var POSIX_CHARS = {
|
|
61
|
+
DOT_LITERAL,
|
|
62
|
+
PLUS_LITERAL,
|
|
63
|
+
QMARK_LITERAL,
|
|
64
|
+
SLASH_LITERAL,
|
|
65
|
+
ONE_CHAR,
|
|
66
|
+
QMARK,
|
|
67
|
+
END_ANCHOR,
|
|
68
|
+
DOTS_SLASH,
|
|
69
|
+
NO_DOT,
|
|
70
|
+
NO_DOTS,
|
|
71
|
+
NO_DOT_SLASH,
|
|
72
|
+
NO_DOTS_SLASH,
|
|
73
|
+
QMARK_NO_DOT,
|
|
74
|
+
STAR,
|
|
75
|
+
START_ANCHOR,
|
|
76
|
+
SEP
|
|
77
|
+
};
|
|
78
|
+
var WINDOWS_CHARS = {
|
|
79
|
+
...POSIX_CHARS,
|
|
80
|
+
SLASH_LITERAL: `[${WIN_SLASH}]`,
|
|
81
|
+
QMARK: WIN_NO_SLASH,
|
|
82
|
+
STAR: `${WIN_NO_SLASH}*?`,
|
|
83
|
+
DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
|
|
84
|
+
NO_DOT: `(?!${DOT_LITERAL})`,
|
|
85
|
+
NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
|
|
86
|
+
NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
|
|
87
|
+
NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
|
|
88
|
+
QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
|
|
89
|
+
START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
|
|
90
|
+
END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
|
|
91
|
+
SEP: "\\"
|
|
92
|
+
};
|
|
93
|
+
var POSIX_REGEX_SOURCE = {
|
|
94
|
+
__proto__: null,
|
|
95
|
+
alnum: "a-zA-Z0-9",
|
|
96
|
+
alpha: "a-zA-Z",
|
|
97
|
+
ascii: "\\x00-\\x7F",
|
|
98
|
+
blank: " \\t",
|
|
99
|
+
cntrl: "\\x00-\\x1F\\x7F",
|
|
100
|
+
digit: "0-9",
|
|
101
|
+
graph: "\\x21-\\x7E",
|
|
102
|
+
lower: "a-z",
|
|
103
|
+
print: "\\x20-\\x7E ",
|
|
104
|
+
punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
|
|
105
|
+
space: " \\t\\r\\n\\v\\f",
|
|
106
|
+
upper: "A-Z",
|
|
107
|
+
word: "A-Za-z0-9_",
|
|
108
|
+
xdigit: "A-Fa-f0-9"
|
|
109
|
+
};
|
|
110
|
+
module2.exports = {
|
|
111
|
+
DEFAULT_MAX_EXTGLOB_RECURSION,
|
|
112
|
+
MAX_LENGTH: 1024 * 64,
|
|
113
|
+
POSIX_REGEX_SOURCE,
|
|
114
|
+
// regular expressions
|
|
115
|
+
REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
|
|
116
|
+
REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
|
|
117
|
+
REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
|
|
118
|
+
REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
|
|
119
|
+
REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
|
|
120
|
+
REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
|
|
121
|
+
// Replace globs with equivalent patterns to reduce parsing time.
|
|
122
|
+
REPLACEMENTS: {
|
|
123
|
+
__proto__: null,
|
|
124
|
+
"***": "*",
|
|
125
|
+
"**/**": "**",
|
|
126
|
+
"**/**/**": "**"
|
|
127
|
+
},
|
|
128
|
+
// Digits
|
|
129
|
+
CHAR_0: 48,
|
|
130
|
+
/* 0 */
|
|
131
|
+
CHAR_9: 57,
|
|
132
|
+
/* 9 */
|
|
133
|
+
// Alphabet chars.
|
|
134
|
+
CHAR_UPPERCASE_A: 65,
|
|
135
|
+
/* A */
|
|
136
|
+
CHAR_LOWERCASE_A: 97,
|
|
137
|
+
/* a */
|
|
138
|
+
CHAR_UPPERCASE_Z: 90,
|
|
139
|
+
/* Z */
|
|
140
|
+
CHAR_LOWERCASE_Z: 122,
|
|
141
|
+
/* z */
|
|
142
|
+
CHAR_LEFT_PARENTHESES: 40,
|
|
143
|
+
/* ( */
|
|
144
|
+
CHAR_RIGHT_PARENTHESES: 41,
|
|
145
|
+
/* ) */
|
|
146
|
+
CHAR_ASTERISK: 42,
|
|
147
|
+
/* * */
|
|
148
|
+
// Non-alphabetic chars.
|
|
149
|
+
CHAR_AMPERSAND: 38,
|
|
150
|
+
/* & */
|
|
151
|
+
CHAR_AT: 64,
|
|
152
|
+
/* @ */
|
|
153
|
+
CHAR_BACKWARD_SLASH: 92,
|
|
154
|
+
/* \ */
|
|
155
|
+
CHAR_CARRIAGE_RETURN: 13,
|
|
156
|
+
/* \r */
|
|
157
|
+
CHAR_CIRCUMFLEX_ACCENT: 94,
|
|
158
|
+
/* ^ */
|
|
159
|
+
CHAR_COLON: 58,
|
|
160
|
+
/* : */
|
|
161
|
+
CHAR_COMMA: 44,
|
|
162
|
+
/* , */
|
|
163
|
+
CHAR_DOT: 46,
|
|
164
|
+
/* . */
|
|
165
|
+
CHAR_DOUBLE_QUOTE: 34,
|
|
166
|
+
/* " */
|
|
167
|
+
CHAR_EQUAL: 61,
|
|
168
|
+
/* = */
|
|
169
|
+
CHAR_EXCLAMATION_MARK: 33,
|
|
170
|
+
/* ! */
|
|
171
|
+
CHAR_FORM_FEED: 12,
|
|
172
|
+
/* \f */
|
|
173
|
+
CHAR_FORWARD_SLASH: 47,
|
|
174
|
+
/* / */
|
|
175
|
+
CHAR_GRAVE_ACCENT: 96,
|
|
176
|
+
/* ` */
|
|
177
|
+
CHAR_HASH: 35,
|
|
178
|
+
/* # */
|
|
179
|
+
CHAR_HYPHEN_MINUS: 45,
|
|
180
|
+
/* - */
|
|
181
|
+
CHAR_LEFT_ANGLE_BRACKET: 60,
|
|
182
|
+
/* < */
|
|
183
|
+
CHAR_LEFT_CURLY_BRACE: 123,
|
|
184
|
+
/* { */
|
|
185
|
+
CHAR_LEFT_SQUARE_BRACKET: 91,
|
|
186
|
+
/* [ */
|
|
187
|
+
CHAR_LINE_FEED: 10,
|
|
188
|
+
/* \n */
|
|
189
|
+
CHAR_NO_BREAK_SPACE: 160,
|
|
190
|
+
/* \u00A0 */
|
|
191
|
+
CHAR_PERCENT: 37,
|
|
192
|
+
/* % */
|
|
193
|
+
CHAR_PLUS: 43,
|
|
194
|
+
/* + */
|
|
195
|
+
CHAR_QUESTION_MARK: 63,
|
|
196
|
+
/* ? */
|
|
197
|
+
CHAR_RIGHT_ANGLE_BRACKET: 62,
|
|
198
|
+
/* > */
|
|
199
|
+
CHAR_RIGHT_CURLY_BRACE: 125,
|
|
200
|
+
/* } */
|
|
201
|
+
CHAR_RIGHT_SQUARE_BRACKET: 93,
|
|
202
|
+
/* ] */
|
|
203
|
+
CHAR_SEMICOLON: 59,
|
|
204
|
+
/* ; */
|
|
205
|
+
CHAR_SINGLE_QUOTE: 39,
|
|
206
|
+
/* ' */
|
|
207
|
+
CHAR_SPACE: 32,
|
|
208
|
+
/* */
|
|
209
|
+
CHAR_TAB: 9,
|
|
210
|
+
/* \t */
|
|
211
|
+
CHAR_UNDERSCORE: 95,
|
|
212
|
+
/* _ */
|
|
213
|
+
CHAR_VERTICAL_LINE: 124,
|
|
214
|
+
/* | */
|
|
215
|
+
CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
|
|
216
|
+
/* \uFEFF */
|
|
217
|
+
/**
|
|
218
|
+
* Create EXTGLOB_CHARS
|
|
219
|
+
*/
|
|
220
|
+
extglobChars(chars) {
|
|
221
|
+
return {
|
|
222
|
+
"!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
|
|
223
|
+
"?": { type: "qmark", open: "(?:", close: ")?" },
|
|
224
|
+
"+": { type: "plus", open: "(?:", close: ")+" },
|
|
225
|
+
"*": { type: "star", open: "(?:", close: ")*" },
|
|
226
|
+
"@": { type: "at", open: "(?:", close: ")" }
|
|
227
|
+
};
|
|
228
|
+
},
|
|
229
|
+
/**
|
|
230
|
+
* Create GLOB_CHARS
|
|
231
|
+
*/
|
|
232
|
+
globChars(win32) {
|
|
233
|
+
return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
|
|
234
|
+
}
|
|
235
|
+
};
|
|
236
|
+
}
|
|
237
|
+
});
|
|
238
|
+
|
|
239
|
+
// node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/utils.js
|
|
240
|
+
var require_utils = __commonJS({
|
|
241
|
+
"node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/utils.js"(exports2) {
|
|
242
|
+
"use strict";
|
|
243
|
+
var {
|
|
244
|
+
REGEX_BACKSLASH,
|
|
245
|
+
REGEX_REMOVE_BACKSLASH,
|
|
246
|
+
REGEX_SPECIAL_CHARS,
|
|
247
|
+
REGEX_SPECIAL_CHARS_GLOBAL
|
|
248
|
+
} = require_constants();
|
|
249
|
+
exports2.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
|
|
250
|
+
exports2.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
|
|
251
|
+
exports2.isRegexChar = (str) => str.length === 1 && exports2.hasRegexChars(str);
|
|
252
|
+
exports2.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
|
|
253
|
+
exports2.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
|
|
254
|
+
exports2.isWindows = () => {
|
|
255
|
+
if (typeof navigator !== "undefined" && navigator.platform) {
|
|
256
|
+
const platform3 = navigator.platform.toLowerCase();
|
|
257
|
+
return platform3 === "win32" || platform3 === "windows";
|
|
258
|
+
}
|
|
259
|
+
if (typeof process !== "undefined" && process.platform) {
|
|
260
|
+
return process.platform === "win32";
|
|
261
|
+
}
|
|
262
|
+
return false;
|
|
263
|
+
};
|
|
264
|
+
exports2.removeBackslashes = (str) => {
|
|
265
|
+
return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
|
|
266
|
+
return match === "\\" ? "" : match;
|
|
267
|
+
});
|
|
268
|
+
};
|
|
269
|
+
exports2.escapeLast = (input, char, lastIdx) => {
|
|
270
|
+
const idx = input.lastIndexOf(char, lastIdx);
|
|
271
|
+
if (idx === -1) return input;
|
|
272
|
+
if (input[idx - 1] === "\\") return exports2.escapeLast(input, char, idx - 1);
|
|
273
|
+
return `${input.slice(0, idx)}\\${input.slice(idx)}`;
|
|
274
|
+
};
|
|
275
|
+
exports2.removePrefix = (input, state = {}) => {
|
|
276
|
+
let output = input;
|
|
277
|
+
if (output.startsWith("./")) {
|
|
278
|
+
output = output.slice(2);
|
|
279
|
+
state.prefix = "./";
|
|
280
|
+
}
|
|
281
|
+
return output;
|
|
282
|
+
};
|
|
283
|
+
exports2.wrapOutput = (input, state = {}, options = {}) => {
|
|
284
|
+
const prepend = options.contains ? "" : "^";
|
|
285
|
+
const append = options.contains ? "" : "$";
|
|
286
|
+
let output = `${prepend}(?:${input})${append}`;
|
|
287
|
+
if (state.negated === true) {
|
|
288
|
+
output = `(?:^(?!${output}).*$)`;
|
|
289
|
+
}
|
|
290
|
+
return output;
|
|
291
|
+
};
|
|
292
|
+
exports2.basename = (path3, { windows } = {}) => {
|
|
293
|
+
const segs = path3.split(windows ? /[\\/]/ : "/");
|
|
294
|
+
const last = segs[segs.length - 1];
|
|
295
|
+
if (last === "") {
|
|
296
|
+
return segs[segs.length - 2];
|
|
297
|
+
}
|
|
298
|
+
return last;
|
|
299
|
+
};
|
|
300
|
+
}
|
|
301
|
+
});
|
|
302
|
+
|
|
303
|
+
// node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/scan.js
|
|
304
|
+
var require_scan = __commonJS({
|
|
305
|
+
"node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/scan.js"(exports2, module2) {
|
|
306
|
+
"use strict";
|
|
307
|
+
var utils = require_utils();
|
|
308
|
+
var {
|
|
309
|
+
CHAR_ASTERISK,
|
|
310
|
+
/* * */
|
|
311
|
+
CHAR_AT,
|
|
312
|
+
/* @ */
|
|
313
|
+
CHAR_BACKWARD_SLASH,
|
|
314
|
+
/* \ */
|
|
315
|
+
CHAR_COMMA,
|
|
316
|
+
/* , */
|
|
317
|
+
CHAR_DOT,
|
|
318
|
+
/* . */
|
|
319
|
+
CHAR_EXCLAMATION_MARK,
|
|
320
|
+
/* ! */
|
|
321
|
+
CHAR_FORWARD_SLASH,
|
|
322
|
+
/* / */
|
|
323
|
+
CHAR_LEFT_CURLY_BRACE,
|
|
324
|
+
/* { */
|
|
325
|
+
CHAR_LEFT_PARENTHESES,
|
|
326
|
+
/* ( */
|
|
327
|
+
CHAR_LEFT_SQUARE_BRACKET,
|
|
328
|
+
/* [ */
|
|
329
|
+
CHAR_PLUS,
|
|
330
|
+
/* + */
|
|
331
|
+
CHAR_QUESTION_MARK,
|
|
332
|
+
/* ? */
|
|
333
|
+
CHAR_RIGHT_CURLY_BRACE,
|
|
334
|
+
/* } */
|
|
335
|
+
CHAR_RIGHT_PARENTHESES,
|
|
336
|
+
/* ) */
|
|
337
|
+
CHAR_RIGHT_SQUARE_BRACKET
|
|
338
|
+
/* ] */
|
|
339
|
+
} = require_constants();
|
|
340
|
+
var isPathSeparator = (code) => {
|
|
341
|
+
return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
|
|
342
|
+
};
|
|
343
|
+
var depth = (token) => {
|
|
344
|
+
if (token.isPrefix !== true) {
|
|
345
|
+
token.depth = token.isGlobstar ? Infinity : 1;
|
|
346
|
+
}
|
|
347
|
+
};
|
|
348
|
+
var scan = (input, options) => {
|
|
349
|
+
const opts = options || {};
|
|
350
|
+
const length = input.length - 1;
|
|
351
|
+
const scanToEnd = opts.parts === true || opts.tokens === true || opts.scanToEnd === true;
|
|
352
|
+
const slashes = [];
|
|
353
|
+
const tokens = [];
|
|
354
|
+
const parts = [];
|
|
355
|
+
let str = input;
|
|
356
|
+
let index = -1;
|
|
357
|
+
let start = 0;
|
|
358
|
+
let lastIndex = 0;
|
|
359
|
+
let isBrace = false;
|
|
360
|
+
let isBracket = false;
|
|
361
|
+
let isGlob = false;
|
|
362
|
+
let isExtglob = false;
|
|
363
|
+
let isGlobstar = false;
|
|
364
|
+
let braceEscaped = false;
|
|
365
|
+
let backslashes = false;
|
|
366
|
+
let negated = false;
|
|
367
|
+
let negatedExtglob = false;
|
|
368
|
+
let finished = false;
|
|
369
|
+
let braces = 0;
|
|
370
|
+
let prev;
|
|
371
|
+
let code;
|
|
372
|
+
let token = { value: "", depth: 0, isGlob: false };
|
|
373
|
+
const eos = () => index >= length;
|
|
374
|
+
const peek = () => str.charCodeAt(index + 1);
|
|
375
|
+
const advance = () => {
|
|
376
|
+
prev = code;
|
|
377
|
+
return str.charCodeAt(++index);
|
|
378
|
+
};
|
|
379
|
+
while (index < length) {
|
|
380
|
+
code = advance();
|
|
381
|
+
let next;
|
|
382
|
+
if (code === CHAR_BACKWARD_SLASH) {
|
|
383
|
+
backslashes = token.backslashes = true;
|
|
384
|
+
code = advance();
|
|
385
|
+
if (code === CHAR_LEFT_CURLY_BRACE) {
|
|
386
|
+
braceEscaped = true;
|
|
387
|
+
}
|
|
388
|
+
continue;
|
|
389
|
+
}
|
|
390
|
+
if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
|
|
391
|
+
braces++;
|
|
392
|
+
while (eos() !== true && (code = advance())) {
|
|
393
|
+
if (code === CHAR_BACKWARD_SLASH) {
|
|
394
|
+
backslashes = token.backslashes = true;
|
|
395
|
+
advance();
|
|
396
|
+
continue;
|
|
397
|
+
}
|
|
398
|
+
if (code === CHAR_LEFT_CURLY_BRACE) {
|
|
399
|
+
braces++;
|
|
400
|
+
continue;
|
|
401
|
+
}
|
|
402
|
+
if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
|
|
403
|
+
isBrace = token.isBrace = true;
|
|
404
|
+
isGlob = token.isGlob = true;
|
|
405
|
+
finished = true;
|
|
406
|
+
if (scanToEnd === true) {
|
|
407
|
+
continue;
|
|
408
|
+
}
|
|
409
|
+
break;
|
|
410
|
+
}
|
|
411
|
+
if (braceEscaped !== true && code === CHAR_COMMA) {
|
|
412
|
+
isBrace = token.isBrace = true;
|
|
413
|
+
isGlob = token.isGlob = true;
|
|
414
|
+
finished = true;
|
|
415
|
+
if (scanToEnd === true) {
|
|
416
|
+
continue;
|
|
417
|
+
}
|
|
418
|
+
break;
|
|
419
|
+
}
|
|
420
|
+
if (code === CHAR_RIGHT_CURLY_BRACE) {
|
|
421
|
+
braces--;
|
|
422
|
+
if (braces === 0) {
|
|
423
|
+
braceEscaped = false;
|
|
424
|
+
isBrace = token.isBrace = true;
|
|
425
|
+
finished = true;
|
|
426
|
+
break;
|
|
427
|
+
}
|
|
428
|
+
}
|
|
429
|
+
}
|
|
430
|
+
if (scanToEnd === true) {
|
|
431
|
+
continue;
|
|
432
|
+
}
|
|
433
|
+
break;
|
|
434
|
+
}
|
|
435
|
+
if (code === CHAR_FORWARD_SLASH) {
|
|
436
|
+
slashes.push(index);
|
|
437
|
+
tokens.push(token);
|
|
438
|
+
token = { value: "", depth: 0, isGlob: false };
|
|
439
|
+
if (finished === true) continue;
|
|
440
|
+
if (prev === CHAR_DOT && index === start + 1) {
|
|
441
|
+
start += 2;
|
|
442
|
+
continue;
|
|
443
|
+
}
|
|
444
|
+
lastIndex = index + 1;
|
|
445
|
+
continue;
|
|
446
|
+
}
|
|
447
|
+
if (opts.noext !== true) {
|
|
448
|
+
const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
|
|
449
|
+
if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
|
|
450
|
+
isGlob = token.isGlob = true;
|
|
451
|
+
isExtglob = token.isExtglob = true;
|
|
452
|
+
finished = true;
|
|
453
|
+
if (code === CHAR_EXCLAMATION_MARK && index === start) {
|
|
454
|
+
negatedExtglob = true;
|
|
455
|
+
}
|
|
456
|
+
if (scanToEnd === true) {
|
|
457
|
+
let parens = 0;
|
|
458
|
+
while (eos() !== true && (code = advance())) {
|
|
459
|
+
if (code === CHAR_BACKWARD_SLASH) {
|
|
460
|
+
backslashes = token.backslashes = true;
|
|
461
|
+
advance();
|
|
462
|
+
continue;
|
|
463
|
+
}
|
|
464
|
+
if (code === CHAR_LEFT_PARENTHESES) {
|
|
465
|
+
parens++;
|
|
466
|
+
continue;
|
|
467
|
+
}
|
|
468
|
+
if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
|
|
469
|
+
finished = true;
|
|
470
|
+
break;
|
|
471
|
+
}
|
|
472
|
+
}
|
|
473
|
+
continue;
|
|
474
|
+
}
|
|
475
|
+
break;
|
|
476
|
+
}
|
|
477
|
+
}
|
|
478
|
+
if (code === CHAR_ASTERISK) {
|
|
479
|
+
if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
|
|
480
|
+
isGlob = token.isGlob = true;
|
|
481
|
+
finished = true;
|
|
482
|
+
if (scanToEnd === true) {
|
|
483
|
+
continue;
|
|
484
|
+
}
|
|
485
|
+
break;
|
|
486
|
+
}
|
|
487
|
+
if (code === CHAR_QUESTION_MARK) {
|
|
488
|
+
isGlob = token.isGlob = true;
|
|
489
|
+
finished = true;
|
|
490
|
+
if (scanToEnd === true) {
|
|
491
|
+
continue;
|
|
492
|
+
}
|
|
493
|
+
break;
|
|
494
|
+
}
|
|
495
|
+
if (code === CHAR_LEFT_SQUARE_BRACKET) {
|
|
496
|
+
while (eos() !== true && (next = advance())) {
|
|
497
|
+
if (next === CHAR_BACKWARD_SLASH) {
|
|
498
|
+
backslashes = token.backslashes = true;
|
|
499
|
+
advance();
|
|
500
|
+
continue;
|
|
501
|
+
}
|
|
502
|
+
if (next === CHAR_RIGHT_SQUARE_BRACKET) {
|
|
503
|
+
isBracket = token.isBracket = true;
|
|
504
|
+
isGlob = token.isGlob = true;
|
|
505
|
+
finished = true;
|
|
506
|
+
break;
|
|
507
|
+
}
|
|
508
|
+
}
|
|
509
|
+
if (scanToEnd === true) {
|
|
510
|
+
continue;
|
|
511
|
+
}
|
|
512
|
+
break;
|
|
513
|
+
}
|
|
514
|
+
if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
|
|
515
|
+
negated = token.negated = true;
|
|
516
|
+
start++;
|
|
517
|
+
continue;
|
|
518
|
+
}
|
|
519
|
+
if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
|
|
520
|
+
isGlob = token.isGlob = true;
|
|
521
|
+
if (scanToEnd === true) {
|
|
522
|
+
let parens = 1;
|
|
523
|
+
while (eos() !== true && (code = advance())) {
|
|
524
|
+
if (code === CHAR_BACKWARD_SLASH) {
|
|
525
|
+
backslashes = token.backslashes = true;
|
|
526
|
+
advance();
|
|
527
|
+
continue;
|
|
528
|
+
}
|
|
529
|
+
if (code === CHAR_LEFT_PARENTHESES) {
|
|
530
|
+
parens++;
|
|
531
|
+
continue;
|
|
532
|
+
}
|
|
533
|
+
if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
|
|
534
|
+
finished = true;
|
|
535
|
+
break;
|
|
536
|
+
}
|
|
537
|
+
}
|
|
538
|
+
continue;
|
|
539
|
+
}
|
|
540
|
+
break;
|
|
541
|
+
}
|
|
542
|
+
if (isGlob === true) {
|
|
543
|
+
finished = true;
|
|
544
|
+
if (scanToEnd === true) {
|
|
545
|
+
continue;
|
|
546
|
+
}
|
|
547
|
+
break;
|
|
548
|
+
}
|
|
549
|
+
}
|
|
550
|
+
if (opts.noext === true) {
|
|
551
|
+
isExtglob = false;
|
|
552
|
+
isGlob = false;
|
|
553
|
+
}
|
|
554
|
+
let base = str;
|
|
555
|
+
let prefix = "";
|
|
556
|
+
let glob = "";
|
|
557
|
+
if (start > 0) {
|
|
558
|
+
prefix = str.slice(0, start);
|
|
559
|
+
str = str.slice(start);
|
|
560
|
+
lastIndex -= start;
|
|
561
|
+
}
|
|
562
|
+
if (base && isGlob === true && lastIndex > 0) {
|
|
563
|
+
base = str.slice(0, lastIndex);
|
|
564
|
+
glob = str.slice(lastIndex);
|
|
565
|
+
} else if (isGlob === true) {
|
|
566
|
+
base = "";
|
|
567
|
+
glob = str;
|
|
568
|
+
} else {
|
|
569
|
+
base = str;
|
|
570
|
+
}
|
|
571
|
+
if (base && base !== "" && base !== "/" && base !== str) {
|
|
572
|
+
if (isPathSeparator(base.charCodeAt(base.length - 1))) {
|
|
573
|
+
base = base.slice(0, -1);
|
|
574
|
+
}
|
|
575
|
+
}
|
|
576
|
+
if (opts.unescape === true) {
|
|
577
|
+
if (glob) glob = utils.removeBackslashes(glob);
|
|
578
|
+
if (base && backslashes === true) {
|
|
579
|
+
base = utils.removeBackslashes(base);
|
|
580
|
+
}
|
|
581
|
+
}
|
|
582
|
+
const state = {
|
|
583
|
+
prefix,
|
|
584
|
+
input,
|
|
585
|
+
start,
|
|
586
|
+
base,
|
|
587
|
+
glob,
|
|
588
|
+
isBrace,
|
|
589
|
+
isBracket,
|
|
590
|
+
isGlob,
|
|
591
|
+
isExtglob,
|
|
592
|
+
isGlobstar,
|
|
593
|
+
negated,
|
|
594
|
+
negatedExtglob
|
|
595
|
+
};
|
|
596
|
+
if (opts.tokens === true) {
|
|
597
|
+
state.maxDepth = 0;
|
|
598
|
+
if (!isPathSeparator(code)) {
|
|
599
|
+
tokens.push(token);
|
|
600
|
+
}
|
|
601
|
+
state.tokens = tokens;
|
|
602
|
+
}
|
|
603
|
+
if (opts.parts === true || opts.tokens === true) {
|
|
604
|
+
let prevIndex;
|
|
605
|
+
for (let idx = 0; idx < slashes.length; idx++) {
|
|
606
|
+
const n2 = prevIndex !== void 0 ? prevIndex + 1 : start;
|
|
607
|
+
const i = slashes[idx];
|
|
608
|
+
const value2 = input.slice(n2, i);
|
|
609
|
+
if (opts.tokens) {
|
|
610
|
+
if (idx === 0 && start !== 0) {
|
|
611
|
+
tokens[idx].isPrefix = true;
|
|
612
|
+
tokens[idx].value = prefix;
|
|
613
|
+
} else {
|
|
614
|
+
tokens[idx].value = value2;
|
|
615
|
+
}
|
|
616
|
+
depth(tokens[idx]);
|
|
617
|
+
state.maxDepth += tokens[idx].depth;
|
|
618
|
+
}
|
|
619
|
+
if (i >= start) {
|
|
620
|
+
parts.push(value2);
|
|
621
|
+
prevIndex = i;
|
|
622
|
+
}
|
|
623
|
+
}
|
|
624
|
+
const n = prevIndex !== void 0 ? prevIndex + 1 : start;
|
|
625
|
+
const value = input.slice(n);
|
|
626
|
+
parts.push(value);
|
|
627
|
+
if (opts.tokens && prevIndex && prevIndex + 1 < input.length) {
|
|
628
|
+
tokens[tokens.length - 1].value = value;
|
|
629
|
+
depth(tokens[tokens.length - 1]);
|
|
630
|
+
state.maxDepth += tokens[tokens.length - 1].depth;
|
|
631
|
+
}
|
|
632
|
+
state.slashes = slashes;
|
|
633
|
+
state.parts = parts;
|
|
634
|
+
}
|
|
635
|
+
return state;
|
|
636
|
+
};
|
|
637
|
+
module2.exports = scan;
|
|
638
|
+
}
|
|
639
|
+
});
|
|
640
|
+
|
|
641
|
+
// node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/parse.js
|
|
642
|
+
var require_parse = __commonJS({
|
|
643
|
+
"node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/parse.js"(exports2, module2) {
|
|
644
|
+
"use strict";
|
|
645
|
+
var constants = require_constants();
|
|
646
|
+
var utils = require_utils();
|
|
647
|
+
var {
|
|
648
|
+
MAX_LENGTH,
|
|
649
|
+
POSIX_REGEX_SOURCE,
|
|
650
|
+
REGEX_NON_SPECIAL_CHARS,
|
|
651
|
+
REGEX_SPECIAL_CHARS_BACKREF,
|
|
652
|
+
REPLACEMENTS
|
|
653
|
+
} = constants;
|
|
654
|
+
var expandRange = (args, options) => {
|
|
655
|
+
if (typeof options.expandRange === "function") {
|
|
656
|
+
return options.expandRange(...args, options);
|
|
657
|
+
}
|
|
658
|
+
args.sort();
|
|
659
|
+
const value = `[${args.join("-")}]`;
|
|
660
|
+
try {
|
|
661
|
+
new RegExp(value);
|
|
662
|
+
} catch (ex) {
|
|
663
|
+
return args.map((v) => utils.escapeRegex(v)).join("..");
|
|
664
|
+
}
|
|
665
|
+
return value;
|
|
666
|
+
};
|
|
667
|
+
var syntaxError = (type, char) => {
|
|
668
|
+
return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
|
|
669
|
+
};
|
|
670
|
+
var splitTopLevel = (input) => {
|
|
671
|
+
const parts = [];
|
|
672
|
+
let bracket = 0;
|
|
673
|
+
let paren = 0;
|
|
674
|
+
let quote = 0;
|
|
675
|
+
let value = "";
|
|
676
|
+
let escaped = false;
|
|
677
|
+
for (const ch of input) {
|
|
678
|
+
if (escaped === true) {
|
|
679
|
+
value += ch;
|
|
680
|
+
escaped = false;
|
|
681
|
+
continue;
|
|
682
|
+
}
|
|
683
|
+
if (ch === "\\") {
|
|
684
|
+
value += ch;
|
|
685
|
+
escaped = true;
|
|
686
|
+
continue;
|
|
687
|
+
}
|
|
688
|
+
if (ch === '"') {
|
|
689
|
+
quote = quote === 1 ? 0 : 1;
|
|
690
|
+
value += ch;
|
|
691
|
+
continue;
|
|
692
|
+
}
|
|
693
|
+
if (quote === 0) {
|
|
694
|
+
if (ch === "[") {
|
|
695
|
+
bracket++;
|
|
696
|
+
} else if (ch === "]" && bracket > 0) {
|
|
697
|
+
bracket--;
|
|
698
|
+
} else if (bracket === 0) {
|
|
699
|
+
if (ch === "(") {
|
|
700
|
+
paren++;
|
|
701
|
+
} else if (ch === ")" && paren > 0) {
|
|
702
|
+
paren--;
|
|
703
|
+
} else if (ch === "|" && paren === 0) {
|
|
704
|
+
parts.push(value);
|
|
705
|
+
value = "";
|
|
706
|
+
continue;
|
|
707
|
+
}
|
|
708
|
+
}
|
|
709
|
+
}
|
|
710
|
+
value += ch;
|
|
711
|
+
}
|
|
712
|
+
parts.push(value);
|
|
713
|
+
return parts;
|
|
714
|
+
};
|
|
715
|
+
var isPlainBranch = (branch) => {
|
|
716
|
+
let escaped = false;
|
|
717
|
+
for (const ch of branch) {
|
|
718
|
+
if (escaped === true) {
|
|
719
|
+
escaped = false;
|
|
720
|
+
continue;
|
|
721
|
+
}
|
|
722
|
+
if (ch === "\\") {
|
|
723
|
+
escaped = true;
|
|
724
|
+
continue;
|
|
725
|
+
}
|
|
726
|
+
if (/[?*+@!()[\]{}]/.test(ch)) {
|
|
727
|
+
return false;
|
|
728
|
+
}
|
|
729
|
+
}
|
|
730
|
+
return true;
|
|
731
|
+
};
|
|
732
|
+
var normalizeSimpleBranch = (branch) => {
|
|
733
|
+
let value = branch.trim();
|
|
734
|
+
let changed = true;
|
|
735
|
+
while (changed === true) {
|
|
736
|
+
changed = false;
|
|
737
|
+
if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
|
|
738
|
+
value = value.slice(2, -1);
|
|
739
|
+
changed = true;
|
|
740
|
+
}
|
|
741
|
+
}
|
|
742
|
+
if (!isPlainBranch(value)) {
|
|
743
|
+
return;
|
|
744
|
+
}
|
|
745
|
+
return value.replace(/\\(.)/g, "$1");
|
|
746
|
+
};
|
|
747
|
+
var hasRepeatedCharPrefixOverlap = (branches) => {
|
|
748
|
+
const values = branches.map(normalizeSimpleBranch).filter(Boolean);
|
|
749
|
+
for (let i = 0; i < values.length; i++) {
|
|
750
|
+
for (let j = i + 1; j < values.length; j++) {
|
|
751
|
+
const a = values[i];
|
|
752
|
+
const b = values[j];
|
|
753
|
+
const char = a[0];
|
|
754
|
+
if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
|
|
755
|
+
continue;
|
|
756
|
+
}
|
|
757
|
+
if (a === b || a.startsWith(b) || b.startsWith(a)) {
|
|
758
|
+
return true;
|
|
759
|
+
}
|
|
760
|
+
}
|
|
761
|
+
}
|
|
762
|
+
return false;
|
|
763
|
+
};
|
|
764
|
+
var parseRepeatedExtglob = (pattern, requireEnd = true) => {
|
|
765
|
+
if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
|
|
766
|
+
return;
|
|
767
|
+
}
|
|
768
|
+
let bracket = 0;
|
|
769
|
+
let paren = 0;
|
|
770
|
+
let quote = 0;
|
|
771
|
+
let escaped = false;
|
|
772
|
+
for (let i = 1; i < pattern.length; i++) {
|
|
773
|
+
const ch = pattern[i];
|
|
774
|
+
if (escaped === true) {
|
|
775
|
+
escaped = false;
|
|
776
|
+
continue;
|
|
777
|
+
}
|
|
778
|
+
if (ch === "\\") {
|
|
779
|
+
escaped = true;
|
|
780
|
+
continue;
|
|
781
|
+
}
|
|
782
|
+
if (ch === '"') {
|
|
783
|
+
quote = quote === 1 ? 0 : 1;
|
|
784
|
+
continue;
|
|
785
|
+
}
|
|
786
|
+
if (quote === 1) {
|
|
787
|
+
continue;
|
|
788
|
+
}
|
|
789
|
+
if (ch === "[") {
|
|
790
|
+
bracket++;
|
|
791
|
+
continue;
|
|
792
|
+
}
|
|
793
|
+
if (ch === "]" && bracket > 0) {
|
|
794
|
+
bracket--;
|
|
795
|
+
continue;
|
|
796
|
+
}
|
|
797
|
+
if (bracket > 0) {
|
|
798
|
+
continue;
|
|
799
|
+
}
|
|
800
|
+
if (ch === "(") {
|
|
801
|
+
paren++;
|
|
802
|
+
continue;
|
|
803
|
+
}
|
|
804
|
+
if (ch === ")") {
|
|
805
|
+
paren--;
|
|
806
|
+
if (paren === 0) {
|
|
807
|
+
if (requireEnd === true && i !== pattern.length - 1) {
|
|
808
|
+
return;
|
|
809
|
+
}
|
|
810
|
+
return {
|
|
811
|
+
type: pattern[0],
|
|
812
|
+
body: pattern.slice(2, i),
|
|
813
|
+
end: i
|
|
814
|
+
};
|
|
815
|
+
}
|
|
816
|
+
}
|
|
817
|
+
}
|
|
818
|
+
};
|
|
819
|
+
var buildCharClassStar = (chars) => {
|
|
820
|
+
const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
|
|
821
|
+
return `${source}*`;
|
|
822
|
+
};
|
|
823
|
+
var getStarExtglobSequenceChars = (pattern) => {
|
|
824
|
+
let index = 0;
|
|
825
|
+
const chars = [];
|
|
826
|
+
while (index < pattern.length) {
|
|
827
|
+
const match = parseRepeatedExtglob(pattern.slice(index), false);
|
|
828
|
+
if (!match || match.type !== "*") {
|
|
829
|
+
return;
|
|
830
|
+
}
|
|
831
|
+
const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
|
|
832
|
+
if (branches.length !== 1) {
|
|
833
|
+
return;
|
|
834
|
+
}
|
|
835
|
+
const branch = normalizeSimpleBranch(branches[0]);
|
|
836
|
+
if (!branch || branch.length !== 1) {
|
|
837
|
+
return;
|
|
838
|
+
}
|
|
839
|
+
chars.push(branch);
|
|
840
|
+
index += match.end + 1;
|
|
841
|
+
}
|
|
842
|
+
if (chars.length < 1) {
|
|
843
|
+
return;
|
|
844
|
+
}
|
|
845
|
+
return chars;
|
|
846
|
+
};
|
|
847
|
+
var repeatedExtglobRecursion = (pattern) => {
|
|
848
|
+
let depth = 0;
|
|
849
|
+
let value = pattern.trim();
|
|
850
|
+
let match = parseRepeatedExtglob(value);
|
|
851
|
+
while (match) {
|
|
852
|
+
depth++;
|
|
853
|
+
value = match.body.trim();
|
|
854
|
+
match = parseRepeatedExtglob(value);
|
|
855
|
+
}
|
|
856
|
+
return depth;
|
|
857
|
+
};
|
|
858
|
+
var analyzeRepeatedExtglob = (body, options) => {
|
|
859
|
+
if (options.maxExtglobRecursion === false) {
|
|
860
|
+
return { risky: false };
|
|
861
|
+
}
|
|
862
|
+
const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
|
|
863
|
+
const branches = splitTopLevel(body).map((branch) => branch.trim());
|
|
864
|
+
if (branches.length > 1) {
|
|
865
|
+
if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
|
|
866
|
+
return { risky: true };
|
|
867
|
+
}
|
|
868
|
+
}
|
|
869
|
+
const safeChars = [];
|
|
870
|
+
let sawStarSequence = false;
|
|
871
|
+
let combinable = true;
|
|
872
|
+
for (const branch of branches) {
|
|
873
|
+
const chars = getStarExtglobSequenceChars(branch);
|
|
874
|
+
if (chars) {
|
|
875
|
+
sawStarSequence = true;
|
|
876
|
+
safeChars.push(...chars);
|
|
877
|
+
continue;
|
|
878
|
+
}
|
|
879
|
+
const literal = normalizeSimpleBranch(branch);
|
|
880
|
+
if (literal && literal.length === 1) {
|
|
881
|
+
safeChars.push(literal);
|
|
882
|
+
continue;
|
|
883
|
+
}
|
|
884
|
+
combinable = false;
|
|
885
|
+
if (repeatedExtglobRecursion(branch) > max) {
|
|
886
|
+
return { risky: true };
|
|
887
|
+
}
|
|
888
|
+
}
|
|
889
|
+
if (sawStarSequence) {
|
|
890
|
+
return combinable ? { risky: true, safeOutput: buildCharClassStar([...new Set(safeChars)]) } : { risky: true };
|
|
891
|
+
}
|
|
892
|
+
return { risky: false };
|
|
893
|
+
};
|
|
894
|
+
var parse = (input, options) => {
|
|
895
|
+
if (typeof input !== "string") {
|
|
896
|
+
throw new TypeError("Expected a string");
|
|
897
|
+
}
|
|
898
|
+
input = REPLACEMENTS[input] || input;
|
|
899
|
+
const opts = { ...options };
|
|
900
|
+
const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
|
|
901
|
+
let len = input.length;
|
|
902
|
+
if (len > max) {
|
|
903
|
+
throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
|
|
904
|
+
}
|
|
905
|
+
const bos = { type: "bos", value: "", output: opts.prepend || "" };
|
|
906
|
+
const tokens = [bos];
|
|
907
|
+
const capture = opts.capture ? "" : "?:";
|
|
908
|
+
const PLATFORM_CHARS = constants.globChars(opts.windows);
|
|
909
|
+
const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
|
|
910
|
+
const {
|
|
911
|
+
DOT_LITERAL,
|
|
912
|
+
PLUS_LITERAL,
|
|
913
|
+
SLASH_LITERAL,
|
|
914
|
+
ONE_CHAR,
|
|
915
|
+
DOTS_SLASH,
|
|
916
|
+
NO_DOT,
|
|
917
|
+
NO_DOT_SLASH,
|
|
918
|
+
NO_DOTS_SLASH,
|
|
919
|
+
QMARK,
|
|
920
|
+
QMARK_NO_DOT,
|
|
921
|
+
STAR,
|
|
922
|
+
START_ANCHOR
|
|
923
|
+
} = PLATFORM_CHARS;
|
|
924
|
+
const globstar = (opts2) => {
|
|
925
|
+
return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
|
|
926
|
+
};
|
|
927
|
+
const nodot = opts.dot ? "" : NO_DOT;
|
|
928
|
+
const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
|
|
929
|
+
let star = opts.bash === true ? globstar(opts) : STAR;
|
|
930
|
+
if (opts.capture) {
|
|
931
|
+
star = `(${star})`;
|
|
932
|
+
}
|
|
933
|
+
if (typeof opts.noext === "boolean") {
|
|
934
|
+
opts.noextglob = opts.noext;
|
|
935
|
+
}
|
|
936
|
+
const state = {
|
|
937
|
+
input,
|
|
938
|
+
index: -1,
|
|
939
|
+
start: 0,
|
|
940
|
+
dot: opts.dot === true,
|
|
941
|
+
consumed: "",
|
|
942
|
+
output: "",
|
|
943
|
+
prefix: "",
|
|
944
|
+
backtrack: false,
|
|
945
|
+
negated: false,
|
|
946
|
+
brackets: 0,
|
|
947
|
+
braces: 0,
|
|
948
|
+
parens: 0,
|
|
949
|
+
quotes: 0,
|
|
950
|
+
globstar: false,
|
|
951
|
+
tokens
|
|
952
|
+
};
|
|
953
|
+
input = utils.removePrefix(input, state);
|
|
954
|
+
len = input.length;
|
|
955
|
+
const extglobs = [];
|
|
956
|
+
const braces = [];
|
|
957
|
+
const stack = [];
|
|
958
|
+
let prev = bos;
|
|
959
|
+
let value;
|
|
960
|
+
const eos = () => state.index === len - 1;
|
|
961
|
+
const peek = state.peek = (n = 1) => input[state.index + n];
|
|
962
|
+
const advance = state.advance = () => input[++state.index] || "";
|
|
963
|
+
const remaining = () => input.slice(state.index + 1);
|
|
964
|
+
const consume = (value2 = "", num = 0) => {
|
|
965
|
+
state.consumed += value2;
|
|
966
|
+
state.index += num;
|
|
967
|
+
};
|
|
968
|
+
const append = (token) => {
|
|
969
|
+
state.output += token.output != null ? token.output : token.value;
|
|
970
|
+
consume(token.value);
|
|
971
|
+
};
|
|
972
|
+
const negate = () => {
|
|
973
|
+
let count = 1;
|
|
974
|
+
while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
|
|
975
|
+
advance();
|
|
976
|
+
state.start++;
|
|
977
|
+
count++;
|
|
978
|
+
}
|
|
979
|
+
if (count % 2 === 0) {
|
|
980
|
+
return false;
|
|
981
|
+
}
|
|
982
|
+
state.negated = true;
|
|
983
|
+
state.start++;
|
|
984
|
+
return true;
|
|
985
|
+
};
|
|
986
|
+
const increment = (type) => {
|
|
987
|
+
state[type]++;
|
|
988
|
+
stack.push(type);
|
|
989
|
+
};
|
|
990
|
+
const decrement = (type) => {
|
|
991
|
+
state[type]--;
|
|
992
|
+
stack.pop();
|
|
993
|
+
};
|
|
994
|
+
const push = (tok) => {
|
|
995
|
+
if (prev.type === "globstar") {
|
|
996
|
+
const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
|
|
997
|
+
const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
|
|
998
|
+
if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
|
|
999
|
+
state.output = state.output.slice(0, -prev.output.length);
|
|
1000
|
+
prev.type = "star";
|
|
1001
|
+
prev.value = "*";
|
|
1002
|
+
prev.output = star;
|
|
1003
|
+
state.output += prev.output;
|
|
1004
|
+
}
|
|
1005
|
+
}
|
|
1006
|
+
if (extglobs.length && tok.type !== "paren") {
|
|
1007
|
+
extglobs[extglobs.length - 1].inner += tok.value;
|
|
1008
|
+
}
|
|
1009
|
+
if (tok.value || tok.output) append(tok);
|
|
1010
|
+
if (prev && prev.type === "text" && tok.type === "text") {
|
|
1011
|
+
prev.output = (prev.output || prev.value) + tok.value;
|
|
1012
|
+
prev.value += tok.value;
|
|
1013
|
+
return;
|
|
1014
|
+
}
|
|
1015
|
+
tok.prev = prev;
|
|
1016
|
+
tokens.push(tok);
|
|
1017
|
+
prev = tok;
|
|
1018
|
+
};
|
|
1019
|
+
const extglobOpen = (type, value2) => {
|
|
1020
|
+
const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
|
|
1021
|
+
token.prev = prev;
|
|
1022
|
+
token.parens = state.parens;
|
|
1023
|
+
token.output = state.output;
|
|
1024
|
+
token.startIndex = state.index;
|
|
1025
|
+
token.tokensIndex = tokens.length;
|
|
1026
|
+
const output = (opts.capture ? "(" : "") + token.open;
|
|
1027
|
+
increment("parens");
|
|
1028
|
+
push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
|
|
1029
|
+
push({ type: "paren", extglob: true, value: advance(), output });
|
|
1030
|
+
extglobs.push(token);
|
|
1031
|
+
};
|
|
1032
|
+
const extglobClose = (token) => {
|
|
1033
|
+
const literal = input.slice(token.startIndex, state.index + 1);
|
|
1034
|
+
const body = input.slice(token.startIndex + 2, state.index);
|
|
1035
|
+
const analysis = analyzeRepeatedExtglob(body, opts);
|
|
1036
|
+
if ((token.type === "plus" || token.type === "star") && analysis.risky) {
|
|
1037
|
+
const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
|
|
1038
|
+
const open = tokens[token.tokensIndex];
|
|
1039
|
+
open.type = "text";
|
|
1040
|
+
open.value = literal;
|
|
1041
|
+
open.output = safeOutput || utils.escapeRegex(literal);
|
|
1042
|
+
for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
|
|
1043
|
+
tokens[i].value = "";
|
|
1044
|
+
tokens[i].output = "";
|
|
1045
|
+
delete tokens[i].suffix;
|
|
1046
|
+
}
|
|
1047
|
+
state.output = token.output + open.output;
|
|
1048
|
+
state.backtrack = true;
|
|
1049
|
+
push({ type: "paren", extglob: true, value, output: "" });
|
|
1050
|
+
decrement("parens");
|
|
1051
|
+
return;
|
|
1052
|
+
}
|
|
1053
|
+
let output = token.close + (opts.capture ? ")" : "");
|
|
1054
|
+
let rest;
|
|
1055
|
+
if (token.type === "negate") {
|
|
1056
|
+
let extglobStar = star;
|
|
1057
|
+
if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
|
|
1058
|
+
extglobStar = globstar(opts);
|
|
1059
|
+
}
|
|
1060
|
+
if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
|
|
1061
|
+
output = token.close = `)$))${extglobStar}`;
|
|
1062
|
+
}
|
|
1063
|
+
if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
|
|
1064
|
+
const expression = parse(rest, { ...options, fastpaths: false }).output;
|
|
1065
|
+
output = token.close = `)${expression})${extglobStar})`;
|
|
1066
|
+
}
|
|
1067
|
+
if (token.prev.type === "bos") {
|
|
1068
|
+
state.negatedExtglob = true;
|
|
1069
|
+
}
|
|
1070
|
+
}
|
|
1071
|
+
push({ type: "paren", extglob: true, value, output });
|
|
1072
|
+
decrement("parens");
|
|
1073
|
+
};
|
|
1074
|
+
if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
|
|
1075
|
+
let backslashes = false;
|
|
1076
|
+
let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
|
|
1077
|
+
if (first === "\\") {
|
|
1078
|
+
backslashes = true;
|
|
1079
|
+
return m;
|
|
1080
|
+
}
|
|
1081
|
+
if (first === "?") {
|
|
1082
|
+
if (esc) {
|
|
1083
|
+
return esc + first + (rest ? QMARK.repeat(rest.length) : "");
|
|
1084
|
+
}
|
|
1085
|
+
if (index === 0) {
|
|
1086
|
+
return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
|
|
1087
|
+
}
|
|
1088
|
+
return QMARK.repeat(chars.length);
|
|
1089
|
+
}
|
|
1090
|
+
if (first === ".") {
|
|
1091
|
+
return DOT_LITERAL.repeat(chars.length);
|
|
1092
|
+
}
|
|
1093
|
+
if (first === "*") {
|
|
1094
|
+
if (esc) {
|
|
1095
|
+
return esc + first + (rest ? star : "");
|
|
1096
|
+
}
|
|
1097
|
+
return star;
|
|
1098
|
+
}
|
|
1099
|
+
return esc ? m : `\\${m}`;
|
|
1100
|
+
});
|
|
1101
|
+
if (backslashes === true) {
|
|
1102
|
+
if (opts.unescape === true) {
|
|
1103
|
+
output = output.replace(/\\/g, "");
|
|
1104
|
+
} else {
|
|
1105
|
+
output = output.replace(/\\+/g, (m) => {
|
|
1106
|
+
return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
|
|
1107
|
+
});
|
|
1108
|
+
}
|
|
1109
|
+
}
|
|
1110
|
+
if (output === input && opts.contains === true) {
|
|
1111
|
+
state.output = input;
|
|
1112
|
+
return state;
|
|
1113
|
+
}
|
|
1114
|
+
state.output = utils.wrapOutput(output, state, options);
|
|
1115
|
+
return state;
|
|
1116
|
+
}
|
|
1117
|
+
while (!eos()) {
|
|
1118
|
+
value = advance();
|
|
1119
|
+
if (value === "\0") {
|
|
1120
|
+
continue;
|
|
1121
|
+
}
|
|
1122
|
+
if (value === "\\") {
|
|
1123
|
+
const next = peek();
|
|
1124
|
+
if (next === "/" && opts.bash !== true) {
|
|
1125
|
+
continue;
|
|
1126
|
+
}
|
|
1127
|
+
if (next === "." || next === ";") {
|
|
1128
|
+
continue;
|
|
1129
|
+
}
|
|
1130
|
+
if (!next) {
|
|
1131
|
+
value += "\\";
|
|
1132
|
+
push({ type: "text", value });
|
|
1133
|
+
continue;
|
|
1134
|
+
}
|
|
1135
|
+
const match = /^\\+/.exec(remaining());
|
|
1136
|
+
let slashes = 0;
|
|
1137
|
+
if (match && match[0].length > 2) {
|
|
1138
|
+
slashes = match[0].length;
|
|
1139
|
+
state.index += slashes;
|
|
1140
|
+
if (slashes % 2 !== 0) {
|
|
1141
|
+
value += "\\";
|
|
1142
|
+
}
|
|
1143
|
+
}
|
|
1144
|
+
if (opts.unescape === true) {
|
|
1145
|
+
value = advance();
|
|
1146
|
+
} else {
|
|
1147
|
+
value += advance();
|
|
1148
|
+
}
|
|
1149
|
+
if (state.brackets === 0) {
|
|
1150
|
+
push({ type: "text", value });
|
|
1151
|
+
continue;
|
|
1152
|
+
}
|
|
1153
|
+
}
|
|
1154
|
+
if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
|
|
1155
|
+
if (opts.posix !== false && value === ":") {
|
|
1156
|
+
const inner = prev.value.slice(1);
|
|
1157
|
+
if (inner.includes("[")) {
|
|
1158
|
+
prev.posix = true;
|
|
1159
|
+
if (inner.includes(":")) {
|
|
1160
|
+
const idx = prev.value.lastIndexOf("[");
|
|
1161
|
+
const pre = prev.value.slice(0, idx);
|
|
1162
|
+
const rest2 = prev.value.slice(idx + 2);
|
|
1163
|
+
const posix = POSIX_REGEX_SOURCE[rest2];
|
|
1164
|
+
if (posix) {
|
|
1165
|
+
prev.value = pre + posix;
|
|
1166
|
+
state.backtrack = true;
|
|
1167
|
+
advance();
|
|
1168
|
+
if (!bos.output && tokens.indexOf(prev) === 1) {
|
|
1169
|
+
bos.output = ONE_CHAR;
|
|
1170
|
+
}
|
|
1171
|
+
continue;
|
|
1172
|
+
}
|
|
1173
|
+
}
|
|
1174
|
+
}
|
|
1175
|
+
}
|
|
1176
|
+
if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
|
|
1177
|
+
value = `\\${value}`;
|
|
1178
|
+
}
|
|
1179
|
+
if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
|
|
1180
|
+
value = `\\${value}`;
|
|
1181
|
+
}
|
|
1182
|
+
if (opts.posix === true && value === "!" && prev.value === "[") {
|
|
1183
|
+
value = "^";
|
|
1184
|
+
}
|
|
1185
|
+
prev.value += value;
|
|
1186
|
+
append({ value });
|
|
1187
|
+
continue;
|
|
1188
|
+
}
|
|
1189
|
+
if (state.quotes === 1 && value !== '"') {
|
|
1190
|
+
value = utils.escapeRegex(value);
|
|
1191
|
+
prev.value += value;
|
|
1192
|
+
append({ value });
|
|
1193
|
+
continue;
|
|
1194
|
+
}
|
|
1195
|
+
if (value === '"') {
|
|
1196
|
+
state.quotes = state.quotes === 1 ? 0 : 1;
|
|
1197
|
+
if (opts.keepQuotes === true) {
|
|
1198
|
+
push({ type: "text", value });
|
|
1199
|
+
}
|
|
1200
|
+
continue;
|
|
1201
|
+
}
|
|
1202
|
+
if (value === "(") {
|
|
1203
|
+
increment("parens");
|
|
1204
|
+
push({ type: "paren", value });
|
|
1205
|
+
continue;
|
|
1206
|
+
}
|
|
1207
|
+
if (value === ")") {
|
|
1208
|
+
if (state.parens === 0 && opts.strictBrackets === true) {
|
|
1209
|
+
throw new SyntaxError(syntaxError("opening", "("));
|
|
1210
|
+
}
|
|
1211
|
+
const extglob = extglobs[extglobs.length - 1];
|
|
1212
|
+
if (extglob && state.parens === extglob.parens + 1) {
|
|
1213
|
+
extglobClose(extglobs.pop());
|
|
1214
|
+
continue;
|
|
1215
|
+
}
|
|
1216
|
+
push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
|
|
1217
|
+
decrement("parens");
|
|
1218
|
+
continue;
|
|
1219
|
+
}
|
|
1220
|
+
if (value === "[") {
|
|
1221
|
+
if (opts.nobracket === true || !remaining().includes("]")) {
|
|
1222
|
+
if (opts.nobracket !== true && opts.strictBrackets === true) {
|
|
1223
|
+
throw new SyntaxError(syntaxError("closing", "]"));
|
|
1224
|
+
}
|
|
1225
|
+
value = `\\${value}`;
|
|
1226
|
+
} else {
|
|
1227
|
+
increment("brackets");
|
|
1228
|
+
}
|
|
1229
|
+
push({ type: "bracket", value });
|
|
1230
|
+
continue;
|
|
1231
|
+
}
|
|
1232
|
+
if (value === "]") {
|
|
1233
|
+
if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
|
|
1234
|
+
push({ type: "text", value, output: `\\${value}` });
|
|
1235
|
+
continue;
|
|
1236
|
+
}
|
|
1237
|
+
if (state.brackets === 0) {
|
|
1238
|
+
if (opts.strictBrackets === true) {
|
|
1239
|
+
throw new SyntaxError(syntaxError("opening", "["));
|
|
1240
|
+
}
|
|
1241
|
+
push({ type: "text", value, output: `\\${value}` });
|
|
1242
|
+
continue;
|
|
1243
|
+
}
|
|
1244
|
+
decrement("brackets");
|
|
1245
|
+
const prevValue = prev.value.slice(1);
|
|
1246
|
+
if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
|
|
1247
|
+
value = `/${value}`;
|
|
1248
|
+
}
|
|
1249
|
+
prev.value += value;
|
|
1250
|
+
append({ value });
|
|
1251
|
+
if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
|
|
1252
|
+
continue;
|
|
1253
|
+
}
|
|
1254
|
+
const escaped = utils.escapeRegex(prev.value);
|
|
1255
|
+
state.output = state.output.slice(0, -prev.value.length);
|
|
1256
|
+
if (opts.literalBrackets === true) {
|
|
1257
|
+
state.output += escaped;
|
|
1258
|
+
prev.value = escaped;
|
|
1259
|
+
continue;
|
|
1260
|
+
}
|
|
1261
|
+
prev.value = `(${capture}${escaped}|${prev.value})`;
|
|
1262
|
+
state.output += prev.value;
|
|
1263
|
+
continue;
|
|
1264
|
+
}
|
|
1265
|
+
if (value === "{" && opts.nobrace !== true) {
|
|
1266
|
+
increment("braces");
|
|
1267
|
+
const open = {
|
|
1268
|
+
type: "brace",
|
|
1269
|
+
value,
|
|
1270
|
+
output: "(",
|
|
1271
|
+
outputIndex: state.output.length,
|
|
1272
|
+
tokensIndex: state.tokens.length
|
|
1273
|
+
};
|
|
1274
|
+
braces.push(open);
|
|
1275
|
+
push(open);
|
|
1276
|
+
continue;
|
|
1277
|
+
}
|
|
1278
|
+
if (value === "}") {
|
|
1279
|
+
const brace = braces[braces.length - 1];
|
|
1280
|
+
if (opts.nobrace === true || !brace) {
|
|
1281
|
+
push({ type: "text", value, output: value });
|
|
1282
|
+
continue;
|
|
1283
|
+
}
|
|
1284
|
+
let output = ")";
|
|
1285
|
+
if (brace.dots === true) {
|
|
1286
|
+
const arr = tokens.slice();
|
|
1287
|
+
const range = [];
|
|
1288
|
+
for (let i = arr.length - 1; i >= 0; i--) {
|
|
1289
|
+
tokens.pop();
|
|
1290
|
+
if (arr[i].type === "brace") {
|
|
1291
|
+
break;
|
|
1292
|
+
}
|
|
1293
|
+
if (arr[i].type !== "dots") {
|
|
1294
|
+
range.unshift(arr[i].value);
|
|
1295
|
+
}
|
|
1296
|
+
}
|
|
1297
|
+
output = expandRange(range, opts);
|
|
1298
|
+
state.backtrack = true;
|
|
1299
|
+
}
|
|
1300
|
+
if (brace.comma !== true && brace.dots !== true) {
|
|
1301
|
+
const out = state.output.slice(0, brace.outputIndex);
|
|
1302
|
+
const toks = state.tokens.slice(brace.tokensIndex);
|
|
1303
|
+
brace.value = brace.output = "\\{";
|
|
1304
|
+
value = output = "\\}";
|
|
1305
|
+
state.output = out;
|
|
1306
|
+
for (const t of toks) {
|
|
1307
|
+
state.output += t.output || t.value;
|
|
1308
|
+
}
|
|
1309
|
+
}
|
|
1310
|
+
push({ type: "brace", value, output });
|
|
1311
|
+
decrement("braces");
|
|
1312
|
+
braces.pop();
|
|
1313
|
+
continue;
|
|
1314
|
+
}
|
|
1315
|
+
if (value === "|") {
|
|
1316
|
+
if (extglobs.length > 0) {
|
|
1317
|
+
extglobs[extglobs.length - 1].conditions++;
|
|
1318
|
+
}
|
|
1319
|
+
push({ type: "text", value });
|
|
1320
|
+
continue;
|
|
1321
|
+
}
|
|
1322
|
+
if (value === ",") {
|
|
1323
|
+
let output = value;
|
|
1324
|
+
const brace = braces[braces.length - 1];
|
|
1325
|
+
if (brace && stack[stack.length - 1] === "braces") {
|
|
1326
|
+
brace.comma = true;
|
|
1327
|
+
output = "|";
|
|
1328
|
+
}
|
|
1329
|
+
push({ type: "comma", value, output });
|
|
1330
|
+
continue;
|
|
1331
|
+
}
|
|
1332
|
+
if (value === "/") {
|
|
1333
|
+
if (prev.type === "dot" && state.index === state.start + 1) {
|
|
1334
|
+
state.start = state.index + 1;
|
|
1335
|
+
state.consumed = "";
|
|
1336
|
+
state.output = "";
|
|
1337
|
+
tokens.pop();
|
|
1338
|
+
prev = bos;
|
|
1339
|
+
continue;
|
|
1340
|
+
}
|
|
1341
|
+
push({ type: "slash", value, output: SLASH_LITERAL });
|
|
1342
|
+
continue;
|
|
1343
|
+
}
|
|
1344
|
+
if (value === ".") {
|
|
1345
|
+
if (state.braces > 0 && prev.type === "dot") {
|
|
1346
|
+
if (prev.value === ".") prev.output = DOT_LITERAL;
|
|
1347
|
+
const brace = braces[braces.length - 1];
|
|
1348
|
+
prev.type = "dots";
|
|
1349
|
+
prev.output += value;
|
|
1350
|
+
prev.value += value;
|
|
1351
|
+
brace.dots = true;
|
|
1352
|
+
continue;
|
|
1353
|
+
}
|
|
1354
|
+
if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
|
|
1355
|
+
push({ type: "text", value, output: DOT_LITERAL });
|
|
1356
|
+
continue;
|
|
1357
|
+
}
|
|
1358
|
+
push({ type: "dot", value, output: DOT_LITERAL });
|
|
1359
|
+
continue;
|
|
1360
|
+
}
|
|
1361
|
+
if (value === "?") {
|
|
1362
|
+
const isGroup = prev && prev.value === "(";
|
|
1363
|
+
if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
|
|
1364
|
+
extglobOpen("qmark", value);
|
|
1365
|
+
continue;
|
|
1366
|
+
}
|
|
1367
|
+
if (prev && prev.type === "paren") {
|
|
1368
|
+
const next = peek();
|
|
1369
|
+
let output = value;
|
|
1370
|
+
if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
|
|
1371
|
+
output = `\\${value}`;
|
|
1372
|
+
}
|
|
1373
|
+
push({ type: "text", value, output });
|
|
1374
|
+
continue;
|
|
1375
|
+
}
|
|
1376
|
+
if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
|
|
1377
|
+
push({ type: "qmark", value, output: QMARK_NO_DOT });
|
|
1378
|
+
continue;
|
|
1379
|
+
}
|
|
1380
|
+
push({ type: "qmark", value, output: QMARK });
|
|
1381
|
+
continue;
|
|
1382
|
+
}
|
|
1383
|
+
if (value === "!") {
|
|
1384
|
+
if (opts.noextglob !== true && peek() === "(") {
|
|
1385
|
+
if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
|
|
1386
|
+
extglobOpen("negate", value);
|
|
1387
|
+
continue;
|
|
1388
|
+
}
|
|
1389
|
+
}
|
|
1390
|
+
if (opts.nonegate !== true && state.index === 0) {
|
|
1391
|
+
negate();
|
|
1392
|
+
continue;
|
|
1393
|
+
}
|
|
1394
|
+
}
|
|
1395
|
+
if (value === "+") {
|
|
1396
|
+
if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
|
|
1397
|
+
extglobOpen("plus", value);
|
|
1398
|
+
continue;
|
|
1399
|
+
}
|
|
1400
|
+
if (prev && prev.value === "(" || opts.regex === false) {
|
|
1401
|
+
push({ type: "plus", value, output: PLUS_LITERAL });
|
|
1402
|
+
continue;
|
|
1403
|
+
}
|
|
1404
|
+
if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
|
|
1405
|
+
push({ type: "plus", value });
|
|
1406
|
+
continue;
|
|
1407
|
+
}
|
|
1408
|
+
push({ type: "plus", value: PLUS_LITERAL });
|
|
1409
|
+
continue;
|
|
1410
|
+
}
|
|
1411
|
+
if (value === "@") {
|
|
1412
|
+
if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
|
|
1413
|
+
push({ type: "at", extglob: true, value, output: "" });
|
|
1414
|
+
continue;
|
|
1415
|
+
}
|
|
1416
|
+
push({ type: "text", value });
|
|
1417
|
+
continue;
|
|
1418
|
+
}
|
|
1419
|
+
if (value !== "*") {
|
|
1420
|
+
if (value === "$" || value === "^") {
|
|
1421
|
+
value = `\\${value}`;
|
|
1422
|
+
}
|
|
1423
|
+
const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
|
|
1424
|
+
if (match) {
|
|
1425
|
+
value += match[0];
|
|
1426
|
+
state.index += match[0].length;
|
|
1427
|
+
}
|
|
1428
|
+
push({ type: "text", value });
|
|
1429
|
+
continue;
|
|
1430
|
+
}
|
|
1431
|
+
if (prev && (prev.type === "globstar" || prev.star === true)) {
|
|
1432
|
+
prev.type = "star";
|
|
1433
|
+
prev.star = true;
|
|
1434
|
+
prev.value += value;
|
|
1435
|
+
prev.output = star;
|
|
1436
|
+
state.backtrack = true;
|
|
1437
|
+
state.globstar = true;
|
|
1438
|
+
consume(value);
|
|
1439
|
+
continue;
|
|
1440
|
+
}
|
|
1441
|
+
let rest = remaining();
|
|
1442
|
+
if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
|
|
1443
|
+
extglobOpen("star", value);
|
|
1444
|
+
continue;
|
|
1445
|
+
}
|
|
1446
|
+
if (prev.type === "star") {
|
|
1447
|
+
if (opts.noglobstar === true) {
|
|
1448
|
+
consume(value);
|
|
1449
|
+
continue;
|
|
1450
|
+
}
|
|
1451
|
+
const prior = prev.prev;
|
|
1452
|
+
const before = prior.prev;
|
|
1453
|
+
const isStart = prior.type === "slash" || prior.type === "bos";
|
|
1454
|
+
const afterStar = before && (before.type === "star" || before.type === "globstar");
|
|
1455
|
+
if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
|
|
1456
|
+
push({ type: "star", value, output: "" });
|
|
1457
|
+
continue;
|
|
1458
|
+
}
|
|
1459
|
+
const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
|
|
1460
|
+
const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
|
|
1461
|
+
if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
|
|
1462
|
+
push({ type: "star", value, output: "" });
|
|
1463
|
+
continue;
|
|
1464
|
+
}
|
|
1465
|
+
while (rest.slice(0, 3) === "/**") {
|
|
1466
|
+
const after = input[state.index + 4];
|
|
1467
|
+
if (after && after !== "/") {
|
|
1468
|
+
break;
|
|
1469
|
+
}
|
|
1470
|
+
rest = rest.slice(3);
|
|
1471
|
+
consume("/**", 3);
|
|
1472
|
+
}
|
|
1473
|
+
const isEnd = eos() || state.parens > 0 && rest === ")".repeat(state.parens) && !extglobs.some((extglob) => extglob.type === "negate");
|
|
1474
|
+
if (prior.type === "bos" && eos()) {
|
|
1475
|
+
prev.type = "globstar";
|
|
1476
|
+
prev.value += value;
|
|
1477
|
+
prev.output = globstar(opts);
|
|
1478
|
+
state.output = prev.output;
|
|
1479
|
+
state.globstar = true;
|
|
1480
|
+
consume(value);
|
|
1481
|
+
continue;
|
|
1482
|
+
}
|
|
1483
|
+
if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && isEnd) {
|
|
1484
|
+
state.output = state.output.slice(0, -(prior.output + prev.output).length);
|
|
1485
|
+
prior.output = `(?:${prior.output}`;
|
|
1486
|
+
prev.type = "globstar";
|
|
1487
|
+
prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
|
|
1488
|
+
prev.value += value;
|
|
1489
|
+
state.globstar = true;
|
|
1490
|
+
state.output += prior.output + prev.output;
|
|
1491
|
+
consume(value);
|
|
1492
|
+
continue;
|
|
1493
|
+
}
|
|
1494
|
+
if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
|
|
1495
|
+
const end = rest[1] !== void 0 ? "|$" : "";
|
|
1496
|
+
state.output = state.output.slice(0, -(prior.output + prev.output).length);
|
|
1497
|
+
prior.output = `(?:${prior.output}`;
|
|
1498
|
+
prev.type = "globstar";
|
|
1499
|
+
prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
|
|
1500
|
+
prev.value += value;
|
|
1501
|
+
state.output += prior.output + prev.output;
|
|
1502
|
+
state.globstar = true;
|
|
1503
|
+
consume(value + advance());
|
|
1504
|
+
push({ type: "slash", value: "/", output: "" });
|
|
1505
|
+
continue;
|
|
1506
|
+
}
|
|
1507
|
+
if (prior.type === "bos" && rest[0] === "/") {
|
|
1508
|
+
prev.type = "globstar";
|
|
1509
|
+
prev.value += value;
|
|
1510
|
+
prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
|
|
1511
|
+
state.output = prev.output;
|
|
1512
|
+
state.globstar = true;
|
|
1513
|
+
consume(value + advance());
|
|
1514
|
+
push({ type: "slash", value: "/", output: "" });
|
|
1515
|
+
continue;
|
|
1516
|
+
}
|
|
1517
|
+
state.output = state.output.slice(0, -prev.output.length);
|
|
1518
|
+
prev.type = "globstar";
|
|
1519
|
+
prev.output = globstar(opts);
|
|
1520
|
+
prev.value += value;
|
|
1521
|
+
state.output += prev.output;
|
|
1522
|
+
state.globstar = true;
|
|
1523
|
+
consume(value);
|
|
1524
|
+
continue;
|
|
1525
|
+
}
|
|
1526
|
+
const token = { type: "star", value, output: star };
|
|
1527
|
+
if (opts.bash === true) {
|
|
1528
|
+
token.output = ".*?";
|
|
1529
|
+
if (prev.type === "bos" || prev.type === "slash") {
|
|
1530
|
+
token.output = nodot + token.output;
|
|
1531
|
+
}
|
|
1532
|
+
push(token);
|
|
1533
|
+
continue;
|
|
1534
|
+
}
|
|
1535
|
+
if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
|
|
1536
|
+
token.output = value;
|
|
1537
|
+
push(token);
|
|
1538
|
+
continue;
|
|
1539
|
+
}
|
|
1540
|
+
if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
|
|
1541
|
+
if (prev.type === "dot") {
|
|
1542
|
+
state.output += NO_DOT_SLASH;
|
|
1543
|
+
prev.output += NO_DOT_SLASH;
|
|
1544
|
+
} else if (opts.dot === true) {
|
|
1545
|
+
state.output += NO_DOTS_SLASH;
|
|
1546
|
+
prev.output += NO_DOTS_SLASH;
|
|
1547
|
+
} else {
|
|
1548
|
+
state.output += nodot;
|
|
1549
|
+
prev.output += nodot;
|
|
1550
|
+
}
|
|
1551
|
+
if (peek() !== "*") {
|
|
1552
|
+
state.output += ONE_CHAR;
|
|
1553
|
+
prev.output += ONE_CHAR;
|
|
1554
|
+
}
|
|
1555
|
+
}
|
|
1556
|
+
push(token);
|
|
1557
|
+
}
|
|
1558
|
+
while (state.brackets > 0) {
|
|
1559
|
+
if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
|
|
1560
|
+
state.output = utils.escapeLast(state.output, "[");
|
|
1561
|
+
decrement("brackets");
|
|
1562
|
+
}
|
|
1563
|
+
while (state.parens > 0) {
|
|
1564
|
+
if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
|
|
1565
|
+
state.output = utils.escapeLast(state.output, "(");
|
|
1566
|
+
decrement("parens");
|
|
1567
|
+
}
|
|
1568
|
+
while (state.braces > 0) {
|
|
1569
|
+
if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
|
|
1570
|
+
state.output = utils.escapeLast(state.output, "{");
|
|
1571
|
+
decrement("braces");
|
|
1572
|
+
}
|
|
1573
|
+
if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
|
|
1574
|
+
push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
|
|
1575
|
+
}
|
|
1576
|
+
if (state.backtrack === true) {
|
|
1577
|
+
state.output = "";
|
|
1578
|
+
for (const token of state.tokens) {
|
|
1579
|
+
state.output += token.output != null ? token.output : token.value;
|
|
1580
|
+
if (token.suffix) {
|
|
1581
|
+
state.output += token.suffix;
|
|
1582
|
+
}
|
|
1583
|
+
}
|
|
1584
|
+
}
|
|
1585
|
+
return state;
|
|
1586
|
+
};
|
|
1587
|
+
parse.fastpaths = (input, options) => {
|
|
1588
|
+
const opts = { ...options };
|
|
1589
|
+
const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
|
|
1590
|
+
const len = input.length;
|
|
1591
|
+
if (len > max) {
|
|
1592
|
+
throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
|
|
1593
|
+
}
|
|
1594
|
+
input = REPLACEMENTS[input] || input;
|
|
1595
|
+
const {
|
|
1596
|
+
DOT_LITERAL,
|
|
1597
|
+
SLASH_LITERAL,
|
|
1598
|
+
ONE_CHAR,
|
|
1599
|
+
DOTS_SLASH,
|
|
1600
|
+
NO_DOT,
|
|
1601
|
+
NO_DOTS,
|
|
1602
|
+
NO_DOTS_SLASH,
|
|
1603
|
+
STAR,
|
|
1604
|
+
START_ANCHOR
|
|
1605
|
+
} = constants.globChars(opts.windows);
|
|
1606
|
+
const nodot = opts.dot ? NO_DOTS : NO_DOT;
|
|
1607
|
+
const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
|
|
1608
|
+
const capture = opts.capture ? "" : "?:";
|
|
1609
|
+
const state = { negated: false, prefix: "" };
|
|
1610
|
+
let star = opts.bash === true ? ".*?" : STAR;
|
|
1611
|
+
if (opts.capture) {
|
|
1612
|
+
star = `(${star})`;
|
|
1613
|
+
}
|
|
1614
|
+
const globstar = (opts2) => {
|
|
1615
|
+
if (opts2.noglobstar === true) return star;
|
|
1616
|
+
return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
|
|
1617
|
+
};
|
|
1618
|
+
const create = (str) => {
|
|
1619
|
+
switch (str) {
|
|
1620
|
+
case "*":
|
|
1621
|
+
return `${nodot}${ONE_CHAR}${star}`;
|
|
1622
|
+
case ".*":
|
|
1623
|
+
return `${DOT_LITERAL}${ONE_CHAR}${star}`;
|
|
1624
|
+
case "*.*":
|
|
1625
|
+
return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
|
|
1626
|
+
case "*/*":
|
|
1627
|
+
return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
|
|
1628
|
+
case "**":
|
|
1629
|
+
return nodot + globstar(opts);
|
|
1630
|
+
case "**/*":
|
|
1631
|
+
return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
|
|
1632
|
+
case "**/*.*":
|
|
1633
|
+
return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
|
|
1634
|
+
case "**/.*":
|
|
1635
|
+
return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
|
|
1636
|
+
default: {
|
|
1637
|
+
const match = /^(.*?)\.(\w+)$/.exec(str);
|
|
1638
|
+
if (!match) return;
|
|
1639
|
+
const source2 = create(match[1]);
|
|
1640
|
+
if (!source2) return;
|
|
1641
|
+
return source2 + DOT_LITERAL + match[2];
|
|
1642
|
+
}
|
|
1643
|
+
}
|
|
1644
|
+
};
|
|
1645
|
+
const output = utils.removePrefix(input, state);
|
|
1646
|
+
let source = create(output);
|
|
1647
|
+
if (source && opts.strictSlashes !== true) {
|
|
1648
|
+
source += `${SLASH_LITERAL}?`;
|
|
1649
|
+
}
|
|
1650
|
+
return source;
|
|
1651
|
+
};
|
|
1652
|
+
module2.exports = parse;
|
|
1653
|
+
}
|
|
1654
|
+
});
|
|
1655
|
+
|
|
1656
|
+
// node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/picomatch.js
|
|
1657
|
+
var require_picomatch = __commonJS({
|
|
1658
|
+
"node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
|
|
1659
|
+
"use strict";
|
|
1660
|
+
var scan = require_scan();
|
|
1661
|
+
var parse = require_parse();
|
|
1662
|
+
var utils = require_utils();
|
|
1663
|
+
var constants = require_constants();
|
|
1664
|
+
var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
|
|
1665
|
+
var picomatch = (glob, options, returnState = false) => {
|
|
1666
|
+
if (Array.isArray(glob)) {
|
|
1667
|
+
const fns = glob.map((input) => picomatch(input, options, returnState));
|
|
1668
|
+
const arrayMatcher = (str) => {
|
|
1669
|
+
for (const isMatch of fns) {
|
|
1670
|
+
const state2 = isMatch(str);
|
|
1671
|
+
if (state2) return state2;
|
|
1672
|
+
}
|
|
1673
|
+
return false;
|
|
1674
|
+
};
|
|
1675
|
+
return arrayMatcher;
|
|
1676
|
+
}
|
|
1677
|
+
const isState = isObject(glob) && glob.tokens && glob.input;
|
|
1678
|
+
if (glob === "" || typeof glob !== "string" && !isState) {
|
|
1679
|
+
throw new TypeError("Expected pattern to be a non-empty string");
|
|
1680
|
+
}
|
|
1681
|
+
const opts = options || {};
|
|
1682
|
+
const posix = opts.windows;
|
|
1683
|
+
const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
|
|
1684
|
+
const state = regex.state;
|
|
1685
|
+
delete regex.state;
|
|
1686
|
+
let isIgnored = () => false;
|
|
1687
|
+
if (opts.ignore) {
|
|
1688
|
+
const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
|
|
1689
|
+
isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
|
|
1690
|
+
}
|
|
1691
|
+
const matcher = (input, returnObject = false) => {
|
|
1692
|
+
const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
|
|
1693
|
+
const result = { glob, state, regex, posix, input, output, match, isMatch };
|
|
1694
|
+
if (typeof opts.onResult === "function") {
|
|
1695
|
+
opts.onResult(result);
|
|
1696
|
+
}
|
|
1697
|
+
if (isMatch === false) {
|
|
1698
|
+
result.isMatch = false;
|
|
1699
|
+
return returnObject ? result : false;
|
|
1700
|
+
}
|
|
1701
|
+
if (isIgnored(input)) {
|
|
1702
|
+
if (typeof opts.onIgnore === "function") {
|
|
1703
|
+
opts.onIgnore(result);
|
|
1704
|
+
}
|
|
1705
|
+
result.isMatch = false;
|
|
1706
|
+
return returnObject ? result : false;
|
|
1707
|
+
}
|
|
1708
|
+
if (typeof opts.onMatch === "function") {
|
|
1709
|
+
opts.onMatch(result);
|
|
1710
|
+
}
|
|
1711
|
+
return returnObject ? result : true;
|
|
1712
|
+
};
|
|
1713
|
+
if (returnState) {
|
|
1714
|
+
matcher.state = state;
|
|
1715
|
+
}
|
|
1716
|
+
return matcher;
|
|
1717
|
+
};
|
|
1718
|
+
picomatch.test = (input, regex, options, { glob, posix } = {}) => {
|
|
1719
|
+
if (typeof input !== "string") {
|
|
1720
|
+
throw new TypeError("Expected input to be a string");
|
|
1721
|
+
}
|
|
1722
|
+
if (input === "") {
|
|
1723
|
+
return { isMatch: false, output: "" };
|
|
1724
|
+
}
|
|
1725
|
+
const opts = options || {};
|
|
1726
|
+
const format = opts.format || (posix ? utils.toPosixSlashes : null);
|
|
1727
|
+
let match = input === glob;
|
|
1728
|
+
let output = match && format ? format(input) : input;
|
|
1729
|
+
if (match === false) {
|
|
1730
|
+
output = format ? format(input) : input;
|
|
1731
|
+
match = output === glob;
|
|
1732
|
+
}
|
|
1733
|
+
if (match === false || opts.capture === true) {
|
|
1734
|
+
if (opts.matchBase === true || opts.basename === true) {
|
|
1735
|
+
match = picomatch.matchBase(input, regex, options, posix);
|
|
1736
|
+
} else {
|
|
1737
|
+
match = regex.exec(output);
|
|
1738
|
+
}
|
|
1739
|
+
}
|
|
1740
|
+
return { isMatch: Boolean(match), match, output };
|
|
1741
|
+
};
|
|
1742
|
+
picomatch.matchBase = (input, glob, options, posix = options && options.windows) => {
|
|
1743
|
+
const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
|
|
1744
|
+
return regex.test(utils.basename(input, { windows: posix }));
|
|
1745
|
+
};
|
|
1746
|
+
picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
|
|
1747
|
+
picomatch.parse = (pattern, options) => {
|
|
1748
|
+
if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
|
|
1749
|
+
return parse(pattern, { ...options, fastpaths: false });
|
|
1750
|
+
};
|
|
1751
|
+
picomatch.scan = (input, options) => scan(input, options);
|
|
1752
|
+
picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
|
|
1753
|
+
if (returnOutput === true) {
|
|
1754
|
+
return state.output;
|
|
1755
|
+
}
|
|
1756
|
+
const opts = options || {};
|
|
1757
|
+
const prepend = opts.contains ? "" : "^";
|
|
1758
|
+
const append = opts.contains ? "" : "$";
|
|
1759
|
+
let source = `${prepend}(?:${state.output})${append}`;
|
|
1760
|
+
if (state && state.negated === true) {
|
|
1761
|
+
source = `^(?!${source}).*$`;
|
|
1762
|
+
}
|
|
1763
|
+
const regex = picomatch.toRegex(source, options);
|
|
1764
|
+
if (returnState === true) {
|
|
1765
|
+
regex.state = state;
|
|
1766
|
+
}
|
|
1767
|
+
return regex;
|
|
1768
|
+
};
|
|
1769
|
+
picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
|
|
1770
|
+
if (!input || typeof input !== "string") {
|
|
1771
|
+
throw new TypeError("Expected a non-empty string");
|
|
1772
|
+
}
|
|
1773
|
+
let parsed = { negated: false, fastpaths: true };
|
|
1774
|
+
if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
|
|
1775
|
+
parsed.output = parse.fastpaths(input, options);
|
|
1776
|
+
}
|
|
1777
|
+
if (!parsed.output) {
|
|
1778
|
+
parsed = parse(input, options);
|
|
1779
|
+
}
|
|
1780
|
+
return picomatch.compileRe(parsed, options, returnOutput, returnState);
|
|
1781
|
+
};
|
|
1782
|
+
picomatch.toRegex = (source, options) => {
|
|
1783
|
+
try {
|
|
1784
|
+
const opts = options || {};
|
|
1785
|
+
return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
|
|
1786
|
+
} catch (err) {
|
|
1787
|
+
if (options && options.debug === true) throw err;
|
|
1788
|
+
return /$^/;
|
|
1789
|
+
}
|
|
1790
|
+
};
|
|
1791
|
+
picomatch.constants = constants;
|
|
1792
|
+
module2.exports = picomatch;
|
|
1793
|
+
}
|
|
1794
|
+
});
|
|
1795
|
+
|
|
1796
|
+
// node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/index.js
|
|
1797
|
+
var require_picomatch2 = __commonJS({
|
|
1798
|
+
"node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/index.js"(exports2, module2) {
|
|
1799
|
+
"use strict";
|
|
1800
|
+
var pico = require_picomatch();
|
|
1801
|
+
var utils = require_utils();
|
|
1802
|
+
function picomatch(glob, options, returnState = false) {
|
|
1803
|
+
if (options && (options.windows === null || options.windows === void 0)) {
|
|
1804
|
+
options = { ...options, windows: utils.isWindows() };
|
|
1805
|
+
}
|
|
1806
|
+
return pico(glob, options, returnState);
|
|
1807
|
+
}
|
|
1808
|
+
Object.assign(picomatch, pico);
|
|
1809
|
+
module2.exports = picomatch;
|
|
1810
|
+
}
|
|
1811
|
+
});
|
|
1812
|
+
|
|
1813
|
+
// node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.7/node_modules/fdir/dist/index.cjs
|
|
38
1814
|
var require_dist = __commonJS({
|
|
39
|
-
"node_modules/.pnpm/fdir@6.5.0/node_modules/fdir/dist/index.cjs"(exports2) {
|
|
1815
|
+
"node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.7/node_modules/fdir/dist/index.cjs"(exports2) {
|
|
40
1816
|
var __create2 = Object.create;
|
|
41
1817
|
var __defProp2 = Object.defineProperty;
|
|
42
1818
|
var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
|
|
@@ -174,10 +1950,10 @@ var require_dist = __commonJS({
|
|
|
174
1950
|
queue.enqueue();
|
|
175
1951
|
fs$1.realpath(path$1, (error, resolvedPath) => {
|
|
176
1952
|
if (error) return queue.dequeue(suppressErrors ? null : error, state);
|
|
177
|
-
fs$1.stat(resolvedPath, (error$1,
|
|
1953
|
+
fs$1.stat(resolvedPath, (error$1, stat2) => {
|
|
178
1954
|
if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
|
|
179
|
-
if (
|
|
180
|
-
callback$1(
|
|
1955
|
+
if (stat2.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state);
|
|
1956
|
+
callback$1(stat2, resolvedPath);
|
|
181
1957
|
queue.dequeue(null, state);
|
|
182
1958
|
});
|
|
183
1959
|
});
|
|
@@ -187,9 +1963,9 @@ var require_dist = __commonJS({
|
|
|
187
1963
|
queue.enqueue();
|
|
188
1964
|
try {
|
|
189
1965
|
const resolvedPath = fs$1.realpathSync(path$1);
|
|
190
|
-
const
|
|
191
|
-
if (
|
|
192
|
-
callback$1(
|
|
1966
|
+
const stat2 = fs$1.statSync(resolvedPath);
|
|
1967
|
+
if (stat2.isDirectory() && isRecursive(path$1, resolvedPath, state)) return;
|
|
1968
|
+
callback$1(stat2, resolvedPath);
|
|
193
1969
|
} catch (e) {
|
|
194
1970
|
if (!suppressErrors) throw e;
|
|
195
1971
|
}
|
|
@@ -386,8 +2162,8 @@ var require_dist = __commonJS({
|
|
|
386
2162
|
this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk);
|
|
387
2163
|
} else if (this.resolveSymlink && entry.isSymbolicLink()) {
|
|
388
2164
|
let path$1 = joinPathWithBasePath(entry.name, directoryPath);
|
|
389
|
-
this.resolveSymlink(path$1, this.state, (
|
|
390
|
-
if (
|
|
2165
|
+
this.resolveSymlink(path$1, this.state, (stat2, resolvedPath) => {
|
|
2166
|
+
if (stat2.isDirectory()) {
|
|
391
2167
|
resolvedPath = normalizePath(resolvedPath, this.state.options);
|
|
392
2168
|
if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return;
|
|
393
2169
|
this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk);
|
|
@@ -438,7 +2214,7 @@ var require_dist = __commonJS({
|
|
|
438
2214
|
var pm = null;
|
|
439
2215
|
try {
|
|
440
2216
|
require.resolve("picomatch");
|
|
441
|
-
pm =
|
|
2217
|
+
pm = require_picomatch2();
|
|
442
2218
|
} catch {
|
|
443
2219
|
}
|
|
444
2220
|
var Builder = class {
|
|
@@ -1422,19 +3198,23 @@ __export(index_exports, {
|
|
|
1422
3198
|
module.exports = __toCommonJS(index_exports);
|
|
1423
3199
|
|
|
1424
3200
|
// src/engine.ts
|
|
1425
|
-
var
|
|
3201
|
+
var import_node_fs4 = require("node:fs");
|
|
1426
3202
|
var import_node_path2 = require("node:path");
|
|
3203
|
+
var import_node_process2 = require("node:process");
|
|
1427
3204
|
var import_fdir = __toESM(require_dist(), 1);
|
|
1428
3205
|
|
|
1429
3206
|
// src/cascade.ts
|
|
1430
3207
|
var import_node_fs = require("node:fs");
|
|
1431
|
-
function
|
|
3208
|
+
function readIgnoreFileText(dirPath, filename) {
|
|
1432
3209
|
try {
|
|
1433
|
-
return (0, import_node_fs.readFileSync)(`${dirPath.replace(/\/+$/, "")}
|
|
3210
|
+
return (0, import_node_fs.readFileSync)(`${dirPath.replace(/\/+$/, "")}/${filename}`, "utf8");
|
|
1434
3211
|
} catch {
|
|
1435
3212
|
return null;
|
|
1436
3213
|
}
|
|
1437
3214
|
}
|
|
3215
|
+
function readGitignoreText(dirPath) {
|
|
3216
|
+
return readIgnoreFileText(dirPath, ".gitignore");
|
|
3217
|
+
}
|
|
1438
3218
|
function splitLines(text) {
|
|
1439
3219
|
return text.split(/\r?\n/);
|
|
1440
3220
|
}
|
|
@@ -1474,16 +3254,23 @@ var PRESETS = {
|
|
|
1474
3254
|
// Build outputs and coverage. These are collision-grade names (a project's
|
|
1475
3255
|
// source can legitimately live in `lib/`) — that is exactly why they ride
|
|
1476
3256
|
// the un-excludable preset channel (`!lib/` names its way out) instead of
|
|
1477
|
-
// a separate immune layer.
|
|
1478
|
-
|
|
3257
|
+
// a separate immune layer. `/target` is the ROOT-ANCHORED cargo/maven
|
|
3258
|
+
// build tree: anchored exactly because `target` is collision-grade — the
|
|
3259
|
+
// Rust toolchain's own adjudication (cargo#3158: a bare `target` hits
|
|
3260
|
+
// same-named directories at any depth; `cargo new` generates `/target`),
|
|
3261
|
+
// so the entry binds only when the scan root itself is the project.
|
|
3262
|
+
dirs: ["dist", "build", "lib", "out", "coverage", "/target"]
|
|
1479
3263
|
},
|
|
1480
3264
|
caches: {
|
|
1481
|
-
// Python
|
|
3265
|
+
// Cache/generated trees (Python, front-end, build tools). Vendor lineage
|
|
3266
|
+
// of the entries:
|
|
1482
3267
|
// - repomix `defaultIgnore.ts` (MIT): __pycache__, .mypy_cache,
|
|
1483
|
-
// .pytest_cache, .tox, .venv,
|
|
1484
|
-
// .parcel-cache, .svelte-kit
|
|
3268
|
+
// .pytest_cache, .tox, .venv, venv, .gradle, .cache, .next, .nuxt,
|
|
3269
|
+
// .turbo, .vite, .parcel-cache, .svelte-kit
|
|
1485
3270
|
// - watchfiles `DefaultFilter` (Python-side alignment): __pycache__,
|
|
1486
3271
|
// .mypy_cache, .pytest_cache, .ruff_cache, .tox, .nox, .venv
|
|
3272
|
+
// (non-dot `venv` and `.gradle` are repomix-only — watchfiles carries
|
|
3273
|
+
// neither; github's Python/Gradle templates carry both)
|
|
1487
3274
|
// This group is NOT in the default mount set.
|
|
1488
3275
|
dirs: [
|
|
1489
3276
|
"__pycache__",
|
|
@@ -1492,6 +3279,8 @@ var PRESETS = {
|
|
|
1492
3279
|
".ruff_cache",
|
|
1493
3280
|
".tox",
|
|
1494
3281
|
".venv",
|
|
3282
|
+
"venv",
|
|
3283
|
+
".gradle",
|
|
1495
3284
|
".cache",
|
|
1496
3285
|
".next",
|
|
1497
3286
|
".nuxt",
|
|
@@ -1549,10 +3338,58 @@ var PathscopeGitError = class extends Error {
|
|
|
1549
3338
|
}
|
|
1550
3339
|
};
|
|
1551
3340
|
|
|
3341
|
+
// src/win-attr.ts
|
|
3342
|
+
var import_node_module = require("node:module");
|
|
3343
|
+
var import_node_process = require("node:process");
|
|
3344
|
+
var import_meta = {};
|
|
3345
|
+
var cached;
|
|
3346
|
+
function requireForThisFile() {
|
|
3347
|
+
if (typeof __filename !== "undefined") return (0, import_node_module.createRequire)(__filename);
|
|
3348
|
+
return (0, import_node_module.createRequire)(import_meta.url);
|
|
3349
|
+
}
|
|
3350
|
+
var PREBUILD_CANDIDATES = [
|
|
3351
|
+
"../prebuilds/win32-x64/pathscope_win_attr.node",
|
|
3352
|
+
"../../prebuilds/win32-x64/pathscope_win_attr.node"
|
|
3353
|
+
];
|
|
3354
|
+
function loadWinAttr() {
|
|
3355
|
+
if (cached !== void 0) return cached;
|
|
3356
|
+
cached = null;
|
|
3357
|
+
if (import_node_process.platform === "win32") {
|
|
3358
|
+
const require2 = requireForThisFile();
|
|
3359
|
+
for (const candidate of PREBUILD_CANDIDATES) {
|
|
3360
|
+
try {
|
|
3361
|
+
const mod = require2(candidate);
|
|
3362
|
+
if (typeof mod.getHidden === "function" && typeof mod.readdirWithAttrs === "function" && typeof mod.readdirWithAttrsSync === "function") {
|
|
3363
|
+
cached = mod;
|
|
3364
|
+
break;
|
|
3365
|
+
}
|
|
3366
|
+
} catch {
|
|
3367
|
+
}
|
|
3368
|
+
}
|
|
3369
|
+
}
|
|
3370
|
+
return cached;
|
|
3371
|
+
}
|
|
3372
|
+
function hiddenFaceDiagnostic(excludeDotEntriesOn, addonAvailable, isWin) {
|
|
3373
|
+
if (!isWin || !excludeDotEntriesOn || addonAvailable) return null;
|
|
3374
|
+
return {
|
|
3375
|
+
code: "windows-hidden-attributes-unavailable",
|
|
3376
|
+
message: "the Windows hidden-attribute face of the dot category is inert this run (native prebuild not loaded): attribute-hidden, dot-less entries are NOT pruned \u2014 never a silent cut; install integrity or the package tarball is the first suspect"
|
|
3377
|
+
};
|
|
3378
|
+
}
|
|
3379
|
+
|
|
1552
3380
|
// src/exclusion-engine.ts
|
|
1553
3381
|
var nodeExclusionIO = {
|
|
1554
3382
|
exists: (dirKey, name) => Promise.resolve((0, import_node_fs2.existsSync)((0, import_node_path.join)(dirKey, ...name.split("/")))),
|
|
1555
|
-
readGitignore: (dirKey) => Promise.resolve(readGitignoreText(dirKey))
|
|
3383
|
+
readGitignore: (dirKey) => Promise.resolve(readGitignoreText(dirKey)),
|
|
3384
|
+
readIgnoreFamily: (dirKey) => Promise.resolve({
|
|
3385
|
+
ignore: readIgnoreFileText(dirKey, ".ignore"),
|
|
3386
|
+
rgignore: readIgnoreFileText(dirKey, ".rgignore")
|
|
3387
|
+
}),
|
|
3388
|
+
hidden: (dirKey, name) => {
|
|
3389
|
+
const winAttr = loadWinAttr();
|
|
3390
|
+
if (winAttr === null) return Promise.resolve(null);
|
|
3391
|
+
return Promise.resolve(winAttr.getHidden((0, import_node_path.join)(dirKey, ...name.split("/"))) === 1);
|
|
3392
|
+
}
|
|
1556
3393
|
};
|
|
1557
3394
|
function validateOptions(options) {
|
|
1558
3395
|
if (options.mountPresets !== void 0) {
|
|
@@ -1625,18 +3462,20 @@ function parentDirKey(key) {
|
|
|
1625
3462
|
async function createExclusionEngine(rootKey, options = {}, io = nodeExclusionIO) {
|
|
1626
3463
|
validateOptions(options);
|
|
1627
3464
|
const respectGitignore = options.respectGitignore !== false;
|
|
3465
|
+
const respectIgnoreFamily = options.respectIgnoreFamily !== false;
|
|
1628
3466
|
const asRule = (raw) => raw === "" || raw.startsWith("#") || raw === "!" ? null : raw;
|
|
1629
3467
|
const ruleIg = (mounted) => {
|
|
1630
3468
|
const ig = (0, import_ignore.default)();
|
|
1631
3469
|
ig.add([mounted]);
|
|
1632
3470
|
return ig;
|
|
1633
3471
|
};
|
|
1634
|
-
const gitignoreRules = (lines, anchor, prefix) =>
|
|
3472
|
+
const gitignoreRules = (lines, anchor, prefix) => ignoreFileRules(lines, anchor, prefix, "gitignore");
|
|
3473
|
+
const ignoreFileRules = (lines, anchor, prefix, source, ignoreFile) => {
|
|
1635
3474
|
const out = [];
|
|
1636
3475
|
for (const raw of lines) {
|
|
1637
3476
|
const mounted = prefix === "" ? asRule(raw) : reanchorLine(raw, prefix);
|
|
1638
3477
|
if (mounted === null) continue;
|
|
1639
|
-
out.push({ mounted, original: raw, source
|
|
3478
|
+
out.push({ mounted, original: raw, source, gitignoreAnchor: anchor, ...ignoreFile !== void 0 ? { ignoreFile } : {}, ig: ruleIg(mounted) });
|
|
1640
3479
|
}
|
|
1641
3480
|
return out;
|
|
1642
3481
|
};
|
|
@@ -1648,6 +3487,7 @@ async function createExclusionEngine(rootKey, options = {}, io = nodeExclusionIO
|
|
|
1648
3487
|
const hit = { source: r.source, ruleText: r.original };
|
|
1649
3488
|
if (r.presetName !== void 0) hit.presetName = r.presetName;
|
|
1650
3489
|
if (r.gitignoreAnchor !== void 0) hit.gitignoreAnchor = r.gitignoreAnchor;
|
|
3490
|
+
if (r.ignoreFile !== void 0) hit.ignoreFile = r.ignoreFile;
|
|
1651
3491
|
hits.push(hit);
|
|
1652
3492
|
}
|
|
1653
3493
|
return hits;
|
|
@@ -1718,6 +3558,15 @@ async function createExclusionEngine(rootKey, options = {}, io = nodeExclusionIO
|
|
|
1718
3558
|
if (rootIgnoreText !== null) {
|
|
1719
3559
|
coreRules.push(...gitignoreRules(splitLines(rootIgnoreText), "", offRel));
|
|
1720
3560
|
}
|
|
3561
|
+
if (respectIgnoreFamily && io.readIgnoreFamily !== void 0) {
|
|
3562
|
+
const family = await io.readIgnoreFamily(rootKey);
|
|
3563
|
+
if (family.ignore !== null) {
|
|
3564
|
+
coreRules.push(...ignoreFileRules(splitLines(family.ignore), "", offRel, "ignore", ".ignore"));
|
|
3565
|
+
}
|
|
3566
|
+
if (family.rgignore !== null) {
|
|
3567
|
+
coreRules.push(...ignoreFileRules(splitLines(family.rgignore), "", offRel, "ignore", ".rgignore"));
|
|
3568
|
+
}
|
|
3569
|
+
}
|
|
1721
3570
|
if (coreRules.length > 0) core.add(coreRules.map((r) => r.mounted));
|
|
1722
3571
|
const policy = (0, import_ignore.default)();
|
|
1723
3572
|
const policyRules = [];
|
|
@@ -1790,82 +3639,109 @@ async function createExclusionEngine(rootKey, options = {}, io = nodeExclusionIO
|
|
|
1790
3639
|
if (policyResult.unignored) return false;
|
|
1791
3640
|
return core.test(canonical).ignored;
|
|
1792
3641
|
};
|
|
1793
|
-
const
|
|
3642
|
+
const runDirectoryVerdict = (name, dirPath, stoneHit, meta, hits) => {
|
|
1794
3643
|
const key = dirPath.replace(/\/+$/, "");
|
|
1795
3644
|
const relDir = key === rootKey ? "" : key.slice(rootKey.length + 1);
|
|
1796
|
-
const hits = [];
|
|
1797
3645
|
if (key !== rootKey) {
|
|
1798
|
-
const stones =
|
|
1799
|
-
hits.push(...stones);
|
|
1800
|
-
if (stones.some((h) => h.enforced)) return
|
|
3646
|
+
const stones = stoneDetail(stoneHit, relDir);
|
|
3647
|
+
if (hits !== void 0) hits.push(...stoneHitEntries(stones));
|
|
3648
|
+
if (stones.some((h) => h.enforced)) return true;
|
|
1801
3649
|
}
|
|
1802
3650
|
const canonicalDir = toCanonical(`${relDir}/`);
|
|
1803
|
-
hits.push(...channelHits(strictRules, canonicalDir));
|
|
1804
|
-
if (strictIg.test(canonicalDir).ignored) return
|
|
3651
|
+
if (hits !== void 0) hits.push(...channelHits(strictRules, canonicalDir));
|
|
3652
|
+
if (strictIg.test(canonicalDir).ignored) return true;
|
|
1805
3653
|
if (overrideIg.test(canonicalDir).ignored) {
|
|
1806
|
-
hits.push(...channelHits(overrideRules, canonicalDir));
|
|
1807
|
-
return
|
|
3654
|
+
if (hits !== void 0) hits.push(...channelHits(overrideRules, canonicalDir));
|
|
3655
|
+
return false;
|
|
3656
|
+
}
|
|
3657
|
+
if (hits !== void 0) {
|
|
3658
|
+
hits.push(...channelHits(coreRules, canonicalDir));
|
|
3659
|
+
hits.push(...channelHits(policyRules, canonicalDir));
|
|
1808
3660
|
}
|
|
1809
|
-
hits.push(...channelHits(coreRules, canonicalDir));
|
|
1810
|
-
hits.push(...channelHits(policyRules, canonicalDir));
|
|
1811
3661
|
const policyResult = policy.test(canonicalDir);
|
|
1812
|
-
if (policyResult.ignored) return
|
|
3662
|
+
if (policyResult.ignored) return true;
|
|
1813
3663
|
if (policyResult.unignored) {
|
|
1814
3664
|
if (core.test(canonicalDir).ignored) {
|
|
1815
3665
|
core.add(`!/${canonicalDir}`);
|
|
1816
3666
|
}
|
|
1817
3667
|
} else if (core.test(canonicalDir).ignored) {
|
|
1818
|
-
return
|
|
3668
|
+
return true;
|
|
1819
3669
|
}
|
|
1820
|
-
if (excludeDotEntries
|
|
1821
|
-
|
|
1822
|
-
|
|
3670
|
+
if (excludeDotEntries) {
|
|
3671
|
+
const byName = name.startsWith(".");
|
|
3672
|
+
const byAttribute = !byName && meta?.hidden === true;
|
|
3673
|
+
if (byName || byAttribute) {
|
|
3674
|
+
if (hits !== void 0) hits.push({ source: "dot", via: byName ? "name" : "attribute" });
|
|
3675
|
+
return true;
|
|
3676
|
+
}
|
|
1823
3677
|
}
|
|
1824
|
-
return
|
|
3678
|
+
return false;
|
|
1825
3679
|
};
|
|
1826
|
-
const
|
|
3680
|
+
const runFileVerdict = (relPath, meta, hits) => {
|
|
1827
3681
|
const canonical = toCanonical(relPath);
|
|
1828
|
-
|
|
1829
|
-
|
|
1830
|
-
if (strictIg.test(canonical).ignored) return { admitted: false, hits };
|
|
3682
|
+
if (hits !== void 0) hits.push(...channelHits(strictRules, canonical));
|
|
3683
|
+
if (strictIg.test(canonical).ignored) return false;
|
|
1831
3684
|
if (overrideIg.test(canonical).ignored) {
|
|
1832
|
-
hits.push(...channelHits(overrideRules, canonical));
|
|
1833
|
-
return
|
|
3685
|
+
if (hits !== void 0) hits.push(...channelHits(overrideRules, canonical));
|
|
3686
|
+
return true;
|
|
1834
3687
|
}
|
|
1835
|
-
hits
|
|
1836
|
-
|
|
1837
|
-
|
|
1838
|
-
|
|
1839
|
-
|
|
1840
|
-
|
|
3688
|
+
if (hits !== void 0) {
|
|
3689
|
+
hits.push(...channelHits(coreRules, canonical));
|
|
3690
|
+
hits.push(...channelHits(policyRules, canonical));
|
|
3691
|
+
}
|
|
3692
|
+
if (combinedExcludes(canonical)) return false;
|
|
3693
|
+
if (excludeDotEntries) {
|
|
3694
|
+
const byName = baseNamePosix(relPath).startsWith(".");
|
|
3695
|
+
const byAttribute = !byName && meta?.hidden === true;
|
|
3696
|
+
if (byName || byAttribute) {
|
|
3697
|
+
if (hits !== void 0) hits.push({ source: "dot", via: byName ? "name" : "attribute" });
|
|
3698
|
+
return false;
|
|
3699
|
+
}
|
|
3700
|
+
}
|
|
3701
|
+
return true;
|
|
3702
|
+
};
|
|
3703
|
+
const adjudicateDirectoryImpl = (name, dirPath, stoneHit, meta) => {
|
|
3704
|
+
const hits = [];
|
|
3705
|
+
const excluded = runDirectoryVerdict(name, dirPath, stoneHit, meta, hits);
|
|
3706
|
+
return { excluded, hits };
|
|
3707
|
+
};
|
|
3708
|
+
const adjudicateFileImpl = (relPath, meta) => {
|
|
3709
|
+
const hits = [];
|
|
3710
|
+
const admitted = runFileVerdict(relPath, meta, hits);
|
|
3711
|
+
return { admitted, hits };
|
|
3712
|
+
};
|
|
3713
|
+
const foldLayer = (dirPath, text, source, ignoreFile) => {
|
|
3714
|
+
if (text == null || (source === "gitignore" ? !respectGitignore : !respectIgnoreFamily)) return;
|
|
3715
|
+
const key = dirPath.replace(/\/+$/, "");
|
|
3716
|
+
if (key === rootKey) return;
|
|
3717
|
+
const relDir = key.slice(rootKey.length + 1);
|
|
3718
|
+
const rules = ignoreFileRules(splitLines(text), relDir, joinPosix(offRel, relDir), source, ignoreFile);
|
|
3719
|
+
if (rules.length > 0) {
|
|
3720
|
+
core.add(rules.map((r) => r.mounted));
|
|
3721
|
+
coreRules.push(...rules);
|
|
1841
3722
|
}
|
|
1842
|
-
return { admitted: true, hits };
|
|
1843
3723
|
};
|
|
1844
3724
|
return {
|
|
1845
3725
|
rootKey,
|
|
1846
3726
|
stoneNames,
|
|
1847
|
-
excludeDirectory(name, dirPath, stoneHit) {
|
|
1848
|
-
return
|
|
3727
|
+
excludeDirectory(name, dirPath, stoneHit, meta) {
|
|
3728
|
+
return runDirectoryVerdict(name, dirPath, stoneHit, meta, void 0);
|
|
1849
3729
|
},
|
|
1850
3730
|
foldGitignore(dirPath, text) {
|
|
1851
|
-
|
|
1852
|
-
const key = dirPath.replace(/\/+$/, "");
|
|
1853
|
-
if (key === rootKey) return;
|
|
1854
|
-
const relDir = key.slice(rootKey.length + 1);
|
|
1855
|
-
const rules = gitignoreRules(splitLines(text), relDir, joinPosix(offRel, relDir));
|
|
1856
|
-
if (rules.length > 0) {
|
|
1857
|
-
core.add(rules.map((r) => r.mounted));
|
|
1858
|
-
coreRules.push(...rules);
|
|
1859
|
-
}
|
|
3731
|
+
foldLayer(dirPath, text, "gitignore");
|
|
1860
3732
|
},
|
|
1861
|
-
|
|
1862
|
-
|
|
3733
|
+
foldIgnoreFamily(dirPath, texts) {
|
|
3734
|
+
foldLayer(dirPath, texts.ignore ?? null, "ignore", ".ignore");
|
|
3735
|
+
foldLayer(dirPath, texts.rgignore ?? null, "ignore", ".rgignore");
|
|
1863
3736
|
},
|
|
1864
|
-
|
|
1865
|
-
return
|
|
3737
|
+
admitFile(relPath, meta) {
|
|
3738
|
+
return runFileVerdict(relPath, meta, void 0);
|
|
1866
3739
|
},
|
|
1867
|
-
|
|
1868
|
-
return
|
|
3740
|
+
adjudicateDirectory(name, dirPath, stoneHit, meta) {
|
|
3741
|
+
return adjudicateDirectoryImpl(name, dirPath, stoneHit, meta);
|
|
3742
|
+
},
|
|
3743
|
+
adjudicateFile(relPath, meta) {
|
|
3744
|
+
return adjudicateFileImpl(relPath, meta);
|
|
1869
3745
|
},
|
|
1870
3746
|
attributeStones(relDir, stoneHit) {
|
|
1871
3747
|
if (relDir === "") return [];
|
|
@@ -1879,12 +3755,134 @@ async function createExclusionEngine(rootKey, options = {}, io = nodeExclusionIO
|
|
|
1879
3755
|
};
|
|
1880
3756
|
}
|
|
1881
3757
|
|
|
3758
|
+
// src/walk-links.ts
|
|
3759
|
+
var import_node_fs3 = require("node:fs");
|
|
3760
|
+
var nativeFs = __toESM(require("node:fs"), 1);
|
|
3761
|
+
function createLinkRecorder(base = nativeFs) {
|
|
3762
|
+
const recorded = /* @__PURE__ */ new Set();
|
|
3763
|
+
let rootForm = null;
|
|
3764
|
+
const observe = (crawlPath, entries) => {
|
|
3765
|
+
if (rootForm === null) rootForm = crawlPath;
|
|
3766
|
+
const out = [];
|
|
3767
|
+
for (const entry of entries) {
|
|
3768
|
+
let observed = entry;
|
|
3769
|
+
if (entry.isSymbolicLink()) {
|
|
3770
|
+
recorded.add(crawlPath.slice(rootForm.length) + entry.name);
|
|
3771
|
+
} else if (!entry.isFile() && !entry.isDirectory()) {
|
|
3772
|
+
observed = rescueUnknownType(crawlPath + entry.name, entry);
|
|
3773
|
+
if (observed !== entry && observed.isSymbolicLink()) {
|
|
3774
|
+
recorded.add(crawlPath.slice(rootForm.length) + entry.name);
|
|
3775
|
+
}
|
|
3776
|
+
}
|
|
3777
|
+
out.push(observed);
|
|
3778
|
+
}
|
|
3779
|
+
return out;
|
|
3780
|
+
};
|
|
3781
|
+
const readdir = ((crawlPath, opts, cb) => {
|
|
3782
|
+
base.readdir(crawlPath, opts, (err, entries) => {
|
|
3783
|
+
if (err) return cb(err);
|
|
3784
|
+
cb(null, observe(crawlPath, entries));
|
|
3785
|
+
});
|
|
3786
|
+
});
|
|
3787
|
+
const readdirSync = ((crawlPath, opts) => observe(crawlPath, base.readdirSync(crawlPath, opts)));
|
|
3788
|
+
return {
|
|
3789
|
+
fs: {
|
|
3790
|
+
readdir,
|
|
3791
|
+
readdirSync,
|
|
3792
|
+
realpath: base.realpath,
|
|
3793
|
+
realpathSync: base.realpathSync,
|
|
3794
|
+
stat: base.stat,
|
|
3795
|
+
statSync: base.statSync
|
|
3796
|
+
},
|
|
3797
|
+
links: recorded,
|
|
3798
|
+
observeDirents: observe
|
|
3799
|
+
};
|
|
3800
|
+
}
|
|
3801
|
+
function rescueUnknownType(walkPath, entry) {
|
|
3802
|
+
let stats;
|
|
3803
|
+
try {
|
|
3804
|
+
stats = (0, import_node_fs3.lstatSync)(walkPath);
|
|
3805
|
+
} catch {
|
|
3806
|
+
return entry;
|
|
3807
|
+
}
|
|
3808
|
+
if (stats.isSymbolicLink()) return direntFacade(entry.name, false, false, true);
|
|
3809
|
+
if (stats.isFile()) return direntFacade(entry.name, true, false, false);
|
|
3810
|
+
if (stats.isDirectory()) return direntFacade(entry.name, false, true, false);
|
|
3811
|
+
return entry;
|
|
3812
|
+
}
|
|
3813
|
+
function direntFacade(name, file, dir, link) {
|
|
3814
|
+
return { name, isFile: () => file, isDirectory: () => dir, isSymbolicLink: () => link };
|
|
3815
|
+
}
|
|
3816
|
+
function selectLinks(files, recorded) {
|
|
3817
|
+
return files.filter((rel) => recorded.has(rel));
|
|
3818
|
+
}
|
|
3819
|
+
|
|
3820
|
+
// src/walk-hidden.ts
|
|
3821
|
+
var nativeFs2 = __toESM(require("node:fs"), 1);
|
|
3822
|
+
var ATTR_HIDDEN = 2;
|
|
3823
|
+
var ATTR_DIRECTORY = 16;
|
|
3824
|
+
var ATTR_REPARSE_POINT = 1024;
|
|
3825
|
+
function createHiddenStashFs(winAttr) {
|
|
3826
|
+
const hiddenByDir = /* @__PURE__ */ new Map();
|
|
3827
|
+
const dirKeyOf = (crawlPath) => crawlPath.replace(/\/+$/, "");
|
|
3828
|
+
const facade = (name, attrs) => {
|
|
3829
|
+
const isLink = (attrs & ATTR_REPARSE_POINT) !== 0;
|
|
3830
|
+
const isDir = !isLink && (attrs & ATTR_DIRECTORY) !== 0;
|
|
3831
|
+
return {
|
|
3832
|
+
name,
|
|
3833
|
+
isFile: () => !isDir && !isLink,
|
|
3834
|
+
isDirectory: () => isDir,
|
|
3835
|
+
isSymbolicLink: () => isLink
|
|
3836
|
+
};
|
|
3837
|
+
};
|
|
3838
|
+
const observe = (crawlPath, names, attrs) => {
|
|
3839
|
+
const key = dirKeyOf(crawlPath);
|
|
3840
|
+
const out = [];
|
|
3841
|
+
for (let i = 0; i < names.length; i++) {
|
|
3842
|
+
if ((attrs[i] & ATTR_HIDDEN) !== 0) {
|
|
3843
|
+
let set = hiddenByDir.get(key);
|
|
3844
|
+
if (set === void 0) {
|
|
3845
|
+
set = /* @__PURE__ */ new Set();
|
|
3846
|
+
hiddenByDir.set(key, set);
|
|
3847
|
+
}
|
|
3848
|
+
set.add(names[i]);
|
|
3849
|
+
}
|
|
3850
|
+
out.push(facade(names[i], attrs[i]));
|
|
3851
|
+
}
|
|
3852
|
+
return out;
|
|
3853
|
+
};
|
|
3854
|
+
const readdir = ((crawlPath, opts, cb) => {
|
|
3855
|
+
winAttr.readdirWithAttrs(crawlPath, (err, names, attrs) => {
|
|
3856
|
+
if (err !== null) {
|
|
3857
|
+
cb(err);
|
|
3858
|
+
return;
|
|
3859
|
+
}
|
|
3860
|
+
cb(null, observe(crawlPath, names ?? [], attrs ?? []));
|
|
3861
|
+
});
|
|
3862
|
+
});
|
|
3863
|
+
const readdirSync = ((crawlPath, opts) => {
|
|
3864
|
+
const { names, attrs } = winAttr.readdirWithAttrsSync(crawlPath);
|
|
3865
|
+
return observe(crawlPath, names, attrs);
|
|
3866
|
+
});
|
|
3867
|
+
return {
|
|
3868
|
+
fs: {
|
|
3869
|
+
readdir,
|
|
3870
|
+
readdirSync,
|
|
3871
|
+
realpath: nativeFs2.realpath,
|
|
3872
|
+
realpathSync: nativeFs2.realpathSync,
|
|
3873
|
+
stat: nativeFs2.stat,
|
|
3874
|
+
statSync: nativeFs2.statSync
|
|
3875
|
+
},
|
|
3876
|
+
hiddenFor: (dirKey, name) => hiddenByDir.get(dirKey)?.has(name) === true ? true : void 0
|
|
3877
|
+
};
|
|
3878
|
+
}
|
|
3879
|
+
|
|
1882
3880
|
// src/engine.ts
|
|
1883
3881
|
var DEFAULT_MAX_FILES = 2e3;
|
|
1884
3882
|
async function walkScope(root, options = {}) {
|
|
1885
3883
|
validateOptions(options);
|
|
1886
3884
|
const rootNative = (0, import_node_path2.resolve)(root);
|
|
1887
|
-
if (!(0,
|
|
3885
|
+
if (!(0, import_node_fs4.existsSync)(rootNative)) {
|
|
1888
3886
|
throw new PathscopeConfigError(`scan root does not exist: ${rootNative}`);
|
|
1889
3887
|
}
|
|
1890
3888
|
const scanKey = rootNative.replace(/\\/g, "/");
|
|
@@ -1892,24 +3890,49 @@ async function walkScope(root, options = {}) {
|
|
|
1892
3890
|
const stoneHits = (key) => {
|
|
1893
3891
|
const hits = [];
|
|
1894
3892
|
for (const name of engine.stoneNames) {
|
|
1895
|
-
if ((0,
|
|
3893
|
+
if ((0, import_node_fs4.existsSync)((0, import_node_path2.join)(key, ...name.split("/")))) hits.push(name);
|
|
1896
3894
|
}
|
|
1897
3895
|
return hits;
|
|
1898
3896
|
};
|
|
1899
3897
|
const diagnostics = [];
|
|
3898
|
+
const winAttr = options.excludeDotEntries === false ? null : loadWinAttr();
|
|
3899
|
+
const respectIgnoreFamily = options.respectIgnoreFamily !== false;
|
|
3900
|
+
const attrStash = winAttr === null ? null : createHiddenStashFs(winAttr);
|
|
3901
|
+
const degraded = hiddenFaceDiagnostic(options.excludeDotEntries !== false, attrStash !== null, import_node_process2.platform === "win32");
|
|
3902
|
+
if (degraded !== null) diagnostics.push(degraded);
|
|
3903
|
+
const stoneReport = [];
|
|
1900
3904
|
const controller = new AbortController();
|
|
1901
3905
|
const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
|
|
1902
3906
|
let included = 0;
|
|
1903
3907
|
let budgetCut = false;
|
|
1904
3908
|
const excludeDirectory = (dirName, dirPath) => {
|
|
1905
3909
|
const key = dirPath.replace(/\/+$/, "");
|
|
1906
|
-
|
|
3910
|
+
const hits = stoneHits(key);
|
|
3911
|
+
if (key !== scanKey && hits.length > 0) {
|
|
3912
|
+
const relDir = key.slice(scanKey.length + 1);
|
|
3913
|
+
for (const hit of engine.attributeStones(relDir, hits)) {
|
|
3914
|
+
if (hit.stoneName !== void 0) {
|
|
3915
|
+
stoneReport.push({ stoneName: hit.stoneName, path: relDir, enforced: hit.enforced === true });
|
|
3916
|
+
}
|
|
3917
|
+
}
|
|
3918
|
+
}
|
|
3919
|
+
const meta = attrStash !== null && !dirName.startsWith(".") && attrStash.hiddenFor(key.slice(0, key.lastIndexOf("/")), dirName) === true ? { hidden: true } : void 0;
|
|
3920
|
+
if (engine.excludeDirectory(dirName, key, hits, meta)) return true;
|
|
1907
3921
|
engine.foldGitignore(key, readGitignoreText(key));
|
|
3922
|
+
if (respectIgnoreFamily) {
|
|
3923
|
+
engine.foldIgnoreFamily(key, {
|
|
3924
|
+
ignore: readIgnoreFileText(key, ".ignore"),
|
|
3925
|
+
rgignore: readIgnoreFileText(key, ".rgignore")
|
|
3926
|
+
});
|
|
3927
|
+
}
|
|
1908
3928
|
return false;
|
|
1909
3929
|
};
|
|
1910
3930
|
const keepFile = (rel) => {
|
|
1911
3931
|
if (budgetCut) return false;
|
|
1912
|
-
|
|
3932
|
+
const slash = rel.lastIndexOf("/");
|
|
3933
|
+
const name = slash === -1 ? rel : rel.slice(slash + 1);
|
|
3934
|
+
const fileMeta = attrStash !== null && !name.startsWith(".") && attrStash.hiddenFor(slash === -1 ? scanKey : `${scanKey}/${rel.slice(0, slash)}`, name) === true ? { hidden: true } : void 0;
|
|
3935
|
+
if (!engine.admitFile(rel, fileMeta)) return false;
|
|
1913
3936
|
if (included >= maxFiles) {
|
|
1914
3937
|
budgetCut = true;
|
|
1915
3938
|
controller.abort();
|
|
@@ -1923,23 +3946,35 @@ async function walkScope(root, options = {}) {
|
|
|
1923
3946
|
included += 1;
|
|
1924
3947
|
return true;
|
|
1925
3948
|
};
|
|
3949
|
+
const follow = options.followSymlinks === true;
|
|
3950
|
+
const recorder = follow ? null : createLinkRecorder(attrStash?.fs);
|
|
1926
3951
|
const files = await new import_fdir.fdir({
|
|
1927
3952
|
pathSeparator: "/",
|
|
1928
3953
|
exclude: excludeDirectory,
|
|
1929
3954
|
signal: controller.signal,
|
|
1930
|
-
resolveSymlinks:
|
|
3955
|
+
resolveSymlinks: follow,
|
|
1931
3956
|
// Keep descended-through-symlink paths in the scan-root universe instead
|
|
1932
3957
|
// of emitting real (possibly outside-root) paths.
|
|
1933
3958
|
useRealPaths: false,
|
|
1934
3959
|
// Unreadable directories are skipped, ripgrep-style; the loud channel is
|
|
1935
3960
|
// the budget, not per-directory I/O errors.
|
|
1936
|
-
suppressErrors: true
|
|
3961
|
+
suppressErrors: true,
|
|
3962
|
+
fs: recorder?.fs ?? attrStash?.fs
|
|
1937
3963
|
}).withRelativePaths().filter((path3) => keepFile(path3)).crawl(rootNative).withPromise();
|
|
1938
|
-
|
|
3964
|
+
stoneReport.sort(
|
|
3965
|
+
(a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.stoneName < b.stoneName ? -1 : a.stoneName > b.stoneName ? 1 : 0
|
|
3966
|
+
);
|
|
3967
|
+
const sortedFiles = [...files].sort();
|
|
3968
|
+
return {
|
|
3969
|
+
files: sortedFiles,
|
|
3970
|
+
links: recorder ? selectLinks(sortedFiles, recorder.links) : [],
|
|
3971
|
+
diagnostics,
|
|
3972
|
+
stoneHits: stoneReport
|
|
3973
|
+
};
|
|
1939
3974
|
}
|
|
1940
3975
|
|
|
1941
3976
|
// src/explain.ts
|
|
1942
|
-
var
|
|
3977
|
+
var import_node_fs5 = require("node:fs");
|
|
1943
3978
|
var import_node_path3 = require("node:path");
|
|
1944
3979
|
function parseRelPath(relPath) {
|
|
1945
3980
|
if (typeof relPath !== "string") {
|
|
@@ -1969,7 +4004,7 @@ function parseRelPath(relPath) {
|
|
|
1969
4004
|
async function explainScopePath(root, relPath, options = {}) {
|
|
1970
4005
|
const { segments, isDir, isRoot } = parseRelPath(relPath);
|
|
1971
4006
|
const rootNative = (0, import_node_path3.resolve)(root);
|
|
1972
|
-
if (!(0,
|
|
4007
|
+
if (!(0, import_node_fs5.existsSync)(rootNative)) {
|
|
1973
4008
|
throw new PathscopeConfigError(`scan root does not exist: ${rootNative}`);
|
|
1974
4009
|
}
|
|
1975
4010
|
const baseKey = rootNative.replace(/\\/g, "/").replace(/\/+$/, "");
|
|
@@ -2002,9 +4037,11 @@ async function explainScopePath(root, relPath, options = {}) {
|
|
|
2002
4037
|
const relHere = segments.slice(0, i + 1).join("/");
|
|
2003
4038
|
const isLeaf = i === segments.length - 1;
|
|
2004
4039
|
const adjudicateAsDir = isLeaf ? isDir : true;
|
|
4040
|
+
const parentKey = i === 0 ? baseKey : keys[i - 1];
|
|
4041
|
+
const hiddenMeta = io.hidden !== void 0 && !name.startsWith(".") ? { hidden: await io.hidden(parentKey, name) === true } : void 0;
|
|
2005
4042
|
if (adjudicateAsDir) {
|
|
2006
4043
|
const stoneHit = await probeStones(keys[i]);
|
|
2007
|
-
const adj = engine.adjudicateDirectory(name, keys[i], stoneHit);
|
|
4044
|
+
const adj = engine.adjudicateDirectory(name, keys[i], stoneHit, hiddenMeta);
|
|
2008
4045
|
hitChain.push(...withPath(adj.hits, relHere));
|
|
2009
4046
|
if (adj.excluded) {
|
|
2010
4047
|
excluded = true;
|
|
@@ -2013,9 +4050,12 @@ async function explainScopePath(root, relPath, options = {}) {
|
|
|
2013
4050
|
break;
|
|
2014
4051
|
}
|
|
2015
4052
|
engine.foldGitignore(keys[i], await io.readGitignore(keys[i]));
|
|
4053
|
+
if (io.readIgnoreFamily !== void 0 && options.respectIgnoreFamily !== false) {
|
|
4054
|
+
engine.foldIgnoreFamily(keys[i], await io.readIgnoreFamily(keys[i]));
|
|
4055
|
+
}
|
|
2016
4056
|
if (isLeaf) excluded = false;
|
|
2017
4057
|
} else {
|
|
2018
|
-
const adj = engine.adjudicateFile(relHere);
|
|
4058
|
+
const adj = engine.adjudicateFile(relHere, hiddenMeta);
|
|
2019
4059
|
hitChain.push(...withPath(adj.hits, relHere));
|
|
2020
4060
|
excluded = !adj.admitted;
|
|
2021
4061
|
}
|
|
@@ -2188,9 +4228,9 @@ var import_node_path7 = require("node:path");
|
|
|
2188
4228
|
var import_node_path6 = __toESM(require("node:path"), 1);
|
|
2189
4229
|
|
|
2190
4230
|
// node_modules/.pnpm/locate-path@8.0.0/node_modules/locate-path/index.js
|
|
2191
|
-
var
|
|
4231
|
+
var import_node_process3 = __toESM(require("node:process"), 1);
|
|
2192
4232
|
var import_node_path5 = __toESM(require("node:path"), 1);
|
|
2193
|
-
var
|
|
4233
|
+
var import_node_fs6 = __toESM(require("node:fs"), 1);
|
|
2194
4234
|
var import_node_url = require("node:url");
|
|
2195
4235
|
var typeMappings = {
|
|
2196
4236
|
directory: "isDirectory",
|
|
@@ -2202,25 +4242,25 @@ function checkType(type) {
|
|
|
2202
4242
|
}
|
|
2203
4243
|
throw new Error(`Invalid type specified: ${type}`);
|
|
2204
4244
|
}
|
|
2205
|
-
var matchType = (type,
|
|
4245
|
+
var matchType = (type, stat2) => type === "both" ? stat2.isFile() || stat2.isDirectory() : stat2[typeMappings[type]]();
|
|
2206
4246
|
var toPath = (urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath;
|
|
2207
4247
|
function locatePathSync(paths, {
|
|
2208
|
-
cwd =
|
|
4248
|
+
cwd = import_node_process3.default.cwd(),
|
|
2209
4249
|
type = "file",
|
|
2210
4250
|
allowSymlinks = true
|
|
2211
4251
|
} = {}) {
|
|
2212
4252
|
checkType(type);
|
|
2213
4253
|
cwd = toPath(cwd);
|
|
2214
|
-
const statFunction = allowSymlinks ?
|
|
4254
|
+
const statFunction = allowSymlinks ? import_node_fs6.default.statSync : import_node_fs6.default.lstatSync;
|
|
2215
4255
|
for (const path_ of paths) {
|
|
2216
4256
|
try {
|
|
2217
|
-
const
|
|
4257
|
+
const stat2 = statFunction(import_node_path5.default.resolve(cwd, path_), {
|
|
2218
4258
|
throwIfNoEntry: false
|
|
2219
4259
|
});
|
|
2220
|
-
if (!
|
|
4260
|
+
if (!stat2) {
|
|
2221
4261
|
continue;
|
|
2222
4262
|
}
|
|
2223
|
-
if (matchType(type,
|
|
4263
|
+
if (matchType(type, stat2)) {
|
|
2224
4264
|
return path_;
|
|
2225
4265
|
}
|
|
2226
4266
|
} catch {
|