You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4756 lines
165 KiB
4756 lines
165 KiB
var __create = Object.create; |
|
var __defProp = Object.defineProperty; |
|
var __defProps = Object.defineProperties; |
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; |
|
var __getOwnPropDescs = Object.getOwnPropertyDescriptors; |
|
var __getOwnPropNames = Object.getOwnPropertyNames; |
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols; |
|
var __getProtoOf = Object.getPrototypeOf; |
|
var __hasOwnProp = Object.prototype.hasOwnProperty; |
|
var __propIsEnum = Object.prototype.propertyIsEnumerable; |
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; |
|
var __spreadValues = (a, b) => { |
|
for (var prop in b || (b = {})) |
|
if (__hasOwnProp.call(b, prop)) |
|
__defNormalProp(a, prop, b[prop]); |
|
if (__getOwnPropSymbols) |
|
for (var prop of __getOwnPropSymbols(b)) { |
|
if (__propIsEnum.call(b, prop)) |
|
__defNormalProp(a, prop, b[prop]); |
|
} |
|
return a; |
|
}; |
|
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); |
|
var __commonJS = (cb, mod) => function __require() { |
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; |
|
}; |
|
var __export = (target, all) => { |
|
for (var name in all) |
|
__defProp(target, name, { get: all[name], enumerable: true }); |
|
}; |
|
var __copyProps = (to, from, except, desc) => { |
|
if (from && typeof from === "object" || typeof from === "function") { |
|
for (let key of __getOwnPropNames(from)) |
|
if (!__hasOwnProp.call(to, key) && key !== except) |
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
|
} |
|
return to; |
|
}; |
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod)); |
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); |
|
|
|
// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js |
|
var require_constants = __commonJS({ |
|
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"(exports, module2) { |
|
"use strict"; |
|
var path4 = require("path"); |
|
var WIN_SLASH = "\\\\/"; |
|
var WIN_NO_SLASH = `[^${WIN_SLASH}]`; |
|
var DOT_LITERAL = "\\."; |
|
var PLUS_LITERAL = "\\+"; |
|
var QMARK_LITERAL = "\\?"; |
|
var SLASH_LITERAL = "\\/"; |
|
var ONE_CHAR = "(?=.)"; |
|
var QMARK = "[^/]"; |
|
var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`; |
|
var START_ANCHOR = `(?:^|${SLASH_LITERAL})`; |
|
var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`; |
|
var NO_DOT = `(?!${DOT_LITERAL})`; |
|
var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`; |
|
var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`; |
|
var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`; |
|
var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`; |
|
var STAR = `${QMARK}*?`; |
|
var POSIX_CHARS = { |
|
DOT_LITERAL, |
|
PLUS_LITERAL, |
|
QMARK_LITERAL, |
|
SLASH_LITERAL, |
|
ONE_CHAR, |
|
QMARK, |
|
END_ANCHOR, |
|
DOTS_SLASH, |
|
NO_DOT, |
|
NO_DOTS, |
|
NO_DOT_SLASH, |
|
NO_DOTS_SLASH, |
|
QMARK_NO_DOT, |
|
STAR, |
|
START_ANCHOR |
|
}; |
|
var WINDOWS_CHARS = __spreadProps(__spreadValues({}, POSIX_CHARS), { |
|
SLASH_LITERAL: `[${WIN_SLASH}]`, |
|
QMARK: WIN_NO_SLASH, |
|
STAR: `${WIN_NO_SLASH}*?`, |
|
DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, |
|
NO_DOT: `(?!${DOT_LITERAL})`, |
|
NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, |
|
NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, |
|
NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, |
|
QMARK_NO_DOT: `[^.${WIN_SLASH}]`, |
|
START_ANCHOR: `(?:^|[${WIN_SLASH}])`, |
|
END_ANCHOR: `(?:[${WIN_SLASH}]|$)` |
|
}); |
|
var POSIX_REGEX_SOURCE = { |
|
alnum: "a-zA-Z0-9", |
|
alpha: "a-zA-Z", |
|
ascii: "\\x00-\\x7F", |
|
blank: " \\t", |
|
cntrl: "\\x00-\\x1F\\x7F", |
|
digit: "0-9", |
|
graph: "\\x21-\\x7E", |
|
lower: "a-z", |
|
print: "\\x20-\\x7E ", |
|
punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~", |
|
space: " \\t\\r\\n\\v\\f", |
|
upper: "A-Z", |
|
word: "A-Za-z0-9_", |
|
xdigit: "A-Fa-f0-9" |
|
}; |
|
module2.exports = { |
|
MAX_LENGTH: 1024 * 64, |
|
POSIX_REGEX_SOURCE, |
|
REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, |
|
REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/, |
|
REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, |
|
REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, |
|
REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, |
|
REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, |
|
REPLACEMENTS: { |
|
"***": "*", |
|
"**/**": "**", |
|
"**/**/**": "**" |
|
}, |
|
CHAR_0: 48, |
|
CHAR_9: 57, |
|
CHAR_UPPERCASE_A: 65, |
|
CHAR_LOWERCASE_A: 97, |
|
CHAR_UPPERCASE_Z: 90, |
|
CHAR_LOWERCASE_Z: 122, |
|
CHAR_LEFT_PARENTHESES: 40, |
|
CHAR_RIGHT_PARENTHESES: 41, |
|
CHAR_ASTERISK: 42, |
|
CHAR_AMPERSAND: 38, |
|
CHAR_AT: 64, |
|
CHAR_BACKWARD_SLASH: 92, |
|
CHAR_CARRIAGE_RETURN: 13, |
|
CHAR_CIRCUMFLEX_ACCENT: 94, |
|
CHAR_COLON: 58, |
|
CHAR_COMMA: 44, |
|
CHAR_DOT: 46, |
|
CHAR_DOUBLE_QUOTE: 34, |
|
CHAR_EQUAL: 61, |
|
CHAR_EXCLAMATION_MARK: 33, |
|
CHAR_FORM_FEED: 12, |
|
CHAR_FORWARD_SLASH: 47, |
|
CHAR_GRAVE_ACCENT: 96, |
|
CHAR_HASH: 35, |
|
CHAR_HYPHEN_MINUS: 45, |
|
CHAR_LEFT_ANGLE_BRACKET: 60, |
|
CHAR_LEFT_CURLY_BRACE: 123, |
|
CHAR_LEFT_SQUARE_BRACKET: 91, |
|
CHAR_LINE_FEED: 10, |
|
CHAR_NO_BREAK_SPACE: 160, |
|
CHAR_PERCENT: 37, |
|
CHAR_PLUS: 43, |
|
CHAR_QUESTION_MARK: 63, |
|
CHAR_RIGHT_ANGLE_BRACKET: 62, |
|
CHAR_RIGHT_CURLY_BRACE: 125, |
|
CHAR_RIGHT_SQUARE_BRACKET: 93, |
|
CHAR_SEMICOLON: 59, |
|
CHAR_SINGLE_QUOTE: 39, |
|
CHAR_SPACE: 32, |
|
CHAR_TAB: 9, |
|
CHAR_UNDERSCORE: 95, |
|
CHAR_VERTICAL_LINE: 124, |
|
CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, |
|
SEP: path4.sep, |
|
extglobChars(chars) { |
|
return { |
|
"!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` }, |
|
"?": { type: "qmark", open: "(?:", close: ")?" }, |
|
"+": { type: "plus", open: "(?:", close: ")+" }, |
|
"*": { type: "star", open: "(?:", close: ")*" }, |
|
"@": { type: "at", open: "(?:", close: ")" } |
|
}; |
|
}, |
|
globChars(win322) { |
|
return win322 === true ? WINDOWS_CHARS : POSIX_CHARS; |
|
} |
|
}; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js |
|
var require_utils = __commonJS({ |
|
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"(exports) { |
|
"use strict"; |
|
var path4 = require("path"); |
|
var win322 = process.platform === "win32"; |
|
var { |
|
REGEX_BACKSLASH, |
|
REGEX_REMOVE_BACKSLASH, |
|
REGEX_SPECIAL_CHARS, |
|
REGEX_SPECIAL_CHARS_GLOBAL |
|
} = require_constants(); |
|
exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val); |
|
exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str); |
|
exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str); |
|
exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1"); |
|
exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/"); |
|
exports.removeBackslashes = (str) => { |
|
return str.replace(REGEX_REMOVE_BACKSLASH, (match) => { |
|
return match === "\\" ? "" : match; |
|
}); |
|
}; |
|
exports.supportsLookbehinds = () => { |
|
const segs = process.version.slice(1).split(".").map(Number); |
|
if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) { |
|
return true; |
|
} |
|
return false; |
|
}; |
|
exports.isWindows = (options) => { |
|
if (options && typeof options.windows === "boolean") { |
|
return options.windows; |
|
} |
|
return win322 === true || path4.sep === "\\"; |
|
}; |
|
exports.escapeLast = (input, char, lastIdx) => { |
|
const idx = input.lastIndexOf(char, lastIdx); |
|
if (idx === -1) |
|
return input; |
|
if (input[idx - 1] === "\\") |
|
return exports.escapeLast(input, char, idx - 1); |
|
return `${input.slice(0, idx)}\\${input.slice(idx)}`; |
|
}; |
|
exports.removePrefix = (input, state = {}) => { |
|
let output = input; |
|
if (output.startsWith("./")) { |
|
output = output.slice(2); |
|
state.prefix = "./"; |
|
} |
|
return output; |
|
}; |
|
exports.wrapOutput = (input, state = {}, options = {}) => { |
|
const prepend = options.contains ? "" : "^"; |
|
const append = options.contains ? "" : "$"; |
|
let output = `${prepend}(?:${input})${append}`; |
|
if (state.negated === true) { |
|
output = `(?:^(?!${output}).*$)`; |
|
} |
|
return output; |
|
}; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js |
|
var require_scan = __commonJS({ |
|
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js"(exports, module2) { |
|
"use strict"; |
|
var utils = require_utils(); |
|
var { |
|
CHAR_ASTERISK, |
|
CHAR_AT, |
|
CHAR_BACKWARD_SLASH, |
|
CHAR_COMMA, |
|
CHAR_DOT, |
|
CHAR_EXCLAMATION_MARK, |
|
CHAR_FORWARD_SLASH, |
|
CHAR_LEFT_CURLY_BRACE, |
|
CHAR_LEFT_PARENTHESES, |
|
CHAR_LEFT_SQUARE_BRACKET, |
|
CHAR_PLUS, |
|
CHAR_QUESTION_MARK, |
|
CHAR_RIGHT_CURLY_BRACE, |
|
CHAR_RIGHT_PARENTHESES, |
|
CHAR_RIGHT_SQUARE_BRACKET |
|
} = require_constants(); |
|
var isPathSeparator = (code) => { |
|
return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; |
|
}; |
|
var depth = (token) => { |
|
if (token.isPrefix !== true) { |
|
token.depth = token.isGlobstar ? Infinity : 1; |
|
} |
|
}; |
|
var scan = (input, options) => { |
|
const opts = options || {}; |
|
const length = input.length - 1; |
|
const scanToEnd = opts.parts === true || opts.scanToEnd === true; |
|
const slashes = []; |
|
const tokens = []; |
|
const parts = []; |
|
let str = input; |
|
let index = -1; |
|
let start = 0; |
|
let lastIndex = 0; |
|
let isBrace = false; |
|
let isBracket = false; |
|
let isGlob = false; |
|
let isExtglob = false; |
|
let isGlobstar = false; |
|
let braceEscaped = false; |
|
let backslashes = false; |
|
let negated = false; |
|
let negatedExtglob = false; |
|
let finished = false; |
|
let braces = 0; |
|
let prev; |
|
let code; |
|
let token = { value: "", depth: 0, isGlob: false }; |
|
const eos = () => index >= length; |
|
const peek = () => str.charCodeAt(index + 1); |
|
const advance = () => { |
|
prev = code; |
|
return str.charCodeAt(++index); |
|
}; |
|
while (index < length) { |
|
code = advance(); |
|
let next; |
|
if (code === CHAR_BACKWARD_SLASH) { |
|
backslashes = token.backslashes = true; |
|
code = advance(); |
|
if (code === CHAR_LEFT_CURLY_BRACE) { |
|
braceEscaped = true; |
|
} |
|
continue; |
|
} |
|
if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) { |
|
braces++; |
|
while (eos() !== true && (code = advance())) { |
|
if (code === CHAR_BACKWARD_SLASH) { |
|
backslashes = token.backslashes = true; |
|
advance(); |
|
continue; |
|
} |
|
if (code === CHAR_LEFT_CURLY_BRACE) { |
|
braces++; |
|
continue; |
|
} |
|
if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) { |
|
isBrace = token.isBrace = true; |
|
isGlob = token.isGlob = true; |
|
finished = true; |
|
if (scanToEnd === true) { |
|
continue; |
|
} |
|
break; |
|
} |
|
if (braceEscaped !== true && code === CHAR_COMMA) { |
|
isBrace = token.isBrace = true; |
|
isGlob = token.isGlob = true; |
|
finished = true; |
|
if (scanToEnd === true) { |
|
continue; |
|
} |
|
break; |
|
} |
|
if (code === CHAR_RIGHT_CURLY_BRACE) { |
|
braces--; |
|
if (braces === 0) { |
|
braceEscaped = false; |
|
isBrace = token.isBrace = true; |
|
finished = true; |
|
break; |
|
} |
|
} |
|
} |
|
if (scanToEnd === true) { |
|
continue; |
|
} |
|
break; |
|
} |
|
if (code === CHAR_FORWARD_SLASH) { |
|
slashes.push(index); |
|
tokens.push(token); |
|
token = { value: "", depth: 0, isGlob: false }; |
|
if (finished === true) |
|
continue; |
|
if (prev === CHAR_DOT && index === start + 1) { |
|
start += 2; |
|
continue; |
|
} |
|
lastIndex = index + 1; |
|
continue; |
|
} |
|
if (opts.noext !== true) { |
|
const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK; |
|
if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) { |
|
isGlob = token.isGlob = true; |
|
isExtglob = token.isExtglob = true; |
|
finished = true; |
|
if (code === CHAR_EXCLAMATION_MARK && index === start) { |
|
negatedExtglob = true; |
|
} |
|
if (scanToEnd === true) { |
|
while (eos() !== true && (code = advance())) { |
|
if (code === CHAR_BACKWARD_SLASH) { |
|
backslashes = token.backslashes = true; |
|
code = advance(); |
|
continue; |
|
} |
|
if (code === CHAR_RIGHT_PARENTHESES) { |
|
isGlob = token.isGlob = true; |
|
finished = true; |
|
break; |
|
} |
|
} |
|
continue; |
|
} |
|
break; |
|
} |
|
} |
|
if (code === CHAR_ASTERISK) { |
|
if (prev === CHAR_ASTERISK) |
|
isGlobstar = token.isGlobstar = true; |
|
isGlob = token.isGlob = true; |
|
finished = true; |
|
if (scanToEnd === true) { |
|
continue; |
|
} |
|
break; |
|
} |
|
if (code === CHAR_QUESTION_MARK) { |
|
isGlob = token.isGlob = true; |
|
finished = true; |
|
if (scanToEnd === true) { |
|
continue; |
|
} |
|
break; |
|
} |
|
if (code === CHAR_LEFT_SQUARE_BRACKET) { |
|
while (eos() !== true && (next = advance())) { |
|
if (next === CHAR_BACKWARD_SLASH) { |
|
backslashes = token.backslashes = true; |
|
advance(); |
|
continue; |
|
} |
|
if (next === CHAR_RIGHT_SQUARE_BRACKET) { |
|
isBracket = token.isBracket = true; |
|
isGlob = token.isGlob = true; |
|
finished = true; |
|
break; |
|
} |
|
} |
|
if (scanToEnd === true) { |
|
continue; |
|
} |
|
break; |
|
} |
|
if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) { |
|
negated = token.negated = true; |
|
start++; |
|
continue; |
|
} |
|
if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) { |
|
isGlob = token.isGlob = true; |
|
if (scanToEnd === true) { |
|
while (eos() !== true && (code = advance())) { |
|
if (code === CHAR_LEFT_PARENTHESES) { |
|
backslashes = token.backslashes = true; |
|
code = advance(); |
|
continue; |
|
} |
|
if (code === CHAR_RIGHT_PARENTHESES) { |
|
finished = true; |
|
break; |
|
} |
|
} |
|
continue; |
|
} |
|
break; |
|
} |
|
if (isGlob === true) { |
|
finished = true; |
|
if (scanToEnd === true) { |
|
continue; |
|
} |
|
break; |
|
} |
|
} |
|
if (opts.noext === true) { |
|
isExtglob = false; |
|
isGlob = false; |
|
} |
|
let base = str; |
|
let prefix = ""; |
|
let glob = ""; |
|
if (start > 0) { |
|
prefix = str.slice(0, start); |
|
str = str.slice(start); |
|
lastIndex -= start; |
|
} |
|
if (base && isGlob === true && lastIndex > 0) { |
|
base = str.slice(0, lastIndex); |
|
glob = str.slice(lastIndex); |
|
} else if (isGlob === true) { |
|
base = ""; |
|
glob = str; |
|
} else { |
|
base = str; |
|
} |
|
if (base && base !== "" && base !== "/" && base !== str) { |
|
if (isPathSeparator(base.charCodeAt(base.length - 1))) { |
|
base = base.slice(0, -1); |
|
} |
|
} |
|
if (opts.unescape === true) { |
|
if (glob) |
|
glob = utils.removeBackslashes(glob); |
|
if (base && backslashes === true) { |
|
base = utils.removeBackslashes(base); |
|
} |
|
} |
|
const state = { |
|
prefix, |
|
input, |
|
start, |
|
base, |
|
glob, |
|
isBrace, |
|
isBracket, |
|
isGlob, |
|
isExtglob, |
|
isGlobstar, |
|
negated, |
|
negatedExtglob |
|
}; |
|
if (opts.tokens === true) { |
|
state.maxDepth = 0; |
|
if (!isPathSeparator(code)) { |
|
tokens.push(token); |
|
} |
|
state.tokens = tokens; |
|
} |
|
if (opts.parts === true || opts.tokens === true) { |
|
let prevIndex; |
|
for (let idx = 0; idx < slashes.length; idx++) { |
|
const n = prevIndex ? prevIndex + 1 : start; |
|
const i = slashes[idx]; |
|
const value = input.slice(n, i); |
|
if (opts.tokens) { |
|
if (idx === 0 && start !== 0) { |
|
tokens[idx].isPrefix = true; |
|
tokens[idx].value = prefix; |
|
} else { |
|
tokens[idx].value = value; |
|
} |
|
depth(tokens[idx]); |
|
state.maxDepth += tokens[idx].depth; |
|
} |
|
if (idx !== 0 || value !== "") { |
|
parts.push(value); |
|
} |
|
prevIndex = i; |
|
} |
|
if (prevIndex && prevIndex + 1 < input.length) { |
|
const value = input.slice(prevIndex + 1); |
|
parts.push(value); |
|
if (opts.tokens) { |
|
tokens[tokens.length - 1].value = value; |
|
depth(tokens[tokens.length - 1]); |
|
state.maxDepth += tokens[tokens.length - 1].depth; |
|
} |
|
} |
|
state.slashes = slashes; |
|
state.parts = parts; |
|
} |
|
return state; |
|
}; |
|
module2.exports = scan; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js |
|
var require_parse = __commonJS({ |
|
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js"(exports, module2) { |
|
"use strict"; |
|
var constants = require_constants(); |
|
var utils = require_utils(); |
|
var { |
|
MAX_LENGTH, |
|
POSIX_REGEX_SOURCE, |
|
REGEX_NON_SPECIAL_CHARS, |
|
REGEX_SPECIAL_CHARS_BACKREF, |
|
REPLACEMENTS |
|
} = constants; |
|
var expandRange = (args, options) => { |
|
if (typeof options.expandRange === "function") { |
|
return options.expandRange(...args, options); |
|
} |
|
args.sort(); |
|
const value = `[${args.join("-")}]`; |
|
try { |
|
new RegExp(value); |
|
} catch (ex) { |
|
return args.map((v) => utils.escapeRegex(v)).join(".."); |
|
} |
|
return value; |
|
}; |
|
var syntaxError = (type, char) => { |
|
return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`; |
|
}; |
|
var parse = (input, options) => { |
|
if (typeof input !== "string") { |
|
throw new TypeError("Expected a string"); |
|
} |
|
input = REPLACEMENTS[input] || input; |
|
const opts = __spreadValues({}, options); |
|
const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; |
|
let len = input.length; |
|
if (len > max) { |
|
throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); |
|
} |
|
const bos = { type: "bos", value: "", output: opts.prepend || "" }; |
|
const tokens = [bos]; |
|
const capture = opts.capture ? "" : "?:"; |
|
const win322 = utils.isWindows(options); |
|
const PLATFORM_CHARS = constants.globChars(win322); |
|
const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS); |
|
const { |
|
DOT_LITERAL, |
|
PLUS_LITERAL, |
|
SLASH_LITERAL, |
|
ONE_CHAR, |
|
DOTS_SLASH, |
|
NO_DOT, |
|
NO_DOT_SLASH, |
|
NO_DOTS_SLASH, |
|
QMARK, |
|
QMARK_NO_DOT, |
|
STAR, |
|
START_ANCHOR |
|
} = PLATFORM_CHARS; |
|
const globstar = (opts2) => { |
|
return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; |
|
}; |
|
const nodot = opts.dot ? "" : NO_DOT; |
|
const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT; |
|
let star = opts.bash === true ? globstar(opts) : STAR; |
|
if (opts.capture) { |
|
star = `(${star})`; |
|
} |
|
if (typeof opts.noext === "boolean") { |
|
opts.noextglob = opts.noext; |
|
} |
|
const state = { |
|
input, |
|
index: -1, |
|
start: 0, |
|
dot: opts.dot === true, |
|
consumed: "", |
|
output: "", |
|
prefix: "", |
|
backtrack: false, |
|
negated: false, |
|
brackets: 0, |
|
braces: 0, |
|
parens: 0, |
|
quotes: 0, |
|
globstar: false, |
|
tokens |
|
}; |
|
input = utils.removePrefix(input, state); |
|
len = input.length; |
|
const extglobs = []; |
|
const braces = []; |
|
const stack = []; |
|
let prev = bos; |
|
let value; |
|
const eos = () => state.index === len - 1; |
|
const peek = state.peek = (n = 1) => input[state.index + n]; |
|
const advance = state.advance = () => input[++state.index] || ""; |
|
const remaining = () => input.slice(state.index + 1); |
|
const consume = (value2 = "", num = 0) => { |
|
state.consumed += value2; |
|
state.index += num; |
|
}; |
|
const append = (token) => { |
|
state.output += token.output != null ? token.output : token.value; |
|
consume(token.value); |
|
}; |
|
const negate = () => { |
|
let count = 1; |
|
while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) { |
|
advance(); |
|
state.start++; |
|
count++; |
|
} |
|
if (count % 2 === 0) { |
|
return false; |
|
} |
|
state.negated = true; |
|
state.start++; |
|
return true; |
|
}; |
|
const increment = (type) => { |
|
state[type]++; |
|
stack.push(type); |
|
}; |
|
const decrement = (type) => { |
|
state[type]--; |
|
stack.pop(); |
|
}; |
|
const push = (tok) => { |
|
if (prev.type === "globstar") { |
|
const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace"); |
|
const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren"); |
|
if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) { |
|
state.output = state.output.slice(0, -prev.output.length); |
|
prev.type = "star"; |
|
prev.value = "*"; |
|
prev.output = star; |
|
state.output += prev.output; |
|
} |
|
} |
|
if (extglobs.length && tok.type !== "paren") { |
|
extglobs[extglobs.length - 1].inner += tok.value; |
|
} |
|
if (tok.value || tok.output) |
|
append(tok); |
|
if (prev && prev.type === "text" && tok.type === "text") { |
|
prev.value += tok.value; |
|
prev.output = (prev.output || "") + tok.value; |
|
return; |
|
} |
|
tok.prev = prev; |
|
tokens.push(tok); |
|
prev = tok; |
|
}; |
|
const extglobOpen = (type, value2) => { |
|
const token = __spreadProps(__spreadValues({}, EXTGLOB_CHARS[value2]), { conditions: 1, inner: "" }); |
|
token.prev = prev; |
|
token.parens = state.parens; |
|
token.output = state.output; |
|
const output = (opts.capture ? "(" : "") + token.open; |
|
increment("parens"); |
|
push({ type, value: value2, output: state.output ? "" : ONE_CHAR }); |
|
push({ type: "paren", extglob: true, value: advance(), output }); |
|
extglobs.push(token); |
|
}; |
|
const extglobClose = (token) => { |
|
let output = token.close + (opts.capture ? ")" : ""); |
|
let rest; |
|
if (token.type === "negate") { |
|
let extglobStar = star; |
|
if (token.inner && token.inner.length > 1 && token.inner.includes("/")) { |
|
extglobStar = globstar(opts); |
|
} |
|
if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) { |
|
output = token.close = `)$))${extglobStar}`; |
|
} |
|
if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) { |
|
const expression = parse(rest, __spreadProps(__spreadValues({}, options), { fastpaths: false })).output; |
|
output = token.close = `)${expression})${extglobStar})`; |
|
} |
|
if (token.prev.type === "bos") { |
|
state.negatedExtglob = true; |
|
} |
|
} |
|
push({ type: "paren", extglob: true, value, output }); |
|
decrement("parens"); |
|
}; |
|
if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) { |
|
let backslashes = false; |
|
let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => { |
|
if (first === "\\") { |
|
backslashes = true; |
|
return m; |
|
} |
|
if (first === "?") { |
|
if (esc) { |
|
return esc + first + (rest ? QMARK.repeat(rest.length) : ""); |
|
} |
|
if (index === 0) { |
|
return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : ""); |
|
} |
|
return QMARK.repeat(chars.length); |
|
} |
|
if (first === ".") { |
|
return DOT_LITERAL.repeat(chars.length); |
|
} |
|
if (first === "*") { |
|
if (esc) { |
|
return esc + first + (rest ? star : ""); |
|
} |
|
return star; |
|
} |
|
return esc ? m : `\\${m}`; |
|
}); |
|
if (backslashes === true) { |
|
if (opts.unescape === true) { |
|
output = output.replace(/\\/g, ""); |
|
} else { |
|
output = output.replace(/\\+/g, (m) => { |
|
return m.length % 2 === 0 ? "\\\\" : m ? "\\" : ""; |
|
}); |
|
} |
|
} |
|
if (output === input && opts.contains === true) { |
|
state.output = input; |
|
return state; |
|
} |
|
state.output = utils.wrapOutput(output, state, options); |
|
return state; |
|
} |
|
while (!eos()) { |
|
value = advance(); |
|
if (value === "\0") { |
|
continue; |
|
} |
|
if (value === "\\") { |
|
const next = peek(); |
|
if (next === "/" && opts.bash !== true) { |
|
continue; |
|
} |
|
if (next === "." || next === ";") { |
|
continue; |
|
} |
|
if (!next) { |
|
value += "\\"; |
|
push({ type: "text", value }); |
|
continue; |
|
} |
|
const match = /^\\+/.exec(remaining()); |
|
let slashes = 0; |
|
if (match && match[0].length > 2) { |
|
slashes = match[0].length; |
|
state.index += slashes; |
|
if (slashes % 2 !== 0) { |
|
value += "\\"; |
|
} |
|
} |
|
if (opts.unescape === true) { |
|
value = advance(); |
|
} else { |
|
value += advance(); |
|
} |
|
if (state.brackets === 0) { |
|
push({ type: "text", value }); |
|
continue; |
|
} |
|
} |
|
if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) { |
|
if (opts.posix !== false && value === ":") { |
|
const inner = prev.value.slice(1); |
|
if (inner.includes("[")) { |
|
prev.posix = true; |
|
if (inner.includes(":")) { |
|
const idx = prev.value.lastIndexOf("["); |
|
const pre = prev.value.slice(0, idx); |
|
const rest2 = prev.value.slice(idx + 2); |
|
const posix2 = POSIX_REGEX_SOURCE[rest2]; |
|
if (posix2) { |
|
prev.value = pre + posix2; |
|
state.backtrack = true; |
|
advance(); |
|
if (!bos.output && tokens.indexOf(prev) === 1) { |
|
bos.output = ONE_CHAR; |
|
} |
|
continue; |
|
} |
|
} |
|
} |
|
} |
|
if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") { |
|
value = `\\${value}`; |
|
} |
|
if (value === "]" && (prev.value === "[" || prev.value === "[^")) { |
|
value = `\\${value}`; |
|
} |
|
if (opts.posix === true && value === "!" && prev.value === "[") { |
|
value = "^"; |
|
} |
|
prev.value += value; |
|
append({ value }); |
|
continue; |
|
} |
|
if (state.quotes === 1 && value !== '"') { |
|
value = utils.escapeRegex(value); |
|
prev.value += value; |
|
append({ value }); |
|
continue; |
|
} |
|
if (value === '"') { |
|
state.quotes = state.quotes === 1 ? 0 : 1; |
|
if (opts.keepQuotes === true) { |
|
push({ type: "text", value }); |
|
} |
|
continue; |
|
} |
|
if (value === "(") { |
|
increment("parens"); |
|
push({ type: "paren", value }); |
|
continue; |
|
} |
|
if (value === ")") { |
|
if (state.parens === 0 && opts.strictBrackets === true) { |
|
throw new SyntaxError(syntaxError("opening", "(")); |
|
} |
|
const extglob = extglobs[extglobs.length - 1]; |
|
if (extglob && state.parens === extglob.parens + 1) { |
|
extglobClose(extglobs.pop()); |
|
continue; |
|
} |
|
push({ type: "paren", value, output: state.parens ? ")" : "\\)" }); |
|
decrement("parens"); |
|
continue; |
|
} |
|
if (value === "[") { |
|
if (opts.nobracket === true || !remaining().includes("]")) { |
|
if (opts.nobracket !== true && opts.strictBrackets === true) { |
|
throw new SyntaxError(syntaxError("closing", "]")); |
|
} |
|
value = `\\${value}`; |
|
} else { |
|
increment("brackets"); |
|
} |
|
push({ type: "bracket", value }); |
|
continue; |
|
} |
|
if (value === "]") { |
|
if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) { |
|
push({ type: "text", value, output: `\\${value}` }); |
|
continue; |
|
} |
|
if (state.brackets === 0) { |
|
if (opts.strictBrackets === true) { |
|
throw new SyntaxError(syntaxError("opening", "[")); |
|
} |
|
push({ type: "text", value, output: `\\${value}` }); |
|
continue; |
|
} |
|
decrement("brackets"); |
|
const prevValue = prev.value.slice(1); |
|
if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) { |
|
value = `/${value}`; |
|
} |
|
prev.value += value; |
|
append({ value }); |
|
if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) { |
|
continue; |
|
} |
|
const escaped = utils.escapeRegex(prev.value); |
|
state.output = state.output.slice(0, -prev.value.length); |
|
if (opts.literalBrackets === true) { |
|
state.output += escaped; |
|
prev.value = escaped; |
|
continue; |
|
} |
|
prev.value = `(${capture}${escaped}|${prev.value})`; |
|
state.output += prev.value; |
|
continue; |
|
} |
|
if (value === "{" && opts.nobrace !== true) { |
|
increment("braces"); |
|
const open = { |
|
type: "brace", |
|
value, |
|
output: "(", |
|
outputIndex: state.output.length, |
|
tokensIndex: state.tokens.length |
|
}; |
|
braces.push(open); |
|
push(open); |
|
continue; |
|
} |
|
if (value === "}") { |
|
const brace = braces[braces.length - 1]; |
|
if (opts.nobrace === true || !brace) { |
|
push({ type: "text", value, output: value }); |
|
continue; |
|
} |
|
let output = ")"; |
|
if (brace.dots === true) { |
|
const arr = tokens.slice(); |
|
const range = []; |
|
for (let i = arr.length - 1; i >= 0; i--) { |
|
tokens.pop(); |
|
if (arr[i].type === "brace") { |
|
break; |
|
} |
|
if (arr[i].type !== "dots") { |
|
range.unshift(arr[i].value); |
|
} |
|
} |
|
output = expandRange(range, opts); |
|
state.backtrack = true; |
|
} |
|
if (brace.comma !== true && brace.dots !== true) { |
|
const out = state.output.slice(0, brace.outputIndex); |
|
const toks = state.tokens.slice(brace.tokensIndex); |
|
brace.value = brace.output = "\\{"; |
|
value = output = "\\}"; |
|
state.output = out; |
|
for (const t of toks) { |
|
state.output += t.output || t.value; |
|
} |
|
} |
|
push({ type: "brace", value, output }); |
|
decrement("braces"); |
|
braces.pop(); |
|
continue; |
|
} |
|
if (value === "|") { |
|
if (extglobs.length > 0) { |
|
extglobs[extglobs.length - 1].conditions++; |
|
} |
|
push({ type: "text", value }); |
|
continue; |
|
} |
|
if (value === ",") { |
|
let output = value; |
|
const brace = braces[braces.length - 1]; |
|
if (brace && stack[stack.length - 1] === "braces") { |
|
brace.comma = true; |
|
output = "|"; |
|
} |
|
push({ type: "comma", value, output }); |
|
continue; |
|
} |
|
if (value === "/") { |
|
if (prev.type === "dot" && state.index === state.start + 1) { |
|
state.start = state.index + 1; |
|
state.consumed = ""; |
|
state.output = ""; |
|
tokens.pop(); |
|
prev = bos; |
|
continue; |
|
} |
|
push({ type: "slash", value, output: SLASH_LITERAL }); |
|
continue; |
|
} |
|
if (value === ".") { |
|
if (state.braces > 0 && prev.type === "dot") { |
|
if (prev.value === ".") |
|
prev.output = DOT_LITERAL; |
|
const brace = braces[braces.length - 1]; |
|
prev.type = "dots"; |
|
prev.output += value; |
|
prev.value += value; |
|
brace.dots = true; |
|
continue; |
|
} |
|
if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") { |
|
push({ type: "text", value, output: DOT_LITERAL }); |
|
continue; |
|
} |
|
push({ type: "dot", value, output: DOT_LITERAL }); |
|
continue; |
|
} |
|
if (value === "?") { |
|
const isGroup = prev && prev.value === "("; |
|
if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") { |
|
extglobOpen("qmark", value); |
|
continue; |
|
} |
|
if (prev && prev.type === "paren") { |
|
const next = peek(); |
|
let output = value; |
|
if (next === "<" && !utils.supportsLookbehinds()) { |
|
throw new Error("Node.js v10 or higher is required for regex lookbehinds"); |
|
} |
|
if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) { |
|
output = `\\${value}`; |
|
} |
|
push({ type: "text", value, output }); |
|
continue; |
|
} |
|
if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) { |
|
push({ type: "qmark", value, output: QMARK_NO_DOT }); |
|
continue; |
|
} |
|
push({ type: "qmark", value, output: QMARK }); |
|
continue; |
|
} |
|
if (value === "!") { |
|
if (opts.noextglob !== true && peek() === "(") { |
|
if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) { |
|
extglobOpen("negate", value); |
|
continue; |
|
} |
|
} |
|
if (opts.nonegate !== true && state.index === 0) { |
|
negate(); |
|
continue; |
|
} |
|
} |
|
if (value === "+") { |
|
if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") { |
|
extglobOpen("plus", value); |
|
continue; |
|
} |
|
if (prev && prev.value === "(" || opts.regex === false) { |
|
push({ type: "plus", value, output: PLUS_LITERAL }); |
|
continue; |
|
} |
|
if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) { |
|
push({ type: "plus", value }); |
|
continue; |
|
} |
|
push({ type: "plus", value: PLUS_LITERAL }); |
|
continue; |
|
} |
|
if (value === "@") { |
|
if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") { |
|
push({ type: "at", extglob: true, value, output: "" }); |
|
continue; |
|
} |
|
push({ type: "text", value }); |
|
continue; |
|
} |
|
if (value !== "*") { |
|
if (value === "$" || value === "^") { |
|
value = `\\${value}`; |
|
} |
|
const match = REGEX_NON_SPECIAL_CHARS.exec(remaining()); |
|
if (match) { |
|
value += match[0]; |
|
state.index += match[0].length; |
|
} |
|
push({ type: "text", value }); |
|
continue; |
|
} |
|
if (prev && (prev.type === "globstar" || prev.star === true)) { |
|
prev.type = "star"; |
|
prev.star = true; |
|
prev.value += value; |
|
prev.output = star; |
|
state.backtrack = true; |
|
state.globstar = true; |
|
consume(value); |
|
continue; |
|
} |
|
let rest = remaining(); |
|
if (opts.noextglob !== true && /^\([^?]/.test(rest)) { |
|
extglobOpen("star", value); |
|
continue; |
|
} |
|
if (prev.type === "star") { |
|
if (opts.noglobstar === true) { |
|
consume(value); |
|
continue; |
|
} |
|
const prior = prev.prev; |
|
const before = prior.prev; |
|
const isStart = prior.type === "slash" || prior.type === "bos"; |
|
const afterStar = before && (before.type === "star" || before.type === "globstar"); |
|
if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) { |
|
push({ type: "star", value, output: "" }); |
|
continue; |
|
} |
|
const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace"); |
|
const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren"); |
|
if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) { |
|
push({ type: "star", value, output: "" }); |
|
continue; |
|
} |
|
while (rest.slice(0, 3) === "/**") { |
|
const after = input[state.index + 4]; |
|
if (after && after !== "/") { |
|
break; |
|
} |
|
rest = rest.slice(3); |
|
consume("/**", 3); |
|
} |
|
if (prior.type === "bos" && eos()) { |
|
prev.type = "globstar"; |
|
prev.value += value; |
|
prev.output = globstar(opts); |
|
state.output = prev.output; |
|
state.globstar = true; |
|
consume(value); |
|
continue; |
|
} |
|
if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) { |
|
state.output = state.output.slice(0, -(prior.output + prev.output).length); |
|
prior.output = `(?:${prior.output}`; |
|
prev.type = "globstar"; |
|
prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)"); |
|
prev.value += value; |
|
state.globstar = true; |
|
state.output += prior.output + prev.output; |
|
consume(value); |
|
continue; |
|
} |
|
if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") { |
|
const end = rest[1] !== void 0 ? "|$" : ""; |
|
state.output = state.output.slice(0, -(prior.output + prev.output).length); |
|
prior.output = `(?:${prior.output}`; |
|
prev.type = "globstar"; |
|
prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`; |
|
prev.value += value; |
|
state.output += prior.output + prev.output; |
|
state.globstar = true; |
|
consume(value + advance()); |
|
push({ type: "slash", value: "/", output: "" }); |
|
continue; |
|
} |
|
if (prior.type === "bos" && rest[0] === "/") { |
|
prev.type = "globstar"; |
|
prev.value += value; |
|
prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`; |
|
state.output = prev.output; |
|
state.globstar = true; |
|
consume(value + advance()); |
|
push({ type: "slash", value: "/", output: "" }); |
|
continue; |
|
} |
|
state.output = state.output.slice(0, -prev.output.length); |
|
prev.type = "globstar"; |
|
prev.output = globstar(opts); |
|
prev.value += value; |
|
state.output += prev.output; |
|
state.globstar = true; |
|
consume(value); |
|
continue; |
|
} |
|
const token = { type: "star", value, output: star }; |
|
if (opts.bash === true) { |
|
token.output = ".*?"; |
|
if (prev.type === "bos" || prev.type === "slash") { |
|
token.output = nodot + token.output; |
|
} |
|
push(token); |
|
continue; |
|
} |
|
if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) { |
|
token.output = value; |
|
push(token); |
|
continue; |
|
} |
|
if (state.index === state.start || prev.type === "slash" || prev.type === "dot") { |
|
if (prev.type === "dot") { |
|
state.output += NO_DOT_SLASH; |
|
prev.output += NO_DOT_SLASH; |
|
} else if (opts.dot === true) { |
|
state.output += NO_DOTS_SLASH; |
|
prev.output += NO_DOTS_SLASH; |
|
} else { |
|
state.output += nodot; |
|
prev.output += nodot; |
|
} |
|
if (peek() !== "*") { |
|
state.output += ONE_CHAR; |
|
prev.output += ONE_CHAR; |
|
} |
|
} |
|
push(token); |
|
} |
|
while (state.brackets > 0) { |
|
if (opts.strictBrackets === true) |
|
throw new SyntaxError(syntaxError("closing", "]")); |
|
state.output = utils.escapeLast(state.output, "["); |
|
decrement("brackets"); |
|
} |
|
while (state.parens > 0) { |
|
if (opts.strictBrackets === true) |
|
throw new SyntaxError(syntaxError("closing", ")")); |
|
state.output = utils.escapeLast(state.output, "("); |
|
decrement("parens"); |
|
} |
|
while (state.braces > 0) { |
|
if (opts.strictBrackets === true) |
|
throw new SyntaxError(syntaxError("closing", "}")); |
|
state.output = utils.escapeLast(state.output, "{"); |
|
decrement("braces"); |
|
} |
|
if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) { |
|
push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` }); |
|
} |
|
if (state.backtrack === true) { |
|
state.output = ""; |
|
for (const token of state.tokens) { |
|
state.output += token.output != null ? token.output : token.value; |
|
if (token.suffix) { |
|
state.output += token.suffix; |
|
} |
|
} |
|
} |
|
return state; |
|
}; |
|
parse.fastpaths = (input, options) => { |
|
const opts = __spreadValues({}, options); |
|
const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; |
|
const len = input.length; |
|
if (len > max) { |
|
throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); |
|
} |
|
input = REPLACEMENTS[input] || input; |
|
const win322 = utils.isWindows(options); |
|
const { |
|
DOT_LITERAL, |
|
SLASH_LITERAL, |
|
ONE_CHAR, |
|
DOTS_SLASH, |
|
NO_DOT, |
|
NO_DOTS, |
|
NO_DOTS_SLASH, |
|
STAR, |
|
START_ANCHOR |
|
} = constants.globChars(win322); |
|
const nodot = opts.dot ? NO_DOTS : NO_DOT; |
|
const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT; |
|
const capture = opts.capture ? "" : "?:"; |
|
const state = { negated: false, prefix: "" }; |
|
let star = opts.bash === true ? ".*?" : STAR; |
|
if (opts.capture) { |
|
star = `(${star})`; |
|
} |
|
const globstar = (opts2) => { |
|
if (opts2.noglobstar === true) |
|
return star; |
|
return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; |
|
}; |
|
const create = (str) => { |
|
switch (str) { |
|
case "*": |
|
return `${nodot}${ONE_CHAR}${star}`; |
|
case ".*": |
|
return `${DOT_LITERAL}${ONE_CHAR}${star}`; |
|
case "*.*": |
|
return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; |
|
case "*/*": |
|
return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`; |
|
case "**": |
|
return nodot + globstar(opts); |
|
case "**/*": |
|
return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`; |
|
case "**/*.*": |
|
return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; |
|
case "**/.*": |
|
return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`; |
|
default: { |
|
const match = /^(.*?)\.(\w+)$/.exec(str); |
|
if (!match) |
|
return; |
|
const source2 = create(match[1]); |
|
if (!source2) |
|
return; |
|
return source2 + DOT_LITERAL + match[2]; |
|
} |
|
} |
|
}; |
|
const output = utils.removePrefix(input, state); |
|
let source = create(output); |
|
if (source && opts.strictSlashes !== true) { |
|
source += `${SLASH_LITERAL}?`; |
|
} |
|
return source; |
|
}; |
|
module2.exports = parse; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js |
|
var require_picomatch = __commonJS({ |
|
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js"(exports, module2) { |
|
"use strict"; |
|
var path4 = require("path"); |
|
var scan = require_scan(); |
|
var parse = require_parse(); |
|
var utils = require_utils(); |
|
var constants = require_constants(); |
|
var isObject = (val) => val && typeof val === "object" && !Array.isArray(val); |
|
var picomatch = (glob, options, returnState = false) => { |
|
if (Array.isArray(glob)) { |
|
const fns = glob.map((input) => picomatch(input, options, returnState)); |
|
const arrayMatcher = (str) => { |
|
for (const isMatch of fns) { |
|
const state2 = isMatch(str); |
|
if (state2) |
|
return state2; |
|
} |
|
return false; |
|
}; |
|
return arrayMatcher; |
|
} |
|
const isState = isObject(glob) && glob.tokens && glob.input; |
|
if (glob === "" || typeof glob !== "string" && !isState) { |
|
throw new TypeError("Expected pattern to be a non-empty string"); |
|
} |
|
const opts = options || {}; |
|
const posix2 = utils.isWindows(options); |
|
const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true); |
|
const state = regex.state; |
|
delete regex.state; |
|
let isIgnored = () => false; |
|
if (opts.ignore) { |
|
const ignoreOpts = __spreadProps(__spreadValues({}, options), { ignore: null, onMatch: null, onResult: null }); |
|
isIgnored = picomatch(opts.ignore, ignoreOpts, returnState); |
|
} |
|
const matcher = (input, returnObject = false) => { |
|
const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix: posix2 }); |
|
const result = { glob, state, regex, posix: posix2, input, output, match, isMatch }; |
|
if (typeof opts.onResult === "function") { |
|
opts.onResult(result); |
|
} |
|
if (isMatch === false) { |
|
result.isMatch = false; |
|
return returnObject ? result : false; |
|
} |
|
if (isIgnored(input)) { |
|
if (typeof opts.onIgnore === "function") { |
|
opts.onIgnore(result); |
|
} |
|
result.isMatch = false; |
|
return returnObject ? result : false; |
|
} |
|
if (typeof opts.onMatch === "function") { |
|
opts.onMatch(result); |
|
} |
|
return returnObject ? result : true; |
|
}; |
|
if (returnState) { |
|
matcher.state = state; |
|
} |
|
return matcher; |
|
}; |
|
picomatch.test = (input, regex, options, { glob, posix: posix2 } = {}) => { |
|
if (typeof input !== "string") { |
|
throw new TypeError("Expected input to be a string"); |
|
} |
|
if (input === "") { |
|
return { isMatch: false, output: "" }; |
|
} |
|
const opts = options || {}; |
|
const format = opts.format || (posix2 ? utils.toPosixSlashes : null); |
|
let match = input === glob; |
|
let output = match && format ? format(input) : input; |
|
if (match === false) { |
|
output = format ? format(input) : input; |
|
match = output === glob; |
|
} |
|
if (match === false || opts.capture === true) { |
|
if (opts.matchBase === true || opts.basename === true) { |
|
match = picomatch.matchBase(input, regex, options, posix2); |
|
} else { |
|
match = regex.exec(output); |
|
} |
|
} |
|
return { isMatch: Boolean(match), match, output }; |
|
}; |
|
picomatch.matchBase = (input, glob, options, posix2 = utils.isWindows(options)) => { |
|
const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options); |
|
return regex.test(path4.basename(input)); |
|
}; |
|
picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); |
|
picomatch.parse = (pattern, options) => { |
|
if (Array.isArray(pattern)) |
|
return pattern.map((p) => picomatch.parse(p, options)); |
|
return parse(pattern, __spreadProps(__spreadValues({}, options), { fastpaths: false })); |
|
}; |
|
picomatch.scan = (input, options) => scan(input, options); |
|
picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => { |
|
if (returnOutput === true) { |
|
return state.output; |
|
} |
|
const opts = options || {}; |
|
const prepend = opts.contains ? "" : "^"; |
|
const append = opts.contains ? "" : "$"; |
|
let source = `${prepend}(?:${state.output})${append}`; |
|
if (state && state.negated === true) { |
|
source = `^(?!${source}).*$`; |
|
} |
|
const regex = picomatch.toRegex(source, options); |
|
if (returnState === true) { |
|
regex.state = state; |
|
} |
|
return regex; |
|
}; |
|
picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => { |
|
if (!input || typeof input !== "string") { |
|
throw new TypeError("Expected a non-empty string"); |
|
} |
|
let parsed = { negated: false, fastpaths: true }; |
|
if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) { |
|
parsed.output = parse.fastpaths(input, options); |
|
} |
|
if (!parsed.output) { |
|
parsed = parse(input, options); |
|
} |
|
return picomatch.compileRe(parsed, options, returnOutput, returnState); |
|
}; |
|
picomatch.toRegex = (source, options) => { |
|
try { |
|
const opts = options || {}; |
|
return new RegExp(source, opts.flags || (opts.nocase ? "i" : "")); |
|
} catch (err) { |
|
if (options && options.debug === true) |
|
throw err; |
|
return /$^/; |
|
} |
|
}; |
|
picomatch.constants = constants; |
|
module2.exports = picomatch; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js |
|
var require_picomatch2 = __commonJS({ |
|
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js"(exports, module2) { |
|
"use strict"; |
|
module2.exports = require_picomatch(); |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/hash-sum@2.0.0/node_modules/hash-sum/hash-sum.js |
|
var require_hash_sum = __commonJS({ |
|
"../../node_modules/.pnpm/hash-sum@2.0.0/node_modules/hash-sum/hash-sum.js"(exports, module2) { |
|
"use strict"; |
|
function pad(hash2, len) { |
|
while (hash2.length < len) { |
|
hash2 = "0" + hash2; |
|
} |
|
return hash2; |
|
} |
|
function fold(hash2, text) { |
|
var i; |
|
var chr; |
|
var len; |
|
if (text.length === 0) { |
|
return hash2; |
|
} |
|
for (i = 0, len = text.length; i < len; i++) { |
|
chr = text.charCodeAt(i); |
|
hash2 = (hash2 << 5) - hash2 + chr; |
|
hash2 |= 0; |
|
} |
|
return hash2 < 0 ? hash2 * -2 : hash2; |
|
} |
|
function foldObject(hash2, o, seen) { |
|
return Object.keys(o).sort().reduce(foldKey, hash2); |
|
function foldKey(hash3, key) { |
|
return foldValue(hash3, o[key], key, seen); |
|
} |
|
} |
|
function foldValue(input, value, key, seen) { |
|
var hash2 = fold(fold(fold(input, key), toString(value)), typeof value); |
|
if (value === null) { |
|
return fold(hash2, "null"); |
|
} |
|
if (value === void 0) { |
|
return fold(hash2, "undefined"); |
|
} |
|
if (typeof value === "object" || typeof value === "function") { |
|
if (seen.indexOf(value) !== -1) { |
|
return fold(hash2, "[Circular]" + key); |
|
} |
|
seen.push(value); |
|
var objHash = foldObject(hash2, value, seen); |
|
if (!("valueOf" in value) || typeof value.valueOf !== "function") { |
|
return objHash; |
|
} |
|
try { |
|
return fold(objHash, String(value.valueOf())); |
|
} catch (err) { |
|
return fold(objHash, "[valueOf exception]" + (err.stack || err.message)); |
|
} |
|
} |
|
return fold(hash2, value.toString()); |
|
} |
|
function toString(o) { |
|
return Object.prototype.toString.call(o); |
|
} |
|
function sum(o) { |
|
return pad(foldValue(0, o, "", []).toString(16), 8); |
|
} |
|
module2.exports = sum; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/ms@2.1.2/node_modules/ms/index.js |
|
var require_ms = __commonJS({ |
|
"../../node_modules/.pnpm/ms@2.1.2/node_modules/ms/index.js"(exports, module2) { |
|
var s = 1e3; |
|
var m = s * 60; |
|
var h = m * 60; |
|
var d = h * 24; |
|
var w = d * 7; |
|
var y = d * 365.25; |
|
module2.exports = function(val, options) { |
|
options = options || {}; |
|
var type = typeof val; |
|
if (type === "string" && val.length > 0) { |
|
return parse(val); |
|
} else if (type === "number" && isFinite(val)) { |
|
return options.long ? fmtLong(val) : fmtShort(val); |
|
} |
|
throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val)); |
|
}; |
|
function parse(str) { |
|
str = String(str); |
|
if (str.length > 100) { |
|
return; |
|
} |
|
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str); |
|
if (!match) { |
|
return; |
|
} |
|
var n = parseFloat(match[1]); |
|
var type = (match[2] || "ms").toLowerCase(); |
|
switch (type) { |
|
case "years": |
|
case "year": |
|
case "yrs": |
|
case "yr": |
|
case "y": |
|
return n * y; |
|
case "weeks": |
|
case "week": |
|
case "w": |
|
return n * w; |
|
case "days": |
|
case "day": |
|
case "d": |
|
return n * d; |
|
case "hours": |
|
case "hour": |
|
case "hrs": |
|
case "hr": |
|
case "h": |
|
return n * h; |
|
case "minutes": |
|
case "minute": |
|
case "mins": |
|
case "min": |
|
case "m": |
|
return n * m; |
|
case "seconds": |
|
case "second": |
|
case "secs": |
|
case "sec": |
|
case "s": |
|
return n * s; |
|
case "milliseconds": |
|
case "millisecond": |
|
case "msecs": |
|
case "msec": |
|
case "ms": |
|
return n; |
|
default: |
|
return void 0; |
|
} |
|
} |
|
function fmtShort(ms) { |
|
var msAbs = Math.abs(ms); |
|
if (msAbs >= d) { |
|
return Math.round(ms / d) + "d"; |
|
} |
|
if (msAbs >= h) { |
|
return Math.round(ms / h) + "h"; |
|
} |
|
if (msAbs >= m) { |
|
return Math.round(ms / m) + "m"; |
|
} |
|
if (msAbs >= s) { |
|
return Math.round(ms / s) + "s"; |
|
} |
|
return ms + "ms"; |
|
} |
|
function fmtLong(ms) { |
|
var msAbs = Math.abs(ms); |
|
if (msAbs >= d) { |
|
return plural(ms, msAbs, d, "day"); |
|
} |
|
if (msAbs >= h) { |
|
return plural(ms, msAbs, h, "hour"); |
|
} |
|
if (msAbs >= m) { |
|
return plural(ms, msAbs, m, "minute"); |
|
} |
|
if (msAbs >= s) { |
|
return plural(ms, msAbs, s, "second"); |
|
} |
|
return ms + " ms"; |
|
} |
|
function plural(ms, msAbs, n, name) { |
|
var isPlural = msAbs >= n * 1.5; |
|
return Math.round(ms / n) + " " + name + (isPlural ? "s" : ""); |
|
} |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/common.js |
|
var require_common = __commonJS({ |
|
"../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/common.js"(exports, module2) { |
|
function setup(env) { |
|
createDebug.debug = createDebug; |
|
createDebug.default = createDebug; |
|
createDebug.coerce = coerce; |
|
createDebug.disable = disable; |
|
createDebug.enable = enable; |
|
createDebug.enabled = enabled; |
|
createDebug.humanize = require_ms(); |
|
createDebug.destroy = destroy; |
|
Object.keys(env).forEach((key) => { |
|
createDebug[key] = env[key]; |
|
}); |
|
createDebug.names = []; |
|
createDebug.skips = []; |
|
createDebug.formatters = {}; |
|
function selectColor(namespace) { |
|
let hash2 = 0; |
|
for (let i = 0; i < namespace.length; i++) { |
|
hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i); |
|
hash2 |= 0; |
|
} |
|
return createDebug.colors[Math.abs(hash2) % createDebug.colors.length]; |
|
} |
|
createDebug.selectColor = selectColor; |
|
function createDebug(namespace) { |
|
let prevTime; |
|
let enableOverride = null; |
|
let namespacesCache; |
|
let enabledCache; |
|
function debug2(...args) { |
|
if (!debug2.enabled) { |
|
return; |
|
} |
|
const self = debug2; |
|
const curr = Number(new Date()); |
|
const ms = curr - (prevTime || curr); |
|
self.diff = ms; |
|
self.prev = prevTime; |
|
self.curr = curr; |
|
prevTime = curr; |
|
args[0] = createDebug.coerce(args[0]); |
|
if (typeof args[0] !== "string") { |
|
args.unshift("%O"); |
|
} |
|
let index = 0; |
|
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { |
|
if (match === "%%") { |
|
return "%"; |
|
} |
|
index++; |
|
const formatter = createDebug.formatters[format]; |
|
if (typeof formatter === "function") { |
|
const val = args[index]; |
|
match = formatter.call(self, val); |
|
args.splice(index, 1); |
|
index--; |
|
} |
|
return match; |
|
}); |
|
createDebug.formatArgs.call(self, args); |
|
const logFn = self.log || createDebug.log; |
|
logFn.apply(self, args); |
|
} |
|
debug2.namespace = namespace; |
|
debug2.useColors = createDebug.useColors(); |
|
debug2.color = createDebug.selectColor(namespace); |
|
debug2.extend = extend; |
|
debug2.destroy = createDebug.destroy; |
|
Object.defineProperty(debug2, "enabled", { |
|
enumerable: true, |
|
configurable: false, |
|
get: () => { |
|
if (enableOverride !== null) { |
|
return enableOverride; |
|
} |
|
if (namespacesCache !== createDebug.namespaces) { |
|
namespacesCache = createDebug.namespaces; |
|
enabledCache = createDebug.enabled(namespace); |
|
} |
|
return enabledCache; |
|
}, |
|
set: (v) => { |
|
enableOverride = v; |
|
} |
|
}); |
|
if (typeof createDebug.init === "function") { |
|
createDebug.init(debug2); |
|
} |
|
return debug2; |
|
} |
|
function extend(namespace, delimiter) { |
|
const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace); |
|
newDebug.log = this.log; |
|
return newDebug; |
|
} |
|
function enable(namespaces) { |
|
createDebug.save(namespaces); |
|
createDebug.namespaces = namespaces; |
|
createDebug.names = []; |
|
createDebug.skips = []; |
|
let i; |
|
const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/); |
|
const len = split.length; |
|
for (i = 0; i < len; i++) { |
|
if (!split[i]) { |
|
continue; |
|
} |
|
namespaces = split[i].replace(/\*/g, ".*?"); |
|
if (namespaces[0] === "-") { |
|
createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$")); |
|
} else { |
|
createDebug.names.push(new RegExp("^" + namespaces + "$")); |
|
} |
|
} |
|
} |
|
function disable() { |
|
const namespaces = [ |
|
...createDebug.names.map(toNamespace), |
|
...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace) |
|
].join(","); |
|
createDebug.enable(""); |
|
return namespaces; |
|
} |
|
function enabled(name) { |
|
if (name[name.length - 1] === "*") { |
|
return true; |
|
} |
|
let i; |
|
let len; |
|
for (i = 0, len = createDebug.skips.length; i < len; i++) { |
|
if (createDebug.skips[i].test(name)) { |
|
return false; |
|
} |
|
} |
|
for (i = 0, len = createDebug.names.length; i < len; i++) { |
|
if (createDebug.names[i].test(name)) { |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
function toNamespace(regexp) { |
|
return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*"); |
|
} |
|
function coerce(val) { |
|
if (val instanceof Error) { |
|
return val.stack || val.message; |
|
} |
|
return val; |
|
} |
|
function destroy() { |
|
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); |
|
} |
|
createDebug.enable(createDebug.load()); |
|
return createDebug; |
|
} |
|
module2.exports = setup; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/browser.js |
|
var require_browser = __commonJS({ |
|
"../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/browser.js"(exports, module2) { |
|
exports.formatArgs = formatArgs; |
|
exports.save = save; |
|
exports.load = load; |
|
exports.useColors = useColors; |
|
exports.storage = localstorage(); |
|
exports.destroy = (() => { |
|
let warned = false; |
|
return () => { |
|
if (!warned) { |
|
warned = true; |
|
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); |
|
} |
|
}; |
|
})(); |
|
exports.colors = [ |
|
"#0000CC", |
|
"#0000FF", |
|
"#0033CC", |
|
"#0033FF", |
|
"#0066CC", |
|
"#0066FF", |
|
"#0099CC", |
|
"#0099FF", |
|
"#00CC00", |
|
"#00CC33", |
|
"#00CC66", |
|
"#00CC99", |
|
"#00CCCC", |
|
"#00CCFF", |
|
"#3300CC", |
|
"#3300FF", |
|
"#3333CC", |
|
"#3333FF", |
|
"#3366CC", |
|
"#3366FF", |
|
"#3399CC", |
|
"#3399FF", |
|
"#33CC00", |
|
"#33CC33", |
|
"#33CC66", |
|
"#33CC99", |
|
"#33CCCC", |
|
"#33CCFF", |
|
"#6600CC", |
|
"#6600FF", |
|
"#6633CC", |
|
"#6633FF", |
|
"#66CC00", |
|
"#66CC33", |
|
"#9900CC", |
|
"#9900FF", |
|
"#9933CC", |
|
"#9933FF", |
|
"#99CC00", |
|
"#99CC33", |
|
"#CC0000", |
|
"#CC0033", |
|
"#CC0066", |
|
"#CC0099", |
|
"#CC00CC", |
|
"#CC00FF", |
|
"#CC3300", |
|
"#CC3333", |
|
"#CC3366", |
|
"#CC3399", |
|
"#CC33CC", |
|
"#CC33FF", |
|
"#CC6600", |
|
"#CC6633", |
|
"#CC9900", |
|
"#CC9933", |
|
"#CCCC00", |
|
"#CCCC33", |
|
"#FF0000", |
|
"#FF0033", |
|
"#FF0066", |
|
"#FF0099", |
|
"#FF00CC", |
|
"#FF00FF", |
|
"#FF3300", |
|
"#FF3333", |
|
"#FF3366", |
|
"#FF3399", |
|
"#FF33CC", |
|
"#FF33FF", |
|
"#FF6600", |
|
"#FF6633", |
|
"#FF9900", |
|
"#FF9933", |
|
"#FFCC00", |
|
"#FFCC33" |
|
]; |
|
function useColors() { |
|
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) { |
|
return true; |
|
} |
|
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { |
|
return false; |
|
} |
|
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/); |
|
} |
|
function formatArgs(args) { |
|
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff); |
|
if (!this.useColors) { |
|
return; |
|
} |
|
const c = "color: " + this.color; |
|
args.splice(1, 0, c, "color: inherit"); |
|
let index = 0; |
|
let lastC = 0; |
|
args[0].replace(/%[a-zA-Z%]/g, (match) => { |
|
if (match === "%%") { |
|
return; |
|
} |
|
index++; |
|
if (match === "%c") { |
|
lastC = index; |
|
} |
|
}); |
|
args.splice(lastC, 0, c); |
|
} |
|
exports.log = console.debug || console.log || (() => { |
|
}); |
|
function save(namespaces) { |
|
try { |
|
if (namespaces) { |
|
exports.storage.setItem("debug", namespaces); |
|
} else { |
|
exports.storage.removeItem("debug"); |
|
} |
|
} catch (error) { |
|
} |
|
} |
|
function load() { |
|
let r; |
|
try { |
|
r = exports.storage.getItem("debug"); |
|
} catch (error) { |
|
} |
|
if (!r && typeof process !== "undefined" && "env" in process) { |
|
r = process.env.DEBUG; |
|
} |
|
return r; |
|
} |
|
function localstorage() { |
|
try { |
|
return localStorage; |
|
} catch (error) { |
|
} |
|
} |
|
module2.exports = require_common()(exports); |
|
var { formatters } = module2.exports; |
|
formatters.j = function(v) { |
|
try { |
|
return JSON.stringify(v); |
|
} catch (error) { |
|
return "[UnexpectedJSONParseError]: " + error.message; |
|
} |
|
}; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/node.js |
|
var require_node = __commonJS({ |
|
"../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/node.js"(exports, module2) { |
|
var tty = require("tty"); |
|
var util = require("util"); |
|
exports.init = init; |
|
exports.log = log; |
|
exports.formatArgs = formatArgs; |
|
exports.save = save; |
|
exports.load = load; |
|
exports.useColors = useColors; |
|
exports.destroy = util.deprecate(() => { |
|
}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); |
|
exports.colors = [6, 2, 3, 4, 5, 1]; |
|
try { |
|
const supportsColor = require("supports-color"); |
|
if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) { |
|
exports.colors = [ |
|
20, |
|
21, |
|
26, |
|
27, |
|
32, |
|
33, |
|
38, |
|
39, |
|
40, |
|
41, |
|
42, |
|
43, |
|
44, |
|
45, |
|
56, |
|
57, |
|
62, |
|
63, |
|
68, |
|
69, |
|
74, |
|
75, |
|
76, |
|
77, |
|
78, |
|
79, |
|
80, |
|
81, |
|
92, |
|
93, |
|
98, |
|
99, |
|
112, |
|
113, |
|
128, |
|
129, |
|
134, |
|
135, |
|
148, |
|
149, |
|
160, |
|
161, |
|
162, |
|
163, |
|
164, |
|
165, |
|
166, |
|
167, |
|
168, |
|
169, |
|
170, |
|
171, |
|
172, |
|
173, |
|
178, |
|
179, |
|
184, |
|
185, |
|
196, |
|
197, |
|
198, |
|
199, |
|
200, |
|
201, |
|
202, |
|
203, |
|
204, |
|
205, |
|
206, |
|
207, |
|
208, |
|
209, |
|
214, |
|
215, |
|
220, |
|
221 |
|
]; |
|
} |
|
} catch (error) { |
|
} |
|
exports.inspectOpts = Object.keys(process.env).filter((key) => { |
|
return /^debug_/i.test(key); |
|
}).reduce((obj, key) => { |
|
const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => { |
|
return k.toUpperCase(); |
|
}); |
|
let val = process.env[key]; |
|
if (/^(yes|on|true|enabled)$/i.test(val)) { |
|
val = true; |
|
} else if (/^(no|off|false|disabled)$/i.test(val)) { |
|
val = false; |
|
} else if (val === "null") { |
|
val = null; |
|
} else { |
|
val = Number(val); |
|
} |
|
obj[prop] = val; |
|
return obj; |
|
}, {}); |
|
function useColors() { |
|
return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd); |
|
} |
|
function formatArgs(args) { |
|
const { namespace: name, useColors: useColors2 } = this; |
|
if (useColors2) { |
|
const c = this.color; |
|
const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c); |
|
const prefix = ` ${colorCode};1m${name} \x1B[0m`; |
|
args[0] = prefix + args[0].split("\n").join("\n" + prefix); |
|
args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m"); |
|
} else { |
|
args[0] = getDate() + name + " " + args[0]; |
|
} |
|
} |
|
function getDate() { |
|
if (exports.inspectOpts.hideDate) { |
|
return ""; |
|
} |
|
return new Date().toISOString() + " "; |
|
} |
|
function log(...args) { |
|
return process.stderr.write(util.format(...args) + "\n"); |
|
} |
|
function save(namespaces) { |
|
if (namespaces) { |
|
process.env.DEBUG = namespaces; |
|
} else { |
|
delete process.env.DEBUG; |
|
} |
|
} |
|
function load() { |
|
return process.env.DEBUG; |
|
} |
|
function init(debug2) { |
|
debug2.inspectOpts = {}; |
|
const keys = Object.keys(exports.inspectOpts); |
|
for (let i = 0; i < keys.length; i++) { |
|
debug2.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]]; |
|
} |
|
} |
|
module2.exports = require_common()(exports); |
|
var { formatters } = module2.exports; |
|
formatters.o = function(v) { |
|
this.inspectOpts.colors = this.useColors; |
|
return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" "); |
|
}; |
|
formatters.O = function(v) { |
|
this.inspectOpts.colors = this.useColors; |
|
return util.inspect(v, this.inspectOpts); |
|
}; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/index.js |
|
var require_src = __commonJS({ |
|
"../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/index.js"(exports, module2) { |
|
if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) { |
|
module2.exports = require_browser(); |
|
} else { |
|
module2.exports = require_node(); |
|
} |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64.js |
|
var require_base64 = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64.js"(exports) { |
|
var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""); |
|
exports.encode = function(number) { |
|
if (0 <= number && number < intToCharMap.length) { |
|
return intToCharMap[number]; |
|
} |
|
throw new TypeError("Must be between 0 and 63: " + number); |
|
}; |
|
exports.decode = function(charCode) { |
|
var bigA = 65; |
|
var bigZ = 90; |
|
var littleA = 97; |
|
var littleZ = 122; |
|
var zero = 48; |
|
var nine = 57; |
|
var plus = 43; |
|
var slash2 = 47; |
|
var littleOffset = 26; |
|
var numberOffset = 52; |
|
if (bigA <= charCode && charCode <= bigZ) { |
|
return charCode - bigA; |
|
} |
|
if (littleA <= charCode && charCode <= littleZ) { |
|
return charCode - littleA + littleOffset; |
|
} |
|
if (zero <= charCode && charCode <= nine) { |
|
return charCode - zero + numberOffset; |
|
} |
|
if (charCode == plus) { |
|
return 62; |
|
} |
|
if (charCode == slash2) { |
|
return 63; |
|
} |
|
return -1; |
|
}; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64-vlq.js |
|
var require_base64_vlq = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64-vlq.js"(exports) { |
|
var base64 = require_base64(); |
|
var VLQ_BASE_SHIFT = 5; |
|
var VLQ_BASE = 1 << VLQ_BASE_SHIFT; |
|
var VLQ_BASE_MASK = VLQ_BASE - 1; |
|
var VLQ_CONTINUATION_BIT = VLQ_BASE; |
|
function toVLQSigned(aValue) { |
|
return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0; |
|
} |
|
function fromVLQSigned(aValue) { |
|
var isNegative = (aValue & 1) === 1; |
|
var shifted = aValue >> 1; |
|
return isNegative ? -shifted : shifted; |
|
} |
|
exports.encode = function base64VLQ_encode(aValue) { |
|
var encoded = ""; |
|
var digit; |
|
var vlq = toVLQSigned(aValue); |
|
do { |
|
digit = vlq & VLQ_BASE_MASK; |
|
vlq >>>= VLQ_BASE_SHIFT; |
|
if (vlq > 0) { |
|
digit |= VLQ_CONTINUATION_BIT; |
|
} |
|
encoded += base64.encode(digit); |
|
} while (vlq > 0); |
|
return encoded; |
|
}; |
|
exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) { |
|
var strLen = aStr.length; |
|
var result = 0; |
|
var shift = 0; |
|
var continuation, digit; |
|
do { |
|
if (aIndex >= strLen) { |
|
throw new Error("Expected more digits in base 64 VLQ value."); |
|
} |
|
digit = base64.decode(aStr.charCodeAt(aIndex++)); |
|
if (digit === -1) { |
|
throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1)); |
|
} |
|
continuation = !!(digit & VLQ_CONTINUATION_BIT); |
|
digit &= VLQ_BASE_MASK; |
|
result = result + (digit << shift); |
|
shift += VLQ_BASE_SHIFT; |
|
} while (continuation); |
|
aOutParam.value = fromVLQSigned(result); |
|
aOutParam.rest = aIndex; |
|
}; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/util.js |
|
var require_util = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/util.js"(exports) { |
|
function getArg(aArgs, aName, aDefaultValue) { |
|
if (aName in aArgs) { |
|
return aArgs[aName]; |
|
} else if (arguments.length === 3) { |
|
return aDefaultValue; |
|
} else { |
|
throw new Error('"' + aName + '" is a required argument.'); |
|
} |
|
} |
|
exports.getArg = getArg; |
|
var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/; |
|
var dataUrlRegexp = /^data:.+\,.+$/; |
|
function urlParse(aUrl) { |
|
var match = aUrl.match(urlRegexp); |
|
if (!match) { |
|
return null; |
|
} |
|
return { |
|
scheme: match[1], |
|
auth: match[2], |
|
host: match[3], |
|
port: match[4], |
|
path: match[5] |
|
}; |
|
} |
|
exports.urlParse = urlParse; |
|
function urlGenerate(aParsedUrl) { |
|
var url = ""; |
|
if (aParsedUrl.scheme) { |
|
url += aParsedUrl.scheme + ":"; |
|
} |
|
url += "//"; |
|
if (aParsedUrl.auth) { |
|
url += aParsedUrl.auth + "@"; |
|
} |
|
if (aParsedUrl.host) { |
|
url += aParsedUrl.host; |
|
} |
|
if (aParsedUrl.port) { |
|
url += ":" + aParsedUrl.port; |
|
} |
|
if (aParsedUrl.path) { |
|
url += aParsedUrl.path; |
|
} |
|
return url; |
|
} |
|
exports.urlGenerate = urlGenerate; |
|
function normalize(aPath) { |
|
var path4 = aPath; |
|
var url = urlParse(aPath); |
|
if (url) { |
|
if (!url.path) { |
|
return aPath; |
|
} |
|
path4 = url.path; |
|
} |
|
var isAbsolute2 = exports.isAbsolute(path4); |
|
var parts = path4.split(/\/+/); |
|
for (var part, up = 0, i = parts.length - 1; i >= 0; i--) { |
|
part = parts[i]; |
|
if (part === ".") { |
|
parts.splice(i, 1); |
|
} else if (part === "..") { |
|
up++; |
|
} else if (up > 0) { |
|
if (part === "") { |
|
parts.splice(i + 1, up); |
|
up = 0; |
|
} else { |
|
parts.splice(i, 2); |
|
up--; |
|
} |
|
} |
|
} |
|
path4 = parts.join("/"); |
|
if (path4 === "") { |
|
path4 = isAbsolute2 ? "/" : "."; |
|
} |
|
if (url) { |
|
url.path = path4; |
|
return urlGenerate(url); |
|
} |
|
return path4; |
|
} |
|
exports.normalize = normalize; |
|
function join(aRoot, aPath) { |
|
if (aRoot === "") { |
|
aRoot = "."; |
|
} |
|
if (aPath === "") { |
|
aPath = "."; |
|
} |
|
var aPathUrl = urlParse(aPath); |
|
var aRootUrl = urlParse(aRoot); |
|
if (aRootUrl) { |
|
aRoot = aRootUrl.path || "/"; |
|
} |
|
if (aPathUrl && !aPathUrl.scheme) { |
|
if (aRootUrl) { |
|
aPathUrl.scheme = aRootUrl.scheme; |
|
} |
|
return urlGenerate(aPathUrl); |
|
} |
|
if (aPathUrl || aPath.match(dataUrlRegexp)) { |
|
return aPath; |
|
} |
|
if (aRootUrl && !aRootUrl.host && !aRootUrl.path) { |
|
aRootUrl.host = aPath; |
|
return urlGenerate(aRootUrl); |
|
} |
|
var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath); |
|
if (aRootUrl) { |
|
aRootUrl.path = joined; |
|
return urlGenerate(aRootUrl); |
|
} |
|
return joined; |
|
} |
|
exports.join = join; |
|
exports.isAbsolute = function(aPath) { |
|
return aPath.charAt(0) === "/" || urlRegexp.test(aPath); |
|
}; |
|
function relative(aRoot, aPath) { |
|
if (aRoot === "") { |
|
aRoot = "."; |
|
} |
|
aRoot = aRoot.replace(/\/$/, ""); |
|
var level = 0; |
|
while (aPath.indexOf(aRoot + "/") !== 0) { |
|
var index = aRoot.lastIndexOf("/"); |
|
if (index < 0) { |
|
return aPath; |
|
} |
|
aRoot = aRoot.slice(0, index); |
|
if (aRoot.match(/^([^\/]+:\/)?\/*$/)) { |
|
return aPath; |
|
} |
|
++level; |
|
} |
|
return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1); |
|
} |
|
exports.relative = relative; |
|
var supportsNullProto = function() { |
|
var obj = /* @__PURE__ */ Object.create(null); |
|
return !("__proto__" in obj); |
|
}(); |
|
function identity(s) { |
|
return s; |
|
} |
|
function toSetString(aStr) { |
|
if (isProtoString(aStr)) { |
|
return "$" + aStr; |
|
} |
|
return aStr; |
|
} |
|
exports.toSetString = supportsNullProto ? identity : toSetString; |
|
function fromSetString(aStr) { |
|
if (isProtoString(aStr)) { |
|
return aStr.slice(1); |
|
} |
|
return aStr; |
|
} |
|
exports.fromSetString = supportsNullProto ? identity : fromSetString; |
|
function isProtoString(s) { |
|
if (!s) { |
|
return false; |
|
} |
|
var length = s.length; |
|
if (length < 9) { |
|
return false; |
|
} |
|
if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) { |
|
return false; |
|
} |
|
for (var i = length - 10; i >= 0; i--) { |
|
if (s.charCodeAt(i) !== 36) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) { |
|
var cmp = strcmp(mappingA.source, mappingB.source); |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.originalLine - mappingB.originalLine; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.originalColumn - mappingB.originalColumn; |
|
if (cmp !== 0 || onlyCompareOriginal) { |
|
return cmp; |
|
} |
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.generatedLine - mappingB.generatedLine; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
return strcmp(mappingA.name, mappingB.name); |
|
} |
|
exports.compareByOriginalPositions = compareByOriginalPositions; |
|
function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) { |
|
var cmp = mappingA.generatedLine - mappingB.generatedLine; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn; |
|
if (cmp !== 0 || onlyCompareGenerated) { |
|
return cmp; |
|
} |
|
cmp = strcmp(mappingA.source, mappingB.source); |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.originalLine - mappingB.originalLine; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.originalColumn - mappingB.originalColumn; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
return strcmp(mappingA.name, mappingB.name); |
|
} |
|
exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated; |
|
function strcmp(aStr1, aStr2) { |
|
if (aStr1 === aStr2) { |
|
return 0; |
|
} |
|
if (aStr1 === null) { |
|
return 1; |
|
} |
|
if (aStr2 === null) { |
|
return -1; |
|
} |
|
if (aStr1 > aStr2) { |
|
return 1; |
|
} |
|
return -1; |
|
} |
|
function compareByGeneratedPositionsInflated(mappingA, mappingB) { |
|
var cmp = mappingA.generatedLine - mappingB.generatedLine; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = strcmp(mappingA.source, mappingB.source); |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.originalLine - mappingB.originalLine; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
cmp = mappingA.originalColumn - mappingB.originalColumn; |
|
if (cmp !== 0) { |
|
return cmp; |
|
} |
|
return strcmp(mappingA.name, mappingB.name); |
|
} |
|
exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated; |
|
function parseSourceMapInput(str) { |
|
return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, "")); |
|
} |
|
exports.parseSourceMapInput = parseSourceMapInput; |
|
function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) { |
|
sourceURL = sourceURL || ""; |
|
if (sourceRoot) { |
|
if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") { |
|
sourceRoot += "/"; |
|
} |
|
sourceURL = sourceRoot + sourceURL; |
|
} |
|
if (sourceMapURL) { |
|
var parsed = urlParse(sourceMapURL); |
|
if (!parsed) { |
|
throw new Error("sourceMapURL could not be parsed"); |
|
} |
|
if (parsed.path) { |
|
var index = parsed.path.lastIndexOf("/"); |
|
if (index >= 0) { |
|
parsed.path = parsed.path.substring(0, index + 1); |
|
} |
|
} |
|
sourceURL = join(urlGenerate(parsed), sourceURL); |
|
} |
|
return normalize(sourceURL); |
|
} |
|
exports.computeSourceURL = computeSourceURL; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/array-set.js |
|
var require_array_set = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/array-set.js"(exports) { |
|
var util = require_util(); |
|
var has = Object.prototype.hasOwnProperty; |
|
var hasNativeMap = typeof Map !== "undefined"; |
|
function ArraySet() { |
|
this._array = []; |
|
this._set = hasNativeMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null); |
|
} |
|
ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) { |
|
var set = new ArraySet(); |
|
for (var i = 0, len = aArray.length; i < len; i++) { |
|
set.add(aArray[i], aAllowDuplicates); |
|
} |
|
return set; |
|
}; |
|
ArraySet.prototype.size = function ArraySet_size() { |
|
return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length; |
|
}; |
|
ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) { |
|
var sStr = hasNativeMap ? aStr : util.toSetString(aStr); |
|
var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr); |
|
var idx = this._array.length; |
|
if (!isDuplicate || aAllowDuplicates) { |
|
this._array.push(aStr); |
|
} |
|
if (!isDuplicate) { |
|
if (hasNativeMap) { |
|
this._set.set(aStr, idx); |
|
} else { |
|
this._set[sStr] = idx; |
|
} |
|
} |
|
}; |
|
ArraySet.prototype.has = function ArraySet_has(aStr) { |
|
if (hasNativeMap) { |
|
return this._set.has(aStr); |
|
} else { |
|
var sStr = util.toSetString(aStr); |
|
return has.call(this._set, sStr); |
|
} |
|
}; |
|
ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) { |
|
if (hasNativeMap) { |
|
var idx = this._set.get(aStr); |
|
if (idx >= 0) { |
|
return idx; |
|
} |
|
} else { |
|
var sStr = util.toSetString(aStr); |
|
if (has.call(this._set, sStr)) { |
|
return this._set[sStr]; |
|
} |
|
} |
|
throw new Error('"' + aStr + '" is not in the set.'); |
|
}; |
|
ArraySet.prototype.at = function ArraySet_at(aIdx) { |
|
if (aIdx >= 0 && aIdx < this._array.length) { |
|
return this._array[aIdx]; |
|
} |
|
throw new Error("No element indexed by " + aIdx); |
|
}; |
|
ArraySet.prototype.toArray = function ArraySet_toArray() { |
|
return this._array.slice(); |
|
}; |
|
exports.ArraySet = ArraySet; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/mapping-list.js |
|
var require_mapping_list = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/mapping-list.js"(exports) { |
|
var util = require_util(); |
|
function generatedPositionAfter(mappingA, mappingB) { |
|
var lineA = mappingA.generatedLine; |
|
var lineB = mappingB.generatedLine; |
|
var columnA = mappingA.generatedColumn; |
|
var columnB = mappingB.generatedColumn; |
|
return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0; |
|
} |
|
function MappingList() { |
|
this._array = []; |
|
this._sorted = true; |
|
this._last = { generatedLine: -1, generatedColumn: 0 }; |
|
} |
|
MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) { |
|
this._array.forEach(aCallback, aThisArg); |
|
}; |
|
MappingList.prototype.add = function MappingList_add(aMapping) { |
|
if (generatedPositionAfter(this._last, aMapping)) { |
|
this._last = aMapping; |
|
this._array.push(aMapping); |
|
} else { |
|
this._sorted = false; |
|
this._array.push(aMapping); |
|
} |
|
}; |
|
MappingList.prototype.toArray = function MappingList_toArray() { |
|
if (!this._sorted) { |
|
this._array.sort(util.compareByGeneratedPositionsInflated); |
|
this._sorted = true; |
|
} |
|
return this._array; |
|
}; |
|
exports.MappingList = MappingList; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-map-generator.js |
|
var require_source_map_generator = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-map-generator.js"(exports) { |
|
var base64VLQ = require_base64_vlq(); |
|
var util = require_util(); |
|
var ArraySet = require_array_set().ArraySet; |
|
var MappingList = require_mapping_list().MappingList; |
|
function SourceMapGenerator2(aArgs) { |
|
if (!aArgs) { |
|
aArgs = {}; |
|
} |
|
this._file = util.getArg(aArgs, "file", null); |
|
this._sourceRoot = util.getArg(aArgs, "sourceRoot", null); |
|
this._skipValidation = util.getArg(aArgs, "skipValidation", false); |
|
this._sources = new ArraySet(); |
|
this._names = new ArraySet(); |
|
this._mappings = new MappingList(); |
|
this._sourcesContents = null; |
|
} |
|
SourceMapGenerator2.prototype._version = 3; |
|
SourceMapGenerator2.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) { |
|
var sourceRoot = aSourceMapConsumer.sourceRoot; |
|
var generator = new SourceMapGenerator2({ |
|
file: aSourceMapConsumer.file, |
|
sourceRoot |
|
}); |
|
aSourceMapConsumer.eachMapping(function(mapping) { |
|
var newMapping = { |
|
generated: { |
|
line: mapping.generatedLine, |
|
column: mapping.generatedColumn |
|
} |
|
}; |
|
if (mapping.source != null) { |
|
newMapping.source = mapping.source; |
|
if (sourceRoot != null) { |
|
newMapping.source = util.relative(sourceRoot, newMapping.source); |
|
} |
|
newMapping.original = { |
|
line: mapping.originalLine, |
|
column: mapping.originalColumn |
|
}; |
|
if (mapping.name != null) { |
|
newMapping.name = mapping.name; |
|
} |
|
} |
|
generator.addMapping(newMapping); |
|
}); |
|
aSourceMapConsumer.sources.forEach(function(sourceFile) { |
|
var sourceRelative = sourceFile; |
|
if (sourceRoot !== null) { |
|
sourceRelative = util.relative(sourceRoot, sourceFile); |
|
} |
|
if (!generator._sources.has(sourceRelative)) { |
|
generator._sources.add(sourceRelative); |
|
} |
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile); |
|
if (content != null) { |
|
generator.setSourceContent(sourceFile, content); |
|
} |
|
}); |
|
return generator; |
|
}; |
|
SourceMapGenerator2.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) { |
|
var generated = util.getArg(aArgs, "generated"); |
|
var original = util.getArg(aArgs, "original", null); |
|
var source = util.getArg(aArgs, "source", null); |
|
var name = util.getArg(aArgs, "name", null); |
|
if (!this._skipValidation) { |
|
this._validateMapping(generated, original, source, name); |
|
} |
|
if (source != null) { |
|
source = String(source); |
|
if (!this._sources.has(source)) { |
|
this._sources.add(source); |
|
} |
|
} |
|
if (name != null) { |
|
name = String(name); |
|
if (!this._names.has(name)) { |
|
this._names.add(name); |
|
} |
|
} |
|
this._mappings.add({ |
|
generatedLine: generated.line, |
|
generatedColumn: generated.column, |
|
originalLine: original != null && original.line, |
|
originalColumn: original != null && original.column, |
|
source, |
|
name |
|
}); |
|
}; |
|
SourceMapGenerator2.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) { |
|
var source = aSourceFile; |
|
if (this._sourceRoot != null) { |
|
source = util.relative(this._sourceRoot, source); |
|
} |
|
if (aSourceContent != null) { |
|
if (!this._sourcesContents) { |
|
this._sourcesContents = /* @__PURE__ */ Object.create(null); |
|
} |
|
this._sourcesContents[util.toSetString(source)] = aSourceContent; |
|
} else if (this._sourcesContents) { |
|
delete this._sourcesContents[util.toSetString(source)]; |
|
if (Object.keys(this._sourcesContents).length === 0) { |
|
this._sourcesContents = null; |
|
} |
|
} |
|
}; |
|
SourceMapGenerator2.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) { |
|
var sourceFile = aSourceFile; |
|
if (aSourceFile == null) { |
|
if (aSourceMapConsumer.file == null) { |
|
throw new Error(`SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`); |
|
} |
|
sourceFile = aSourceMapConsumer.file; |
|
} |
|
var sourceRoot = this._sourceRoot; |
|
if (sourceRoot != null) { |
|
sourceFile = util.relative(sourceRoot, sourceFile); |
|
} |
|
var newSources = new ArraySet(); |
|
var newNames = new ArraySet(); |
|
this._mappings.unsortedForEach(function(mapping) { |
|
if (mapping.source === sourceFile && mapping.originalLine != null) { |
|
var original = aSourceMapConsumer.originalPositionFor({ |
|
line: mapping.originalLine, |
|
column: mapping.originalColumn |
|
}); |
|
if (original.source != null) { |
|
mapping.source = original.source; |
|
if (aSourceMapPath != null) { |
|
mapping.source = util.join(aSourceMapPath, mapping.source); |
|
} |
|
if (sourceRoot != null) { |
|
mapping.source = util.relative(sourceRoot, mapping.source); |
|
} |
|
mapping.originalLine = original.line; |
|
mapping.originalColumn = original.column; |
|
if (original.name != null) { |
|
mapping.name = original.name; |
|
} |
|
} |
|
} |
|
var source = mapping.source; |
|
if (source != null && !newSources.has(source)) { |
|
newSources.add(source); |
|
} |
|
var name = mapping.name; |
|
if (name != null && !newNames.has(name)) { |
|
newNames.add(name); |
|
} |
|
}, this); |
|
this._sources = newSources; |
|
this._names = newNames; |
|
aSourceMapConsumer.sources.forEach(function(sourceFile2) { |
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile2); |
|
if (content != null) { |
|
if (aSourceMapPath != null) { |
|
sourceFile2 = util.join(aSourceMapPath, sourceFile2); |
|
} |
|
if (sourceRoot != null) { |
|
sourceFile2 = util.relative(sourceRoot, sourceFile2); |
|
} |
|
this.setSourceContent(sourceFile2, content); |
|
} |
|
}, this); |
|
}; |
|
SourceMapGenerator2.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) { |
|
if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") { |
|
throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values."); |
|
} |
|
if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) { |
|
return; |
|
} else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) { |
|
return; |
|
} else { |
|
throw new Error("Invalid mapping: " + JSON.stringify({ |
|
generated: aGenerated, |
|
source: aSource, |
|
original: aOriginal, |
|
name: aName |
|
})); |
|
} |
|
}; |
|
SourceMapGenerator2.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() { |
|
var previousGeneratedColumn = 0; |
|
var previousGeneratedLine = 1; |
|
var previousOriginalColumn = 0; |
|
var previousOriginalLine = 0; |
|
var previousName = 0; |
|
var previousSource = 0; |
|
var result = ""; |
|
var next; |
|
var mapping; |
|
var nameIdx; |
|
var sourceIdx; |
|
var mappings = this._mappings.toArray(); |
|
for (var i = 0, len = mappings.length; i < len; i++) { |
|
mapping = mappings[i]; |
|
next = ""; |
|
if (mapping.generatedLine !== previousGeneratedLine) { |
|
previousGeneratedColumn = 0; |
|
while (mapping.generatedLine !== previousGeneratedLine) { |
|
next += ";"; |
|
previousGeneratedLine++; |
|
} |
|
} else { |
|
if (i > 0) { |
|
if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) { |
|
continue; |
|
} |
|
next += ","; |
|
} |
|
} |
|
next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn); |
|
previousGeneratedColumn = mapping.generatedColumn; |
|
if (mapping.source != null) { |
|
sourceIdx = this._sources.indexOf(mapping.source); |
|
next += base64VLQ.encode(sourceIdx - previousSource); |
|
previousSource = sourceIdx; |
|
next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine); |
|
previousOriginalLine = mapping.originalLine - 1; |
|
next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn); |
|
previousOriginalColumn = mapping.originalColumn; |
|
if (mapping.name != null) { |
|
nameIdx = this._names.indexOf(mapping.name); |
|
next += base64VLQ.encode(nameIdx - previousName); |
|
previousName = nameIdx; |
|
} |
|
} |
|
result += next; |
|
} |
|
return result; |
|
}; |
|
SourceMapGenerator2.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) { |
|
return aSources.map(function(source) { |
|
if (!this._sourcesContents) { |
|
return null; |
|
} |
|
if (aSourceRoot != null) { |
|
source = util.relative(aSourceRoot, source); |
|
} |
|
var key = util.toSetString(source); |
|
return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null; |
|
}, this); |
|
}; |
|
SourceMapGenerator2.prototype.toJSON = function SourceMapGenerator_toJSON() { |
|
var map = { |
|
version: this._version, |
|
sources: this._sources.toArray(), |
|
names: this._names.toArray(), |
|
mappings: this._serializeMappings() |
|
}; |
|
if (this._file != null) { |
|
map.file = this._file; |
|
} |
|
if (this._sourceRoot != null) { |
|
map.sourceRoot = this._sourceRoot; |
|
} |
|
if (this._sourcesContents) { |
|
map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot); |
|
} |
|
return map; |
|
}; |
|
SourceMapGenerator2.prototype.toString = function SourceMapGenerator_toString() { |
|
return JSON.stringify(this.toJSON()); |
|
}; |
|
exports.SourceMapGenerator = SourceMapGenerator2; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/binary-search.js |
|
var require_binary_search = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/binary-search.js"(exports) { |
|
exports.GREATEST_LOWER_BOUND = 1; |
|
exports.LEAST_UPPER_BOUND = 2; |
|
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) { |
|
var mid = Math.floor((aHigh - aLow) / 2) + aLow; |
|
var cmp = aCompare(aNeedle, aHaystack[mid], true); |
|
if (cmp === 0) { |
|
return mid; |
|
} else if (cmp > 0) { |
|
if (aHigh - mid > 1) { |
|
return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias); |
|
} |
|
if (aBias == exports.LEAST_UPPER_BOUND) { |
|
return aHigh < aHaystack.length ? aHigh : -1; |
|
} else { |
|
return mid; |
|
} |
|
} else { |
|
if (mid - aLow > 1) { |
|
return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias); |
|
} |
|
if (aBias == exports.LEAST_UPPER_BOUND) { |
|
return mid; |
|
} else { |
|
return aLow < 0 ? -1 : aLow; |
|
} |
|
} |
|
} |
|
exports.search = function search(aNeedle, aHaystack, aCompare, aBias) { |
|
if (aHaystack.length === 0) { |
|
return -1; |
|
} |
|
var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND); |
|
if (index < 0) { |
|
return -1; |
|
} |
|
while (index - 1 >= 0) { |
|
if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) { |
|
break; |
|
} |
|
--index; |
|
} |
|
return index; |
|
}; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/quick-sort.js |
|
var require_quick_sort = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/quick-sort.js"(exports) { |
|
function swap(ary, x, y) { |
|
var temp = ary[x]; |
|
ary[x] = ary[y]; |
|
ary[y] = temp; |
|
} |
|
function randomIntInRange(low, high) { |
|
return Math.round(low + Math.random() * (high - low)); |
|
} |
|
function doQuickSort(ary, comparator, p, r) { |
|
if (p < r) { |
|
var pivotIndex = randomIntInRange(p, r); |
|
var i = p - 1; |
|
swap(ary, pivotIndex, r); |
|
var pivot = ary[r]; |
|
for (var j = p; j < r; j++) { |
|
if (comparator(ary[j], pivot) <= 0) { |
|
i += 1; |
|
swap(ary, i, j); |
|
} |
|
} |
|
swap(ary, i + 1, j); |
|
var q = i + 1; |
|
doQuickSort(ary, comparator, p, q - 1); |
|
doQuickSort(ary, comparator, q + 1, r); |
|
} |
|
} |
|
exports.quickSort = function(ary, comparator) { |
|
doQuickSort(ary, comparator, 0, ary.length - 1); |
|
}; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-map-consumer.js |
|
var require_source_map_consumer = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-map-consumer.js"(exports) { |
|
var util = require_util(); |
|
var binarySearch = require_binary_search(); |
|
var ArraySet = require_array_set().ArraySet; |
|
var base64VLQ = require_base64_vlq(); |
|
var quickSort = require_quick_sort().quickSort; |
|
function SourceMapConsumer2(aSourceMap, aSourceMapURL) { |
|
var sourceMap = aSourceMap; |
|
if (typeof aSourceMap === "string") { |
|
sourceMap = util.parseSourceMapInput(aSourceMap); |
|
} |
|
return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL); |
|
} |
|
SourceMapConsumer2.fromSourceMap = function(aSourceMap, aSourceMapURL) { |
|
return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL); |
|
}; |
|
SourceMapConsumer2.prototype._version = 3; |
|
SourceMapConsumer2.prototype.__generatedMappings = null; |
|
Object.defineProperty(SourceMapConsumer2.prototype, "_generatedMappings", { |
|
configurable: true, |
|
enumerable: true, |
|
get: function() { |
|
if (!this.__generatedMappings) { |
|
this._parseMappings(this._mappings, this.sourceRoot); |
|
} |
|
return this.__generatedMappings; |
|
} |
|
}); |
|
SourceMapConsumer2.prototype.__originalMappings = null; |
|
Object.defineProperty(SourceMapConsumer2.prototype, "_originalMappings", { |
|
configurable: true, |
|
enumerable: true, |
|
get: function() { |
|
if (!this.__originalMappings) { |
|
this._parseMappings(this._mappings, this.sourceRoot); |
|
} |
|
return this.__originalMappings; |
|
} |
|
}); |
|
SourceMapConsumer2.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) { |
|
var c = aStr.charAt(index); |
|
return c === ";" || c === ","; |
|
}; |
|
SourceMapConsumer2.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) { |
|
throw new Error("Subclasses must implement _parseMappings"); |
|
}; |
|
SourceMapConsumer2.GENERATED_ORDER = 1; |
|
SourceMapConsumer2.ORIGINAL_ORDER = 2; |
|
SourceMapConsumer2.GREATEST_LOWER_BOUND = 1; |
|
SourceMapConsumer2.LEAST_UPPER_BOUND = 2; |
|
SourceMapConsumer2.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) { |
|
var context = aContext || null; |
|
var order = aOrder || SourceMapConsumer2.GENERATED_ORDER; |
|
var mappings; |
|
switch (order) { |
|
case SourceMapConsumer2.GENERATED_ORDER: |
|
mappings = this._generatedMappings; |
|
break; |
|
case SourceMapConsumer2.ORIGINAL_ORDER: |
|
mappings = this._originalMappings; |
|
break; |
|
default: |
|
throw new Error("Unknown order of iteration."); |
|
} |
|
var sourceRoot = this.sourceRoot; |
|
mappings.map(function(mapping) { |
|
var source = mapping.source === null ? null : this._sources.at(mapping.source); |
|
source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL); |
|
return { |
|
source, |
|
generatedLine: mapping.generatedLine, |
|
generatedColumn: mapping.generatedColumn, |
|
originalLine: mapping.originalLine, |
|
originalColumn: mapping.originalColumn, |
|
name: mapping.name === null ? null : this._names.at(mapping.name) |
|
}; |
|
}, this).forEach(aCallback, context); |
|
}; |
|
SourceMapConsumer2.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) { |
|
var line = util.getArg(aArgs, "line"); |
|
var needle = { |
|
source: util.getArg(aArgs, "source"), |
|
originalLine: line, |
|
originalColumn: util.getArg(aArgs, "column", 0) |
|
}; |
|
needle.source = this._findSourceIndex(needle.source); |
|
if (needle.source < 0) { |
|
return []; |
|
} |
|
var mappings = []; |
|
var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND); |
|
if (index >= 0) { |
|
var mapping = this._originalMappings[index]; |
|
if (aArgs.column === void 0) { |
|
var originalLine = mapping.originalLine; |
|
while (mapping && mapping.originalLine === originalLine) { |
|
mappings.push({ |
|
line: util.getArg(mapping, "generatedLine", null), |
|
column: util.getArg(mapping, "generatedColumn", null), |
|
lastColumn: util.getArg(mapping, "lastGeneratedColumn", null) |
|
}); |
|
mapping = this._originalMappings[++index]; |
|
} |
|
} else { |
|
var originalColumn = mapping.originalColumn; |
|
while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) { |
|
mappings.push({ |
|
line: util.getArg(mapping, "generatedLine", null), |
|
column: util.getArg(mapping, "generatedColumn", null), |
|
lastColumn: util.getArg(mapping, "lastGeneratedColumn", null) |
|
}); |
|
mapping = this._originalMappings[++index]; |
|
} |
|
} |
|
} |
|
return mappings; |
|
}; |
|
exports.SourceMapConsumer = SourceMapConsumer2; |
|
function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) { |
|
var sourceMap = aSourceMap; |
|
if (typeof aSourceMap === "string") { |
|
sourceMap = util.parseSourceMapInput(aSourceMap); |
|
} |
|
var version = util.getArg(sourceMap, "version"); |
|
var sources = util.getArg(sourceMap, "sources"); |
|
var names = util.getArg(sourceMap, "names", []); |
|
var sourceRoot = util.getArg(sourceMap, "sourceRoot", null); |
|
var sourcesContent = util.getArg(sourceMap, "sourcesContent", null); |
|
var mappings = util.getArg(sourceMap, "mappings"); |
|
var file = util.getArg(sourceMap, "file", null); |
|
if (version != this._version) { |
|
throw new Error("Unsupported version: " + version); |
|
} |
|
if (sourceRoot) { |
|
sourceRoot = util.normalize(sourceRoot); |
|
} |
|
sources = sources.map(String).map(util.normalize).map(function(source) { |
|
return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source; |
|
}); |
|
this._names = ArraySet.fromArray(names.map(String), true); |
|
this._sources = ArraySet.fromArray(sources, true); |
|
this._absoluteSources = this._sources.toArray().map(function(s) { |
|
return util.computeSourceURL(sourceRoot, s, aSourceMapURL); |
|
}); |
|
this.sourceRoot = sourceRoot; |
|
this.sourcesContent = sourcesContent; |
|
this._mappings = mappings; |
|
this._sourceMapURL = aSourceMapURL; |
|
this.file = file; |
|
} |
|
BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer2.prototype); |
|
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer2; |
|
BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) { |
|
var relativeSource = aSource; |
|
if (this.sourceRoot != null) { |
|
relativeSource = util.relative(this.sourceRoot, relativeSource); |
|
} |
|
if (this._sources.has(relativeSource)) { |
|
return this._sources.indexOf(relativeSource); |
|
} |
|
var i; |
|
for (i = 0; i < this._absoluteSources.length; ++i) { |
|
if (this._absoluteSources[i] == aSource) { |
|
return i; |
|
} |
|
} |
|
return -1; |
|
}; |
|
BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) { |
|
var smc = Object.create(BasicSourceMapConsumer.prototype); |
|
var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true); |
|
var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true); |
|
smc.sourceRoot = aSourceMap._sourceRoot; |
|
smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot); |
|
smc.file = aSourceMap._file; |
|
smc._sourceMapURL = aSourceMapURL; |
|
smc._absoluteSources = smc._sources.toArray().map(function(s) { |
|
return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL); |
|
}); |
|
var generatedMappings = aSourceMap._mappings.toArray().slice(); |
|
var destGeneratedMappings = smc.__generatedMappings = []; |
|
var destOriginalMappings = smc.__originalMappings = []; |
|
for (var i = 0, length = generatedMappings.length; i < length; i++) { |
|
var srcMapping = generatedMappings[i]; |
|
var destMapping = new Mapping(); |
|
destMapping.generatedLine = srcMapping.generatedLine; |
|
destMapping.generatedColumn = srcMapping.generatedColumn; |
|
if (srcMapping.source) { |
|
destMapping.source = sources.indexOf(srcMapping.source); |
|
destMapping.originalLine = srcMapping.originalLine; |
|
destMapping.originalColumn = srcMapping.originalColumn; |
|
if (srcMapping.name) { |
|
destMapping.name = names.indexOf(srcMapping.name); |
|
} |
|
destOriginalMappings.push(destMapping); |
|
} |
|
destGeneratedMappings.push(destMapping); |
|
} |
|
quickSort(smc.__originalMappings, util.compareByOriginalPositions); |
|
return smc; |
|
}; |
|
BasicSourceMapConsumer.prototype._version = 3; |
|
Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", { |
|
get: function() { |
|
return this._absoluteSources.slice(); |
|
} |
|
}); |
|
function Mapping() { |
|
this.generatedLine = 0; |
|
this.generatedColumn = 0; |
|
this.source = null; |
|
this.originalLine = null; |
|
this.originalColumn = null; |
|
this.name = null; |
|
} |
|
BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) { |
|
var generatedLine = 1; |
|
var previousGeneratedColumn = 0; |
|
var previousOriginalLine = 0; |
|
var previousOriginalColumn = 0; |
|
var previousSource = 0; |
|
var previousName = 0; |
|
var length = aStr.length; |
|
var index = 0; |
|
var cachedSegments = {}; |
|
var temp = {}; |
|
var originalMappings = []; |
|
var generatedMappings = []; |
|
var mapping, str, segment, end, value; |
|
while (index < length) { |
|
if (aStr.charAt(index) === ";") { |
|
generatedLine++; |
|
index++; |
|
previousGeneratedColumn = 0; |
|
} else if (aStr.charAt(index) === ",") { |
|
index++; |
|
} else { |
|
mapping = new Mapping(); |
|
mapping.generatedLine = generatedLine; |
|
for (end = index; end < length; end++) { |
|
if (this._charIsMappingSeparator(aStr, end)) { |
|
break; |
|
} |
|
} |
|
str = aStr.slice(index, end); |
|
segment = cachedSegments[str]; |
|
if (segment) { |
|
index += str.length; |
|
} else { |
|
segment = []; |
|
while (index < end) { |
|
base64VLQ.decode(aStr, index, temp); |
|
value = temp.value; |
|
index = temp.rest; |
|
segment.push(value); |
|
} |
|
if (segment.length === 2) { |
|
throw new Error("Found a source, but no line and column"); |
|
} |
|
if (segment.length === 3) { |
|
throw new Error("Found a source and line, but no column"); |
|
} |
|
cachedSegments[str] = segment; |
|
} |
|
mapping.generatedColumn = previousGeneratedColumn + segment[0]; |
|
previousGeneratedColumn = mapping.generatedColumn; |
|
if (segment.length > 1) { |
|
mapping.source = previousSource + segment[1]; |
|
previousSource += segment[1]; |
|
mapping.originalLine = previousOriginalLine + segment[2]; |
|
previousOriginalLine = mapping.originalLine; |
|
mapping.originalLine += 1; |
|
mapping.originalColumn = previousOriginalColumn + segment[3]; |
|
previousOriginalColumn = mapping.originalColumn; |
|
if (segment.length > 4) { |
|
mapping.name = previousName + segment[4]; |
|
previousName += segment[4]; |
|
} |
|
} |
|
generatedMappings.push(mapping); |
|
if (typeof mapping.originalLine === "number") { |
|
originalMappings.push(mapping); |
|
} |
|
} |
|
} |
|
quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated); |
|
this.__generatedMappings = generatedMappings; |
|
quickSort(originalMappings, util.compareByOriginalPositions); |
|
this.__originalMappings = originalMappings; |
|
}; |
|
BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) { |
|
if (aNeedle[aLineName] <= 0) { |
|
throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]); |
|
} |
|
if (aNeedle[aColumnName] < 0) { |
|
throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]); |
|
} |
|
return binarySearch.search(aNeedle, aMappings, aComparator, aBias); |
|
}; |
|
BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() { |
|
for (var index = 0; index < this._generatedMappings.length; ++index) { |
|
var mapping = this._generatedMappings[index]; |
|
if (index + 1 < this._generatedMappings.length) { |
|
var nextMapping = this._generatedMappings[index + 1]; |
|
if (mapping.generatedLine === nextMapping.generatedLine) { |
|
mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1; |
|
continue; |
|
} |
|
} |
|
mapping.lastGeneratedColumn = Infinity; |
|
} |
|
}; |
|
BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) { |
|
var needle = { |
|
generatedLine: util.getArg(aArgs, "line"), |
|
generatedColumn: util.getArg(aArgs, "column") |
|
}; |
|
var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer2.GREATEST_LOWER_BOUND)); |
|
if (index >= 0) { |
|
var mapping = this._generatedMappings[index]; |
|
if (mapping.generatedLine === needle.generatedLine) { |
|
var source = util.getArg(mapping, "source", null); |
|
if (source !== null) { |
|
source = this._sources.at(source); |
|
source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL); |
|
} |
|
var name = util.getArg(mapping, "name", null); |
|
if (name !== null) { |
|
name = this._names.at(name); |
|
} |
|
return { |
|
source, |
|
line: util.getArg(mapping, "originalLine", null), |
|
column: util.getArg(mapping, "originalColumn", null), |
|
name |
|
}; |
|
} |
|
} |
|
return { |
|
source: null, |
|
line: null, |
|
column: null, |
|
name: null |
|
}; |
|
}; |
|
BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() { |
|
if (!this.sourcesContent) { |
|
return false; |
|
} |
|
return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) { |
|
return sc == null; |
|
}); |
|
}; |
|
BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) { |
|
if (!this.sourcesContent) { |
|
return null; |
|
} |
|
var index = this._findSourceIndex(aSource); |
|
if (index >= 0) { |
|
return this.sourcesContent[index]; |
|
} |
|
var relativeSource = aSource; |
|
if (this.sourceRoot != null) { |
|
relativeSource = util.relative(this.sourceRoot, relativeSource); |
|
} |
|
var url; |
|
if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) { |
|
var fileUriAbsPath = relativeSource.replace(/^file:\/\//, ""); |
|
if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) { |
|
return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]; |
|
} |
|
if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) { |
|
return this.sourcesContent[this._sources.indexOf("/" + relativeSource)]; |
|
} |
|
} |
|
if (nullOnMissing) { |
|
return null; |
|
} else { |
|
throw new Error('"' + relativeSource + '" is not in the SourceMap.'); |
|
} |
|
}; |
|
BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) { |
|
var source = util.getArg(aArgs, "source"); |
|
source = this._findSourceIndex(source); |
|
if (source < 0) { |
|
return { |
|
line: null, |
|
column: null, |
|
lastColumn: null |
|
}; |
|
} |
|
var needle = { |
|
source, |
|
originalLine: util.getArg(aArgs, "line"), |
|
originalColumn: util.getArg(aArgs, "column") |
|
}; |
|
var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer2.GREATEST_LOWER_BOUND)); |
|
if (index >= 0) { |
|
var mapping = this._originalMappings[index]; |
|
if (mapping.source === needle.source) { |
|
return { |
|
line: util.getArg(mapping, "generatedLine", null), |
|
column: util.getArg(mapping, "generatedColumn", null), |
|
lastColumn: util.getArg(mapping, "lastGeneratedColumn", null) |
|
}; |
|
} |
|
} |
|
return { |
|
line: null, |
|
column: null, |
|
lastColumn: null |
|
}; |
|
}; |
|
exports.BasicSourceMapConsumer = BasicSourceMapConsumer; |
|
function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) { |
|
var sourceMap = aSourceMap; |
|
if (typeof aSourceMap === "string") { |
|
sourceMap = util.parseSourceMapInput(aSourceMap); |
|
} |
|
var version = util.getArg(sourceMap, "version"); |
|
var sections = util.getArg(sourceMap, "sections"); |
|
if (version != this._version) { |
|
throw new Error("Unsupported version: " + version); |
|
} |
|
this._sources = new ArraySet(); |
|
this._names = new ArraySet(); |
|
var lastOffset = { |
|
line: -1, |
|
column: 0 |
|
}; |
|
this._sections = sections.map(function(s) { |
|
if (s.url) { |
|
throw new Error("Support for url field in sections not implemented."); |
|
} |
|
var offset = util.getArg(s, "offset"); |
|
var offsetLine = util.getArg(offset, "line"); |
|
var offsetColumn = util.getArg(offset, "column"); |
|
if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) { |
|
throw new Error("Section offsets must be ordered and non-overlapping."); |
|
} |
|
lastOffset = offset; |
|
return { |
|
generatedOffset: { |
|
generatedLine: offsetLine + 1, |
|
generatedColumn: offsetColumn + 1 |
|
}, |
|
consumer: new SourceMapConsumer2(util.getArg(s, "map"), aSourceMapURL) |
|
}; |
|
}); |
|
} |
|
IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer2.prototype); |
|
IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer2; |
|
IndexedSourceMapConsumer.prototype._version = 3; |
|
Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", { |
|
get: function() { |
|
var sources = []; |
|
for (var i = 0; i < this._sections.length; i++) { |
|
for (var j = 0; j < this._sections[i].consumer.sources.length; j++) { |
|
sources.push(this._sections[i].consumer.sources[j]); |
|
} |
|
} |
|
return sources; |
|
} |
|
}); |
|
IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) { |
|
var needle = { |
|
generatedLine: util.getArg(aArgs, "line"), |
|
generatedColumn: util.getArg(aArgs, "column") |
|
}; |
|
var sectionIndex = binarySearch.search(needle, this._sections, function(needle2, section2) { |
|
var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine; |
|
if (cmp) { |
|
return cmp; |
|
} |
|
return needle2.generatedColumn - section2.generatedOffset.generatedColumn; |
|
}); |
|
var section = this._sections[sectionIndex]; |
|
if (!section) { |
|
return { |
|
source: null, |
|
line: null, |
|
column: null, |
|
name: null |
|
}; |
|
} |
|
return section.consumer.originalPositionFor({ |
|
line: needle.generatedLine - (section.generatedOffset.generatedLine - 1), |
|
column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0), |
|
bias: aArgs.bias |
|
}); |
|
}; |
|
IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() { |
|
return this._sections.every(function(s) { |
|
return s.consumer.hasContentsOfAllSources(); |
|
}); |
|
}; |
|
IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) { |
|
for (var i = 0; i < this._sections.length; i++) { |
|
var section = this._sections[i]; |
|
var content = section.consumer.sourceContentFor(aSource, true); |
|
if (content) { |
|
return content; |
|
} |
|
} |
|
if (nullOnMissing) { |
|
return null; |
|
} else { |
|
throw new Error('"' + aSource + '" is not in the SourceMap.'); |
|
} |
|
}; |
|
IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) { |
|
for (var i = 0; i < this._sections.length; i++) { |
|
var section = this._sections[i]; |
|
if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) { |
|
continue; |
|
} |
|
var generatedPosition = section.consumer.generatedPositionFor(aArgs); |
|
if (generatedPosition) { |
|
var ret = { |
|
line: generatedPosition.line + (section.generatedOffset.generatedLine - 1), |
|
column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0) |
|
}; |
|
return ret; |
|
} |
|
} |
|
return { |
|
line: null, |
|
column: null |
|
}; |
|
}; |
|
IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) { |
|
this.__generatedMappings = []; |
|
this.__originalMappings = []; |
|
for (var i = 0; i < this._sections.length; i++) { |
|
var section = this._sections[i]; |
|
var sectionMappings = section.consumer._generatedMappings; |
|
for (var j = 0; j < sectionMappings.length; j++) { |
|
var mapping = sectionMappings[j]; |
|
var source = section.consumer._sources.at(mapping.source); |
|
source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL); |
|
this._sources.add(source); |
|
source = this._sources.indexOf(source); |
|
var name = null; |
|
if (mapping.name) { |
|
name = section.consumer._names.at(mapping.name); |
|
this._names.add(name); |
|
name = this._names.indexOf(name); |
|
} |
|
var adjustedMapping = { |
|
source, |
|
generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1), |
|
generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0), |
|
originalLine: mapping.originalLine, |
|
originalColumn: mapping.originalColumn, |
|
name |
|
}; |
|
this.__generatedMappings.push(adjustedMapping); |
|
if (typeof adjustedMapping.originalLine === "number") { |
|
this.__originalMappings.push(adjustedMapping); |
|
} |
|
} |
|
} |
|
quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated); |
|
quickSort(this.__originalMappings, util.compareByOriginalPositions); |
|
}; |
|
exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-node.js |
|
var require_source_node = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-node.js"(exports) { |
|
var SourceMapGenerator2 = require_source_map_generator().SourceMapGenerator; |
|
var util = require_util(); |
|
var REGEX_NEWLINE = /(\r?\n)/; |
|
var NEWLINE_CODE = 10; |
|
var isSourceNode = "$$$isSourceNode$$$"; |
|
function SourceNode(aLine, aColumn, aSource, aChunks, aName) { |
|
this.children = []; |
|
this.sourceContents = {}; |
|
this.line = aLine == null ? null : aLine; |
|
this.column = aColumn == null ? null : aColumn; |
|
this.source = aSource == null ? null : aSource; |
|
this.name = aName == null ? null : aName; |
|
this[isSourceNode] = true; |
|
if (aChunks != null) |
|
this.add(aChunks); |
|
} |
|
SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) { |
|
var node = new SourceNode(); |
|
var remainingLines = aGeneratedCode.split(REGEX_NEWLINE); |
|
var remainingLinesIndex = 0; |
|
var shiftNextLine = function() { |
|
var lineContents = getNextLine(); |
|
var newLine = getNextLine() || ""; |
|
return lineContents + newLine; |
|
function getNextLine() { |
|
return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0; |
|
} |
|
}; |
|
var lastGeneratedLine = 1, lastGeneratedColumn = 0; |
|
var lastMapping = null; |
|
aSourceMapConsumer.eachMapping(function(mapping) { |
|
if (lastMapping !== null) { |
|
if (lastGeneratedLine < mapping.generatedLine) { |
|
addMappingWithCode(lastMapping, shiftNextLine()); |
|
lastGeneratedLine++; |
|
lastGeneratedColumn = 0; |
|
} else { |
|
var nextLine = remainingLines[remainingLinesIndex] || ""; |
|
var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn); |
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn); |
|
lastGeneratedColumn = mapping.generatedColumn; |
|
addMappingWithCode(lastMapping, code); |
|
lastMapping = mapping; |
|
return; |
|
} |
|
} |
|
while (lastGeneratedLine < mapping.generatedLine) { |
|
node.add(shiftNextLine()); |
|
lastGeneratedLine++; |
|
} |
|
if (lastGeneratedColumn < mapping.generatedColumn) { |
|
var nextLine = remainingLines[remainingLinesIndex] || ""; |
|
node.add(nextLine.substr(0, mapping.generatedColumn)); |
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn); |
|
lastGeneratedColumn = mapping.generatedColumn; |
|
} |
|
lastMapping = mapping; |
|
}, this); |
|
if (remainingLinesIndex < remainingLines.length) { |
|
if (lastMapping) { |
|
addMappingWithCode(lastMapping, shiftNextLine()); |
|
} |
|
node.add(remainingLines.splice(remainingLinesIndex).join("")); |
|
} |
|
aSourceMapConsumer.sources.forEach(function(sourceFile) { |
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile); |
|
if (content != null) { |
|
if (aRelativePath != null) { |
|
sourceFile = util.join(aRelativePath, sourceFile); |
|
} |
|
node.setSourceContent(sourceFile, content); |
|
} |
|
}); |
|
return node; |
|
function addMappingWithCode(mapping, code) { |
|
if (mapping === null || mapping.source === void 0) { |
|
node.add(code); |
|
} else { |
|
var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source; |
|
node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name)); |
|
} |
|
} |
|
}; |
|
SourceNode.prototype.add = function SourceNode_add(aChunk) { |
|
if (Array.isArray(aChunk)) { |
|
aChunk.forEach(function(chunk) { |
|
this.add(chunk); |
|
}, this); |
|
} else if (aChunk[isSourceNode] || typeof aChunk === "string") { |
|
if (aChunk) { |
|
this.children.push(aChunk); |
|
} |
|
} else { |
|
throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk); |
|
} |
|
return this; |
|
}; |
|
SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) { |
|
if (Array.isArray(aChunk)) { |
|
for (var i = aChunk.length - 1; i >= 0; i--) { |
|
this.prepend(aChunk[i]); |
|
} |
|
} else if (aChunk[isSourceNode] || typeof aChunk === "string") { |
|
this.children.unshift(aChunk); |
|
} else { |
|
throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk); |
|
} |
|
return this; |
|
}; |
|
SourceNode.prototype.walk = function SourceNode_walk(aFn) { |
|
var chunk; |
|
for (var i = 0, len = this.children.length; i < len; i++) { |
|
chunk = this.children[i]; |
|
if (chunk[isSourceNode]) { |
|
chunk.walk(aFn); |
|
} else { |
|
if (chunk !== "") { |
|
aFn(chunk, { |
|
source: this.source, |
|
line: this.line, |
|
column: this.column, |
|
name: this.name |
|
}); |
|
} |
|
} |
|
} |
|
}; |
|
SourceNode.prototype.join = function SourceNode_join(aSep) { |
|
var newChildren; |
|
var i; |
|
var len = this.children.length; |
|
if (len > 0) { |
|
newChildren = []; |
|
for (i = 0; i < len - 1; i++) { |
|
newChildren.push(this.children[i]); |
|
newChildren.push(aSep); |
|
} |
|
newChildren.push(this.children[i]); |
|
this.children = newChildren; |
|
} |
|
return this; |
|
}; |
|
SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) { |
|
var lastChild = this.children[this.children.length - 1]; |
|
if (lastChild[isSourceNode]) { |
|
lastChild.replaceRight(aPattern, aReplacement); |
|
} else if (typeof lastChild === "string") { |
|
this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement); |
|
} else { |
|
this.children.push("".replace(aPattern, aReplacement)); |
|
} |
|
return this; |
|
}; |
|
SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) { |
|
this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent; |
|
}; |
|
SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) { |
|
for (var i = 0, len = this.children.length; i < len; i++) { |
|
if (this.children[i][isSourceNode]) { |
|
this.children[i].walkSourceContents(aFn); |
|
} |
|
} |
|
var sources = Object.keys(this.sourceContents); |
|
for (var i = 0, len = sources.length; i < len; i++) { |
|
aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]); |
|
} |
|
}; |
|
SourceNode.prototype.toString = function SourceNode_toString() { |
|
var str = ""; |
|
this.walk(function(chunk) { |
|
str += chunk; |
|
}); |
|
return str; |
|
}; |
|
SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) { |
|
var generated = { |
|
code: "", |
|
line: 1, |
|
column: 0 |
|
}; |
|
var map = new SourceMapGenerator2(aArgs); |
|
var sourceMappingActive = false; |
|
var lastOriginalSource = null; |
|
var lastOriginalLine = null; |
|
var lastOriginalColumn = null; |
|
var lastOriginalName = null; |
|
this.walk(function(chunk, original) { |
|
generated.code += chunk; |
|
if (original.source !== null && original.line !== null && original.column !== null) { |
|
if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) { |
|
map.addMapping({ |
|
source: original.source, |
|
original: { |
|
line: original.line, |
|
column: original.column |
|
}, |
|
generated: { |
|
line: generated.line, |
|
column: generated.column |
|
}, |
|
name: original.name |
|
}); |
|
} |
|
lastOriginalSource = original.source; |
|
lastOriginalLine = original.line; |
|
lastOriginalColumn = original.column; |
|
lastOriginalName = original.name; |
|
sourceMappingActive = true; |
|
} else if (sourceMappingActive) { |
|
map.addMapping({ |
|
generated: { |
|
line: generated.line, |
|
column: generated.column |
|
} |
|
}); |
|
lastOriginalSource = null; |
|
sourceMappingActive = false; |
|
} |
|
for (var idx = 0, length = chunk.length; idx < length; idx++) { |
|
if (chunk.charCodeAt(idx) === NEWLINE_CODE) { |
|
generated.line++; |
|
generated.column = 0; |
|
if (idx + 1 === length) { |
|
lastOriginalSource = null; |
|
sourceMappingActive = false; |
|
} else if (sourceMappingActive) { |
|
map.addMapping({ |
|
source: original.source, |
|
original: { |
|
line: original.line, |
|
column: original.column |
|
}, |
|
generated: { |
|
line: generated.line, |
|
column: generated.column |
|
}, |
|
name: original.name |
|
}); |
|
} |
|
} else { |
|
generated.column++; |
|
} |
|
} |
|
}); |
|
this.walkSourceContents(function(sourceFile, sourceContent) { |
|
map.setSourceContent(sourceFile, sourceContent); |
|
}); |
|
return { code: generated.code, map }; |
|
}; |
|
exports.SourceNode = SourceNode; |
|
} |
|
}); |
|
|
|
// ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/source-map.js |
|
var require_source_map = __commonJS({ |
|
"../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/source-map.js"(exports) { |
|
exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator; |
|
exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer; |
|
exports.SourceNode = require_source_node().SourceNode; |
|
} |
|
}); |
|
|
|
// src/index.ts |
|
var src_exports = {}; |
|
__export(src_exports, { |
|
default: () => vuePlugin, |
|
parseVueRequest: () => parseVueRequest |
|
}); |
|
module.exports = vuePlugin; |
|
vuePlugin['default'] = vuePlugin; |
|
var import_fs2 = __toESM(require("fs")); |
|
|
|
// ../../node_modules/.pnpm/@rollup+pluginutils@4.2.1/node_modules/@rollup/pluginutils/dist/es/index.js |
|
var import_path = require("path"); |
|
var import_picomatch = __toESM(require_picomatch2(), 1); |
|
function isArray(arg) { |
|
return Array.isArray(arg); |
|
} |
|
function ensureArray(thing) { |
|
if (isArray(thing)) |
|
return thing; |
|
if (thing == null) |
|
return []; |
|
return [thing]; |
|
} |
|
var normalizePath = function normalizePath2(filename) { |
|
return filename.split(import_path.win32.sep).join(import_path.posix.sep); |
|
}; |
|
function getMatcherString(id, resolutionBase) { |
|
if (resolutionBase === false || (0, import_path.isAbsolute)(id) || id.startsWith("*")) { |
|
return normalizePath(id); |
|
} |
|
const basePath = normalizePath((0, import_path.resolve)(resolutionBase || "")).replace(/[-^$*+?.()|[\]{}]/g, "\\$&"); |
|
return import_path.posix.join(basePath, normalizePath(id)); |
|
} |
|
var createFilter = function createFilter2(include, exclude, options) { |
|
const resolutionBase = options && options.resolve; |
|
const getMatcher = (id) => id instanceof RegExp ? id : { |
|
test: (what) => { |
|
const pattern = getMatcherString(id, resolutionBase); |
|
const fn = (0, import_picomatch.default)(pattern, { dot: true }); |
|
const result = fn(what); |
|
return result; |
|
} |
|
}; |
|
const includeMatchers = ensureArray(include).map(getMatcher); |
|
const excludeMatchers = ensureArray(exclude).map(getMatcher); |
|
return function result(id) { |
|
if (typeof id !== "string") |
|
return false; |
|
if (/\0/.test(id)) |
|
return false; |
|
const pathId = normalizePath(id); |
|
for (let i = 0; i < excludeMatchers.length; ++i) { |
|
const matcher = excludeMatchers[i]; |
|
if (matcher.test(pathId)) |
|
return false; |
|
} |
|
for (let i = 0; i < includeMatchers.length; ++i) { |
|
const matcher = includeMatchers[i]; |
|
if (matcher.test(pathId)) |
|
return true; |
|
} |
|
return !includeMatchers.length; |
|
}; |
|
}; |
|
var reservedWords = "break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public"; |
|
var builtins = "arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl"; |
|
var forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(" ")); |
|
forbiddenIdentifiers.add(""); |
|
|
|
// src/compiler.ts |
|
function resolveCompiler(root) { |
|
const compiler = tryRequire("vue/compiler-sfc", root) || tryRequire("vue/compiler-sfc"); |
|
if (!compiler) { |
|
throw new Error(`Failed to resolve vue/compiler-sfc. |
|
@vitejs/plugin-vue requires vue (>=3.2.25) to be present in the dependency tree.`); |
|
} |
|
return compiler; |
|
} |
|
function tryRequire(id, from) { |
|
try { |
|
return from ? require(require.resolve(id, { paths: [from] })) : require(id); |
|
} catch (e) { |
|
} |
|
} |
|
|
|
// src/utils/query.ts |
|
function parseVueRequest(id) { |
|
const [filename, rawQuery] = id.split(`?`, 2); |
|
const query = Object.fromEntries(new URLSearchParams(rawQuery)); |
|
if (query.vue != null) { |
|
query.vue = true; |
|
} |
|
if (query.index != null) { |
|
query.index = Number(query.index); |
|
} |
|
if (query.raw != null) { |
|
query.raw = true; |
|
} |
|
return { |
|
filename, |
|
query |
|
}; |
|
} |
|
|
|
// src/utils/descriptorCache.ts |
|
var import_fs = __toESM(require("fs")); |
|
var import_path2 = __toESM(require("path")); |
|
|
|
// ../../node_modules/.pnpm/slash@4.0.0/node_modules/slash/index.js |
|
function slash(path4) { |
|
const isExtendedLengthPath = /^\\\\\?\\/.test(path4); |
|
const hasNonAscii = /[^\u0000-\u0080]+/.test(path4); |
|
if (isExtendedLengthPath || hasNonAscii) { |
|
return path4; |
|
} |
|
return path4.replace(/\\/g, "/"); |
|
} |
|
|
|
// src/utils/descriptorCache.ts |
|
var import_hash_sum = __toESM(require_hash_sum()); |
|
var cache = /* @__PURE__ */ new Map(); |
|
var prevCache = /* @__PURE__ */ new Map(); |
|
function createDescriptor(filename, source, { root, isProduction, sourceMap, compiler }) { |
|
const { descriptor, errors } = compiler.parse(source, { |
|
filename, |
|
sourceMap |
|
}); |
|
const normalizedPath = slash(import_path2.default.normalize(import_path2.default.relative(root, filename))); |
|
descriptor.id = (0, import_hash_sum.default)(normalizedPath + (isProduction ? source : "")); |
|
cache.set(filename, descriptor); |
|
return { descriptor, errors }; |
|
} |
|
function getPrevDescriptor(filename) { |
|
return prevCache.get(filename); |
|
} |
|
function setPrevDescriptor(filename, entry) { |
|
prevCache.set(filename, entry); |
|
} |
|
function getDescriptor(filename, options, createIfNotFound = true) { |
|
if (cache.has(filename)) { |
|
return cache.get(filename); |
|
} |
|
if (createIfNotFound) { |
|
const { descriptor, errors } = createDescriptor(filename, import_fs.default.readFileSync(filename, "utf-8"), options); |
|
if (errors.length) { |
|
throw errors[0]; |
|
} |
|
return descriptor; |
|
} |
|
} |
|
function getSrcDescriptor(filename, query) { |
|
return cache.get(`${filename}?src=${query.src}`); |
|
} |
|
function setSrcDescriptor(filename, entry) { |
|
cache.set(`${filename}?src=${entry.id}`, entry); |
|
} |
|
|
|
// src/template.ts |
|
var import_path3 = __toESM(require("path")); |
|
|
|
// src/utils/error.ts |
|
function createRollupError(id, error) { |
|
const { message, name, stack } = error; |
|
const rollupError = { |
|
id, |
|
plugin: "vue", |
|
message, |
|
name, |
|
stack |
|
}; |
|
if ("code" in error && error.loc) { |
|
rollupError.loc = { |
|
file: id, |
|
line: error.loc.start.line, |
|
column: error.loc.start.column |
|
}; |
|
} |
|
return rollupError; |
|
} |
|
|
|
// src/template.ts |
|
async function transformTemplateAsModule(code, descriptor, options, pluginContext, ssr) { |
|
const result = compile(code, descriptor, options, pluginContext, ssr); |
|
let returnCode = result.code; |
|
if (options.devServer && options.devServer.config.server.hmr !== false && !ssr && !options.isProduction) { |
|
returnCode += ` |
|
import.meta.hot.accept(({ render }) => { |
|
__VUE_HMR_RUNTIME__.rerender(${JSON.stringify(descriptor.id)}, render) |
|
})`; |
|
} |
|
return { |
|
code: returnCode, |
|
map: result.map |
|
}; |
|
} |
|
function transformTemplateInMain(code, descriptor, options, pluginContext, ssr) { |
|
const result = compile(code, descriptor, options, pluginContext, ssr); |
|
return __spreadProps(__spreadValues({}, result), { |
|
code: result.code.replace(/\nexport (function|const) (render|ssrRender)/, "\n$1 _sfc_$2") |
|
}); |
|
} |
|
function compile(code, descriptor, options, pluginContext, ssr) { |
|
const filename = descriptor.filename; |
|
const result = options.compiler.compileTemplate(__spreadProps(__spreadValues({}, resolveTemplateCompilerOptions(descriptor, options, ssr)), { |
|
source: code |
|
})); |
|
if (result.errors.length) { |
|
result.errors.forEach((error) => pluginContext.error(typeof error === "string" ? { id: filename, message: error } : createRollupError(filename, error))); |
|
} |
|
if (result.tips.length) { |
|
result.tips.forEach((tip) => pluginContext.warn({ |
|
id: filename, |
|
message: tip |
|
})); |
|
} |
|
return result; |
|
} |
|
function resolveTemplateCompilerOptions(descriptor, options, ssr) { |
|
var _a, _b, _c, _d, _e, _f, _g; |
|
const block = descriptor.template; |
|
if (!block) { |
|
return; |
|
} |
|
const resolvedScript = getResolvedScript(descriptor, ssr); |
|
const hasScoped = descriptor.styles.some((s) => s.scoped); |
|
const { id, filename, cssVars } = descriptor; |
|
let transformAssetUrls = (_a = options.template) == null ? void 0 : _a.transformAssetUrls; |
|
let assetUrlOptions; |
|
if (options.devServer) { |
|
if (filename.startsWith(options.root)) { |
|
assetUrlOptions = { |
|
base: options.devServer.config.base + slash(import_path3.default.relative(options.root, import_path3.default.dirname(filename))) |
|
}; |
|
} |
|
} else { |
|
assetUrlOptions = { |
|
includeAbsolute: true |
|
}; |
|
} |
|
if (transformAssetUrls && typeof transformAssetUrls === "object") { |
|
if (Object.values(transformAssetUrls).some((val) => Array.isArray(val))) { |
|
transformAssetUrls = __spreadProps(__spreadValues({}, assetUrlOptions), { |
|
tags: transformAssetUrls |
|
}); |
|
} else { |
|
transformAssetUrls = __spreadValues(__spreadValues({}, assetUrlOptions), transformAssetUrls); |
|
} |
|
} else { |
|
transformAssetUrls = assetUrlOptions; |
|
} |
|
let preprocessOptions = block.lang && ((_b = options.template) == null ? void 0 : _b.preprocessOptions); |
|
if (block.lang === "pug") { |
|
preprocessOptions = __spreadValues({ |
|
doctype: "html" |
|
}, preprocessOptions); |
|
} |
|
const expressionPlugins = ((_d = (_c = options.template) == null ? void 0 : _c.compilerOptions) == null ? void 0 : _d.expressionPlugins) || []; |
|
const lang = ((_e = descriptor.scriptSetup) == null ? void 0 : _e.lang) || ((_f = descriptor.script) == null ? void 0 : _f.lang); |
|
if (lang && /tsx?$/.test(lang) && !expressionPlugins.includes("typescript")) { |
|
expressionPlugins.push("typescript"); |
|
} |
|
return __spreadProps(__spreadValues({}, options.template), { |
|
id, |
|
filename, |
|
scoped: hasScoped, |
|
slotted: descriptor.slotted, |
|
isProd: options.isProduction, |
|
inMap: block.src ? void 0 : block.map, |
|
ssr, |
|
ssrCssVars: cssVars, |
|
transformAssetUrls, |
|
preprocessLang: block.lang, |
|
preprocessOptions, |
|
compilerOptions: __spreadProps(__spreadValues({}, (_g = options.template) == null ? void 0 : _g.compilerOptions), { |
|
scopeId: hasScoped ? `data-v-${id}` : void 0, |
|
bindingMetadata: resolvedScript ? resolvedScript.bindings : void 0, |
|
expressionPlugins, |
|
sourceMap: options.sourceMap |
|
}) |
|
}); |
|
} |
|
|
|
// src/script.ts |
|
var clientCache = /* @__PURE__ */ new WeakMap(); |
|
var ssrCache = /* @__PURE__ */ new WeakMap(); |
|
function getResolvedScript(descriptor, ssr) { |
|
return (ssr ? ssrCache : clientCache).get(descriptor); |
|
} |
|
function setResolvedScript(descriptor, script, ssr) { |
|
; |
|
(ssr ? ssrCache : clientCache).set(descriptor, script); |
|
} |
|
function isUseInlineTemplate(descriptor, isProd) { |
|
var _a; |
|
return isProd && !!descriptor.scriptSetup && !((_a = descriptor.template) == null ? void 0 : _a.src); |
|
} |
|
function resolveScript(descriptor, options, ssr) { |
|
if (!descriptor.script && !descriptor.scriptSetup) { |
|
return null; |
|
} |
|
const cacheToUse = ssr ? ssrCache : clientCache; |
|
const cached = cacheToUse.get(descriptor); |
|
if (cached) { |
|
return cached; |
|
} |
|
let resolved = null; |
|
resolved = options.compiler.compileScript(descriptor, __spreadProps(__spreadValues({}, options.script), { |
|
id: descriptor.id, |
|
isProd: options.isProduction, |
|
inlineTemplate: isUseInlineTemplate(descriptor, !options.devServer), |
|
reactivityTransform: options.reactivityTransform !== false, |
|
templateOptions: resolveTemplateCompilerOptions(descriptor, options, ssr), |
|
sourceMap: options.sourceMap |
|
})); |
|
cacheToUse.set(descriptor, resolved); |
|
return resolved; |
|
} |
|
|
|
// src/main.ts |
|
var import_path4 = __toESM(require("path")); |
|
|
|
// src/handleHotUpdate.ts |
|
var import_debug = __toESM(require_src()); |
|
var debug = (0, import_debug.default)("vite:hmr"); |
|
var directRequestRE = /(\?|&)direct\b/; |
|
async function handleHotUpdate({ file, modules, read, server }, options) { |
|
var _a, _b, _c, _d; |
|
const prevDescriptor = getDescriptor(file, options, false); |
|
if (!prevDescriptor) { |
|
return; |
|
} |
|
setPrevDescriptor(file, prevDescriptor); |
|
const content = await read(); |
|
const { descriptor } = createDescriptor(file, content, options); |
|
let needRerender = false; |
|
const affectedModules = /* @__PURE__ */ new Set(); |
|
const mainModule = modules.find((m) => !/type=/.test(m.url) || /type=script/.test(m.url)); |
|
const templateModule = modules.find((m) => /type=template/.test(m.url)); |
|
if (hasScriptChanged(prevDescriptor, descriptor)) { |
|
let scriptModule; |
|
if (((_a = descriptor.scriptSetup) == null ? void 0 : _a.lang) && !descriptor.scriptSetup.src || ((_b = descriptor.script) == null ? void 0 : _b.lang) && !descriptor.script.src) { |
|
const scriptModuleRE = new RegExp(`type=script.*&lang.${((_c = descriptor.scriptSetup) == null ? void 0 : _c.lang) || ((_d = descriptor.script) == null ? void 0 : _d.lang)}$`); |
|
scriptModule = modules.find((m) => scriptModuleRE.test(m.url)); |
|
} |
|
affectedModules.add(scriptModule || mainModule); |
|
} |
|
if (!isEqualBlock(descriptor.template, prevDescriptor.template)) { |
|
if (mainModule && !affectedModules.has(mainModule)) { |
|
setResolvedScript(descriptor, getResolvedScript(prevDescriptor, false), false); |
|
} |
|
affectedModules.add(templateModule); |
|
needRerender = true; |
|
} |
|
let didUpdateStyle = false; |
|
const prevStyles = prevDescriptor.styles || []; |
|
const nextStyles = descriptor.styles || []; |
|
if (prevDescriptor.cssVars.join("") !== descriptor.cssVars.join("")) { |
|
affectedModules.add(mainModule); |
|
} |
|
if (prevStyles.some((s) => s.scoped) !== nextStyles.some((s) => s.scoped)) { |
|
affectedModules.add(templateModule); |
|
affectedModules.add(mainModule); |
|
} |
|
for (let i = 0; i < nextStyles.length; i++) { |
|
const prev = prevStyles[i]; |
|
const next = nextStyles[i]; |
|
if (!prev || !isEqualBlock(prev, next)) { |
|
didUpdateStyle = true; |
|
const mod = modules.find((m) => m.url.includes(`type=style&index=${i}`) && m.url.endsWith(`.${next.lang || "css"}`) && !directRequestRE.test(m.url)); |
|
if (mod) { |
|
affectedModules.add(mod); |
|
if (mod.url.includes("&inline")) { |
|
affectedModules.add(mainModule); |
|
} |
|
} else { |
|
affectedModules.add(mainModule); |
|
} |
|
} |
|
} |
|
if (prevStyles.length > nextStyles.length) { |
|
affectedModules.add(mainModule); |
|
} |
|
const prevCustoms = prevDescriptor.customBlocks || []; |
|
const nextCustoms = descriptor.customBlocks || []; |
|
if (prevCustoms.length !== nextCustoms.length) { |
|
affectedModules.add(mainModule); |
|
} else { |
|
for (let i = 0; i < nextCustoms.length; i++) { |
|
const prev = prevCustoms[i]; |
|
const next = nextCustoms[i]; |
|
if (!prev || !isEqualBlock(prev, next)) { |
|
const mod = modules.find((m) => m.url.includes(`type=${prev.type}&index=${i}`)); |
|
if (mod) { |
|
affectedModules.add(mod); |
|
} else { |
|
affectedModules.add(mainModule); |
|
} |
|
} |
|
} |
|
} |
|
const updateType = []; |
|
if (needRerender) { |
|
updateType.push(`template`); |
|
if (!templateModule) { |
|
affectedModules.add(mainModule); |
|
} |
|
} |
|
if (didUpdateStyle) { |
|
updateType.push(`style`); |
|
} |
|
if (updateType.length) { |
|
debug(`[vue:update(${updateType.join("&")})] ${file}`); |
|
} |
|
return [...affectedModules].filter(Boolean); |
|
} |
|
function isEqualBlock(a, b) { |
|
if (!a && !b) |
|
return true; |
|
if (!a || !b) |
|
return false; |
|
if (a.src && b.src && a.src === b.src) |
|
return true; |
|
if (a.content !== b.content) |
|
return false; |
|
const keysA = Object.keys(a.attrs); |
|
const keysB = Object.keys(b.attrs); |
|
if (keysA.length !== keysB.length) { |
|
return false; |
|
} |
|
return keysA.every((key) => a.attrs[key] === b.attrs[key]); |
|
} |
|
function isOnlyTemplateChanged(prev, next) { |
|
return !hasScriptChanged(prev, next) && prev.styles.length === next.styles.length && prev.styles.every((s, i) => isEqualBlock(s, next.styles[i])) && prev.customBlocks.length === next.customBlocks.length && prev.customBlocks.every((s, i) => isEqualBlock(s, next.customBlocks[i])); |
|
} |
|
function hasScriptChanged(prev, next) { |
|
if (!isEqualBlock(prev.script, next.script)) { |
|
return true; |
|
} |
|
if (!isEqualBlock(prev.scriptSetup, next.scriptSetup)) { |
|
return true; |
|
} |
|
const prevResolvedScript = getResolvedScript(prev, false); |
|
const prevImports = prevResolvedScript == null ? void 0 : prevResolvedScript.imports; |
|
if (prevImports) { |
|
return next.shouldForceReload(prevImports); |
|
} |
|
return false; |
|
} |
|
|
|
// src/main.ts |
|
var import_source_map = __toESM(require_source_map()); |
|
var import_vite = require("vite"); |
|
|
|
// src/helper.ts |
|
var EXPORT_HELPER_ID = "plugin-vue:export-helper"; |
|
var helperCode = ` |
|
export default (sfc, props) => { |
|
const target = sfc.__vccOpts || sfc; |
|
for (const [key, val] of props) { |
|
target[key] = val; |
|
} |
|
return target; |
|
} |
|
`; |
|
|
|
// src/main.ts |
|
async function transformMain(code, filename, options, pluginContext, ssr, asCustomElement) { |
|
var _a, _b, _c, _d, _e, _f, _g; |
|
const { devServer, isProduction, devToolsEnabled } = options; |
|
const prevDescriptor = getPrevDescriptor(filename); |
|
const { descriptor, errors } = createDescriptor(filename, code, options); |
|
if (errors.length) { |
|
errors.forEach((error) => pluginContext.error(createRollupError(filename, error))); |
|
return null; |
|
} |
|
const attachedProps = []; |
|
const hasScoped = descriptor.styles.some((s) => s.scoped); |
|
const { code: scriptCode, map } = await genScriptCode(descriptor, options, pluginContext, ssr); |
|
const hasTemplateImport = descriptor.template && !isUseInlineTemplate(descriptor, !devServer); |
|
let templateCode = ""; |
|
let templateMap; |
|
if (hasTemplateImport) { |
|
; |
|
({ code: templateCode, map: templateMap } = await genTemplateCode(descriptor, options, pluginContext, ssr)); |
|
} |
|
if (hasTemplateImport) { |
|
attachedProps.push(ssr ? ["ssrRender", "_sfc_ssrRender"] : ["render", "_sfc_render"]); |
|
} else { |
|
if (prevDescriptor && !isEqualBlock(descriptor.template, prevDescriptor.template)) { |
|
attachedProps.push([ssr ? "ssrRender" : "render", "() => {}"]); |
|
} |
|
} |
|
const stylesCode = await genStyleCode(descriptor, pluginContext, asCustomElement, attachedProps); |
|
const customBlocksCode = await genCustomBlockCode(descriptor, pluginContext); |
|
const output = [ |
|
scriptCode, |
|
templateCode, |
|
stylesCode, |
|
customBlocksCode |
|
]; |
|
if (hasScoped) { |
|
attachedProps.push([`__scopeId`, JSON.stringify(`data-v-${descriptor.id}`)]); |
|
} |
|
if (devToolsEnabled || devServer && !isProduction) { |
|
attachedProps.push([ |
|
`__file`, |
|
JSON.stringify(isProduction ? import_path4.default.basename(filename) : filename) |
|
]); |
|
} |
|
if (devServer && devServer.config.server.hmr !== false && !ssr && !isProduction) { |
|
output.push(`_sfc_main.__hmrId = ${JSON.stringify(descriptor.id)}`); |
|
output.push(`typeof __VUE_HMR_RUNTIME__ !== 'undefined' && __VUE_HMR_RUNTIME__.createRecord(_sfc_main.__hmrId, _sfc_main)`); |
|
if (prevDescriptor && isOnlyTemplateChanged(prevDescriptor, descriptor)) { |
|
output.push(`export const _rerender_only = true`); |
|
} |
|
output.push(`import.meta.hot.accept(({ default: updated, _rerender_only }) => {`, ` if (_rerender_only) {`, ` __VUE_HMR_RUNTIME__.rerender(updated.__hmrId, updated.render)`, ` } else {`, ` __VUE_HMR_RUNTIME__.reload(updated.__hmrId, updated)`, ` }`, `})`); |
|
} |
|
if (ssr) { |
|
const normalizedFilename = normalizePath(import_path4.default.relative(options.root, filename)); |
|
output.push(`import { useSSRContext as __vite_useSSRContext } from 'vue'`, `const _sfc_setup = _sfc_main.setup`, `_sfc_main.setup = (props, ctx) => {`, ` const ssrContext = __vite_useSSRContext()`, ` ;(ssrContext.modules || (ssrContext.modules = new Set())).add(${JSON.stringify(normalizedFilename)})`, ` return _sfc_setup ? _sfc_setup(props, ctx) : undefined`, `}`); |
|
} |
|
let resolvedMap = options.sourceMap ? map : void 0; |
|
if (resolvedMap && templateMap) { |
|
const generator = import_source_map.SourceMapGenerator.fromSourceMap(new import_source_map.SourceMapConsumer(map)); |
|
const offset = ((_b = (_a = scriptCode.match(/\r?\n/g)) == null ? void 0 : _a.length) != null ? _b : 0) + 1; |
|
const templateMapConsumer = new import_source_map.SourceMapConsumer(templateMap); |
|
templateMapConsumer.eachMapping((m) => { |
|
generator.addMapping({ |
|
source: m.source, |
|
original: { line: m.originalLine, column: m.originalColumn }, |
|
generated: { |
|
line: m.generatedLine + offset, |
|
column: m.generatedColumn |
|
} |
|
}); |
|
}); |
|
resolvedMap = generator.toJSON(); |
|
resolvedMap.sourcesContent = templateMap.sourcesContent; |
|
} |
|
if (!attachedProps.length) { |
|
output.push(`export default _sfc_main`); |
|
} else { |
|
output.push(`import _export_sfc from '${EXPORT_HELPER_ID}'`, `export default /*#__PURE__*/_export_sfc(_sfc_main, [${attachedProps.map(([key, val]) => `['${key}',${val}]`).join(",")}])`); |
|
} |
|
let resolvedCode = output.join("\n"); |
|
if ((((_c = descriptor.script) == null ? void 0 : _c.lang) === "ts" || ((_d = descriptor.scriptSetup) == null ? void 0 : _d.lang) === "ts") && !((_e = descriptor.script) == null ? void 0 : _e.src)) { |
|
const { code: code2, map: map2 } = await (0, import_vite.transformWithEsbuild)(resolvedCode, filename, { loader: "ts", sourcemap: options.sourceMap }, resolvedMap); |
|
resolvedCode = code2; |
|
resolvedMap = resolvedMap ? map2 : resolvedMap; |
|
} |
|
return { |
|
code: resolvedCode, |
|
map: resolvedMap || { |
|
mappings: "" |
|
}, |
|
meta: { |
|
vite: { |
|
lang: ((_f = descriptor.script) == null ? void 0 : _f.lang) || ((_g = descriptor.scriptSetup) == null ? void 0 : _g.lang) || "js" |
|
} |
|
} |
|
}; |
|
} |
|
async function genTemplateCode(descriptor, options, pluginContext, ssr) { |
|
const template = descriptor.template; |
|
if (!template.lang && !template.src) { |
|
return transformTemplateInMain(template.content, descriptor, options, pluginContext, ssr); |
|
} else { |
|
if (template.src) { |
|
await linkSrcToDescriptor(template.src, descriptor, pluginContext); |
|
} |
|
const src = template.src || descriptor.filename; |
|
const srcQuery = template.src ? `&src=${descriptor.id}` : ``; |
|
const attrsQuery = attrsToQuery(template.attrs, "js", true); |
|
const query = `?vue&type=template${srcQuery}${attrsQuery}`; |
|
const request = JSON.stringify(src + query); |
|
const renderFnName = ssr ? "ssrRender" : "render"; |
|
return { |
|
code: `import { ${renderFnName} as _sfc_${renderFnName} } from ${request}`, |
|
map: void 0 |
|
}; |
|
} |
|
} |
|
async function genScriptCode(descriptor, options, pluginContext, ssr) { |
|
let scriptCode = `const _sfc_main = {}`; |
|
let map; |
|
const script = resolveScript(descriptor, options, ssr); |
|
if (script) { |
|
if ((!script.lang || script.lang === "ts") && !script.src) { |
|
scriptCode = options.compiler.rewriteDefault(script.content, "_sfc_main", script.lang === "ts" ? ["typescript"] : void 0); |
|
map = script.map; |
|
} else { |
|
if (script.src) { |
|
await linkSrcToDescriptor(script.src, descriptor, pluginContext); |
|
} |
|
const src = script.src || descriptor.filename; |
|
const langFallback = script.src && import_path4.default.extname(src).slice(1) || "js"; |
|
const attrsQuery = attrsToQuery(script.attrs, langFallback); |
|
const srcQuery = script.src ? `&src=${descriptor.id}` : ``; |
|
const query = `?vue&type=script${srcQuery}${attrsQuery}`; |
|
const request = JSON.stringify(src + query); |
|
scriptCode = `import _sfc_main from ${request} |
|
export * from ${request}`; |
|
} |
|
} |
|
return { |
|
code: scriptCode, |
|
map |
|
}; |
|
} |
|
async function genStyleCode(descriptor, pluginContext, asCustomElement, attachedProps) { |
|
let stylesCode = ``; |
|
let cssModulesMap; |
|
if (descriptor.styles.length) { |
|
for (let i = 0; i < descriptor.styles.length; i++) { |
|
const style = descriptor.styles[i]; |
|
if (style.src) { |
|
await linkSrcToDescriptor(style.src, descriptor, pluginContext); |
|
} |
|
const src = style.src || descriptor.filename; |
|
const attrsQuery = attrsToQuery(style.attrs, "css"); |
|
const srcQuery = style.src ? `&src=${descriptor.id}` : ``; |
|
const directQuery = asCustomElement ? `&inline` : ``; |
|
const query = `?vue&type=style&index=${i}${srcQuery}${directQuery}`; |
|
const styleRequest = src + query + attrsQuery; |
|
if (style.module) { |
|
if (asCustomElement) { |
|
throw new Error(`<style module> is not supported in custom elements mode.`); |
|
} |
|
const [importCode, nameMap] = genCSSModulesCode(i, styleRequest, style.module); |
|
stylesCode += importCode; |
|
Object.assign(cssModulesMap || (cssModulesMap = {}), nameMap); |
|
} else { |
|
if (asCustomElement) { |
|
stylesCode += ` |
|
import _style_${i} from ${JSON.stringify(styleRequest)}`; |
|
} else { |
|
stylesCode += ` |
|
import ${JSON.stringify(styleRequest)}`; |
|
} |
|
} |
|
} |
|
if (asCustomElement) { |
|
attachedProps.push([ |
|
`styles`, |
|
`[${descriptor.styles.map((_, i) => `_style_${i}`).join(",")}]` |
|
]); |
|
} |
|
} |
|
if (cssModulesMap) { |
|
const mappingCode = Object.entries(cssModulesMap).reduce((code, [key, value]) => code + `"${key}":${value}, |
|
`, "{\n") + "}"; |
|
stylesCode += ` |
|
const cssModules = ${mappingCode}`; |
|
attachedProps.push([`__cssModules`, `cssModules`]); |
|
} |
|
return stylesCode; |
|
} |
|
function genCSSModulesCode(index, request, moduleName) { |
|
const styleVar = `style${index}`; |
|
const exposedName = typeof moduleName === "string" ? moduleName : "$style"; |
|
const moduleRequest = request.replace(/\.(\w+)$/, ".module.$1"); |
|
return [ |
|
` |
|
import ${styleVar} from ${JSON.stringify(moduleRequest)}`, |
|
{ [exposedName]: styleVar } |
|
]; |
|
} |
|
async function genCustomBlockCode(descriptor, pluginContext) { |
|
let code = ""; |
|
for (let index = 0; index < descriptor.customBlocks.length; index++) { |
|
const block = descriptor.customBlocks[index]; |
|
if (block.src) { |
|
await linkSrcToDescriptor(block.src, descriptor, pluginContext); |
|
} |
|
const src = block.src || descriptor.filename; |
|
const attrsQuery = attrsToQuery(block.attrs, block.type); |
|
const srcQuery = block.src ? `&src` : ``; |
|
const query = `?vue&type=${block.type}&index=${index}${srcQuery}${attrsQuery}`; |
|
const request = JSON.stringify(src + query); |
|
code += `import block${index} from ${request} |
|
`; |
|
code += `if (typeof block${index} === 'function') block${index}(_sfc_main) |
|
`; |
|
} |
|
return code; |
|
} |
|
async function linkSrcToDescriptor(src, descriptor, pluginContext) { |
|
var _a; |
|
const srcFile = ((_a = await pluginContext.resolve(src, descriptor.filename)) == null ? void 0 : _a.id) || src; |
|
setSrcDescriptor(srcFile.replace(/\?.*$/, ""), descriptor); |
|
} |
|
var ignoreList = ["id", "index", "src", "type", "lang", "module"]; |
|
function attrsToQuery(attrs, langFallback, forceLangFallback = false) { |
|
let query = ``; |
|
for (const name in attrs) { |
|
const value = attrs[name]; |
|
if (!ignoreList.includes(name)) { |
|
query += `&${encodeURIComponent(name)}${value ? `=${encodeURIComponent(value)}` : ``}`; |
|
} |
|
} |
|
if (langFallback || attrs.lang) { |
|
query += `lang` in attrs ? forceLangFallback ? `&lang.${langFallback}` : `&lang.${attrs.lang}` : `&lang.${langFallback}`; |
|
} |
|
return query; |
|
} |
|
|
|
// src/style.ts |
|
var import_vite2 = require("vite"); |
|
async function transformStyle(code, descriptor, index, options, pluginContext, filename) { |
|
const block = descriptor.styles[index]; |
|
const result = await options.compiler.compileStyleAsync(__spreadValues(__spreadProps(__spreadValues({}, options.style), { |
|
filename: descriptor.filename, |
|
id: `data-v-${descriptor.id}`, |
|
isProd: options.isProduction, |
|
source: code, |
|
scoped: block.scoped |
|
}), options.cssDevSourcemap ? { |
|
postcssOptions: { |
|
map: { |
|
from: filename, |
|
inline: false, |
|
annotation: false |
|
} |
|
} |
|
} : {})); |
|
if (result.errors.length) { |
|
result.errors.forEach((error) => { |
|
if (error.line && error.column) { |
|
error.loc = { |
|
file: descriptor.filename, |
|
line: error.line + block.loc.start.line, |
|
column: error.column |
|
}; |
|
} |
|
pluginContext.error(error); |
|
}); |
|
return null; |
|
} |
|
const map = result.map ? (0, import_vite2.formatPostcssSourceMap)(result.map, filename) : { mappings: "" }; |
|
return { |
|
code: result.code, |
|
map |
|
}; |
|
} |
|
|
|
// src/index.ts |
|
function vuePlugin(rawOptions = {}) { |
|
const { |
|
include = /\.vue$/, |
|
exclude, |
|
customElement = /\.ce\.vue$/, |
|
reactivityTransform = false |
|
} = rawOptions; |
|
const filter = createFilter(include, exclude); |
|
const customElementFilter = typeof customElement === "boolean" ? () => customElement : createFilter(customElement); |
|
const refTransformFilter = reactivityTransform === false ? () => false : reactivityTransform === true ? createFilter(/\.(j|t)sx?$/, /node_modules/) : createFilter(reactivityTransform); |
|
let options = __spreadProps(__spreadValues({ |
|
isProduction: process.env.NODE_ENV === "production", |
|
compiler: null |
|
}, rawOptions), { |
|
include, |
|
exclude, |
|
customElement, |
|
reactivityTransform, |
|
root: process.cwd(), |
|
sourceMap: true, |
|
cssDevSourcemap: false, |
|
devToolsEnabled: process.env.NODE_ENV !== "production" |
|
}); |
|
const isSSR = (opt) => opt === void 0 ? false : typeof opt === "boolean" ? opt : (opt == null ? void 0 : opt.ssr) === true; |
|
return { |
|
name: "vite:vue", |
|
handleHotUpdate(ctx) { |
|
if (!filter(ctx.file)) { |
|
return; |
|
} |
|
return handleHotUpdate(ctx, options); |
|
}, |
|
config(config) { |
|
var _a, _b, _c, _d; |
|
return { |
|
define: { |
|
__VUE_OPTIONS_API__: (_b = (_a = config.define) == null ? void 0 : _a.__VUE_OPTIONS_API__) != null ? _b : true, |
|
__VUE_PROD_DEVTOOLS__: (_d = (_c = config.define) == null ? void 0 : _c.__VUE_PROD_DEVTOOLS__) != null ? _d : false |
|
}, |
|
ssr: { |
|
external: ["vue", "@vue/server-renderer"] |
|
} |
|
}; |
|
}, |
|
configResolved(config) { |
|
var _a, _b; |
|
options = __spreadProps(__spreadValues({}, options), { |
|
root: config.root, |
|
sourceMap: config.command === "build" ? !!config.build.sourcemap : true, |
|
cssDevSourcemap: (_b = (_a = config.css) == null ? void 0 : _a.devSourcemap) != null ? _b : false, |
|
isProduction: config.isProduction, |
|
devToolsEnabled: !!config.define.__VUE_PROD_DEVTOOLS__ || !config.isProduction |
|
}); |
|
}, |
|
configureServer(server) { |
|
options.devServer = server; |
|
}, |
|
buildStart() { |
|
options.compiler = options.compiler || resolveCompiler(options.root); |
|
}, |
|
async resolveId(id) { |
|
if (id === EXPORT_HELPER_ID) { |
|
return id; |
|
} |
|
if (parseVueRequest(id).query.vue) { |
|
return id; |
|
} |
|
}, |
|
load(id, opt) { |
|
const ssr = isSSR(opt); |
|
if (id === EXPORT_HELPER_ID) { |
|
return helperCode; |
|
} |
|
const { filename, query } = parseVueRequest(id); |
|
if (query.vue) { |
|
if (query.src) { |
|
return import_fs2.default.readFileSync(filename, "utf-8"); |
|
} |
|
const descriptor = getDescriptor(filename, options); |
|
let block; |
|
if (query.type === "script") { |
|
block = getResolvedScript(descriptor, ssr); |
|
} else if (query.type === "template") { |
|
block = descriptor.template; |
|
} else if (query.type === "style") { |
|
block = descriptor.styles[query.index]; |
|
} else if (query.index != null) { |
|
block = descriptor.customBlocks[query.index]; |
|
} |
|
if (block) { |
|
return { |
|
code: block.content, |
|
map: block.map |
|
}; |
|
} |
|
} |
|
}, |
|
transform(code, id, opt) { |
|
const ssr = isSSR(opt); |
|
const { filename, query } = parseVueRequest(id); |
|
if (query.raw) { |
|
return; |
|
} |
|
if (!filter(filename) && !query.vue) { |
|
if (!query.vue && refTransformFilter(filename) && options.compiler.shouldTransformRef(code)) { |
|
return options.compiler.transformRef(code, { |
|
filename, |
|
sourceMap: true |
|
}); |
|
} |
|
return; |
|
} |
|
if (!query.vue) { |
|
return transformMain(code, filename, options, this, ssr, customElementFilter(filename)); |
|
} else { |
|
const descriptor = query.src ? getSrcDescriptor(filename, query) : getDescriptor(filename, options); |
|
if (query.type === "template") { |
|
return transformTemplateAsModule(code, descriptor, options, this, ssr); |
|
} else if (query.type === "style") { |
|
return transformStyle(code, descriptor, Number(query.index), options, this, filename); |
|
} |
|
} |
|
} |
|
}; |
|
} |
|
// Annotate the CommonJS export names for ESM import in node: |
|
0 && (module.exports = { |
|
parseVueRequest |
|
});
|
|
|