hot-updater
Version:
React Native OTA solution for self-hosted
15,003 lines • 503 kB
JavaScript
import { __commonJS, __require, __toESM, require_picocolors } from "./picocolors-OFVOrezl.js";
import fs from "node:fs";
import fs$1 from "fs";
import * as p$1 from "@clack/prompts";
import * as p from "@clack/prompts";
import { getCwd, loadConfig } from "@hot-updater/plugin-core";
import path from "path";
import { createFingerprintAsync, diffFingerprintChangesAsync } from "@expo/fingerprint";
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/util.js
const nameStartChar$1 = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
const nameChar$1 = nameStartChar$1 + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
const nameRegexp = "[" + nameStartChar$1 + "][" + nameChar$1 + "]*";
const regexName = new RegExp("^" + nameRegexp + "$");
function getAllMatches(string$1, regex) {
const matches = [];
let match = regex.exec(string$1);
while (match) {
const allmatches = [];
allmatches.startIndex = regex.lastIndex - match[0].length;
const len$1 = match.length;
for (let index = 0; index < len$1; index++) allmatches.push(match[index]);
matches.push(allmatches);
match = regex.exec(string$1);
}
return matches;
}
const isName = function(string$1) {
const match = regexName.exec(string$1);
return !(match === null || typeof match === "undefined");
};
function isExist(v) {
return typeof v !== "undefined";
}
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/validator.js
const defaultOptions$2 = {
allowBooleanAttributes: false,
unpairedTags: []
};
function validate(xmlData, options) {
options = Object.assign({}, defaultOptions$2, options);
const tags = [];
let tagFound = false;
let reachedRoot = false;
if (xmlData[0] === "") xmlData = xmlData.substr(1);
for (let i$1 = 0; i$1 < xmlData.length; i$1++) if (xmlData[i$1] === "<" && xmlData[i$1 + 1] === "?") {
i$1 += 2;
i$1 = readPI(xmlData, i$1);
if (i$1.err) return i$1;
} else if (xmlData[i$1] === "<") {
let tagStartPos = i$1;
i$1++;
if (xmlData[i$1] === "!") {
i$1 = readCommentAndCDATA(xmlData, i$1);
continue;
} else {
let closingTag = false;
if (xmlData[i$1] === "/") {
closingTag = true;
i$1++;
}
let tagName = "";
for (; i$1 < xmlData.length && xmlData[i$1] !== ">" && xmlData[i$1] !== " " && xmlData[i$1] !== " " && xmlData[i$1] !== "\n" && xmlData[i$1] !== "\r"; i$1++) tagName += xmlData[i$1];
tagName = tagName.trim();
if (tagName[tagName.length - 1] === "/") {
tagName = tagName.substring(0, tagName.length - 1);
i$1--;
}
if (!validateTagName(tagName)) {
let msg;
if (tagName.trim().length === 0) msg = "Invalid space after '<'.";
else msg = "Tag '" + tagName + "' is an invalid name.";
return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i$1));
}
const result = readAttributeStr(xmlData, i$1);
if (result === false) return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i$1));
let attrStr = result.value;
i$1 = result.index;
if (attrStr[attrStr.length - 1] === "/") {
const attrStrStart = i$1 - attrStr.length;
attrStr = attrStr.substring(0, attrStr.length - 1);
const isValid = validateAttributeString(attrStr, options);
if (isValid === true) tagFound = true;
else return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
} else if (closingTag) if (!result.tagClosed) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i$1));
else if (attrStr.trim().length > 0) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
else if (tags.length === 0) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
else {
const otg = tags.pop();
if (tagName !== otg.tagName) {
let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
return getErrorObject("InvalidTag", "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.", getLineNumberForPosition(xmlData, tagStartPos));
}
if (tags.length == 0) reachedRoot = true;
}
else {
const isValid = validateAttributeString(attrStr, options);
if (isValid !== true) return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i$1 - attrStr.length + isValid.err.line));
if (reachedRoot === true) return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i$1));
else if (options.unpairedTags.indexOf(tagName) !== -1) {} else tags.push({
tagName,
tagStartPos
});
tagFound = true;
}
for (i$1++; i$1 < xmlData.length; i$1++) if (xmlData[i$1] === "<") if (xmlData[i$1 + 1] === "!") {
i$1++;
i$1 = readCommentAndCDATA(xmlData, i$1);
continue;
} else if (xmlData[i$1 + 1] === "?") {
i$1 = readPI(xmlData, ++i$1);
if (i$1.err) return i$1;
} else break;
else if (xmlData[i$1] === "&") {
const afterAmp = validateAmpersand(xmlData, i$1);
if (afterAmp == -1) return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i$1));
i$1 = afterAmp;
} else if (reachedRoot === true && !isWhiteSpace(xmlData[i$1])) return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i$1));
if (xmlData[i$1] === "<") i$1--;
}
} else {
if (isWhiteSpace(xmlData[i$1])) continue;
return getErrorObject("InvalidChar", "char '" + xmlData[i$1] + "' is not expected.", getLineNumberForPosition(xmlData, i$1));
}
if (!tagFound) return getErrorObject("InvalidXml", "Start tag expected.", 1);
else if (tags.length == 1) return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
else if (tags.length > 0) return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", {
line: 1,
col: 1
});
return true;
}
function isWhiteSpace(char) {
return char === " " || char === " " || char === "\n" || char === "\r";
}
/**
* Read Processing insstructions and skip
* @param {*} xmlData
* @param {*} i
*/
function readPI(xmlData, i$1) {
const start = i$1;
for (; i$1 < xmlData.length; i$1++) if (xmlData[i$1] == "?" || xmlData[i$1] == " ") {
const tagname = xmlData.substr(start, i$1 - start);
if (i$1 > 5 && tagname === "xml") return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i$1));
else if (xmlData[i$1] == "?" && xmlData[i$1 + 1] == ">") {
i$1++;
break;
} else continue;
}
return i$1;
}
function readCommentAndCDATA(xmlData, i$1) {
if (xmlData.length > i$1 + 5 && xmlData[i$1 + 1] === "-" && xmlData[i$1 + 2] === "-") {
for (i$1 += 3; i$1 < xmlData.length; i$1++) if (xmlData[i$1] === "-" && xmlData[i$1 + 1] === "-" && xmlData[i$1 + 2] === ">") {
i$1 += 2;
break;
}
} else if (xmlData.length > i$1 + 8 && xmlData[i$1 + 1] === "D" && xmlData[i$1 + 2] === "O" && xmlData[i$1 + 3] === "C" && xmlData[i$1 + 4] === "T" && xmlData[i$1 + 5] === "Y" && xmlData[i$1 + 6] === "P" && xmlData[i$1 + 7] === "E") {
let angleBracketsCount = 1;
for (i$1 += 8; i$1 < xmlData.length; i$1++) if (xmlData[i$1] === "<") angleBracketsCount++;
else if (xmlData[i$1] === ">") {
angleBracketsCount--;
if (angleBracketsCount === 0) break;
}
} else if (xmlData.length > i$1 + 9 && xmlData[i$1 + 1] === "[" && xmlData[i$1 + 2] === "C" && xmlData[i$1 + 3] === "D" && xmlData[i$1 + 4] === "A" && xmlData[i$1 + 5] === "T" && xmlData[i$1 + 6] === "A" && xmlData[i$1 + 7] === "[") {
for (i$1 += 8; i$1 < xmlData.length; i$1++) if (xmlData[i$1] === "]" && xmlData[i$1 + 1] === "]" && xmlData[i$1 + 2] === ">") {
i$1 += 2;
break;
}
}
return i$1;
}
const doubleQuote = "\"";
const singleQuote = "'";
/**
* Keep reading xmlData until '<' is found outside the attribute value.
* @param {string} xmlData
* @param {number} i
*/
function readAttributeStr(xmlData, i$1) {
let attrStr = "";
let startChar = "";
let tagClosed = false;
for (; i$1 < xmlData.length; i$1++) {
if (xmlData[i$1] === doubleQuote || xmlData[i$1] === singleQuote) if (startChar === "") startChar = xmlData[i$1];
else if (startChar !== xmlData[i$1]) {} else startChar = "";
else if (xmlData[i$1] === ">") {
if (startChar === "") {
tagClosed = true;
break;
}
}
attrStr += xmlData[i$1];
}
if (startChar !== "") return false;
return {
value: attrStr,
index: i$1,
tagClosed
};
}
/**
* Select all the attributes whether valid or invalid.
*/
const validAttrStrRegxp = new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?", "g");
function validateAttributeString(attrStr, options) {
const matches = getAllMatches(attrStr, validAttrStrRegxp);
const attrNames = {};
for (let i$1 = 0; i$1 < matches.length; i$1++) {
if (matches[i$1][1].length === 0) return getErrorObject("InvalidAttr", "Attribute '" + matches[i$1][2] + "' has no space in starting.", getPositionFromMatch(matches[i$1]));
else if (matches[i$1][3] !== void 0 && matches[i$1][4] === void 0) return getErrorObject("InvalidAttr", "Attribute '" + matches[i$1][2] + "' is without value.", getPositionFromMatch(matches[i$1]));
else if (matches[i$1][3] === void 0 && !options.allowBooleanAttributes) return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i$1][2] + "' is not allowed.", getPositionFromMatch(matches[i$1]));
const attrName = matches[i$1][2];
if (!validateAttrName(attrName)) return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i$1]));
if (!attrNames.hasOwnProperty(attrName)) attrNames[attrName] = 1;
else return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i$1]));
}
return true;
}
function validateNumberAmpersand(xmlData, i$1) {
let re = /\d/;
if (xmlData[i$1] === "x") {
i$1++;
re = /[\da-fA-F]/;
}
for (; i$1 < xmlData.length; i$1++) {
if (xmlData[i$1] === ";") return i$1;
if (!xmlData[i$1].match(re)) break;
}
return -1;
}
function validateAmpersand(xmlData, i$1) {
i$1++;
if (xmlData[i$1] === ";") return -1;
if (xmlData[i$1] === "#") {
i$1++;
return validateNumberAmpersand(xmlData, i$1);
}
let count = 0;
for (; i$1 < xmlData.length; i$1++, count++) {
if (xmlData[i$1].match(/\w/) && count < 20) continue;
if (xmlData[i$1] === ";") break;
return -1;
}
return i$1;
}
function getErrorObject(code$1, message, lineNumber) {
return { err: {
code: code$1,
msg: message,
line: lineNumber.line || lineNumber,
col: lineNumber.col
} };
}
function validateAttrName(attrName) {
return isName(attrName);
}
function validateTagName(tagname) {
return isName(tagname);
}
function getLineNumberForPosition(xmlData, index) {
const lines = xmlData.substring(0, index).split(/\r?\n/);
return {
line: lines.length,
col: lines[lines.length - 1].length + 1
};
}
function getPositionFromMatch(match) {
return match.startIndex + match[1].length;
}
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
const defaultOptions$1 = {
preserveOrder: false,
attributeNamePrefix: "@_",
attributesGroupName: false,
textNodeName: "#text",
ignoreAttributes: true,
removeNSPrefix: false,
allowBooleanAttributes: false,
parseTagValue: true,
parseAttributeValue: false,
trimValues: true,
cdataPropName: false,
numberParseOptions: {
hex: true,
leadingZeros: true,
eNotation: true
},
tagValueProcessor: function(tagName, val) {
return val;
},
attributeValueProcessor: function(attrName, val) {
return val;
},
stopNodes: [],
alwaysCreateTextNode: false,
isArray: () => false,
commentPropName: false,
unpairedTags: [],
processEntities: true,
htmlEntities: false,
ignoreDeclaration: false,
ignorePiTags: false,
transformTagName: false,
transformAttributeName: false,
updateTag: function(tagName, jPath, attrs) {
return tagName;
},
captureMetaData: false
};
const buildOptions = function(options) {
return Object.assign({}, defaultOptions$1, options);
};
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
let METADATA_SYMBOL$1;
if (typeof Symbol !== "function") METADATA_SYMBOL$1 = "@@xmlMetadata";
else METADATA_SYMBOL$1 = Symbol("XML Node Metadata");
var XmlNode = class {
constructor(tagname) {
this.tagname = tagname;
this.child = [];
this[":@"] = {};
}
add(key, val) {
if (key === "__proto__") key = "#__proto__";
this.child.push({ [key]: val });
}
addChild(node, startIndex) {
if (node.tagname === "__proto__") node.tagname = "#__proto__";
if (node[":@"] && Object.keys(node[":@"]).length > 0) this.child.push({
[node.tagname]: node.child,
[":@"]: node[":@"]
});
else this.child.push({ [node.tagname]: node.child });
if (startIndex !== void 0) this.child[this.child.length - 1][METADATA_SYMBOL$1] = { startIndex };
}
/** symbol used for metadata */
static getMetaDataSymbol() {
return METADATA_SYMBOL$1;
}
};
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
function readDocType(xmlData, i$1) {
const entities$1 = {};
if (xmlData[i$1 + 3] === "O" && xmlData[i$1 + 4] === "C" && xmlData[i$1 + 5] === "T" && xmlData[i$1 + 6] === "Y" && xmlData[i$1 + 7] === "P" && xmlData[i$1 + 8] === "E") {
i$1 = i$1 + 9;
let angleBracketsCount = 1;
let hasBody = false, comment = false;
let exp = "";
for (; i$1 < xmlData.length; i$1++) if (xmlData[i$1] === "<" && !comment) {
if (hasBody && hasSeq(xmlData, "!ENTITY", i$1)) {
i$1 += 7;
let entityName, val;
[entityName, val, i$1] = readEntityExp(xmlData, i$1 + 1);
if (val.indexOf("&") === -1) entities$1[entityName] = {
regx: RegExp(`&${entityName};`, "g"),
val
};
} else if (hasBody && hasSeq(xmlData, "!ELEMENT", i$1)) {
i$1 += 8;
const { index } = readElementExp(xmlData, i$1 + 1);
i$1 = index;
} else if (hasBody && hasSeq(xmlData, "!ATTLIST", i$1)) i$1 += 8;
else if (hasBody && hasSeq(xmlData, "!NOTATION", i$1)) {
i$1 += 9;
const { index } = readNotationExp(xmlData, i$1 + 1);
i$1 = index;
} else if (hasSeq(xmlData, "!--", i$1)) comment = true;
else throw new Error("Invalid DOCTYPE");
angleBracketsCount++;
exp = "";
} else if (xmlData[i$1] === ">") {
if (comment) {
if (xmlData[i$1 - 1] === "-" && xmlData[i$1 - 2] === "-") {
comment = false;
angleBracketsCount--;
}
} else angleBracketsCount--;
if (angleBracketsCount === 0) break;
} else if (xmlData[i$1] === "[") hasBody = true;
else exp += xmlData[i$1];
if (angleBracketsCount !== 0) throw new Error(`Unclosed DOCTYPE`);
} else throw new Error(`Invalid Tag instead of DOCTYPE`);
return {
entities: entities$1,
i: i$1
};
}
const skipWhitespace = (data, index) => {
while (index < data.length && /\s/.test(data[index])) index++;
return index;
};
function readEntityExp(xmlData, i$1) {
i$1 = skipWhitespace(xmlData, i$1);
let entityName = "";
while (i$1 < xmlData.length && !/\s/.test(xmlData[i$1]) && xmlData[i$1] !== "\"" && xmlData[i$1] !== "'") {
entityName += xmlData[i$1];
i$1++;
}
validateEntityName(entityName);
i$1 = skipWhitespace(xmlData, i$1);
if (xmlData.substring(i$1, i$1 + 6).toUpperCase() === "SYSTEM") throw new Error("External entities are not supported");
else if (xmlData[i$1] === "%") throw new Error("Parameter entities are not supported");
let entityValue = "";
[i$1, entityValue] = readIdentifierVal(xmlData, i$1, "entity");
i$1--;
return [
entityName,
entityValue,
i$1
];
}
function readNotationExp(xmlData, i$1) {
i$1 = skipWhitespace(xmlData, i$1);
let notationName = "";
while (i$1 < xmlData.length && !/\s/.test(xmlData[i$1])) {
notationName += xmlData[i$1];
i$1++;
}
validateEntityName(notationName);
i$1 = skipWhitespace(xmlData, i$1);
const identifierType = xmlData.substring(i$1, i$1 + 6).toUpperCase();
if (identifierType !== "SYSTEM" && identifierType !== "PUBLIC") throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
i$1 += identifierType.length;
i$1 = skipWhitespace(xmlData, i$1);
let publicIdentifier = null;
let systemIdentifier = null;
if (identifierType === "PUBLIC") {
[i$1, publicIdentifier] = readIdentifierVal(xmlData, i$1, "publicIdentifier");
i$1 = skipWhitespace(xmlData, i$1);
if (xmlData[i$1] === "\"" || xmlData[i$1] === "'") [i$1, systemIdentifier] = readIdentifierVal(xmlData, i$1, "systemIdentifier");
} else if (identifierType === "SYSTEM") {
[i$1, systemIdentifier] = readIdentifierVal(xmlData, i$1, "systemIdentifier");
if (!systemIdentifier) throw new Error("Missing mandatory system identifier for SYSTEM notation");
}
return {
notationName,
publicIdentifier,
systemIdentifier,
index: --i$1
};
}
function readIdentifierVal(xmlData, i$1, type$1) {
let identifierVal = "";
const startChar = xmlData[i$1];
if (startChar !== "\"" && startChar !== "'") throw new Error(`Expected quoted string, found "${startChar}"`);
i$1++;
while (i$1 < xmlData.length && xmlData[i$1] !== startChar) {
identifierVal += xmlData[i$1];
i$1++;
}
if (xmlData[i$1] !== startChar) throw new Error(`Unterminated ${type$1} value`);
i$1++;
return [i$1, identifierVal];
}
function readElementExp(xmlData, i$1) {
i$1 = skipWhitespace(xmlData, i$1);
let elementName = "";
while (i$1 < xmlData.length && !/\s/.test(xmlData[i$1])) {
elementName += xmlData[i$1];
i$1++;
}
if (!validateEntityName(elementName)) throw new Error(`Invalid element name: "${elementName}"`);
i$1 = skipWhitespace(xmlData, i$1);
let contentModel = "";
if (xmlData[i$1] === "E" && hasSeq(xmlData, "MPTY", i$1)) i$1 += 6;
else if (xmlData[i$1] === "A" && hasSeq(xmlData, "NY", i$1)) i$1 += 4;
else if (xmlData[i$1] === "(") {
i$1++;
while (i$1 < xmlData.length && xmlData[i$1] !== ")") {
contentModel += xmlData[i$1];
i$1++;
}
if (xmlData[i$1] !== ")") throw new Error("Unterminated content model");
} else throw new Error(`Invalid Element Expression, found "${xmlData[i$1]}"`);
return {
elementName,
contentModel: contentModel.trim(),
index: i$1
};
}
function hasSeq(data, seq, i$1) {
for (let j = 0; j < seq.length; j++) if (seq[j] !== data[i$1 + j + 1]) return false;
return true;
}
function validateEntityName(name) {
if (isName(name)) return name;
else throw new Error(`Invalid entity name ${name}`);
}
//#endregion
//#region ../../node_modules/.pnpm/strnum@2.1.1/node_modules/strnum/strnum.js
const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
const consider = {
hex: true,
leadingZeros: true,
decimalPoint: ".",
eNotation: true
};
function toNumber(str, options = {}) {
options = Object.assign({}, consider, options);
if (!str || typeof str !== "string") return str;
let trimmedStr = str.trim();
if (options.skipLike !== void 0 && options.skipLike.test(trimmedStr)) return str;
else if (str === "0") return 0;
else if (options.hex && hexRegex.test(trimmedStr)) return parse_int(trimmedStr, 16);
else if (trimmedStr.search(/.+[eE].+/) !== -1) return resolveEnotation(str, trimmedStr, options);
else {
const match = numRegex.exec(trimmedStr);
if (match) {
const sign = match[1] || "";
const leadingZeros = match[2];
let numTrimmedByZeros = trimZeros(match[3]);
const decimalAdjacentToLeadingZeros = sign ? str[leadingZeros.length + 1] === "." : str[leadingZeros.length] === ".";
if (!options.leadingZeros && (leadingZeros.length > 1 || leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros)) return str;
else {
const num = Number(trimmedStr);
const parsedStr = String(num);
if (num === 0) return num;
if (parsedStr.search(/[eE]/) !== -1) if (options.eNotation) return num;
else return str;
else if (trimmedStr.indexOf(".") !== -1) if (parsedStr === "0") return num;
else if (parsedStr === numTrimmedByZeros) return num;
else if (parsedStr === `${sign}${numTrimmedByZeros}`) return num;
else return str;
let n = leadingZeros ? numTrimmedByZeros : trimmedStr;
if (leadingZeros) return n === parsedStr || sign + n === parsedStr ? num : str;
else return n === parsedStr || n === sign + parsedStr ? num : str;
}
} else return str;
}
}
const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
function resolveEnotation(str, trimmedStr, options) {
if (!options.eNotation) return str;
const notation = trimmedStr.match(eNotationRegx);
if (notation) {
let sign = notation[1] || "";
const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";
const leadingZeros = notation[2];
const eAdjacentToLeadingZeros = sign ? str[leadingZeros.length + 1] === eChar : str[leadingZeros.length] === eChar;
if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
else if (leadingZeros.length === 1 && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) return Number(trimmedStr);
else if (options.leadingZeros && !eAdjacentToLeadingZeros) {
trimmedStr = (notation[1] || "") + notation[3];
return Number(trimmedStr);
} else return str;
} else return str;
}
/**
*
* @param {string} numStr without leading zeros
* @returns
*/
function trimZeros(numStr) {
if (numStr && numStr.indexOf(".") !== -1) {
numStr = numStr.replace(/0+$/, "");
if (numStr === ".") numStr = "0";
else if (numStr[0] === ".") numStr = "0" + numStr;
else if (numStr[numStr.length - 1] === ".") numStr = numStr.substring(0, numStr.length - 1);
return numStr;
}
return numStr;
}
function parse_int(numStr, base) {
if (parseInt) return parseInt(numStr, base);
else if (Number.parseInt) return Number.parseInt(numStr, base);
else if (window && window.parseInt) return window.parseInt(numStr, base);
else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
}
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/ignoreAttributes.js
function getIgnoreAttributesFn(ignoreAttributes) {
if (typeof ignoreAttributes === "function") return ignoreAttributes;
if (Array.isArray(ignoreAttributes)) return (attrName) => {
for (const pattern$1 of ignoreAttributes) {
if (typeof pattern$1 === "string" && attrName === pattern$1) return true;
if (pattern$1 instanceof RegExp && pattern$1.test(attrName)) return true;
}
};
return () => false;
}
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
var OrderedObjParser = class {
constructor(options) {
this.options = options;
this.currentNode = null;
this.tagsNodeStack = [];
this.docTypeEntities = {};
this.lastEntities = {
"apos": {
regex: /&(apos|#39|#x27);/g,
val: "'"
},
"gt": {
regex: /&(gt|#62|#x3E);/g,
val: ">"
},
"lt": {
regex: /&(lt|#60|#x3C);/g,
val: "<"
},
"quot": {
regex: /&(quot|#34|#x22);/g,
val: "\""
}
};
this.ampEntity = {
regex: /&(amp|#38|#x26);/g,
val: "&"
};
this.htmlEntities = {
"space": {
regex: /&(nbsp|#160);/g,
val: " "
},
"cent": {
regex: /&(cent|#162);/g,
val: "¢"
},
"pound": {
regex: /&(pound|#163);/g,
val: "£"
},
"yen": {
regex: /&(yen|#165);/g,
val: "¥"
},
"euro": {
regex: /&(euro|#8364);/g,
val: "€"
},
"copyright": {
regex: /&(copy|#169);/g,
val: "©"
},
"reg": {
regex: /&(reg|#174);/g,
val: "®"
},
"inr": {
regex: /&(inr|#8377);/g,
val: "₹"
},
"num_dec": {
regex: /&#([0-9]{1,7});/g,
val: (_, str) => String.fromCodePoint(Number.parseInt(str, 10))
},
"num_hex": {
regex: /&#x([0-9a-fA-F]{1,6});/g,
val: (_, str) => String.fromCodePoint(Number.parseInt(str, 16))
}
};
this.addExternalEntities = addExternalEntities;
this.parseXml = parseXml;
this.parseTextData = parseTextData;
this.resolveNameSpace = resolveNameSpace;
this.buildAttributesMap = buildAttributesMap;
this.isItStopNode = isItStopNode;
this.replaceEntitiesValue = replaceEntitiesValue$1;
this.readStopNodeData = readStopNodeData;
this.saveTextToParentTag = saveTextToParentTag;
this.addChild = addChild;
this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
}
};
function addExternalEntities(externalEntities) {
const entKeys = Object.keys(externalEntities);
for (let i$1 = 0; i$1 < entKeys.length; i$1++) {
const ent = entKeys[i$1];
this.lastEntities[ent] = {
regex: new RegExp("&" + ent + ";", "g"),
val: externalEntities[ent]
};
}
}
/**
* @param {string} val
* @param {string} tagName
* @param {string} jPath
* @param {boolean} dontTrim
* @param {boolean} hasAttributes
* @param {boolean} isLeafNode
* @param {boolean} escapeEntities
*/
function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
if (val !== void 0) {
if (this.options.trimValues && !dontTrim) val = val.trim();
if (val.length > 0) {
if (!escapeEntities) val = this.replaceEntitiesValue(val);
const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
if (newval === null || newval === void 0) return val;
else if (typeof newval !== typeof val || newval !== val) return newval;
else if (this.options.trimValues) return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
else {
const trimmedVal = val.trim();
if (trimmedVal === val) return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
else return val;
}
}
}
}
function resolveNameSpace(tagname) {
if (this.options.removeNSPrefix) {
const tags = tagname.split(":");
const prefix = tagname.charAt(0) === "/" ? "/" : "";
if (tags[0] === "xmlns") return "";
if (tags.length === 2) tagname = prefix + tags[1];
}
return tagname;
}
const attrsRegx = new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?", "gm");
function buildAttributesMap(attrStr, jPath, tagName) {
if (this.options.ignoreAttributes !== true && typeof attrStr === "string") {
const matches = getAllMatches(attrStr, attrsRegx);
const len$1 = matches.length;
const attrs = {};
for (let i$1 = 0; i$1 < len$1; i$1++) {
const attrName = this.resolveNameSpace(matches[i$1][1]);
if (this.ignoreAttributesFn(attrName, jPath)) continue;
let oldVal = matches[i$1][4];
let aName = this.options.attributeNamePrefix + attrName;
if (attrName.length) {
if (this.options.transformAttributeName) aName = this.options.transformAttributeName(aName);
if (aName === "__proto__") aName = "#__proto__";
if (oldVal !== void 0) {
if (this.options.trimValues) oldVal = oldVal.trim();
oldVal = this.replaceEntitiesValue(oldVal);
const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
if (newVal === null || newVal === void 0) attrs[aName] = oldVal;
else if (typeof newVal !== typeof oldVal || newVal !== oldVal) attrs[aName] = newVal;
else attrs[aName] = parseValue(oldVal, this.options.parseAttributeValue, this.options.numberParseOptions);
} else if (this.options.allowBooleanAttributes) attrs[aName] = true;
}
}
if (!Object.keys(attrs).length) return;
if (this.options.attributesGroupName) {
const attrCollection = {};
attrCollection[this.options.attributesGroupName] = attrs;
return attrCollection;
}
return attrs;
}
}
const parseXml = function(xmlData) {
xmlData = xmlData.replace(/\r\n?/g, "\n");
const xmlObj = new XmlNode("!xml");
let currentNode = xmlObj;
let textData = "";
let jPath = "";
for (let i$1 = 0; i$1 < xmlData.length; i$1++) {
const ch = xmlData[i$1];
if (ch === "<") if (xmlData[i$1 + 1] === "/") {
const closeIndex = findClosingIndex(xmlData, ">", i$1, "Closing Tag is not closed.");
let tagName = xmlData.substring(i$1 + 2, closeIndex).trim();
if (this.options.removeNSPrefix) {
const colonIndex = tagName.indexOf(":");
if (colonIndex !== -1) tagName = tagName.substr(colonIndex + 1);
}
if (this.options.transformTagName) tagName = this.options.transformTagName(tagName);
if (currentNode) textData = this.saveTextToParentTag(textData, currentNode, jPath);
const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
let propIndex = 0;
if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
propIndex = jPath.lastIndexOf(".", jPath.lastIndexOf(".") - 1);
this.tagsNodeStack.pop();
} else propIndex = jPath.lastIndexOf(".");
jPath = jPath.substring(0, propIndex);
currentNode = this.tagsNodeStack.pop();
textData = "";
i$1 = closeIndex;
} else if (xmlData[i$1 + 1] === "?") {
let tagData = readTagExp(xmlData, i$1, false, "?>");
if (!tagData) throw new Error("Pi Tag is not closed.");
textData = this.saveTextToParentTag(textData, currentNode, jPath);
if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {} else {
const childNode = new XmlNode(tagData.tagName);
childNode.add(this.options.textNodeName, "");
if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
this.addChild(currentNode, childNode, jPath, i$1);
}
i$1 = tagData.closeIndex + 1;
} else if (xmlData.substr(i$1 + 1, 3) === "!--") {
const endIndex = findClosingIndex(xmlData, "-->", i$1 + 4, "Comment is not closed.");
if (this.options.commentPropName) {
const comment = xmlData.substring(i$1 + 4, endIndex - 2);
textData = this.saveTextToParentTag(textData, currentNode, jPath);
currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
}
i$1 = endIndex;
} else if (xmlData.substr(i$1 + 1, 2) === "!D") {
const result = readDocType(xmlData, i$1);
this.docTypeEntities = result.entities;
i$1 = result.i;
} else if (xmlData.substr(i$1 + 1, 2) === "![") {
const closeIndex = findClosingIndex(xmlData, "]]>", i$1, "CDATA is not closed.") - 2;
const tagExp = xmlData.substring(i$1 + 9, closeIndex);
textData = this.saveTextToParentTag(textData, currentNode, jPath);
let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
if (val == void 0) val = "";
if (this.options.cdataPropName) currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
else currentNode.add(this.options.textNodeName, val);
i$1 = closeIndex + 2;
} else {
let result = readTagExp(xmlData, i$1, this.options.removeNSPrefix);
let tagName = result.tagName;
const rawTagName = result.rawTagName;
let tagExp = result.tagExp;
let attrExpPresent = result.attrExpPresent;
let closeIndex = result.closeIndex;
if (this.options.transformTagName) tagName = this.options.transformTagName(tagName);
if (currentNode && textData) {
if (currentNode.tagname !== "!xml") textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
}
const lastTag = currentNode;
if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
currentNode = this.tagsNodeStack.pop();
jPath = jPath.substring(0, jPath.lastIndexOf("."));
}
if (tagName !== xmlObj.tagname) jPath += jPath ? "." + tagName : tagName;
const startIndex = i$1;
if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
let tagContent = "";
if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
if (tagName[tagName.length - 1] === "/") {
tagName = tagName.substr(0, tagName.length - 1);
jPath = jPath.substr(0, jPath.length - 1);
tagExp = tagName;
} else tagExp = tagExp.substr(0, tagExp.length - 1);
i$1 = result.closeIndex;
} else if (this.options.unpairedTags.indexOf(tagName) !== -1) i$1 = result.closeIndex;
else {
const result$1 = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
if (!result$1) throw new Error(`Unexpected end of ${rawTagName}`);
i$1 = result$1.i;
tagContent = result$1.tagContent;
}
const childNode = new XmlNode(tagName);
if (tagName !== tagExp && attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
if (tagContent) tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
jPath = jPath.substr(0, jPath.lastIndexOf("."));
childNode.add(this.options.textNodeName, tagContent);
this.addChild(currentNode, childNode, jPath, startIndex);
} else {
if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
if (tagName[tagName.length - 1] === "/") {
tagName = tagName.substr(0, tagName.length - 1);
jPath = jPath.substr(0, jPath.length - 1);
tagExp = tagName;
} else tagExp = tagExp.substr(0, tagExp.length - 1);
if (this.options.transformTagName) tagName = this.options.transformTagName(tagName);
const childNode = new XmlNode(tagName);
if (tagName !== tagExp && attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
this.addChild(currentNode, childNode, jPath, startIndex);
jPath = jPath.substr(0, jPath.lastIndexOf("."));
} else {
const childNode = new XmlNode(tagName);
this.tagsNodeStack.push(currentNode);
if (tagName !== tagExp && attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
this.addChild(currentNode, childNode, jPath, startIndex);
currentNode = childNode;
}
textData = "";
i$1 = closeIndex;
}
}
else textData += xmlData[i$1];
}
return xmlObj.child;
};
function addChild(currentNode, childNode, jPath, startIndex) {
if (!this.options.captureMetaData) startIndex = void 0;
const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
if (result === false) {} else if (typeof result === "string") {
childNode.tagname = result;
currentNode.addChild(childNode, startIndex);
} else currentNode.addChild(childNode, startIndex);
}
const replaceEntitiesValue$1 = function(val) {
if (this.options.processEntities) {
for (let entityName in this.docTypeEntities) {
const entity = this.docTypeEntities[entityName];
val = val.replace(entity.regx, entity.val);
}
for (let entityName in this.lastEntities) {
const entity = this.lastEntities[entityName];
val = val.replace(entity.regex, entity.val);
}
if (this.options.htmlEntities) for (let entityName in this.htmlEntities) {
const entity = this.htmlEntities[entityName];
val = val.replace(entity.regex, entity.val);
}
val = val.replace(this.ampEntity.regex, this.ampEntity.val);
}
return val;
};
function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
if (textData) {
if (isLeafNode === void 0) isLeafNode = currentNode.child.length === 0;
textData = this.parseTextData(textData, currentNode.tagname, jPath, false, currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false, isLeafNode);
if (textData !== void 0 && textData !== "") currentNode.add(this.options.textNodeName, textData);
textData = "";
}
return textData;
}
/**
*
* @param {string[]} stopNodes
* @param {string} jPath
* @param {string} currentTagName
*/
function isItStopNode(stopNodes, jPath, currentTagName) {
const allNodesExp = "*." + currentTagName;
for (const stopNodePath in stopNodes) {
const stopNodeExp = stopNodes[stopNodePath];
if (allNodesExp === stopNodeExp || jPath === stopNodeExp) return true;
}
return false;
}
/**
* Returns the tag Expression and where it is ending handling single-double quotes situation
* @param {string} xmlData
* @param {number} i starting index
* @returns
*/
function tagExpWithClosingIndex(xmlData, i$1, closingChar = ">") {
let attrBoundary;
let tagExp = "";
for (let index = i$1; index < xmlData.length; index++) {
let ch = xmlData[index];
if (attrBoundary) {
if (ch === attrBoundary) attrBoundary = "";
} else if (ch === "\"" || ch === "'") attrBoundary = ch;
else if (ch === closingChar[0]) if (closingChar[1]) {
if (xmlData[index + 1] === closingChar[1]) return {
data: tagExp,
index
};
} else return {
data: tagExp,
index
};
else if (ch === " ") ch = " ";
tagExp += ch;
}
}
function findClosingIndex(xmlData, str, i$1, errMsg) {
const closingIndex = xmlData.indexOf(str, i$1);
if (closingIndex === -1) throw new Error(errMsg);
else return closingIndex + str.length - 1;
}
function readTagExp(xmlData, i$1, removeNSPrefix, closingChar = ">") {
const result = tagExpWithClosingIndex(xmlData, i$1 + 1, closingChar);
if (!result) return;
let tagExp = result.data;
const closeIndex = result.index;
const separatorIndex = tagExp.search(/\s/);
let tagName = tagExp;
let attrExpPresent = true;
if (separatorIndex !== -1) {
tagName = tagExp.substring(0, separatorIndex);
tagExp = tagExp.substring(separatorIndex + 1).trimStart();
}
const rawTagName = tagName;
if (removeNSPrefix) {
const colonIndex = tagName.indexOf(":");
if (colonIndex !== -1) {
tagName = tagName.substr(colonIndex + 1);
attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
}
}
return {
tagName,
tagExp,
closeIndex,
attrExpPresent,
rawTagName
};
}
/**
* find paired tag for a stop node
* @param {string} xmlData
* @param {string} tagName
* @param {number} i
*/
function readStopNodeData(xmlData, tagName, i$1) {
const startIndex = i$1;
let openTagCount = 1;
for (; i$1 < xmlData.length; i$1++) if (xmlData[i$1] === "<") if (xmlData[i$1 + 1] === "/") {
const closeIndex = findClosingIndex(xmlData, ">", i$1, `${tagName} is not closed`);
let closeTagName = xmlData.substring(i$1 + 2, closeIndex).trim();
if (closeTagName === tagName) {
openTagCount--;
if (openTagCount === 0) return {
tagContent: xmlData.substring(startIndex, i$1),
i: closeIndex
};
}
i$1 = closeIndex;
} else if (xmlData[i$1 + 1] === "?") {
const closeIndex = findClosingIndex(xmlData, "?>", i$1 + 1, "StopNode is not closed.");
i$1 = closeIndex;
} else if (xmlData.substr(i$1 + 1, 3) === "!--") {
const closeIndex = findClosingIndex(xmlData, "-->", i$1 + 3, "StopNode is not closed.");
i$1 = closeIndex;
} else if (xmlData.substr(i$1 + 1, 2) === "![") {
const closeIndex = findClosingIndex(xmlData, "]]>", i$1, "StopNode is not closed.") - 2;
i$1 = closeIndex;
} else {
const tagData = readTagExp(xmlData, i$1, ">");
if (tagData) {
const openTagName = tagData && tagData.tagName;
if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") openTagCount++;
i$1 = tagData.closeIndex;
}
}
}
function parseValue(val, shouldParse, options) {
if (shouldParse && typeof val === "string") {
const newval = val.trim();
if (newval === "true") return true;
else if (newval === "false") return false;
else return toNumber(val, options);
} else if (isExist(val)) return val;
else return "";
}
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/xmlparser/node2json.js
const METADATA_SYMBOL = XmlNode.getMetaDataSymbol();
/**
*
* @param {array} node
* @param {any} options
* @returns
*/
function prettify(node, options) {
return compress(node, options);
}
/**
*
* @param {array} arr
* @param {object} options
* @param {string} jPath
* @returns object
*/
function compress(arr, options, jPath) {
let text;
const compressedObj = {};
for (let i$1 = 0; i$1 < arr.length; i$1++) {
const tagObj = arr[i$1];
const property = propName$1(tagObj);
let newJpath = "";
if (jPath === void 0) newJpath = property;
else newJpath = jPath + "." + property;
if (property === options.textNodeName) if (text === void 0) text = tagObj[property];
else text += "" + tagObj[property];
else if (property === void 0) continue;
else if (tagObj[property]) {
let val = compress(tagObj[property], options, newJpath);
const isLeaf = isLeafTag(val, options);
if (tagObj[METADATA_SYMBOL] !== void 0) val[METADATA_SYMBOL] = tagObj[METADATA_SYMBOL];
if (tagObj[":@"]) assignAttributes(val, tagObj[":@"], newJpath, options);
else if (Object.keys(val).length === 1 && val[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) val = val[options.textNodeName];
else if (Object.keys(val).length === 0) if (options.alwaysCreateTextNode) val[options.textNodeName] = "";
else val = "";
if (compressedObj[property] !== void 0 && compressedObj.hasOwnProperty(property)) {
if (!Array.isArray(compressedObj[property])) compressedObj[property] = [compressedObj[property]];
compressedObj[property].push(val);
} else if (options.isArray(property, newJpath, isLeaf)) compressedObj[property] = [val];
else compressedObj[property] = val;
}
}
if (typeof text === "string") {
if (text.length > 0) compressedObj[options.textNodeName] = text;
} else if (text !== void 0) compressedObj[options.textNodeName] = text;
return compressedObj;
}
function propName$1(obj) {
const keys = Object.keys(obj);
for (let i$1 = 0; i$1 < keys.length; i$1++) {
const key = keys[i$1];
if (key !== ":@") return key;
}
}
function assignAttributes(obj, attrMap, jpath, options) {
if (attrMap) {
const keys = Object.keys(attrMap);
const len$1 = keys.length;
for (let i$1 = 0; i$1 < len$1; i$1++) {
const atrrName = keys[i$1];
if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) obj[atrrName] = [attrMap[atrrName]];
else obj[atrrName] = attrMap[atrrName];
}
}
}
function isLeafTag(obj, options) {
const { textNodeName } = options;
const propCount = Object.keys(obj).length;
if (propCount === 0) return true;
if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) return true;
return false;
}
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
var XMLParser = class {
constructor(options) {
this.externalEntities = {};
this.options = buildOptions(options);
}
/**
* Parse XML dats to JS object
* @param {string|Buffer} xmlData
* @param {boolean|Object} validationOption
*/
parse(xmlData, validationOption) {
if (typeof xmlData === "string") {} else if (xmlData.toString) xmlData = xmlData.toString();
else throw new Error("XML data is accepted in String or Bytes[] form.");
if (validationOption) {
if (validationOption === true) validationOption = {};
const result = validate(xmlData, validationOption);
if (result !== true) throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
}
const orderedObjParser = new OrderedObjParser(this.options);
orderedObjParser.addExternalEntities(this.externalEntities);
const orderedResult = orderedObjParser.parseXml(xmlData);
if (this.options.preserveOrder || orderedResult === void 0) return orderedResult;
else return prettify(orderedResult, this.options);
}
/**
* Add Entity which is not by default supported by this library
* @param {string} key
* @param {string} value
*/
addEntity(key, value) {
if (value.indexOf("&") !== -1) throw new Error("Entity value can't have '&'");
else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '
'");
else if (value === "&") throw new Error("An entity with value '&' is not permitted");
else this.externalEntities[key] = value;
}
/**
* Returns a Symbol that can be used to access the metadata
* property on a node.
*
* If Symbol is not available in the environment, an ordinary property is used
* and the name of the property is here returned.
*
* The XMLMetaData property is only present when `captureMetaData`
* is true in the options.
*/
static getMetaDataSymbol() {
return XmlNode.getMetaDataSymbol();
}
};
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js
const EOL = "\n";
/**
*
* @param {array} jArray
* @param {any} options
* @returns
*/
function toXml(jArray, options) {
let indentation = "";
if (options.format && options.indentBy.length > 0) indentation = EOL;
return arrToStr(jArray, options, "", indentation);
}
function arrToStr(arr, options, jPath, indentation) {
let xmlStr = "";
let isPreviousElementTag = false;
for (let i$1 = 0; i$1 < arr.length; i$1++) {
const tagObj = arr[i$1];
const tagName = propName(tagObj);
if (tagName === void 0) continue;
let newJPath = "";
if (jPath.length === 0) newJPath = tagName;
else newJPath = `${jPath}.${tagName}`;
if (tagName === options.textNodeName) {
let tagText = tagObj[tagName];
if (!isStopNode(newJPath, options)) {
tagText = options.tagValueProcessor(tagName, tagText);
tagText = replaceEntitiesValue(tagText, options);
}
if (isPreviousElementTag) xmlStr += indentation;
xmlStr += tagText;
isPreviousElementTag = false;
continue;
} else if (tagName === options.cdataPropName) {
if (isPreviousElementTag) xmlStr += indentation;
xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
isPreviousElementTag = false;
continue;
} else if (tagName === options.commentPropName) {
xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
isPreviousElementTag = true;
continue;
} else if (tagName[0] === "?") {
const attStr$1 = attr_to_str(tagObj[":@"], options);
const tempInd = tagName === "?xml" ? "" : indentation;
let piTextNodeName = tagObj[tagName][0][options.textNodeName];
piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : "";
xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr$1}?>`;
isPreviousElementTag = true;
continue;
}
let newIdentation = indentation;
if (newIdentation !== "") newIdentation += options.indentBy;
const attStr = attr_to_str(tagObj[":@"], options);
const tagStart = indentation + `<${tagName}${attStr}`;
const tagValue = arrToStr(tagObj[tagName], options, newJPath, newIdentation);
if (options.unpairedTags.indexOf(tagName) !== -1) if (options.suppressUnpairedNode) xmlStr += tagStart + ">";
else xmlStr += tagStart + "/>";
else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) xmlStr += tagStart + "/>";
else if (tagValue && tagValue.endsWith(">")) xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;
else {
xmlStr += tagStart + ">";
if (tagValue && indentation !== "" && (tagValue.includes("/>") || tagValue.includes("</"))) xmlStr += indentation + options.indentBy + tagValue + indentation;
else xmlStr += tagValue;
xmlStr += `</${tagName}>`;
}
isPreviousElementTag = true;
}
return xmlStr;
}
function propName(obj) {
const keys = Object.keys(obj);
for (let i$1 = 0; i$1 < keys.length; i$1++) {
const key = keys[i$1];
if (!obj.hasOwnProperty(key)) continue;
if (key !== ":@") return key;
}
}
function attr_to_str(attrMap, options) {
let attrStr = "";
if (attrMap && !options.ignoreAttributes) for (let attr in attrMap) {
if (!attrMap.hasOwnProperty(attr)) continue;
let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
attrVal = replaceEntitiesValue(attrVal, options);
if (attrVal === true && options.suppressBooleanAttributes) attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
else attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
}
return attrStr;
}
function isStopNode(jPath, options) {
jPath = jPath.substr(0, jPath.length - options.textNodeName.length - 1);
let tagName = jPath.substr(jPath.lastIndexOf(".") + 1);
for (let index in options.stopNodes) if (options.stopNodes[index] === jPath || options.stopNodes[index] === "*." + tagName) return true;
return false;
}
function replaceEntitiesValue(textValue, options) {
if (textValue && textValue.length > 0 && options.processEntities) for (let i$1 = 0; i$1 < options.entities.length; i$1++) {
const entity = options.entities[i$1];
textValue = textValue.replace(entity.regex, entity.val);
}
return textValue;
}
//#endregion
//#region ../../node_modules/.pnpm/fast-xml-parser@5.2.3/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js
const defaultOptions = {
attributeNamePrefix: "@_",
attributesGroupName: false,
textNodeName: "#text",
ignoreAttributes: true,
cdataPropName: false,
format: false,
indentBy: " ",
suppressEmptyNode: false,
suppressUnpairedNode: true,
suppressBooleanAttributes: true,
tagValueProcessor: function(key, a) {
return a;
},
attributeValueProcessor: function(attrName, a) {
return a;
},
preserveOrder: false,
commentPropName: false,
unpairedTags: [],
entities: [
{
regex: new RegExp("&", "g"),
val: "&"
},
{
regex: new RegExp(">", "g"),
val: ">"
},
{
regex: new RegExp("<", "g"),
val: "<"
},
{
regex: new RegExp("'", "g"),
val: "'"
},
{
regex: new RegExp("\"", "g"),
val: """
}
],
processEntities: true,
stopNodes: [],
oneListGroup: false
};
function Builder(options) {
this.options = Object.assign({}, defaultOptions, options);
if (this.options.ignoreAttributes === true || this.options.attributesGroupName) this.isAttribute = function() {
return false;
};
else {
this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
this.attrPrefixLen = this.options.attributeNamePrefix.length;
this.isAttribute = isAttribute;
}
this.processTextOrObjNode = processTextOrObjNode;
if (this.options.format) {
this.indentate = indentate;
this.tagEndChar = ">\n";
this.newLine = "\n";
} else {
this.indentate = function() {
return "";
};
this.tagEndChar = ">";
this.newLine = "";
}
}
Builder.prototype.build = function(jObj) {
if (this.options.preserveOrder) return toXml(jObj, this.options);
else {
if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) jObj = { [this.options.arrayNodeName]: jObj };
return this.j2x(jObj, 0, []).val;
}
};
Builder.prototype.j2x = function(jObj, level, ajPath) {
let attrStr = "";
let val = "";
const jPath = ajPath.join(".");
for (let key in jObj) {
if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
if (typeof jObj[key] === "undefined") {
if (this.isAttribute(key)) val += "";
} else if (jObj[key] === null) if (this.isAttribute(key)) val += "";
else if (key === this.options.cdataPropName) val += "";
else if (key[0] === "?") val += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
else val += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
else if (jObj[key] instanceof Date) val += this.buildTextValNode(jObj[key], key, "", level);
else if (typeof jObj[key] !== "object") {
const attr = this.isAttribute(key);
if (attr && !this.ignoreAttributesFn(attr, jPath)) attrStr += this.buildAttrPairStr(attr, "" + jObj[key]);
else if (!attr) if (key === this.options.textNodeName) {
let newval = this.options.tagValueProcessor(key, "" + jObj[key]);
val += this.replaceEntitiesValue(newval);
} else val += this.buildTextValNode(jObj[key], key, "", level);
} else if (Array.isArray(jObj[key])) {
const arrLen = jObj[key].length;
let listTagVal = "";
let listTagAttr = "";
for (let j = 0; j < arrLen; j++) {
const item = jObj[key][j];
if (typeof item === "undefined") {} else if (item === null) if (key[0] === "?") val += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
else val += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
else if (typeof item === "object") if (this.options.oneListGroup) {
const result = this.j2x(item, level + 1, ajPath.concat(key));
listTagVal += result.val;
if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) listTagAttr += result.attrStr;
} else listTagVal += this.processTextOrObjNode(item, key, level, ajPath);
else if (this.options.oneListGroup) {
let textValue = this.options.tagValueProcessor(key, item);
textValue = this.replaceEntitiesValue(textValue);
listTagVal += textValue;
} else listTagVal += this.buildTextValNode(item, key, "", level);
}
if (this.options.oneListGroup) listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);
val += listTagVal;
} else if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
const Ks = Object.keys(jObj[key]);
const L = Ks.length;
for (let j = 0; j < L; j++) attrStr += this.buildAttrPairStr(Ks[j], "" + jObj[key][Ks[j]]);
} else val += this.processTextOrObjNode(jObj[key], key, level, ajPath);
}
return {
attrStr,
val
};
};
Builder.prototype.buildAttrPairStr = function(attrName, val) {
val = this.options.attributeValueProcessor(attrName, "" + val);
val = this.replaceEntitiesValue(val);
if (this.options.suppressBooleanAttributes && val === "true") return " " + attrName;
else return " " + attrName + "=\"" + val + "\"";
};
function processTextOrObjNode(object, key, level, ajPath) {
const result = this.j2x(object, level + 1, ajPath.concat(key));
if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
else return this.buildObjectNode(result.val, key, result.attrStr, level);
}
Builder.prototype.buildObjectNode = function(val, key, attrStr, level) {
if (val === "") if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
else return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
else {
let tagEndExp = "</" + key + this.tagEndChar;
let piClosingChar = "";
if (key[0] === "?") {
piClosingChar = "?";
tagEndExp = "";
}
if ((attrStr || attrStr === "") && val.indexOf("<") === -1) return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val + tagEndExp;
else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) return this.indentate(level) + `<!--${val}-->` + this.newLine;
else return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val + this.indentate(level) + tagEndExp;
}
};
Builder.prototype.closeTag = function(key) {
let closeTag = "";
if (this.options.unpairedTags.indexOf(key) !== -1) {
if (!this.options.suppressUnpairedNode) closeTag = "/";
} else if (this.options.suppressEmptyNode) closeTag = "/";
else closeTag = `></${key}`;
return closeTag;
};
Builder.prototype.buildTextValNode = function(val, key, attrStr, level) {
if (this.options.cdataPropName !== false && key === this.options.cdataPropName) return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;
else if (this.options.commentPropName !== false && key === this.options.commentPropName) return this.indentate(level) + `<!--${val}-->` + this.newLine;
else if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
else {
let textValue = this.options.tagValueProcessor(key, val);
textValue = this.replaceEntitiesValue(textValue);
if (textValue === "") return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
else return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
}
};
Builder.prototype.replaceEntitiesValue = function(textValue) {
if (textValue && textValue.length > 0 && this.options.processEntities) for (let i$1 = 0; i$1 < this.options.entities.length; i$1++) {
const entity = this.options.entities[i$1];
textValue = textValue.replace(entity.regex, entity.val);
}
return textValue;
};
function indentate(level) {
return this.options.indentBy.repeat(level);
}
function isAttribute(name) {
if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) return name.substr(this.attrPrefixLen);
else return false;
}
//#endregion
//#region src/utils/configParser/androidParser.ts
var AndroidConfigParser = class {
stringsXmlPath;
parser;
builder;
constructor() {
this.stringsXmlPath = path.join(getCwd(), "android", "app", "src", "main", "res", "values", "strings.xml");
const options = {
ignoreAttributes: false,
attributeNamePrefix: "@_",
textNodeName: "#text",
format: true,
indentBy: " ",
suppressEmptyNode: true
};
this.parser = new XMLParser(options);
this.builder = new Builder({
...options,
format: true,
indentBy: " ",
suppressBooleanAttributes: false,
processEntities: true
});
}
async exists() {
return fs$1.existsSync(this.stringsXmlPath);
}
async get(key) {
if (!await this.exists()) return {
value: null,
path: path.relative(getCwd(), this.stringsXmlPath)
};
try {
const content = await fs$1.promises.readFile(this.stringsXmlPath, "utf-8");
const result = this.parser.parse(content);
if (!result.resources.string) return {
value: null,
path: path.relative(getCwd(), this.stringsXmlPath)
};
const strings = Array.isArray(result.resources.string) ? result.resources.string : [result.resources.string];
const stringElement = strings.find((str) => str["@_name"] === key && str["@_moduleConfig"] === "true");
return {
value: stringElement?.["#text"]?.trim() ?? null,
path: path.relative(getCwd(), this.stringsXmlPath)
};
} catch (error) {
return {
value: null,
path: path.relative(getCwd(), this.stringsXmlPath)
};
}
}
async set(key, value) {
if (!await this.exists()) {
console.warn("hot-updater: strings.xml not found. Skipping Android-specific config modifications.");
return { path: null };
}
const content = await fs$1.promises.readFile(this.stringsXmlPath, "utf-8");
try {
const result = this.parser.parse(content);
if (!result.resources.string) result.resources.string = [];
const strings = Array.isArray(result.resources.string) ? result.resources.string : [result.resources.string];
const existingIndex = strings.findIndex((str) => str["@_name"] === key && str["@_moduleConfig"] === "true");
const stringElement = {
"@_name": key,
"@_moduleConfig": "true",
"#text": value
};
if (existingIndex !== -1) strings[existingIndex] = stringElement;
else strings.push(stringElement);
result.resources.string = strings.length === 1 ? strings[0] : strings;
const newContent = this.builder.build(result);
await fs$1.promises.writeFile(this.stringsXmlPath, newContent, "utf-8");
return { path: path.relative(getCwd(), this.stringsXmlPath) };
} catch (error) {
throw new Error(`Failed to parse or update strings.xml: ${error}`);
}
}
};
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.js
var require_array = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.splitWhen = exports.flatten = void 0;
function flatten(items) {
return items.reduce((collection, item) => [].concat(collection, item), []);
}
exports.flatten = flatten;
function splitWhen(items, predicate) {
const result = [[]];
let groupIndex = 0;
for (const item of items) if (predicate(item)) {
groupIndex++;
result[groupIndex] = [];
} else result[groupIndex].push(item);
return result;
}
exports.splitWhen = splitWhen;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/errno.js
var require_errno = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/errno.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.isEnoentCodeError = void 0;
function isEnoentCodeError(error) {
return error.code === "ENOENT";
}
exports.isEnoentCodeError = isEnoentCodeError;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/fs.js
var require_fs$3 = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/fs.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.createDirentFromStats = void 0;
var DirentFromStats$1 = class {
constructor(name, stats) {
this.name = name;
this.isBlockDevice = stats.isBlockDevice.bind(stats);
this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
this.isDirectory = stats.isDirectory.bind(stats);
this.isFIFO = stats.isFIFO.bind(stats);
this.isFile = stats.isFile.bind(stats);
this.isSocket = stats.isSocket.bind(stats);
this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
}
};
function createDirentFromStats$1(name, stats) {
return new DirentFromStats$1(name, stats);
}
exports.createDirentFromStats = createDirentFromStats$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/path.js
var require_path = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/path.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
const os$1 = __require("os");
const path$10 = __require("path");
const IS_WINDOWS_PLATFORM = os$1.platform() === "win32";
const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
/**
* All non-escaped special characters.
* Posix: ()*?[]{|}, !+@ before (, ! at the beginning, \\ before non-special characters.
* Windows: (){}[], !+@ before (, ! at the beginning.
*/
const POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
const WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
/**
* The device path (\\.\ or \\?\).
* https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths
*/
const DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
/**
* All backslashes except those escaping special characters.
* Windows: !()+@{}
* https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
*/
const WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
/**
* Designed to work only with simple paths: `dir\\file`.
*/
function unixify(filepath) {
return filepath.replace(/\\/g, "/");
}
exports.unixify = unixify;
function makeAbsolute(cwd, filepath) {
return path$10.resolve(cwd, filepath);
}
exports.makeAbsolute = makeAbsolute;
function removeLeadingDotSegment(entry) {
if (entry.charAt(0) === ".") {
const secondCharactery = entry.charAt(1);
if (secondCharactery === "/" || secondCharactery === "\\") return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
}
return entry;
}
exports.removeLeadingDotSegment = removeLeadingDotSegment;
exports.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
function escapeWindowsPath(pattern$1) {
return pattern$1.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
}
exports.escapeWindowsPath = escapeWindowsPath;
function escapePosixPath(pattern$1) {
return pattern$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
}
exports.escapePosixPath = escapePosixPath;
exports.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
function convertWindowsPathToPattern(filepath) {
return escapeWindowsPath(filepath).replace(DOS_DEVICE_PATH_RE, "//$1").replace(WINDOWS_BACKSLASHES_RE, "/");
}
exports.convertWindowsPathToPattern = convertWindowsPathToPattern;
function convertPosixPathToPattern(filepath) {
return escapePosixPath(filepath);
}
exports.convertPosixPathToPattern = convertPosixPathToPattern;
} });
//#endregion
//#region ../../node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js
var require_is_extglob = __commonJS({ "../../node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js"(exports, module) {
/*!
* is-extglob <https://github.com/jonschlinkert/is-extglob>
*
* Copyright (c) 2014-2016, Jon Schlinkert.
* Licensed under the MIT License.
*/
module.exports = function isExtglob$1(str) {
if (typeof str !== "string" || str === "") return false;
var match;
while (match = /(\\).|([@?!+*]\(.*\))/g.exec(str)) {
if (match[2]) return true;
str = str.slice(match.index + match[0].length);
}
return false;
};
} });
//#endregion
//#region ../../node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js
var require_is_glob = __commonJS({ "../../node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js"(exports, module) {
/*!
* is-glob <https://github.com/jonschlinkert/is-glob>
*
* Copyright (c) 2014-2017, Jon Schlinkert.
* Released under the MIT License.
*/
var isExtglob = require_is_extglob();
var chars = {
"{": "}",
"(": ")",
"[": "]"
};
var strictCheck = function(str) {
if (str[0] === "!") return true;
var index = 0;
var pipeIndex = -2;
var closeSquareIndex = -2;
var closeCurlyIndex = -2;
var closeParenIndex = -2;
var backSlashIndex = -2;
while (index < str.length) {
if (str[index] === "*") return true;
if (str[index + 1] === "?" && /[\].+)]/.test(str[index])) return true;
if (closeSquareIndex !== -1 && str[index] === "[" && str[index + 1] !== "]") {
if (closeSquareIndex < index) closeSquareIndex = str.indexOf("]", index);
if (closeSquareIndex > index) {
if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) return true;
backSlashIndex = str.indexOf("\\", index);
if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) return true;
}
}
if (closeCurlyIndex !== -1 && str[index] === "{" && str[index + 1] !== "}") {
closeCurlyIndex = str.indexOf("}", index);
if (closeCurlyIndex > index) {
backSlashIndex = str.indexOf("\\", index);
if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) return true;
}
}
if (closeParenIndex !== -1 && str[index] === "(" && str[index + 1] === "?" && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ")") {
closeParenIndex = str.indexOf(")", index);
if (closeParenIndex > index) {
backSlashIndex = str.indexOf("\\", index);
if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) return true;
}
}
if (pipeIndex !== -1 && str[index] === "(" && str[index + 1] !== "|") {
if (pipeIndex < index) pipeIndex = str.indexOf("|", index);
if (pipeIndex !== -1 && str[pipeIndex + 1] !== ")") {
closeParenIndex = str.indexOf(")", pipeIndex);
if (closeParenIndex > pipeIndex) {
backSlashIndex = str.indexOf("\\", pipeIndex);
if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) return true;
}
}
}
if (str[index] === "\\") {
var open = str[index + 1];
index += 2;
var close = chars[open];
if (close) {
var n = str.indexOf(close, index);
if (n !== -1) index = n + 1;
}
if (str[index] === "!") return true;
} else index++;
}
return false;
};
var relaxedCheck = function(str) {
if (str[0] === "!") return true;
var index = 0;
while (index < str.length) {
if (/[*?{}()[\]]/.test(str[index])) return true;
if (str[index] === "\\") {
var open = str[index + 1];
index += 2;
var close = chars[open];
if (close) {
var n = str.indexOf(close, index);
if (n !== -1) index = n + 1;
}
if (str[index] === "!") return true;
} else index++;
}
return false;
};
module.exports = function isGlob$1(str, options) {
if (typeof str !== "string" || str === "") return false;
if (isExtglob(str)) return true;
var check = strictCheck;
if (options && options.strict === false) check = relaxedCheck;
return check(str);
};
} });
//#endregion
//#region ../../node_modules/.pnpm/glob-parent@5.1.2/node_modules/glob-parent/index.js
var require_glob_parent = __commonJS({ "../../node_modules/.pnpm/glob-parent@5.1.2/node_modules/glob-parent/index.js"(exports, module) {
var isGlob = require_is_glob();
var pathPosixDirname = __require("path").posix.dirname;
var isWin32 = __require("os").platform() === "win32";
var slash = "/";
var backslash = /\\/g;
var enclosure = /[\{\[].*[\}\]]$/;
var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
/**
* @param {string} str
* @param {Object} opts
* @param {boolean} [opts.flipBackslashes=true]
* @returns {string}
*/
module.exports = function globParent$1(str, opts) {
var options = Object.assign({ flipBackslashes: true }, opts);
if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) str = str.replace(backslash, slash);
if (enclosure.test(str)) str += slash;
str += "a";
do
str = pathPosixDirname(str);
while (isGlob(str) || globby.test(str));
return str.replace(escaped, "$1");
};
} });
//#endregion
//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js
var require_utils$3 = __commonJS({ "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js"(exports) {
exports.isInteger = (num) => {
if (typeof num === "number") return Number.isInteger(num);
if (typeof num === "string" && num.trim() !== "") return Number.isInteger(Number(num));
return false;
};
/**
* Find a node of the given type
*/
exports.find = (node, type$1) => node.nodes.find((node$1) => node$1.type === type$1);
/**
* Find a node of the given type
*/
exports.exceedsLimit = (min, max, step = 1, limit) => {
if (limit === false) return false;
if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
return (Number(max) - Number(min)) / Number(step) >= limit;
};
/**
* Escape the given node with '\\' before node.value
*/
exports.escapeNode = (block, n = 0, type$1) => {
const node = block.nodes[n];
if (!node) return;
if (type$1 && node.type === type$1 || node.type === "open" || node.type === "close") {
if (node.escaped !== true) {
node.value = "\\" + node.value;
node.escaped = true;
}
}
};
/**
* Returns true if the given brace node should be enclosed in literal braces
*/
exports.encloseBrace = (node) => {
if (node.type !== "brace") return false;
if (node.commas >> 0 + node.ranges >> 0 === 0) {
node.invalid = true;
return true;
}
return false;
};
/**
* Returns true if a brace node is invalid.
*/
exports.isInvalidBrace = (block) => {
if (block.type !== "brace") return false;
if (block.invalid === true || block.dollar) return true;
if (block.commas >> 0 + block.ranges >> 0 === 0) {
block.invalid = true;
return true;
}
if (block.open !== true || block.close !== true) {
block.invalid = true;
return true;
}
return false;
};
/**
* Returns true if a node is an open or close node
*/
exports.isOpenOrClose = (node) => {
if (node.type === "open" || node.type === "close") return true;
return node.open === true || node.close === true;
};
/**
* Reduce an array of text nodes.
*/
exports.reduce = (nodes) => nodes.reduce((acc, node) => {
if (node.type === "text") acc.push(node.value);
if (node.type === "range") node.type = "text";
return acc;
}, []);
/**
* Flatten an array
*/
exports.flatten = (...args) => {
const result = [];
const flat = (arr) => {
for (let i$1 = 0; i$1 < arr.length; i$1++) {
const ele = arr[i$1];
if (Array.isArray(ele)) {
flat(ele);
continue;
}
if (ele !== void 0) result.push(ele);
}
return result;
};
flat(args);
return result;
};
} });
//#endregion
//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js
var require_stringify = __commonJS({ "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js"(exports, module) {
const utils$16 = require_utils$3();
module.exports = (ast, options = {}) => {
const stringify$4 = (node, parent = {}) => {
const invalidBlock = options.escapeInvalid && utils$16.isInvalidBrace(parent);
const invalidNode = node.invalid === true && options.escapeInvalid === true;
let output = "";
if (node.value) {
if ((invalidBlock || invalidNode) && utils$16.isOpenOrClose(node)) return "\\" + node.value;
return node.value;
}
if (node.value) return node.value;
if (node.nodes) for (const child of node.nodes) output += stringify$4(child);
return output;
};
return stringify$4(ast);
};
} });
//#endregion
//#region ../../node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js
var require_is_number = __commonJS({ "../../node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js"(exports, module) {
module.exports = function(num) {
if (typeof num === "number") return num - num === 0;
if (typeof num === "string" && num.trim() !== "") return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
return false;
};
} });
//#endregion
//#region ../../node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js
var require_to_regex_range = __commonJS({ "../../node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js"(exports, module) {
const isNumber$1 = require_is_number();
const toRegexRange$1 = (min, max, options) => {
if (isNumber$1(min) === false) throw new TypeError("toRegexRange: expected the first argument to be a number");
if (max === void 0 || min === max) return String(min);
if (isNumber$1(max) === false) throw new TypeError("toRegexRange: expected the second argument to be a number.");
let opts = {
relaxZeros: true,
...options
};
if (typeof opts.strictZeros === "boolean") opts.relaxZeros = opts.strictZeros === false;
let relax = String(opts.relaxZeros);
let shorthand = String(opts.shorthand);
let capture = String(opts.capture);
let wrap = String(opts.wrap);
let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
if (toRegexRange$1.cache.hasOwnProperty(cacheKey)) return toRegexRange$1.cache[cacheKey].result;
let a = Math.min(min, max);
let b = Math.max(min, max);
if (Math.abs(a - b) === 1) {
let result = min + "|" + max;
if (opts.capture) return `(${result})`;
if (opts.wrap === false) return result;
return `(?:${result})`;
}
let isPadded = hasPadding(min) || hasPadding(max);
let state = {
min,
max,
a,
b
};
let positives = [];
let negatives = [];
if (isPadded) {
state.isPadded = isPadded;
state.maxLen = String(state.max).length;
}
if (a < 0) {
let newMin = b < 0 ? Math.abs(b) : 1;
negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
a = state.a = 0;
}
if (b >= 0) positives = splitToPatterns(a, b, state, opts);
state.negatives = negatives;
state.positives = positives;
state.result = collatePatterns(negatives, positives, opts);
if (opts.capture === true) state.result = `(${state.result})`;
else if (opts.wrap !== false && positives.length + negatives.length > 1) state.result = `(?:${state.result})`;
toRegexRange$1.cache[cacheKey] = state;
return state.result;
};
function collatePatterns(neg, pos, options) {
let onlyNegative = filterPatterns(neg, pos, "-", false, options) || [];
let onlyPositive = filterPatterns(pos, neg, "", false, options) || [];
let intersected = filterPatterns(neg, pos, "-?", true, options) || [];
let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
return subpatterns.join("|");
}
function splitToRanges(min, max) {
let nines = 1;
let zeros$1 = 1;
let stop = countNines(min, nines);
let stops = new Set([max]);
while (min <= stop && stop <= max) {
stops.add(stop);
nines += 1;
stop = countNines(min, nines);
}
stop = countZeros(max + 1, zeros$1) - 1;
while (min < stop && stop <= max) {
stops.add(stop);
zeros$1 += 1;
stop = countZeros(max + 1, zeros$1) - 1;
}
stops = [...stops];
stops.sort(compare);
return stops;
}
/**
* Convert a range to a regex pattern
* @param {Number} `start`
* @param {Number} `stop`
* @return {String}
*/
function rangeToPattern(start, stop, options) {
if (start === stop) return {
pattern: start,
count: [],
digits: 0
};
let zipped = zip(start, stop);
let digits = zipped.length;
let pattern$1 = "";
let count = 0;
for (let i$1 = 0; i$1 < digits; i$1++) {
let [startDigit, stopDigit] = zipped[i$1];
if (startDigit === stopDigit) pattern$1 += startDigit;
else if (startDigit !== "0" || stopDigit !== "9") pattern$1 += toCharacterClass(startDigit, stopDigit, options);
else count++;
}
if (count) pattern$1 += options.shorthand === true ? "\\d" : "[0-9]";
return {
pattern: pattern$1,
count: [count],
digits
};
}
function splitToPatterns(min, max, tok, options) {
let ranges = splitToRanges(min, max);
let tokens = [];
let start = min;
let prev;
for (let i$1 = 0; i$1 < ranges.length; i$1++) {
let max$1 = ranges[i$1];
let obj = rangeToPattern(String(start), String(max$1), options);
let zeros$1 = "";
if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
if (prev.count.length > 1) prev.count.pop();
prev.count.push(obj.count[0]);
prev.string = prev.pattern + toQuantifier(prev.count);
start = max$1 + 1;
continue;
}
if (tok.isPadded) zeros$1 = padZeros(max$1, tok, options);
obj.string = zeros$1 + obj.pattern + toQuantifier(obj.count);
tokens.push(obj);
start = max$1 + 1;
prev = obj;
}
return tokens;
}
function filterPatterns(arr, comparison, prefix, intersection, options) {
let result = [];
for (let ele of arr) {
let { string: string$1 } = ele;
if (!intersection && !contains(comparison, "string", string$1)) result.push(prefix + string$1);
if (intersection && contains(comparison, "string", string$1)) result.push(prefix + string$1);
}
return result;
}
/**
* Zip strings
*/
function zip(a, b) {
let arr = [];
for (let i$1 = 0; i$1 < a.length; i$1++) arr.push([a[i$1], b[i$1]]);
return arr;
}
function compare(a, b) {
return a > b ? 1 : b > a ? -1 : 0;
}
function contains(arr, key, val) {
return arr.some((ele) => ele[key] === val);
}
function countNines(min, len$1) {
return Number(String(min).slice(0, -len$1) + "9".repeat(len$1));
}
function countZeros(integer, zeros$1) {
return integer - integer % Math.pow(10, zeros$1);
}
function toQuantifier(digits) {
let [start = 0, stop = ""] = digits;
if (stop || start > 1) return `{${start + (stop ? "," + stop : "")}}`;
return "";
}
function toCharacterClass(a, b, options) {
return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
}
function hasPadding(str) {
return /^-?(0+)\d/.test(str);
}
function padZeros(value, tok, options) {
if (!tok.isPadded) return value;
let diff = Math.abs(tok.maxLen - String(value).length);
let relax = options.relaxZeros !== false;
switch (diff) {
case 0: return "";
case 1: return relax ? "0?" : "0";
case 2: return relax ? "0{0,2}" : "00";
default: return relax ? `0{0,${diff}}` : `0{${diff}}`;
}
}
/**
* Cache
*/
toRegexRange$1.cache = {};
toRegexRange$1.clearCache = () => toRegexRange$1.cache = {};
/**
* Expose `toRegexRange`
*/
module.exports = toRegexRange$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js
var require_fill_range = __commonJS({ "../../node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js"(exports, module) {
const util$1 = __require("util");
const toRegexRange = require_to_regex_range();
const isObject$1 = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
const transform = (toNumber$1) => {
return (value) => toNumber$1 === true ? Number(value) : String(value);
};
const isValidValue = (value) => {
return typeof value === "number" || typeof value === "string" && value !== "";
};
const isNumber = (num) => Number.isInteger(+num);
const zeros = (input) => {
let value = `${input}`;
let index = -1;
if (value[0] === "-") value = value.slice(1);
if (value === "0") return false;
while (value[++index] === "0");
return index > 0;
};
const stringify$3 = (start, end, options) => {
if (typeof start === "string" || typeof end === "string") return true;
return options.stringify === true;
};
const pad = (input, maxLength, toNumber$1) => {
if (maxLength > 0) {
let dash = input[0] === "-" ? "-" : "";
if (dash) input = input.slice(1);
input = dash + input.padStart(dash ? maxLength - 1 : maxLength, "0");
}
if (toNumber$1 === false) return String(input);
return input;
};
const toMaxLen = (input, maxLength) => {
let negative = input[0] === "-" ? "-" : "";
if (negative) {
input = input.slice(1);
maxLength--;
}
while (input.length < maxLength) input = "0" + input;
return negative ? "-" + input : input;
};
const toSequence = (parts, options, maxLen) => {
parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
let prefix = options.capture ? "" : "?:";
let positives = "";
let negatives = "";
let result;
if (parts.positives.length) positives = parts.positives.map((v) => toMaxLen(String(v), maxLen)).join("|");
if (parts.negatives.length) negatives = `-(${prefix}${parts.negatives.map((v) => toMaxLen(String(v), maxLen)).join("|")})`;
if (positives && negatives) result = `${positives}|${negatives}`;
else result = positives || negatives;
if (options.wrap) return `(${prefix}${result})`;
return result;
};
const toRange = (a, b, isNumbers, options) => {
if (isNumbers) return toRegexRange(a, b, {
wrap: false,
...options
});
let start = String.fromCharCode(a);
if (a === b) return start;
let stop = String.fromCharCode(b);
return `[${start}-${stop}]`;
};
const toRegex = (start, end, options) => {
if (Array.isArray(start)) {
let wrap = options.wrap === true;
let prefix = options.capture ? "" : "?:";
return wrap ? `(${prefix}${start.join("|")})` : start.join("|");
}
return toRegexRange(start, end, options);
};
const rangeError = (...args) => {
return new RangeError("Invalid range arguments: " + util$1.inspect(...args));
};
const invalidRange = (start, end, options) => {
if (options.strictRanges === true) throw rangeError([start, end]);
return [];
};
const invalidStep = (step, options) => {
if (options.strictRanges === true) throw new TypeError(`Expected step "${step}" to be a number`);
return [];
};
const fillNumbers = (start, end, step = 1, options = {}) => {
let a = Number(start);
let b = Number(end);
if (!Number.isInteger(a) || !Number.isInteger(b)) {
if (options.strictRanges === true) throw rangeError([start, end]);
return [];
}
if (a === 0) a = 0;
if (b === 0) b = 0;
let descending = a > b;
let startString = String(start);
let endString = String(end);
let stepString = String(step);
step = Math.max(Math.abs(step), 1);
let padded = zeros(startString) || zeros(endString) || zeros(stepString);
let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
let toNumber$1 = padded === false && stringify$3(start, end, options) === false;
let format = options.transform || transform(toNumber$1);
if (options.toRegex && step === 1) return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
let parts = {
negatives: [],
positives: []
};
let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
let range = [];
let index = 0;
while (descending ? a >= b : a <= b) {
if (options.toRegex === true && step > 1) push(a);
else range.push(pad(format(a, index), maxLen, toNumber$1));
a = descending ? a - step : a + step;
index++;
}
if (options.toRegex === true) return step > 1 ? toSequence(parts, options, maxLen) : toRegex(range, null, {
wrap: false,
...options
});
return range;
};
const fillLetters = (start, end, step = 1, options = {}) => {
if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) return invalidRange(start, end, options);
let format = options.transform || ((val) => String.fromCharCode(val));
let a = `${start}`.charCodeAt(0);
let b = `${end}`.charCodeAt(0);
let descending = a > b;
let min = Math.min(a, b);
let max = Math.max(a, b);
if (options.toRegex && step === 1) return toRange(min, max, false, options);
let range = [];
let index = 0;
while (descending ? a >= b : a <= b) {
range.push(format(a, index));
a = descending ? a - step : a + step;
index++;
}
if (options.toRegex === true) return toRegex(range, null, {
wrap: false,
options
});
return range;
};
const fill$2 = (start, end, step, options = {}) => {
if (end == null && isValidValue(start)) return [start];
if (!isValidValue(start) || !isValidValue(end)) return invalidRange(start, end, options);
if (typeof step === "function") return fill$2(start, end, 1, { transform: step });
if (isObject$1(step)) return fill$2(start, end, 0, step);
let opts = { ...options };
if (opts.capture === true) opts.wrap = true;
step = step || opts.step || 1;
if (!isNumber(step)) {
if (step != null && !isObject$1(step)) return invalidStep(step, opts);
return fill$2(start, end, 1, step);
}
if (isNumber(start) && isNumber(end)) return fillNumbers(start, end, step, opts);
return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
};
module.exports = fill$2;
} });
//#endregion
//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js
var require_compile = __commonJS({ "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js"(exports, module) {
const fill$1 = require_fill_range();
const utils$15 = require_utils$3();
const compile$1 = (ast, options = {}) => {
const walk$1 = (node, parent = {}) => {
const invalidBlock = utils$15.isInvalidBrace(parent);
const invalidNode = node.invalid === true && options.escapeInvalid === true;
const invalid = invalidBlock === true || invalidNode === true;
const prefix = options.escapeInvalid === true ? "\\" : "";
let output = "";
if (node.isOpen === true) return prefix + node.value;
if (node.isClose === true) {
console.log("node.isClose", prefix, node.value);
return prefix + node.value;
}
if (node.type === "open") return invalid ? prefix + node.value : "(";
if (node.type === "close") return invalid ? prefix + node.value : ")";
if (node.type === "comma") return node.prev.type === "comma" ? "" : invalid ? node.value : "|";
if (node.value) return node.value;
if (node.nodes && node.ranges > 0) {
const args = utils$15.reduce(node.nodes);
const range = fill$1(...args, {
...options,
wrap: false,
toRegex: true,
strictZeros: true
});
if (range.length !== 0) return args.length > 1 && range.length > 1 ? `(${range})` : range;
}
if (node.nodes) for (const child of node.nodes) output += walk$1(child, node);
return output;
};
return walk$1(ast);
};
module.exports = compile$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js
var require_expand = __commonJS({ "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js"(exports, module) {
const fill = require_fill_range();
const stringify$2 = require_stringify();
const utils$14 = require_utils$3();
const append = (queue = "", stash = "", enclose = false) => {
const result = [];
queue = [].concat(queue);
stash = [].concat(stash);
if (!stash.length) return queue;
if (!queue.length) return enclose ? utils$14.flatten(stash).map((ele) => `{${ele}}`) : stash;
for (const item of queue) if (Array.isArray(item)) for (const value of item) result.push(append(value, stash, enclose));
else for (let ele of stash) {
if (enclose === true && typeof ele === "string") ele = `{${ele}}`;
result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
}
return utils$14.flatten(result);
};
const expand$1 = (ast, options = {}) => {
const rangeLimit = options.rangeLimit === void 0 ? 1e3 : options.rangeLimit;
const walk$1 = (node, parent = {}) => {
node.queue = [];
let p$2 = parent;
let q = parent.queue;
while (p$2.type !== "brace" && p$2.type !== "root" && p$2.parent) {
p$2 = p$2.parent;
q = p$2.queue;
}
if (node.invalid || node.dollar) {
q.push(append(q.pop(), stringify$2(node, options)));
return;
}
if (node.type === "brace" && node.invalid !== true && node.nodes.length === 2) {
q.push(append(q.pop(), ["{}"]));
return;
}
if (node.nodes && node.ranges > 0) {
const args = utils$14.reduce(node.nodes);
if (utils$14.exceedsLimit(...args, options.step, rangeLimit)) throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
let range = fill(...args, options);
if (range.length === 0) range = stringify$2(node, options);
q.push(append(q.pop(), range));
node.nodes = [];
return;
}
const enclose = utils$14.encloseBrace(node);
let queue = node.queue;
let block = node;
while (block.type !== "brace" && block.type !== "root" && block.parent) {
block = block.parent;
queue = block.queue;
}
for (let i$1 = 0; i$1 < node.nodes.length; i$1++) {
const child = node.nodes[i$1];
if (child.type === "comma" && node.type === "brace") {
if (i$1 === 1) queue.push("");
queue.push("");
continue;
}
if (child.type === "close") {
q.push(append(q.pop(), queue, enclose));
continue;
}
if (child.value && child.type !== "open") {
queue.push(append(queue.pop(), child.value));
continue;
}
if (child.nodes) walk$1(child, node);
}
return queue;
};
return utils$14.flatten(walk$1(ast));
};
module.exports = expand$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js
var require_constants$2 = __commonJS({ "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js"(exports, module) {
module.exports = {
MAX_LENGTH: 1e4,
CHAR_0: "0",
CHAR_9: "9",
CHAR_UPPERCASE_A: "A",
CHAR_LOWERCASE_A: "a",
CHAR_UPPERCASE_Z: "Z",
CHAR_LOWERCASE_Z: "z",
CHAR_LEFT_PARENTHESES: "(",
CHAR_RIGHT_PARENTHESES: ")",
CHAR_ASTERISK: "*",
CHAR_AMPERSAND: "&",
CHAR_AT: "@",
CHAR_BACKSLASH: "\\",
CHAR_BACKTICK: "`",
CHAR_CARRIAGE_RETURN: "\r",
CHAR_CIRCUMFLEX_ACCENT: "^",
CHAR_COLON: ":",
CHAR_COMMA: ",",
CHAR_DOLLAR: "$",
CHAR_DOT: ".",
CHAR_DOUBLE_QUOTE: "\"",
CHAR_EQUAL: "=",
CHAR_EXCLAMATION_MARK: "!",
CHAR_FORM_FEED: "\f",
CHAR_FORWARD_SLASH: "/",
CHAR_HASH: "#",
CHAR_HYPHEN_MINUS: "-",
CHAR_LEFT_ANGLE_BRACKET: "<",
CHAR_LEFT_CURLY_BRACE: "{",
CHAR_LEFT_SQUARE_BRACKET: "[",
CHAR_LINE_FEED: "\n",
CHAR_NO_BREAK_SPACE: "\xA0",
CHAR_PERCENT: "%",
CHAR_PLUS: "+",
CHAR_QUESTION_MARK: "?",
CHAR_RIGHT_ANGLE_BRACKET: ">",
CHAR_RIGHT_CURLY_BRACE: "}",
CHAR_RIGHT_SQUARE_BRACKET: "]",
CHAR_SEMICOLON: ";",
CHAR_SINGLE_QUOTE: "'",
CHAR_SPACE: " ",
CHAR_TAB: " ",
CHAR_UNDERSCORE: "_",
CHAR_VERTICAL_LINE: "|",
CHAR_ZERO_WIDTH_NOBREAK_SPACE: ""
};
} });
//#endregion
//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js
var require_parse$2 = __commonJS({ "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js"(exports, module) {
const stringify$1 = require_stringify();
/**
* Constants
*/
const { MAX_LENGTH: MAX_LENGTH$1, CHAR_BACKSLASH, CHAR_BACKTICK, CHAR_COMMA: CHAR_COMMA$1, CHAR_DOT: CHAR_DOT$1, CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1, CHAR_DOUBLE_QUOTE, CHAR_SINGLE_QUOTE, CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = require_constants$2();
/**
* parse
*/
const parse$5 = (input, options = {}) => {
if (typeof input !== "string") throw new TypeError("Expected a string");
const opts = options || {};
const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
if (input.length > max) throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
const ast = {
type: "root",
input,
nodes: []
};
const stack = [ast];
let block = ast;
let prev = ast;
let brackets = 0;
const length = input.length;
let index = 0;
let depth$1 = 0;
let value;
/**
* Helpers
*/
const advance = () => input[index++];
const push = (node) => {
if (node.type === "text" && prev.type === "dot") prev.type = "text";
if (prev && prev.type === "text" && node.type === "text") {
prev.value += node.value;
return;
}
block.nodes.push(node);
node.parent = block;
node.prev = prev;
prev = node;
return node;
};
push({ type: "bos" });
while (index < length) {
block = stack[stack.length - 1];
value = advance();
/**
* Invalid chars
*/
if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) continue;
/**
* Escaped chars
*/
if (value === CHAR_BACKSLASH) {
push({
type: "text",
value: (options.keepEscaping ? value : "") + advance()
});
continue;
}
/**
* Right square bracket (literal): ']'
*/
if (value === CHAR_RIGHT_SQUARE_BRACKET$1) {
push({
type: "text",
value: "\\" + value
});
continue;
}
/**
* Left square bracket: '['
*/
if (value === CHAR_LEFT_SQUARE_BRACKET$1) {
brackets++;
let next;
while (index < length && (next = advance())) {
value += next;
if (next === CHAR_LEFT_SQUARE_BRACKET$1) {
brackets++;
continue;
}
if (next === CHAR_BACKSLASH) {
value += advance();
continue;
}
if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
brackets--;
if (brackets === 0) break;
}
}
push({
type: "text",
value
});
continue;
}
/**
* Parentheses
*/
if (value === CHAR_LEFT_PARENTHESES$1) {
block = push({
type: "paren",
nodes: []
});
stack.push(block);
push({
type: "text",
value
});
continue;
}
if (value === CHAR_RIGHT_PARENTHESES$1) {
if (block.type !== "paren") {
push({
type: "text",
value
});
continue;
}
block = stack.pop();
push({
type: "text",
value
});
block = stack[stack.length - 1];
continue;
}
/**
* Quotes: '|"|`
*/
if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
const open = value;
let next;
if (options.keepQuotes !== true) value = "";
while (index < length && (next = advance())) {
if (next === CHAR_BACKSLASH) {
value += next + advance();
continue;
}
if (next === open) {
if (options.keepQuotes === true) value += next;
break;
}
value += next;
}
push({
type: "text",
value
});
continue;
}
/**
* Left curly brace: '{'
*/
if (value === CHAR_LEFT_CURLY_BRACE$1) {
depth$1++;
const dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
const brace = {
type: "brace",
open: true,
close: false,
dollar,
depth: depth$1,
commas: 0,
ranges: 0,
nodes: []
};
block = push(brace);
stack.push(block);
push({
type: "open",
value
});
continue;
}
/**
* Right curly brace: '}'
*/
if (value === CHAR_RIGHT_CURLY_BRACE$1) {
if (block.type !== "brace") {
push({
type: "text",
value
});
continue;
}
const type$1 = "close";
block = stack.pop();
block.close = true;
push({
type: type$1,
value
});
depth$1--;
block = stack[stack.length - 1];
continue;
}
/**
* Comma: ','
*/
if (value === CHAR_COMMA$1 && depth$1 > 0) {
if (block.ranges > 0) {
block.ranges = 0;
const open = block.nodes.shift();
block.nodes = [open, {
type: "text",
value: stringify$1(block)
}];
}
push({
type: "comma",
value
});
block.commas++;
continue;
}
/**
* Dot: '.'
*/
if (value === CHAR_DOT$1 && depth$1 > 0 && block.commas === 0) {
const siblings = block.nodes;
if (depth$1 === 0 || siblings.length === 0) {
push({
type: "text",
value
});
continue;
}
if (prev.type === "dot") {
block.range = [];
prev.value += value;
prev.type = "range";
if (block.nodes.length !== 3 && block.nodes.length !== 5) {
block.invalid = true;
block.ranges = 0;
prev.type = "text";
continue;
}
block.ranges++;
block.args = [];
continue;
}
if (prev.type === "range") {
siblings.pop();
const before = siblings[siblings.length - 1];
before.value += prev.value + value;
prev = before;
block.ranges--;
continue;
}
push({
type: "dot",
value
});
continue;
}
/**
* Text
*/
push({
type: "text",
value
});
}
do {
block = stack.pop();
if (block.type !== "root") {
block.nodes.forEach((node) => {
if (!node.nodes) {
if (node.type === "open") node.isOpen = true;
if (node.type === "close") node.isClose = true;
if (!node.nodes) node.type = "text";
node.invalid = true;
}
});
const parent = stack[stack.length - 1];
const index$1 = parent.nodes.indexOf(block);
parent.nodes.splice(index$1, 1, ...block.nodes);
}
} while (stack.length > 0);
push({ type: "eos" });
return ast;
};
module.exports = parse$5;
} });
//#endregion
//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js
var require_braces = __commonJS({ "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js"(exports, module) {
const stringify = require_stringify();
const compile = require_compile();
const expand = require_expand();
const parse$4 = require_parse$2();
/**
* Expand the given pattern or create a regex-compatible string.
*
* ```js
* const braces = require('braces');
* console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
* console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
* ```
* @param {String} `str`
* @param {Object} `options`
* @return {String}
* @api public
*/
const braces$1 = (input, options = {}) => {
let output = [];
if (Array.isArray(input)) for (const pattern$1 of input) {
const result = braces$1.create(pattern$1, options);
if (Array.isArray(result)) output.push(...result);
else output.push(result);
}
else output = [].concat(braces$1.create(input, options));
if (options && options.expand === true && options.nodupes === true) output = [...new Set(output)];
return output;
};
/**
* Parse the given `str` with the given `options`.
*
* ```js
* // braces.parse(pattern, [, options]);
* const ast = braces.parse('a/{b,c}/d');
* console.log(ast);
* ```
* @param {String} pattern Brace pattern to parse
* @param {Object} options
* @return {Object} Returns an AST
* @api public
*/
braces$1.parse = (input, options = {}) => parse$4(input, options);
/**
* Creates a braces string from an AST, or an AST node.
*
* ```js
* const braces = require('braces');
* let ast = braces.parse('foo/{a,b}/bar');
* console.log(stringify(ast.nodes[2])); //=> '{a,b}'
* ```
* @param {String} `input` Brace pattern or AST.
* @param {Object} `options`
* @return {Array} Returns an array of expanded values.
* @api public
*/
braces$1.stringify = (input, options = {}) => {
if (typeof input === "string") return stringify(braces$1.parse(input, options), options);
return stringify(input, options);
};
/**
* Compiles a brace pattern into a regex-compatible, optimized string.
* This method is called by the main [braces](#braces) function by default.
*
* ```js
* const braces = require('braces');
* console.log(braces.compile('a/{b,c}/d'));
* //=> ['a/(b|c)/d']
* ```
* @param {String} `input` Brace pattern or AST.
* @param {Object} `options`
* @return {Array} Returns an array of expanded values.
* @api public
*/
braces$1.compile = (input, options = {}) => {
if (typeof input === "string") input = braces$1.parse(input, options);
return compile(input, options);
};
/**
* Expands a brace pattern into an array. This method is called by the
* main [braces](#braces) function when `options.expand` is true. Before
* using this method it's recommended that you read the [performance notes](#performance))
* and advantages of using [.compile](#compile) instead.
*
* ```js
* const braces = require('braces');
* console.log(braces.expand('a/{b,c}/d'));
* //=> ['a/b/d', 'a/c/d'];
* ```
* @param {String} `pattern` Brace pattern
* @param {Object} `options`
* @return {Array} Returns an array of expanded values.
* @api public
*/
braces$1.expand = (input, options = {}) => {
if (typeof input === "string") input = braces$1.parse(input, options);
let result = expand(input, options);
if (options.noempty === true) result = result.filter(Boolean);
if (options.nodupes === true) result = [...new Set(result)];
return result;
};
/**
* Processes a brace pattern and returns either an expanded array
* (if `options.expand` is true), a highly optimized regex-compatible string.
* This method is called by the main [braces](#braces) function.
*
* ```js
* const braces = require('braces');
* console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
* //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
* ```
* @param {String} `pattern` Brace pattern
* @param {Object} `options`
* @return {Array} Returns an array of expanded values.
* @api public
*/
braces$1.create = (input, options = {}) => {
if (input === "" || input.length < 3) return [input];
return options.expand !== true ? braces$1.compile(input, options) : braces$1.expand(input, options);
};
/**
* Expose "braces"
*/
module.exports = braces$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js
var require_constants$1 = __commonJS({ "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"(exports, module) {
const path$9 = __require("path");
const WIN_SLASH = "\\\\/";
const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
/**
* Posix glob regex
*/
const DOT_LITERAL = "\\.";
const PLUS_LITERAL = "\\+";
const QMARK_LITERAL = "\\?";
const SLASH_LITERAL = "\\/";
const ONE_CHAR = "(?=.)";
const QMARK = "[^/]";
const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
const NO_DOT = `(?!${DOT_LITERAL})`;
const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
const STAR = `${QMARK}*?`;
const 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
};
/**
* Windows glob regex
*/
const WINDOWS_CHARS = {
...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}]|$)`
};
/**
* POSIX Bracket Regex
*/
const POSIX_REGEX_SOURCE$1 = {
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"
};
module.exports = {
MAX_LENGTH: 1024 * 64,
POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
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: path$9.sep,
extglobChars(chars$1) {
return {
"!": {
type: "negate",
open: "(?:(?!(?:",
close: `))${chars$1.STAR})`
},
"?": {
type: "qmark",
open: "(?:",
close: ")?"
},
"+": {
type: "plus",
open: "(?:",
close: ")+"
},
"*": {
type: "star",
open: "(?:",
close: ")*"
},
"@": {
type: "at",
open: "(?:",
close: ")"
}
};
},
globChars(win32$1) {
return win32$1 === true ? WINDOWS_CHARS : POSIX_CHARS;
}
};
} });
//#endregion
//#region ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js
var require_utils$2 = __commonJS({ "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"(exports) {
const path$8 = __require("path");
const win32 = process.platform === "win32";
const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants$1();
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 win32 === true || path$8.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$1 = options.contains ? "" : "$";
let output = `${prepend}(?:${input})${append$1}`;
if (state.negated === true) output = `(?:^(?!${output}).*$)`;
return output;
};
} });
//#endregion
//#region ../../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, module) {
const utils$13 = require_utils$2();
const { 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$1();
const isPathSeparator = (code$1) => {
return code$1 === CHAR_FORWARD_SLASH || code$1 === CHAR_BACKWARD_SLASH;
};
const depth = (token) => {
if (token.isPrefix !== true) token.depth = token.isGlobstar ? Infinity : 1;
};
/**
* Quickly scans a glob pattern and returns an object with a handful of
* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
*
* ```js
* const pm = require('picomatch');
* console.log(pm.scan('foo/bar/*.js'));
* { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
* ```
* @param {String} `str`
* @param {Object} `options`
* @return {Object} Returns an object with tokens and regex source string.
* @api public
*/
const scan$1 = (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$1 = false;
let isExtglob$1 = false;
let isGlobstar = false;
let braceEscaped = false;
let backslashes = false;
let negated = false;
let negatedExtglob = false;
let finished = false;
let braces$2 = 0;
let prev;
let code$1;
let token = {
value: "",
depth: 0,
isGlob: false
};
const eos = () => index >= length;
const peek = () => str.charCodeAt(index + 1);
const advance = () => {
prev = code$1;
return str.charCodeAt(++index);
};
while (index < length) {
code$1 = advance();
let next;
if (code$1 === CHAR_BACKWARD_SLASH) {
backslashes = token.backslashes = true;
code$1 = advance();
if (code$1 === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
continue;
}
if (braceEscaped === true || code$1 === CHAR_LEFT_CURLY_BRACE) {
braces$2++;
while (eos() !== true && (code$1 = advance())) {
if (code$1 === CHAR_BACKWARD_SLASH) {
backslashes = token.backslashes = true;
advance();
continue;
}
if (code$1 === CHAR_LEFT_CURLY_BRACE) {
braces$2++;
continue;
}
if (braceEscaped !== true && code$1 === CHAR_DOT && (code$1 = advance()) === CHAR_DOT) {
isBrace = token.isBrace = true;
isGlob$1 = token.isGlob = true;
finished = true;
if (scanToEnd === true) continue;
break;
}
if (braceEscaped !== true && code$1 === CHAR_COMMA) {
isBrace = token.isBrace = true;
isGlob$1 = token.isGlob = true;
finished = true;
if (scanToEnd === true) continue;
break;
}
if (code$1 === CHAR_RIGHT_CURLY_BRACE) {
braces$2--;
if (braces$2 === 0) {
braceEscaped = false;
isBrace = token.isBrace = true;
finished = true;
break;
}
}
}
if (scanToEnd === true) continue;
break;
}
if (code$1 === 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$1 === CHAR_PLUS || code$1 === CHAR_AT || code$1 === CHAR_ASTERISK || code$1 === CHAR_QUESTION_MARK || code$1 === CHAR_EXCLAMATION_MARK;
if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
isGlob$1 = token.isGlob = true;
isExtglob$1 = token.isExtglob = true;
finished = true;
if (code$1 === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
if (scanToEnd === true) {
while (eos() !== true && (code$1 = advance())) {
if (code$1 === CHAR_BACKWARD_SLASH) {
backslashes = token.backslashes = true;
code$1 = advance();
continue;
}
if (code$1 === CHAR_RIGHT_PARENTHESES) {
isGlob$1 = token.isGlob = true;
finished = true;
break;
}
}
continue;
}
break;
}
}
if (code$1 === CHAR_ASTERISK) {
if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
isGlob$1 = token.isGlob = true;
finished = true;
if (scanToEnd === true) continue;
break;
}
if (code$1 === CHAR_QUESTION_MARK) {
isGlob$1 = token.isGlob = true;
finished = true;
if (scanToEnd === true) continue;
break;
}
if (code$1 === 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$1 = token.isGlob = true;
finished = true;
break;
}
}
if (scanToEnd === true) continue;
break;
}
if (opts.nonegate !== true && code$1 === CHAR_EXCLAMATION_MARK && index === start) {
negated = token.negated = true;
start++;
continue;
}
if (opts.noparen !== true && code$1 === CHAR_LEFT_PARENTHESES) {
isGlob$1 = token.isGlob = true;
if (scanToEnd === true) {
while (eos() !== true && (code$1 = advance())) {
if (code$1 === CHAR_LEFT_PARENTHESES) {
backslashes = token.backslashes = true;
code$1 = advance();
continue;
}
if (code$1 === CHAR_RIGHT_PARENTHESES) {
finished = true;
break;
}
}
continue;
}
break;
}
if (isGlob$1 === true) {
finished = true;
if (scanToEnd === true) continue;
break;
}
}
if (opts.noext === true) {
isExtglob$1 = false;
isGlob$1 = 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$1 === true && lastIndex > 0) {
base = str.slice(0, lastIndex);
glob = str.slice(lastIndex);
} else if (isGlob$1 === 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$13.removeBackslashes(glob);
if (base && backslashes === true) base = utils$13.removeBackslashes(base);
}
const state = {
prefix,
input,
start,
base,
glob,
isBrace,
isBracket,
isGlob: isGlob$1,
isExtglob: isExtglob$1,
isGlobstar,
negated,
negatedExtglob
};
if (opts.tokens === true) {
state.maxDepth = 0;
if (!isPathSeparator(code$1)) 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$1 = slashes[idx];
const value = input.slice(n, i$1);
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$1;
}
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;
};
module.exports = scan$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js
var require_parse$1 = __commonJS({ "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js"(exports, module) {
const constants$1 = require_constants$1();
const utils$12 = require_utils$2();
/**
* Constants
*/
const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1;
/**
* Helpers
*/
const 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$12.escapeRegex(v)).join("..");
}
return value;
};
/**
* Create the message for a syntax error
*/
const syntaxError = (type$1, char) => {
return `Missing ${type$1}: "${char}" - use "\\\\${char}" to match literal characters`;
};
/**
* Parse the given input string.
* @param {String} input
* @param {Object} options
* @return {Object}
*/
const parse$3 = (input, options) => {
if (typeof input !== "string") throw new TypeError("Expected a string");
input = REPLACEMENTS[input] || input;
const opts = { ...options };
const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
let len$1 = input.length;
if (len$1 > max) throw new SyntaxError(`Input length: ${len$1}, exceeds maximum allowed length: ${max}`);
const bos = {
type: "bos",
value: "",
output: opts.prepend || ""
};
const tokens = [bos];
const capture = opts.capture ? "" : "?:";
const win32$1 = utils$12.isWindows(options);
const PLATFORM_CHARS = constants$1.globChars(win32$1);
const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
const { DOT_LITERAL: DOT_LITERAL$1, PLUS_LITERAL: PLUS_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT: NO_DOT$1, NO_DOT_SLASH: NO_DOT_SLASH$1, NO_DOTS_SLASH: NO_DOTS_SLASH$1, QMARK: QMARK$1, QMARK_NO_DOT: QMARK_NO_DOT$1, STAR: STAR$1, START_ANCHOR: START_ANCHOR$1 } = PLATFORM_CHARS;
const globstar = (opts$1) => {
return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
};
const nodot = opts.dot ? "" : NO_DOT$1;
const qmarkNoDot = opts.dot ? QMARK$1 : QMARK_NO_DOT$1;
let star = opts.bash === true ? globstar(opts) : STAR$1;
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$12.removePrefix(input, state);
len$1 = input.length;
const extglobs = [];
const braces$2 = [];
const stack = [];
let prev = bos;
let value;
/**
* Tokenizing helpers
*/
const eos = () => state.index === len$1 - 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 = (value$1 = "", num = 0) => {
state.consumed += value$1;
state.index += num;
};
const append$1 = (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$1) => {
state[type$1]++;
stack.push(type$1);
};
const decrement = (type$1) => {
state[type$1]--;
stack.pop();
};
/**
* Push tokens onto the tokens array. This helper speeds up
* tokenizing by 1) helping us avoid backtracking as much as possible,
* and 2) helping us avoid creating extra tokens when consecutive
* characters are plain text. This improves performance and simplifies
* lookbehinds.
*/
const push = (tok) => {
if (prev.type === "globstar") {
const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
const isExtglob$1 = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob$1) {
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$1(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$1, value$1) => {
const token = {
...EXTGLOB_CHARS[value$1],
conditions: 1,
inner: ""
};
token.prev = prev;
token.parens = state.parens;
token.output = state.output;
const output = (opts.capture ? "(" : "") + token.open;
increment("parens");
push({
type: type$1,
value: value$1,
output: state.output ? "" : ONE_CHAR$1
});
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$3(rest, {
...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");
};
/**
* Fast paths
*/
if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
let backslashes = false;
let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars$1, first, rest, index) => {
if (first === "\\") {
backslashes = true;
return m;
}
if (first === "?") {
if (esc) return esc + first + (rest ? QMARK$1.repeat(rest.length) : "");
if (index === 0) return qmarkNoDot + (rest ? QMARK$1.repeat(rest.length) : "");
return QMARK$1.repeat(chars$1.length);
}
if (first === ".") return DOT_LITERAL$1.repeat(chars$1.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$12.wrapOutput(output, state, options);
return state;
}
/**
* Tokenize input until we reach end-of-string
*/
while (!eos()) {
value = advance();
if (value === "\0") continue;
/**
* Escaped characters
*/
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 we're inside a regex character class, continue
* until we reach the closing bracket.
*/
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 rest$1 = prev.value.slice(idx + 2);
const posix = POSIX_REGEX_SOURCE[rest$1];
if (posix) {
prev.value = pre + posix;
state.backtrack = true;
advance();
if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR$1;
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$1({ value });
continue;
}
/**
* If we're inside a quoted string, continue
* until we reach the closing double quote.
*/
if (state.quotes === 1 && value !== "\"") {
value = utils$12.escapeRegex(value);
prev.value += value;
append$1({ value });
continue;
}
/**
* Double quotes
*/
if (value === "\"") {
state.quotes = state.quotes === 1 ? 0 : 1;
if (opts.keepQuotes === true) push({
type: "text",
value
});
continue;
}
/**
* Parentheses
*/
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;
}
/**
* Square brackets
*/
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$1({ value });
if (opts.literalBrackets === false || utils$12.hasRegexChars(prevValue)) continue;
const escaped$1 = utils$12.escapeRegex(prev.value);
state.output = state.output.slice(0, -prev.value.length);
if (opts.literalBrackets === true) {
state.output += escaped$1;
prev.value = escaped$1;
continue;
}
prev.value = `(${capture}${escaped$1}|${prev.value})`;
state.output += prev.value;
continue;
}
/**
* Braces
*/
if (value === "{" && opts.nobrace !== true) {
increment("braces");
const open = {
type: "brace",
value,
output: "(",
outputIndex: state.output.length,
tokensIndex: state.tokens.length
};
braces$2.push(open);
push(open);
continue;
}
if (value === "}") {
const brace = braces$2[braces$2.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$1 = arr.length - 1; i$1 >= 0; i$1--) {
tokens.pop();
if (arr[i$1].type === "brace") break;
if (arr[i$1].type !== "dots") range.unshift(arr[i$1].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$2.pop();
continue;
}
/**
* Pipes
*/
if (value === "|") {
if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
push({
type: "text",
value
});
continue;
}
/**
* Commas
*/
if (value === ",") {
let output = value;
const brace = braces$2[braces$2.length - 1];
if (brace && stack[stack.length - 1] === "braces") {
brace.comma = true;
output = "|";
}
push({
type: "comma",
value,
output
});
continue;
}
/**
* Slashes
*/
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$1
});
continue;
}
/**
* Dots
*/
if (value === ".") {
if (state.braces > 0 && prev.type === "dot") {
if (prev.value === ".") prev.output = DOT_LITERAL$1;
const brace = braces$2[braces$2.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$1
});
continue;
}
push({
type: "dot",
value,
output: DOT_LITERAL$1
});
continue;
}
/**
* Question marks
*/
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$12.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$1
});
continue;
}
push({
type: "qmark",
value,
output: QMARK$1
});
continue;
}
/**
* Exclamation
*/
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;
}
}
/**
* Plus
*/
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$1
});
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$1
});
continue;
}
/**
* Plain text
*/
if (value === "@") {
if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
push({
type: "at",
extglob: true,
value,
output: ""
});
continue;
}
push({
type: "text",
value
});
continue;
}
/**
* Plain text
*/
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;
}
/**
* Stars
*/
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$1 = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob$1) {
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$1}|${SLASH_LITERAL$1}${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$1}|${globstar(opts)}${SLASH_LITERAL$1})`;
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$1;
prev.output += NO_DOT_SLASH$1;
} else if (opts.dot === true) {
state.output += NO_DOTS_SLASH$1;
prev.output += NO_DOTS_SLASH$1;
} else {
state.output += nodot;
prev.output += nodot;
}
if (peek() !== "*") {
state.output += ONE_CHAR$1;
prev.output += ONE_CHAR$1;
}
}
push(token);
}
while (state.brackets > 0) {
if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
state.output = utils$12.escapeLast(state.output, "[");
decrement("brackets");
}
while (state.parens > 0) {
if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
state.output = utils$12.escapeLast(state.output, "(");
decrement("parens");
}
while (state.braces > 0) {
if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
state.output = utils$12.escapeLast(state.output, "{");
decrement("braces");
}
if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
type: "maybe_slash",
value: "",
output: `${SLASH_LITERAL$1}?`
});
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;
};
/**
* Fast paths for creating regular expressions for common glob patterns.
* This can significantly speed up processing and has very little downside
* impact when none of the fast paths match.
*/
parse$3.fastpaths = (input, options) => {
const opts = { ...options };
const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
const len$1 = input.length;
if (len$1 > max) throw new SyntaxError(`Input length: ${len$1}, exceeds maximum allowed length: ${max}`);
input = REPLACEMENTS[input] || input;
const win32$1 = utils$12.isWindows(options);
const { DOT_LITERAL: DOT_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT: NO_DOT$1, NO_DOTS: NO_DOTS$1, NO_DOTS_SLASH: NO_DOTS_SLASH$1, STAR: STAR$1, START_ANCHOR: START_ANCHOR$1 } = constants$1.globChars(win32$1);
const nodot = opts.dot ? NO_DOTS$1 : NO_DOT$1;
const slashDot = opts.dot ? NO_DOTS_SLASH$1 : NO_DOT$1;
const capture = opts.capture ? "" : "?:";
const state = {
negated: false,
prefix: ""
};
let star = opts.bash === true ? ".*?" : STAR$1;
if (opts.capture) star = `(${star})`;
const globstar = (opts$1) => {
if (opts$1.noglobstar === true) return star;
return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
};
const create = (str) => {
switch (str) {
case "*": return `${nodot}${ONE_CHAR$1}${star}`;
case ".*": return `${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
case "*.*": return `${nodot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
case "*/*": return `${nodot}${star}${SLASH_LITERAL$1}${ONE_CHAR$1}${slashDot}${star}`;
case "**": return nodot + globstar(opts);
case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${ONE_CHAR$1}${star}`;
case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
default: {
const match = /^(.*?)\.(\w+)$/.exec(str);
if (!match) return;
const source$1 = create(match[1]);
if (!source$1) return;
return source$1 + DOT_LITERAL$1 + match[2];
}
}
};
const output = utils$12.removePrefix(input, state);
let source = create(output);
if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL$1}?`;
return source;
};
module.exports = parse$3;
} });
//#endregion
//#region ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js
var require_picomatch$1 = __commonJS({ "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js"(exports, module) {
const path$7 = __require("path");
const scan = require_scan();
const parse$2 = require_parse$1();
const utils$11 = require_utils$2();
const constants = require_constants$1();
const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
/**
* Creates a matcher function from one or more glob patterns. The
* returned function takes a string to match as its first argument,
* and returns true if the string is a match. The returned matcher
* function also takes a boolean as the second argument that, when true,
* returns an object with additional information.
*
* ```js
* const picomatch = require('picomatch');
* // picomatch(glob[, options]);
*
* const isMatch = picomatch('*.!(*a)');
* console.log(isMatch('a.a')); //=> false
* console.log(isMatch('a.b')); //=> true
* ```
* @name picomatch
* @param {String|Array} `globs` One or more glob patterns.
* @param {Object=} `options`
* @return {Function=} Returns a matcher function.
* @api public
*/
const picomatch$1 = (glob, options, returnState = false) => {
if (Array.isArray(glob)) {
const fns = glob.map((input) => picomatch$1(input, options, returnState));
const arrayMatcher = (str) => {
for (const isMatch of fns) {
const state$1 = isMatch(str);
if (state$1) return state$1;
}
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 posix = utils$11.isWindows(options);
const regex = isState ? picomatch$1.compileRe(glob, options) : picomatch$1.makeRe(glob, options, false, true);
const state = regex.state;
delete regex.state;
let isIgnored = () => false;
if (opts.ignore) {
const ignoreOpts = {
...options,
ignore: null,
onMatch: null,
onResult: null
};
isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
}
const matcher = (input, returnObject = false) => {
const { isMatch, match, output } = picomatch$1.test(input, regex, options, {
glob,
posix
});
const result = {
glob,
state,
regex,
posix,
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;
};
/**
* Test `input` with the given `regex`. This is used by the main
* `picomatch()` function to test the input string.
*
* ```js
* const picomatch = require('picomatch');
* // picomatch.test(input, regex[, options]);
*
* console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
* // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
* ```
* @param {String} `input` String to test.
* @param {RegExp} `regex`
* @return {Object} Returns an object with matching info.
* @api public
*/
picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
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 || (posix ? utils$11.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$1.matchBase(input, regex, options, posix);
else match = regex.exec(output);
return {
isMatch: Boolean(match),
match,
output
};
};
/**
* Match the basename of a filepath.
*
* ```js
* const picomatch = require('picomatch');
* // picomatch.matchBase(input, glob[, options]);
* console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
* ```
* @param {String} `input` String to test.
* @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
* @return {Boolean}
* @api public
*/
picomatch$1.matchBase = (input, glob, options, posix = utils$11.isWindows(options)) => {
const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
return regex.test(path$7.basename(input));
};
/**
* Returns true if **any** of the given glob `patterns` match the specified `string`.
*
* ```js
* const picomatch = require('picomatch');
* // picomatch.isMatch(string, patterns[, options]);
*
* console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
* console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
* ```
* @param {String|Array} str The string to test.
* @param {String|Array} patterns One or more glob patterns to use for matching.
* @param {Object} [options] See available [options](#options).
* @return {Boolean} Returns true if any patterns match `str`
* @api public
*/
picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
/**
* Parse a glob pattern to create the source string for a regular
* expression.
*
* ```js
* const picomatch = require('picomatch');
* const result = picomatch.parse(pattern[, options]);
* ```
* @param {String} `pattern`
* @param {Object} `options`
* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
* @api public
*/
picomatch$1.parse = (pattern$1, options) => {
if (Array.isArray(pattern$1)) return pattern$1.map((p$2) => picomatch$1.parse(p$2, options));
return parse$2(pattern$1, {
...options,
fastpaths: false
});
};
/**
* Scan a glob pattern to separate the pattern into segments.
*
* ```js
* const picomatch = require('picomatch');
* // picomatch.scan(input[, options]);
*
* const result = picomatch.scan('!./foo/*.js');
* console.log(result);
* { prefix: '!./',
* input: '!./foo/*.js',
* start: 3,
* base: 'foo',
* glob: '*.js',
* isBrace: false,
* isBracket: false,
* isGlob: true,
* isExtglob: false,
* isGlobstar: false,
* negated: true }
* ```
* @param {String} `input` Glob pattern to scan.
* @param {Object} `options`
* @return {Object} Returns an object with
* @api public
*/
picomatch$1.scan = (input, options) => scan(input, options);
/**
* Compile a regular expression from the `state` object returned by the
* [parse()](#parse) method.
*
* @param {Object} `state`
* @param {Object} `options`
* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
* @return {RegExp}
* @api public
*/
picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
if (returnOutput === true) return state.output;
const opts = options || {};
const prepend = opts.contains ? "" : "^";
const append$1 = opts.contains ? "" : "$";
let source = `${prepend}(?:${state.output})${append$1}`;
if (state && state.negated === true) source = `^(?!${source}).*$`;
const regex = picomatch$1.toRegex(source, options);
if (returnState === true) regex.state = state;
return regex;
};
/**
* Create a regular expression from a parsed glob pattern.
*
* ```js
* const picomatch = require('picomatch');
* const state = picomatch.parse('*.js');
* // picomatch.compileRe(state[, options]);
*
* console.log(picomatch.compileRe(state));
* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
* ```
* @param {String} `state` The object returned from the `.parse` method.
* @param {Object} `options`
* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
* @return {RegExp} Returns a regex created from the given pattern.
* @api public
*/
picomatch$1.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$2.fastpaths(input, options);
if (!parsed.output) parsed = parse$2(input, options);
return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
};
/**
* Create a regular expression from the given regex source string.
*
* ```js
* const picomatch = require('picomatch');
* // picomatch.toRegex(source[, options]);
*
* const { output } = picomatch.parse('*.js');
* console.log(picomatch.toRegex(output));
* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
* ```
* @param {String} `source` Regular expression source string.
* @param {Object} `options`
* @return {RegExp}
* @api public
*/
picomatch$1.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.
* @return {Object}
*/
picomatch$1.constants = constants;
/**
* Expose "picomatch"
*/
module.exports = picomatch$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js
var require_picomatch = __commonJS({ "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js"(exports, module) {
module.exports = require_picomatch$1();
} });
//#endregion
//#region ../../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js
var require_micromatch = __commonJS({ "../../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js"(exports, module) {
const util = __require("util");
const braces = require_braces();
const picomatch = require_picomatch();
const utils$10 = require_utils$2();
const isEmptyString = (v) => v === "" || v === "./";
const hasBraces = (v) => {
const index = v.indexOf("{");
return index > -1 && v.indexOf("}", index) > -1;
};
/**
* Returns an array of strings that match one or more glob patterns.
*
* ```js
* const mm = require('micromatch');
* // mm(list, patterns[, options]);
*
* console.log(mm(['a.js', 'a.txt'], ['*.js']));
* //=> [ 'a.js' ]
* ```
* @param {String|Array<string>} `list` List of strings to match.
* @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options)
* @return {Array} Returns an array of matches
* @summary false
* @api public
*/
const micromatch$1 = (list, patterns, options) => {
patterns = [].concat(patterns);
list = [].concat(list);
let omit = /* @__PURE__ */ new Set();
let keep = /* @__PURE__ */ new Set();
let items = /* @__PURE__ */ new Set();
let negatives = 0;
let onResult = (state) => {
items.add(state.output);
if (options && options.onResult) options.onResult(state);
};
for (let i$1 = 0; i$1 < patterns.length; i$1++) {
let isMatch = picomatch(String(patterns[i$1]), {
...options,
onResult
}, true);
let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
if (negated) negatives++;
for (let item of list) {
let matched = isMatch(item, true);
let match = negated ? !matched.isMatch : matched.isMatch;
if (!match) continue;
if (negated) omit.add(matched.output);
else {
omit.delete(matched.output);
keep.add(matched.output);
}
}
}
let result = negatives === patterns.length ? [...items] : [...keep];
let matches = result.filter((item) => !omit.has(item));
if (options && matches.length === 0) {
if (options.failglob === true) throw new Error(`No matches found for "${patterns.join(", ")}"`);
if (options.nonull === true || options.nullglob === true) return options.unescape ? patterns.map((p$2) => p$2.replace(/\\/g, "")) : patterns;
}
return matches;
};
/**
* Backwards compatibility
*/
micromatch$1.match = micromatch$1;
/**
* Returns a matcher function from the given glob `pattern` and `options`.
* The returned function takes a string to match as its only argument and returns
* true if the string is a match.
*
* ```js
* const mm = require('micromatch');
* // mm.matcher(pattern[, options]);
*
* const isMatch = mm.matcher('*.!(*a)');
* console.log(isMatch('a.a')); //=> false
* console.log(isMatch('a.b')); //=> true
* ```
* @param {String} `pattern` Glob pattern
* @param {Object} `options`
* @return {Function} Returns a matcher function.
* @api public
*/
micromatch$1.matcher = (pattern$1, options) => picomatch(pattern$1, options);
/**
* Returns true if **any** of the given glob `patterns` match the specified `string`.
*
* ```js
* const mm = require('micromatch');
* // mm.isMatch(string, patterns[, options]);
*
* console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
* console.log(mm.isMatch('a.a', 'b.*')); //=> false
* ```
* @param {String} `str` The string to test.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `[options]` See available [options](#options).
* @return {Boolean} Returns true if any patterns match `str`
* @api public
*/
micromatch$1.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
/**
* Backwards compatibility
*/
micromatch$1.any = micromatch$1.isMatch;
/**
* Returns a list of strings that _**do not match any**_ of the given `patterns`.
*
* ```js
* const mm = require('micromatch');
* // mm.not(list, patterns[, options]);
*
* console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));
* //=> ['b.b', 'c.c']
* ```
* @param {Array} `list` Array of strings to match.
* @param {String|Array} `patterns` One or more glob pattern to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Array} Returns an array of strings that **do not match** the given patterns.
* @api public
*/
micromatch$1.not = (list, patterns, options = {}) => {
patterns = [].concat(patterns).map(String);
let result = /* @__PURE__ */ new Set();
let items = [];
let onResult = (state) => {
if (options.onResult) options.onResult(state);
items.push(state.output);
};
let matches = new Set(micromatch$1(list, patterns, {
...options,
onResult
}));
for (let item of items) if (!matches.has(item)) result.add(item);
return [...result];
};
/**
* Returns true if the given `string` contains the given pattern. Similar
* to [.isMatch](#isMatch) but the pattern can match any part of the string.
*
* ```js
* var mm = require('micromatch');
* // mm.contains(string, pattern[, options]);
*
* console.log(mm.contains('aa/bb/cc', '*b'));
* //=> true
* console.log(mm.contains('aa/bb/cc', '*d'));
* //=> false
* ```
* @param {String} `str` The string to match.
* @param {String|Array} `patterns` Glob pattern to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if any of the patterns matches any part of `str`.
* @api public
*/
micromatch$1.contains = (str, pattern$1, options) => {
if (typeof str !== "string") throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
if (Array.isArray(pattern$1)) return pattern$1.some((p$2) => micromatch$1.contains(str, p$2, options));
if (typeof pattern$1 === "string") {
if (isEmptyString(str) || isEmptyString(pattern$1)) return false;
if (str.includes(pattern$1) || str.startsWith("./") && str.slice(2).includes(pattern$1)) return true;
}
return micromatch$1.isMatch(str, pattern$1, {
...options,
contains: true
});
};
/**
* Filter the keys of the given object with the given `glob` pattern
* and `options`. Does not attempt to match nested keys. If you need this feature,
* use [glob-object][] instead.
*
* ```js
* const mm = require('micromatch');
* // mm.matchKeys(object, patterns[, options]);
*
* const obj = { aa: 'a', ab: 'b', ac: 'c' };
* console.log(mm.matchKeys(obj, '*b'));
* //=> { ab: 'b' }
* ```
* @param {Object} `object` The object with keys to filter.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Object} Returns an object with only keys that match the given patterns.
* @api public
*/
micromatch$1.matchKeys = (obj, patterns, options) => {
if (!utils$10.isObject(obj)) throw new TypeError("Expected the first argument to be an object");
let keys = micromatch$1(Object.keys(obj), patterns, options);
let res = {};
for (let key of keys) res[key] = obj[key];
return res;
};
/**
* Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
*
* ```js
* const mm = require('micromatch');
* // mm.some(list, patterns[, options]);
*
* console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
* // true
* console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));
* // false
* ```
* @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if any `patterns` matches any of the strings in `list`
* @api public
*/
micromatch$1.some = (list, patterns, options) => {
let items = [].concat(list);
for (let pattern$1 of [].concat(patterns)) {
let isMatch = picomatch(String(pattern$1), options);
if (items.some((item) => isMatch(item))) return true;
}
return false;
};
/**
* Returns true if every string in the given `list` matches
* any of the given glob `patterns`.
*
* ```js
* const mm = require('micromatch');
* // mm.every(list, patterns[, options]);
*
* console.log(mm.every('foo.js', ['foo.js']));
* // true
* console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
* // true
* console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
* // false
* console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));
* // false
* ```
* @param {String|Array} `list` The string or array of strings to test.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if all `patterns` matches all of the strings in `list`
* @api public
*/
micromatch$1.every = (list, patterns, options) => {
let items = [].concat(list);
for (let pattern$1 of [].concat(patterns)) {
let isMatch = picomatch(String(pattern$1), options);
if (!items.every((item) => isMatch(item))) return false;
}
return true;
};
/**
* Returns true if **all** of the given `patterns` match
* the specified string.
*
* ```js
* const mm = require('micromatch');
* // mm.all(string, patterns[, options]);
*
* console.log(mm.all('foo.js', ['foo.js']));
* // true
*
* console.log(mm.all('foo.js', ['*.js', '!foo.js']));
* // false
*
* console.log(mm.all('foo.js', ['*.js', 'foo.js']));
* // true
*
* console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
* // true
* ```
* @param {String|Array} `str` The string to test.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if any patterns match `str`
* @api public
*/
micromatch$1.all = (str, patterns, options) => {
if (typeof str !== "string") throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
return [].concat(patterns).every((p$2) => picomatch(p$2, options)(str));
};
/**
* Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.
*
* ```js
* const mm = require('micromatch');
* // mm.capture(pattern, string[, options]);
*
* console.log(mm.capture('test/*.js', 'test/foo.js'));
* //=> ['foo']
* console.log(mm.capture('test/*.js', 'foo/bar.css'));
* //=> null
* ```
* @param {String} `glob` Glob pattern to use for matching.
* @param {String} `input` String to match
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.
* @api public
*/
micromatch$1.capture = (glob, input, options) => {
let posix = utils$10.isWindows(options);
let regex = picomatch.makeRe(String(glob), {
...options,
capture: true
});
let match = regex.exec(posix ? utils$10.toPosixSlashes(input) : input);
if (match) return match.slice(1).map((v) => v === void 0 ? "" : v);
};
/**
* Create a regular expression from the given glob `pattern`.
*
* ```js
* const mm = require('micromatch');
* // mm.makeRe(pattern[, options]);
*
* console.log(mm.makeRe('*.js'));
* //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
* ```
* @param {String} `pattern` A glob pattern to convert to regex.
* @param {Object} `options`
* @return {RegExp} Returns a regex created from the given pattern.
* @api public
*/
micromatch$1.makeRe = (...args) => picomatch.makeRe(...args);
/**
* Scan a glob pattern to separate the pattern into segments. Used
* by the [split](#split) method.
*
* ```js
* const mm = require('micromatch');
* const state = mm.scan(pattern[, options]);
* ```
* @param {String} `pattern`
* @param {Object} `options`
* @return {Object} Returns an object with
* @api public
*/
micromatch$1.scan = (...args) => picomatch.scan(...args);
/**
* Parse a glob pattern to create the source string for a regular
* expression.
*
* ```js
* const mm = require('micromatch');
* const state = mm.parse(pattern[, options]);
* ```
* @param {String} `glob`
* @param {Object} `options`
* @return {Object} Returns an object with useful properties and output to be used as regex source string.
* @api public
*/
micromatch$1.parse = (patterns, options) => {
let res = [];
for (let pattern$1 of [].concat(patterns || [])) for (let str of braces(String(pattern$1), options)) res.push(picomatch.parse(str, options));
return res;
};
/**
* Process the given brace `pattern`.
*
* ```js
* const { braces } = require('micromatch');
* console.log(braces('foo/{a,b,c}/bar'));
* //=> [ 'foo/(a|b|c)/bar' ]
*
* console.log(braces('foo/{a,b,c}/bar', { expand: true }));
* //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
* ```
* @param {String} `pattern` String with brace pattern to process.
* @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.
* @return {Array}
* @api public
*/
micromatch$1.braces = (pattern$1, options) => {
if (typeof pattern$1 !== "string") throw new TypeError("Expected a string");
if (options && options.nobrace === true || !hasBraces(pattern$1)) return [pattern$1];
return braces(pattern$1, options);
};
/**
* Expand braces
*/
micromatch$1.braceExpand = (pattern$1, options) => {
if (typeof pattern$1 !== "string") throw new TypeError("Expected a string");
return micromatch$1.braces(pattern$1, {
...options,
expand: true
});
};
/**
* Expose micromatch
*/
micromatch$1.hasBraces = hasBraces;
module.exports = micromatch$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/pattern.js
var require_pattern = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/pattern.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.isAbsolute = exports.partitionAbsoluteAndRelative = exports.removeDuplicateSlashes = exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.isPatternRelatedToParentDirectory = exports.getPatternsOutsideCurrentDirectory = exports.getPatternsInsideCurrentDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
const path$6 = __require("path");
const globParent = require_glob_parent();
const micromatch = require_micromatch();
const GLOBSTAR = "**";
const ESCAPE_SYMBOL = "\\";
const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
/**
* Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
* The latter is due to the presence of the device path at the beginning of the UNC path.
*/
const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
function isStaticPattern(pattern$1, options = {}) {
return !isDynamicPattern(pattern$1, options);
}
exports.isStaticPattern = isStaticPattern;
function isDynamicPattern(pattern$1, options = {}) {
/**
* A special case with an empty string is necessary for matching patterns that start with a forward slash.
* An empty string cannot be a dynamic pattern.
* For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
*/
if (pattern$1 === "") return false;
/**
* When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
* filepath directly (without read directory).
*/
if (options.caseSensitiveMatch === false || pattern$1.includes(ESCAPE_SYMBOL)) return true;
if (COMMON_GLOB_SYMBOLS_RE.test(pattern$1) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern$1) || REGEX_GROUP_SYMBOLS_RE.test(pattern$1)) return true;
if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern$1)) return true;
if (options.braceExpansion !== false && hasBraceExpansion(pattern$1)) return true;
return false;
}
exports.isDynamicPattern = isDynamicPattern;
function hasBraceExpansion(pattern$1) {
const openingBraceIndex = pattern$1.indexOf("{");
if (openingBraceIndex === -1) return false;
const closingBraceIndex = pattern$1.indexOf("}", openingBraceIndex + 1);
if (closingBraceIndex === -1) return false;
const braceContent = pattern$1.slice(openingBraceIndex, closingBraceIndex);
return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
}
function convertToPositivePattern(pattern$1) {
return isNegativePattern(pattern$1) ? pattern$1.slice(1) : pattern$1;
}
exports.convertToPositivePattern = convertToPositivePattern;
function convertToNegativePattern(pattern$1) {
return "!" + pattern$1;
}
exports.convertToNegativePattern = convertToNegativePattern;
function isNegativePattern(pattern$1) {
return pattern$1.startsWith("!") && pattern$1[1] !== "(";
}
exports.isNegativePattern = isNegativePattern;
function isPositivePattern(pattern$1) {
return !isNegativePattern(pattern$1);
}
exports.isPositivePattern = isPositivePattern;
function getNegativePatterns(patterns) {
return patterns.filter(isNegativePattern);
}
exports.getNegativePatterns = getNegativePatterns;
function getPositivePatterns$1(patterns) {
return patterns.filter(isPositivePattern);
}
exports.getPositivePatterns = getPositivePatterns$1;
/**
* Returns patterns that can be applied inside the current directory.
*
* @example
* // ['./*', '*', 'a/*']
* getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
*/
function getPatternsInsideCurrentDirectory(patterns) {
return patterns.filter((pattern$1) => !isPatternRelatedToParentDirectory(pattern$1));
}
exports.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
/**
* Returns patterns to be expanded relative to (outside) the current directory.
*
* @example
* // ['../*', './../*']
* getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
*/
function getPatternsOutsideCurrentDirectory(patterns) {
return patterns.filter(isPatternRelatedToParentDirectory);
}
exports.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
function isPatternRelatedToParentDirectory(pattern$1) {
return pattern$1.startsWith("..") || pattern$1.startsWith("./..");
}
exports.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
function getBaseDirectory(pattern$1) {
return globParent(pattern$1, { flipBackslashes: false });
}
exports.getBaseDirectory = getBaseDirectory;
function hasGlobStar(pattern$1) {
return pattern$1.includes(GLOBSTAR);
}
exports.hasGlobStar = hasGlobStar;
function endsWithSlashGlobStar(pattern$1) {
return pattern$1.endsWith("/" + GLOBSTAR);
}
exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
function isAffectDepthOfReadingPattern(pattern$1) {
const basename = path$6.basename(pattern$1);
return endsWithSlashGlobStar(pattern$1) || isStaticPattern(basename);
}
exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
function expandPatternsWithBraceExpansion(patterns) {
return patterns.reduce((collection, pattern$1) => {
return collection.concat(expandBraceExpansion(pattern$1));
}, []);
}
exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
function expandBraceExpansion(pattern$1) {
const patterns = micromatch.braces(pattern$1, {
expand: true,
nodupes: true,
keepEscaping: true
});
/**
* Sort the patterns by length so that the same depth patterns are processed side by side.
* `a/{b,}/{c,}/*` – `['a///*', 'a/b//*', 'a//c/*', 'a/b/c/*']`
*/
patterns.sort((a, b) => a.length - b.length);
/**
* Micromatch can return an empty string in the case of patterns like `{a,}`.
*/
return patterns.filter((pattern$2) => pattern$2 !== "");
}
exports.expandBraceExpansion = expandBraceExpansion;
function getPatternParts(pattern$1, options) {
let { parts } = micromatch.scan(pattern$1, Object.assign(Object.assign({}, options), { parts: true }));
/**
* The scan method returns an empty array in some cases.
* See micromatch/picomatch#58 for more details.
*/
if (parts.length === 0) parts = [pattern$1];
/**
* The scan method does not return an empty part for the pattern with a forward slash.
* This is another part of micromatch/picomatch#58.
*/
if (parts[0].startsWith("/")) {
parts[0] = parts[0].slice(1);
parts.unshift("");
}
return parts;
}
exports.getPatternParts = getPatternParts;
function makeRe(pattern$1, options) {
return micromatch.makeRe(pattern$1, options);
}
exports.makeRe = makeRe;
function convertPatternsToRe(patterns, options) {
return patterns.map((pattern$1) => makeRe(pattern$1, options));
}
exports.convertPatternsToRe = convertPatternsToRe;
function matchAny(entry, patternsRe) {
return patternsRe.some((patternRe) => patternRe.test(entry));
}
exports.matchAny = matchAny;
/**
* This package only works with forward slashes as a path separator.
* Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
*/
function removeDuplicateSlashes(pattern$1) {
return pattern$1.replace(DOUBLE_SLASH_RE, "/");
}
exports.removeDuplicateSlashes = removeDuplicateSlashes;
function partitionAbsoluteAndRelative(patterns) {
const absolute = [];
const relative = [];
for (const pattern$1 of patterns) if (isAbsolute(pattern$1)) absolute.push(pattern$1);
else relative.push(pattern$1);
return [absolute, relative];
}
exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
function isAbsolute(pattern$1) {
return path$6.isAbsolute(pattern$1);
}
exports.isAbsolute = isAbsolute;
} });
//#endregion
//#region ../../node_modules/.pnpm/merge2@1.4.1/node_modules/merge2/index.js
var require_merge2 = __commonJS({ "../../node_modules/.pnpm/merge2@1.4.1/node_modules/merge2/index.js"(exports, module) {
const Stream = __require("stream");
const PassThrough = Stream.PassThrough;
const slice = Array.prototype.slice;
module.exports = merge2$1;
function merge2$1() {
const streamsQueue = [];
const args = slice.call(arguments);
let merging = false;
let options = args[args.length - 1];
if (options && !Array.isArray(options) && options.pipe == null) args.pop();
else options = {};
const doEnd = options.end !== false;
const doPipeError = options.pipeError === true;
if (options.objectMode == null) options.objectMode = true;
if (options.highWaterMark == null) options.highWaterMark = 64 * 1024;
const mergedStream = PassThrough(options);
function addStream() {
for (let i$1 = 0, len$1 = arguments.length; i$1 < len$1; i$1++) streamsQueue.push(pauseStreams(arguments[i$1], options));
mergeStream();
return this;
}
function mergeStream() {
if (merging) return;
merging = true;
let streams = streamsQueue.shift();
if (!streams) {
process.nextTick(endStream);
return;
}
if (!Array.isArray(streams)) streams = [streams];
let pipesCount = streams.length + 1;
function next() {
if (--pipesCount > 0) return;
merging = false;
mergeStream();
}
function pipe(stream$1) {
function onend() {
stream$1.removeListener("merge2UnpipeEnd", onend);
stream$1.removeListener("end", onend);
if (doPipeError) stream$1.removeListener("error", onerror);
next();
}
function onerror(err) {
mergedStream.emit("error", err);
}
if (stream$1._readableState.endEmitted) return next();
stream$1.on("merge2UnpipeEnd", onend);
stream$1.on("end", onend);
if (doPipeError) stream$1.on("error", onerror);
stream$1.pipe(mergedStream, { end: false });
stream$1.resume();
}
for (let i$1 = 0; i$1 < streams.length; i$1++) pipe(streams[i$1]);
next();
}
function endStream() {
merging = false;
mergedStream.emit("queueDrain");
if (doEnd) mergedStream.end();
}
mergedStream.setMaxListeners(0);
mergedStream.add = addStream;
mergedStream.on("unpipe", function(stream$1) {
stream$1.emit("merge2UnpipeEnd");
});
if (args.length) addStream.apply(null, args);
return mergedStream;
}
function pauseStreams(streams, options) {
if (!Array.isArray(streams)) {
if (!streams._readableState && streams.pipe) streams = streams.pipe(PassThrough(options));
if (!streams._readableState || !streams.pause || !streams.pipe) throw new Error("Only readable stream can be merged.");
streams.pause();
} else for (let i$1 = 0, len$1 = streams.length; i$1 < len$1; i$1++) streams[i$1] = pauseStreams(streams[i$1], options);
return streams;
}
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/stream.js
var require_stream$3 = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/stream.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.merge = void 0;
const merge2 = require_merge2();
function merge(streams) {
const mergedStream = merge2(streams);
streams.forEach((stream$1) => {
stream$1.once("error", (error) => mergedStream.emit("error", error));
});
mergedStream.once("close", () => propagateCloseEventToSources(streams));
mergedStream.once("end", () => propagateCloseEventToSources(streams));
return mergedStream;
}
exports.merge = merge;
function propagateCloseEventToSources(streams) {
streams.forEach((stream$1) => stream$1.emit("close"));
}
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/string.js
var require_string = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/string.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.isEmpty = exports.isString = void 0;
function isString(input) {
return typeof input === "string";
}
exports.isString = isString;
function isEmpty(input) {
return input === "";
}
exports.isEmpty = isEmpty;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/index.js
var require_utils$1 = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/index.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = void 0;
const array = require_array();
exports.array = array;
const errno = require_errno();
exports.errno = errno;
const fs$8 = require_fs$3();
exports.fs = fs$8;
const path$5 = require_path();
exports.path = path$5;
const pattern = require_pattern();
exports.pattern = pattern;
const stream = require_stream$3();
exports.stream = stream;
const string = require_string();
exports.string = string;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/managers/tasks.js
var require_tasks = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/managers/tasks.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0;
const utils$9 = require_utils$1();
function generate(input, settings) {
const patterns = processPatterns(input, settings);
const ignore = processPatterns(settings.ignore, settings);
const positivePatterns = getPositivePatterns(patterns);
const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
const staticPatterns = positivePatterns.filter((pattern$1) => utils$9.pattern.isStaticPattern(pattern$1, settings));
const dynamicPatterns = positivePatterns.filter((pattern$1) => utils$9.pattern.isDynamicPattern(pattern$1, settings));
const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, false);
const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, true);
return staticTasks.concat(dynamicTasks);
}
exports.generate = generate;
function processPatterns(input, settings) {
let patterns = input;
/**
* The original pattern like `{,*,**,a/*}` can lead to problems checking the depth when matching entry
* and some problems with the micromatch package (see fast-glob issues: #365, #394).
*
* To solve this problem, we expand all patterns containing brace expansion. This can lead to a slight slowdown
* in matching in the case of a large set of patterns after expansion.
*/
if (settings.braceExpansion) patterns = utils$9.pattern.expandPatternsWithBraceExpansion(patterns);
/**
* If the `baseNameMatch` option is enabled, we must add globstar to patterns, so that they can be used
* at any nesting level.
*
* We do this here, because otherwise we have to complicate the filtering logic. For example, we need to change
* the pattern in the filter before creating a regular expression. There is no need to change the patterns
* in the application. Only on the input.
*/
if (settings.baseNameMatch) patterns = patterns.map((pattern$1) => pattern$1.includes("/") ? pattern$1 : `**/${pattern$1}`);
/**
* This method also removes duplicate slashes that may have been in the pattern or formed as a result of expansion.
*/
return patterns.map((pattern$1) => utils$9.pattern.removeDuplicateSlashes(pattern$1));
}
/**
* Returns tasks grouped by basic pattern directories.
*
* Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
* This is necessary because directory traversal starts at the base directory and goes deeper.
*/
function convertPatternsToTasks(positive, negative, dynamic) {
const tasks = [];
const patternsOutsideCurrentDirectory = utils$9.pattern.getPatternsOutsideCurrentDirectory(positive);
const patternsInsideCurrentDirectory = utils$9.pattern.getPatternsInsideCurrentDirectory(positive);
const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
if ("." in insideCurrentDirectoryGroup) tasks.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
else tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
return tasks;
}
exports.convertPatternsToTasks = convertPatternsToTasks;
function getPositivePatterns(patterns) {
return utils$9.pattern.getPositivePatterns(patterns);
}
exports.getPositivePatterns = getPositivePatterns;
function getNegativePatternsAsPositive(patterns, ignore) {
const negative = utils$9.pattern.getNegativePatterns(patterns).concat(ignore);
const positive = negative.map(utils$9.pattern.convertToPositivePattern);
return positive;
}
exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
function groupPatternsByBaseDirectory(patterns) {
const group = {};
return patterns.reduce((collection, pattern$1) => {
const base = utils$9.pattern.getBaseDirectory(pattern$1);
if (base in collection) collection[base].push(pattern$1);
else collection[base] = [pattern$1];
return collection;
}, group);
}
exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
function convertPatternGroupsToTasks(positive, negative, dynamic) {
return Object.keys(positive).map((base) => {
return convertPatternGroupToTask(base, positive[base], negative, dynamic);
});
}
exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
function convertPatternGroupToTask(base, positive, negative, dynamic) {
return {
dynamic,
positive,
negative,
base,
patterns: [].concat(positive, negative.map(utils$9.pattern.convertToNegativePattern))
};
}
exports.convertPatternGroupToTask = convertPatternGroupToTask;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/async.js
var require_async$5 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/async.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.read = void 0;
function read$3(path$11, settings, callback) {
settings.fs.lstat(path$11, (lstatError, lstat) => {
if (lstatError !== null) {
callFailureCallback$2(callback, lstatError);
return;
}
if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
callSuccessCallback$2(callback, lstat);
return;
}
settings.fs.stat(path$11, (statError, stat$1) => {
if (statError !== null) {
if (settings.throwErrorOnBrokenSymbolicLink) {
callFailureCallback$2(callback, statError);
return;
}
callSuccessCallback$2(callback, lstat);
return;
}
if (settings.markSymbolicLink) stat$1.isSymbolicLink = () => true;
callSuccessCallback$2(callback, stat$1);
});
});
}
exports.read = read$3;
function callFailureCallback$2(callback, error) {
callback(error);
}
function callSuccessCallback$2(callback, result) {
callback(null, result);
}
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/sync.js
var require_sync$5 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/sync.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.read = void 0;
function read$2(path$11, settings) {
const lstat = settings.fs.lstatSync(path$11);
if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) return lstat;
try {
const stat$1 = settings.fs.statSync(path$11);
if (settings.markSymbolicLink) stat$1.isSymbolicLink = () => true;
return stat$1;
} catch (error) {
if (!settings.throwErrorOnBrokenSymbolicLink) return lstat;
throw error;
}
}
exports.read = read$2;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/adapters/fs.js
var require_fs$2 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/adapters/fs.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
const fs$7 = __require("fs");
exports.FILE_SYSTEM_ADAPTER = {
lstat: fs$7.lstat,
stat: fs$7.stat,
lstatSync: fs$7.lstatSync,
statSync: fs$7.statSync
};
function createFileSystemAdapter$1(fsMethods) {
if (fsMethods === void 0) return exports.FILE_SYSTEM_ADAPTER;
return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
}
exports.createFileSystemAdapter = createFileSystemAdapter$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.js
var require_settings$3 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const fs$6 = require_fs$2();
var Settings$3 = class {
constructor(_options = {}) {
this._options = _options;
this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
this.fs = fs$6.createFileSystemAdapter(this._options.fs);
this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
}
_getValue(option, value) {
return option !== null && option !== void 0 ? option : value;
}
};
exports.default = Settings$3;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.js
var require_out$3 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.statSync = exports.stat = exports.Settings = void 0;
const async$1 = require_async$5();
const sync$1 = require_sync$5();
const settings_1$3 = require_settings$3();
exports.Settings = settings_1$3.default;
function stat(path$11, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === "function") {
async$1.read(path$11, getSettings$2(), optionsOrSettingsOrCallback);
return;
}
async$1.read(path$11, getSettings$2(optionsOrSettingsOrCallback), callback);
}
exports.stat = stat;
function statSync$1(path$11, optionsOrSettings) {
const settings = getSettings$2(optionsOrSettings);
return sync$1.read(path$11, settings);
}
exports.statSync = statSync$1;
function getSettings$2(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1$3.default) return settingsOrOptions;
return new settings_1$3.default(settingsOrOptions);
}
} });
//#endregion
//#region ../../node_modules/.pnpm/queue-microtask@1.2.3/node_modules/queue-microtask/index.js
var require_queue_microtask = __commonJS({ "../../node_modules/.pnpm/queue-microtask@1.2.3/node_modules/queue-microtask/index.js"(exports, module) {
/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
let promise;
module.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : global) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
throw err;
}, 0));
} });
//#endregion
//#region ../../node_modules/.pnpm/run-parallel@1.2.0/node_modules/run-parallel/index.js
var require_run_parallel = __commonJS({ "../../node_modules/.pnpm/run-parallel@1.2.0/node_modules/run-parallel/index.js"(exports, module) {
/*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
module.exports = runParallel;
const queueMicrotask$1 = require_queue_microtask();
function runParallel(tasks, cb) {
let results, pending, keys;
let isSync = true;
if (Array.isArray(tasks)) {
results = [];
pending = tasks.length;
} else {
keys = Object.keys(tasks);
results = {};
pending = keys.length;
}
function done(err) {
function end() {
if (cb) cb(err, results);
cb = null;
}
if (isSync) queueMicrotask$1(end);
else end();
}
function each(i$1, err, result) {
results[i$1] = result;
if (--pending === 0 || err) done(err);
}
if (!pending) done(null);
else if (keys) keys.forEach(function(key) {
tasks[key](function(err, result) {
each(key, err, result);
});
});
else tasks.forEach(function(task, i$1) {
task(function(err, result) {
each(i$1, err, result);
});
});
isSync = false;
}
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/constants.js
var require_constants = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/constants.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
const NODE_PROCESS_VERSION_PARTS = process.versions.node.split(".");
if (NODE_PROCESS_VERSION_PARTS[0] === void 0 || NODE_PROCESS_VERSION_PARTS[1] === void 0) throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
const MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
const MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
const SUPPORTED_MAJOR_VERSION = 10;
const SUPPORTED_MINOR_VERSION = 10;
const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
/**
* IS `true` for Node.js 10.10 and greater.
*/
exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/fs.js
var require_fs$1 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/fs.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.createDirentFromStats = void 0;
var DirentFromStats = class {
constructor(name, stats) {
this.name = name;
this.isBlockDevice = stats.isBlockDevice.bind(stats);
this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
this.isDirectory = stats.isDirectory.bind(stats);
this.isFIFO = stats.isFIFO.bind(stats);
this.isFile = stats.isFile.bind(stats);
this.isSocket = stats.isSocket.bind(stats);
this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
}
};
function createDirentFromStats(name, stats) {
return new DirentFromStats(name, stats);
}
exports.createDirentFromStats = createDirentFromStats;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/index.js
var require_utils = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/index.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.fs = void 0;
const fs$5 = require_fs$1();
exports.fs = fs$5;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/common.js
var require_common$1 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/common.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.joinPathSegments = void 0;
function joinPathSegments$1(a, b, separator) {
/**
* The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
*/
if (a.endsWith(separator)) return a + b;
return a + separator + b;
}
exports.joinPathSegments = joinPathSegments$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/async.js
var require_async$4 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/async.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.readdir = exports.readdirWithFileTypes = exports.read = void 0;
const fsStat$5 = require_out$3();
const rpl = require_run_parallel();
const constants_1$1 = require_constants();
const utils$8 = require_utils();
const common$4 = require_common$1();
function read$1(directory, settings, callback) {
if (!settings.stats && constants_1$1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
readdirWithFileTypes$1(directory, settings, callback);
return;
}
readdir$1(directory, settings, callback);
}
exports.read = read$1;
function readdirWithFileTypes$1(directory, settings, callback) {
settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
if (readdirError !== null) {
callFailureCallback$1(callback, readdirError);
return;
}
const entries = dirents.map((dirent) => ({
dirent,
name: dirent.name,
path: common$4.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
}));
if (!settings.followSymbolicLinks) {
callSuccessCallback$1(callback, entries);
return;
}
const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
rpl(tasks, (rplError, rplEntries) => {
if (rplError !== null) {
callFailureCallback$1(callback, rplError);
return;
}
callSuccessCallback$1(callback, rplEntries);
});
});
}
exports.readdirWithFileTypes = readdirWithFileTypes$1;
function makeRplTaskEntry(entry, settings) {
return (done) => {
if (!entry.dirent.isSymbolicLink()) {
done(null, entry);
return;
}
settings.fs.stat(entry.path, (statError, stats) => {
if (statError !== null) {
if (settings.throwErrorOnBrokenSymbolicLink) {
done(statError);
return;
}
done(null, entry);
return;
}
entry.dirent = utils$8.fs.createDirentFromStats(entry.name, stats);
done(null, entry);
});
};
}
function readdir$1(directory, settings, callback) {
settings.fs.readdir(directory, (readdirError, names) => {
if (readdirError !== null) {
callFailureCallback$1(callback, readdirError);
return;
}
const tasks = names.map((name) => {
const path$11 = common$4.joinPathSegments(directory, name, settings.pathSegmentSeparator);
return (done) => {
fsStat$5.stat(path$11, settings.fsStatSettings, (error, stats) => {
if (error !== null) {
done(error);
return;
}
const entry = {
name,
path: path$11,
dirent: utils$8.fs.createDirentFromStats(name, stats)
};
if (settings.stats) entry.stats = stats;
done(null, entry);
});
};
});
rpl(tasks, (rplError, entries) => {
if (rplError !== null) {
callFailureCallback$1(callback, rplError);
return;
}
callSuccessCallback$1(callback, entries);
});
});
}
exports.readdir = readdir$1;
function callFailureCallback$1(callback, error) {
callback(error);
}
function callSuccessCallback$1(callback, result) {
callback(null, result);
}
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/sync.js
var require_sync$4 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/sync.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.readdir = exports.readdirWithFileTypes = exports.read = void 0;
const fsStat$4 = require_out$3();
const constants_1 = require_constants();
const utils$7 = require_utils();
const common$3 = require_common$1();
function read(directory, settings) {
if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) return readdirWithFileTypes(directory, settings);
return readdir(directory, settings);
}
exports.read = read;
function readdirWithFileTypes(directory, settings) {
const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
return dirents.map((dirent) => {
const entry = {
dirent,
name: dirent.name,
path: common$3.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
};
if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) try {
const stats = settings.fs.statSync(entry.path);
entry.dirent = utils$7.fs.createDirentFromStats(entry.name, stats);
} catch (error) {
if (settings.throwErrorOnBrokenSymbolicLink) throw error;
}
return entry;
});
}
exports.readdirWithFileTypes = readdirWithFileTypes;
function readdir(directory, settings) {
const names = settings.fs.readdirSync(directory);
return names.map((name) => {
const entryPath = common$3.joinPathSegments(directory, name, settings.pathSegmentSeparator);
const stats = fsStat$4.statSync(entryPath, settings.fsStatSettings);
const entry = {
name,
path: entryPath,
dirent: utils$7.fs.createDirentFromStats(name, stats)
};
if (settings.stats) entry.stats = stats;
return entry;
});
}
exports.readdir = readdir;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/adapters/fs.js
var require_fs = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/adapters/fs.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
const fs$4 = __require("fs");
exports.FILE_SYSTEM_ADAPTER = {
lstat: fs$4.lstat,
stat: fs$4.stat,
lstatSync: fs$4.lstatSync,
statSync: fs$4.statSync,
readdir: fs$4.readdir,
readdirSync: fs$4.readdirSync
};
function createFileSystemAdapter(fsMethods) {
if (fsMethods === void 0) return exports.FILE_SYSTEM_ADAPTER;
return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
}
exports.createFileSystemAdapter = createFileSystemAdapter;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/settings.js
var require_settings$2 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/settings.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const path$4 = __require("path");
const fsStat$3 = require_out$3();
const fs$3 = require_fs();
var Settings$2 = class {
constructor(_options = {}) {
this._options = _options;
this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
this.fs = fs$3.createFileSystemAdapter(this._options.fs);
this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$4.sep);
this.stats = this._getValue(this._options.stats, false);
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
this.fsStatSettings = new fsStat$3.Settings({
followSymbolicLink: this.followSymbolicLinks,
fs: this.fs,
throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
});
}
_getValue(option, value) {
return option !== null && option !== void 0 ? option : value;
}
};
exports.default = Settings$2;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.js
var require_out$2 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Settings = exports.scandirSync = exports.scandir = void 0;
const async = require_async$4();
const sync = require_sync$4();
const settings_1$2 = require_settings$2();
exports.Settings = settings_1$2.default;
function scandir(path$11, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === "function") {
async.read(path$11, getSettings$1(), optionsOrSettingsOrCallback);
return;
}
async.read(path$11, getSettings$1(optionsOrSettingsOrCallback), callback);
}
exports.scandir = scandir;
function scandirSync(path$11, optionsOrSettings) {
const settings = getSettings$1(optionsOrSettings);
return sync.read(path$11, settings);
}
exports.scandirSync = scandirSync;
function getSettings$1(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1$2.default) return settingsOrOptions;
return new settings_1$2.default(settingsOrOptions);
}
} });
//#endregion
//#region ../../node_modules/.pnpm/reusify@1.0.4/node_modules/reusify/reusify.js
var require_reusify = __commonJS({ "../../node_modules/.pnpm/reusify@1.0.4/node_modules/reusify/reusify.js"(exports, module) {
function reusify$1(Constructor) {
var head = new Constructor();
var tail = head;
function get() {
var current = head;
if (current.next) head = current.next;
else {
head = new Constructor();
tail = head;
}
current.next = null;
return current;
}
function release(obj) {
tail.next = obj;
tail = obj;
}
return {
get,
release
};
}
module.exports = reusify$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/fastq@1.17.1/node_modules/fastq/queue.js
var require_queue = __commonJS({ "../../node_modules/.pnpm/fastq@1.17.1/node_modules/fastq/queue.js"(exports, module) {
var reusify = require_reusify();
function fastqueue(context, worker, _concurrency) {
if (typeof context === "function") {
_concurrency = worker;
worker = context;
context = null;
}
if (!(_concurrency >= 1)) throw new Error("fastqueue concurrency must be equal to or greater than 1");
var cache = reusify(Task);
var queueHead = null;
var queueTail = null;
var _running = 0;
var errorHandler = null;
var self = {
push,
drain: noop,
saturated: noop,
pause,
paused: false,
get concurrency() {
return _concurrency;
},
set concurrency(value) {
if (!(value >= 1)) throw new Error("fastqueue concurrency must be equal to or greater than 1");
_concurrency = value;
if (self.paused) return;
for (; queueHead && _running < _concurrency;) {
_running++;
release();
}
},
running,
resume,
idle,
length,
getQueue,
unshift,
empty: noop,
kill,
killAndDrain,
error
};
return self;
function running() {
return _running;
}
function pause() {
self.paused = true;
}
function length() {
var current = queueHead;
var counter = 0;
while (current) {
current = current.next;
counter++;
}
return counter;
}
function getQueue() {
var current = queueHead;
var tasks = [];
while (current) {
tasks.push(current.value);
current = current.next;
}
return tasks;
}
function resume() {
if (!self.paused) return;
self.paused = false;
if (queueHead === null) {
_running++;
release();
return;
}
for (; queueHead && _running < _concurrency;) {
_running++;
release();
}
}
function idle() {
return _running === 0 && self.length() === 0;
}
function push(value, done) {
var current = cache.get();
current.context = context;
current.release = release;
current.value = value;
current.callback = done || noop;
current.errorHandler = errorHandler;
if (_running >= _concurrency || self.paused) if (queueTail) {
queueTail.next = current;
queueTail = current;
} else {
queueHead = current;
queueTail = current;
self.saturated();
}
else {
_running++;
worker.call(context, current.value, current.worked);
}
}
function unshift(value, done) {
var current = cache.get();
current.context = context;
current.release = release;
current.value = value;
current.callback = done || noop;
current.errorHandler = errorHandler;
if (_running >= _concurrency || self.paused) if (queueHead) {
current.next = queueHead;
queueHead = current;
} else {
queueHead = current;
queueTail = current;
self.saturated();
}
else {
_running++;
worker.call(context, current.value, current.worked);
}
}
function release(holder) {
if (holder) cache.release(holder);
var next = queueHead;
if (next && _running <= _concurrency) if (!self.paused) {
if (queueTail === queueHead) queueTail = null;
queueHead = next.next;
next.next = null;
worker.call(context, next.value, next.worked);
if (queueTail === null) self.empty();
} else _running--;
else if (--_running === 0) self.drain();
}
function kill() {
queueHead = null;
queueTail = null;
self.drain = noop;
}
function killAndDrain() {
queueHead = null;
queueTail = null;
self.drain();
self.drain = noop;
}
function error(handler) {
errorHandler = handler;
}
}
function noop() {}
function Task() {
this.value = null;
this.callback = noop;
this.next = null;
this.release = noop;
this.context = null;
this.errorHandler = null;
var self = this;
this.worked = function worked(err, result) {
var callback = self.callback;
var errorHandler = self.errorHandler;
var val = self.value;
self.value = null;
self.callback = noop;
if (self.errorHandler) errorHandler(err, val);
callback.call(self.context, err, result);
self.release(self);
};
}
function queueAsPromised(context, worker, _concurrency) {
if (typeof context === "function") {
_concurrency = worker;
worker = context;
context = null;
}
function asyncWrapper(arg, cb) {
worker.call(this, arg).then(function(res) {
cb(null, res);
}, cb);
}
var queue = fastqueue(context, asyncWrapper, _concurrency);
var pushCb = queue.push;
var unshiftCb = queue.unshift;
queue.push = push;
queue.unshift = unshift;
queue.drained = drained;
return queue;
function push(value) {
var p$2 = new Promise(function(resolve, reject) {
pushCb(value, function(err, result) {
if (err) {
reject(err);
return;
}
resolve(result);
});
});
p$2.catch(noop);
return p$2;
}
function unshift(value) {
var p$2 = new Promise(function(resolve, reject) {
unshiftCb(value, function(err, result) {
if (err) {
reject(err);
return;
}
resolve(result);
});
});
p$2.catch(noop);
return p$2;
}
function drained() {
if (queue.idle()) return new Promise(function(resolve) {
resolve();
});
var previousDrain = queue.drain;
var p$2 = new Promise(function(resolve) {
queue.drain = function() {
previousDrain();
resolve();
};
});
return p$2;
}
}
module.exports = fastqueue;
module.exports.promise = queueAsPromised;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/common.js
var require_common = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/common.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.joinPathSegments = exports.replacePathSegmentSeparator = exports.isAppliedFilter = exports.isFatalError = void 0;
function isFatalError(settings, error) {
if (settings.errorFilter === null) return true;
return !settings.errorFilter(error);
}
exports.isFatalError = isFatalError;
function isAppliedFilter(filter, value) {
return filter === null || filter(value);
}
exports.isAppliedFilter = isAppliedFilter;
function replacePathSegmentSeparator(filepath, separator) {
return filepath.split(/[/\\]/).join(separator);
}
exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
function joinPathSegments(a, b, separator) {
if (a === "") return b;
/**
* The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
*/
if (a.endsWith(separator)) return a + b;
return a + separator + b;
}
exports.joinPathSegments = joinPathSegments;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/reader.js
var require_reader$1 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/reader.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const common$2 = require_common();
var Reader$1 = class {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._root = common$2.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
}
};
exports.default = Reader$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/async.js
var require_async$3 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/async.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = __require("events");
const fsScandir$2 = require_out$2();
const fastq = require_queue();
const common$1 = require_common();
const reader_1$4 = require_reader$1();
var AsyncReader = class extends reader_1$4.default {
constructor(_root, _settings) {
super(_root, _settings);
this._settings = _settings;
this._scandir = fsScandir$2.scandir;
this._emitter = new events_1.EventEmitter();
this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
this._isFatalError = false;
this._isDestroyed = false;
this._queue.drain = () => {
if (!this._isFatalError) this._emitter.emit("end");
};
}
read() {
this._isFatalError = false;
this._isDestroyed = false;
setImmediate(() => {
this._pushToQueue(this._root, this._settings.basePath);
});
return this._emitter;
}
get isDestroyed() {
return this._isDestroyed;
}
destroy() {
if (this._isDestroyed) throw new Error("The reader is already destroyed");
this._isDestroyed = true;
this._queue.killAndDrain();
}
onEntry(callback) {
this._emitter.on("entry", callback);
}
onError(callback) {
this._emitter.once("error", callback);
}
onEnd(callback) {
this._emitter.once("end", callback);
}
_pushToQueue(directory, base) {
const queueItem = {
directory,
base
};
this._queue.push(queueItem, (error) => {
if (error !== null) this._handleError(error);
});
}
_worker(item, done) {
this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
if (error !== null) {
done(error, void 0);
return;
}
for (const entry of entries) this._handleEntry(entry, item.base);
done(null, void 0);
});
}
_handleError(error) {
if (this._isDestroyed || !common$1.isFatalError(this._settings, error)) return;
this._isFatalError = true;
this._isDestroyed = true;
this._emitter.emit("error", error);
}
_handleEntry(entry, base) {
if (this._isDestroyed || this._isFatalError) return;
const fullpath = entry.path;
if (base !== void 0) entry.path = common$1.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
if (common$1.isAppliedFilter(this._settings.entryFilter, entry)) this._emitEntry(entry);
if (entry.dirent.isDirectory() && common$1.isAppliedFilter(this._settings.deepFilter, entry)) this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
}
_emitEntry(entry) {
this._emitter.emit("entry", entry);
}
};
exports.default = AsyncReader;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/async.js
var require_async$2 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/async.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const async_1$4 = require_async$3();
var AsyncProvider = class {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new async_1$4.default(this._root, this._settings);
this._storage = [];
}
read(callback) {
this._reader.onError((error) => {
callFailureCallback(callback, error);
});
this._reader.onEntry((entry) => {
this._storage.push(entry);
});
this._reader.onEnd(() => {
callSuccessCallback(callback, this._storage);
});
this._reader.read();
}
};
exports.default = AsyncProvider;
function callFailureCallback(callback, error) {
callback(error);
}
function callSuccessCallback(callback, entries) {
callback(null, entries);
}
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/stream.js
var require_stream$2 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/stream.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const stream_1$5 = __require("stream");
const async_1$3 = require_async$3();
var StreamProvider = class {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new async_1$3.default(this._root, this._settings);
this._stream = new stream_1$5.Readable({
objectMode: true,
read: () => {},
destroy: () => {
if (!this._reader.isDestroyed) this._reader.destroy();
}
});
}
read() {
this._reader.onError((error) => {
this._stream.emit("error", error);
});
this._reader.onEntry((entry) => {
this._stream.push(entry);
});
this._reader.onEnd(() => {
this._stream.push(null);
});
this._reader.read();
return this._stream;
}
};
exports.default = StreamProvider;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/sync.js
var require_sync$3 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/sync.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const fsScandir$1 = require_out$2();
const common = require_common();
const reader_1$3 = require_reader$1();
var SyncReader = class extends reader_1$3.default {
constructor() {
super(...arguments);
this._scandir = fsScandir$1.scandirSync;
this._storage = [];
this._queue = /* @__PURE__ */ new Set();
}
read() {
this._pushToQueue(this._root, this._settings.basePath);
this._handleQueue();
return this._storage;
}
_pushToQueue(directory, base) {
this._queue.add({
directory,
base
});
}
_handleQueue() {
for (const item of this._queue.values()) this._handleDirectory(item.directory, item.base);
}
_handleDirectory(directory, base) {
try {
const entries = this._scandir(directory, this._settings.fsScandirSettings);
for (const entry of entries) this._handleEntry(entry, base);
} catch (error) {
this._handleError(error);
}
}
_handleError(error) {
if (!common.isFatalError(this._settings, error)) return;
throw error;
}
_handleEntry(entry, base) {
const fullpath = entry.path;
if (base !== void 0) entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
if (common.isAppliedFilter(this._settings.entryFilter, entry)) this._pushToStorage(entry);
if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
}
_pushToStorage(entry) {
this._storage.push(entry);
}
};
exports.default = SyncReader;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/sync.js
var require_sync$2 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/sync.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const sync_1$3 = require_sync$3();
var SyncProvider = class {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new sync_1$3.default(this._root, this._settings);
}
read() {
return this._reader.read();
}
};
exports.default = SyncProvider;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.js
var require_settings$1 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const path$3 = __require("path");
const fsScandir = require_out$2();
var Settings$1 = class {
constructor(_options = {}) {
this._options = _options;
this.basePath = this._getValue(this._options.basePath, void 0);
this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
this.deepFilter = this._getValue(this._options.deepFilter, null);
this.entryFilter = this._getValue(this._options.entryFilter, null);
this.errorFilter = this._getValue(this._options.errorFilter, null);
this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$3.sep);
this.fsScandirSettings = new fsScandir.Settings({
followSymbolicLinks: this._options.followSymbolicLinks,
fs: this._options.fs,
pathSegmentSeparator: this._options.pathSegmentSeparator,
stats: this._options.stats,
throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
});
}
_getValue(option, value) {
return option !== null && option !== void 0 ? option : value;
}
};
exports.default = Settings$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.js
var require_out$1 = __commonJS({ "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Settings = exports.walkStream = exports.walkSync = exports.walk = void 0;
const async_1$2 = require_async$2();
const stream_1$4 = require_stream$2();
const sync_1$2 = require_sync$2();
const settings_1$1 = require_settings$1();
exports.Settings = settings_1$1.default;
function walk(directory, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === "function") {
new async_1$2.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
return;
}
new async_1$2.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
}
exports.walk = walk;
function walkSync(directory, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
const provider = new sync_1$2.default(directory, settings);
return provider.read();
}
exports.walkSync = walkSync;
function walkStream(directory, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
const provider = new stream_1$4.default(directory, settings);
return provider.read();
}
exports.walkStream = walkStream;
function getSettings(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1$1.default) return settingsOrOptions;
return new settings_1$1.default(settingsOrOptions);
}
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/reader.js
var require_reader = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/reader.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const path$2 = __require("path");
const fsStat$2 = require_out$3();
const utils$6 = require_utils$1();
var Reader = class {
constructor(_settings) {
this._settings = _settings;
this._fsStatSettings = new fsStat$2.Settings({
followSymbolicLink: this._settings.followSymbolicLinks,
fs: this._settings.fs,
throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
});
}
_getFullEntryPath(filepath) {
return path$2.resolve(this._settings.cwd, filepath);
}
_makeEntry(stats, pattern$1) {
const entry = {
name: pattern$1,
path: pattern$1,
dirent: utils$6.fs.createDirentFromStats(pattern$1, stats)
};
if (this._settings.stats) entry.stats = stats;
return entry;
}
_isFatalError(error) {
return !utils$6.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
}
};
exports.default = Reader;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/stream.js
var require_stream$1 = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/stream.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const stream_1$3 = __require("stream");
const fsStat$1 = require_out$3();
const fsWalk$2 = require_out$1();
const reader_1$2 = require_reader();
var ReaderStream = class extends reader_1$2.default {
constructor() {
super(...arguments);
this._walkStream = fsWalk$2.walkStream;
this._stat = fsStat$1.stat;
}
dynamic(root, options) {
return this._walkStream(root, options);
}
static(patterns, options) {
const filepaths = patterns.map(this._getFullEntryPath, this);
const stream$1 = new stream_1$3.PassThrough({ objectMode: true });
stream$1._write = (index, _enc, done) => {
return this._getEntry(filepaths[index], patterns[index], options).then((entry) => {
if (entry !== null && options.entryFilter(entry)) stream$1.push(entry);
if (index === filepaths.length - 1) stream$1.end();
done();
}).catch(done);
};
for (let i$1 = 0; i$1 < filepaths.length; i$1++) stream$1.write(i$1);
return stream$1;
}
_getEntry(filepath, pattern$1, options) {
return this._getStat(filepath).then((stats) => this._makeEntry(stats, pattern$1)).catch((error) => {
if (options.errorFilter(error)) return null;
throw error;
});
}
_getStat(filepath) {
return new Promise((resolve, reject) => {
this._stat(filepath, this._fsStatSettings, (error, stats) => {
return error === null ? resolve(stats) : reject(error);
});
});
}
};
exports.default = ReaderStream;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/async.js
var require_async$1 = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/async.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const fsWalk$1 = require_out$1();
const reader_1$1 = require_reader();
const stream_1$2 = require_stream$1();
var ReaderAsync = class extends reader_1$1.default {
constructor() {
super(...arguments);
this._walkAsync = fsWalk$1.walk;
this._readerStream = new stream_1$2.default(this._settings);
}
dynamic(root, options) {
return new Promise((resolve, reject) => {
this._walkAsync(root, options, (error, entries) => {
if (error === null) resolve(entries);
else reject(error);
});
});
}
async static(patterns, options) {
const entries = [];
const stream$1 = this._readerStream.static(patterns, options);
return new Promise((resolve, reject) => {
stream$1.once("error", reject);
stream$1.on("data", (entry) => entries.push(entry));
stream$1.once("end", () => resolve(entries));
});
}
};
exports.default = ReaderAsync;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/matchers/matcher.js
var require_matcher = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/matchers/matcher.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const utils$5 = require_utils$1();
var Matcher = class {
constructor(_patterns, _settings, _micromatchOptions) {
this._patterns = _patterns;
this._settings = _settings;
this._micromatchOptions = _micromatchOptions;
this._storage = [];
this._fillStorage();
}
_fillStorage() {
for (const pattern$1 of this._patterns) {
const segments = this._getPatternSegments(pattern$1);
const sections = this._splitSegmentsIntoSections(segments);
this._storage.push({
complete: sections.length <= 1,
pattern: pattern$1,
segments,
sections
});
}
}
_getPatternSegments(pattern$1) {
const parts = utils$5.pattern.getPatternParts(pattern$1, this._micromatchOptions);
return parts.map((part) => {
const dynamic = utils$5.pattern.isDynamicPattern(part, this._settings);
if (!dynamic) return {
dynamic: false,
pattern: part
};
return {
dynamic: true,
pattern: part,
patternRe: utils$5.pattern.makeRe(part, this._micromatchOptions)
};
});
}
_splitSegmentsIntoSections(segments) {
return utils$5.array.splitWhen(segments, (segment) => segment.dynamic && utils$5.pattern.hasGlobStar(segment.pattern));
}
};
exports.default = Matcher;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/matchers/partial.js
var require_partial = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/matchers/partial.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const matcher_1 = require_matcher();
var PartialMatcher = class extends matcher_1.default {
match(filepath) {
const parts = filepath.split("/");
const levels = parts.length;
const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
for (const pattern$1 of patterns) {
const section = pattern$1.sections[0];
/**
* In this case, the pattern has a globstar and we must read all directories unconditionally,
* but only if the level has reached the end of the first group.
*
* fixtures/{a,b}/**
* ^ true/false ^ always true
*/
if (!pattern$1.complete && levels > section.length) return true;
const match = parts.every((part, index) => {
const segment = pattern$1.segments[index];
if (segment.dynamic && segment.patternRe.test(part)) return true;
if (!segment.dynamic && segment.pattern === part) return true;
return false;
});
if (match) return true;
}
return false;
}
};
exports.default = PartialMatcher;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/deep.js
var require_deep = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/deep.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const utils$4 = require_utils$1();
const partial_1 = require_partial();
var DeepFilter = class {
constructor(_settings, _micromatchOptions) {
this._settings = _settings;
this._micromatchOptions = _micromatchOptions;
}
getFilter(basePath, positive, negative) {
const matcher = this._getMatcher(positive);
const negativeRe = this._getNegativePatternsRe(negative);
return (entry) => this._filter(basePath, entry, matcher, negativeRe);
}
_getMatcher(patterns) {
return new partial_1.default(patterns, this._settings, this._micromatchOptions);
}
_getNegativePatternsRe(patterns) {
const affectDepthOfReadingPatterns = patterns.filter(utils$4.pattern.isAffectDepthOfReadingPattern);
return utils$4.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
}
_filter(basePath, entry, matcher, negativeRe) {
if (this._isSkippedByDeep(basePath, entry.path)) return false;
if (this._isSkippedSymbolicLink(entry)) return false;
const filepath = utils$4.path.removeLeadingDotSegment(entry.path);
if (this._isSkippedByPositivePatterns(filepath, matcher)) return false;
return this._isSkippedByNegativePatterns(filepath, negativeRe);
}
_isSkippedByDeep(basePath, entryPath) {
/**
* Avoid unnecessary depth calculations when it doesn't matter.
*/
if (this._settings.deep === Infinity) return false;
return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
}
_getEntryLevel(basePath, entryPath) {
const entryPathDepth = entryPath.split("/").length;
if (basePath === "") return entryPathDepth;
const basePathDepth = basePath.split("/").length;
return entryPathDepth - basePathDepth;
}
_isSkippedSymbolicLink(entry) {
return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
}
_isSkippedByPositivePatterns(entryPath, matcher) {
return !this._settings.baseNameMatch && !matcher.match(entryPath);
}
_isSkippedByNegativePatterns(entryPath, patternsRe) {
return !utils$4.pattern.matchAny(entryPath, patternsRe);
}
};
exports.default = DeepFilter;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/entry.js
var require_entry$1 = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/entry.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const utils$3 = require_utils$1();
var EntryFilter = class {
constructor(_settings, _micromatchOptions) {
this._settings = _settings;
this._micromatchOptions = _micromatchOptions;
this.index = /* @__PURE__ */ new Map();
}
getFilter(positive, negative) {
const [absoluteNegative, relativeNegative] = utils$3.pattern.partitionAbsoluteAndRelative(negative);
const patterns = {
positive: { all: utils$3.pattern.convertPatternsToRe(positive, this._micromatchOptions) },
negative: {
absolute: utils$3.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true })),
relative: utils$3.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }))
}
};
return (entry) => this._filter(entry, patterns);
}
_filter(entry, patterns) {
const filepath = utils$3.path.removeLeadingDotSegment(entry.path);
if (this._settings.unique && this._isDuplicateEntry(filepath)) return false;
if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) return false;
const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
if (this._settings.unique && isMatched) this._createIndexRecord(filepath);
return isMatched;
}
_isDuplicateEntry(filepath) {
return this.index.has(filepath);
}
_createIndexRecord(filepath) {
this.index.set(filepath, void 0);
}
_onlyFileFilter(entry) {
return this._settings.onlyFiles && !entry.dirent.isFile();
}
_onlyDirectoryFilter(entry) {
return this._settings.onlyDirectories && !entry.dirent.isDirectory();
}
_isMatchToPatternsSet(filepath, patterns, isDirectory) {
const isMatched = this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
if (!isMatched) return false;
const isMatchedByRelativeNegative = this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
if (isMatchedByRelativeNegative) return false;
const isMatchedByAbsoluteNegative = this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
if (isMatchedByAbsoluteNegative) return false;
return true;
}
_isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory) {
if (patternsRe.length === 0) return false;
const fullpath = utils$3.path.makeAbsolute(this._settings.cwd, filepath);
return this._isMatchToPatterns(fullpath, patternsRe, isDirectory);
}
_isMatchToPatterns(filepath, patternsRe, isDirectory) {
if (patternsRe.length === 0) return false;
const isMatched = utils$3.pattern.matchAny(filepath, patternsRe);
if (!isMatched && isDirectory) return utils$3.pattern.matchAny(filepath + "/", patternsRe);
return isMatched;
}
};
exports.default = EntryFilter;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/error.js
var require_error = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/error.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const utils$2 = require_utils$1();
var ErrorFilter = class {
constructor(_settings) {
this._settings = _settings;
}
getFilter() {
return (error) => this._isNonFatalError(error);
}
_isNonFatalError(error) {
return utils$2.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
}
};
exports.default = ErrorFilter;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/transformers/entry.js
var require_entry = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/transformers/entry.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const utils$1 = require_utils$1();
var EntryTransformer = class {
constructor(_settings) {
this._settings = _settings;
}
getTransformer() {
return (entry) => this._transform(entry);
}
_transform(entry) {
let filepath = entry.path;
if (this._settings.absolute) {
filepath = utils$1.path.makeAbsolute(this._settings.cwd, filepath);
filepath = utils$1.path.unixify(filepath);
}
if (this._settings.markDirectories && entry.dirent.isDirectory()) filepath += "/";
if (!this._settings.objectMode) return filepath;
return Object.assign(Object.assign({}, entry), { path: filepath });
}
};
exports.default = EntryTransformer;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/provider.js
var require_provider = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/provider.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const path$1 = __require("path");
const deep_1 = require_deep();
const entry_1 = require_entry$1();
const error_1 = require_error();
const entry_2 = require_entry();
var Provider = class {
constructor(_settings) {
this._settings = _settings;
this.errorFilter = new error_1.default(this._settings);
this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
this.entryTransformer = new entry_2.default(this._settings);
}
_getRootDirectory(task) {
return path$1.resolve(this._settings.cwd, task.base);
}
_getReaderOptions(task) {
const basePath = task.base === "." ? "" : task.base;
return {
basePath,
pathSegmentSeparator: "/",
concurrency: this._settings.concurrency,
deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
errorFilter: this.errorFilter.getFilter(),
followSymbolicLinks: this._settings.followSymbolicLinks,
fs: this._settings.fs,
stats: this._settings.stats,
throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
transform: this.entryTransformer.getTransformer()
};
}
_getMicromatchOptions() {
return {
dot: this._settings.dot,
matchBase: this._settings.baseNameMatch,
nobrace: !this._settings.braceExpansion,
nocase: !this._settings.caseSensitiveMatch,
noext: !this._settings.extglob,
noglobstar: !this._settings.globstar,
posix: true,
strictSlashes: false
};
}
};
exports.default = Provider;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/async.js
var require_async = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/async.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const async_1$1 = require_async$1();
const provider_1$2 = require_provider();
var ProviderAsync = class extends provider_1$2.default {
constructor() {
super(...arguments);
this._reader = new async_1$1.default(this._settings);
}
async read(task) {
const root = this._getRootDirectory(task);
const options = this._getReaderOptions(task);
const entries = await this.api(root, task, options);
return entries.map((entry) => options.transform(entry));
}
api(root, task, options) {
if (task.dynamic) return this._reader.dynamic(root, options);
return this._reader.static(task.patterns, options);
}
};
exports.default = ProviderAsync;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/stream.js
var require_stream = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/stream.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const stream_1$1 = __require("stream");
const stream_2 = require_stream$1();
const provider_1$1 = require_provider();
var ProviderStream = class extends provider_1$1.default {
constructor() {
super(...arguments);
this._reader = new stream_2.default(this._settings);
}
read(task) {
const root = this._getRootDirectory(task);
const options = this._getReaderOptions(task);
const source = this.api(root, task, options);
const destination = new stream_1$1.Readable({
objectMode: true,
read: () => {}
});
source.once("error", (error) => destination.emit("error", error)).on("data", (entry) => destination.emit("data", options.transform(entry))).once("end", () => destination.emit("end"));
destination.once("close", () => source.destroy());
return destination;
}
api(root, task, options) {
if (task.dynamic) return this._reader.dynamic(root, options);
return this._reader.static(task.patterns, options);
}
};
exports.default = ProviderStream;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/sync.js
var require_sync$1 = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/sync.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const fsStat = require_out$3();
const fsWalk = require_out$1();
const reader_1 = require_reader();
var ReaderSync = class extends reader_1.default {
constructor() {
super(...arguments);
this._walkSync = fsWalk.walkSync;
this._statSync = fsStat.statSync;
}
dynamic(root, options) {
return this._walkSync(root, options);
}
static(patterns, options) {
const entries = [];
for (const pattern$1 of patterns) {
const filepath = this._getFullEntryPath(pattern$1);
const entry = this._getEntry(filepath, pattern$1, options);
if (entry === null || !options.entryFilter(entry)) continue;
entries.push(entry);
}
return entries;
}
_getEntry(filepath, pattern$1, options) {
try {
const stats = this._getStat(filepath);
return this._makeEntry(stats, pattern$1);
} catch (error) {
if (options.errorFilter(error)) return null;
throw error;
}
}
_getStat(filepath) {
return this._statSync(filepath, this._fsStatSettings);
}
};
exports.default = ReaderSync;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/sync.js
var require_sync = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/sync.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
const sync_1$1 = require_sync$1();
const provider_1 = require_provider();
var ProviderSync = class extends provider_1.default {
constructor() {
super(...arguments);
this._reader = new sync_1$1.default(this._settings);
}
read(task) {
const root = this._getRootDirectory(task);
const options = this._getReaderOptions(task);
const entries = this.api(root, task, options);
return entries.map(options.transform);
}
api(root, task, options) {
if (task.dynamic) return this._reader.dynamic(root, options);
return this._reader.static(task.patterns, options);
}
};
exports.default = ProviderSync;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/settings.js
var require_settings = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/settings.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
const fs$2 = __require("fs");
const os = __require("os");
/**
* The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
* https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
*/
const CPU_COUNT = Math.max(os.cpus().length, 1);
exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
lstat: fs$2.lstat,
lstatSync: fs$2.lstatSync,
stat: fs$2.stat,
statSync: fs$2.statSync,
readdir: fs$2.readdir,
readdirSync: fs$2.readdirSync
};
var Settings = class {
constructor(_options = {}) {
this._options = _options;
this.absolute = this._getValue(this._options.absolute, false);
this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
this.braceExpansion = this._getValue(this._options.braceExpansion, true);
this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
this.cwd = this._getValue(this._options.cwd, process.cwd());
this.deep = this._getValue(this._options.deep, Infinity);
this.dot = this._getValue(this._options.dot, false);
this.extglob = this._getValue(this._options.extglob, true);
this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
this.fs = this._getFileSystemMethods(this._options.fs);
this.globstar = this._getValue(this._options.globstar, true);
this.ignore = this._getValue(this._options.ignore, []);
this.markDirectories = this._getValue(this._options.markDirectories, false);
this.objectMode = this._getValue(this._options.objectMode, false);
this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
this.onlyFiles = this._getValue(this._options.onlyFiles, true);
this.stats = this._getValue(this._options.stats, false);
this.suppressErrors = this._getValue(this._options.suppressErrors, false);
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
this.unique = this._getValue(this._options.unique, true);
if (this.onlyDirectories) this.onlyFiles = false;
if (this.stats) this.objectMode = true;
this.ignore = [].concat(this.ignore);
}
_getValue(option, value) {
return option === void 0 ? value : option;
}
_getFileSystemMethods(methods = {}) {
return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
}
};
exports.default = Settings;
} });
//#endregion
//#region ../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/index.js
var require_out = __commonJS({ "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/index.js"(exports, module) {
const taskManager = require_tasks();
const async_1 = require_async();
const stream_1 = require_stream();
const sync_1 = require_sync();
const settings_1 = require_settings();
const utils = require_utils$1();
async function FastGlob(source, options) {
assertPatternsInput(source);
const works = getWorks(source, async_1.default, options);
const result = await Promise.all(works);
return utils.array.flatten(result);
}
(function(FastGlob$1) {
FastGlob$1.glob = FastGlob$1;
FastGlob$1.globSync = sync$2;
FastGlob$1.globStream = stream$1;
FastGlob$1.async = FastGlob$1;
function sync$2(source, options) {
assertPatternsInput(source);
const works = getWorks(source, sync_1.default, options);
return utils.array.flatten(works);
}
FastGlob$1.sync = sync$2;
function stream$1(source, options) {
assertPatternsInput(source);
const works = getWorks(source, stream_1.default, options);
/**
* The stream returned by the provider cannot work with an asynchronous iterator.
* To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
* This affects performance (+25%). I don't see best solution right now.
*/
return utils.stream.merge(works);
}
FastGlob$1.stream = stream$1;
function generateTasks(source, options) {
assertPatternsInput(source);
const patterns = [].concat(source);
const settings = new settings_1.default(options);
return taskManager.generate(patterns, settings);
}
FastGlob$1.generateTasks = generateTasks;
function isDynamicPattern$1(source, options) {
assertPatternsInput(source);
const settings = new settings_1.default(options);
return utils.pattern.isDynamicPattern(source, settings);
}
FastGlob$1.isDynamicPattern = isDynamicPattern$1;
function escapePath(source) {
assertPatternsInput(source);
return utils.path.escape(source);
}
FastGlob$1.escapePath = escapePath;
function convertPathToPattern(source) {
assertPatternsInput(source);
return utils.path.convertPathToPattern(source);
}
FastGlob$1.convertPathToPattern = convertPathToPattern;
let posix;
(function(posix$1) {
function escapePath$1(source) {
assertPatternsInput(source);
return utils.path.escapePosixPath(source);
}
posix$1.escapePath = escapePath$1;
function convertPathToPattern$1(source) {
assertPatternsInput(source);
return utils.path.convertPosixPathToPattern(source);
}
posix$1.convertPathToPattern = convertPathToPattern$1;
})(posix = FastGlob$1.posix || (FastGlob$1.posix = {}));
let win32$1;
(function(win32$2) {
function escapePath$1(source) {
assertPatternsInput(source);
return utils.path.escapeWindowsPath(source);
}
win32$2.escapePath = escapePath$1;
function convertPathToPattern$1(source) {
assertPatternsInput(source);
return utils.path.convertWindowsPathToPattern(source);
}
win32$2.convertPathToPattern = convertPathToPattern$1;
})(win32$1 = FastGlob$1.win32 || (FastGlob$1.win32 = {}));
})(FastGlob || (FastGlob = {}));
function getWorks(source, _Provider, options) {
const patterns = [].concat(source);
const settings = new settings_1.default(options);
const tasks = taskManager.generate(patterns, settings);
const provider = new _Provider(settings);
return tasks.map(provider.read, provider);
}
function assertPatternsInput(input) {
const source = [].concat(input);
const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
if (!isValidSource) throw new TypeError("Patterns must be a string (non empty) or an array of strings");
}
module.exports = FastGlob;
} });
//#endregion
//#region ../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/conventions.js
var require_conventions = __commonJS({ "../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/conventions.js"(exports) {
/**
* Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.
*
* Works with anything that has a `length` property and index access properties, including NodeList.
*
* @template {unknown} T
* @param {Array<T> | ({length:number, [number]: T})} list
* @param {function (item: T, index: number, list:Array<T> | ({length:number, [number]: T})):boolean} predicate
* @param {Partial<Pick<ArrayConstructor['prototype'], 'find'>>?} ac `Array.prototype` by default,
* allows injecting a custom implementation in tests
* @returns {T | undefined}
*
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
* @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find
*/
function find$1(list, predicate, ac) {
if (ac === void 0) ac = Array.prototype;
if (list && typeof ac.find === "function") return ac.find.call(list, predicate);
for (var i$1 = 0; i$1 < list.length; i$1++) if (Object.prototype.hasOwnProperty.call(list, i$1)) {
var item = list[i$1];
if (predicate.call(void 0, item, i$1, list)) return item;
}
}
/**
* "Shallow freezes" an object to render it immutable.
* Uses `Object.freeze` if available,
* otherwise the immutability is only in the type.
*
* Is used to create "enum like" objects.
*
* @template T
* @param {T} object the object to freeze
* @param {Pick<ObjectConstructor, 'freeze'> = Object} oc `Object` by default,
* allows to inject custom object constructor for tests
* @returns {Readonly<T>}
*
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
*/
function freeze$1(object, oc) {
if (oc === void 0) oc = Object;
return oc && typeof oc.freeze === "function" ? oc.freeze(object) : object;
}
/**
* Since we can not rely on `Object.assign` we provide a simplified version
* that is sufficient for our needs.
*
* @param {Object} target
* @param {Object | null | undefined} source
*
* @returns {Object} target
* @throws TypeError if target is not an object
*
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
* @see https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-object.assign
*/
function assign(target, source) {
if (target === null || typeof target !== "object") throw new TypeError("target is not an object");
for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
return target;
}
/**
* All mime types that are allowed as input to `DOMParser.parseFromString`
*
* @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString#Argument02 MDN
* @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#domparsersupportedtype WHATWG HTML Spec
* @see DOMParser.prototype.parseFromString
*/
var MIME_TYPE = freeze$1({
HTML: "text/html",
isHTML: function(value) {
return value === MIME_TYPE.HTML;
},
XML_APPLICATION: "application/xml",
XML_TEXT: "text/xml",
XML_XHTML_APPLICATION: "application/xhtml+xml",
XML_SVG_IMAGE: "image/svg+xml"
});
/**
* Namespaces that are used in this code base.
*
* @see http://www.w3.org/TR/REC-xml-names
*/
var NAMESPACE$3 = freeze$1({
HTML: "http://www.w3.org/1999/xhtml",
isHTML: function(uri) {
return uri === NAMESPACE$3.HTML;
},
SVG: "http://www.w3.org/2000/svg",
XML: "http://www.w3.org/XML/1998/namespace",
XMLNS: "http://www.w3.org/2000/xmlns/"
});
exports.assign = assign;
exports.find = find$1;
exports.freeze = freeze$1;
exports.MIME_TYPE = MIME_TYPE;
exports.NAMESPACE = NAMESPACE$3;
} });
//#endregion
//#region ../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/dom.js
var require_dom = __commonJS({ "../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/dom.js"(exports) {
var conventions$1 = require_conventions();
var find = conventions$1.find;
var NAMESPACE$2 = conventions$1.NAMESPACE;
/**
* A prerequisite for `[].filter`, to drop elements that are empty
* @param {string} input
* @returns {boolean}
*/
function notEmptyString(input) {
return input !== "";
}
/**
* @see https://infra.spec.whatwg.org/#split-on-ascii-whitespace
* @see https://infra.spec.whatwg.org/#ascii-whitespace
*
* @param {string} input
* @returns {string[]} (can be empty)
*/
function splitOnASCIIWhitespace(input) {
return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];
}
/**
* Adds element as a key to current if it is not already present.
*
* @param {Record<string, boolean | undefined>} current
* @param {string} element
* @returns {Record<string, boolean | undefined>}
*/
function orderedSetReducer(current, element) {
if (!current.hasOwnProperty(element)) current[element] = true;
return current;
}
/**
* @see https://infra.spec.whatwg.org/#ordered-set
* @param {string} input
* @returns {string[]}
*/
function toOrderedSet(input) {
if (!input) return [];
var list = splitOnASCIIWhitespace(input);
return Object.keys(list.reduce(orderedSetReducer, {}));
}
/**
* Uses `list.indexOf` to implement something like `Array.prototype.includes`,
* which we can not rely on being available.
*
* @param {any[]} list
* @returns {function(any): boolean}
*/
function arrayIncludes(list) {
return function(element) {
return list && list.indexOf(element) !== -1;
};
}
function copy(src, dest) {
for (var p$2 in src) if (Object.prototype.hasOwnProperty.call(src, p$2)) dest[p$2] = src[p$2];
}
/**
^\w+\.prototype\.([_\w]+)\s*=\s*((?:.*\{\s*?[\r\n][\s\S]*?^})|\S.*?(?=[;\r\n]));?
^\w+\.prototype\.([_\w]+)\s*=\s*(\S.*?(?=[;\r\n]));?
*/
function _extends(Class, Super) {
var pt = Class.prototype;
if (!(pt instanceof Super)) {
function t() {}
t.prototype = Super.prototype;
t = new t();
copy(pt, t);
Class.prototype = pt = t;
}
if (pt.constructor != Class) {
if (typeof Class != "function") console.error("unknown Class:" + Class);
pt.constructor = Class;
}
}
var NodeType = {};
var ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;
var ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;
var TEXT_NODE$1 = NodeType.TEXT_NODE = 3;
var CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;
var ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;
var ENTITY_NODE = NodeType.ENTITY_NODE = 6;
var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
var COMMENT_NODE$1 = NodeType.COMMENT_NODE = 8;
var DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;
var DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;
var DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;
var NOTATION_NODE = NodeType.NOTATION_NODE = 12;
var ExceptionCode = {};
var ExceptionMessage = {};
var INDEX_SIZE_ERR = ExceptionCode.INDEX_SIZE_ERR = (ExceptionMessage[1] = "Index size error", 1);
var DOMSTRING_SIZE_ERR = ExceptionCode.DOMSTRING_SIZE_ERR = (ExceptionMessage[2] = "DOMString size error", 2);
var HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = (ExceptionMessage[3] = "Hierarchy request error", 3);
var WRONG_DOCUMENT_ERR = ExceptionCode.WRONG_DOCUMENT_ERR = (ExceptionMessage[4] = "Wrong document", 4);
var INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = (ExceptionMessage[5] = "Invalid character", 5);
var NO_DATA_ALLOWED_ERR = ExceptionCode.NO_DATA_ALLOWED_ERR = (ExceptionMessage[6] = "No data allowed", 6);
var NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = (ExceptionMessage[7] = "No modification allowed", 7);
var NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = (ExceptionMessage[8] = "Not found", 8);
var NOT_SUPPORTED_ERR = ExceptionCode.NOT_SUPPORTED_ERR = (ExceptionMessage[9] = "Not supported", 9);
var INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = (ExceptionMessage[10] = "Attribute in use", 10);
var INVALID_STATE_ERR = ExceptionCode.INVALID_STATE_ERR = (ExceptionMessage[11] = "Invalid state", 11);
var SYNTAX_ERR = ExceptionCode.SYNTAX_ERR = (ExceptionMessage[12] = "Syntax error", 12);
var INVALID_MODIFICATION_ERR = ExceptionCode.INVALID_MODIFICATION_ERR = (ExceptionMessage[13] = "Invalid modification", 13);
var NAMESPACE_ERR = ExceptionCode.NAMESPACE_ERR = (ExceptionMessage[14] = "Invalid namespace", 14);
var INVALID_ACCESS_ERR = ExceptionCode.INVALID_ACCESS_ERR = (ExceptionMessage[15] = "Invalid access", 15);
/**
* DOM Level 2
* Object DOMException
* @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html
* @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html
*/
function DOMException(code$1, message) {
if (message instanceof Error) var error = message;
else {
error = this;
Error.call(this, ExceptionMessage[code$1]);
this.message = ExceptionMessage[code$1];
if (Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
}
error.code = code$1;
if (message) this.message = this.message + ": " + message;
return error;
}
DOMException.prototype = Error.prototype;
copy(ExceptionCode, DOMException);
/**
* @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177
* The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.
* The items in the NodeList are accessible via an integral index, starting from 0.
*/
function NodeList() {}
NodeList.prototype = {
length: 0,
item: function(index) {
return index >= 0 && index < this.length ? this[index] : null;
},
toString: function(isHTML, nodeFilter) {
for (var buf = [], i$1 = 0; i$1 < this.length; i$1++) serializeToString(this[i$1], buf, isHTML, nodeFilter);
return buf.join("");
},
filter: function(predicate) {
return Array.prototype.filter.call(this, predicate);
},
indexOf: function(item) {
return Array.prototype.indexOf.call(this, item);
}
};
function LiveNodeList(node, refresh) {
this._node = node;
this._refresh = refresh;
_updateLiveList(this);
}
function _updateLiveList(list) {
var inc = list._node._inc || list._node.ownerDocument._inc;
if (list._inc !== inc) {
var ls = list._refresh(list._node);
__set__(list, "length", ls.length);
if (!list.$$length || ls.length < list.$$length) {
for (var i$1 = ls.length; i$1 in list; i$1++) if (Object.prototype.hasOwnProperty.call(list, i$1)) delete list[i$1];
}
copy(ls, list);
list._inc = inc;
}
}
LiveNodeList.prototype.item = function(i$1) {
_updateLiveList(this);
return this[i$1] || null;
};
_extends(LiveNodeList, NodeList);
/**
* Objects implementing the NamedNodeMap interface are used
* to represent collections of nodes that can be accessed by name.
* Note that NamedNodeMap does not inherit from NodeList;
* NamedNodeMaps are not maintained in any particular order.
* Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index,
* but this is simply to allow convenient enumeration of the contents of a NamedNodeMap,
* and does not imply that the DOM specifies an order to these Nodes.
* NamedNodeMap objects in the DOM are live.
* used for attributes or DocumentType entities
*/
function NamedNodeMap() {}
function _findNodeIndex(list, node) {
var i$1 = list.length;
while (i$1--) if (list[i$1] === node) return i$1;
}
function _addNamedNode(el, list, newAttr, oldAttr) {
if (oldAttr) list[_findNodeIndex(list, oldAttr)] = newAttr;
else list[list.length++] = newAttr;
if (el) {
newAttr.ownerElement = el;
var doc = el.ownerDocument;
if (doc) {
oldAttr && _onRemoveAttribute(doc, el, oldAttr);
_onAddAttribute(doc, el, newAttr);
}
}
}
function _removeNamedNode(el, list, attr) {
var i$1 = _findNodeIndex(list, attr);
if (i$1 >= 0) {
var lastIndex = list.length - 1;
while (i$1 < lastIndex) list[i$1] = list[++i$1];
list.length = lastIndex;
if (el) {
var doc = el.ownerDocument;
if (doc) {
_onRemoveAttribute(doc, el, attr);
attr.ownerElement = null;
}
}
} else throw new DOMException(NOT_FOUND_ERR, new Error(el.tagName + "@" + attr));
}
NamedNodeMap.prototype = {
length: 0,
item: NodeList.prototype.item,
getNamedItem: function(key) {
var i$1 = this.length;
while (i$1--) {
var attr = this[i$1];
if (attr.nodeName == key) return attr;
}
},
setNamedItem: function(attr) {
var el = attr.ownerElement;
if (el && el != this._ownerElement) throw new DOMException(INUSE_ATTRIBUTE_ERR);
var oldAttr = this.getNamedItem(attr.nodeName);
_addNamedNode(this._ownerElement, this, attr, oldAttr);
return oldAttr;
},
setNamedItemNS: function(attr) {
var el = attr.ownerElement, oldAttr;
if (el && el != this._ownerElement) throw new DOMException(INUSE_ATTRIBUTE_ERR);
oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
_addNamedNode(this._ownerElement, this, attr, oldAttr);
return oldAttr;
},
removeNamedItem: function(key) {
var attr = this.getNamedItem(key);
_removeNamedNode(this._ownerElement, this, attr);
return attr;
},
removeNamedItemNS: function(namespaceURI, localName) {
var attr = this.getNamedItemNS(namespaceURI, localName);
_removeNamedNode(this._ownerElement, this, attr);
return attr;
},
getNamedItemNS: function(namespaceURI, localName) {
var i$1 = this.length;
while (i$1--) {
var node = this[i$1];
if (node.localName == localName && node.namespaceURI == namespaceURI) return node;
}
return null;
}
};
/**
* The DOMImplementation interface represents an object providing methods
* which are not dependent on any particular document.
* Such an object is returned by the `Document.implementation` property.
*
* __The individual methods describe the differences compared to the specs.__
*
* @constructor
*
* @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation MDN
* @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490 DOM Level 1 Core (Initial)
* @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-102161490 DOM Level 2 Core
* @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-102161490 DOM Level 3 Core
* @see https://dom.spec.whatwg.org/#domimplementation DOM Living Standard
*/
function DOMImplementation$1() {}
DOMImplementation$1.prototype = {
hasFeature: function(feature, version) {
return true;
},
createDocument: function(namespaceURI, qualifiedName, doctype) {
var doc = new Document();
doc.implementation = this;
doc.childNodes = new NodeList();
doc.doctype = doctype || null;
if (doctype) doc.appendChild(doctype);
if (qualifiedName) {
var root = doc.createElementNS(namespaceURI, qualifiedName);
doc.appendChild(root);
}
return doc;
},
createDocumentType: function(qualifiedName, publicId, systemId) {
var node = new DocumentType();
node.name = qualifiedName;
node.nodeName = qualifiedName;
node.publicId = publicId || "";
node.systemId = systemId || "";
return node;
}
};
/**
* @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
*/
function Node() {}
Node.prototype = {
firstChild: null,
lastChild: null,
previousSibling: null,
nextSibling: null,
attributes: null,
parentNode: null,
childNodes: null,
ownerDocument: null,
nodeValue: null,
namespaceURI: null,
prefix: null,
localName: null,
insertBefore: function(newChild, refChild) {
return _insertBefore(this, newChild, refChild);
},
replaceChild: function(newChild, oldChild) {
_insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
if (oldChild) this.removeChild(oldChild);
},
removeChild: function(oldChild) {
return _removeChild(this, oldChild);
},
appendChild: function(newChild) {
return this.insertBefore(newChild, null);
},
hasChildNodes: function() {
return this.firstChild != null;
},
cloneNode: function(deep) {
return cloneNode(this.ownerDocument || this, this, deep);
},
normalize: function() {
var child = this.firstChild;
while (child) {
var next = child.nextSibling;
if (next && next.nodeType == TEXT_NODE$1 && child.nodeType == TEXT_NODE$1) {
this.removeChild(next);
child.appendData(next.data);
} else {
child.normalize();
child = next;
}
}
},
isSupported: function(feature, version) {
return this.ownerDocument.implementation.hasFeature(feature, version);
},
hasAttributes: function() {
return this.attributes.length > 0;
},
lookupPrefix: function(namespaceURI) {
var el = this;
while (el) {
var map = el._nsMap;
if (map) {
for (var n in map) if (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) return n;
}
el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
}
return null;
},
lookupNamespaceURI: function(prefix) {
var el = this;
while (el) {
var map = el._nsMap;
if (map) {
if (Object.prototype.hasOwnProperty.call(map, prefix)) return map[prefix];
}
el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
}
return null;
},
isDefaultNamespace: function(namespaceURI) {
var prefix = this.lookupPrefix(namespaceURI);
return prefix == null;
}
};
function _xmlEncoder(c) {
return c == "<" && "<" || c == ">" && ">" || c == "&" && "&" || c == "\"" && """ || "&#" + c.charCodeAt() + ";";
}
copy(NodeType, Node);
copy(NodeType, Node.prototype);
/**
* @param callback return true for continue,false for break
* @return boolean true: break visit;
*/
function _visitNode(node, callback) {
if (callback(node)) return true;
if (node = node.firstChild) do
if (_visitNode(node, callback)) return true;
while (node = node.nextSibling);
}
function Document() {
this.ownerDocument = this;
}
function _onAddAttribute(doc, el, newAttr) {
doc && doc._inc++;
var ns = newAttr.namespaceURI;
if (ns === NAMESPACE$2.XMLNS) el._nsMap[newAttr.prefix ? newAttr.localName : ""] = newAttr.value;
}
function _onRemoveAttribute(doc, el, newAttr, remove) {
doc && doc._inc++;
var ns = newAttr.namespaceURI;
if (ns === NAMESPACE$2.XMLNS) delete el._nsMap[newAttr.prefix ? newAttr.localName : ""];
}
/**
* Updates `el.childNodes`, updating the indexed items and it's `length`.
* Passing `newChild` means it will be appended.
* Otherwise it's assumed that an item has been removed,
* and `el.firstNode` and it's `.nextSibling` are used
* to walk the current list of child nodes.
*
* @param {Document} doc
* @param {Node} el
* @param {Node} [newChild]
* @private
*/
function _onUpdateChild(doc, el, newChild) {
if (doc && doc._inc) {
doc._inc++;
var cs = el.childNodes;
if (newChild) cs[cs.length++] = newChild;
else {
var child = el.firstChild;
var i$1 = 0;
while (child) {
cs[i$1++] = child;
child = child.nextSibling;
}
cs.length = i$1;
delete cs[cs.length];
}
}
}
/**
* Removes the connections between `parentNode` and `child`
* and any existing `child.previousSibling` or `child.nextSibling`.
*
* @see https://github.com/xmldom/xmldom/issues/135
* @see https://github.com/xmldom/xmldom/issues/145
*
* @param {Node} parentNode
* @param {Node} child
* @returns {Node} the child that was removed.
* @private
*/
function _removeChild(parentNode, child) {
var previous = child.previousSibling;
var next = child.nextSibling;
if (previous) previous.nextSibling = next;
else parentNode.firstChild = next;
if (next) next.previousSibling = previous;
else parentNode.lastChild = previous;
child.parentNode = null;
child.previousSibling = null;
child.nextSibling = null;
_onUpdateChild(parentNode.ownerDocument, parentNode);
return child;
}
/**
* Returns `true` if `node` can be a parent for insertion.
* @param {Node} node
* @returns {boolean}
*/
function hasValidParentNodeType(node) {
return node && (node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.ELEMENT_NODE);
}
/**
* Returns `true` if `node` can be inserted according to it's `nodeType`.
* @param {Node} node
* @returns {boolean}
*/
function hasInsertableNodeType(node) {
return node && (isElementNode(node) || isTextNode(node) || isDocTypeNode(node) || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.COMMENT_NODE || node.nodeType === Node.PROCESSING_INSTRUCTION_NODE);
}
/**
* Returns true if `node` is a DOCTYPE node
* @param {Node} node
* @returns {boolean}
*/
function isDocTypeNode(node) {
return node && node.nodeType === Node.DOCUMENT_TYPE_NODE;
}
/**
* Returns true if the node is an element
* @param {Node} node
* @returns {boolean}
*/
function isElementNode(node) {
return node && node.nodeType === Node.ELEMENT_NODE;
}
/**
* Returns true if `node` is a text node
* @param {Node} node
* @returns {boolean}
*/
function isTextNode(node) {
return node && node.nodeType === Node.TEXT_NODE;
}
/**
* Check if en element node can be inserted before `child`, or at the end if child is falsy,
* according to the presence and position of a doctype node on the same level.
*
* @param {Document} doc The document node
* @param {Node} child the node that would become the nextSibling if the element would be inserted
* @returns {boolean} `true` if an element can be inserted before child
* @private
* https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
*/
function isElementInsertionPossible(doc, child) {
var parentChildNodes = doc.childNodes || [];
if (find(parentChildNodes, isElementNode) || isDocTypeNode(child)) return false;
var docTypeNode = find(parentChildNodes, isDocTypeNode);
return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
}
/**
* Check if en element node can be inserted before `child`, or at the end if child is falsy,
* according to the presence and position of a doctype node on the same level.
*
* @param {Node} doc The document node
* @param {Node} child the node that would become the nextSibling if the element would be inserted
* @returns {boolean} `true` if an element can be inserted before child
* @private
* https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
*/
function isElementReplacementPossible(doc, child) {
var parentChildNodes = doc.childNodes || [];
function hasElementChildThatIsNotChild(node) {
return isElementNode(node) && node !== child;
}
if (find(parentChildNodes, hasElementChildThatIsNotChild)) return false;
var docTypeNode = find(parentChildNodes, isDocTypeNode);
return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
}
/**
* @private
* Steps 1-5 of the checks before inserting and before replacing a child are the same.
*
* @param {Node} parent the parent node to insert `node` into
* @param {Node} node the node to insert
* @param {Node=} child the node that should become the `nextSibling` of `node`
* @returns {Node}
* @throws DOMException for several node combinations that would create a DOM that is not well-formed.
* @throws DOMException if `child` is provided but is not a child of `parent`.
* @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
* @see https://dom.spec.whatwg.org/#concept-node-replace
*/
function assertPreInsertionValidity1to5(parent, node, child) {
if (!hasValidParentNodeType(parent)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Unexpected parent node type " + parent.nodeType);
if (child && child.parentNode !== parent) throw new DOMException(NOT_FOUND_ERR, "child not in parent");
if (!hasInsertableNodeType(node) || isDocTypeNode(node) && parent.nodeType !== Node.DOCUMENT_NODE) throw new DOMException(HIERARCHY_REQUEST_ERR, "Unexpected node type " + node.nodeType + " for parent node type " + parent.nodeType);
}
/**
* @private
* Step 6 of the checks before inserting and before replacing a child are different.
*
* @param {Document} parent the parent node to insert `node` into
* @param {Node} node the node to insert
* @param {Node | undefined} child the node that should become the `nextSibling` of `node`
* @returns {Node}
* @throws DOMException for several node combinations that would create a DOM that is not well-formed.
* @throws DOMException if `child` is provided but is not a child of `parent`.
* @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
* @see https://dom.spec.whatwg.org/#concept-node-replace
*/
function assertPreInsertionValidityInDocument(parent, node, child) {
var parentChildNodes = parent.childNodes || [];
var nodeChildNodes = node.childNodes || [];
if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
var nodeChildElements = nodeChildNodes.filter(isElementNode);
if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) throw new DOMException(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
if (nodeChildElements.length === 1 && !isElementInsertionPossible(parent, child)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
}
if (isElementNode(node)) {
if (!isElementInsertionPossible(parent, child)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
}
if (isDocTypeNode(node)) {
if (find(parentChildNodes, isDocTypeNode)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
var parentElementChild = find(parentChildNodes, isElementNode);
if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
if (!child && parentElementChild) throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can not be appended since element is present");
}
}
/**
* @private
* Step 6 of the checks before inserting and before replacing a child are different.
*
* @param {Document} parent the parent node to insert `node` into
* @param {Node} node the node to insert
* @param {Node | undefined} child the node that should become the `nextSibling` of `node`
* @returns {Node}
* @throws DOMException for several node combinations that would create a DOM that is not well-formed.
* @throws DOMException if `child` is provided but is not a child of `parent`.
* @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
* @see https://dom.spec.whatwg.org/#concept-node-replace
*/
function assertPreReplacementValidityInDocument(parent, node, child) {
var parentChildNodes = parent.childNodes || [];
var nodeChildNodes = node.childNodes || [];
if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
var nodeChildElements = nodeChildNodes.filter(isElementNode);
if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) throw new DOMException(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
if (nodeChildElements.length === 1 && !isElementReplacementPossible(parent, child)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
}
if (isElementNode(node)) {
if (!isElementReplacementPossible(parent, child)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
}
if (isDocTypeNode(node)) {
function hasDoctypeChildThatIsNotChild(node$1) {
return isDocTypeNode(node$1) && node$1 !== child;
}
if (find(parentChildNodes, hasDoctypeChildThatIsNotChild)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
var parentElementChild = find(parentChildNodes, isElementNode);
if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
}
}
/**
* @private
* @param {Node} parent the parent node to insert `node` into
* @param {Node} node the node to insert
* @param {Node=} child the node that should become the `nextSibling` of `node`
* @returns {Node}
* @throws DOMException for several node combinations that would create a DOM that is not well-formed.
* @throws DOMException if `child` is provided but is not a child of `parent`.
* @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
*/
function _insertBefore(parent, node, child, _inDocumentAssertion) {
assertPreInsertionValidity1to5(parent, node, child);
if (parent.nodeType === Node.DOCUMENT_NODE) (_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child);
var cp = node.parentNode;
if (cp) cp.removeChild(node);
if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
var newFirst = node.firstChild;
if (newFirst == null) return node;
var newLast = node.lastChild;
} else newFirst = newLast = node;
var pre = child ? child.previousSibling : parent.lastChild;
newFirst.previousSibling = pre;
newLast.nextSibling = child;
if (pre) pre.nextSibling = newFirst;
else parent.firstChild = newFirst;
if (child == null) parent.lastChild = newLast;
else child.previousSibling = newLast;
do
newFirst.parentNode = parent;
while (newFirst !== newLast && (newFirst = newFirst.nextSibling));
_onUpdateChild(parent.ownerDocument || parent, parent);
if (node.nodeType == DOCUMENT_FRAGMENT_NODE) node.firstChild = node.lastChild = null;
return node;
}
/**
* Appends `newChild` to `parentNode`.
* If `newChild` is already connected to a `parentNode` it is first removed from it.
*
* @see https://github.com/xmldom/xmldom/issues/135
* @see https://github.com/xmldom/xmldom/issues/145
* @param {Node} parentNode
* @param {Node} newChild
* @returns {Node}
* @private
*/
function _appendSingleChild(parentNode, newChild) {
if (newChild.parentNode) newChild.parentNode.removeChild(newChild);
newChild.parentNode = parentNode;
newChild.previousSibling = parentNode.lastChild;
newChild.nextSibling = null;
if (newChild.previousSibling) newChild.previousSibling.nextSibling = newChild;
else parentNode.firstChild = newChild;
parentNode.lastChild = newChild;
_onUpdateChild(parentNode.ownerDocument, parentNode, newChild);
return newChild;
}
Document.prototype = {
nodeName: "#document",
nodeType: DOCUMENT_NODE,
doctype: null,
documentElement: null,
_inc: 1,
insertBefore: function(newChild, refChild) {
if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
var child = newChild.firstChild;
while (child) {
var next = child.nextSibling;
this.insertBefore(child, refChild);
child = next;
}
return newChild;
}
_insertBefore(this, newChild, refChild);
newChild.ownerDocument = this;
if (this.documentElement === null && newChild.nodeType === ELEMENT_NODE) this.documentElement = newChild;
return newChild;
},
removeChild: function(oldChild) {
if (this.documentElement == oldChild) this.documentElement = null;
return _removeChild(this, oldChild);
},
replaceChild: function(newChild, oldChild) {
_insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
newChild.ownerDocument = this;
if (oldChild) this.removeChild(oldChild);
if (isElementNode(newChild)) this.documentElement = newChild;
},
importNode: function(importedNode, deep) {
return importNode(this, importedNode, deep);
},
getElementById: function(id) {
var rtv = null;
_visitNode(this.documentElement, function(node) {
if (node.nodeType == ELEMENT_NODE) {
if (node.getAttribute("id") == id) {
rtv = node;
return true;
}
}
});
return rtv;
},
getElementsByClassName: function(classNames) {
var classNamesSet = toOrderedSet(classNames);
return new LiveNodeList(this, function(base) {
var ls = [];
if (classNamesSet.length > 0) _visitNode(base.documentElement, function(node) {
if (node !== base && node.nodeType === ELEMENT_NODE) {
var nodeClassNames = node.getAttribute("class");
if (nodeClassNames) {
var matches = classNames === nodeClassNames;
if (!matches) {
var nodeClassNamesSet = toOrderedSet(nodeClassNames);
matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));
}
if (matches) ls.push(node);
}
}
});
return ls;
});
},
createElement: function(tagName) {
var node = new Element();
node.ownerDocument = this;
node.nodeName = tagName;
node.tagName = tagName;
node.localName = tagName;
node.childNodes = new NodeList();
var attrs = node.attributes = new NamedNodeMap();
attrs._ownerElement = node;
return node;
},
createDocumentFragment: function() {
var node = new DocumentFragment();
node.ownerDocument = this;
node.childNodes = new NodeList();
return node;
},
createTextNode: function(data) {
var node = new Text();
node.ownerDocument = this;
node.appendData(data);
return node;
},
createComment: function(data) {
var node = new Comment();
node.ownerDocument = this;
node.appendData(data);
return node;
},
createCDATASection: function(data) {
var node = new CDATASection();
node.ownerDocument = this;
node.appendData(data);
return node;
},
createProcessingInstruction: function(target, data) {
var node = new ProcessingInstruction();
node.ownerDocument = this;
node.tagName = node.nodeName = node.target = target;
node.nodeValue = node.data = data;
return node;
},
createAttribute: function(name) {
var node = new Attr();
node.ownerDocument = this;
node.name = name;
node.nodeName = name;
node.localName = name;
node.specified = true;
return node;
},
createEntityReference: function(name) {
var node = new EntityReference();
node.ownerDocument = this;
node.nodeName = name;
return node;
},
createElementNS: function(namespaceURI, qualifiedName) {
var node = new Element();
var pl = qualifiedName.split(":");
var attrs = node.attributes = new NamedNodeMap();
node.childNodes = new NodeList();
node.ownerDocument = this;
node.nodeName = qualifiedName;
node.tagName = qualifiedName;
node.namespaceURI = namespaceURI;
if (pl.length == 2) {
node.prefix = pl[0];
node.localName = pl[1];
} else node.localName = qualifiedName;
attrs._ownerElement = node;
return node;
},
createAttributeNS: function(namespaceURI, qualifiedName) {
var node = new Attr();
var pl = qualifiedName.split(":");
node.ownerDocument = this;
node.nodeName = qualifiedName;
node.name = qualifiedName;
node.namespaceURI = namespaceURI;
node.specified = true;
if (pl.length == 2) {
node.prefix = pl[0];
node.localName = pl[1];
} else node.localName = qualifiedName;
return node;
}
};
_extends(Document, Node);
function Element() {
this._nsMap = {};
}
Element.prototype = {
nodeType: ELEMENT_NODE,
hasAttribute: function(name) {
return this.getAttributeNode(name) != null;
},
getAttribute: function(name) {
var attr = this.getAttributeNode(name);
return attr && attr.value || "";
},
getAttributeNode: function(name) {
return this.attributes.getNamedItem(name);
},
setAttribute: function(name, value) {
var attr = this.ownerDocument.createAttribute(name);
attr.value = attr.nodeValue = "" + value;
this.setAttributeNode(attr);
},
removeAttribute: function(name) {
var attr = this.getAttributeNode(name);
attr && this.removeAttributeNode(attr);
},
appendChild: function(newChild) {
if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) return this.insertBefore(newChild, null);
else return _appendSingleChild(this, newChild);
},
setAttributeNode: function(newAttr) {
return this.attributes.setNamedItem(newAttr);
},
setAttributeNodeNS: function(newAttr) {
return this.attributes.setNamedItemNS(newAttr);
},
removeAttributeNode: function(oldAttr) {
return this.attributes.removeNamedItem(oldAttr.nodeName);
},
removeAttributeNS: function(namespaceURI, localName) {
var old = this.getAttributeNodeNS(namespaceURI, localName);
old && this.removeAttributeNode(old);
},
hasAttributeNS: function(namespaceURI, localName) {
return this.getAttributeNodeNS(namespaceURI, localName) != null;
},
getAttributeNS: function(namespaceURI, localName) {
var attr = this.getAttributeNodeNS(namespaceURI, localName);
return attr && attr.value || "";
},
setAttributeNS: function(namespaceURI, qualifiedName, value) {
var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
attr.value = attr.nodeValue = "" + value;
this.setAttributeNode(attr);
},
getAttributeNodeNS: function(namespaceURI, localName) {
return this.attributes.getNamedItemNS(namespaceURI, localName);
},
getElementsByTagName: function(tagName) {
return new LiveNodeList(this, function(base) {
var ls = [];
_visitNode(base, function(node) {
if (node !== base && node.nodeType == ELEMENT_NODE && (tagName === "*" || node.tagName == tagName)) ls.push(node);
});
return ls;
});
},
getElementsByTagNameNS: function(namespaceURI, localName) {
return new LiveNodeList(this, function(base) {
var ls = [];
_visitNode(base, function(node) {
if (node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === "*" || node.namespaceURI === namespaceURI) && (localName === "*" || node.localName == localName)) ls.push(node);
});
return ls;
});
}
};
Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
_extends(Element, Node);
function Attr() {}
Attr.prototype.nodeType = ATTRIBUTE_NODE;
_extends(Attr, Node);
function CharacterData() {}
CharacterData.prototype = {
data: "",
substringData: function(offset, count) {
return this.data.substring(offset, offset + count);
},
appendData: function(text) {
text = this.data + text;
this.nodeValue = this.data = text;
this.length = text.length;
},
insertData: function(offset, text) {
this.replaceData(offset, 0, text);
},
appendChild: function(newChild) {
throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);
},
deleteData: function(offset, count) {
this.replaceData(offset, count, "");
},
replaceData: function(offset, count, text) {
var start = this.data.substring(0, offset);
var end = this.data.substring(offset + count);
text = start + text + end;
this.nodeValue = this.data = text;
this.length = text.length;
}
};
_extends(CharacterData, Node);
function Text() {}
Text.prototype = {
nodeName: "#text",
nodeType: TEXT_NODE$1,
splitText: function(offset) {
var text = this.data;
var newText = text.substring(offset);
text = text.substring(0, offset);
this.data = this.nodeValue = text;
this.length = text.length;
var newNode = this.ownerDocument.createTextNode(newText);
if (this.parentNode) this.parentNode.insertBefore(newNode, this.nextSibling);
return newNode;
}
};
_extends(Text, CharacterData);
function Comment() {}
Comment.prototype = {
nodeName: "#comment",
nodeType: COMMENT_NODE$1
};
_extends(Comment, CharacterData);
function CDATASection() {}
CDATASection.prototype = {
nodeName: "#cdata-section",
nodeType: CDATA_SECTION_NODE
};
_extends(CDATASection, CharacterData);
function DocumentType() {}
DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
_extends(DocumentType, Node);
function Notation() {}
Notation.prototype.nodeType = NOTATION_NODE;
_extends(Notation, Node);
function Entity() {}
Entity.prototype.nodeType = ENTITY_NODE;
_extends(Entity, Node);
function EntityReference() {}
EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
_extends(EntityReference, Node);
function DocumentFragment() {}
DocumentFragment.prototype.nodeName = "#document-fragment";
DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
_extends(DocumentFragment, Node);
function ProcessingInstruction() {}
ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
_extends(ProcessingInstruction, Node);
function XMLSerializer() {}
XMLSerializer.prototype.serializeToString = function(node, isHtml, nodeFilter) {
return nodeSerializeToString.call(node, isHtml, nodeFilter);
};
Node.prototype.toString = nodeSerializeToString;
function nodeSerializeToString(isHtml, nodeFilter) {
var buf = [];
var refNode = this.nodeType == 9 && this.documentElement || this;
var prefix = refNode.prefix;
var uri = refNode.namespaceURI;
if (uri && prefix == null) {
var prefix = refNode.lookupPrefix(uri);
if (prefix == null) var visibleNamespaces = [{
namespace: uri,
prefix: null
}];
}
serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces);
return buf.join("");
}
function needNamespaceDefine(node, isHTML, visibleNamespaces) {
var prefix = node.prefix || "";
var uri = node.namespaceURI;
if (!uri) return false;
if (prefix === "xml" && uri === NAMESPACE$2.XML || uri === NAMESPACE$2.XMLNS) return false;
var i$1 = visibleNamespaces.length;
while (i$1--) {
var ns = visibleNamespaces[i$1];
if (ns.prefix === prefix) return ns.namespace !== uri;
}
return true;
}
/**
* Well-formed constraint: No < in Attribute Values
* > The replacement text of any entity referred to directly or indirectly
* > in an attribute value must not contain a <.
* @see https://www.w3.org/TR/xml11/#CleanAttrVals
* @see https://www.w3.org/TR/xml11/#NT-AttValue
*
* Literal whitespace other than space that appear in attribute values
* are serialized as their entity references, so they will be preserved.
* (In contrast to whitespace literals in the input which are normalized to spaces)
* @see https://www.w3.org/TR/xml11/#AVNormalize
* @see https://w3c.github.io/DOM-Parsing/#serializing-an-element-s-attributes
*/
function addSerializedAttribute(buf, qualifiedName, value) {
buf.push(" ", qualifiedName, "=\"", value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), "\"");
}
function serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces) {
if (!visibleNamespaces) visibleNamespaces = [];
if (nodeFilter) {
node = nodeFilter(node);
if (node) {
if (typeof node == "string") {
buf.push(node);
return;
}
} else return;
}
switch (node.nodeType) {
case ELEMENT_NODE:
var attrs = node.attributes;
var len$1 = attrs.length;
var child = node.firstChild;
var nodeName = node.tagName;
isHTML = NAMESPACE$2.isHTML(node.namespaceURI) || isHTML;
var prefixedNodeName = nodeName;
if (!isHTML && !node.prefix && node.namespaceURI) {
var defaultNS;
for (var ai = 0; ai < attrs.length; ai++) if (attrs.item(ai).name === "xmlns") {
defaultNS = attrs.item(ai).value;
break;
}
if (!defaultNS) for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
var namespace = visibleNamespaces[nsi];
if (namespace.prefix === "" && namespace.namespace === node.namespaceURI) {
defaultNS = namespace.namespace;
break;
}
}
if (defaultNS !== node.namespaceURI) for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
var namespace = visibleNamespaces[nsi];
if (namespace.namespace === node.namespaceURI) {
if (namespace.prefix) prefixedNodeName = namespace.prefix + ":" + nodeName;
break;
}
}
}
buf.push("<", prefixedNodeName);
for (var i$1 = 0; i$1 < len$1; i$1++) {
var attr = attrs.item(i$1);
if (attr.prefix == "xmlns") visibleNamespaces.push({
prefix: attr.localName,
namespace: attr.value
});
else if (attr.nodeName == "xmlns") visibleNamespaces.push({
prefix: "",
namespace: attr.value
});
}
for (var i$1 = 0; i$1 < len$1; i$1++) {
var attr = attrs.item(i$1);
if (needNamespaceDefine(attr, isHTML, visibleNamespaces)) {
var prefix = attr.prefix || "";
var uri = attr.namespaceURI;
addSerializedAttribute(buf, prefix ? "xmlns:" + prefix : "xmlns", uri);
visibleNamespaces.push({
prefix,
namespace: uri
});
}
serializeToString(attr, buf, isHTML, nodeFilter, visibleNamespaces);
}
if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
var prefix = node.prefix || "";
var uri = node.namespaceURI;
addSerializedAttribute(buf, prefix ? "xmlns:" + prefix : "xmlns", uri);
visibleNamespaces.push({
prefix,
namespace: uri
});
}
if (child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)) {
buf.push(">");
if (isHTML && /^script$/i.test(nodeName)) while (child) {
if (child.data) buf.push(child.data);
else serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
child = child.nextSibling;
}
else while (child) {
serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
child = child.nextSibling;
}
buf.push("</", prefixedNodeName, ">");
} else buf.push("/>");
return;
case DOCUMENT_NODE:
case DOCUMENT_FRAGMENT_NODE:
var child = node.firstChild;
while (child) {
serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
child = child.nextSibling;
}
return;
case ATTRIBUTE_NODE: return addSerializedAttribute(buf, node.name, node.value);
case TEXT_NODE$1:
/**
* The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
* except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section.
* If they are needed elsewhere, they must be escaped using either numeric character references or the strings
* `&` and `<` respectively.
* The right angle bracket (>) may be represented using the string " > ", and must, for compatibility,
* be escaped using either `>` or a character reference when it appears in the string `]]>` in content,
* when that string is not marking the end of a CDATA section.
*
* In the content of elements, character data is any string of characters
* which does not contain the start-delimiter of any markup
* and does not include the CDATA-section-close delimiter, `]]>`.
*
* @see https://www.w3.org/TR/xml/#NT-CharData
* @see https://w3c.github.io/DOM-Parsing/#xml-serializing-a-text-node
*/
return buf.push(node.data.replace(/[<&>]/g, _xmlEncoder));
case CDATA_SECTION_NODE: return buf.push("<![CDATA[", node.data, "]]>");
case COMMENT_NODE$1: return buf.push("<!--", node.data, "-->");
case DOCUMENT_TYPE_NODE:
var pubid = node.publicId;
var sysid = node.systemId;
buf.push("<!DOCTYPE ", node.name);
if (pubid) {
buf.push(" PUBLIC ", pubid);
if (sysid && sysid != ".") buf.push(" ", sysid);
buf.push(">");
} else if (sysid && sysid != ".") buf.push(" SYSTEM ", sysid, ">");
else {
var sub = node.internalSubset;
if (sub) buf.push(" [", sub, "]");
buf.push(">");
}
return;
case PROCESSING_INSTRUCTION_NODE: return buf.push("<?", node.target, " ", node.data, "?>");
case ENTITY_REFERENCE_NODE: return buf.push("&", node.nodeName, ";");
default: buf.push("??", node.nodeName);
}
}
function importNode(doc, node, deep) {
var node2;
switch (node.nodeType) {
case ELEMENT_NODE:
node2 = node.cloneNode(false);
node2.ownerDocument = doc;
case DOCUMENT_FRAGMENT_NODE: break;
case ATTRIBUTE_NODE:
deep = true;
break;
}
if (!node2) node2 = node.cloneNode(false);
node2.ownerDocument = doc;
node2.parentNode = null;
if (deep) {
var child = node.firstChild;
while (child) {
node2.appendChild(importNode(doc, child, deep));
child = child.nextSibling;
}
}
return node2;
}
function cloneNode(doc, node, deep) {
var node2 = new node.constructor();
for (var n in node) if (Object.prototype.hasOwnProperty.call(node, n)) {
var v = node[n];
if (typeof v != "object") {
if (v != node2[n]) node2[n] = v;
}
}
if (node.childNodes) node2.childNodes = new NodeList();
node2.ownerDocument = doc;
switch (node2.nodeType) {
case ELEMENT_NODE:
var attrs = node.attributes;
var attrs2 = node2.attributes = new NamedNodeMap();
var len$1 = attrs.length;
attrs2._ownerElement = node2;
for (var i$1 = 0; i$1 < len$1; i$1++) node2.setAttributeNode(cloneNode(doc, attrs.item(i$1), true));
break;
case ATTRIBUTE_NODE: deep = true;
}
if (deep) {
var child = node.firstChild;
while (child) {
node2.appendChild(cloneNode(doc, child, deep));
child = child.nextSibling;
}
}
return node2;
}
function __set__(object, key, value) {
object[key] = value;
}
try {
if (Object.defineProperty) {
Object.defineProperty(LiveNodeList.prototype, "length", { get: function() {
_updateLiveList(this);
return this.$$length;
} });
Object.defineProperty(Node.prototype, "textContent", {
get: function() {
return getTextContent(this);
},
set: function(data) {
switch (this.nodeType) {
case ELEMENT_NODE:
case DOCUMENT_FRAGMENT_NODE:
while (this.firstChild) this.removeChild(this.firstChild);
if (data || String(data)) this.appendChild(this.ownerDocument.createTextNode(data));
break;
default:
this.data = data;
this.value = data;
this.nodeValue = data;
}
}
});
function getTextContent(node) {
switch (node.nodeType) {
case ELEMENT_NODE:
case DOCUMENT_FRAGMENT_NODE:
var buf = [];
node = node.firstChild;
while (node) {
if (node.nodeType !== 7 && node.nodeType !== 8) buf.push(getTextContent(node));
node = node.nextSibling;
}
return buf.join("");
default: return node.nodeValue;
}
}
__set__ = function(object, key, value) {
object["$$" + key] = value;
};
}
} catch (e) {}
exports.DocumentType = DocumentType;
exports.DOMException = DOMException;
exports.DOMImplementation = DOMImplementation$1;
exports.Element = Element;
exports.Node = Node;
exports.NodeList = NodeList;
exports.XMLSerializer = XMLSerializer;
} });
//#endregion
//#region ../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/entities.js
var require_entities = __commonJS({ "../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/entities.js"(exports) {
var freeze = require_conventions().freeze;
/**
* The entities that are predefined in every XML document.
*
* @see https://www.w3.org/TR/2006/REC-xml11-20060816/#sec-predefined-ent W3C XML 1.1
* @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-predefined-ent W3C XML 1.0
* @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Predefined_entities_in_XML Wikipedia
*/
exports.XML_ENTITIES = freeze({
amp: "&",
apos: "'",
gt: ">",
lt: "<",
quot: "\""
});
/**
* A map of all entities that are detected in an HTML document.
* They contain all entries from `XML_ENTITIES`.
*
* @see XML_ENTITIES
* @see DOMParser.parseFromString
* @see DOMImplementation.prototype.createHTMLDocument
* @see https://html.spec.whatwg.org/#named-character-references WHATWG HTML(5) Spec
* @see https://html.spec.whatwg.org/entities.json JSON
* @see https://www.w3.org/TR/xml-entity-names/ W3C XML Entity Names
* @see https://www.w3.org/TR/html4/sgml/entities.html W3C HTML4/SGML
* @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Character_entity_references_in_HTML Wikipedia (HTML)
* @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Entities_representing_special_characters_in_XHTML Wikpedia (XHTML)
*/
exports.HTML_ENTITIES = freeze({
Aacute: "Á",
aacute: "á",
Abreve: "Ă",
abreve: "ă",
ac: "∾",
acd: "∿",
acE: "∾̳",
Acirc: "Â",
acirc: "â",
acute: "´",
Acy: "А",
acy: "а",
AElig: "Æ",
aelig: "æ",
af: "",
Afr: "𝔄",
afr: "𝔞",
Agrave: "À",
agrave: "à",
alefsym: "ℵ",
aleph: "ℵ",
Alpha: "Α",
alpha: "α",
Amacr: "Ā",
amacr: "ā",
amalg: "⨿",
AMP: "&",
amp: "&",
And: "⩓",
and: "∧",
andand: "⩕",
andd: "⩜",
andslope: "⩘",
andv: "⩚",
ang: "∠",
ange: "⦤",
angle: "∠",
angmsd: "∡",
angmsdaa: "⦨",
angmsdab: "⦩",
angmsdac: "⦪",
angmsdad: "⦫",
angmsdae: "⦬",
angmsdaf: "⦭",
angmsdag: "⦮",
angmsdah: "⦯",
angrt: "∟",
angrtvb: "⊾",
angrtvbd: "⦝",
angsph: "∢",
angst: "Å",
angzarr: "⍼",
Aogon: "Ą",
aogon: "ą",
Aopf: "𝔸",
aopf: "𝕒",
ap: "≈",
apacir: "⩯",
apE: "⩰",
ape: "≊",
apid: "≋",
apos: "'",
ApplyFunction: "",
approx: "≈",
approxeq: "≊",
Aring: "Å",
aring: "å",
Ascr: "𝒜",
ascr: "𝒶",
Assign: "≔",
ast: "*",
asymp: "≈",
asympeq: "≍",
Atilde: "Ã",
atilde: "ã",
Auml: "Ä",
auml: "ä",
awconint: "∳",
awint: "⨑",
backcong: "≌",
backepsilon: "϶",
backprime: "‵",
backsim: "∽",
backsimeq: "⋍",
Backslash: "∖",
Barv: "⫧",
barvee: "⊽",
Barwed: "⌆",
barwed: "⌅",
barwedge: "⌅",
bbrk: "⎵",
bbrktbrk: "⎶",
bcong: "≌",
Bcy: "Б",
bcy: "б",
bdquo: "„",
becaus: "∵",
Because: "∵",
because: "∵",
bemptyv: "⦰",
bepsi: "϶",
bernou: "ℬ",
Bernoullis: "ℬ",
Beta: "Β",
beta: "β",
beth: "ℶ",
between: "≬",
Bfr: "𝔅",
bfr: "𝔟",
bigcap: "⋂",
bigcirc: "◯",
bigcup: "⋃",
bigodot: "⨀",
bigoplus: "⨁",
bigotimes: "⨂",
bigsqcup: "⨆",
bigstar: "★",
bigtriangledown: "▽",
bigtriangleup: "△",
biguplus: "⨄",
bigvee: "⋁",
bigwedge: "⋀",
bkarow: "⤍",
blacklozenge: "⧫",
blacksquare: "▪",
blacktriangle: "▴",
blacktriangledown: "▾",
blacktriangleleft: "◂",
blacktriangleright: "▸",
blank: "␣",
blk12: "▒",
blk14: "░",
blk34: "▓",
block: "█",
bne: "=⃥",
bnequiv: "≡⃥",
bNot: "⫭",
bnot: "⌐",
Bopf: "𝔹",
bopf: "𝕓",
bot: "⊥",
bottom: "⊥",
bowtie: "⋈",
boxbox: "⧉",
boxDL: "╗",
boxDl: "╖",
boxdL: "╕",
boxdl: "┐",
boxDR: "╔",
boxDr: "╓",
boxdR: "╒",
boxdr: "┌",
boxH: "═",
boxh: "─",
boxHD: "╦",
boxHd: "╤",
boxhD: "╥",
boxhd: "┬",
boxHU: "╩",
boxHu: "╧",
boxhU: "╨",
boxhu: "┴",
boxminus: "⊟",
boxplus: "⊞",
boxtimes: "⊠",
boxUL: "╝",
boxUl: "╜",
boxuL: "╛",
boxul: "┘",
boxUR: "╚",
boxUr: "╙",
boxuR: "╘",
boxur: "└",
boxV: "║",
boxv: "│",
boxVH: "╬",
boxVh: "╫",
boxvH: "╪",
boxvh: "┼",
boxVL: "╣",
boxVl: "╢",
boxvL: "╡",
boxvl: "┤",
boxVR: "╠",
boxVr: "╟",
boxvR: "╞",
boxvr: "├",
bprime: "‵",
Breve: "˘",
breve: "˘",
brvbar: "¦",
Bscr: "ℬ",
bscr: "𝒷",
bsemi: "⁏",
bsim: "∽",
bsime: "⋍",
bsol: "\\",
bsolb: "⧅",
bsolhsub: "⟈",
bull: "•",
bullet: "•",
bump: "≎",
bumpE: "⪮",
bumpe: "≏",
Bumpeq: "≎",
bumpeq: "≏",
Cacute: "Ć",
cacute: "ć",
Cap: "⋒",
cap: "∩",
capand: "⩄",
capbrcup: "⩉",
capcap: "⩋",
capcup: "⩇",
capdot: "⩀",
CapitalDifferentialD: "ⅅ",
caps: "∩︀",
caret: "⁁",
caron: "ˇ",
Cayleys: "ℭ",
ccaps: "⩍",
Ccaron: "Č",
ccaron: "č",
Ccedil: "Ç",
ccedil: "ç",
Ccirc: "Ĉ",
ccirc: "ĉ",
Cconint: "∰",
ccups: "⩌",
ccupssm: "⩐",
Cdot: "Ċ",
cdot: "ċ",
cedil: "¸",
Cedilla: "¸",
cemptyv: "⦲",
cent: "¢",
CenterDot: "·",
centerdot: "·",
Cfr: "ℭ",
cfr: "𝔠",
CHcy: "Ч",
chcy: "ч",
check: "✓",
checkmark: "✓",
Chi: "Χ",
chi: "χ",
cir: "○",
circ: "ˆ",
circeq: "≗",
circlearrowleft: "↺",
circlearrowright: "↻",
circledast: "⊛",
circledcirc: "⊚",
circleddash: "⊝",
CircleDot: "⊙",
circledR: "®",
circledS: "Ⓢ",
CircleMinus: "⊖",
CirclePlus: "⊕",
CircleTimes: "⊗",
cirE: "⧃",
cire: "≗",
cirfnint: "⨐",
cirmid: "⫯",
cirscir: "⧂",
ClockwiseContourIntegral: "∲",
CloseCurlyDoubleQuote: "”",
CloseCurlyQuote: "’",
clubs: "♣",
clubsuit: "♣",
Colon: "∷",
colon: ":",
Colone: "⩴",
colone: "≔",
coloneq: "≔",
comma: ",",
commat: "@",
comp: "∁",
compfn: "∘",
complement: "∁",
complexes: "ℂ",
cong: "≅",
congdot: "⩭",
Congruent: "≡",
Conint: "∯",
conint: "∮",
ContourIntegral: "∮",
Copf: "ℂ",
copf: "𝕔",
coprod: "∐",
Coproduct: "∐",
COPY: "©",
copy: "©",
copysr: "℗",
CounterClockwiseContourIntegral: "∳",
crarr: "↵",
Cross: "⨯",
cross: "✗",
Cscr: "𝒞",
cscr: "𝒸",
csub: "⫏",
csube: "⫑",
csup: "⫐",
csupe: "⫒",
ctdot: "⋯",
cudarrl: "⤸",
cudarrr: "⤵",
cuepr: "⋞",
cuesc: "⋟",
cularr: "↶",
cularrp: "⤽",
Cup: "⋓",
cup: "∪",
cupbrcap: "⩈",
CupCap: "≍",
cupcap: "⩆",
cupcup: "⩊",
cupdot: "⊍",
cupor: "⩅",
cups: "∪︀",
curarr: "↷",
curarrm: "⤼",
curlyeqprec: "⋞",
curlyeqsucc: "⋟",
curlyvee: "⋎",
curlywedge: "⋏",
curren: "¤",
curvearrowleft: "↶",
curvearrowright: "↷",
cuvee: "⋎",
cuwed: "⋏",
cwconint: "∲",
cwint: "∱",
cylcty: "⌭",
Dagger: "‡",
dagger: "†",
daleth: "ℸ",
Darr: "↡",
dArr: "⇓",
darr: "↓",
dash: "‐",
Dashv: "⫤",
dashv: "⊣",
dbkarow: "⤏",
dblac: "˝",
Dcaron: "Ď",
dcaron: "ď",
Dcy: "Д",
dcy: "д",
DD: "ⅅ",
dd: "ⅆ",
ddagger: "‡",
ddarr: "⇊",
DDotrahd: "⤑",
ddotseq: "⩷",
deg: "°",
Del: "∇",
Delta: "Δ",
delta: "δ",
demptyv: "⦱",
dfisht: "⥿",
Dfr: "𝔇",
dfr: "𝔡",
dHar: "⥥",
dharl: "⇃",
dharr: "⇂",
DiacriticalAcute: "´",
DiacriticalDot: "˙",
DiacriticalDoubleAcute: "˝",
DiacriticalGrave: "`",
DiacriticalTilde: "˜",
diam: "⋄",
Diamond: "⋄",
diamond: "⋄",
diamondsuit: "♦",
diams: "♦",
die: "¨",
DifferentialD: "ⅆ",
digamma: "ϝ",
disin: "⋲",
div: "÷",
divide: "÷",
divideontimes: "⋇",
divonx: "⋇",
DJcy: "Ђ",
djcy: "ђ",
dlcorn: "⌞",
dlcrop: "⌍",
dollar: "$",
Dopf: "𝔻",
dopf: "𝕕",
Dot: "¨",
dot: "˙",
DotDot: "⃜",
doteq: "≐",
doteqdot: "≑",
DotEqual: "≐",
dotminus: "∸",
dotplus: "∔",
dotsquare: "⊡",
doublebarwedge: "⌆",
DoubleContourIntegral: "∯",
DoubleDot: "¨",
DoubleDownArrow: "⇓",
DoubleLeftArrow: "⇐",
DoubleLeftRightArrow: "⇔",
DoubleLeftTee: "⫤",
DoubleLongLeftArrow: "⟸",
DoubleLongLeftRightArrow: "⟺",
DoubleLongRightArrow: "⟹",
DoubleRightArrow: "⇒",
DoubleRightTee: "⊨",
DoubleUpArrow: "⇑",
DoubleUpDownArrow: "⇕",
DoubleVerticalBar: "∥",
DownArrow: "↓",
Downarrow: "⇓",
downarrow: "↓",
DownArrowBar: "⤓",
DownArrowUpArrow: "⇵",
DownBreve: "̑",
downdownarrows: "⇊",
downharpoonleft: "⇃",
downharpoonright: "⇂",
DownLeftRightVector: "⥐",
DownLeftTeeVector: "⥞",
DownLeftVector: "↽",
DownLeftVectorBar: "⥖",
DownRightTeeVector: "⥟",
DownRightVector: "⇁",
DownRightVectorBar: "⥗",
DownTee: "⊤",
DownTeeArrow: "↧",
drbkarow: "⤐",
drcorn: "⌟",
drcrop: "⌌",
Dscr: "𝒟",
dscr: "𝒹",
DScy: "Ѕ",
dscy: "ѕ",
dsol: "⧶",
Dstrok: "Đ",
dstrok: "đ",
dtdot: "⋱",
dtri: "▿",
dtrif: "▾",
duarr: "⇵",
duhar: "⥯",
dwangle: "⦦",
DZcy: "Џ",
dzcy: "џ",
dzigrarr: "⟿",
Eacute: "É",
eacute: "é",
easter: "⩮",
Ecaron: "Ě",
ecaron: "ě",
ecir: "≖",
Ecirc: "Ê",
ecirc: "ê",
ecolon: "≕",
Ecy: "Э",
ecy: "э",
eDDot: "⩷",
Edot: "Ė",
eDot: "≑",
edot: "ė",
ee: "ⅇ",
efDot: "≒",
Efr: "𝔈",
efr: "𝔢",
eg: "⪚",
Egrave: "È",
egrave: "è",
egs: "⪖",
egsdot: "⪘",
el: "⪙",
Element: "∈",
elinters: "⏧",
ell: "ℓ",
els: "⪕",
elsdot: "⪗",
Emacr: "Ē",
emacr: "ē",
empty: "∅",
emptyset: "∅",
EmptySmallSquare: "◻",
emptyv: "∅",
EmptyVerySmallSquare: "▫",
emsp: " ",
emsp13: " ",
emsp14: " ",
ENG: "Ŋ",
eng: "ŋ",
ensp: " ",
Eogon: "Ę",
eogon: "ę",
Eopf: "𝔼",
eopf: "𝕖",
epar: "⋕",
eparsl: "⧣",
eplus: "⩱",
epsi: "ε",
Epsilon: "Ε",
epsilon: "ε",
epsiv: "ϵ",
eqcirc: "≖",
eqcolon: "≕",
eqsim: "≂",
eqslantgtr: "⪖",
eqslantless: "⪕",
Equal: "⩵",
equals: "=",
EqualTilde: "≂",
equest: "≟",
Equilibrium: "⇌",
equiv: "≡",
equivDD: "⩸",
eqvparsl: "⧥",
erarr: "⥱",
erDot: "≓",
Escr: "ℰ",
escr: "ℯ",
esdot: "≐",
Esim: "⩳",
esim: "≂",
Eta: "Η",
eta: "η",
ETH: "Ð",
eth: "ð",
Euml: "Ë",
euml: "ë",
euro: "€",
excl: "!",
exist: "∃",
Exists: "∃",
expectation: "ℰ",
ExponentialE: "ⅇ",
exponentiale: "ⅇ",
fallingdotseq: "≒",
Fcy: "Ф",
fcy: "ф",
female: "♀",
ffilig: "ffi",
fflig: "ff",
ffllig: "ffl",
Ffr: "𝔉",
ffr: "𝔣",
filig: "fi",
FilledSmallSquare: "◼",
FilledVerySmallSquare: "▪",
fjlig: "fj",
flat: "♭",
fllig: "fl",
fltns: "▱",
fnof: "ƒ",
Fopf: "𝔽",
fopf: "𝕗",
ForAll: "∀",
forall: "∀",
fork: "⋔",
forkv: "⫙",
Fouriertrf: "ℱ",
fpartint: "⨍",
frac12: "½",
frac13: "⅓",
frac14: "¼",
frac15: "⅕",
frac16: "⅙",
frac18: "⅛",
frac23: "⅔",
frac25: "⅖",
frac34: "¾",
frac35: "⅗",
frac38: "⅜",
frac45: "⅘",
frac56: "⅚",
frac58: "⅝",
frac78: "⅞",
frasl: "⁄",
frown: "⌢",
Fscr: "ℱ",
fscr: "𝒻",
gacute: "ǵ",
Gamma: "Γ",
gamma: "γ",
Gammad: "Ϝ",
gammad: "ϝ",
gap: "⪆",
Gbreve: "Ğ",
gbreve: "ğ",
Gcedil: "Ģ",
Gcirc: "Ĝ",
gcirc: "ĝ",
Gcy: "Г",
gcy: "г",
Gdot: "Ġ",
gdot: "ġ",
gE: "≧",
ge: "≥",
gEl: "⪌",
gel: "⋛",
geq: "≥",
geqq: "≧",
geqslant: "⩾",
ges: "⩾",
gescc: "⪩",
gesdot: "⪀",
gesdoto: "⪂",
gesdotol: "⪄",
gesl: "⋛︀",
gesles: "⪔",
Gfr: "𝔊",
gfr: "𝔤",
Gg: "⋙",
gg: "≫",
ggg: "⋙",
gimel: "ℷ",
GJcy: "Ѓ",
gjcy: "ѓ",
gl: "≷",
gla: "⪥",
glE: "⪒",
glj: "⪤",
gnap: "⪊",
gnapprox: "⪊",
gnE: "≩",
gne: "⪈",
gneq: "⪈",
gneqq: "≩",
gnsim: "⋧",
Gopf: "𝔾",
gopf: "𝕘",
grave: "`",
GreaterEqual: "≥",
GreaterEqualLess: "⋛",
GreaterFullEqual: "≧",
GreaterGreater: "⪢",
GreaterLess: "≷",
GreaterSlantEqual: "⩾",
GreaterTilde: "≳",
Gscr: "𝒢",
gscr: "ℊ",
gsim: "≳",
gsime: "⪎",
gsiml: "⪐",
Gt: "≫",
GT: ">",
gt: ">",
gtcc: "⪧",
gtcir: "⩺",
gtdot: "⋗",
gtlPar: "⦕",
gtquest: "⩼",
gtrapprox: "⪆",
gtrarr: "⥸",
gtrdot: "⋗",
gtreqless: "⋛",
gtreqqless: "⪌",
gtrless: "≷",
gtrsim: "≳",
gvertneqq: "≩︀",
gvnE: "≩︀",
Hacek: "ˇ",
hairsp: " ",
half: "½",
hamilt: "ℋ",
HARDcy: "Ъ",
hardcy: "ъ",
hArr: "⇔",
harr: "↔",
harrcir: "⥈",
harrw: "↭",
Hat: "^",
hbar: "ℏ",
Hcirc: "Ĥ",
hcirc: "ĥ",
hearts: "♥",
heartsuit: "♥",
hellip: "…",
hercon: "⊹",
Hfr: "ℌ",
hfr: "𝔥",
HilbertSpace: "ℋ",
hksearow: "⤥",
hkswarow: "⤦",
hoarr: "⇿",
homtht: "∻",
hookleftarrow: "↩",
hookrightarrow: "↪",
Hopf: "ℍ",
hopf: "𝕙",
horbar: "―",
HorizontalLine: "─",
Hscr: "ℋ",
hscr: "𝒽",
hslash: "ℏ",
Hstrok: "Ħ",
hstrok: "ħ",
HumpDownHump: "≎",
HumpEqual: "≏",
hybull: "⁃",
hyphen: "‐",
Iacute: "Í",
iacute: "í",
ic: "",
Icirc: "Î",
icirc: "î",
Icy: "И",
icy: "и",
Idot: "İ",
IEcy: "Е",
iecy: "е",
iexcl: "¡",
iff: "⇔",
Ifr: "ℑ",
ifr: "𝔦",
Igrave: "Ì",
igrave: "ì",
ii: "ⅈ",
iiiint: "⨌",
iiint: "∭",
iinfin: "⧜",
iiota: "℩",
IJlig: "IJ",
ijlig: "ij",
Im: "ℑ",
Imacr: "Ī",
imacr: "ī",
image: "ℑ",
ImaginaryI: "ⅈ",
imagline: "ℐ",
imagpart: "ℑ",
imath: "ı",
imof: "⊷",
imped: "Ƶ",
Implies: "⇒",
in: "∈",
incare: "℅",
infin: "∞",
infintie: "⧝",
inodot: "ı",
Int: "∬",
int: "∫",
intcal: "⊺",
integers: "ℤ",
Integral: "∫",
intercal: "⊺",
Intersection: "⋂",
intlarhk: "⨗",
intprod: "⨼",
InvisibleComma: "",
InvisibleTimes: "",
IOcy: "Ё",
iocy: "ё",
Iogon: "Į",
iogon: "į",
Iopf: "𝕀",
iopf: "𝕚",
Iota: "Ι",
iota: "ι",
iprod: "⨼",
iquest: "¿",
Iscr: "ℐ",
iscr: "𝒾",
isin: "∈",
isindot: "⋵",
isinE: "⋹",
isins: "⋴",
isinsv: "⋳",
isinv: "∈",
it: "",
Itilde: "Ĩ",
itilde: "ĩ",
Iukcy: "І",
iukcy: "і",
Iuml: "Ï",
iuml: "ï",
Jcirc: "Ĵ",
jcirc: "ĵ",
Jcy: "Й",
jcy: "й",
Jfr: "𝔍",
jfr: "𝔧",
jmath: "ȷ",
Jopf: "𝕁",
jopf: "𝕛",
Jscr: "𝒥",
jscr: "𝒿",
Jsercy: "Ј",
jsercy: "ј",
Jukcy: "Є",
jukcy: "є",
Kappa: "Κ",
kappa: "κ",
kappav: "ϰ",
Kcedil: "Ķ",
kcedil: "ķ",
Kcy: "К",
kcy: "к",
Kfr: "𝔎",
kfr: "𝔨",
kgreen: "ĸ",
KHcy: "Х",
khcy: "х",
KJcy: "Ќ",
kjcy: "ќ",
Kopf: "𝕂",
kopf: "𝕜",
Kscr: "𝒦",
kscr: "𝓀",
lAarr: "⇚",
Lacute: "Ĺ",
lacute: "ĺ",
laemptyv: "⦴",
lagran: "ℒ",
Lambda: "Λ",
lambda: "λ",
Lang: "⟪",
lang: "⟨",
langd: "⦑",
langle: "⟨",
lap: "⪅",
Laplacetrf: "ℒ",
laquo: "«",
Larr: "↞",
lArr: "⇐",
larr: "←",
larrb: "⇤",
larrbfs: "⤟",
larrfs: "⤝",
larrhk: "↩",
larrlp: "↫",
larrpl: "⤹",
larrsim: "⥳",
larrtl: "↢",
lat: "⪫",
lAtail: "⤛",
latail: "⤙",
late: "⪭",
lates: "⪭︀",
lBarr: "⤎",
lbarr: "⤌",
lbbrk: "❲",
lbrace: "{",
lbrack: "[",
lbrke: "⦋",
lbrksld: "⦏",
lbrkslu: "⦍",
Lcaron: "Ľ",
lcaron: "ľ",
Lcedil: "Ļ",
lcedil: "ļ",
lceil: "⌈",
lcub: "{",
Lcy: "Л",
lcy: "л",
ldca: "⤶",
ldquo: "“",
ldquor: "„",
ldrdhar: "⥧",
ldrushar: "⥋",
ldsh: "↲",
lE: "≦",
le: "≤",
LeftAngleBracket: "⟨",
LeftArrow: "←",
Leftarrow: "⇐",
leftarrow: "←",
LeftArrowBar: "⇤",
LeftArrowRightArrow: "⇆",
leftarrowtail: "↢",
LeftCeiling: "⌈",
LeftDoubleBracket: "⟦",
LeftDownTeeVector: "⥡",
LeftDownVector: "⇃",
LeftDownVectorBar: "⥙",
LeftFloor: "⌊",
leftharpoondown: "↽",
leftharpoonup: "↼",
leftleftarrows: "⇇",
LeftRightArrow: "↔",
Leftrightarrow: "⇔",
leftrightarrow: "↔",
leftrightarrows: "⇆",
leftrightharpoons: "⇋",
leftrightsquigarrow: "↭",
LeftRightVector: "⥎",
LeftTee: "⊣",
LeftTeeArrow: "↤",
LeftTeeVector: "⥚",
leftthreetimes: "⋋",
LeftTriangle: "⊲",
LeftTriangleBar: "⧏",
LeftTriangleEqual: "⊴",
LeftUpDownVector: "⥑",
LeftUpTeeVector: "⥠",
LeftUpVector: "↿",
LeftUpVectorBar: "⥘",
LeftVector: "↼",
LeftVectorBar: "⥒",
lEg: "⪋",
leg: "⋚",
leq: "≤",
leqq: "≦",
leqslant: "⩽",
les: "⩽",
lescc: "⪨",
lesdot: "⩿",
lesdoto: "⪁",
lesdotor: "⪃",
lesg: "⋚︀",
lesges: "⪓",
lessapprox: "⪅",
lessdot: "⋖",
lesseqgtr: "⋚",
lesseqqgtr: "⪋",
LessEqualGreater: "⋚",
LessFullEqual: "≦",
LessGreater: "≶",
lessgtr: "≶",
LessLess: "⪡",
lesssim: "≲",
LessSlantEqual: "⩽",
LessTilde: "≲",
lfisht: "⥼",
lfloor: "⌊",
Lfr: "𝔏",
lfr: "𝔩",
lg: "≶",
lgE: "⪑",
lHar: "⥢",
lhard: "↽",
lharu: "↼",
lharul: "⥪",
lhblk: "▄",
LJcy: "Љ",
ljcy: "љ",
Ll: "⋘",
ll: "≪",
llarr: "⇇",
llcorner: "⌞",
Lleftarrow: "⇚",
llhard: "⥫",
lltri: "◺",
Lmidot: "Ŀ",
lmidot: "ŀ",
lmoust: "⎰",
lmoustache: "⎰",
lnap: "⪉",
lnapprox: "⪉",
lnE: "≨",
lne: "⪇",
lneq: "⪇",
lneqq: "≨",
lnsim: "⋦",
loang: "⟬",
loarr: "⇽",
lobrk: "⟦",
LongLeftArrow: "⟵",
Longleftarrow: "⟸",
longleftarrow: "⟵",
LongLeftRightArrow: "⟷",
Longleftrightarrow: "⟺",
longleftrightarrow: "⟷",
longmapsto: "⟼",
LongRightArrow: "⟶",
Longrightarrow: "⟹",
longrightarrow: "⟶",
looparrowleft: "↫",
looparrowright: "↬",
lopar: "⦅",
Lopf: "𝕃",
lopf: "𝕝",
loplus: "⨭",
lotimes: "⨴",
lowast: "∗",
lowbar: "_",
LowerLeftArrow: "↙",
LowerRightArrow: "↘",
loz: "◊",
lozenge: "◊",
lozf: "⧫",
lpar: "(",
lparlt: "⦓",
lrarr: "⇆",
lrcorner: "⌟",
lrhar: "⇋",
lrhard: "⥭",
lrm: "",
lrtri: "⊿",
lsaquo: "‹",
Lscr: "ℒ",
lscr: "𝓁",
Lsh: "↰",
lsh: "↰",
lsim: "≲",
lsime: "⪍",
lsimg: "⪏",
lsqb: "[",
lsquo: "‘",
lsquor: "‚",
Lstrok: "Ł",
lstrok: "ł",
Lt: "≪",
LT: "<",
lt: "<",
ltcc: "⪦",
ltcir: "⩹",
ltdot: "⋖",
lthree: "⋋",
ltimes: "⋉",
ltlarr: "⥶",
ltquest: "⩻",
ltri: "◃",
ltrie: "⊴",
ltrif: "◂",
ltrPar: "⦖",
lurdshar: "⥊",
luruhar: "⥦",
lvertneqq: "≨︀",
lvnE: "≨︀",
macr: "¯",
male: "♂",
malt: "✠",
maltese: "✠",
Map: "⤅",
map: "↦",
mapsto: "↦",
mapstodown: "↧",
mapstoleft: "↤",
mapstoup: "↥",
marker: "▮",
mcomma: "⨩",
Mcy: "М",
mcy: "м",
mdash: "—",
mDDot: "∺",
measuredangle: "∡",
MediumSpace: " ",
Mellintrf: "ℳ",
Mfr: "𝔐",
mfr: "𝔪",
mho: "℧",
micro: "µ",
mid: "∣",
midast: "*",
midcir: "⫰",
middot: "·",
minus: "−",
minusb: "⊟",
minusd: "∸",
minusdu: "⨪",
MinusPlus: "∓",
mlcp: "⫛",
mldr: "…",
mnplus: "∓",
models: "⊧",
Mopf: "𝕄",
mopf: "𝕞",
mp: "∓",
Mscr: "ℳ",
mscr: "𝓂",
mstpos: "∾",
Mu: "Μ",
mu: "μ",
multimap: "⊸",
mumap: "⊸",
nabla: "∇",
Nacute: "Ń",
nacute: "ń",
nang: "∠⃒",
nap: "≉",
napE: "⩰̸",
napid: "≋̸",
napos: "ʼn",
napprox: "≉",
natur: "♮",
natural: "♮",
naturals: "ℕ",
nbsp: "\xA0",
nbump: "≎̸",
nbumpe: "≏̸",
ncap: "⩃",
Ncaron: "Ň",
ncaron: "ň",
Ncedil: "Ņ",
ncedil: "ņ",
ncong: "≇",
ncongdot: "⩭̸",
ncup: "⩂",
Ncy: "Н",
ncy: "н",
ndash: "–",
ne: "≠",
nearhk: "⤤",
neArr: "⇗",
nearr: "↗",
nearrow: "↗",
nedot: "≐̸",
NegativeMediumSpace: "",
NegativeThickSpace: "",
NegativeThinSpace: "",
NegativeVeryThinSpace: "",
nequiv: "≢",
nesear: "⤨",
nesim: "≂̸",
NestedGreaterGreater: "≫",
NestedLessLess: "≪",
NewLine: "\n",
nexist: "∄",
nexists: "∄",
Nfr: "𝔑",
nfr: "𝔫",
ngE: "≧̸",
nge: "≱",
ngeq: "≱",
ngeqq: "≧̸",
ngeqslant: "⩾̸",
nges: "⩾̸",
nGg: "⋙̸",
ngsim: "≵",
nGt: "≫⃒",
ngt: "≯",
ngtr: "≯",
nGtv: "≫̸",
nhArr: "⇎",
nharr: "↮",
nhpar: "⫲",
ni: "∋",
nis: "⋼",
nisd: "⋺",
niv: "∋",
NJcy: "Њ",
njcy: "њ",
nlArr: "⇍",
nlarr: "↚",
nldr: "‥",
nlE: "≦̸",
nle: "≰",
nLeftarrow: "⇍",
nleftarrow: "↚",
nLeftrightarrow: "⇎",
nleftrightarrow: "↮",
nleq: "≰",
nleqq: "≦̸",
nleqslant: "⩽̸",
nles: "⩽̸",
nless: "≮",
nLl: "⋘̸",
nlsim: "≴",
nLt: "≪⃒",
nlt: "≮",
nltri: "⋪",
nltrie: "⋬",
nLtv: "≪̸",
nmid: "∤",
NoBreak: "",
NonBreakingSpace: "\xA0",
Nopf: "ℕ",
nopf: "𝕟",
Not: "⫬",
not: "¬",
NotCongruent: "≢",
NotCupCap: "≭",
NotDoubleVerticalBar: "∦",
NotElement: "∉",
NotEqual: "≠",
NotEqualTilde: "≂̸",
NotExists: "∄",
NotGreater: "≯",
NotGreaterEqual: "≱",
NotGreaterFullEqual: "≧̸",
NotGreaterGreater: "≫̸",
NotGreaterLess: "≹",
NotGreaterSlantEqual: "⩾̸",
NotGreaterTilde: "≵",
NotHumpDownHump: "≎̸",
NotHumpEqual: "≏̸",
notin: "∉",
notindot: "⋵̸",
notinE: "⋹̸",
notinva: "∉",
notinvb: "⋷",
notinvc: "⋶",
NotLeftTriangle: "⋪",
NotLeftTriangleBar: "⧏̸",
NotLeftTriangleEqual: "⋬",
NotLess: "≮",
NotLessEqual: "≰",
NotLessGreater: "≸",
NotLessLess: "≪̸",
NotLessSlantEqual: "⩽̸",
NotLessTilde: "≴",
NotNestedGreaterGreater: "⪢̸",
NotNestedLessLess: "⪡̸",
notni: "∌",
notniva: "∌",
notnivb: "⋾",
notnivc: "⋽",
NotPrecedes: "⊀",
NotPrecedesEqual: "⪯̸",
NotPrecedesSlantEqual: "⋠",
NotReverseElement: "∌",
NotRightTriangle: "⋫",
NotRightTriangleBar: "⧐̸",
NotRightTriangleEqual: "⋭",
NotSquareSubset: "⊏̸",
NotSquareSubsetEqual: "⋢",
NotSquareSuperset: "⊐̸",
NotSquareSupersetEqual: "⋣",
NotSubset: "⊂⃒",
NotSubsetEqual: "⊈",
NotSucceeds: "⊁",
NotSucceedsEqual: "⪰̸",
NotSucceedsSlantEqual: "⋡",
NotSucceedsTilde: "≿̸",
NotSuperset: "⊃⃒",
NotSupersetEqual: "⊉",
NotTilde: "≁",
NotTildeEqual: "≄",
NotTildeFullEqual: "≇",
NotTildeTilde: "≉",
NotVerticalBar: "∤",
npar: "∦",
nparallel: "∦",
nparsl: "⫽⃥",
npart: "∂̸",
npolint: "⨔",
npr: "⊀",
nprcue: "⋠",
npre: "⪯̸",
nprec: "⊀",
npreceq: "⪯̸",
nrArr: "⇏",
nrarr: "↛",
nrarrc: "⤳̸",
nrarrw: "↝̸",
nRightarrow: "⇏",
nrightarrow: "↛",
nrtri: "⋫",
nrtrie: "⋭",
nsc: "⊁",
nsccue: "⋡",
nsce: "⪰̸",
Nscr: "𝒩",
nscr: "𝓃",
nshortmid: "∤",
nshortparallel: "∦",
nsim: "≁",
nsime: "≄",
nsimeq: "≄",
nsmid: "∤",
nspar: "∦",
nsqsube: "⋢",
nsqsupe: "⋣",
nsub: "⊄",
nsubE: "⫅̸",
nsube: "⊈",
nsubset: "⊂⃒",
nsubseteq: "⊈",
nsubseteqq: "⫅̸",
nsucc: "⊁",
nsucceq: "⪰̸",
nsup: "⊅",
nsupE: "⫆̸",
nsupe: "⊉",
nsupset: "⊃⃒",
nsupseteq: "⊉",
nsupseteqq: "⫆̸",
ntgl: "≹",
Ntilde: "Ñ",
ntilde: "ñ",
ntlg: "≸",
ntriangleleft: "⋪",
ntrianglelefteq: "⋬",
ntriangleright: "⋫",
ntrianglerighteq: "⋭",
Nu: "Ν",
nu: "ν",
num: "#",
numero: "№",
numsp: " ",
nvap: "≍⃒",
nVDash: "⊯",
nVdash: "⊮",
nvDash: "⊭",
nvdash: "⊬",
nvge: "≥⃒",
nvgt: ">⃒",
nvHarr: "⤄",
nvinfin: "⧞",
nvlArr: "⤂",
nvle: "≤⃒",
nvlt: "<⃒",
nvltrie: "⊴⃒",
nvrArr: "⤃",
nvrtrie: "⊵⃒",
nvsim: "∼⃒",
nwarhk: "⤣",
nwArr: "⇖",
nwarr: "↖",
nwarrow: "↖",
nwnear: "⤧",
Oacute: "Ó",
oacute: "ó",
oast: "⊛",
ocir: "⊚",
Ocirc: "Ô",
ocirc: "ô",
Ocy: "О",
ocy: "о",
odash: "⊝",
Odblac: "Ő",
odblac: "ő",
odiv: "⨸",
odot: "⊙",
odsold: "⦼",
OElig: "Œ",
oelig: "œ",
ofcir: "⦿",
Ofr: "𝔒",
ofr: "𝔬",
ogon: "˛",
Ograve: "Ò",
ograve: "ò",
ogt: "⧁",
ohbar: "⦵",
ohm: "Ω",
oint: "∮",
olarr: "↺",
olcir: "⦾",
olcross: "⦻",
oline: "‾",
olt: "⧀",
Omacr: "Ō",
omacr: "ō",
Omega: "Ω",
omega: "ω",
Omicron: "Ο",
omicron: "ο",
omid: "⦶",
ominus: "⊖",
Oopf: "𝕆",
oopf: "𝕠",
opar: "⦷",
OpenCurlyDoubleQuote: "“",
OpenCurlyQuote: "‘",
operp: "⦹",
oplus: "⊕",
Or: "⩔",
or: "∨",
orarr: "↻",
ord: "⩝",
order: "ℴ",
orderof: "ℴ",
ordf: "ª",
ordm: "º",
origof: "⊶",
oror: "⩖",
orslope: "⩗",
orv: "⩛",
oS: "Ⓢ",
Oscr: "𝒪",
oscr: "ℴ",
Oslash: "Ø",
oslash: "ø",
osol: "⊘",
Otilde: "Õ",
otilde: "õ",
Otimes: "⨷",
otimes: "⊗",
otimesas: "⨶",
Ouml: "Ö",
ouml: "ö",
ovbar: "⌽",
OverBar: "‾",
OverBrace: "⏞",
OverBracket: "⎴",
OverParenthesis: "⏜",
par: "∥",
para: "¶",
parallel: "∥",
parsim: "⫳",
parsl: "⫽",
part: "∂",
PartialD: "∂",
Pcy: "П",
pcy: "п",
percnt: "%",
period: ".",
permil: "‰",
perp: "⊥",
pertenk: "‱",
Pfr: "𝔓",
pfr: "𝔭",
Phi: "Φ",
phi: "φ",
phiv: "ϕ",
phmmat: "ℳ",
phone: "☎",
Pi: "Π",
pi: "π",
pitchfork: "⋔",
piv: "ϖ",
planck: "ℏ",
planckh: "ℎ",
plankv: "ℏ",
plus: "+",
plusacir: "⨣",
plusb: "⊞",
pluscir: "⨢",
plusdo: "∔",
plusdu: "⨥",
pluse: "⩲",
PlusMinus: "±",
plusmn: "±",
plussim: "⨦",
plustwo: "⨧",
pm: "±",
Poincareplane: "ℌ",
pointint: "⨕",
Popf: "ℙ",
popf: "𝕡",
pound: "£",
Pr: "⪻",
pr: "≺",
prap: "⪷",
prcue: "≼",
prE: "⪳",
pre: "⪯",
prec: "≺",
precapprox: "⪷",
preccurlyeq: "≼",
Precedes: "≺",
PrecedesEqual: "⪯",
PrecedesSlantEqual: "≼",
PrecedesTilde: "≾",
preceq: "⪯",
precnapprox: "⪹",
precneqq: "⪵",
precnsim: "⋨",
precsim: "≾",
Prime: "″",
prime: "′",
primes: "ℙ",
prnap: "⪹",
prnE: "⪵",
prnsim: "⋨",
prod: "∏",
Product: "∏",
profalar: "⌮",
profline: "⌒",
profsurf: "⌓",
prop: "∝",
Proportion: "∷",
Proportional: "∝",
propto: "∝",
prsim: "≾",
prurel: "⊰",
Pscr: "𝒫",
pscr: "𝓅",
Psi: "Ψ",
psi: "ψ",
puncsp: " ",
Qfr: "𝔔",
qfr: "𝔮",
qint: "⨌",
Qopf: "ℚ",
qopf: "𝕢",
qprime: "⁗",
Qscr: "𝒬",
qscr: "𝓆",
quaternions: "ℍ",
quatint: "⨖",
quest: "?",
questeq: "≟",
QUOT: "\"",
quot: "\"",
rAarr: "⇛",
race: "∽̱",
Racute: "Ŕ",
racute: "ŕ",
radic: "√",
raemptyv: "⦳",
Rang: "⟫",
rang: "⟩",
rangd: "⦒",
range: "⦥",
rangle: "⟩",
raquo: "»",
Rarr: "↠",
rArr: "⇒",
rarr: "→",
rarrap: "⥵",
rarrb: "⇥",
rarrbfs: "⤠",
rarrc: "⤳",
rarrfs: "⤞",
rarrhk: "↪",
rarrlp: "↬",
rarrpl: "⥅",
rarrsim: "⥴",
Rarrtl: "⤖",
rarrtl: "↣",
rarrw: "↝",
rAtail: "⤜",
ratail: "⤚",
ratio: "∶",
rationals: "ℚ",
RBarr: "⤐",
rBarr: "⤏",
rbarr: "⤍",
rbbrk: "❳",
rbrace: "}",
rbrack: "]",
rbrke: "⦌",
rbrksld: "⦎",
rbrkslu: "⦐",
Rcaron: "Ř",
rcaron: "ř",
Rcedil: "Ŗ",
rcedil: "ŗ",
rceil: "⌉",
rcub: "}",
Rcy: "Р",
rcy: "р",
rdca: "⤷",
rdldhar: "⥩",
rdquo: "”",
rdquor: "”",
rdsh: "↳",
Re: "ℜ",
real: "ℜ",
realine: "ℛ",
realpart: "ℜ",
reals: "ℝ",
rect: "▭",
REG: "®",
reg: "®",
ReverseElement: "∋",
ReverseEquilibrium: "⇋",
ReverseUpEquilibrium: "⥯",
rfisht: "⥽",
rfloor: "⌋",
Rfr: "ℜ",
rfr: "𝔯",
rHar: "⥤",
rhard: "⇁",
rharu: "⇀",
rharul: "⥬",
Rho: "Ρ",
rho: "ρ",
rhov: "ϱ",
RightAngleBracket: "⟩",
RightArrow: "→",
Rightarrow: "⇒",
rightarrow: "→",
RightArrowBar: "⇥",
RightArrowLeftArrow: "⇄",
rightarrowtail: "↣",
RightCeiling: "⌉",
RightDoubleBracket: "⟧",
RightDownTeeVector: "⥝",
RightDownVector: "⇂",
RightDownVectorBar: "⥕",
RightFloor: "⌋",
rightharpoondown: "⇁",
rightharpoonup: "⇀",
rightleftarrows: "⇄",
rightleftharpoons: "⇌",
rightrightarrows: "⇉",
rightsquigarrow: "↝",
RightTee: "⊢",
RightTeeArrow: "↦",
RightTeeVector: "⥛",
rightthreetimes: "⋌",
RightTriangle: "⊳",
RightTriangleBar: "⧐",
RightTriangleEqual: "⊵",
RightUpDownVector: "⥏",
RightUpTeeVector: "⥜",
RightUpVector: "↾",
RightUpVectorBar: "⥔",
RightVector: "⇀",
RightVectorBar: "⥓",
ring: "˚",
risingdotseq: "≓",
rlarr: "⇄",
rlhar: "⇌",
rlm: "",
rmoust: "⎱",
rmoustache: "⎱",
rnmid: "⫮",
roang: "⟭",
roarr: "⇾",
robrk: "⟧",
ropar: "⦆",
Ropf: "ℝ",
ropf: "𝕣",
roplus: "⨮",
rotimes: "⨵",
RoundImplies: "⥰",
rpar: ")",
rpargt: "⦔",
rppolint: "⨒",
rrarr: "⇉",
Rrightarrow: "⇛",
rsaquo: "›",
Rscr: "ℛ",
rscr: "𝓇",
Rsh: "↱",
rsh: "↱",
rsqb: "]",
rsquo: "’",
rsquor: "’",
rthree: "⋌",
rtimes: "⋊",
rtri: "▹",
rtrie: "⊵",
rtrif: "▸",
rtriltri: "⧎",
RuleDelayed: "⧴",
ruluhar: "⥨",
rx: "℞",
Sacute: "Ś",
sacute: "ś",
sbquo: "‚",
Sc: "⪼",
sc: "≻",
scap: "⪸",
Scaron: "Š",
scaron: "š",
sccue: "≽",
scE: "⪴",
sce: "⪰",
Scedil: "Ş",
scedil: "ş",
Scirc: "Ŝ",
scirc: "ŝ",
scnap: "⪺",
scnE: "⪶",
scnsim: "⋩",
scpolint: "⨓",
scsim: "≿",
Scy: "С",
scy: "с",
sdot: "⋅",
sdotb: "⊡",
sdote: "⩦",
searhk: "⤥",
seArr: "⇘",
searr: "↘",
searrow: "↘",
sect: "§",
semi: ";",
seswar: "⤩",
setminus: "∖",
setmn: "∖",
sext: "✶",
Sfr: "𝔖",
sfr: "𝔰",
sfrown: "⌢",
sharp: "♯",
SHCHcy: "Щ",
shchcy: "щ",
SHcy: "Ш",
shcy: "ш",
ShortDownArrow: "↓",
ShortLeftArrow: "←",
shortmid: "∣",
shortparallel: "∥",
ShortRightArrow: "→",
ShortUpArrow: "↑",
shy: "",
Sigma: "Σ",
sigma: "σ",
sigmaf: "ς",
sigmav: "ς",
sim: "∼",
simdot: "⩪",
sime: "≃",
simeq: "≃",
simg: "⪞",
simgE: "⪠",
siml: "⪝",
simlE: "⪟",
simne: "≆",
simplus: "⨤",
simrarr: "⥲",
slarr: "←",
SmallCircle: "∘",
smallsetminus: "∖",
smashp: "⨳",
smeparsl: "⧤",
smid: "∣",
smile: "⌣",
smt: "⪪",
smte: "⪬",
smtes: "⪬︀",
SOFTcy: "Ь",
softcy: "ь",
sol: "/",
solb: "⧄",
solbar: "⌿",
Sopf: "𝕊",
sopf: "𝕤",
spades: "♠",
spadesuit: "♠",
spar: "∥",
sqcap: "⊓",
sqcaps: "⊓︀",
sqcup: "⊔",
sqcups: "⊔︀",
Sqrt: "√",
sqsub: "⊏",
sqsube: "⊑",
sqsubset: "⊏",
sqsubseteq: "⊑",
sqsup: "⊐",
sqsupe: "⊒",
sqsupset: "⊐",
sqsupseteq: "⊒",
squ: "□",
Square: "□",
square: "□",
SquareIntersection: "⊓",
SquareSubset: "⊏",
SquareSubsetEqual: "⊑",
SquareSuperset: "⊐",
SquareSupersetEqual: "⊒",
SquareUnion: "⊔",
squarf: "▪",
squf: "▪",
srarr: "→",
Sscr: "𝒮",
sscr: "𝓈",
ssetmn: "∖",
ssmile: "⌣",
sstarf: "⋆",
Star: "⋆",
star: "☆",
starf: "★",
straightepsilon: "ϵ",
straightphi: "ϕ",
strns: "¯",
Sub: "⋐",
sub: "⊂",
subdot: "⪽",
subE: "⫅",
sube: "⊆",
subedot: "⫃",
submult: "⫁",
subnE: "⫋",
subne: "⊊",
subplus: "⪿",
subrarr: "⥹",
Subset: "⋐",
subset: "⊂",
subseteq: "⊆",
subseteqq: "⫅",
SubsetEqual: "⊆",
subsetneq: "⊊",
subsetneqq: "⫋",
subsim: "⫇",
subsub: "⫕",
subsup: "⫓",
succ: "≻",
succapprox: "⪸",
succcurlyeq: "≽",
Succeeds: "≻",
SucceedsEqual: "⪰",
SucceedsSlantEqual: "≽",
SucceedsTilde: "≿",
succeq: "⪰",
succnapprox: "⪺",
succneqq: "⪶",
succnsim: "⋩",
succsim: "≿",
SuchThat: "∋",
Sum: "∑",
sum: "∑",
sung: "♪",
Sup: "⋑",
sup: "⊃",
sup1: "¹",
sup2: "²",
sup3: "³",
supdot: "⪾",
supdsub: "⫘",
supE: "⫆",
supe: "⊇",
supedot: "⫄",
Superset: "⊃",
SupersetEqual: "⊇",
suphsol: "⟉",
suphsub: "⫗",
suplarr: "⥻",
supmult: "⫂",
supnE: "⫌",
supne: "⊋",
supplus: "⫀",
Supset: "⋑",
supset: "⊃",
supseteq: "⊇",
supseteqq: "⫆",
supsetneq: "⊋",
supsetneqq: "⫌",
supsim: "⫈",
supsub: "⫔",
supsup: "⫖",
swarhk: "⤦",
swArr: "⇙",
swarr: "↙",
swarrow: "↙",
swnwar: "⤪",
szlig: "ß",
Tab: " ",
target: "⌖",
Tau: "Τ",
tau: "τ",
tbrk: "⎴",
Tcaron: "Ť",
tcaron: "ť",
Tcedil: "Ţ",
tcedil: "ţ",
Tcy: "Т",
tcy: "т",
tdot: "⃛",
telrec: "⌕",
Tfr: "𝔗",
tfr: "𝔱",
there4: "∴",
Therefore: "∴",
therefore: "∴",
Theta: "Θ",
theta: "θ",
thetasym: "ϑ",
thetav: "ϑ",
thickapprox: "≈",
thicksim: "∼",
ThickSpace: " ",
thinsp: " ",
ThinSpace: " ",
thkap: "≈",
thksim: "∼",
THORN: "Þ",
thorn: "þ",
Tilde: "∼",
tilde: "˜",
TildeEqual: "≃",
TildeFullEqual: "≅",
TildeTilde: "≈",
times: "×",
timesb: "⊠",
timesbar: "⨱",
timesd: "⨰",
tint: "∭",
toea: "⤨",
top: "⊤",
topbot: "⌶",
topcir: "⫱",
Topf: "𝕋",
topf: "𝕥",
topfork: "⫚",
tosa: "⤩",
tprime: "‴",
TRADE: "™",
trade: "™",
triangle: "▵",
triangledown: "▿",
triangleleft: "◃",
trianglelefteq: "⊴",
triangleq: "≜",
triangleright: "▹",
trianglerighteq: "⊵",
tridot: "◬",
trie: "≜",
triminus: "⨺",
TripleDot: "⃛",
triplus: "⨹",
trisb: "⧍",
tritime: "⨻",
trpezium: "⏢",
Tscr: "𝒯",
tscr: "𝓉",
TScy: "Ц",
tscy: "ц",
TSHcy: "Ћ",
tshcy: "ћ",
Tstrok: "Ŧ",
tstrok: "ŧ",
twixt: "≬",
twoheadleftarrow: "↞",
twoheadrightarrow: "↠",
Uacute: "Ú",
uacute: "ú",
Uarr: "↟",
uArr: "⇑",
uarr: "↑",
Uarrocir: "⥉",
Ubrcy: "Ў",
ubrcy: "ў",
Ubreve: "Ŭ",
ubreve: "ŭ",
Ucirc: "Û",
ucirc: "û",
Ucy: "У",
ucy: "у",
udarr: "⇅",
Udblac: "Ű",
udblac: "ű",
udhar: "⥮",
ufisht: "⥾",
Ufr: "𝔘",
ufr: "𝔲",
Ugrave: "Ù",
ugrave: "ù",
uHar: "⥣",
uharl: "↿",
uharr: "↾",
uhblk: "▀",
ulcorn: "⌜",
ulcorner: "⌜",
ulcrop: "⌏",
ultri: "◸",
Umacr: "Ū",
umacr: "ū",
uml: "¨",
UnderBar: "_",
UnderBrace: "⏟",
UnderBracket: "⎵",
UnderParenthesis: "⏝",
Union: "⋃",
UnionPlus: "⊎",
Uogon: "Ų",
uogon: "ų",
Uopf: "𝕌",
uopf: "𝕦",
UpArrow: "↑",
Uparrow: "⇑",
uparrow: "↑",
UpArrowBar: "⤒",
UpArrowDownArrow: "⇅",
UpDownArrow: "↕",
Updownarrow: "⇕",
updownarrow: "↕",
UpEquilibrium: "⥮",
upharpoonleft: "↿",
upharpoonright: "↾",
uplus: "⊎",
UpperLeftArrow: "↖",
UpperRightArrow: "↗",
Upsi: "ϒ",
upsi: "υ",
upsih: "ϒ",
Upsilon: "Υ",
upsilon: "υ",
UpTee: "⊥",
UpTeeArrow: "↥",
upuparrows: "⇈",
urcorn: "⌝",
urcorner: "⌝",
urcrop: "⌎",
Uring: "Ů",
uring: "ů",
urtri: "◹",
Uscr: "𝒰",
uscr: "𝓊",
utdot: "⋰",
Utilde: "Ũ",
utilde: "ũ",
utri: "▵",
utrif: "▴",
uuarr: "⇈",
Uuml: "Ü",
uuml: "ü",
uwangle: "⦧",
vangrt: "⦜",
varepsilon: "ϵ",
varkappa: "ϰ",
varnothing: "∅",
varphi: "ϕ",
varpi: "ϖ",
varpropto: "∝",
vArr: "⇕",
varr: "↕",
varrho: "ϱ",
varsigma: "ς",
varsubsetneq: "⊊︀",
varsubsetneqq: "⫋︀",
varsupsetneq: "⊋︀",
varsupsetneqq: "⫌︀",
vartheta: "ϑ",
vartriangleleft: "⊲",
vartriangleright: "⊳",
Vbar: "⫫",
vBar: "⫨",
vBarv: "⫩",
Vcy: "В",
vcy: "в",
VDash: "⊫",
Vdash: "⊩",
vDash: "⊨",
vdash: "⊢",
Vdashl: "⫦",
Vee: "⋁",
vee: "∨",
veebar: "⊻",
veeeq: "≚",
vellip: "⋮",
Verbar: "‖",
verbar: "|",
Vert: "‖",
vert: "|",
VerticalBar: "∣",
VerticalLine: "|",
VerticalSeparator: "❘",
VerticalTilde: "≀",
VeryThinSpace: " ",
Vfr: "𝔙",
vfr: "𝔳",
vltri: "⊲",
vnsub: "⊂⃒",
vnsup: "⊃⃒",
Vopf: "𝕍",
vopf: "𝕧",
vprop: "∝",
vrtri: "⊳",
Vscr: "𝒱",
vscr: "𝓋",
vsubnE: "⫋︀",
vsubne: "⊊︀",
vsupnE: "⫌︀",
vsupne: "⊋︀",
Vvdash: "⊪",
vzigzag: "⦚",
Wcirc: "Ŵ",
wcirc: "ŵ",
wedbar: "⩟",
Wedge: "⋀",
wedge: "∧",
wedgeq: "≙",
weierp: "℘",
Wfr: "𝔚",
wfr: "𝔴",
Wopf: "𝕎",
wopf: "𝕨",
wp: "℘",
wr: "≀",
wreath: "≀",
Wscr: "𝒲",
wscr: "𝓌",
xcap: "⋂",
xcirc: "◯",
xcup: "⋃",
xdtri: "▽",
Xfr: "𝔛",
xfr: "𝔵",
xhArr: "⟺",
xharr: "⟷",
Xi: "Ξ",
xi: "ξ",
xlArr: "⟸",
xlarr: "⟵",
xmap: "⟼",
xnis: "⋻",
xodot: "⨀",
Xopf: "𝕏",
xopf: "𝕩",
xoplus: "⨁",
xotime: "⨂",
xrArr: "⟹",
xrarr: "⟶",
Xscr: "𝒳",
xscr: "𝓍",
xsqcup: "⨆",
xuplus: "⨄",
xutri: "△",
xvee: "⋁",
xwedge: "⋀",
Yacute: "Ý",
yacute: "ý",
YAcy: "Я",
yacy: "я",
Ycirc: "Ŷ",
ycirc: "ŷ",
Ycy: "Ы",
ycy: "ы",
yen: "¥",
Yfr: "𝔜",
yfr: "𝔶",
YIcy: "Ї",
yicy: "ї",
Yopf: "𝕐",
yopf: "𝕪",
Yscr: "𝒴",
yscr: "𝓎",
YUcy: "Ю",
yucy: "ю",
Yuml: "Ÿ",
yuml: "ÿ",
Zacute: "Ź",
zacute: "ź",
Zcaron: "Ž",
zcaron: "ž",
Zcy: "З",
zcy: "з",
Zdot: "Ż",
zdot: "ż",
zeetrf: "ℨ",
ZeroWidthSpace: "",
Zeta: "Ζ",
zeta: "ζ",
Zfr: "ℨ",
zfr: "𝔷",
ZHcy: "Ж",
zhcy: "ж",
zigrarr: "⇝",
Zopf: "ℤ",
zopf: "𝕫",
Zscr: "𝒵",
zscr: "𝓏",
zwj: "",
zwnj: ""
});
/**
* @deprecated use `HTML_ENTITIES` instead
* @see HTML_ENTITIES
*/
exports.entityMap = exports.HTML_ENTITIES;
} });
//#endregion
//#region ../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/sax.js
var require_sax = __commonJS({ "../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/sax.js"(exports) {
var NAMESPACE$1 = require_conventions().NAMESPACE;
var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
var nameChar = new RegExp("[\\-\\.0-9" + nameStartChar.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
var tagNamePattern = new RegExp("^" + nameStartChar.source + nameChar.source + "*(?::" + nameStartChar.source + nameChar.source + "*)?$");
var S_TAG = 0;
var S_ATTR = 1;
var S_ATTR_SPACE = 2;
var S_EQ = 3;
var S_ATTR_NOQUOT_VALUE = 4;
var S_ATTR_END = 5;
var S_TAG_SPACE = 6;
var S_TAG_CLOSE = 7;
/**
* Creates an error that will not be caught by XMLReader aka the SAX parser.
*
* @param {string} message
* @param {any?} locator Optional, can provide details about the location in the source
* @constructor
*/
function ParseError$1(message, locator) {
this.message = message;
this.locator = locator;
if (Error.captureStackTrace) Error.captureStackTrace(this, ParseError$1);
}
ParseError$1.prototype = new Error();
ParseError$1.prototype.name = ParseError$1.name;
function XMLReader$1() {}
XMLReader$1.prototype = { parse: function(source, defaultNSMap, entityMap) {
var domBuilder = this.domBuilder;
domBuilder.startDocument();
_copy(defaultNSMap, defaultNSMap = {});
parse$1(source, defaultNSMap, entityMap, domBuilder, this.errorHandler);
domBuilder.endDocument();
} };
function parse$1(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {
function fixedFromCharCode(code$1) {
if (code$1 > 65535) {
code$1 -= 65536;
var surrogate1 = 55296 + (code$1 >> 10), surrogate2 = 56320 + (code$1 & 1023);
return String.fromCharCode(surrogate1, surrogate2);
} else return String.fromCharCode(code$1);
}
function entityReplacer(a$1) {
var k = a$1.slice(1, -1);
if (Object.hasOwnProperty.call(entityMap, k)) return entityMap[k];
else if (k.charAt(0) === "#") return fixedFromCharCode(parseInt(k.substr(1).replace("x", "0x")));
else {
errorHandler.error("entity not found:" + a$1);
return a$1;
}
}
function appendText(end$1) {
if (end$1 > start) {
var xt = source.substring(start, end$1).replace(/&#?\w+;/g, entityReplacer);
locator && position$1(start);
domBuilder.characters(xt, 0, end$1 - start);
start = end$1;
}
}
function position$1(p$2, m) {
while (p$2 >= lineEnd && (m = linePattern.exec(source))) {
lineStart = m.index;
lineEnd = lineStart + m[0].length;
locator.lineNumber++;
}
locator.columnNumber = p$2 - lineStart + 1;
}
var lineStart = 0;
var lineEnd = 0;
var linePattern = /.*(?:\r\n?|\n)|.*$/g;
var locator = domBuilder.locator;
var parseStack = [{ currentNSMap: defaultNSMapCopy }];
var closeMap = {};
var start = 0;
while (true) {
try {
var tagStart = source.indexOf("<", start);
if (tagStart < 0) {
if (!source.substr(start).match(/^\s*$/)) {
var doc = domBuilder.doc;
var text = doc.createTextNode(source.substr(start));
doc.appendChild(text);
domBuilder.currentElement = text;
}
return;
}
if (tagStart > start) appendText(tagStart);
switch (source.charAt(tagStart + 1)) {
case "/":
var end = source.indexOf(">", tagStart + 3);
var tagName = source.substring(tagStart + 2, end).replace(/[ \t\n\r]+$/g, "");
var config = parseStack.pop();
if (end < 0) {
tagName = source.substring(tagStart + 2).replace(/[\s<].*/, "");
errorHandler.error("end tag name: " + tagName + " is not complete:" + config.tagName);
end = tagStart + 1 + tagName.length;
} else if (tagName.match(/\s</)) {
tagName = tagName.replace(/[\s<].*/, "");
errorHandler.error("end tag name: " + tagName + " maybe not complete");
end = tagStart + 1 + tagName.length;
}
var localNSMap = config.localNSMap;
var endMatch = config.tagName == tagName;
var endIgnoreCaseMach = endMatch || config.tagName && config.tagName.toLowerCase() == tagName.toLowerCase();
if (endIgnoreCaseMach) {
domBuilder.endElement(config.uri, config.localName, tagName);
if (localNSMap) {
for (var prefix in localNSMap) if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) domBuilder.endPrefixMapping(prefix);
}
if (!endMatch) errorHandler.fatalError("end tag name: " + tagName + " is not match the current start tagName:" + config.tagName);
} else parseStack.push(config);
end++;
break;
case "?":
locator && position$1(tagStart);
end = parseInstruction(source, tagStart, domBuilder);
break;
case "!":
locator && position$1(tagStart);
end = parseDCC(source, tagStart, domBuilder, errorHandler);
break;
default:
locator && position$1(tagStart);
var el = new ElementAttributes();
var currentNSMap = parseStack[parseStack.length - 1].currentNSMap;
var end = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler);
var len$1 = el.length;
if (!el.closed && fixSelfClosed(source, end, el.tagName, closeMap)) {
el.closed = true;
if (!entityMap.nbsp) errorHandler.warning("unclosed xml attribute");
}
if (locator && len$1) {
var locator2 = copyLocator(locator, {});
for (var i$1 = 0; i$1 < len$1; i$1++) {
var a = el[i$1];
position$1(a.offset);
a.locator = copyLocator(locator, {});
}
domBuilder.locator = locator2;
if (appendElement$1(el, domBuilder, currentNSMap)) parseStack.push(el);
domBuilder.locator = locator;
} else if (appendElement$1(el, domBuilder, currentNSMap)) parseStack.push(el);
if (NAMESPACE$1.isHTML(el.uri) && !el.closed) end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);
else end++;
}
} catch (e) {
if (e instanceof ParseError$1) throw e;
errorHandler.error("element parse error: " + e);
end = -1;
}
if (end > start) start = end;
else appendText(Math.max(tagStart, start) + 1);
}
}
function copyLocator(f, t) {
t.lineNumber = f.lineNumber;
t.columnNumber = f.columnNumber;
return t;
}
/**
* @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);
* @return end of the elementStartPart(end of elementEndPart for selfClosed el)
*/
function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {
/**
* @param {string} qname
* @param {string} value
* @param {number} startIndex
*/
function addAttribute(qname, value$1, startIndex) {
if (el.attributeNames.hasOwnProperty(qname)) errorHandler.fatalError("Attribute " + qname + " redefined");
el.addValue(qname, value$1.replace(/[\t\n\r]/g, " ").replace(/&#?\w+;/g, entityReplacer), startIndex);
}
var attrName;
var value;
var p$2 = ++start;
var s = S_TAG;
while (true) {
var c = source.charAt(p$2);
switch (c) {
case "=":
if (s === S_ATTR) {
attrName = source.slice(start, p$2);
s = S_EQ;
} else if (s === S_ATTR_SPACE) s = S_EQ;
else throw new Error("attribute equal must after attrName");
break;
case "'":
case "\"":
if (s === S_EQ || s === S_ATTR) {
if (s === S_ATTR) {
errorHandler.warning("attribute value must after \"=\"");
attrName = source.slice(start, p$2);
}
start = p$2 + 1;
p$2 = source.indexOf(c, start);
if (p$2 > 0) {
value = source.slice(start, p$2);
addAttribute(attrName, value, start - 1);
s = S_ATTR_END;
} else throw new Error("attribute value no end '" + c + "' match");
} else if (s == S_ATTR_NOQUOT_VALUE) {
value = source.slice(start, p$2);
addAttribute(attrName, value, start);
errorHandler.warning("attribute \"" + attrName + "\" missed start quot(" + c + ")!!");
start = p$2 + 1;
s = S_ATTR_END;
} else throw new Error("attribute value must after \"=\"");
break;
case "/":
switch (s) {
case S_TAG: el.setTagName(source.slice(start, p$2));
case S_ATTR_END:
case S_TAG_SPACE:
case S_TAG_CLOSE:
s = S_TAG_CLOSE;
el.closed = true;
case S_ATTR_NOQUOT_VALUE:
case S_ATTR: break;
case S_ATTR_SPACE:
el.closed = true;
break;
default: throw new Error("attribute invalid close char('/')");
}
break;
case "":
errorHandler.error("unexpected end of input");
if (s == S_TAG) el.setTagName(source.slice(start, p$2));
return p$2;
case ">":
switch (s) {
case S_TAG: el.setTagName(source.slice(start, p$2));
case S_ATTR_END:
case S_TAG_SPACE:
case S_TAG_CLOSE: break;
case S_ATTR_NOQUOT_VALUE:
case S_ATTR:
value = source.slice(start, p$2);
if (value.slice(-1) === "/") {
el.closed = true;
value = value.slice(0, -1);
}
case S_ATTR_SPACE:
if (s === S_ATTR_SPACE) value = attrName;
if (s == S_ATTR_NOQUOT_VALUE) {
errorHandler.warning("attribute \"" + value + "\" missed quot(\")!");
addAttribute(attrName, value, start);
} else {
if (!NAMESPACE$1.isHTML(currentNSMap[""]) || !value.match(/^(?:disabled|checked|selected)$/i)) errorHandler.warning("attribute \"" + value + "\" missed value!! \"" + value + "\" instead!!");
addAttribute(value, value, start);
}
break;
case S_EQ: throw new Error("attribute value missed!!");
}
return p$2;
case "": c = " ";
default: if (c <= " ") switch (s) {
case S_TAG:
el.setTagName(source.slice(start, p$2));
s = S_TAG_SPACE;
break;
case S_ATTR:
attrName = source.slice(start, p$2);
s = S_ATTR_SPACE;
break;
case S_ATTR_NOQUOT_VALUE:
var value = source.slice(start, p$2);
errorHandler.warning("attribute \"" + value + "\" missed quot(\")!!");
addAttribute(attrName, value, start);
case S_ATTR_END:
s = S_TAG_SPACE;
break;
}
else switch (s) {
case S_ATTR_SPACE:
var tagName = el.tagName;
if (!NAMESPACE$1.isHTML(currentNSMap[""]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) errorHandler.warning("attribute \"" + attrName + "\" missed value!! \"" + attrName + "\" instead2!!");
addAttribute(attrName, attrName, start);
start = p$2;
s = S_ATTR;
break;
case S_ATTR_END: errorHandler.warning("attribute space is required\"" + attrName + "\"!!");
case S_TAG_SPACE:
s = S_ATTR;
start = p$2;
break;
case S_EQ:
s = S_ATTR_NOQUOT_VALUE;
start = p$2;
break;
case S_TAG_CLOSE: throw new Error("elements closed character '/' and '>' must be connected to");
}
}
p$2++;
}
}
/**
* @return true if has new namespace define
*/
function appendElement$1(el, domBuilder, currentNSMap) {
var tagName = el.tagName;
var localNSMap = null;
var i$1 = el.length;
while (i$1--) {
var a = el[i$1];
var qName = a.qName;
var value = a.value;
var nsp = qName.indexOf(":");
if (nsp > 0) {
var prefix = a.prefix = qName.slice(0, nsp);
var localName = qName.slice(nsp + 1);
var nsPrefix = prefix === "xmlns" && localName;
} else {
localName = qName;
prefix = null;
nsPrefix = qName === "xmlns" && "";
}
a.localName = localName;
if (nsPrefix !== false) {
if (localNSMap == null) {
localNSMap = {};
_copy(currentNSMap, currentNSMap = {});
}
currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
a.uri = NAMESPACE$1.XMLNS;
domBuilder.startPrefixMapping(nsPrefix, value);
}
}
var i$1 = el.length;
while (i$1--) {
a = el[i$1];
var prefix = a.prefix;
if (prefix) {
if (prefix === "xml") a.uri = NAMESPACE$1.XML;
if (prefix !== "xmlns") a.uri = currentNSMap[prefix || ""];
}
}
var nsp = tagName.indexOf(":");
if (nsp > 0) {
prefix = el.prefix = tagName.slice(0, nsp);
localName = el.localName = tagName.slice(nsp + 1);
} else {
prefix = null;
localName = el.localName = tagName;
}
var ns = el.uri = currentNSMap[prefix || ""];
domBuilder.startElement(ns, localName, tagName, el);
if (el.closed) {
domBuilder.endElement(ns, localName, tagName);
if (localNSMap) {
for (prefix in localNSMap) if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) domBuilder.endPrefixMapping(prefix);
}
} else {
el.currentNSMap = currentNSMap;
el.localNSMap = localNSMap;
return true;
}
}
function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {
if (/^(?:script|textarea)$/i.test(tagName)) {
var elEndStart = source.indexOf("</" + tagName + ">", elStartEnd);
var text = source.substring(elStartEnd + 1, elEndStart);
if (/[&<]/.test(text)) {
if (/^script$/i.test(tagName)) {
domBuilder.characters(text, 0, text.length);
return elEndStart;
}
text = text.replace(/&#?\w+;/g, entityReplacer);
domBuilder.characters(text, 0, text.length);
return elEndStart;
}
}
return elStartEnd + 1;
}
function fixSelfClosed(source, elStartEnd, tagName, closeMap) {
var pos = closeMap[tagName];
if (pos == null) {
pos = source.lastIndexOf("</" + tagName + ">");
if (pos < elStartEnd) pos = source.lastIndexOf("</" + tagName);
closeMap[tagName] = pos;
}
return pos < elStartEnd;
}
function _copy(source, target) {
for (var n in source) if (Object.prototype.hasOwnProperty.call(source, n)) target[n] = source[n];
}
function parseDCC(source, start, domBuilder, errorHandler) {
var next = source.charAt(start + 2);
switch (next) {
case "-": if (source.charAt(start + 3) === "-") {
var end = source.indexOf("-->", start + 4);
if (end > start) {
domBuilder.comment(source, start + 4, end - start - 4);
return end + 3;
} else {
errorHandler.error("Unclosed comment");
return -1;
}
} else return -1;
default:
if (source.substr(start + 3, 6) == "CDATA[") {
var end = source.indexOf("]]>", start + 9);
domBuilder.startCDATA();
domBuilder.characters(source, start + 9, end - start - 9);
domBuilder.endCDATA();
return end + 3;
}
var matchs = split(source, start);
var len$1 = matchs.length;
if (len$1 > 1 && /!doctype/i.test(matchs[0][0])) {
var name = matchs[1][0];
var pubid = false;
var sysid = false;
if (len$1 > 3) {
if (/^public$/i.test(matchs[2][0])) {
pubid = matchs[3][0];
sysid = len$1 > 4 && matchs[4][0];
} else if (/^system$/i.test(matchs[2][0])) sysid = matchs[3][0];
}
var lastMatch = matchs[len$1 - 1];
domBuilder.startDTD(name, pubid, sysid);
domBuilder.endDTD();
return lastMatch.index + lastMatch[0].length;
}
}
return -1;
}
function parseInstruction(source, start, domBuilder) {
var end = source.indexOf("?>", start);
if (end) {
var match = source.substring(start, end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
if (match) {
var len$1 = match[0].length;
domBuilder.processingInstruction(match[1], match[2]);
return end + 2;
} else return -1;
}
return -1;
}
function ElementAttributes() {
this.attributeNames = {};
}
ElementAttributes.prototype = {
setTagName: function(tagName) {
if (!tagNamePattern.test(tagName)) throw new Error("invalid tagName:" + tagName);
this.tagName = tagName;
},
addValue: function(qName, value, offset) {
if (!tagNamePattern.test(qName)) throw new Error("invalid attribute:" + qName);
this.attributeNames[qName] = this.length;
this[this.length++] = {
qName,
value,
offset
};
},
length: 0,
getLocalName: function(i$1) {
return this[i$1].localName;
},
getLocator: function(i$1) {
return this[i$1].locator;
},
getQName: function(i$1) {
return this[i$1].qName;
},
getURI: function(i$1) {
return this[i$1].uri;
},
getValue: function(i$1) {
return this[i$1].value;
}
};
function split(source, start) {
var match;
var buf = [];
var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
reg.lastIndex = start;
reg.exec(source);
while (match = reg.exec(source)) {
buf.push(match);
if (match[1]) return buf;
}
}
exports.XMLReader = XMLReader$1;
exports.ParseError = ParseError$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/dom-parser.js
var require_dom_parser = __commonJS({ "../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/dom-parser.js"(exports) {
var conventions = require_conventions();
var dom$1 = require_dom();
var entities = require_entities();
var sax = require_sax();
var DOMImplementation = dom$1.DOMImplementation;
var NAMESPACE = conventions.NAMESPACE;
var ParseError = sax.ParseError;
var XMLReader = sax.XMLReader;
/**
* Normalizes line ending according to https://www.w3.org/TR/xml11/#sec-line-ends:
*
* > XML parsed entities are often stored in computer files which,
* > for editing convenience, are organized into lines.
* > These lines are typically separated by some combination
* > of the characters CARRIAGE RETURN (#xD) and LINE FEED (#xA).
* >
* > To simplify the tasks of applications, the XML processor must behave
* > as if it normalized all line breaks in external parsed entities (including the document entity)
* > on input, before parsing, by translating all of the following to a single #xA character:
* >
* > 1. the two-character sequence #xD #xA
* > 2. the two-character sequence #xD #x85
* > 3. the single character #x85
* > 4. the single character #x2028
* > 5. any #xD character that is not immediately followed by #xA or #x85.
*
* @param {string} input
* @returns {string}
*/
function normalizeLineEndings(input) {
return input.replace(/\r[\n\u0085]/g, "\n").replace(/[\r\u0085\u2028]/g, "\n");
}
/**
* @typedef Locator
* @property {number} [columnNumber]
* @property {number} [lineNumber]
*/
/**
* @typedef DOMParserOptions
* @property {DOMHandler} [domBuilder]
* @property {Function} [errorHandler]
* @property {(string) => string} [normalizeLineEndings] used to replace line endings before parsing
* defaults to `normalizeLineEndings`
* @property {Locator} [locator]
* @property {Record<string, string>} [xmlns]
*
* @see normalizeLineEndings
*/
/**
* The DOMParser interface provides the ability to parse XML or HTML source code
* from a string into a DOM `Document`.
*
* _xmldom is different from the spec in that it allows an `options` parameter,
* to override the default behavior._
*
* @param {DOMParserOptions} [options]
* @constructor
*
* @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
* @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-parsing-and-serialization
*/
function DOMParser$1(options) {
this.options = options || { locator: {} };
}
DOMParser$1.prototype.parseFromString = function(source, mimeType) {
var options = this.options;
var sax$1 = new XMLReader();
var domBuilder = options.domBuilder || new DOMHandler();
var errorHandler = options.errorHandler;
var locator = options.locator;
var defaultNSMap = options.xmlns || {};
var isHTML = /\/x?html?$/.test(mimeType);
var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;
if (locator) domBuilder.setDocumentLocator(locator);
sax$1.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
sax$1.domBuilder = options.domBuilder || domBuilder;
if (isHTML) defaultNSMap[""] = NAMESPACE.HTML;
defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
var normalize = options.normalizeLineEndings || normalizeLineEndings;
if (source && typeof source === "string") sax$1.parse(normalize(source), defaultNSMap, entityMap);
else sax$1.errorHandler.error("invalid doc source");
return domBuilder.doc;
};
function buildErrorHandler(errorImpl, domBuilder, locator) {
if (!errorImpl) {
if (domBuilder instanceof DOMHandler) return domBuilder;
errorImpl = domBuilder;
}
var errorHandler = {};
var isCallback = errorImpl instanceof Function;
locator = locator || {};
function build$1(key) {
var fn = errorImpl[key];
if (!fn && isCallback) fn = errorImpl.length == 2 ? function(msg) {
errorImpl(key, msg);
} : errorImpl;
errorHandler[key] = fn && function(msg) {
fn("[xmldom " + key + "] " + msg + _locator(locator));
} || function() {};
}
build$1("warning");
build$1("error");
build$1("fatalError");
return errorHandler;
}
/**
* +ContentHandler+ErrorHandler
* +LexicalHandler+EntityResolver2
* -DeclHandler-DTDHandler
*
* DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler
* DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2
* @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html
*/
function DOMHandler() {
this.cdata = false;
}
function position(locator, node) {
node.lineNumber = locator.lineNumber;
node.columnNumber = locator.columnNumber;
}
/**
* @see org.xml.sax.ContentHandler#startDocument
* @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html
*/
DOMHandler.prototype = {
startDocument: function() {
this.doc = new DOMImplementation().createDocument(null, null, null);
if (this.locator) this.doc.documentURI = this.locator.systemId;
},
startElement: function(namespaceURI, localName, qName, attrs) {
var doc = this.doc;
var el = doc.createElementNS(namespaceURI, qName || localName);
var len$1 = attrs.length;
appendElement(this, el);
this.currentElement = el;
this.locator && position(this.locator, el);
for (var i$1 = 0; i$1 < len$1; i$1++) {
var namespaceURI = attrs.getURI(i$1);
var value = attrs.getValue(i$1);
var qName = attrs.getQName(i$1);
var attr = doc.createAttributeNS(namespaceURI, qName);
this.locator && position(attrs.getLocator(i$1), attr);
attr.value = attr.nodeValue = value;
el.setAttributeNode(attr);
}
},
endElement: function(namespaceURI, localName, qName) {
var current = this.currentElement;
var tagName = current.tagName;
this.currentElement = current.parentNode;
},
startPrefixMapping: function(prefix, uri) {},
endPrefixMapping: function(prefix) {},
processingInstruction: function(target, data) {
var ins = this.doc.createProcessingInstruction(target, data);
this.locator && position(this.locator, ins);
appendElement(this, ins);
},
ignorableWhitespace: function(ch, start, length) {},
characters: function(chars$1, start, length) {
chars$1 = _toString.apply(this, arguments);
if (chars$1) {
if (this.cdata) var charNode = this.doc.createCDATASection(chars$1);
else var charNode = this.doc.createTextNode(chars$1);
if (this.currentElement) this.currentElement.appendChild(charNode);
else if (/^\s*$/.test(chars$1)) this.doc.appendChild(charNode);
this.locator && position(this.locator, charNode);
}
},
skippedEntity: function(name) {},
endDocument: function() {
this.doc.normalize();
},
setDocumentLocator: function(locator) {
if (this.locator = locator) locator.lineNumber = 0;
},
comment: function(chars$1, start, length) {
chars$1 = _toString.apply(this, arguments);
var comm = this.doc.createComment(chars$1);
this.locator && position(this.locator, comm);
appendElement(this, comm);
},
startCDATA: function() {
this.cdata = true;
},
endCDATA: function() {
this.cdata = false;
},
startDTD: function(name, publicId, systemId) {
var impl = this.doc.implementation;
if (impl && impl.createDocumentType) {
var dt = impl.createDocumentType(name, publicId, systemId);
this.locator && position(this.locator, dt);
appendElement(this, dt);
this.doc.doctype = dt;
}
},
warning: function(error) {
console.warn("[xmldom warning] " + error, _locator(this.locator));
},
error: function(error) {
console.error("[xmldom error] " + error, _locator(this.locator));
},
fatalError: function(error) {
throw new ParseError(error, this.locator);
}
};
function _locator(l) {
if (l) return "\n@" + (l.systemId || "") + "#[line:" + l.lineNumber + ",col:" + l.columnNumber + "]";
}
function _toString(chars$1, start, length) {
if (typeof chars$1 == "string") return chars$1.substr(start, length);
else {
if (chars$1.length >= start + length || start) return new java.lang.String(chars$1, start, length) + "";
return chars$1;
}
}
"endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(key) {
DOMHandler.prototype[key] = function() {
return null;
};
});
function appendElement(hander, node) {
if (!hander.currentElement) hander.doc.appendChild(node);
else hander.currentElement.appendChild(node);
}
exports.__DOMHandler = DOMHandler;
exports.normalizeLineEndings = normalizeLineEndings;
exports.DOMParser = DOMParser$1;
} });
//#endregion
//#region ../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/index.js
var require_lib$1 = __commonJS({ "../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/index.js"(exports) {
var dom = require_dom();
exports.DOMImplementation = dom.DOMImplementation;
exports.XMLSerializer = dom.XMLSerializer;
exports.DOMParser = require_dom_parser().DOMParser;
} });
//#endregion
//#region ../../node_modules/.pnpm/plist@3.1.0/node_modules/plist/lib/parse.js
var require_parse = __commonJS({ "../../node_modules/.pnpm/plist@3.1.0/node_modules/plist/lib/parse.js"(exports) {
/**
* Module dependencies.
*/
const { DOMParser } = require_lib$1();
/**
* Module exports.
*/
exports.parse = parse;
var TEXT_NODE = 3;
var CDATA_NODE = 4;
var COMMENT_NODE = 8;
/**
* We ignore raw text (usually whitespace), <!-- xml comments -->,
* and raw CDATA nodes.
*
* @param {Element} node
* @returns {Boolean}
* @api private
*/
function shouldIgnoreNode(node) {
return node.nodeType === TEXT_NODE || node.nodeType === COMMENT_NODE || node.nodeType === CDATA_NODE;
}
/**
* Check if the node is empty. Some plist file has such node:
* <key />
* this node shoud be ignored.
*
* @see https://github.com/TooTallNate/plist.js/issues/66
* @param {Element} node
* @returns {Boolean}
* @api private
*/
function isEmptyNode(node) {
if (!node.childNodes || node.childNodes.length === 0) return true;
else return false;
}
function invariant(test, message) {
if (!test) throw new Error(message);
}
/**
* Parses a Plist XML string. Returns an Object.
*
* @param {String} xml - the XML String to decode
* @returns {Mixed} the decoded value from the Plist XML
* @api public
*/
function parse(xml) {
var doc = new DOMParser().parseFromString(xml);
invariant(doc.documentElement.nodeName === "plist", "malformed document. First element should be <plist>");
var plist$1 = parsePlistXML(doc.documentElement);
if (plist$1.length == 1) plist$1 = plist$1[0];
return plist$1;
}
/**
* Convert an XML based plist document into a JSON representation.
*
* @param {Object} xml_node - current XML node in the plist
* @returns {Mixed} built up JSON object
* @api private
*/
function parsePlistXML(node) {
var i$1, new_obj, key, val, new_arr, res, counter, type$1;
if (!node) return null;
if (node.nodeName === "plist") {
new_arr = [];
if (isEmptyNode(node)) return new_arr;
for (i$1 = 0; i$1 < node.childNodes.length; i$1++) if (!shouldIgnoreNode(node.childNodes[i$1])) new_arr.push(parsePlistXML(node.childNodes[i$1]));
return new_arr;
} else if (node.nodeName === "dict") {
new_obj = {};
key = null;
counter = 0;
if (isEmptyNode(node)) return new_obj;
for (i$1 = 0; i$1 < node.childNodes.length; i$1++) {
if (shouldIgnoreNode(node.childNodes[i$1])) continue;
if (counter % 2 === 0) {
invariant(node.childNodes[i$1].nodeName === "key", "Missing key while parsing <dict/>.");
key = parsePlistXML(node.childNodes[i$1]);
} else {
invariant(node.childNodes[i$1].nodeName !== "key", "Unexpected key \"" + parsePlistXML(node.childNodes[i$1]) + "\" while parsing <dict/>.");
new_obj[key] = parsePlistXML(node.childNodes[i$1]);
}
counter += 1;
}
if (counter % 2 === 1) new_obj[key] = "";
return new_obj;
} else if (node.nodeName === "array") {
new_arr = [];
if (isEmptyNode(node)) return new_arr;
for (i$1 = 0; i$1 < node.childNodes.length; i$1++) if (!shouldIgnoreNode(node.childNodes[i$1])) {
res = parsePlistXML(node.childNodes[i$1]);
if (null != res) new_arr.push(res);
}
return new_arr;
} else if (node.nodeName === "#text") {} else if (node.nodeName === "key") {
if (isEmptyNode(node)) return "";
invariant(node.childNodes[0].nodeValue !== "__proto__", "__proto__ keys can lead to prototype pollution. More details on CVE-2022-22912");
return node.childNodes[0].nodeValue;
} else if (node.nodeName === "string") {
res = "";
if (isEmptyNode(node)) return res;
for (i$1 = 0; i$1 < node.childNodes.length; i$1++) {
var type$1 = node.childNodes[i$1].nodeType;
if (type$1 === TEXT_NODE || type$1 === CDATA_NODE) res += node.childNodes[i$1].nodeValue;
}
return res;
} else if (node.nodeName === "integer") {
invariant(!isEmptyNode(node), "Cannot parse \"\" as integer.");
return parseInt(node.childNodes[0].nodeValue, 10);
} else if (node.nodeName === "real") {
invariant(!isEmptyNode(node), "Cannot parse \"\" as real.");
res = "";
for (i$1 = 0; i$1 < node.childNodes.length; i$1++) if (node.childNodes[i$1].nodeType === TEXT_NODE) res += node.childNodes[i$1].nodeValue;
return parseFloat(res);
} else if (node.nodeName === "data") {
res = "";
if (isEmptyNode(node)) return Buffer.from(res, "base64");
for (i$1 = 0; i$1 < node.childNodes.length; i$1++) if (node.childNodes[i$1].nodeType === TEXT_NODE) res += node.childNodes[i$1].nodeValue.replace(/\s+/g, "");
return Buffer.from(res, "base64");
} else if (node.nodeName === "date") {
invariant(!isEmptyNode(node), "Cannot parse \"\" as Date.");
return new Date(node.childNodes[0].nodeValue);
} else if (node.nodeName === "null") return null;
else if (node.nodeName === "true") return true;
else if (node.nodeName === "false") return false;
else throw new Error("Invalid PLIST tag " + node.nodeName);
}
} });
//#endregion
//#region ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
var require_base64_js = __commonJS({ "../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) {
exports.byteLength = byteLength;
exports.toByteArray = toByteArray;
exports.fromByteArray = fromByteArray;
var lookup = [];
var revLookup = [];
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
for (var i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i];
revLookup[code.charCodeAt(i)] = i;
}
revLookup["-".charCodeAt(0)] = 62;
revLookup["_".charCodeAt(0)] = 63;
function getLens(b64) {
var len$1 = b64.length;
if (len$1 % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
var validLen = b64.indexOf("=");
if (validLen === -1) validLen = len$1;
var placeHoldersLen = validLen === len$1 ? 0 : 4 - validLen % 4;
return [validLen, placeHoldersLen];
}
function byteLength(b64) {
var lens = getLens(b64);
var validLen = lens[0];
var placeHoldersLen = lens[1];
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function _byteLength(b64, validLen, placeHoldersLen) {
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function toByteArray(b64) {
var tmp;
var lens = getLens(b64);
var validLen = lens[0];
var placeHoldersLen = lens[1];
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
var curByte = 0;
var len$1 = placeHoldersLen > 0 ? validLen - 4 : validLen;
var i$1;
for (i$1 = 0; i$1 < len$1; i$1 += 4) {
tmp = revLookup[b64.charCodeAt(i$1)] << 18 | revLookup[b64.charCodeAt(i$1 + 1)] << 12 | revLookup[b64.charCodeAt(i$1 + 2)] << 6 | revLookup[b64.charCodeAt(i$1 + 3)];
arr[curByte++] = tmp >> 16 & 255;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 2) {
tmp = revLookup[b64.charCodeAt(i$1)] << 2 | revLookup[b64.charCodeAt(i$1 + 1)] >> 4;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 1) {
tmp = revLookup[b64.charCodeAt(i$1)] << 10 | revLookup[b64.charCodeAt(i$1 + 1)] << 4 | revLookup[b64.charCodeAt(i$1 + 2)] >> 2;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
return arr;
}
function tripletToBase64(num) {
return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
}
function encodeChunk(uint8, start, end) {
var tmp;
var output = [];
for (var i$1 = start; i$1 < end; i$1 += 3) {
tmp = (uint8[i$1] << 16 & 16711680) + (uint8[i$1 + 1] << 8 & 65280) + (uint8[i$1 + 2] & 255);
output.push(tripletToBase64(tmp));
}
return output.join("");
}
function fromByteArray(uint8) {
var tmp;
var len$1 = uint8.length;
var extraBytes = len$1 % 3;
var parts = [];
var maxChunkLength = 16383;
for (var i$1 = 0, len2 = len$1 - extraBytes; i$1 < len2; i$1 += maxChunkLength) parts.push(encodeChunk(uint8, i$1, i$1 + maxChunkLength > len2 ? len2 : i$1 + maxChunkLength));
if (extraBytes === 1) {
tmp = uint8[len$1 - 1];
parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
} else if (extraBytes === 2) {
tmp = (uint8[len$1 - 2] << 8) + uint8[len$1 - 1];
parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
}
return parts.join("");
}
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/Utility.js
var require_Utility = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/Utility.js"(exports, module) {
(function() {
var assign$1, getValue, isArray, isEmpty$1, isFunction, isObject$2, isPlainObject, hasProp = {}.hasOwnProperty;
assign$1 = function(target, ...sources) {
var i$1, key, len$1, source;
if (isFunction(Object.assign)) Object.assign.apply(null, arguments);
else for (i$1 = 0, len$1 = sources.length; i$1 < len$1; i$1++) {
source = sources[i$1];
if (source != null) for (key in source) {
if (!hasProp.call(source, key)) continue;
target[key] = source[key];
}
}
return target;
};
isFunction = function(val) {
return !!val && Object.prototype.toString.call(val) === "[object Function]";
};
isObject$2 = function(val) {
var ref;
return !!val && ((ref = typeof val) === "function" || ref === "object");
};
isArray = function(val) {
if (isFunction(Array.isArray)) return Array.isArray(val);
else return Object.prototype.toString.call(val) === "[object Array]";
};
isEmpty$1 = function(val) {
var key;
if (isArray(val)) return !val.length;
else {
for (key in val) {
if (!hasProp.call(val, key)) continue;
return false;
}
return true;
}
};
isPlainObject = function(val) {
var ctor, proto;
return isObject$2(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
};
getValue = function(obj) {
if (isFunction(obj.valueOf)) return obj.valueOf();
else return obj;
};
module.exports.assign = assign$1;
module.exports.isFunction = isFunction;
module.exports.isObject = isObject$2;
module.exports.isArray = isArray;
module.exports.isEmpty = isEmpty$1;
module.exports.isPlainObject = isPlainObject;
module.exports.getValue = getValue;
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDOMImplementation.js
var require_XMLDOMImplementation = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDOMImplementation.js"(exports, module) {
(function() {
var XMLDOMImplementation;
module.exports = XMLDOMImplementation = class XMLDOMImplementation$1 {
hasFeature(feature, version) {
return true;
}
createDocumentType(qualifiedName, publicId, systemId) {
throw new Error("This DOM method is not implemented.");
}
createDocument(namespaceURI, qualifiedName, doctype) {
throw new Error("This DOM method is not implemented.");
}
createHTMLDocument(title) {
throw new Error("This DOM method is not implemented.");
}
getFeature(feature, version) {
throw new Error("This DOM method is not implemented.");
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDOMErrorHandler.js
var require_XMLDOMErrorHandler = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDOMErrorHandler.js"(exports, module) {
(function() {
var XMLDOMErrorHandler;
module.exports = XMLDOMErrorHandler = class XMLDOMErrorHandler$1 {
constructor() {}
handleError(error) {
throw new Error(error);
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDOMStringList.js
var require_XMLDOMStringList = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDOMStringList.js"(exports, module) {
(function() {
var XMLDOMStringList;
module.exports = XMLDOMStringList = function() {
class XMLDOMStringList$1 {
constructor(arr) {
this.arr = arr || [];
}
item(index) {
return this.arr[index] || null;
}
contains(str) {
return this.arr.indexOf(str) !== -1;
}
}
Object.defineProperty(XMLDOMStringList$1.prototype, "length", { get: function() {
return this.arr.length;
} });
return XMLDOMStringList$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDOMConfiguration.js
var require_XMLDOMConfiguration = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDOMConfiguration.js"(exports, module) {
(function() {
var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList;
XMLDOMErrorHandler = require_XMLDOMErrorHandler();
XMLDOMStringList = require_XMLDOMStringList();
module.exports = XMLDOMConfiguration = function() {
class XMLDOMConfiguration$1 {
constructor() {
var clonedSelf;
this.defaultParams = {
"canonical-form": false,
"cdata-sections": false,
"comments": false,
"datatype-normalization": false,
"element-content-whitespace": true,
"entities": true,
"error-handler": new XMLDOMErrorHandler(),
"infoset": true,
"validate-if-schema": false,
"namespaces": true,
"namespace-declarations": true,
"normalize-characters": false,
"schema-location": "",
"schema-type": "",
"split-cdata-sections": true,
"validate": false,
"well-formed": true
};
this.params = clonedSelf = Object.create(this.defaultParams);
}
getParameter(name) {
if (this.params.hasOwnProperty(name)) return this.params[name];
else return null;
}
canSetParameter(name, value) {
return true;
}
setParameter(name, value) {
if (value != null) return this.params[name] = value;
else return delete this.params[name];
}
}
Object.defineProperty(XMLDOMConfiguration$1.prototype, "parameterNames", { get: function() {
return new XMLDOMStringList(Object.keys(this.defaultParams));
} });
return XMLDOMConfiguration$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/NodeType.js
var require_NodeType = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/NodeType.js"(exports, module) {
(function() {
module.exports = {
Element: 1,
Attribute: 2,
Text: 3,
CData: 4,
EntityReference: 5,
EntityDeclaration: 6,
ProcessingInstruction: 7,
Comment: 8,
Document: 9,
DocType: 10,
DocumentFragment: 11,
NotationDeclaration: 12,
Declaration: 201,
Raw: 202,
AttributeDeclaration: 203,
ElementDeclaration: 204,
Dummy: 205
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLAttribute.js
var require_XMLAttribute = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLAttribute.js"(exports, module) {
(function() {
var NodeType$1, XMLAttribute, XMLNode;
NodeType$1 = require_NodeType();
XMLNode = require_XMLNode();
module.exports = XMLAttribute = function() {
class XMLAttribute$1 {
constructor(parent, name, value) {
this.parent = parent;
if (this.parent) {
this.options = this.parent.options;
this.stringify = this.parent.stringify;
}
if (name == null) throw new Error("Missing attribute name. " + this.debugInfo(name));
this.name = this.stringify.name(name);
this.value = this.stringify.attValue(value);
this.type = NodeType$1.Attribute;
this.isId = false;
this.schemaTypeInfo = null;
}
clone() {
return Object.create(this);
}
toString(options) {
return this.options.writer.attribute(this, this.options.writer.filterOptions(options));
}
debugInfo(name) {
name = name || this.name;
if (name == null) return "parent: <" + this.parent.name + ">";
else return "attribute: {" + name + "}, parent: <" + this.parent.name + ">";
}
isEqualNode(node) {
if (node.namespaceURI !== this.namespaceURI) return false;
if (node.prefix !== this.prefix) return false;
if (node.localName !== this.localName) return false;
if (node.value !== this.value) return false;
return true;
}
}
Object.defineProperty(XMLAttribute$1.prototype, "nodeType", { get: function() {
return this.type;
} });
Object.defineProperty(XMLAttribute$1.prototype, "ownerElement", { get: function() {
return this.parent;
} });
Object.defineProperty(XMLAttribute$1.prototype, "textContent", {
get: function() {
return this.value;
},
set: function(value) {
return this.value = value || "";
}
});
Object.defineProperty(XMLAttribute$1.prototype, "namespaceURI", { get: function() {
return "";
} });
Object.defineProperty(XMLAttribute$1.prototype, "prefix", { get: function() {
return "";
} });
Object.defineProperty(XMLAttribute$1.prototype, "localName", { get: function() {
return this.name;
} });
Object.defineProperty(XMLAttribute$1.prototype, "specified", { get: function() {
return true;
} });
return XMLAttribute$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLNamedNodeMap.js
var require_XMLNamedNodeMap = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLNamedNodeMap.js"(exports, module) {
(function() {
var XMLNamedNodeMap;
module.exports = XMLNamedNodeMap = function() {
class XMLNamedNodeMap$1 {
constructor(nodes) {
this.nodes = nodes;
}
clone() {
return this.nodes = null;
}
getNamedItem(name) {
return this.nodes[name];
}
setNamedItem(node) {
var oldNode;
oldNode = this.nodes[node.nodeName];
this.nodes[node.nodeName] = node;
return oldNode || null;
}
removeNamedItem(name) {
var oldNode;
oldNode = this.nodes[name];
delete this.nodes[name];
return oldNode || null;
}
item(index) {
return this.nodes[Object.keys(this.nodes)[index]] || null;
}
getNamedItemNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented.");
}
setNamedItemNS(node) {
throw new Error("This DOM method is not implemented.");
}
removeNamedItemNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented.");
}
}
Object.defineProperty(XMLNamedNodeMap$1.prototype, "length", { get: function() {
return Object.keys(this.nodes).length || 0;
} });
return XMLNamedNodeMap$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLElement.js
var require_XMLElement = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLElement.js"(exports, module) {
(function() {
var NodeType$1, XMLAttribute, XMLElement, XMLNamedNodeMap, XMLNode, getValue, isFunction, isObject$2, hasProp = {}.hasOwnProperty;
({isObject: isObject$2, isFunction, getValue} = require_Utility());
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
XMLAttribute = require_XMLAttribute();
XMLNamedNodeMap = require_XMLNamedNodeMap();
module.exports = XMLElement = function() {
class XMLElement$1 extends XMLNode {
constructor(parent, name, attributes) {
var child, j, len$1, ref;
super(parent);
if (name == null) throw new Error("Missing element name. " + this.debugInfo());
this.name = this.stringify.name(name);
this.type = NodeType$1.Element;
this.attribs = {};
this.schemaTypeInfo = null;
if (attributes != null) this.attribute(attributes);
if (parent.type === NodeType$1.Document) {
this.isRoot = true;
this.documentObject = parent;
parent.rootObject = this;
if (parent.children) {
ref = parent.children;
for (j = 0, len$1 = ref.length; j < len$1; j++) {
child = ref[j];
if (child.type === NodeType$1.DocType) {
child.name = this.name;
break;
}
}
}
}
}
clone() {
var att, attName, clonedSelf, ref;
clonedSelf = Object.create(this);
if (clonedSelf.isRoot) clonedSelf.documentObject = null;
clonedSelf.attribs = {};
ref = this.attribs;
for (attName in ref) {
if (!hasProp.call(ref, attName)) continue;
att = ref[attName];
clonedSelf.attribs[attName] = att.clone();
}
clonedSelf.children = [];
this.children.forEach(function(child) {
var clonedChild;
clonedChild = child.clone();
clonedChild.parent = clonedSelf;
return clonedSelf.children.push(clonedChild);
});
return clonedSelf;
}
attribute(name, value) {
var attName, attValue;
if (name != null) name = getValue(name);
if (isObject$2(name)) for (attName in name) {
if (!hasProp.call(name, attName)) continue;
attValue = name[attName];
this.attribute(attName, attValue);
}
else {
if (isFunction(value)) value = value.apply();
if (this.options.keepNullAttributes && value == null) this.attribs[name] = new XMLAttribute(this, name, "");
else if (value != null) this.attribs[name] = new XMLAttribute(this, name, value);
}
return this;
}
removeAttribute(name) {
var attName, j, len$1;
if (name == null) throw new Error("Missing attribute name. " + this.debugInfo());
name = getValue(name);
if (Array.isArray(name)) for (j = 0, len$1 = name.length; j < len$1; j++) {
attName = name[j];
delete this.attribs[attName];
}
else delete this.attribs[name];
return this;
}
toString(options) {
return this.options.writer.element(this, this.options.writer.filterOptions(options));
}
att(name, value) {
return this.attribute(name, value);
}
a(name, value) {
return this.attribute(name, value);
}
getAttribute(name) {
if (this.attribs.hasOwnProperty(name)) return this.attribs[name].value;
else return null;
}
setAttribute(name, value) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getAttributeNode(name) {
if (this.attribs.hasOwnProperty(name)) return this.attribs[name];
else return null;
}
setAttributeNode(newAttr) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
removeAttributeNode(oldAttr) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementsByTagName(name) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getAttributeNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
setAttributeNS(namespaceURI, qualifiedName, value) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
removeAttributeNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getAttributeNodeNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
setAttributeNodeNS(newAttr) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementsByTagNameNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
hasAttribute(name) {
return this.attribs.hasOwnProperty(name);
}
hasAttributeNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
setIdAttribute(name, isId) {
if (this.attribs.hasOwnProperty(name)) return this.attribs[name].isId;
else return isId;
}
setIdAttributeNS(namespaceURI, localName, isId) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
setIdAttributeNode(idAttr, isId) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementsByTagName(tagname) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementsByTagNameNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementsByClassName(classNames) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
isEqualNode(node) {
var i$1, j, ref;
if (!super.isEqualNode(node)) return false;
if (node.namespaceURI !== this.namespaceURI) return false;
if (node.prefix !== this.prefix) return false;
if (node.localName !== this.localName) return false;
if (node.attribs.length !== this.attribs.length) return false;
for (i$1 = j = 0, ref = this.attribs.length - 1; 0 <= ref ? j <= ref : j >= ref; i$1 = 0 <= ref ? ++j : --j) if (!this.attribs[i$1].isEqualNode(node.attribs[i$1])) return false;
return true;
}
}
Object.defineProperty(XMLElement$1.prototype, "tagName", { get: function() {
return this.name;
} });
Object.defineProperty(XMLElement$1.prototype, "namespaceURI", { get: function() {
return "";
} });
Object.defineProperty(XMLElement$1.prototype, "prefix", { get: function() {
return "";
} });
Object.defineProperty(XMLElement$1.prototype, "localName", { get: function() {
return this.name;
} });
Object.defineProperty(XMLElement$1.prototype, "id", { get: function() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
} });
Object.defineProperty(XMLElement$1.prototype, "className", { get: function() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
} });
Object.defineProperty(XMLElement$1.prototype, "classList", { get: function() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
} });
Object.defineProperty(XMLElement$1.prototype, "attributes", { get: function() {
if (!this.attributeMap || !this.attributeMap.nodes) this.attributeMap = new XMLNamedNodeMap(this.attribs);
return this.attributeMap;
} });
return XMLElement$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLCharacterData.js
var require_XMLCharacterData = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLCharacterData.js"(exports, module) {
(function() {
var XMLCharacterData, XMLNode;
XMLNode = require_XMLNode();
module.exports = XMLCharacterData = function() {
class XMLCharacterData$1 extends XMLNode {
constructor(parent) {
super(parent);
this.value = "";
}
clone() {
return Object.create(this);
}
substringData(offset, count) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
appendData(arg) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
insertData(offset, arg) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
deleteData(offset, count) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
replaceData(offset, count, arg) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
isEqualNode(node) {
if (!super.isEqualNode(node)) return false;
if (node.data !== this.data) return false;
return true;
}
}
Object.defineProperty(XMLCharacterData$1.prototype, "data", {
get: function() {
return this.value;
},
set: function(value) {
return this.value = value || "";
}
});
Object.defineProperty(XMLCharacterData$1.prototype, "length", { get: function() {
return this.value.length;
} });
Object.defineProperty(XMLCharacterData$1.prototype, "textContent", {
get: function() {
return this.value;
},
set: function(value) {
return this.value = value || "";
}
});
return XMLCharacterData$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLCData.js
var require_XMLCData = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLCData.js"(exports, module) {
(function() {
var NodeType$1, XMLCData, XMLCharacterData;
NodeType$1 = require_NodeType();
XMLCharacterData = require_XMLCharacterData();
module.exports = XMLCData = class XMLCData$1 extends XMLCharacterData {
constructor(parent, text) {
super(parent);
if (text == null) throw new Error("Missing CDATA text. " + this.debugInfo());
this.name = "#cdata-section";
this.type = NodeType$1.CData;
this.value = this.stringify.cdata(text);
}
clone() {
return Object.create(this);
}
toString(options) {
return this.options.writer.cdata(this, this.options.writer.filterOptions(options));
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLComment.js
var require_XMLComment = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLComment.js"(exports, module) {
(function() {
var NodeType$1, XMLCharacterData, XMLComment;
NodeType$1 = require_NodeType();
XMLCharacterData = require_XMLCharacterData();
module.exports = XMLComment = class XMLComment$1 extends XMLCharacterData {
constructor(parent, text) {
super(parent);
if (text == null) throw new Error("Missing comment text. " + this.debugInfo());
this.name = "#comment";
this.type = NodeType$1.Comment;
this.value = this.stringify.comment(text);
}
clone() {
return Object.create(this);
}
toString(options) {
return this.options.writer.comment(this, this.options.writer.filterOptions(options));
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDeclaration.js
var require_XMLDeclaration = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDeclaration.js"(exports, module) {
(function() {
var NodeType$1, XMLDeclaration, XMLNode, isObject$2;
({isObject: isObject$2} = require_Utility());
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
module.exports = XMLDeclaration = class XMLDeclaration$1 extends XMLNode {
constructor(parent, version, encoding, standalone) {
super(parent);
if (isObject$2(version)) ({version, encoding, standalone} = version);
if (!version) version = "1.0";
this.type = NodeType$1.Declaration;
this.version = this.stringify.xmlVersion(version);
if (encoding != null) this.encoding = this.stringify.xmlEncoding(encoding);
if (standalone != null) this.standalone = this.stringify.xmlStandalone(standalone);
}
toString(options) {
return this.options.writer.declaration(this, this.options.writer.filterOptions(options));
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDTDAttList.js
var require_XMLDTDAttList = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDTDAttList.js"(exports, module) {
(function() {
var NodeType$1, XMLDTDAttList, XMLNode;
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
module.exports = XMLDTDAttList = class XMLDTDAttList$1 extends XMLNode {
constructor(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
super(parent);
if (elementName == null) throw new Error("Missing DTD element name. " + this.debugInfo());
if (attributeName == null) throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName));
if (!attributeType) throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName));
if (!defaultValueType) throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName));
if (defaultValueType.indexOf("#") !== 0) defaultValueType = "#" + defaultValueType;
if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. " + this.debugInfo(elementName));
if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName));
this.elementName = this.stringify.name(elementName);
this.type = NodeType$1.AttributeDeclaration;
this.attributeName = this.stringify.name(attributeName);
this.attributeType = this.stringify.dtdAttType(attributeType);
if (defaultValue) this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
this.defaultValueType = defaultValueType;
}
toString(options) {
return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDTDEntity.js
var require_XMLDTDEntity = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDTDEntity.js"(exports, module) {
(function() {
var NodeType$1, XMLDTDEntity, XMLNode, isObject$2;
({isObject: isObject$2} = require_Utility());
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
module.exports = XMLDTDEntity = function() {
class XMLDTDEntity$1 extends XMLNode {
constructor(parent, pe, name, value) {
super(parent);
if (name == null) throw new Error("Missing DTD entity name. " + this.debugInfo(name));
if (value == null) throw new Error("Missing DTD entity value. " + this.debugInfo(name));
this.pe = !!pe;
this.name = this.stringify.name(name);
this.type = NodeType$1.EntityDeclaration;
if (!isObject$2(value)) {
this.value = this.stringify.dtdEntityValue(value);
this.internal = true;
} else {
if (!value.pubID && !value.sysID) throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name));
if (value.pubID && !value.sysID) throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name));
this.internal = false;
if (value.pubID != null) this.pubID = this.stringify.dtdPubID(value.pubID);
if (value.sysID != null) this.sysID = this.stringify.dtdSysID(value.sysID);
if (value.nData != null) this.nData = this.stringify.dtdNData(value.nData);
if (this.pe && this.nData) throw new Error("Notation declaration is not allowed in a parameter entity. " + this.debugInfo(name));
}
}
toString(options) {
return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));
}
}
Object.defineProperty(XMLDTDEntity$1.prototype, "publicId", { get: function() {
return this.pubID;
} });
Object.defineProperty(XMLDTDEntity$1.prototype, "systemId", { get: function() {
return this.sysID;
} });
Object.defineProperty(XMLDTDEntity$1.prototype, "notationName", { get: function() {
return this.nData || null;
} });
Object.defineProperty(XMLDTDEntity$1.prototype, "inputEncoding", { get: function() {
return null;
} });
Object.defineProperty(XMLDTDEntity$1.prototype, "xmlEncoding", { get: function() {
return null;
} });
Object.defineProperty(XMLDTDEntity$1.prototype, "xmlVersion", { get: function() {
return null;
} });
return XMLDTDEntity$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDTDElement.js
var require_XMLDTDElement = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDTDElement.js"(exports, module) {
(function() {
var NodeType$1, XMLDTDElement, XMLNode;
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
module.exports = XMLDTDElement = class XMLDTDElement$1 extends XMLNode {
constructor(parent, name, value) {
super(parent);
if (name == null) throw new Error("Missing DTD element name. " + this.debugInfo());
if (!value) value = "(#PCDATA)";
if (Array.isArray(value)) value = "(" + value.join(",") + ")";
this.name = this.stringify.name(name);
this.type = NodeType$1.ElementDeclaration;
this.value = this.stringify.dtdElementValue(value);
}
toString(options) {
return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDTDNotation.js
var require_XMLDTDNotation = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDTDNotation.js"(exports, module) {
(function() {
var NodeType$1, XMLDTDNotation, XMLNode;
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
module.exports = XMLDTDNotation = function() {
class XMLDTDNotation$1 extends XMLNode {
constructor(parent, name, value) {
super(parent);
if (name == null) throw new Error("Missing DTD notation name. " + this.debugInfo(name));
if (!value.pubID && !value.sysID) throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name));
this.name = this.stringify.name(name);
this.type = NodeType$1.NotationDeclaration;
if (value.pubID != null) this.pubID = this.stringify.dtdPubID(value.pubID);
if (value.sysID != null) this.sysID = this.stringify.dtdSysID(value.sysID);
}
toString(options) {
return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
}
}
Object.defineProperty(XMLDTDNotation$1.prototype, "publicId", { get: function() {
return this.pubID;
} });
Object.defineProperty(XMLDTDNotation$1.prototype, "systemId", { get: function() {
return this.sysID;
} });
return XMLDTDNotation$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDocType.js
var require_XMLDocType = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDocType.js"(exports, module) {
(function() {
var NodeType$1, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject$2;
({isObject: isObject$2} = require_Utility());
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
XMLDTDAttList = require_XMLDTDAttList();
XMLDTDEntity = require_XMLDTDEntity();
XMLDTDElement = require_XMLDTDElement();
XMLDTDNotation = require_XMLDTDNotation();
XMLNamedNodeMap = require_XMLNamedNodeMap();
module.exports = XMLDocType = function() {
class XMLDocType$1 extends XMLNode {
constructor(parent, pubID, sysID) {
var child, i$1, len$1, ref;
super(parent);
this.type = NodeType$1.DocType;
if (parent.children) {
ref = parent.children;
for (i$1 = 0, len$1 = ref.length; i$1 < len$1; i$1++) {
child = ref[i$1];
if (child.type === NodeType$1.Element) {
this.name = child.name;
break;
}
}
}
this.documentObject = parent;
if (isObject$2(pubID)) ({pubID, sysID} = pubID);
if (sysID == null) [sysID, pubID] = [pubID, sysID];
if (pubID != null) this.pubID = this.stringify.dtdPubID(pubID);
if (sysID != null) this.sysID = this.stringify.dtdSysID(sysID);
}
element(name, value) {
var child;
child = new XMLDTDElement(this, name, value);
this.children.push(child);
return this;
}
attList(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
var child;
child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
this.children.push(child);
return this;
}
entity(name, value) {
var child;
child = new XMLDTDEntity(this, false, name, value);
this.children.push(child);
return this;
}
pEntity(name, value) {
var child;
child = new XMLDTDEntity(this, true, name, value);
this.children.push(child);
return this;
}
notation(name, value) {
var child;
child = new XMLDTDNotation(this, name, value);
this.children.push(child);
return this;
}
toString(options) {
return this.options.writer.docType(this, this.options.writer.filterOptions(options));
}
ele(name, value) {
return this.element(name, value);
}
att(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
}
ent(name, value) {
return this.entity(name, value);
}
pent(name, value) {
return this.pEntity(name, value);
}
not(name, value) {
return this.notation(name, value);
}
up() {
return this.root() || this.documentObject;
}
isEqualNode(node) {
if (!super.isEqualNode(node)) return false;
if (node.name !== this.name) return false;
if (node.publicId !== this.publicId) return false;
if (node.systemId !== this.systemId) return false;
return true;
}
}
Object.defineProperty(XMLDocType$1.prototype, "entities", { get: function() {
var child, i$1, len$1, nodes, ref;
nodes = {};
ref = this.children;
for (i$1 = 0, len$1 = ref.length; i$1 < len$1; i$1++) {
child = ref[i$1];
if (child.type === NodeType$1.EntityDeclaration && !child.pe) nodes[child.name] = child;
}
return new XMLNamedNodeMap(nodes);
} });
Object.defineProperty(XMLDocType$1.prototype, "notations", { get: function() {
var child, i$1, len$1, nodes, ref;
nodes = {};
ref = this.children;
for (i$1 = 0, len$1 = ref.length; i$1 < len$1; i$1++) {
child = ref[i$1];
if (child.type === NodeType$1.NotationDeclaration) nodes[child.name] = child;
}
return new XMLNamedNodeMap(nodes);
} });
Object.defineProperty(XMLDocType$1.prototype, "publicId", { get: function() {
return this.pubID;
} });
Object.defineProperty(XMLDocType$1.prototype, "systemId", { get: function() {
return this.sysID;
} });
Object.defineProperty(XMLDocType$1.prototype, "internalSubset", { get: function() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
} });
return XMLDocType$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLRaw.js
var require_XMLRaw = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLRaw.js"(exports, module) {
(function() {
var NodeType$1, XMLNode, XMLRaw;
NodeType$1 = require_NodeType();
XMLNode = require_XMLNode();
module.exports = XMLRaw = class XMLRaw$1 extends XMLNode {
constructor(parent, text) {
super(parent);
if (text == null) throw new Error("Missing raw text. " + this.debugInfo());
this.type = NodeType$1.Raw;
this.value = this.stringify.raw(text);
}
clone() {
return Object.create(this);
}
toString(options) {
return this.options.writer.raw(this, this.options.writer.filterOptions(options));
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLText.js
var require_XMLText = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLText.js"(exports, module) {
(function() {
var NodeType$1, XMLCharacterData, XMLText;
NodeType$1 = require_NodeType();
XMLCharacterData = require_XMLCharacterData();
module.exports = XMLText = function() {
class XMLText$1 extends XMLCharacterData {
constructor(parent, text) {
super(parent);
if (text == null) throw new Error("Missing element text. " + this.debugInfo());
this.name = "#text";
this.type = NodeType$1.Text;
this.value = this.stringify.text(text);
}
clone() {
return Object.create(this);
}
toString(options) {
return this.options.writer.text(this, this.options.writer.filterOptions(options));
}
splitText(offset) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
replaceWholeText(content) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
}
Object.defineProperty(XMLText$1.prototype, "isElementContentWhitespace", { get: function() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
} });
Object.defineProperty(XMLText$1.prototype, "wholeText", { get: function() {
var next, prev, str;
str = "";
prev = this.previousSibling;
while (prev) {
str = prev.data + str;
prev = prev.previousSibling;
}
str += this.data;
next = this.nextSibling;
while (next) {
str = str + next.data;
next = next.nextSibling;
}
return str;
} });
return XMLText$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLProcessingInstruction.js
var require_XMLProcessingInstruction = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLProcessingInstruction.js"(exports, module) {
(function() {
var NodeType$1, XMLCharacterData, XMLProcessingInstruction;
NodeType$1 = require_NodeType();
XMLCharacterData = require_XMLCharacterData();
module.exports = XMLProcessingInstruction = class XMLProcessingInstruction$1 extends XMLCharacterData {
constructor(parent, target, value) {
super(parent);
if (target == null) throw new Error("Missing instruction target. " + this.debugInfo());
this.type = NodeType$1.ProcessingInstruction;
this.target = this.stringify.insTarget(target);
this.name = this.target;
if (value) this.value = this.stringify.insValue(value);
}
clone() {
return Object.create(this);
}
toString(options) {
return this.options.writer.processingInstruction(this, this.options.writer.filterOptions(options));
}
isEqualNode(node) {
if (!super.isEqualNode(node)) return false;
if (node.target !== this.target) return false;
return true;
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDummy.js
var require_XMLDummy = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDummy.js"(exports, module) {
(function() {
var NodeType$1, XMLDummy, XMLNode;
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
module.exports = XMLDummy = class XMLDummy$1 extends XMLNode {
constructor(parent) {
super(parent);
this.type = NodeType$1.Dummy;
}
clone() {
return Object.create(this);
}
toString(options) {
return "";
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLNodeList.js
var require_XMLNodeList = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLNodeList.js"(exports, module) {
(function() {
var XMLNodeList;
module.exports = XMLNodeList = function() {
class XMLNodeList$1 {
constructor(nodes) {
this.nodes = nodes;
}
clone() {
return this.nodes = null;
}
item(index) {
return this.nodes[index] || null;
}
}
Object.defineProperty(XMLNodeList$1.prototype, "length", { get: function() {
return this.nodes.length || 0;
} });
return XMLNodeList$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/DocumentPosition.js
var require_DocumentPosition = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/DocumentPosition.js"(exports, module) {
(function() {
module.exports = {
Disconnected: 1,
Preceding: 2,
Following: 4,
Contains: 8,
ContainedBy: 16,
ImplementationSpecific: 32
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLNode.js
var require_XMLNode = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLNode.js"(exports, module) {
(function() {
var DocumentPosition, NodeType$1, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty$1, isFunction, isObject$2, hasProp = {}.hasOwnProperty, splice = [].splice;
({isObject: isObject$2, isFunction, isEmpty: isEmpty$1, getValue} = require_Utility());
XMLElement = null;
XMLCData = null;
XMLComment = null;
XMLDeclaration = null;
XMLDocType = null;
XMLRaw = null;
XMLText = null;
XMLProcessingInstruction = null;
XMLDummy = null;
NodeType$1 = null;
XMLNodeList = null;
XMLNamedNodeMap = null;
DocumentPosition = null;
module.exports = XMLNode = function() {
class XMLNode$1 {
constructor(parent1) {
this.parent = parent1;
if (this.parent) {
this.options = this.parent.options;
this.stringify = this.parent.stringify;
}
this.value = null;
this.children = [];
this.baseURI = null;
if (!XMLElement) {
XMLElement = require_XMLElement();
XMLCData = require_XMLCData();
XMLComment = require_XMLComment();
XMLDeclaration = require_XMLDeclaration();
XMLDocType = require_XMLDocType();
XMLRaw = require_XMLRaw();
XMLText = require_XMLText();
XMLProcessingInstruction = require_XMLProcessingInstruction();
XMLDummy = require_XMLDummy();
NodeType$1 = require_NodeType();
XMLNodeList = require_XMLNodeList();
XMLNamedNodeMap = require_XMLNamedNodeMap();
DocumentPosition = require_DocumentPosition();
}
}
setParent(parent) {
var child, j, len$1, ref1, results;
this.parent = parent;
if (parent) {
this.options = parent.options;
this.stringify = parent.stringify;
}
ref1 = this.children;
results = [];
for (j = 0, len$1 = ref1.length; j < len$1; j++) {
child = ref1[j];
results.push(child.setParent(this));
}
return results;
}
element(name, attributes, text) {
var childNode, item, j, k, key, lastChild, len$1, len1, val;
lastChild = null;
if (attributes === null && text == null) [attributes, text] = [{}, null];
if (attributes == null) attributes = {};
attributes = getValue(attributes);
if (!isObject$2(attributes)) [text, attributes] = [attributes, text];
if (name != null) name = getValue(name);
if (Array.isArray(name)) for (j = 0, len$1 = name.length; j < len$1; j++) {
item = name[j];
lastChild = this.element(item);
}
else if (isFunction(name)) lastChild = this.element(name.apply());
else if (isObject$2(name)) for (key in name) {
if (!hasProp.call(name, key)) continue;
val = name[key];
if (isFunction(val)) val = val.apply();
if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
else if (!this.options.separateArrayItems && Array.isArray(val) && isEmpty$1(val)) lastChild = this.dummy();
else if (isObject$2(val) && isEmpty$1(val)) lastChild = this.element(key);
else if (!this.options.keepNullNodes && val == null) lastChild = this.dummy();
else if (!this.options.separateArrayItems && Array.isArray(val)) for (k = 0, len1 = val.length; k < len1; k++) {
item = val[k];
childNode = {};
childNode[key] = item;
lastChild = this.element(childNode);
}
else if (isObject$2(val)) if (!this.options.ignoreDecorators && this.stringify.convertTextKey && key.indexOf(this.stringify.convertTextKey) === 0) lastChild = this.element(val);
else {
lastChild = this.element(key);
lastChild.element(val);
}
else lastChild = this.element(key, val);
}
else if (!this.options.keepNullNodes && text === null) lastChild = this.dummy();
else if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) lastChild = this.text(text);
else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) lastChild = this.cdata(text);
else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) lastChild = this.comment(text);
else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) lastChild = this.raw(text);
else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text);
else lastChild = this.node(name, attributes, text);
if (lastChild == null) throw new Error("Could not create any elements with: " + name + ". " + this.debugInfo());
return lastChild;
}
insertBefore(name, attributes, text) {
var child, i$1, newChild, refChild, removed;
if (name != null ? name.type : void 0) {
newChild = name;
refChild = attributes;
newChild.setParent(this);
if (refChild) {
i$1 = children.indexOf(refChild);
removed = children.splice(i$1);
children.push(newChild);
Array.prototype.push.apply(children, removed);
} else children.push(newChild);
return newChild;
} else {
if (this.isRoot) throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
i$1 = this.parent.children.indexOf(this);
removed = this.parent.children.splice(i$1);
child = this.parent.element(name, attributes, text);
Array.prototype.push.apply(this.parent.children, removed);
return child;
}
}
insertAfter(name, attributes, text) {
var child, i$1, removed;
if (this.isRoot) throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
i$1 = this.parent.children.indexOf(this);
removed = this.parent.children.splice(i$1 + 1);
child = this.parent.element(name, attributes, text);
Array.prototype.push.apply(this.parent.children, removed);
return child;
}
remove() {
var i$1, ref1;
if (this.isRoot) throw new Error("Cannot remove the root element. " + this.debugInfo());
i$1 = this.parent.children.indexOf(this);
splice.apply(this.parent.children, [i$1, i$1 - i$1 + 1].concat(ref1 = []));
return this.parent;
}
node(name, attributes, text) {
var child;
if (name != null) name = getValue(name);
attributes || (attributes = {});
attributes = getValue(attributes);
if (!isObject$2(attributes)) [text, attributes] = [attributes, text];
child = new XMLElement(this, name, attributes);
if (text != null) child.text(text);
this.children.push(child);
return child;
}
text(value) {
var child;
if (isObject$2(value)) this.element(value);
child = new XMLText(this, value);
this.children.push(child);
return this;
}
cdata(value) {
var child;
child = new XMLCData(this, value);
this.children.push(child);
return this;
}
comment(value) {
var child;
child = new XMLComment(this, value);
this.children.push(child);
return this;
}
commentBefore(value) {
var child, i$1, removed;
i$1 = this.parent.children.indexOf(this);
removed = this.parent.children.splice(i$1);
child = this.parent.comment(value);
Array.prototype.push.apply(this.parent.children, removed);
return this;
}
commentAfter(value) {
var child, i$1, removed;
i$1 = this.parent.children.indexOf(this);
removed = this.parent.children.splice(i$1 + 1);
child = this.parent.comment(value);
Array.prototype.push.apply(this.parent.children, removed);
return this;
}
raw(value) {
var child;
child = new XMLRaw(this, value);
this.children.push(child);
return this;
}
dummy() {
var child;
child = new XMLDummy(this);
return child;
}
instruction(target, value) {
var insTarget, insValue, instruction, j, len$1;
if (target != null) target = getValue(target);
if (value != null) value = getValue(value);
if (Array.isArray(target)) for (j = 0, len$1 = target.length; j < len$1; j++) {
insTarget = target[j];
this.instruction(insTarget);
}
else if (isObject$2(target)) for (insTarget in target) {
if (!hasProp.call(target, insTarget)) continue;
insValue = target[insTarget];
this.instruction(insTarget, insValue);
}
else {
if (isFunction(value)) value = value.apply();
instruction = new XMLProcessingInstruction(this, target, value);
this.children.push(instruction);
}
return this;
}
instructionBefore(target, value) {
var child, i$1, removed;
i$1 = this.parent.children.indexOf(this);
removed = this.parent.children.splice(i$1);
child = this.parent.instruction(target, value);
Array.prototype.push.apply(this.parent.children, removed);
return this;
}
instructionAfter(target, value) {
var child, i$1, removed;
i$1 = this.parent.children.indexOf(this);
removed = this.parent.children.splice(i$1 + 1);
child = this.parent.instruction(target, value);
Array.prototype.push.apply(this.parent.children, removed);
return this;
}
declaration(version, encoding, standalone) {
var doc, xmldec;
doc = this.document();
xmldec = new XMLDeclaration(doc, version, encoding, standalone);
if (doc.children.length === 0) doc.children.unshift(xmldec);
else if (doc.children[0].type === NodeType$1.Declaration) doc.children[0] = xmldec;
else doc.children.unshift(xmldec);
return doc.root() || doc;
}
dtd(pubID, sysID) {
var child, doc, doctype, i$1, j, k, len$1, len1, ref1, ref2;
doc = this.document();
doctype = new XMLDocType(doc, pubID, sysID);
ref1 = doc.children;
for (i$1 = j = 0, len$1 = ref1.length; j < len$1; i$1 = ++j) {
child = ref1[i$1];
if (child.type === NodeType$1.DocType) {
doc.children[i$1] = doctype;
return doctype;
}
}
ref2 = doc.children;
for (i$1 = k = 0, len1 = ref2.length; k < len1; i$1 = ++k) {
child = ref2[i$1];
if (child.isRoot) {
doc.children.splice(i$1, 0, doctype);
return doctype;
}
}
doc.children.push(doctype);
return doctype;
}
up() {
if (this.isRoot) throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
return this.parent;
}
root() {
var node;
node = this;
while (node) if (node.type === NodeType$1.Document) return node.rootObject;
else if (node.isRoot) return node;
else node = node.parent;
}
document() {
var node;
node = this;
while (node) if (node.type === NodeType$1.Document) return node;
else node = node.parent;
}
end(options) {
return this.document().end(options);
}
prev() {
var i$1;
i$1 = this.parent.children.indexOf(this);
if (i$1 < 1) throw new Error("Already at the first node. " + this.debugInfo());
return this.parent.children[i$1 - 1];
}
next() {
var i$1;
i$1 = this.parent.children.indexOf(this);
if (i$1 === -1 || i$1 === this.parent.children.length - 1) throw new Error("Already at the last node. " + this.debugInfo());
return this.parent.children[i$1 + 1];
}
importDocument(doc) {
var child, clonedRoot, j, len$1, ref1;
clonedRoot = doc.root().clone();
clonedRoot.parent = this;
clonedRoot.isRoot = false;
this.children.push(clonedRoot);
if (this.type === NodeType$1.Document) {
clonedRoot.isRoot = true;
clonedRoot.documentObject = this;
this.rootObject = clonedRoot;
if (this.children) {
ref1 = this.children;
for (j = 0, len$1 = ref1.length; j < len$1; j++) {
child = ref1[j];
if (child.type === NodeType$1.DocType) {
child.name = clonedRoot.name;
break;
}
}
}
}
return this;
}
debugInfo(name) {
var ref1, ref2;
name = name || this.name;
if (name == null && !((ref1 = this.parent) != null ? ref1.name : void 0)) return "";
else if (name == null) return "parent: <" + this.parent.name + ">";
else if (!((ref2 = this.parent) != null ? ref2.name : void 0)) return "node: <" + name + ">";
else return "node: <" + name + ">, parent: <" + this.parent.name + ">";
}
ele(name, attributes, text) {
return this.element(name, attributes, text);
}
nod(name, attributes, text) {
return this.node(name, attributes, text);
}
txt(value) {
return this.text(value);
}
dat(value) {
return this.cdata(value);
}
com(value) {
return this.comment(value);
}
ins(target, value) {
return this.instruction(target, value);
}
doc() {
return this.document();
}
dec(version, encoding, standalone) {
return this.declaration(version, encoding, standalone);
}
e(name, attributes, text) {
return this.element(name, attributes, text);
}
n(name, attributes, text) {
return this.node(name, attributes, text);
}
t(value) {
return this.text(value);
}
d(value) {
return this.cdata(value);
}
c(value) {
return this.comment(value);
}
r(value) {
return this.raw(value);
}
i(target, value) {
return this.instruction(target, value);
}
u() {
return this.up();
}
importXMLBuilder(doc) {
return this.importDocument(doc);
}
attribute(name, value) {
throw new Error("attribute() applies to element nodes only.");
}
att(name, value) {
return this.attribute(name, value);
}
a(name, value) {
return this.attribute(name, value);
}
removeAttribute(name) {
throw new Error("attribute() applies to element nodes only.");
}
replaceChild(newChild, oldChild) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
removeChild(oldChild) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
appendChild(newChild) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
hasChildNodes() {
return this.children.length !== 0;
}
cloneNode(deep) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
normalize() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
isSupported(feature, version) {
return true;
}
hasAttributes() {
return this.attribs.length !== 0;
}
compareDocumentPosition(other) {
var ref, res;
ref = this;
if (ref === other) return 0;
else if (this.document() !== other.document()) {
res = DocumentPosition.Disconnected | DocumentPosition.ImplementationSpecific;
if (Math.random() < .5) res |= DocumentPosition.Preceding;
else res |= DocumentPosition.Following;
return res;
} else if (ref.isAncestor(other)) return DocumentPosition.Contains | DocumentPosition.Preceding;
else if (ref.isDescendant(other)) return DocumentPosition.Contains | DocumentPosition.Following;
else if (ref.isPreceding(other)) return DocumentPosition.Preceding;
else return DocumentPosition.Following;
}
isSameNode(other) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
lookupPrefix(namespaceURI) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
isDefaultNamespace(namespaceURI) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
lookupNamespaceURI(prefix) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
isEqualNode(node) {
var i$1, j, ref1;
if (node.nodeType !== this.nodeType) return false;
if (node.children.length !== this.children.length) return false;
for (i$1 = j = 0, ref1 = this.children.length - 1; 0 <= ref1 ? j <= ref1 : j >= ref1; i$1 = 0 <= ref1 ? ++j : --j) if (!this.children[i$1].isEqualNode(node.children[i$1])) return false;
return true;
}
getFeature(feature, version) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
setUserData(key, data, handler) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getUserData(key) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
contains(other) {
if (!other) return false;
return other === this || this.isDescendant(other);
}
isDescendant(node) {
var child, isDescendantChild, j, len$1, ref1;
ref1 = this.children;
for (j = 0, len$1 = ref1.length; j < len$1; j++) {
child = ref1[j];
if (node === child) return true;
isDescendantChild = child.isDescendant(node);
if (isDescendantChild) return true;
}
return false;
}
isAncestor(node) {
return node.isDescendant(this);
}
isPreceding(node) {
var nodePos, thisPos;
nodePos = this.treePosition(node);
thisPos = this.treePosition(this);
if (nodePos === -1 || thisPos === -1) return false;
else return nodePos < thisPos;
}
isFollowing(node) {
var nodePos, thisPos;
nodePos = this.treePosition(node);
thisPos = this.treePosition(this);
if (nodePos === -1 || thisPos === -1) return false;
else return nodePos > thisPos;
}
treePosition(node) {
var found, pos;
pos = 0;
found = false;
this.foreachTreeNode(this.document(), function(childNode) {
pos++;
if (!found && childNode === node) return found = true;
});
if (found) return pos;
else return -1;
}
foreachTreeNode(node, func) {
var child, j, len$1, ref1, res;
node || (node = this.document());
ref1 = node.children;
for (j = 0, len$1 = ref1.length; j < len$1; j++) {
child = ref1[j];
if (res = func(child)) return res;
else {
res = this.foreachTreeNode(child, func);
if (res) return res;
}
}
}
}
Object.defineProperty(XMLNode$1.prototype, "nodeName", { get: function() {
return this.name;
} });
Object.defineProperty(XMLNode$1.prototype, "nodeType", { get: function() {
return this.type;
} });
Object.defineProperty(XMLNode$1.prototype, "nodeValue", { get: function() {
return this.value;
} });
Object.defineProperty(XMLNode$1.prototype, "parentNode", { get: function() {
return this.parent;
} });
Object.defineProperty(XMLNode$1.prototype, "childNodes", { get: function() {
if (!this.childNodeList || !this.childNodeList.nodes) this.childNodeList = new XMLNodeList(this.children);
return this.childNodeList;
} });
Object.defineProperty(XMLNode$1.prototype, "firstChild", { get: function() {
return this.children[0] || null;
} });
Object.defineProperty(XMLNode$1.prototype, "lastChild", { get: function() {
return this.children[this.children.length - 1] || null;
} });
Object.defineProperty(XMLNode$1.prototype, "previousSibling", { get: function() {
var i$1;
i$1 = this.parent.children.indexOf(this);
return this.parent.children[i$1 - 1] || null;
} });
Object.defineProperty(XMLNode$1.prototype, "nextSibling", { get: function() {
var i$1;
i$1 = this.parent.children.indexOf(this);
return this.parent.children[i$1 + 1] || null;
} });
Object.defineProperty(XMLNode$1.prototype, "ownerDocument", { get: function() {
return this.document() || null;
} });
Object.defineProperty(XMLNode$1.prototype, "textContent", {
get: function() {
var child, j, len$1, ref1, str;
if (this.nodeType === NodeType$1.Element || this.nodeType === NodeType$1.DocumentFragment) {
str = "";
ref1 = this.children;
for (j = 0, len$1 = ref1.length; j < len$1; j++) {
child = ref1[j];
if (child.textContent) str += child.textContent;
}
return str;
} else return null;
},
set: function(value) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
});
return XMLNode$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLStringifier.js
var require_XMLStringifier = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLStringifier.js"(exports, module) {
(function() {
var XMLStringifier, hasProp = {}.hasOwnProperty;
module.exports = XMLStringifier = function() {
class XMLStringifier$1 {
constructor(options) {
var key, ref, value;
this.assertLegalChar = this.assertLegalChar.bind(this);
this.assertLegalName = this.assertLegalName.bind(this);
options || (options = {});
this.options = options;
if (!this.options.version) this.options.version = "1.0";
ref = options.stringify || {};
for (key in ref) {
if (!hasProp.call(ref, key)) continue;
value = ref[key];
this[key] = value;
}
}
name(val) {
if (this.options.noValidation) return val;
return this.assertLegalName("" + val || "");
}
text(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar(this.textEscape("" + val || ""));
}
cdata(val) {
if (this.options.noValidation) return val;
val = "" + val || "";
val = val.replace("]]>", "]]]]><![CDATA[>");
return this.assertLegalChar(val);
}
comment(val) {
if (this.options.noValidation) return val;
val = "" + val || "";
if (val.match(/--/)) throw new Error("Comment text cannot contain double-hypen: " + val);
return this.assertLegalChar(val);
}
raw(val) {
if (this.options.noValidation) return val;
return "" + val || "";
}
attValue(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar(this.attEscape(val = "" + val || ""));
}
insTarget(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar("" + val || "");
}
insValue(val) {
if (this.options.noValidation) return val;
val = "" + val || "";
if (val.match(/\?>/)) throw new Error("Invalid processing instruction value: " + val);
return this.assertLegalChar(val);
}
xmlVersion(val) {
if (this.options.noValidation) return val;
val = "" + val || "";
if (!val.match(/1\.[0-9]+/)) throw new Error("Invalid version number: " + val);
return val;
}
xmlEncoding(val) {
if (this.options.noValidation) return val;
val = "" + val || "";
if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) throw new Error("Invalid encoding: " + val);
return this.assertLegalChar(val);
}
xmlStandalone(val) {
if (this.options.noValidation) return val;
if (val) return "yes";
else return "no";
}
dtdPubID(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar("" + val || "");
}
dtdSysID(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar("" + val || "");
}
dtdElementValue(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar("" + val || "");
}
dtdAttType(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar("" + val || "");
}
dtdAttDefault(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar("" + val || "");
}
dtdEntityValue(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar("" + val || "");
}
dtdNData(val) {
if (this.options.noValidation) return val;
return this.assertLegalChar("" + val || "");
}
assertLegalChar(str) {
var regex, res;
if (this.options.noValidation) return str;
if (this.options.version === "1.0") {
regex = /[\0-\x08\x0B\f\x0E-\x1F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/g;
if (this.options.invalidCharReplacement !== void 0) str = str.replace(regex, this.options.invalidCharReplacement);
else if (res = str.match(regex)) throw new Error(`Invalid character in string: ${str} at index ${res.index}`);
} else if (this.options.version === "1.1") {
regex = /[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/g;
if (this.options.invalidCharReplacement !== void 0) str = str.replace(regex, this.options.invalidCharReplacement);
else if (res = str.match(regex)) throw new Error(`Invalid character in string: ${str} at index ${res.index}`);
}
return str;
}
assertLegalName(str) {
var regex;
if (this.options.noValidation) return str;
str = this.assertLegalChar(str);
regex = /^([:A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])([\x2D\.0-:A-Z_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*$/;
if (!str.match(regex)) throw new Error(`Invalid character in name: ${str}`);
return str;
}
textEscape(str) {
var ampregex;
if (this.options.noValidation) return str;
ampregex = this.options.noDoubleEncoding ? /(?!&(lt|gt|amp|apos|quot);)&/g : /&/g;
return str.replace(ampregex, "&").replace(/</g, "<").replace(/>/g, ">").replace(/\r/g, "
");
}
attEscape(str) {
var ampregex;
if (this.options.noValidation) return str;
ampregex = this.options.noDoubleEncoding ? /(?!&(lt|gt|amp|apos|quot);)&/g : /&/g;
return str.replace(ampregex, "&").replace(/</g, "<").replace(/"/g, """).replace(/\t/g, "	").replace(/\n/g, "
").replace(/\r/g, "
");
}
}
XMLStringifier$1.prototype.convertAttKey = "@";
XMLStringifier$1.prototype.convertPIKey = "?";
XMLStringifier$1.prototype.convertTextKey = "#text";
XMLStringifier$1.prototype.convertCDataKey = "#cdata";
XMLStringifier$1.prototype.convertCommentKey = "#comment";
XMLStringifier$1.prototype.convertRawKey = "#raw";
return XMLStringifier$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/WriterState.js
var require_WriterState = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/WriterState.js"(exports, module) {
(function() {
module.exports = {
None: 0,
OpenTag: 1,
InsideTag: 2,
CloseTag: 3
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLWriterBase.js
var require_XMLWriterBase = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLWriterBase.js"(exports, module) {
(function() {
var NodeType$1, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign$1, hasProp = {}.hasOwnProperty;
({assign: assign$1} = require_Utility());
NodeType$1 = require_NodeType();
XMLDeclaration = require_XMLDeclaration();
XMLDocType = require_XMLDocType();
XMLCData = require_XMLCData();
XMLComment = require_XMLComment();
XMLElement = require_XMLElement();
XMLRaw = require_XMLRaw();
XMLText = require_XMLText();
XMLProcessingInstruction = require_XMLProcessingInstruction();
XMLDummy = require_XMLDummy();
XMLDTDAttList = require_XMLDTDAttList();
XMLDTDElement = require_XMLDTDElement();
XMLDTDEntity = require_XMLDTDEntity();
XMLDTDNotation = require_XMLDTDNotation();
WriterState = require_WriterState();
module.exports = XMLWriterBase = class XMLWriterBase$1 {
constructor(options) {
var key, ref, value;
options || (options = {});
this.options = options;
ref = options.writer || {};
for (key in ref) {
if (!hasProp.call(ref, key)) continue;
value = ref[key];
this["_" + key] = this[key];
this[key] = value;
}
}
filterOptions(options) {
var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7;
options || (options = {});
options = assign$1({}, this.options, options);
filteredOptions = { writer: this };
filteredOptions.pretty = options.pretty || false;
filteredOptions.allowEmpty = options.allowEmpty || false;
filteredOptions.indent = (ref = options.indent) != null ? ref : " ";
filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : "\n";
filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0;
filteredOptions.width = (ref3 = options.width) != null ? ref3 : 0;
filteredOptions.dontPrettyTextNodes = (ref4 = (ref5 = options.dontPrettyTextNodes) != null ? ref5 : options.dontprettytextnodes) != null ? ref4 : 0;
filteredOptions.spaceBeforeSlash = (ref6 = (ref7 = options.spaceBeforeSlash) != null ? ref7 : options.spacebeforeslash) != null ? ref6 : "";
if (filteredOptions.spaceBeforeSlash === true) filteredOptions.spaceBeforeSlash = " ";
filteredOptions.suppressPrettyCount = 0;
filteredOptions.user = {};
filteredOptions.state = WriterState.None;
return filteredOptions;
}
indent(node, options, level) {
var indentLevel;
if (!options.pretty || options.suppressPrettyCount) return "";
else if (options.pretty) {
indentLevel = (level || 0) + options.offset + 1;
if (indentLevel > 0) return new Array(indentLevel).join(options.indent);
}
return "";
}
endline(node, options, level) {
if (!options.pretty || options.suppressPrettyCount) return "";
else return options.newline;
}
attribute(att, options, level) {
var r;
this.openAttribute(att, options, level);
if (options.pretty && options.width > 0) r = att.name + "=\"" + att.value + "\"";
else r = " " + att.name + "=\"" + att.value + "\"";
this.closeAttribute(att, options, level);
return r;
}
cdata(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<![CDATA[";
options.state = WriterState.InsideTag;
r += node.value;
options.state = WriterState.CloseTag;
r += "]]>" + this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
comment(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<!-- ";
options.state = WriterState.InsideTag;
r += node.value;
options.state = WriterState.CloseTag;
r += " -->" + this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
declaration(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<?xml";
options.state = WriterState.InsideTag;
r += " version=\"" + node.version + "\"";
if (node.encoding != null) r += " encoding=\"" + node.encoding + "\"";
if (node.standalone != null) r += " standalone=\"" + node.standalone + "\"";
options.state = WriterState.CloseTag;
r += options.spaceBeforeSlash + "?>";
r += this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
docType(node, options, level) {
var child, i$1, len1, r, ref;
level || (level = 0);
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level);
r += "<!DOCTYPE " + node.root().name;
if (node.pubID && node.sysID) r += " PUBLIC \"" + node.pubID + "\" \"" + node.sysID + "\"";
else if (node.sysID) r += " SYSTEM \"" + node.sysID + "\"";
if (node.children.length > 0) {
r += " [";
r += this.endline(node, options, level);
options.state = WriterState.InsideTag;
ref = node.children;
for (i$1 = 0, len1 = ref.length; i$1 < len1; i$1++) {
child = ref[i$1];
r += this.writeChildNode(child, options, level + 1);
}
options.state = WriterState.CloseTag;
r += "]";
}
options.state = WriterState.CloseTag;
r += options.spaceBeforeSlash + ">";
r += this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
element(node, options, level) {
var att, attLen, child, childNodeCount, firstChildNode, i$1, j, len$1, len1, len2, name, prettySuppressed, r, ratt, ref, ref1, ref2, ref3, rline;
level || (level = 0);
prettySuppressed = false;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<" + node.name;
if (options.pretty && options.width > 0) {
len$1 = r.length;
ref = node.attribs;
for (name in ref) {
if (!hasProp.call(ref, name)) continue;
att = ref[name];
ratt = this.attribute(att, options, level);
attLen = ratt.length;
if (len$1 + attLen > options.width) {
rline = this.indent(node, options, level + 1) + ratt;
r += this.endline(node, options, level) + rline;
len$1 = rline.length;
} else {
rline = " " + ratt;
r += rline;
len$1 += rline.length;
}
}
} else {
ref1 = node.attribs;
for (name in ref1) {
if (!hasProp.call(ref1, name)) continue;
att = ref1[name];
r += this.attribute(att, options, level);
}
}
childNodeCount = node.children.length;
firstChildNode = childNodeCount === 0 ? null : node.children[0];
if (childNodeCount === 0 || node.children.every(function(e) {
return (e.type === NodeType$1.Text || e.type === NodeType$1.Raw || e.type === NodeType$1.CData) && e.value === "";
})) if (options.allowEmpty) {
r += ">";
options.state = WriterState.CloseTag;
r += "</" + node.name + ">" + this.endline(node, options, level);
} else {
options.state = WriterState.CloseTag;
r += options.spaceBeforeSlash + "/>" + this.endline(node, options, level);
}
else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType$1.Text || firstChildNode.type === NodeType$1.Raw || firstChildNode.type === NodeType$1.CData) && firstChildNode.value != null) {
r += ">";
options.state = WriterState.InsideTag;
options.suppressPrettyCount++;
prettySuppressed = true;
r += this.writeChildNode(firstChildNode, options, level + 1);
options.suppressPrettyCount--;
prettySuppressed = false;
options.state = WriterState.CloseTag;
r += "</" + node.name + ">" + this.endline(node, options, level);
} else {
if (options.dontPrettyTextNodes) {
ref2 = node.children;
for (i$1 = 0, len1 = ref2.length; i$1 < len1; i$1++) {
child = ref2[i$1];
if ((child.type === NodeType$1.Text || child.type === NodeType$1.Raw || child.type === NodeType$1.CData) && child.value != null) {
options.suppressPrettyCount++;
prettySuppressed = true;
break;
}
}
}
r += ">" + this.endline(node, options, level);
options.state = WriterState.InsideTag;
ref3 = node.children;
for (j = 0, len2 = ref3.length; j < len2; j++) {
child = ref3[j];
r += this.writeChildNode(child, options, level + 1);
}
options.state = WriterState.CloseTag;
r += this.indent(node, options, level) + "</" + node.name + ">";
if (prettySuppressed) options.suppressPrettyCount--;
r += this.endline(node, options, level);
options.state = WriterState.None;
}
this.closeNode(node, options, level);
return r;
}
writeChildNode(node, options, level) {
switch (node.type) {
case NodeType$1.CData: return this.cdata(node, options, level);
case NodeType$1.Comment: return this.comment(node, options, level);
case NodeType$1.Element: return this.element(node, options, level);
case NodeType$1.Raw: return this.raw(node, options, level);
case NodeType$1.Text: return this.text(node, options, level);
case NodeType$1.ProcessingInstruction: return this.processingInstruction(node, options, level);
case NodeType$1.Dummy: return "";
case NodeType$1.Declaration: return this.declaration(node, options, level);
case NodeType$1.DocType: return this.docType(node, options, level);
case NodeType$1.AttributeDeclaration: return this.dtdAttList(node, options, level);
case NodeType$1.ElementDeclaration: return this.dtdElement(node, options, level);
case NodeType$1.EntityDeclaration: return this.dtdEntity(node, options, level);
case NodeType$1.NotationDeclaration: return this.dtdNotation(node, options, level);
default: throw new Error("Unknown XML node type: " + node.constructor.name);
}
}
processingInstruction(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<?";
options.state = WriterState.InsideTag;
r += node.target;
if (node.value) r += " " + node.value;
options.state = WriterState.CloseTag;
r += options.spaceBeforeSlash + "?>";
r += this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
raw(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level);
options.state = WriterState.InsideTag;
r += node.value;
options.state = WriterState.CloseTag;
r += this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
text(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level);
options.state = WriterState.InsideTag;
r += node.value;
options.state = WriterState.CloseTag;
r += this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
dtdAttList(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<!ATTLIST";
options.state = WriterState.InsideTag;
r += " " + node.elementName + " " + node.attributeName + " " + node.attributeType;
if (node.defaultValueType !== "#DEFAULT") r += " " + node.defaultValueType;
if (node.defaultValue) r += " \"" + node.defaultValue + "\"";
options.state = WriterState.CloseTag;
r += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
dtdElement(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<!ELEMENT";
options.state = WriterState.InsideTag;
r += " " + node.name + " " + node.value;
options.state = WriterState.CloseTag;
r += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
dtdEntity(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<!ENTITY";
options.state = WriterState.InsideTag;
if (node.pe) r += " %";
r += " " + node.name;
if (node.value) r += " \"" + node.value + "\"";
else {
if (node.pubID && node.sysID) r += " PUBLIC \"" + node.pubID + "\" \"" + node.sysID + "\"";
else if (node.sysID) r += " SYSTEM \"" + node.sysID + "\"";
if (node.nData) r += " NDATA " + node.nData;
}
options.state = WriterState.CloseTag;
r += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
dtdNotation(node, options, level) {
var r;
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<!NOTATION";
options.state = WriterState.InsideTag;
r += " " + node.name;
if (node.pubID && node.sysID) r += " PUBLIC \"" + node.pubID + "\" \"" + node.sysID + "\"";
else if (node.pubID) r += " PUBLIC \"" + node.pubID + "\"";
else if (node.sysID) r += " SYSTEM \"" + node.sysID + "\"";
options.state = WriterState.CloseTag;
r += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
options.state = WriterState.None;
this.closeNode(node, options, level);
return r;
}
openNode(node, options, level) {}
closeNode(node, options, level) {}
openAttribute(att, options, level) {}
closeAttribute(att, options, level) {}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLStringWriter.js
var require_XMLStringWriter = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLStringWriter.js"(exports, module) {
(function() {
var XMLStringWriter, XMLWriterBase;
XMLWriterBase = require_XMLWriterBase();
module.exports = XMLStringWriter = class XMLStringWriter$1 extends XMLWriterBase {
constructor(options) {
super(options);
}
document(doc, options) {
var child, i$1, len$1, r, ref;
options = this.filterOptions(options);
r = "";
ref = doc.children;
for (i$1 = 0, len$1 = ref.length; i$1 < len$1; i$1++) {
child = ref[i$1];
r += this.writeChildNode(child, options, 0);
}
if (options.pretty && r.slice(-options.newline.length) === options.newline) r = r.slice(0, -options.newline.length);
return r;
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDocument.js
var require_XMLDocument = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDocument.js"(exports, module) {
(function() {
var NodeType$1, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject;
({isPlainObject} = require_Utility());
XMLDOMImplementation = require_XMLDOMImplementation();
XMLDOMConfiguration = require_XMLDOMConfiguration();
XMLNode = require_XMLNode();
NodeType$1 = require_NodeType();
XMLStringifier = require_XMLStringifier();
XMLStringWriter = require_XMLStringWriter();
module.exports = XMLDocument = function() {
class XMLDocument$1 extends XMLNode {
constructor(options) {
super(null);
this.name = "#document";
this.type = NodeType$1.Document;
this.documentURI = null;
this.domConfig = new XMLDOMConfiguration();
options || (options = {});
if (!options.writer) options.writer = new XMLStringWriter();
this.options = options;
this.stringify = new XMLStringifier(options);
}
end(writer) {
var writerOptions;
writerOptions = {};
if (!writer) writer = this.options.writer;
else if (isPlainObject(writer)) {
writerOptions = writer;
writer = this.options.writer;
}
return writer.document(this, writer.filterOptions(writerOptions));
}
toString(options) {
return this.options.writer.document(this, this.options.writer.filterOptions(options));
}
createElement(tagName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createDocumentFragment() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createTextNode(data) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createComment(data) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createCDATASection(data) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createProcessingInstruction(target, data) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createAttribute(name) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createEntityReference(name) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementsByTagName(tagname) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
importNode(importedNode, deep) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createElementNS(namespaceURI, qualifiedName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createAttributeNS(namespaceURI, qualifiedName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementsByTagNameNS(namespaceURI, localName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementById(elementId) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
adoptNode(source) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
normalizeDocument() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
renameNode(node, namespaceURI, qualifiedName) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
getElementsByClassName(classNames) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createEvent(eventInterface) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createRange() {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createNodeIterator(root, whatToShow, filter) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
createTreeWalker(root, whatToShow, filter) {
throw new Error("This DOM method is not implemented." + this.debugInfo());
}
}
Object.defineProperty(XMLDocument$1.prototype, "implementation", { value: new XMLDOMImplementation() });
Object.defineProperty(XMLDocument$1.prototype, "doctype", { get: function() {
var child, i$1, len$1, ref;
ref = this.children;
for (i$1 = 0, len$1 = ref.length; i$1 < len$1; i$1++) {
child = ref[i$1];
if (child.type === NodeType$1.DocType) return child;
}
return null;
} });
Object.defineProperty(XMLDocument$1.prototype, "documentElement", { get: function() {
return this.rootObject || null;
} });
Object.defineProperty(XMLDocument$1.prototype, "inputEncoding", { get: function() {
return null;
} });
Object.defineProperty(XMLDocument$1.prototype, "strictErrorChecking", { get: function() {
return false;
} });
Object.defineProperty(XMLDocument$1.prototype, "xmlEncoding", { get: function() {
if (this.children.length !== 0 && this.children[0].type === NodeType$1.Declaration) return this.children[0].encoding;
else return null;
} });
Object.defineProperty(XMLDocument$1.prototype, "xmlStandalone", { get: function() {
if (this.children.length !== 0 && this.children[0].type === NodeType$1.Declaration) return this.children[0].standalone === "yes";
else return false;
} });
Object.defineProperty(XMLDocument$1.prototype, "xmlVersion", { get: function() {
if (this.children.length !== 0 && this.children[0].type === NodeType$1.Declaration) return this.children[0].version;
else return "1.0";
} });
Object.defineProperty(XMLDocument$1.prototype, "URL", { get: function() {
return this.documentURI;
} });
Object.defineProperty(XMLDocument$1.prototype, "origin", { get: function() {
return null;
} });
Object.defineProperty(XMLDocument$1.prototype, "compatMode", { get: function() {
return null;
} });
Object.defineProperty(XMLDocument$1.prototype, "characterSet", { get: function() {
return null;
} });
Object.defineProperty(XMLDocument$1.prototype, "contentType", { get: function() {
return null;
} });
return XMLDocument$1;
}.call(this);
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDocumentCB.js
var require_XMLDocumentCB = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLDocumentCB.js"(exports, module) {
(function() {
var NodeType$1, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject$2, isPlainObject, hasProp = {}.hasOwnProperty;
({isObject: isObject$2, isFunction, isPlainObject, getValue} = require_Utility());
NodeType$1 = require_NodeType();
XMLDocument = require_XMLDocument();
XMLElement = require_XMLElement();
XMLCData = require_XMLCData();
XMLComment = require_XMLComment();
XMLRaw = require_XMLRaw();
XMLText = require_XMLText();
XMLProcessingInstruction = require_XMLProcessingInstruction();
XMLDeclaration = require_XMLDeclaration();
XMLDocType = require_XMLDocType();
XMLDTDAttList = require_XMLDTDAttList();
XMLDTDEntity = require_XMLDTDEntity();
XMLDTDElement = require_XMLDTDElement();
XMLDTDNotation = require_XMLDTDNotation();
XMLAttribute = require_XMLAttribute();
XMLStringifier = require_XMLStringifier();
XMLStringWriter = require_XMLStringWriter();
WriterState = require_WriterState();
module.exports = XMLDocumentCB = class XMLDocumentCB$1 {
constructor(options, onData, onEnd) {
var writerOptions;
this.name = "?xml";
this.type = NodeType$1.Document;
options || (options = {});
writerOptions = {};
if (!options.writer) options.writer = new XMLStringWriter();
else if (isPlainObject(options.writer)) {
writerOptions = options.writer;
options.writer = new XMLStringWriter();
}
this.options = options;
this.writer = options.writer;
this.writerOptions = this.writer.filterOptions(writerOptions);
this.stringify = new XMLStringifier(options);
this.onDataCallback = onData || function() {};
this.onEndCallback = onEnd || function() {};
this.currentNode = null;
this.currentLevel = -1;
this.openTags = {};
this.documentStarted = false;
this.documentCompleted = false;
this.root = null;
}
createChildNode(node) {
var att, attName, attributes, child, i$1, len$1, ref, ref1;
switch (node.type) {
case NodeType$1.CData:
this.cdata(node.value);
break;
case NodeType$1.Comment:
this.comment(node.value);
break;
case NodeType$1.Element:
attributes = {};
ref = node.attribs;
for (attName in ref) {
if (!hasProp.call(ref, attName)) continue;
att = ref[attName];
attributes[attName] = att.value;
}
this.node(node.name, attributes);
break;
case NodeType$1.Dummy:
this.dummy();
break;
case NodeType$1.Raw:
this.raw(node.value);
break;
case NodeType$1.Text:
this.text(node.value);
break;
case NodeType$1.ProcessingInstruction:
this.instruction(node.target, node.value);
break;
default: throw new Error("This XML node type is not supported in a JS object: " + node.constructor.name);
}
ref1 = node.children;
for (i$1 = 0, len$1 = ref1.length; i$1 < len$1; i$1++) {
child = ref1[i$1];
this.createChildNode(child);
if (child.type === NodeType$1.Element) this.up();
}
return this;
}
dummy() {
return this;
}
node(name, attributes, text) {
if (name == null) throw new Error("Missing node name.");
if (this.root && this.currentLevel === -1) throw new Error("Document can only have one root node. " + this.debugInfo(name));
this.openCurrent();
name = getValue(name);
if (attributes == null) attributes = {};
attributes = getValue(attributes);
if (!isObject$2(attributes)) [text, attributes] = [attributes, text];
this.currentNode = new XMLElement(this, name, attributes);
this.currentNode.children = false;
this.currentLevel++;
this.openTags[this.currentLevel] = this.currentNode;
if (text != null) this.text(text);
return this;
}
element(name, attributes, text) {
var child, i$1, len$1, oldValidationFlag, ref, root;
if (this.currentNode && this.currentNode.type === NodeType$1.DocType) this.dtdElement(...arguments);
else if (Array.isArray(name) || isObject$2(name) || isFunction(name)) {
oldValidationFlag = this.options.noValidation;
this.options.noValidation = true;
root = new XMLDocument(this.options).element("TEMP_ROOT");
root.element(name);
this.options.noValidation = oldValidationFlag;
ref = root.children;
for (i$1 = 0, len$1 = ref.length; i$1 < len$1; i$1++) {
child = ref[i$1];
this.createChildNode(child);
if (child.type === NodeType$1.Element) this.up();
}
} else this.node(name, attributes, text);
return this;
}
attribute(name, value) {
var attName, attValue;
if (!this.currentNode || this.currentNode.children) throw new Error("att() can only be used immediately after an ele() call in callback mode. " + this.debugInfo(name));
if (name != null) name = getValue(name);
if (isObject$2(name)) for (attName in name) {
if (!hasProp.call(name, attName)) continue;
attValue = name[attName];
this.attribute(attName, attValue);
}
else {
if (isFunction(value)) value = value.apply();
if (this.options.keepNullAttributes && value == null) this.currentNode.attribs[name] = new XMLAttribute(this, name, "");
else if (value != null) this.currentNode.attribs[name] = new XMLAttribute(this, name, value);
}
return this;
}
text(value) {
var node;
this.openCurrent();
node = new XMLText(this, value);
this.onData(this.writer.text(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
cdata(value) {
var node;
this.openCurrent();
node = new XMLCData(this, value);
this.onData(this.writer.cdata(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
comment(value) {
var node;
this.openCurrent();
node = new XMLComment(this, value);
this.onData(this.writer.comment(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
raw(value) {
var node;
this.openCurrent();
node = new XMLRaw(this, value);
this.onData(this.writer.raw(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
instruction(target, value) {
var i$1, insTarget, insValue, len$1, node;
this.openCurrent();
if (target != null) target = getValue(target);
if (value != null) value = getValue(value);
if (Array.isArray(target)) for (i$1 = 0, len$1 = target.length; i$1 < len$1; i$1++) {
insTarget = target[i$1];
this.instruction(insTarget);
}
else if (isObject$2(target)) for (insTarget in target) {
if (!hasProp.call(target, insTarget)) continue;
insValue = target[insTarget];
this.instruction(insTarget, insValue);
}
else {
if (isFunction(value)) value = value.apply();
node = new XMLProcessingInstruction(this, target, value);
this.onData(this.writer.processingInstruction(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
}
return this;
}
declaration(version, encoding, standalone) {
var node;
this.openCurrent();
if (this.documentStarted) throw new Error("declaration() must be the first node.");
node = new XMLDeclaration(this, version, encoding, standalone);
this.onData(this.writer.declaration(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
doctype(root, pubID, sysID) {
this.openCurrent();
if (root == null) throw new Error("Missing root node name.");
if (this.root) throw new Error("dtd() must come before the root node.");
this.currentNode = new XMLDocType(this, pubID, sysID);
this.currentNode.rootNodeName = root;
this.currentNode.children = false;
this.currentLevel++;
this.openTags[this.currentLevel] = this.currentNode;
return this;
}
dtdElement(name, value) {
var node;
this.openCurrent();
node = new XMLDTDElement(this, name, value);
this.onData(this.writer.dtdElement(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
attList(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
var node;
this.openCurrent();
node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
this.onData(this.writer.dtdAttList(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
entity(name, value) {
var node;
this.openCurrent();
node = new XMLDTDEntity(this, false, name, value);
this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
pEntity(name, value) {
var node;
this.openCurrent();
node = new XMLDTDEntity(this, true, name, value);
this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
notation(name, value) {
var node;
this.openCurrent();
node = new XMLDTDNotation(this, name, value);
this.onData(this.writer.dtdNotation(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
return this;
}
up() {
if (this.currentLevel < 0) throw new Error("The document node has no parent.");
if (this.currentNode) {
if (this.currentNode.children) this.closeNode(this.currentNode);
else this.openNode(this.currentNode);
this.currentNode = null;
} else this.closeNode(this.openTags[this.currentLevel]);
delete this.openTags[this.currentLevel];
this.currentLevel--;
return this;
}
end() {
while (this.currentLevel >= 0) this.up();
return this.onEnd();
}
openCurrent() {
if (this.currentNode) {
this.currentNode.children = true;
return this.openNode(this.currentNode);
}
}
openNode(node) {
var att, chunk, name, ref;
if (!node.isOpen) {
if (!this.root && this.currentLevel === 0 && node.type === NodeType$1.Element) this.root = node;
chunk = "";
if (node.type === NodeType$1.Element) {
this.writerOptions.state = WriterState.OpenTag;
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "<" + node.name;
ref = node.attribs;
for (name in ref) {
if (!hasProp.call(ref, name)) continue;
att = ref[name];
chunk += this.writer.attribute(att, this.writerOptions, this.currentLevel);
}
chunk += (node.children ? ">" : "/>") + this.writer.endline(node, this.writerOptions, this.currentLevel);
this.writerOptions.state = WriterState.InsideTag;
} else {
this.writerOptions.state = WriterState.OpenTag;
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "<!DOCTYPE " + node.rootNodeName;
if (node.pubID && node.sysID) chunk += " PUBLIC \"" + node.pubID + "\" \"" + node.sysID + "\"";
else if (node.sysID) chunk += " SYSTEM \"" + node.sysID + "\"";
if (node.children) {
chunk += " [";
this.writerOptions.state = WriterState.InsideTag;
} else {
this.writerOptions.state = WriterState.CloseTag;
chunk += ">";
}
chunk += this.writer.endline(node, this.writerOptions, this.currentLevel);
}
this.onData(chunk, this.currentLevel);
return node.isOpen = true;
}
}
closeNode(node) {
var chunk;
if (!node.isClosed) {
chunk = "";
this.writerOptions.state = WriterState.CloseTag;
if (node.type === NodeType$1.Element) chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "</" + node.name + ">" + this.writer.endline(node, this.writerOptions, this.currentLevel);
else chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "]>" + this.writer.endline(node, this.writerOptions, this.currentLevel);
this.writerOptions.state = WriterState.None;
this.onData(chunk, this.currentLevel);
return node.isClosed = true;
}
}
onData(chunk, level) {
this.documentStarted = true;
return this.onDataCallback(chunk, level + 1);
}
onEnd() {
this.documentCompleted = true;
return this.onEndCallback();
}
debugInfo(name) {
if (name == null) return "";
else return "node: <" + name + ">";
}
ele() {
return this.element(...arguments);
}
nod(name, attributes, text) {
return this.node(name, attributes, text);
}
txt(value) {
return this.text(value);
}
dat(value) {
return this.cdata(value);
}
com(value) {
return this.comment(value);
}
ins(target, value) {
return this.instruction(target, value);
}
dec(version, encoding, standalone) {
return this.declaration(version, encoding, standalone);
}
dtd(root, pubID, sysID) {
return this.doctype(root, pubID, sysID);
}
e(name, attributes, text) {
return this.element(name, attributes, text);
}
n(name, attributes, text) {
return this.node(name, attributes, text);
}
t(value) {
return this.text(value);
}
d(value) {
return this.cdata(value);
}
c(value) {
return this.comment(value);
}
r(value) {
return this.raw(value);
}
i(target, value) {
return this.instruction(target, value);
}
att() {
if (this.currentNode && this.currentNode.type === NodeType$1.DocType) return this.attList(...arguments);
else return this.attribute(...arguments);
}
a() {
if (this.currentNode && this.currentNode.type === NodeType$1.DocType) return this.attList(...arguments);
else return this.attribute(...arguments);
}
ent(name, value) {
return this.entity(name, value);
}
pent(name, value) {
return this.pEntity(name, value);
}
not(name, value) {
return this.notation(name, value);
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLStreamWriter.js
var require_XMLStreamWriter = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/XMLStreamWriter.js"(exports, module) {
(function() {
var NodeType$1, WriterState, XMLStreamWriter, XMLWriterBase, hasProp = {}.hasOwnProperty;
NodeType$1 = require_NodeType();
XMLWriterBase = require_XMLWriterBase();
WriterState = require_WriterState();
module.exports = XMLStreamWriter = class XMLStreamWriter$1 extends XMLWriterBase {
constructor(stream$1, options) {
super(options);
this.stream = stream$1;
}
endline(node, options, level) {
if (node.isLastRootNode && options.state === WriterState.CloseTag) return "";
else return super.endline(node, options, level);
}
document(doc, options) {
var child, i$1, j, k, len1, len2, ref, ref1, results;
ref = doc.children;
for (i$1 = j = 0, len1 = ref.length; j < len1; i$1 = ++j) {
child = ref[i$1];
child.isLastRootNode = i$1 === doc.children.length - 1;
}
options = this.filterOptions(options);
ref1 = doc.children;
results = [];
for (k = 0, len2 = ref1.length; k < len2; k++) {
child = ref1[k];
results.push(this.writeChildNode(child, options, 0));
}
return results;
}
cdata(node, options, level) {
return this.stream.write(super.cdata(node, options, level));
}
comment(node, options, level) {
return this.stream.write(super.comment(node, options, level));
}
declaration(node, options, level) {
return this.stream.write(super.declaration(node, options, level));
}
docType(node, options, level) {
var child, j, len1, ref;
level || (level = 0);
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
this.stream.write(this.indent(node, options, level));
this.stream.write("<!DOCTYPE " + node.root().name);
if (node.pubID && node.sysID) this.stream.write(" PUBLIC \"" + node.pubID + "\" \"" + node.sysID + "\"");
else if (node.sysID) this.stream.write(" SYSTEM \"" + node.sysID + "\"");
if (node.children.length > 0) {
this.stream.write(" [");
this.stream.write(this.endline(node, options, level));
options.state = WriterState.InsideTag;
ref = node.children;
for (j = 0, len1 = ref.length; j < len1; j++) {
child = ref[j];
this.writeChildNode(child, options, level + 1);
}
options.state = WriterState.CloseTag;
this.stream.write("]");
}
options.state = WriterState.CloseTag;
this.stream.write(options.spaceBeforeSlash + ">");
this.stream.write(this.endline(node, options, level));
options.state = WriterState.None;
return this.closeNode(node, options, level);
}
element(node, options, level) {
var att, attLen, child, childNodeCount, firstChildNode, j, len$1, len1, name, prettySuppressed, r, ratt, ref, ref1, ref2, rline;
level || (level = 0);
this.openNode(node, options, level);
options.state = WriterState.OpenTag;
r = this.indent(node, options, level) + "<" + node.name;
if (options.pretty && options.width > 0) {
len$1 = r.length;
ref = node.attribs;
for (name in ref) {
if (!hasProp.call(ref, name)) continue;
att = ref[name];
ratt = this.attribute(att, options, level);
attLen = ratt.length;
if (len$1 + attLen > options.width) {
rline = this.indent(node, options, level + 1) + ratt;
r += this.endline(node, options, level) + rline;
len$1 = rline.length;
} else {
rline = " " + ratt;
r += rline;
len$1 += rline.length;
}
}
} else {
ref1 = node.attribs;
for (name in ref1) {
if (!hasProp.call(ref1, name)) continue;
att = ref1[name];
r += this.attribute(att, options, level);
}
}
this.stream.write(r);
childNodeCount = node.children.length;
firstChildNode = childNodeCount === 0 ? null : node.children[0];
if (childNodeCount === 0 || node.children.every(function(e) {
return (e.type === NodeType$1.Text || e.type === NodeType$1.Raw || e.type === NodeType$1.CData) && e.value === "";
})) if (options.allowEmpty) {
this.stream.write(">");
options.state = WriterState.CloseTag;
this.stream.write("</" + node.name + ">");
} else {
options.state = WriterState.CloseTag;
this.stream.write(options.spaceBeforeSlash + "/>");
}
else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType$1.Text || firstChildNode.type === NodeType$1.Raw || firstChildNode.type === NodeType$1.CData) && firstChildNode.value != null) {
this.stream.write(">");
options.state = WriterState.InsideTag;
options.suppressPrettyCount++;
prettySuppressed = true;
this.writeChildNode(firstChildNode, options, level + 1);
options.suppressPrettyCount--;
prettySuppressed = false;
options.state = WriterState.CloseTag;
this.stream.write("</" + node.name + ">");
} else {
this.stream.write(">" + this.endline(node, options, level));
options.state = WriterState.InsideTag;
ref2 = node.children;
for (j = 0, len1 = ref2.length; j < len1; j++) {
child = ref2[j];
this.writeChildNode(child, options, level + 1);
}
options.state = WriterState.CloseTag;
this.stream.write(this.indent(node, options, level) + "</" + node.name + ">");
}
this.stream.write(this.endline(node, options, level));
options.state = WriterState.None;
return this.closeNode(node, options, level);
}
processingInstruction(node, options, level) {
return this.stream.write(super.processingInstruction(node, options, level));
}
raw(node, options, level) {
return this.stream.write(super.raw(node, options, level));
}
text(node, options, level) {
return this.stream.write(super.text(node, options, level));
}
dtdAttList(node, options, level) {
return this.stream.write(super.dtdAttList(node, options, level));
}
dtdElement(node, options, level) {
return this.stream.write(super.dtdElement(node, options, level));
}
dtdEntity(node, options, level) {
return this.stream.write(super.dtdEntity(node, options, level));
}
dtdNotation(node, options, level) {
return this.stream.write(super.dtdNotation(node, options, level));
}
};
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/index.js
var require_lib = __commonJS({ "../../node_modules/.pnpm/xmlbuilder@15.1.1/node_modules/xmlbuilder/lib/index.js"(exports, module) {
(function() {
var NodeType$1, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign$1, isFunction;
({assign: assign$1, isFunction} = require_Utility());
XMLDOMImplementation = require_XMLDOMImplementation();
XMLDocument = require_XMLDocument();
XMLDocumentCB = require_XMLDocumentCB();
XMLStringWriter = require_XMLStringWriter();
XMLStreamWriter = require_XMLStreamWriter();
NodeType$1 = require_NodeType();
WriterState = require_WriterState();
module.exports.create = function(name, xmldec, doctype, options) {
var doc, root;
if (name == null) throw new Error("Root element needs a name.");
options = assign$1({}, xmldec, doctype, options);
doc = new XMLDocument(options);
root = doc.element(name);
if (!options.headless) {
doc.declaration(options);
if (options.pubID != null || options.sysID != null) doc.dtd(options);
}
return root;
};
module.exports.begin = function(options, onData, onEnd) {
if (isFunction(options)) {
[onData, onEnd] = [options, onData];
options = {};
}
if (onData) return new XMLDocumentCB(options, onData, onEnd);
else return new XMLDocument(options);
};
module.exports.stringWriter = function(options) {
return new XMLStringWriter(options);
};
module.exports.streamWriter = function(stream$1, options) {
return new XMLStreamWriter(stream$1, options);
};
module.exports.implementation = new XMLDOMImplementation();
module.exports.nodeType = NodeType$1;
module.exports.writerState = WriterState;
}).call(void 0);
} });
//#endregion
//#region ../../node_modules/.pnpm/plist@3.1.0/node_modules/plist/lib/build.js
var require_build = __commonJS({ "../../node_modules/.pnpm/plist@3.1.0/node_modules/plist/lib/build.js"(exports) {
/**
* Module dependencies.
*/
var base64 = require_base64_js();
var xmlbuilder = require_lib();
/**
* Module exports.
*/
exports.build = build;
/**
* Accepts a `Date` instance and returns an ISO date string.
*
* @param {Date} d - Date instance to serialize
* @returns {String} ISO date string representation of `d`
* @api private
*/
function ISODateString(d) {
function pad$1(n) {
return n < 10 ? "0" + n : n;
}
return d.getUTCFullYear() + "-" + pad$1(d.getUTCMonth() + 1) + "-" + pad$1(d.getUTCDate()) + "T" + pad$1(d.getUTCHours()) + ":" + pad$1(d.getUTCMinutes()) + ":" + pad$1(d.getUTCSeconds()) + "Z";
}
/**
* Returns the internal "type" of `obj` via the
* `Object.prototype.toString()` trick.
*
* @param {Mixed} obj - any value
* @returns {String} the internal "type" name
* @api private
*/
var toString = Object.prototype.toString;
function type(obj) {
var m = toString.call(obj).match(/\[object (.*)\]/);
return m ? m[1] : m;
}
/**
* Generate an XML plist string from the input object `obj`.
*
* @param {Object} obj - the object to convert
* @param {Object} [opts] - optional options object
* @returns {String} converted plist XML string
* @api public
*/
function build(obj, opts) {
var XMLHDR = {
version: "1.0",
encoding: "UTF-8"
};
var XMLDTD = {
pubid: "-//Apple//DTD PLIST 1.0//EN",
sysid: "http://www.apple.com/DTDs/PropertyList-1.0.dtd"
};
var doc = xmlbuilder.create("plist");
doc.dec(XMLHDR.version, XMLHDR.encoding, XMLHDR.standalone);
doc.dtd(XMLDTD.pubid, XMLDTD.sysid);
doc.att("version", "1.0");
walk_obj(obj, doc);
if (!opts) opts = {};
opts.pretty = opts.pretty !== false;
return doc.end(opts);
}
/**
* depth first, recursive traversal of a javascript object. when complete,
* next_child contains a reference to the build XML object.
*
* @api private
*/
function walk_obj(next, next_child) {
var tag_type, i$1, prop;
var name = type(next);
if ("Undefined" == name) return;
else if (Array.isArray(next)) {
next_child = next_child.ele("array");
for (i$1 = 0; i$1 < next.length; i$1++) walk_obj(next[i$1], next_child);
} else if (Buffer.isBuffer(next)) next_child.ele("data").raw(next.toString("base64"));
else if ("Object" == name) {
next_child = next_child.ele("dict");
for (prop in next) if (next.hasOwnProperty(prop)) {
next_child.ele("key").txt(prop);
walk_obj(next[prop], next_child);
}
} else if ("Number" == name) {
tag_type = next % 1 === 0 ? "integer" : "real";
next_child.ele(tag_type).txt(next.toString());
} else if ("BigInt" == name) next_child.ele("integer").txt(next);
else if ("Date" == name) next_child.ele("date").txt(ISODateString(new Date(next)));
else if ("Boolean" == name) next_child.ele(next ? "true" : "false");
else if ("String" == name) next_child.ele("string").txt(next);
else if ("ArrayBuffer" == name) next_child.ele("data").raw(base64.fromByteArray(next));
else if (next && next.buffer && "ArrayBuffer" == type(next.buffer)) next_child.ele("data").raw(base64.fromByteArray(new Uint8Array(next.buffer), next_child));
else if ("Null" === name) next_child.ele("null").txt("");
}
} });
//#endregion
//#region ../../node_modules/.pnpm/plist@3.1.0/node_modules/plist/index.js
var require_plist = __commonJS({ "../../node_modules/.pnpm/plist@3.1.0/node_modules/plist/index.js"(exports) {
/**
* Parser functions.
*/
var parserFunctions = require_parse();
Object.keys(parserFunctions).forEach(function(k) {
exports[k] = parserFunctions[k];
});
/**
* Builder functions.
*/
var builderFunctions = require_build();
Object.keys(builderFunctions).forEach(function(k) {
exports[k] = builderFunctions[k];
});
} });
//#endregion
//#region src/utils/configParser/iosParser.ts
var import_out$1 = __toESM(require_out());
var import_plist = __toESM(require_plist());
var IosConfigParser = class {
async getPlistPath() {
const [plistFile] = await import_out$1.default.glob("*/Info.plist", {
cwd: path.join(getCwd(), "ios"),
absolute: true,
onlyFiles: true
});
if (!plistFile) return null;
return plistFile;
}
async exists() {
try {
await this.getPlistPath();
return true;
} catch {
return false;
}
}
async get(key) {
try {
const plistFile = await this.getPlistPath();
if (!plistFile) return {
value: null,
path: null
};
const plistXml = await fs$1.promises.readFile(plistFile, "utf-8");
const plistObject = import_plist.default.parse(plistXml);
if (key in plistObject) {
const value = plistObject[key];
if (value === null || value === void 0) return {
value: null,
path: path.relative(getCwd(), plistFile)
};
if (typeof value === "string") return {
value,
path: path.relative(getCwd(), plistFile)
};
return {
value: String(value),
path: path.relative(getCwd(), plistFile)
};
}
return {
value: null,
path: path.relative(getCwd(), plistFile)
};
} catch (error) {
return {
value: null,
path: ""
};
}
}
async set(key, value) {
const plistFile = await this.getPlistPath();
if (!plistFile) {
console.warn("hot-updater: Info.plist not found. Skipping iOS-specific config modifications.");
return { path: null };
}
const plistXml = await fs$1.promises.readFile(plistFile, "utf-8");
const plistObject = import_plist.default.parse(plistXml);
plistObject[key] = value;
const newPlistXml = import_plist.default.build(plistObject, {
indent: " ",
pretty: true
});
await fs$1.promises.writeFile(plistFile, newPlistXml);
return { path: path.relative(getCwd(), plistFile) };
}
};
//#endregion
//#region src/utils/setFingerprintHash.ts
const setAndroidFingerprintHash = async (hash) => {
const androidParser = new AndroidConfigParser();
return await androidParser.set("hot_updater_fingerprint_hash", hash);
};
const setIosFingerprintHash = async (hash) => {
const iosParser = new IosConfigParser();
return await iosParser.set("HOT_UPDATER_FINGERPRINT_HASH", hash);
};
const setFingerprintHash = async (platform, hash) => {
switch (platform) {
case "android": return await setAndroidFingerprintHash(hash);
case "ios": return await setIosFingerprintHash(hash);
}
};
//#endregion
//#region src/utils/fingerprint/processExtraSources.ts
var import_out = __toESM(require_out());
/**
* Processes extra source files and directories for fingerprinting.
* @param extraSources Array of file paths, directory paths, or glob patterns
* @param cwd Current working directory for resolving paths
* @param ignorePaths Optional array of paths to ignore
* @returns Array of processed sources with their contents or directory information
*/
function processExtraSources(extraSources, cwd, ignorePaths) {
const processedSources = [];
for (const source of extraSources) try {
const matches = import_out.default.globSync(source, {
cwd,
ignore: ignorePaths ?? [],
absolute: true,
onlyFiles: false
});
for (const absolutePath of matches) if (fs.existsSync(absolutePath)) {
const stats = fs.statSync(absolutePath);
if (stats.isDirectory()) processedSources.push({
type: "dir",
filePath: absolutePath,
reasons: ["custom-user-config"]
});
else processedSources.push({
type: "contents",
id: absolutePath,
contents: fs.readFileSync(absolutePath, "utf-8"),
reasons: ["custom-user-config"]
});
}
} catch (error) {
console.warn(`Error processing extra source "${source}": ${error}`);
}
return processedSources;
}
//#endregion
//#region src/utils/fingerprint/common.ts
const ensureFingerprintConfig = async () => {
const config = await loadConfig(null);
if (config.updateStrategy === "appVersion") {
p$1.log.error("The updateStrategy in hot-updater.config.ts is set to 'appVersion'. This command only works with 'fingerprint' strategy.");
process.exit(1);
}
return config.fingerprint;
};
function getFingerprintOptions(platform, path$11, options) {
return {
platforms: [platform],
ignorePaths: [
"**/android/**/strings.xml",
"**/ios/**/*.plist",
"**/.gitignore",
...options.ignorePaths
],
extraSources: processExtraSources(options.extraSources, path$11, options.ignorePaths),
debug: options.debug
};
}
function isFingerprintEquals(lhs, rhs) {
if (!lhs || !rhs) return false;
if (isFingerprintResultsObject(lhs) && isFingerprintResultsObject(rhs)) return lhs.android.hash === rhs.android.hash && lhs.ios.hash === rhs.ios.hash;
if (!isFingerprintResultsObject(lhs) && !isFingerprintResultsObject(rhs)) return lhs["hash"] === rhs["hash"];
return false;
function isFingerprintResultsObject(result) {
return typeof result["android"] === "object" && typeof result["ios"] === "object" && !!result["android"]?.hash && !!result["ios"]?.hash;
}
}
//#endregion
//#region src/utils/fingerprint/diff.ts
var import_picocolors = __toESM(require_picocolors());
async function getFingerprintDiff(oldFingerprint, options) {
const projectPath = getCwd();
return await diffFingerprintChangesAsync(oldFingerprint, projectPath, getFingerprintOptions(options.platform, projectPath, options));
}
function getSourcePath(source) {
if (source.type === "file" || source.type === "dir") return source.filePath;
return source.id || source.type;
}
function showFingerprintDiff(diff, platform) {
if (diff.length === 0) return;
p.log.info(`${import_picocolors.default.bold(`${platform} Fingerprint Changes:`)}`);
const added = diff.filter((item) => item.op === "added");
const removed = diff.filter((item) => item.op === "removed");
const changed = diff.filter((item) => item.op === "changed");
if (added.length > 0) p.log.info(` ${import_picocolors.default.green("Added:")} ${added.map((item) => getSourcePath(item.addedSource)).join(", ")}`);
if (removed.length > 0) p.log.info(` ${import_picocolors.default.red("Removed:")} ${removed.map((item) => getSourcePath(item.removedSource)).join(", ")}`);
if (changed.length > 0) p.log.info(` ${import_picocolors.default.yellow("Changed:")} ${changed.map((item) => getSourcePath(item.beforeSource)).join(", ")}`);
}
//#endregion
//#region src/utils/fingerprint/index.ts
/**
* Calculates the fingerprint of the native parts project of the project.
*/
async function nativeFingerprint(path$11, options) {
const platform = options.platform;
return createFingerprintAsync(path$11, getFingerprintOptions(platform, path$11, options));
}
const generateFingerprints = async () => {
const fingerprintConfig = await ensureFingerprintConfig();
const projectPath = getCwd();
const [ios, android] = await Promise.all([nativeFingerprint(projectPath, {
platform: "ios",
...fingerprintConfig
}), nativeFingerprint(projectPath, {
platform: "android",
...fingerprintConfig
})]);
return {
ios,
android
};
};
const generateFingerprint = async (platform) => {
const fingerprintConfig = await ensureFingerprintConfig();
return nativeFingerprint(getCwd(), {
platform,
...fingerprintConfig
});
};
const createAndInjectFingerprintFiles = async ({ platform } = {}) => {
const localFingerprint = await readLocalFingerprint();
const FINGERPRINT_FILE_PATH = path.join(getCwd(), "fingerprint.json");
const newFingerprint = await generateFingerprints();
if (!localFingerprint || !platform) {
await fs$1.promises.writeFile(FINGERPRINT_FILE_PATH, JSON.stringify(newFingerprint, null, 2));
await setFingerprintHash("android", newFingerprint.android.hash);
await setFingerprintHash("ios", newFingerprint.ios.hash);
} else {
const nextFingerprints = {
android: localFingerprint.android || newFingerprint.android,
ios: localFingerprint.ios || newFingerprint.ios,
[platform]: newFingerprint[platform]
};
await fs$1.promises.writeFile(FINGERPRINT_FILE_PATH, JSON.stringify(nextFingerprints, null, 2));
await setFingerprintHash(platform, newFingerprint[platform].hash);
}
return newFingerprint;
};
const readLocalFingerprint = async () => {
const FINGERPRINT_FILE_PATH = path.join(getCwd(), "fingerprint.json");
try {
const content = await fs$1.promises.readFile(FINGERPRINT_FILE_PATH, "utf-8");
return JSON.parse(content);
} catch {
return null;
}
};
//#endregion
export { AndroidConfigParser, IosConfigParser, createAndInjectFingerprintFiles, generateFingerprint, generateFingerprints, getFingerprintDiff, isFingerprintEquals, nativeFingerprint, readLocalFingerprint, require_base64_js, require_out, require_plist, showFingerprintDiff };