1689 lines
54 KiB
JavaScript
1689 lines
54 KiB
JavaScript
//#region rolldown:runtime
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __commonJS = (cb, mod) => function() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
|
|
key = keys[i];
|
|
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
|
|
get: ((k) => from[k]).bind(null, 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));
|
|
|
|
//#endregion
|
|
let node_process = require("node:process");
|
|
node_process = __toESM(node_process);
|
|
let node_path = require("node:path");
|
|
node_path = __toESM(node_path);
|
|
let local_pkg = require("local-pkg");
|
|
local_pkg = __toESM(local_pkg);
|
|
|
|
//#region node_modules/.pnpm/@antfu+utils@9.3.0/node_modules/@antfu/utils/dist/index.mjs
|
|
function toArray(array) {
|
|
array = array ?? [];
|
|
return Array.isArray(array) ? array : [array];
|
|
}
|
|
function notNullish(v) {
|
|
return v != null;
|
|
}
|
|
function slash(str) {
|
|
return str.replace(/\\/g, "/");
|
|
}
|
|
const VOID = Symbol("p-void");
|
|
/**
|
|
* Throttle execution of a function. Especially useful for rate limiting
|
|
* execution of handlers on events like resize and scroll.
|
|
*
|
|
* @param {number} delay - A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
|
|
* are most useful.
|
|
* @param {Function} callback - A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
|
|
* as-is, to `callback` when the throttled-function is executed.
|
|
* @param {object} [options] - An object to configure options.
|
|
* @param {boolean} [options.noTrailing] - Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
|
|
* while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
|
|
* one final time after the last throttled-function call. (After the throttled-function has not been called for
|
|
* `delay` milliseconds, the internal counter is reset).
|
|
* @param {boolean} [options.noLeading] - Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
|
|
* immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
|
|
* callback will never executed if both noLeading = true and noTrailing = true.
|
|
* @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
|
|
* false (at end), schedule `callback` to execute after `delay` ms.
|
|
*
|
|
* @returns {Function} A new, throttled, function.
|
|
*/
|
|
function throttle$1(delay, callback, options) {
|
|
var _ref = options || {}, _ref$noTrailing = _ref.noTrailing, noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing, _ref$noLeading = _ref.noLeading, noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading, _ref$debounceMode = _ref.debounceMode, debounceMode = _ref$debounceMode === void 0 ? void 0 : _ref$debounceMode;
|
|
var timeoutID;
|
|
var cancelled = false;
|
|
var lastExec = 0;
|
|
function clearExistingTimeout() {
|
|
if (timeoutID) clearTimeout(timeoutID);
|
|
}
|
|
function cancel(options$1) {
|
|
var _ref2$upcomingOnly = (options$1 || {}).upcomingOnly, upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
|
|
clearExistingTimeout();
|
|
cancelled = !upcomingOnly;
|
|
}
|
|
function wrapper() {
|
|
for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) arguments_[_key] = arguments[_key];
|
|
var self = this;
|
|
var elapsed = Date.now() - lastExec;
|
|
if (cancelled) return;
|
|
function exec() {
|
|
lastExec = Date.now();
|
|
callback.apply(self, arguments_);
|
|
}
|
|
function clear() {
|
|
timeoutID = void 0;
|
|
}
|
|
if (!noLeading && debounceMode && !timeoutID) exec();
|
|
clearExistingTimeout();
|
|
if (debounceMode === void 0 && elapsed > delay) if (noLeading) {
|
|
lastExec = Date.now();
|
|
if (!noTrailing) timeoutID = setTimeout(debounceMode ? clear : exec, delay);
|
|
} else exec();
|
|
else if (noTrailing !== true) timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === void 0 ? delay - elapsed : delay);
|
|
}
|
|
wrapper.cancel = cancel;
|
|
return wrapper;
|
|
}
|
|
function throttle(...args) {
|
|
return throttle$1(...args);
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/core/constants.ts
|
|
const DISABLE_COMMENT = "/* unplugin-vue-components disabled */";
|
|
const DIRECTIVE_IMPORT_PREFIX = "v";
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
|
|
const balanced = (a, b, str) => {
|
|
const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
|
|
const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
|
|
const r = ma !== null && mb != null && range(ma, mb, str);
|
|
return r && {
|
|
start: r[0],
|
|
end: r[1],
|
|
pre: str.slice(0, r[0]),
|
|
body: str.slice(r[0] + ma.length, r[1]),
|
|
post: str.slice(r[1] + mb.length)
|
|
};
|
|
};
|
|
const maybeMatch = (reg, str) => {
|
|
const m = str.match(reg);
|
|
return m ? m[0] : null;
|
|
};
|
|
const range = (a, b, str) => {
|
|
let begs, beg, left, right = void 0, result;
|
|
let ai = str.indexOf(a);
|
|
let bi = str.indexOf(b, ai + 1);
|
|
let i = ai;
|
|
if (ai >= 0 && bi > 0) {
|
|
if (a === b) return [ai, bi];
|
|
begs = [];
|
|
left = str.length;
|
|
while (i >= 0 && !result) {
|
|
if (i === ai) {
|
|
begs.push(i);
|
|
ai = str.indexOf(a, i + 1);
|
|
} else if (begs.length === 1) {
|
|
const r = begs.pop();
|
|
if (r !== void 0) result = [r, bi];
|
|
} else {
|
|
beg = begs.pop();
|
|
if (beg !== void 0 && beg < left) {
|
|
left = beg;
|
|
right = bi;
|
|
}
|
|
bi = str.indexOf(b, i + 1);
|
|
}
|
|
i = ai < bi && ai >= 0 ? ai : bi;
|
|
}
|
|
if (begs.length && right !== void 0) result = [left, right];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/@isaacs+brace-expansion@5.0.0/node_modules/@isaacs/brace-expansion/dist/esm/index.js
|
|
const escSlash = "\0SLASH" + Math.random() + "\0";
|
|
const escOpen = "\0OPEN" + Math.random() + "\0";
|
|
const escClose = "\0CLOSE" + Math.random() + "\0";
|
|
const escComma = "\0COMMA" + Math.random() + "\0";
|
|
const escPeriod = "\0PERIOD" + Math.random() + "\0";
|
|
const escSlashPattern = new RegExp(escSlash, "g");
|
|
const escOpenPattern = new RegExp(escOpen, "g");
|
|
const escClosePattern = new RegExp(escClose, "g");
|
|
const escCommaPattern = new RegExp(escComma, "g");
|
|
const escPeriodPattern = new RegExp(escPeriod, "g");
|
|
const slashPattern = /\\\\/g;
|
|
const openPattern = /\\{/g;
|
|
const closePattern = /\\}/g;
|
|
const commaPattern = /\\,/g;
|
|
const periodPattern = /\\./g;
|
|
function numeric(str) {
|
|
return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
|
|
}
|
|
function escapeBraces(str) {
|
|
return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
|
|
}
|
|
function unescapeBraces(str) {
|
|
return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
|
|
}
|
|
/**
|
|
* Basically just str.split(","), but handling cases
|
|
* where we have nested braced sections, which should be
|
|
* treated as individual members, like {a,{b,c},d}
|
|
*/
|
|
function parseCommaParts(str) {
|
|
if (!str) return [""];
|
|
const parts = [];
|
|
const m = balanced("{", "}", str);
|
|
if (!m) return str.split(",");
|
|
const { pre, body, post } = m;
|
|
const p = pre.split(",");
|
|
p[p.length - 1] += "{" + body + "}";
|
|
const postParts = parseCommaParts(post);
|
|
if (post.length) {
|
|
p[p.length - 1] += postParts.shift();
|
|
p.push.apply(p, postParts);
|
|
}
|
|
parts.push.apply(parts, p);
|
|
return parts;
|
|
}
|
|
function expand(str) {
|
|
if (!str) return [];
|
|
if (str.slice(0, 2) === "{}") str = "\\{\\}" + str.slice(2);
|
|
return expand_(escapeBraces(str), true).map(unescapeBraces);
|
|
}
|
|
function embrace(str) {
|
|
return "{" + str + "}";
|
|
}
|
|
function isPadded(el) {
|
|
return /^-?0\d/.test(el);
|
|
}
|
|
function lte(i, y) {
|
|
return i <= y;
|
|
}
|
|
function gte(i, y) {
|
|
return i >= y;
|
|
}
|
|
function expand_(str, isTop) {
|
|
/** @type {string[]} */
|
|
const expansions = [];
|
|
const m = balanced("{", "}", str);
|
|
if (!m) return [str];
|
|
const pre = m.pre;
|
|
const post = m.post.length ? expand_(m.post, false) : [""];
|
|
if (/\$$/.test(m.pre)) for (let k = 0; k < post.length; k++) {
|
|
const expansion = pre + "{" + m.body + "}" + post[k];
|
|
expansions.push(expansion);
|
|
}
|
|
else {
|
|
const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
|
|
const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
|
|
const isSequence = isNumericSequence || isAlphaSequence;
|
|
const isOptions = m.body.indexOf(",") >= 0;
|
|
if (!isSequence && !isOptions) {
|
|
if (m.post.match(/,(?!,).*\}/)) {
|
|
str = m.pre + "{" + m.body + escClose + m.post;
|
|
return expand_(str);
|
|
}
|
|
return [str];
|
|
}
|
|
let n;
|
|
if (isSequence) n = m.body.split(/\.\./);
|
|
else {
|
|
n = parseCommaParts(m.body);
|
|
if (n.length === 1 && n[0] !== void 0) {
|
|
n = expand_(n[0], false).map(embrace);
|
|
/* c8 ignore start */
|
|
if (n.length === 1) return post.map((p) => m.pre + n[0] + p);
|
|
}
|
|
}
|
|
let N;
|
|
if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
|
|
const x = numeric(n[0]);
|
|
const y = numeric(n[1]);
|
|
const width = Math.max(n[0].length, n[1].length);
|
|
let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
|
|
let test = lte;
|
|
if (y < x) {
|
|
incr *= -1;
|
|
test = gte;
|
|
}
|
|
const pad = n.some(isPadded);
|
|
N = [];
|
|
for (let i = x; test(i, y); i += incr) {
|
|
let c;
|
|
if (isAlphaSequence) {
|
|
c = String.fromCharCode(i);
|
|
if (c === "\\") c = "";
|
|
} else {
|
|
c = String(i);
|
|
if (pad) {
|
|
const need = width - c.length;
|
|
if (need > 0) {
|
|
const z = new Array(need + 1).join("0");
|
|
if (i < 0) c = "-" + z + c.slice(1);
|
|
else c = z + c;
|
|
}
|
|
}
|
|
}
|
|
N.push(c);
|
|
}
|
|
} else {
|
|
N = [];
|
|
for (let j = 0; j < n.length; j++) N.push.apply(N, expand_(n[j], false));
|
|
}
|
|
for (let j = 0; j < N.length; j++) for (let k = 0; k < post.length; k++) {
|
|
const expansion = pre + N[j] + post[k];
|
|
if (!isTop || isSequence || expansion) expansions.push(expansion);
|
|
}
|
|
}
|
|
return expansions;
|
|
}
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/assert-valid-pattern.js
|
|
const MAX_PATTERN_LENGTH = 1024 * 64;
|
|
const assertValidPattern = (pattern) => {
|
|
if (typeof pattern !== "string") throw new TypeError("invalid pattern");
|
|
if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError("pattern is too long");
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/brace-expressions.js
|
|
const posixClasses = {
|
|
"[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
|
|
"[:alpha:]": ["\\p{L}\\p{Nl}", true],
|
|
"[:ascii:]": ["\\x00-\\x7f", false],
|
|
"[:blank:]": ["\\p{Zs}\\t", true],
|
|
"[:cntrl:]": ["\\p{Cc}", true],
|
|
"[:digit:]": ["\\p{Nd}", true],
|
|
"[:graph:]": [
|
|
"\\p{Z}\\p{C}",
|
|
true,
|
|
true
|
|
],
|
|
"[:lower:]": ["\\p{Ll}", true],
|
|
"[:print:]": ["\\p{C}", true],
|
|
"[:punct:]": ["\\p{P}", true],
|
|
"[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
|
|
"[:upper:]": ["\\p{Lu}", true],
|
|
"[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
|
|
"[:xdigit:]": ["A-Fa-f0-9", false]
|
|
};
|
|
const braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
|
|
const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
|
const rangesToString = (ranges) => ranges.join("");
|
|
const parseClass = (glob, position) => {
|
|
const pos = position;
|
|
/* c8 ignore start */
|
|
if (glob.charAt(pos) !== "[") throw new Error("not in a brace expression");
|
|
/* c8 ignore stop */
|
|
const ranges = [];
|
|
const negs = [];
|
|
let i = pos + 1;
|
|
let sawStart = false;
|
|
let uflag = false;
|
|
let escaping = false;
|
|
let negate = false;
|
|
let endPos = pos;
|
|
let rangeStart = "";
|
|
WHILE: while (i < glob.length) {
|
|
const c = glob.charAt(i);
|
|
if ((c === "!" || c === "^") && i === pos + 1) {
|
|
negate = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (c === "]" && sawStart && !escaping) {
|
|
endPos = i + 1;
|
|
break;
|
|
}
|
|
sawStart = true;
|
|
if (c === "\\") {
|
|
if (!escaping) {
|
|
escaping = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
}
|
|
if (c === "[" && !escaping) {
|
|
for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) if (glob.startsWith(cls, i)) {
|
|
if (rangeStart) return [
|
|
"$.",
|
|
false,
|
|
glob.length - pos,
|
|
true
|
|
];
|
|
i += cls.length;
|
|
if (neg) negs.push(unip);
|
|
else ranges.push(unip);
|
|
uflag = uflag || u;
|
|
continue WHILE;
|
|
}
|
|
}
|
|
escaping = false;
|
|
if (rangeStart) {
|
|
if (c > rangeStart) ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
|
|
else if (c === rangeStart) ranges.push(braceEscape(c));
|
|
rangeStart = "";
|
|
i++;
|
|
continue;
|
|
}
|
|
if (glob.startsWith("-]", i + 1)) {
|
|
ranges.push(braceEscape(c + "-"));
|
|
i += 2;
|
|
continue;
|
|
}
|
|
if (glob.startsWith("-", i + 1)) {
|
|
rangeStart = c;
|
|
i += 2;
|
|
continue;
|
|
}
|
|
ranges.push(braceEscape(c));
|
|
i++;
|
|
}
|
|
if (endPos < i) return [
|
|
"",
|
|
false,
|
|
0,
|
|
false
|
|
];
|
|
if (!ranges.length && !negs.length) return [
|
|
"$.",
|
|
false,
|
|
glob.length - pos,
|
|
true
|
|
];
|
|
if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) return [
|
|
regexpEscape(ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0]),
|
|
false,
|
|
endPos - pos,
|
|
false
|
|
];
|
|
const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
|
|
const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
|
|
return [
|
|
ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs,
|
|
uflag,
|
|
endPos - pos,
|
|
true
|
|
];
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/unescape.js
|
|
/**
|
|
* Un-escape a string that has been escaped with {@link escape}.
|
|
*
|
|
* If the {@link windowsPathsNoEscape} option is used, then square-brace
|
|
* escapes are removed, but not backslash escapes. For example, it will turn
|
|
* the string `'[*]'` into `*`, but it will not turn `'\\*'` into `'*'`,
|
|
* becuase `\` is a path separator in `windowsPathsNoEscape` mode.
|
|
*
|
|
* When `windowsPathsNoEscape` is not set, then both brace escapes and
|
|
* backslash escapes are removed.
|
|
*
|
|
* Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
|
|
* or unescaped.
|
|
*/
|
|
const unescape = (s, { windowsPathsNoEscape = false } = {}) => {
|
|
return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/ast.js
|
|
const types = new Set([
|
|
"!",
|
|
"?",
|
|
"+",
|
|
"*",
|
|
"@"
|
|
]);
|
|
const isExtglobType = (c) => types.has(c);
|
|
const startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
|
|
const startNoDot = "(?!\\.)";
|
|
const addPatternStart = new Set(["[", "."]);
|
|
const justDots = new Set(["..", "."]);
|
|
const reSpecials = /* @__PURE__ */ new Set("().*{}+?[]^$\\!");
|
|
const regExpEscape$1 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
|
const qmark = "[^/]";
|
|
const star$1 = qmark + "*?";
|
|
const starNoEmpty = qmark + "+?";
|
|
var AST = class AST {
|
|
type;
|
|
#root;
|
|
#hasMagic;
|
|
#uflag = false;
|
|
#parts = [];
|
|
#parent;
|
|
#parentIndex;
|
|
#negs;
|
|
#filledNegs = false;
|
|
#options;
|
|
#toString;
|
|
#emptyExt = false;
|
|
constructor(type, parent, options = {}) {
|
|
this.type = type;
|
|
if (type) this.#hasMagic = true;
|
|
this.#parent = parent;
|
|
this.#root = this.#parent ? this.#parent.#root : this;
|
|
this.#options = this.#root === this ? options : this.#root.#options;
|
|
this.#negs = this.#root === this ? [] : this.#root.#negs;
|
|
if (type === "!" && !this.#root.#filledNegs) this.#negs.push(this);
|
|
this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
|
|
}
|
|
get hasMagic() {
|
|
/* c8 ignore start */
|
|
if (this.#hasMagic !== void 0) return this.#hasMagic;
|
|
/* c8 ignore stop */
|
|
for (const p of this.#parts) {
|
|
if (typeof p === "string") continue;
|
|
if (p.type || p.hasMagic) return this.#hasMagic = true;
|
|
}
|
|
return this.#hasMagic;
|
|
}
|
|
toString() {
|
|
if (this.#toString !== void 0) return this.#toString;
|
|
if (!this.type) return this.#toString = this.#parts.map((p) => String(p)).join("");
|
|
else return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
|
|
}
|
|
#fillNegs() {
|
|
/* c8 ignore start */
|
|
if (this !== this.#root) throw new Error("should only call on root");
|
|
if (this.#filledNegs) return this;
|
|
/* c8 ignore stop */
|
|
this.toString();
|
|
this.#filledNegs = true;
|
|
let n;
|
|
while (n = this.#negs.pop()) {
|
|
if (n.type !== "!") continue;
|
|
let p = n;
|
|
let pp = p.#parent;
|
|
while (pp) {
|
|
for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) for (const part of n.#parts) {
|
|
/* c8 ignore start */
|
|
if (typeof part === "string") throw new Error("string part in extglob AST??");
|
|
/* c8 ignore stop */
|
|
part.copyIn(pp.#parts[i]);
|
|
}
|
|
p = pp;
|
|
pp = p.#parent;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
push(...parts) {
|
|
for (const p of parts) {
|
|
if (p === "") continue;
|
|
/* c8 ignore start */
|
|
if (typeof p !== "string" && !(p instanceof AST && p.#parent === this)) throw new Error("invalid part: " + p);
|
|
/* c8 ignore stop */
|
|
this.#parts.push(p);
|
|
}
|
|
}
|
|
toJSON() {
|
|
var _this$parent;
|
|
const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
|
|
if (this.isStart() && !this.type) ret.unshift([]);
|
|
if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && ((_this$parent = this.#parent) === null || _this$parent === void 0 ? void 0 : _this$parent.type) === "!")) ret.push({});
|
|
return ret;
|
|
}
|
|
isStart() {
|
|
var _this$parent2;
|
|
if (this.#root === this) return true;
|
|
if (!((_this$parent2 = this.#parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.isStart())) return false;
|
|
if (this.#parentIndex === 0) return true;
|
|
const p = this.#parent;
|
|
for (let i = 0; i < this.#parentIndex; i++) {
|
|
const pp = p.#parts[i];
|
|
if (!(pp instanceof AST && pp.type === "!")) return false;
|
|
}
|
|
return true;
|
|
}
|
|
isEnd() {
|
|
var _this$parent3, _this$parent4, _this$parent5;
|
|
if (this.#root === this) return true;
|
|
if (((_this$parent3 = this.#parent) === null || _this$parent3 === void 0 ? void 0 : _this$parent3.type) === "!") return true;
|
|
if (!((_this$parent4 = this.#parent) === null || _this$parent4 === void 0 ? void 0 : _this$parent4.isEnd())) return false;
|
|
if (!this.type) return (_this$parent5 = this.#parent) === null || _this$parent5 === void 0 ? void 0 : _this$parent5.isEnd();
|
|
/* c8 ignore start */
|
|
const pl = this.#parent ? this.#parent.#parts.length : 0;
|
|
/* c8 ignore stop */
|
|
return this.#parentIndex === pl - 1;
|
|
}
|
|
copyIn(part) {
|
|
if (typeof part === "string") this.push(part);
|
|
else this.push(part.clone(this));
|
|
}
|
|
clone(parent) {
|
|
const c = new AST(this.type, parent);
|
|
for (const p of this.#parts) c.copyIn(p);
|
|
return c;
|
|
}
|
|
static #parseAST(str, ast, pos, opt) {
|
|
let escaping = false;
|
|
let inBrace = false;
|
|
let braceStart = -1;
|
|
let braceNeg = false;
|
|
if (ast.type === null) {
|
|
let i$1 = pos;
|
|
let acc$1 = "";
|
|
while (i$1 < str.length) {
|
|
const c = str.charAt(i$1++);
|
|
if (escaping || c === "\\") {
|
|
escaping = !escaping;
|
|
acc$1 += c;
|
|
continue;
|
|
}
|
|
if (inBrace) {
|
|
if (i$1 === braceStart + 1) {
|
|
if (c === "^" || c === "!") braceNeg = true;
|
|
} else if (c === "]" && !(i$1 === braceStart + 2 && braceNeg)) inBrace = false;
|
|
acc$1 += c;
|
|
continue;
|
|
} else if (c === "[") {
|
|
inBrace = true;
|
|
braceStart = i$1;
|
|
braceNeg = false;
|
|
acc$1 += c;
|
|
continue;
|
|
}
|
|
if (!opt.noext && isExtglobType(c) && str.charAt(i$1) === "(") {
|
|
ast.push(acc$1);
|
|
acc$1 = "";
|
|
const ext$1 = new AST(c, ast);
|
|
i$1 = AST.#parseAST(str, ext$1, i$1, opt);
|
|
ast.push(ext$1);
|
|
continue;
|
|
}
|
|
acc$1 += c;
|
|
}
|
|
ast.push(acc$1);
|
|
return i$1;
|
|
}
|
|
let i = pos + 1;
|
|
let part = new AST(null, ast);
|
|
const parts = [];
|
|
let acc = "";
|
|
while (i < str.length) {
|
|
const c = str.charAt(i++);
|
|
if (escaping || c === "\\") {
|
|
escaping = !escaping;
|
|
acc += c;
|
|
continue;
|
|
}
|
|
if (inBrace) {
|
|
if (i === braceStart + 1) {
|
|
if (c === "^" || c === "!") braceNeg = true;
|
|
} else if (c === "]" && !(i === braceStart + 2 && braceNeg)) inBrace = false;
|
|
acc += c;
|
|
continue;
|
|
} else if (c === "[") {
|
|
inBrace = true;
|
|
braceStart = i;
|
|
braceNeg = false;
|
|
acc += c;
|
|
continue;
|
|
}
|
|
if (isExtglobType(c) && str.charAt(i) === "(") {
|
|
part.push(acc);
|
|
acc = "";
|
|
const ext$1 = new AST(c, part);
|
|
part.push(ext$1);
|
|
i = AST.#parseAST(str, ext$1, i, opt);
|
|
continue;
|
|
}
|
|
if (c === "|") {
|
|
part.push(acc);
|
|
acc = "";
|
|
parts.push(part);
|
|
part = new AST(null, ast);
|
|
continue;
|
|
}
|
|
if (c === ")") {
|
|
if (acc === "" && ast.#parts.length === 0) ast.#emptyExt = true;
|
|
part.push(acc);
|
|
acc = "";
|
|
ast.push(...parts, part);
|
|
return i;
|
|
}
|
|
acc += c;
|
|
}
|
|
ast.type = null;
|
|
ast.#hasMagic = void 0;
|
|
ast.#parts = [str.substring(pos - 1)];
|
|
return i;
|
|
}
|
|
static fromGlob(pattern, options = {}) {
|
|
const ast = new AST(null, void 0, options);
|
|
AST.#parseAST(pattern, ast, 0, options);
|
|
return ast;
|
|
}
|
|
toMMPattern() {
|
|
/* c8 ignore start */
|
|
if (this !== this.#root) return this.#root.toMMPattern();
|
|
/* c8 ignore stop */
|
|
const glob = this.toString();
|
|
const [re, body, hasMagic, uflag] = this.toRegExpSource();
|
|
if (!(hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase())) return body;
|
|
const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
|
|
return Object.assign(new RegExp(`^${re}$`, flags), {
|
|
_src: re,
|
|
_glob: glob
|
|
});
|
|
}
|
|
get options() {
|
|
return this.#options;
|
|
}
|
|
toRegExpSource(allowDot) {
|
|
const dot = allowDot ?? !!this.#options.dot;
|
|
if (this.#root === this) this.#fillNegs();
|
|
if (!this.type) {
|
|
var _this$parent6;
|
|
const noEmpty = this.isStart() && this.isEnd();
|
|
const src = this.#parts.map((p) => {
|
|
const [re, _, hasMagic, uflag] = typeof p === "string" ? AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
|
|
this.#hasMagic = this.#hasMagic || hasMagic;
|
|
this.#uflag = this.#uflag || uflag;
|
|
return re;
|
|
}).join("");
|
|
let start$1 = "";
|
|
if (this.isStart()) {
|
|
if (typeof this.#parts[0] === "string") {
|
|
if (!(this.#parts.length === 1 && justDots.has(this.#parts[0]))) {
|
|
const aps = addPatternStart;
|
|
const needNoTrav = dot && aps.has(src.charAt(0)) || src.startsWith("\\.") && aps.has(src.charAt(2)) || src.startsWith("\\.\\.") && aps.has(src.charAt(4));
|
|
const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
|
|
start$1 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
|
|
}
|
|
}
|
|
}
|
|
let end = "";
|
|
if (this.isEnd() && this.#root.#filledNegs && ((_this$parent6 = this.#parent) === null || _this$parent6 === void 0 ? void 0 : _this$parent6.type) === "!") end = "(?:$|\\/)";
|
|
return [
|
|
start$1 + src + end,
|
|
unescape(src),
|
|
this.#hasMagic = !!this.#hasMagic,
|
|
this.#uflag
|
|
];
|
|
}
|
|
const repeated = this.type === "*" || this.type === "+";
|
|
const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
|
|
let body = this.#partsToRegExp(dot);
|
|
if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
|
|
const s = this.toString();
|
|
this.#parts = [s];
|
|
this.type = null;
|
|
this.#hasMagic = void 0;
|
|
return [
|
|
s,
|
|
unescape(this.toString()),
|
|
false,
|
|
false
|
|
];
|
|
}
|
|
let bodyDotAllowed = !repeated || allowDot || dot || false ? "" : this.#partsToRegExp(true);
|
|
if (bodyDotAllowed === body) bodyDotAllowed = "";
|
|
if (bodyDotAllowed) body = `(?:${body})(?:${bodyDotAllowed})*?`;
|
|
let final = "";
|
|
if (this.type === "!" && this.#emptyExt) final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
|
|
else {
|
|
const close = this.type === "!" ? "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star$1 + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
|
|
final = start + body + close;
|
|
}
|
|
return [
|
|
final,
|
|
unescape(body),
|
|
this.#hasMagic = !!this.#hasMagic,
|
|
this.#uflag
|
|
];
|
|
}
|
|
#partsToRegExp(dot) {
|
|
return this.#parts.map((p) => {
|
|
/* c8 ignore start */
|
|
if (typeof p === "string") throw new Error("string type in extglob ast??");
|
|
/* c8 ignore stop */
|
|
const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
|
|
this.#uflag = this.#uflag || uflag;
|
|
return re;
|
|
}).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
|
|
}
|
|
static #parseGlob(glob, hasMagic, noEmpty = false) {
|
|
let escaping = false;
|
|
let re = "";
|
|
let uflag = false;
|
|
for (let i = 0; i < glob.length; i++) {
|
|
const c = glob.charAt(i);
|
|
if (escaping) {
|
|
escaping = false;
|
|
re += (reSpecials.has(c) ? "\\" : "") + c;
|
|
continue;
|
|
}
|
|
if (c === "\\") {
|
|
if (i === glob.length - 1) re += "\\\\";
|
|
else escaping = true;
|
|
continue;
|
|
}
|
|
if (c === "[") {
|
|
const [src, needUflag, consumed, magic] = parseClass(glob, i);
|
|
if (consumed) {
|
|
re += src;
|
|
uflag = uflag || needUflag;
|
|
i += consumed - 1;
|
|
hasMagic = hasMagic || magic;
|
|
continue;
|
|
}
|
|
}
|
|
if (c === "*") {
|
|
if (noEmpty && glob === "*") re += starNoEmpty;
|
|
else re += star$1;
|
|
hasMagic = true;
|
|
continue;
|
|
}
|
|
if (c === "?") {
|
|
re += qmark;
|
|
hasMagic = true;
|
|
continue;
|
|
}
|
|
re += regExpEscape$1(c);
|
|
}
|
|
return [
|
|
re,
|
|
unescape(glob),
|
|
!!hasMagic,
|
|
uflag
|
|
];
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/escape.js
|
|
/**
|
|
* Escape all magic characters in a glob pattern.
|
|
*
|
|
* If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}
|
|
* option is used, then characters are escaped by wrapping in `[]`, because
|
|
* a magic character wrapped in a character class can only be satisfied by
|
|
* that exact character. In this mode, `\` is _not_ escaped, because it is
|
|
* not interpreted as a magic character, but instead as a path separator.
|
|
*/
|
|
const escape = (s, { windowsPathsNoEscape = false } = {}) => {
|
|
return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/index.js
|
|
const minimatch = (p, pattern, options = {}) => {
|
|
assertValidPattern(pattern);
|
|
if (!options.nocomment && pattern.charAt(0) === "#") return false;
|
|
return new Minimatch(pattern, options).match(p);
|
|
};
|
|
const starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
|
|
const starDotExtTest = (ext$1) => (f) => !f.startsWith(".") && f.endsWith(ext$1);
|
|
const starDotExtTestDot = (ext$1) => (f) => f.endsWith(ext$1);
|
|
const starDotExtTestNocase = (ext$1) => {
|
|
ext$1 = ext$1.toLowerCase();
|
|
return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext$1);
|
|
};
|
|
const starDotExtTestNocaseDot = (ext$1) => {
|
|
ext$1 = ext$1.toLowerCase();
|
|
return (f) => f.toLowerCase().endsWith(ext$1);
|
|
};
|
|
const starDotStarRE = /^\*+\.\*+$/;
|
|
const starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
|
|
const starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
|
|
const dotStarRE = /^\.\*+$/;
|
|
const dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
|
|
const starRE = /^\*+$/;
|
|
const starTest = (f) => f.length !== 0 && !f.startsWith(".");
|
|
const starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
|
|
const qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
|
|
const qmarksTestNocase = ([$0, ext$1 = ""]) => {
|
|
const noext = qmarksTestNoExt([$0]);
|
|
if (!ext$1) return noext;
|
|
ext$1 = ext$1.toLowerCase();
|
|
return (f) => noext(f) && f.toLowerCase().endsWith(ext$1);
|
|
};
|
|
const qmarksTestNocaseDot = ([$0, ext$1 = ""]) => {
|
|
const noext = qmarksTestNoExtDot([$0]);
|
|
if (!ext$1) return noext;
|
|
ext$1 = ext$1.toLowerCase();
|
|
return (f) => noext(f) && f.toLowerCase().endsWith(ext$1);
|
|
};
|
|
const qmarksTestDot = ([$0, ext$1 = ""]) => {
|
|
const noext = qmarksTestNoExtDot([$0]);
|
|
return !ext$1 ? noext : (f) => noext(f) && f.endsWith(ext$1);
|
|
};
|
|
const qmarksTest = ([$0, ext$1 = ""]) => {
|
|
const noext = qmarksTestNoExt([$0]);
|
|
return !ext$1 ? noext : (f) => noext(f) && f.endsWith(ext$1);
|
|
};
|
|
const qmarksTestNoExt = ([$0]) => {
|
|
const len = $0.length;
|
|
return (f) => f.length === len && !f.startsWith(".");
|
|
};
|
|
const qmarksTestNoExtDot = ([$0]) => {
|
|
const len = $0.length;
|
|
return (f) => f.length === len && f !== "." && f !== "..";
|
|
};
|
|
/* c8 ignore start */
|
|
const defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
|
|
const path = {
|
|
win32: { sep: "\\" },
|
|
posix: { sep: "/" }
|
|
};
|
|
/* c8 ignore stop */
|
|
const sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
|
|
minimatch.sep = sep;
|
|
const GLOBSTAR = Symbol("globstar **");
|
|
minimatch.GLOBSTAR = GLOBSTAR;
|
|
const star = "[^/]*?";
|
|
const twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
|
|
const twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
|
|
const filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
|
|
minimatch.filter = filter;
|
|
const ext = (a, b = {}) => Object.assign({}, a, b);
|
|
const defaults = (def) => {
|
|
if (!def || typeof def !== "object" || !Object.keys(def).length) return minimatch;
|
|
const orig = minimatch;
|
|
const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
|
|
return Object.assign(m, {
|
|
Minimatch: class Minimatch$1 extends orig.Minimatch {
|
|
constructor(pattern, options = {}) {
|
|
super(pattern, ext(def, options));
|
|
}
|
|
static defaults(options) {
|
|
return orig.defaults(ext(def, options)).Minimatch;
|
|
}
|
|
},
|
|
AST: class AST$1 extends orig.AST {
|
|
/* c8 ignore start */
|
|
constructor(type, parent, options = {}) {
|
|
super(type, parent, ext(def, options));
|
|
}
|
|
/* c8 ignore stop */
|
|
static fromGlob(pattern, options = {}) {
|
|
return orig.AST.fromGlob(pattern, ext(def, options));
|
|
}
|
|
},
|
|
unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
|
|
escape: (s, options = {}) => orig.escape(s, ext(def, options)),
|
|
filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
|
|
defaults: (options) => orig.defaults(ext(def, options)),
|
|
makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
|
|
braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
|
|
match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
|
|
sep: orig.sep,
|
|
GLOBSTAR
|
|
});
|
|
};
|
|
minimatch.defaults = defaults;
|
|
const braceExpand = (pattern, options = {}) => {
|
|
assertValidPattern(pattern);
|
|
if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) return [pattern];
|
|
return expand(pattern);
|
|
};
|
|
minimatch.braceExpand = braceExpand;
|
|
const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
|
|
minimatch.makeRe = makeRe;
|
|
const match = (list, pattern, options = {}) => {
|
|
const mm = new Minimatch(pattern, options);
|
|
list = list.filter((f) => mm.match(f));
|
|
if (mm.options.nonull && !list.length) list.push(pattern);
|
|
return list;
|
|
};
|
|
minimatch.match = match;
|
|
const globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
|
|
const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
|
var Minimatch = class {
|
|
options;
|
|
set;
|
|
pattern;
|
|
windowsPathsNoEscape;
|
|
nonegate;
|
|
negate;
|
|
comment;
|
|
empty;
|
|
preserveMultipleSlashes;
|
|
partial;
|
|
globSet;
|
|
globParts;
|
|
nocase;
|
|
isWindows;
|
|
platform;
|
|
windowsNoMagicRoot;
|
|
regexp;
|
|
constructor(pattern, options = {}) {
|
|
assertValidPattern(pattern);
|
|
options = options || {};
|
|
this.options = options;
|
|
this.pattern = pattern;
|
|
this.platform = options.platform || defaultPlatform;
|
|
this.isWindows = this.platform === "win32";
|
|
this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
|
|
if (this.windowsPathsNoEscape) this.pattern = this.pattern.replace(/\\/g, "/");
|
|
this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
|
|
this.regexp = null;
|
|
this.negate = false;
|
|
this.nonegate = !!options.nonegate;
|
|
this.comment = false;
|
|
this.empty = false;
|
|
this.partial = !!options.partial;
|
|
this.nocase = !!this.options.nocase;
|
|
this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
|
|
this.globSet = [];
|
|
this.globParts = [];
|
|
this.set = [];
|
|
this.make();
|
|
}
|
|
hasMagic() {
|
|
if (this.options.magicalBraces && this.set.length > 1) return true;
|
|
for (const pattern of this.set) for (const part of pattern) if (typeof part !== "string") return true;
|
|
return false;
|
|
}
|
|
debug(..._) {}
|
|
make() {
|
|
const pattern = this.pattern;
|
|
const options = this.options;
|
|
if (!options.nocomment && pattern.charAt(0) === "#") {
|
|
this.comment = true;
|
|
return;
|
|
}
|
|
if (!pattern) {
|
|
this.empty = true;
|
|
return;
|
|
}
|
|
this.parseNegate();
|
|
this.globSet = [...new Set(this.braceExpand())];
|
|
if (options.debug) this.debug = (...args) => console.error(...args);
|
|
this.debug(this.pattern, this.globSet);
|
|
const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
|
|
this.globParts = this.preprocess(rawGlobParts);
|
|
this.debug(this.pattern, this.globParts);
|
|
let set = this.globParts.map((s, _, __) => {
|
|
if (this.isWindows && this.windowsNoMagicRoot) {
|
|
const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
|
|
const isDrive = /^[a-z]:/i.test(s[0]);
|
|
if (isUNC) return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
|
|
else if (isDrive) return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
|
|
}
|
|
return s.map((ss) => this.parse(ss));
|
|
});
|
|
this.debug(this.pattern, set);
|
|
this.set = set.filter((s) => s.indexOf(false) === -1);
|
|
if (this.isWindows) for (let i = 0; i < this.set.length; i++) {
|
|
const p = this.set[i];
|
|
if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) p[2] = "?";
|
|
}
|
|
this.debug(this.pattern, this.set);
|
|
}
|
|
preprocess(globParts) {
|
|
if (this.options.noglobstar) {
|
|
for (let i = 0; i < globParts.length; i++) for (let j = 0; j < globParts[i].length; j++) if (globParts[i][j] === "**") globParts[i][j] = "*";
|
|
}
|
|
const { optimizationLevel = 1 } = this.options;
|
|
if (optimizationLevel >= 2) {
|
|
globParts = this.firstPhasePreProcess(globParts);
|
|
globParts = this.secondPhasePreProcess(globParts);
|
|
} else if (optimizationLevel >= 1) globParts = this.levelOneOptimize(globParts);
|
|
else globParts = this.adjascentGlobstarOptimize(globParts);
|
|
return globParts;
|
|
}
|
|
adjascentGlobstarOptimize(globParts) {
|
|
return globParts.map((parts) => {
|
|
let gs = -1;
|
|
while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
|
|
let i = gs;
|
|
while (parts[i + 1] === "**") i++;
|
|
if (i !== gs) parts.splice(gs, i - gs);
|
|
}
|
|
return parts;
|
|
});
|
|
}
|
|
levelOneOptimize(globParts) {
|
|
return globParts.map((parts) => {
|
|
parts = parts.reduce((set, part) => {
|
|
const prev = set[set.length - 1];
|
|
if (part === "**" && prev === "**") return set;
|
|
if (part === "..") {
|
|
if (prev && prev !== ".." && prev !== "." && prev !== "**") {
|
|
set.pop();
|
|
return set;
|
|
}
|
|
}
|
|
set.push(part);
|
|
return set;
|
|
}, []);
|
|
return parts.length === 0 ? [""] : parts;
|
|
});
|
|
}
|
|
levelTwoFileOptimize(parts) {
|
|
if (!Array.isArray(parts)) parts = this.slashSplit(parts);
|
|
let didSomething = false;
|
|
do {
|
|
didSomething = false;
|
|
if (!this.preserveMultipleSlashes) {
|
|
for (let i = 1; i < parts.length - 1; i++) {
|
|
const p = parts[i];
|
|
if (i === 1 && p === "" && parts[0] === "") continue;
|
|
if (p === "." || p === "") {
|
|
didSomething = true;
|
|
parts.splice(i, 1);
|
|
i--;
|
|
}
|
|
}
|
|
if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
|
|
didSomething = true;
|
|
parts.pop();
|
|
}
|
|
}
|
|
let dd = 0;
|
|
while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
|
|
const p = parts[dd - 1];
|
|
if (p && p !== "." && p !== ".." && p !== "**") {
|
|
didSomething = true;
|
|
parts.splice(dd - 1, 2);
|
|
dd -= 2;
|
|
}
|
|
}
|
|
} while (didSomething);
|
|
return parts.length === 0 ? [""] : parts;
|
|
}
|
|
firstPhasePreProcess(globParts) {
|
|
let didSomething = false;
|
|
do {
|
|
didSomething = false;
|
|
for (let parts of globParts) {
|
|
let gs = -1;
|
|
while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
|
|
let gss = gs;
|
|
while (parts[gss + 1] === "**") gss++;
|
|
if (gss > gs) parts.splice(gs + 1, gss - gs);
|
|
let next = parts[gs + 1];
|
|
const p = parts[gs + 2];
|
|
const p2 = parts[gs + 3];
|
|
if (next !== "..") continue;
|
|
if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") continue;
|
|
didSomething = true;
|
|
parts.splice(gs, 1);
|
|
const other = parts.slice(0);
|
|
other[gs] = "**";
|
|
globParts.push(other);
|
|
gs--;
|
|
}
|
|
if (!this.preserveMultipleSlashes) {
|
|
for (let i = 1; i < parts.length - 1; i++) {
|
|
const p = parts[i];
|
|
if (i === 1 && p === "" && parts[0] === "") continue;
|
|
if (p === "." || p === "") {
|
|
didSomething = true;
|
|
parts.splice(i, 1);
|
|
i--;
|
|
}
|
|
}
|
|
if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
|
|
didSomething = true;
|
|
parts.pop();
|
|
}
|
|
}
|
|
let dd = 0;
|
|
while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
|
|
const p = parts[dd - 1];
|
|
if (p && p !== "." && p !== ".." && p !== "**") {
|
|
didSomething = true;
|
|
const splin = dd === 1 && parts[dd + 1] === "**" ? ["."] : [];
|
|
parts.splice(dd - 1, 2, ...splin);
|
|
if (parts.length === 0) parts.push("");
|
|
dd -= 2;
|
|
}
|
|
}
|
|
}
|
|
} while (didSomething);
|
|
return globParts;
|
|
}
|
|
secondPhasePreProcess(globParts) {
|
|
for (let i = 0; i < globParts.length - 1; i++) for (let j = i + 1; j < globParts.length; j++) {
|
|
const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
|
|
if (matched) {
|
|
globParts[i] = [];
|
|
globParts[j] = matched;
|
|
break;
|
|
}
|
|
}
|
|
return globParts.filter((gs) => gs.length);
|
|
}
|
|
partsMatch(a, b, emptyGSMatch = false) {
|
|
let ai = 0;
|
|
let bi = 0;
|
|
let result = [];
|
|
let which = "";
|
|
while (ai < a.length && bi < b.length) if (a[ai] === b[bi]) {
|
|
result.push(which === "b" ? b[bi] : a[ai]);
|
|
ai++;
|
|
bi++;
|
|
} else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
|
|
result.push(a[ai]);
|
|
ai++;
|
|
} else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
|
|
result.push(b[bi]);
|
|
bi++;
|
|
} else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
|
|
if (which === "b") return false;
|
|
which = "a";
|
|
result.push(a[ai]);
|
|
ai++;
|
|
bi++;
|
|
} else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
|
|
if (which === "a") return false;
|
|
which = "b";
|
|
result.push(b[bi]);
|
|
ai++;
|
|
bi++;
|
|
} else return false;
|
|
return a.length === b.length && result;
|
|
}
|
|
parseNegate() {
|
|
if (this.nonegate) return;
|
|
const pattern = this.pattern;
|
|
let negate = false;
|
|
let negateOffset = 0;
|
|
for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
|
|
negate = !negate;
|
|
negateOffset++;
|
|
}
|
|
if (negateOffset) this.pattern = pattern.slice(negateOffset);
|
|
this.negate = negate;
|
|
}
|
|
matchOne(file, pattern, partial = false) {
|
|
const options = this.options;
|
|
if (this.isWindows) {
|
|
const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
|
|
const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
|
|
const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
|
|
const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
|
|
const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
|
|
const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
|
|
if (typeof fdi === "number" && typeof pdi === "number") {
|
|
const [fd, pd] = [file[fdi], pattern[pdi]];
|
|
if (fd.toLowerCase() === pd.toLowerCase()) {
|
|
pattern[pdi] = fd;
|
|
if (pdi > fdi) pattern = pattern.slice(pdi);
|
|
else if (fdi > pdi) file = file.slice(fdi);
|
|
}
|
|
}
|
|
}
|
|
const { optimizationLevel = 1 } = this.options;
|
|
if (optimizationLevel >= 2) file = this.levelTwoFileOptimize(file);
|
|
this.debug("matchOne", this, {
|
|
file,
|
|
pattern
|
|
});
|
|
this.debug("matchOne", file.length, pattern.length);
|
|
for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
|
|
this.debug("matchOne loop");
|
|
var p = pattern[pi];
|
|
var f = file[fi];
|
|
this.debug(pattern, p, f);
|
|
/* c8 ignore start */
|
|
if (p === false) return false;
|
|
/* c8 ignore stop */
|
|
if (p === GLOBSTAR) {
|
|
this.debug("GLOBSTAR", [
|
|
pattern,
|
|
p,
|
|
f
|
|
]);
|
|
var fr = fi;
|
|
var pr = pi + 1;
|
|
if (pr === pl) {
|
|
this.debug("** at the end");
|
|
for (; fi < fl; fi++) if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".") return false;
|
|
return true;
|
|
}
|
|
while (fr < fl) {
|
|
var swallowee = file[fr];
|
|
this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
|
|
if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
|
|
this.debug("globstar found match!", fr, fl, swallowee);
|
|
return true;
|
|
} else {
|
|
if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
|
|
this.debug("dot detected!", file, fr, pattern, pr);
|
|
break;
|
|
}
|
|
this.debug("globstar swallow a segment, and continue");
|
|
fr++;
|
|
}
|
|
}
|
|
/* c8 ignore start */
|
|
if (partial) {
|
|
this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
|
|
if (fr === fl) return true;
|
|
}
|
|
/* c8 ignore stop */
|
|
return false;
|
|
}
|
|
let hit;
|
|
if (typeof p === "string") {
|
|
hit = f === p;
|
|
this.debug("string match", p, f, hit);
|
|
} else {
|
|
hit = p.test(f);
|
|
this.debug("pattern match", p, f, hit);
|
|
}
|
|
if (!hit) return false;
|
|
}
|
|
if (fi === fl && pi === pl) return true;
|
|
else if (fi === fl) return partial;
|
|
else if (pi === pl) return fi === fl - 1 && file[fi] === "";
|
|
else throw new Error("wtf?");
|
|
/* c8 ignore stop */
|
|
}
|
|
braceExpand() {
|
|
return braceExpand(this.pattern, this.options);
|
|
}
|
|
parse(pattern) {
|
|
assertValidPattern(pattern);
|
|
const options = this.options;
|
|
if (pattern === "**") return GLOBSTAR;
|
|
if (pattern === "") return "";
|
|
let m;
|
|
let fastTest = null;
|
|
if (m = pattern.match(starRE)) fastTest = options.dot ? starTestDot : starTest;
|
|
else if (m = pattern.match(starDotExtRE)) fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
|
|
else if (m = pattern.match(qmarksRE)) fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
|
|
else if (m = pattern.match(starDotStarRE)) fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
|
|
else if (m = pattern.match(dotStarRE)) fastTest = dotStarTest;
|
|
const re = AST.fromGlob(pattern, this.options).toMMPattern();
|
|
if (fastTest && typeof re === "object") Reflect.defineProperty(re, "test", { value: fastTest });
|
|
return re;
|
|
}
|
|
makeRe() {
|
|
if (this.regexp || this.regexp === false) return this.regexp;
|
|
const set = this.set;
|
|
if (!set.length) {
|
|
this.regexp = false;
|
|
return this.regexp;
|
|
}
|
|
const options = this.options;
|
|
const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
|
|
const flags = new Set(options.nocase ? ["i"] : []);
|
|
let re = set.map((pattern) => {
|
|
const pp = pattern.map((p) => {
|
|
if (p instanceof RegExp) for (const f of p.flags.split("")) flags.add(f);
|
|
return typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
|
|
});
|
|
pp.forEach((p, i) => {
|
|
const next = pp[i + 1];
|
|
const prev = pp[i - 1];
|
|
if (p !== GLOBSTAR || prev === GLOBSTAR) return;
|
|
if (prev === void 0) if (next !== void 0 && next !== GLOBSTAR) pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
|
|
else pp[i] = twoStar;
|
|
else if (next === void 0) pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
|
|
else if (next !== GLOBSTAR) {
|
|
pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
|
|
pp[i + 1] = GLOBSTAR;
|
|
}
|
|
});
|
|
return pp.filter((p) => p !== GLOBSTAR).join("/");
|
|
}).join("|");
|
|
const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
|
|
re = "^" + open + re + close + "$";
|
|
if (this.negate) re = "^(?!" + re + ").+$";
|
|
try {
|
|
this.regexp = new RegExp(re, [...flags].join(""));
|
|
} catch (ex) {
|
|
this.regexp = false;
|
|
}
|
|
/* c8 ignore stop */
|
|
return this.regexp;
|
|
}
|
|
slashSplit(p) {
|
|
if (this.preserveMultipleSlashes) return p.split("/");
|
|
else if (this.isWindows && /^\/\/[^\/]+/.test(p)) return ["", ...p.split(/\/+/)];
|
|
else return p.split(/\/+/);
|
|
}
|
|
match(f, partial = this.partial) {
|
|
this.debug("match", f, this.pattern);
|
|
if (this.comment) return false;
|
|
if (this.empty) return f === "";
|
|
if (f === "/" && partial) return true;
|
|
const options = this.options;
|
|
if (this.isWindows) f = f.split("\\").join("/");
|
|
const ff = this.slashSplit(f);
|
|
this.debug(this.pattern, "split", ff);
|
|
const set = this.set;
|
|
this.debug(this.pattern, "set", set);
|
|
let filename = ff[ff.length - 1];
|
|
if (!filename) for (let i = ff.length - 2; !filename && i >= 0; i--) filename = ff[i];
|
|
for (let i = 0; i < set.length; i++) {
|
|
const pattern = set[i];
|
|
let file = ff;
|
|
if (options.matchBase && pattern.length === 1) file = [filename];
|
|
if (this.matchOne(file, pattern, partial)) {
|
|
if (options.flipNegate) return true;
|
|
return !this.negate;
|
|
}
|
|
}
|
|
if (options.flipNegate) return false;
|
|
return this.negate;
|
|
}
|
|
static defaults(def) {
|
|
return minimatch.defaults(def).Minimatch;
|
|
}
|
|
};
|
|
/* c8 ignore stop */
|
|
minimatch.AST = AST;
|
|
minimatch.Minimatch = Minimatch;
|
|
minimatch.escape = escape;
|
|
minimatch.unescape = unescape;
|
|
|
|
//#endregion
|
|
//#region src/core/utils.ts
|
|
const isSSR = Boolean(node_process.default.env.SSR || node_process.default.env.SSG || node_process.default.env.VITE_SSR || node_process.default.env.VITE_SSG);
|
|
function pascalCase(str) {
|
|
return capitalize(camelCase(str));
|
|
}
|
|
function camelCase(str) {
|
|
return str.replace(/-(\w)/g, (_, c) => c ? c.toUpperCase() : "");
|
|
}
|
|
function kebabCase(key) {
|
|
return key.replace(/([A-Z])/g, " $1").trim().split(" ").join("-").toLowerCase();
|
|
}
|
|
function capitalize(str) {
|
|
return str.charAt(0).toUpperCase() + str.slice(1);
|
|
}
|
|
function parseId(id) {
|
|
const index = id.indexOf("?");
|
|
if (index < 0) return {
|
|
path: id,
|
|
query: {}
|
|
};
|
|
else {
|
|
const query = Object.fromEntries(new URLSearchParams(id.slice(index)));
|
|
return {
|
|
path: id.slice(0, index),
|
|
query
|
|
};
|
|
}
|
|
}
|
|
function isEmpty(value) {
|
|
if (!value || value === null || value === void 0 || Array.isArray(value) && Object.keys(value).length <= 0) return true;
|
|
else return false;
|
|
}
|
|
function matchGlobs(filepath, globs) {
|
|
for (const glob of globs) {
|
|
const isNegated = glob.startsWith("!");
|
|
if (minimatch(slash(filepath), isNegated ? glob.slice(1) : glob)) return !isNegated;
|
|
}
|
|
return false;
|
|
}
|
|
function getTransformedPath(path$1, importPathTransform) {
|
|
if (importPathTransform) {
|
|
const result = importPathTransform(path$1);
|
|
if (result != null) path$1 = result;
|
|
}
|
|
return path$1;
|
|
}
|
|
function stringifyImport(info) {
|
|
if (typeof info === "string") return `import '${info}'`;
|
|
if (!info.as) return `import '${info.from}'`;
|
|
else if (info.name) return `import { ${info.name} as ${info.as} } from '${info.from}'`;
|
|
else return `import ${info.as} from '${info.from}'`;
|
|
}
|
|
function normalizeComponentInfo(info) {
|
|
if ("path" in info) return {
|
|
from: info.path,
|
|
as: info.name,
|
|
name: info.importName,
|
|
sideEffects: info.sideEffects
|
|
};
|
|
return info;
|
|
}
|
|
function stringifyComponentImport({ as: name, from: path$1, name: importName, sideEffects }, ctx) {
|
|
path$1 = getTransformedPath(path$1, ctx.options.importPathTransform);
|
|
const imports = [stringifyImport({
|
|
as: name,
|
|
from: path$1,
|
|
name: importName
|
|
})];
|
|
if (sideEffects) toArray(sideEffects).forEach((i) => imports.push(stringifyImport(i)));
|
|
return imports.join(";");
|
|
}
|
|
function getNameFromFilePath(filePath, options) {
|
|
const { resolvedDirs, directoryAsNamespace, globalNamespaces, collapseSamePrefixes, root } = options;
|
|
const parsedFilePath = (0, node_path.parse)(slash(filePath));
|
|
let strippedPath = "";
|
|
for (const dir of resolvedDirs) if (parsedFilePath.dir.startsWith(dir)) {
|
|
strippedPath = parsedFilePath.dir.slice(dir.length);
|
|
break;
|
|
}
|
|
let folders = strippedPath.slice(1).split("/").filter(Boolean);
|
|
let filename = parsedFilePath.name;
|
|
if (filename === "index" && !directoryAsNamespace) {
|
|
if (isEmpty(folders)) folders = parsedFilePath.dir.slice(root.length + 1).split("/").filter(Boolean);
|
|
filename = `${folders.slice(-1)[0]}`;
|
|
return filename;
|
|
}
|
|
if (directoryAsNamespace) {
|
|
if (globalNamespaces.some((name) => folders.includes(name))) folders = folders.filter((f) => !globalNamespaces.includes(f));
|
|
folders = folders.map((f) => f.replace(/[^a-z0-9\-]/gi, ""));
|
|
if (filename.toLowerCase() === "index") filename = "";
|
|
if (!isEmpty(folders)) {
|
|
let namespaced = [...folders, filename];
|
|
if (collapseSamePrefixes) {
|
|
const collapsed = [];
|
|
for (const fileOrFolderName of namespaced) {
|
|
let cumulativePrefix = "";
|
|
let didCollapse = false;
|
|
const pascalCasedName = pascalCase(fileOrFolderName);
|
|
for (const parentFolder of [...collapsed].reverse()) {
|
|
cumulativePrefix = `${parentFolder}${cumulativePrefix}`;
|
|
if (pascalCasedName.startsWith(cumulativePrefix)) {
|
|
const collapseSamePrefix = pascalCasedName.slice(cumulativePrefix.length);
|
|
collapsed.push(collapseSamePrefix);
|
|
didCollapse = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!didCollapse) collapsed.push(pascalCasedName);
|
|
}
|
|
namespaced = collapsed;
|
|
}
|
|
filename = namespaced.filter(Boolean).join("-");
|
|
}
|
|
return filename;
|
|
}
|
|
return filename;
|
|
}
|
|
function resolveAlias(filepath, alias) {
|
|
const result = filepath;
|
|
if (Array.isArray(alias)) for (const { find, replacement } of alias) result.replace(find, replacement);
|
|
return result;
|
|
}
|
|
async function getPkgVersion(pkgName, defaultVersion) {
|
|
try {
|
|
if ((0, local_pkg.isPackageExists)(pkgName)) {
|
|
const pkg = await (0, local_pkg.getPackageInfo)(pkgName);
|
|
return (pkg === null || pkg === void 0 ? void 0 : pkg.version) ?? defaultVersion;
|
|
} else return defaultVersion;
|
|
} catch (err) {
|
|
console.error(err);
|
|
return defaultVersion;
|
|
}
|
|
}
|
|
function shouldTransform(code) {
|
|
if (code.includes(DISABLE_COMMENT)) return false;
|
|
return true;
|
|
}
|
|
function isExclude(name, exclude) {
|
|
if (!exclude) return false;
|
|
if (typeof exclude === "string") return name === exclude;
|
|
if (exclude instanceof RegExp) return !!name.match(exclude);
|
|
if (Array.isArray(exclude)) {
|
|
for (const item of exclude) if (name === item || name.match(item)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
const ESCAPE_PARENTHESES_REGEX = /[()]/g;
|
|
function escapeSpecialChars(str) {
|
|
return str.replace(ESCAPE_PARENTHESES_REGEX, "\\$&");
|
|
}
|
|
|
|
//#endregion
|
|
Object.defineProperty(exports, 'DIRECTIVE_IMPORT_PREFIX', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return DIRECTIVE_IMPORT_PREFIX;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'DISABLE_COMMENT', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return DISABLE_COMMENT;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, '__commonJS', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return __commonJS;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, '__toESM', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return __toESM;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'camelCase', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return camelCase;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'escapeSpecialChars', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return escapeSpecialChars;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'getNameFromFilePath', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return getNameFromFilePath;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'getPkgVersion', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return getPkgVersion;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'getTransformedPath', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return getTransformedPath;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'isExclude', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return isExclude;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'isSSR', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return isSSR;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'kebabCase', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return kebabCase;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'matchGlobs', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return matchGlobs;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'normalizeComponentInfo', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return normalizeComponentInfo;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'notNullish', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return notNullish;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'parseId', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return parseId;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'pascalCase', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return pascalCase;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'resolveAlias', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return resolveAlias;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'shouldTransform', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return shouldTransform;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'slash', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return slash;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'stringifyComponentImport', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return stringifyComponentImport;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'throttle', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return throttle;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'toArray', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return toArray;
|
|
}
|
|
}); |