@modern-js/libuild
Version:
A tool for building modern JavaScript libraries
1,520 lines (1,519 loc) • 851 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var stdin_exports = {};
__export(stdin_exports, {
DEFAULT_OUTBASE: () => DEFAULT_OUTBASE,
DEFAULT_OUTDIR: () => DEFAULT_OUTDIR,
assetExt: () => assetExt,
assetsPlugin: () => assetsPlugin,
deepMerge: () => deepMerge,
getAssetContents: () => getAssetContents,
isCssModule: () => isCssModule,
isDef: () => isDef,
isObject: () => isObject,
isStyleExt: () => isStyleExt,
loadProcessor: () => loadProcessor,
postcssTransformer: () => postcssTransformer,
rebaseUrls: () => rebaseUrls,
require_lib: () => require_lib2,
require_minimist: () => require_minimist,
require_strip_bom: () => require_strip_bom,
resolvePathAndQuery: () => resolvePathAndQuery
});
module.exports = __toCommonJS(stdin_exports);
var import_chunk_HYZYPRER = require("./chunk-HYZYPRER.js");
var import_querystring = __toESM(require("querystring"));
var import_path = require("path");
var import_fs = __toESM(require("fs"));
var import_crypto = require("crypto");
var import_postcss = __toESM(require("postcss"));
var import_path2 = require("path");
var import_fs2 = __toESM(require("fs"));
var import_path3 = __toESM(require("path"));
var import_crypto2 = require("crypto");
var require_dist = (0, import_chunk_HYZYPRER.__commonJS)({
"../../../node_modules/.pnpm/lilconfig@2.1.0/node_modules/lilconfig/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.lilconfigSync = exports.lilconfig = exports.defaultLoaders = void 0;
var path2 = (0, import_chunk_HYZYPRER.__require)("path");
var fs3 = (0, import_chunk_HYZYPRER.__require)("fs");
var os = (0, import_chunk_HYZYPRER.__require)("os");
var fsReadFileAsync = fs3.promises.readFile;
function getDefaultSearchPlaces(name) {
return [
"package.json",
`.${name}rc.json`,
`.${name}rc.js`,
`.${name}rc.cjs`,
`.config/${name}rc`,
`.config/${name}rc.json`,
`.config/${name}rc.js`,
`.config/${name}rc.cjs`,
`${name}.config.js`,
`${name}.config.cjs`
];
}
function getSearchPaths(startDir, stopDir) {
return startDir.split(path2.sep).reduceRight((acc, _, ind, arr) => {
const currentPath = arr.slice(0, ind + 1).join(path2.sep);
if (!acc.passedStopDir)
acc.searchPlaces.push(currentPath || path2.sep);
if (currentPath === stopDir)
acc.passedStopDir = true;
return acc;
}, { searchPlaces: [], passedStopDir: false }).searchPlaces;
}
exports.defaultLoaders = Object.freeze({
".js": import_chunk_HYZYPRER.__require,
".json": import_chunk_HYZYPRER.__require,
".cjs": import_chunk_HYZYPRER.__require,
noExt(_, content) {
return JSON.parse(content);
}
});
function getExtDesc(ext) {
return ext === "noExt" ? "files without extensions" : `extension "${ext}"`;
}
function getOptions(name, options = {}) {
const conf = {
stopDir: os.homedir(),
searchPlaces: getDefaultSearchPlaces(name),
ignoreEmptySearchPlaces: true,
transform: (x) => x,
packageProp: [name],
...options,
loaders: { ...exports.defaultLoaders, ...options.loaders }
};
conf.searchPlaces.forEach((place) => {
const key = path2.extname(place) || "noExt";
const loader = conf.loaders[key];
if (!loader) {
throw new Error(`No loader specified for ${getExtDesc(key)}, so searchPlaces item "${place}" is invalid`);
}
if (typeof loader !== "function") {
throw new Error(`loader for ${getExtDesc(key)} is not a function (type provided: "${typeof loader}"), so searchPlaces item "${place}" is invalid`);
}
});
return conf;
}
function getPackageProp(props, obj) {
if (typeof props === "string" && props in obj)
return obj[props];
return (Array.isArray(props) ? props : props.split(".")).reduce((acc, prop) => acc === void 0 ? acc : acc[prop], obj) || null;
}
function getSearchItems(searchPlaces, searchPaths) {
return searchPaths.reduce((acc, searchPath) => {
searchPlaces.forEach((sp) => acc.push({
searchPlace: sp,
filepath: path2.join(searchPath, sp),
loaderKey: path2.extname(sp) || "noExt"
}));
return acc;
}, []);
}
function validateFilePath(filepath) {
if (!filepath)
throw new Error("load must pass a non-empty string");
}
function validateLoader(loader, ext) {
if (!loader)
throw new Error(`No loader specified for extension "${ext}"`);
if (typeof loader !== "function")
throw new Error("loader is not a function");
}
function lilconfig(name, options) {
const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform } = getOptions(name, options);
return {
async search(searchFrom = process.cwd()) {
const searchPaths = getSearchPaths(searchFrom, stopDir);
const result = {
config: null,
filepath: ""
};
const searchItems = getSearchItems(searchPlaces, searchPaths);
for (const { searchPlace, filepath, loaderKey } of searchItems) {
try {
await fs3.promises.access(filepath);
} catch (_a) {
continue;
}
const content = String(await fsReadFileAsync(filepath));
const loader = loaders[loaderKey];
if (searchPlace === "package.json") {
const pkg = await loader(filepath, content);
const maybeConfig = getPackageProp(packageProp, pkg);
if (maybeConfig != null) {
result.config = maybeConfig;
result.filepath = filepath;
break;
}
continue;
}
const isEmpty = content.trim() === "";
if (isEmpty && ignoreEmptySearchPlaces)
continue;
if (isEmpty) {
result.isEmpty = true;
result.config = void 0;
} else {
validateLoader(loader, loaderKey);
result.config = await loader(filepath, content);
}
result.filepath = filepath;
break;
}
if (result.filepath === "" && result.config === null)
return transform(null);
return transform(result);
},
async load(filepath) {
validateFilePath(filepath);
const absPath = path2.resolve(process.cwd(), filepath);
const { base, ext } = path2.parse(absPath);
const loaderKey = ext || "noExt";
const loader = loaders[loaderKey];
validateLoader(loader, loaderKey);
const content = String(await fsReadFileAsync(absPath));
if (base === "package.json") {
const pkg = await loader(absPath, content);
return transform({
config: getPackageProp(packageProp, pkg),
filepath: absPath
});
}
const result = {
config: null,
filepath: absPath
};
const isEmpty = content.trim() === "";
if (isEmpty && ignoreEmptySearchPlaces)
return transform({
config: void 0,
filepath: absPath,
isEmpty: true
});
result.config = isEmpty ? void 0 : await loader(absPath, content);
return transform(isEmpty ? { ...result, isEmpty, config: void 0 } : result);
}
};
}
exports.lilconfig = lilconfig;
function lilconfigSync(name, options) {
const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform } = getOptions(name, options);
return {
search(searchFrom = process.cwd()) {
const searchPaths = getSearchPaths(searchFrom, stopDir);
const result = {
config: null,
filepath: ""
};
const searchItems = getSearchItems(searchPlaces, searchPaths);
for (const { searchPlace, filepath, loaderKey } of searchItems) {
try {
fs3.accessSync(filepath);
} catch (_a) {
continue;
}
const loader = loaders[loaderKey];
const content = String(fs3.readFileSync(filepath));
if (searchPlace === "package.json") {
const pkg = loader(filepath, content);
const maybeConfig = getPackageProp(packageProp, pkg);
if (maybeConfig != null) {
result.config = maybeConfig;
result.filepath = filepath;
break;
}
continue;
}
const isEmpty = content.trim() === "";
if (isEmpty && ignoreEmptySearchPlaces)
continue;
if (isEmpty) {
result.isEmpty = true;
result.config = void 0;
} else {
validateLoader(loader, loaderKey);
result.config = loader(filepath, content);
}
result.filepath = filepath;
break;
}
if (result.filepath === "" && result.config === null)
return transform(null);
return transform(result);
},
load(filepath) {
validateFilePath(filepath);
const absPath = path2.resolve(process.cwd(), filepath);
const { base, ext } = path2.parse(absPath);
const loaderKey = ext || "noExt";
const loader = loaders[loaderKey];
validateLoader(loader, loaderKey);
const content = String(fs3.readFileSync(absPath));
if (base === "package.json") {
const pkg = loader(absPath, content);
return transform({
config: getPackageProp(packageProp, pkg),
filepath: absPath
});
}
const result = {
config: null,
filepath: absPath
};
const isEmpty = content.trim() === "";
if (isEmpty && ignoreEmptySearchPlaces)
return transform({
filepath: absPath,
config: void 0,
isEmpty: true
});
result.config = isEmpty ? void 0 : loader(absPath, content);
return transform(isEmpty ? { ...result, isEmpty, config: void 0 } : result);
}
};
}
exports.lilconfigSync = lilconfigSync;
}
});
var require_PlainValue_ec8e588e = (0, import_chunk_HYZYPRER.__commonJS)({
"../../../node_modules/.pnpm/yaml@1.10.2/node_modules/yaml/dist/PlainValue-ec8e588e.js"(exports) {
"use strict";
var Char = {
ANCHOR: "&",
COMMENT: "#",
TAG: "!",
DIRECTIVES_END: "-",
DOCUMENT_END: "."
};
var Type = {
ALIAS: "ALIAS",
BLANK_LINE: "BLANK_LINE",
BLOCK_FOLDED: "BLOCK_FOLDED",
BLOCK_LITERAL: "BLOCK_LITERAL",
COMMENT: "COMMENT",
DIRECTIVE: "DIRECTIVE",
DOCUMENT: "DOCUMENT",
FLOW_MAP: "FLOW_MAP",
FLOW_SEQ: "FLOW_SEQ",
MAP: "MAP",
MAP_KEY: "MAP_KEY",
MAP_VALUE: "MAP_VALUE",
PLAIN: "PLAIN",
QUOTE_DOUBLE: "QUOTE_DOUBLE",
QUOTE_SINGLE: "QUOTE_SINGLE",
SEQ: "SEQ",
SEQ_ITEM: "SEQ_ITEM"
};
var defaultTagPrefix = "tag:yaml.org,2002:";
var defaultTags = {
MAP: "tag:yaml.org,2002:map",
SEQ: "tag:yaml.org,2002:seq",
STR: "tag:yaml.org,2002:str"
};
function findLineStarts(src) {
const ls = [0];
let offset = src.indexOf("\n");
while (offset !== -1) {
offset += 1;
ls.push(offset);
offset = src.indexOf("\n", offset);
}
return ls;
}
function getSrcInfo(cst) {
let lineStarts, src;
if (typeof cst === "string") {
lineStarts = findLineStarts(cst);
src = cst;
} else {
if (Array.isArray(cst))
cst = cst[0];
if (cst && cst.context) {
if (!cst.lineStarts)
cst.lineStarts = findLineStarts(cst.context.src);
lineStarts = cst.lineStarts;
src = cst.context.src;
}
}
return {
lineStarts,
src
};
}
function getLinePos(offset, cst) {
if (typeof offset !== "number" || offset < 0)
return null;
const {
lineStarts,
src
} = getSrcInfo(cst);
if (!lineStarts || !src || offset > src.length)
return null;
for (let i = 0; i < lineStarts.length; ++i) {
const start = lineStarts[i];
if (offset < start) {
return {
line: i,
col: offset - lineStarts[i - 1] + 1
};
}
if (offset === start)
return {
line: i + 1,
col: 1
};
}
const line = lineStarts.length;
return {
line,
col: offset - lineStarts[line - 1] + 1
};
}
function getLine(line, cst) {
const {
lineStarts,
src
} = getSrcInfo(cst);
if (!lineStarts || !(line >= 1) || line > lineStarts.length)
return null;
const start = lineStarts[line - 1];
let end = lineStarts[line];
while (end && end > start && src[end - 1] === "\n")
--end;
return src.slice(start, end);
}
function getPrettyContext({
start,
end
}, cst, maxWidth = 80) {
let src = getLine(start.line, cst);
if (!src)
return null;
let {
col
} = start;
if (src.length > maxWidth) {
if (col <= maxWidth - 10) {
src = src.substr(0, maxWidth - 1) + "\u2026";
} else {
const halfWidth = Math.round(maxWidth / 2);
if (src.length > col + halfWidth)
src = src.substr(0, col + halfWidth - 1) + "\u2026";
col -= src.length - maxWidth;
src = "\u2026" + src.substr(1 - maxWidth);
}
}
let errLen = 1;
let errEnd = "";
if (end) {
if (end.line === start.line && col + (end.col - start.col) <= maxWidth + 1) {
errLen = end.col - start.col;
} else {
errLen = Math.min(src.length + 1, maxWidth) - col;
errEnd = "\u2026";
}
}
const offset = col > 1 ? " ".repeat(col - 1) : "";
const err = "^".repeat(errLen);
return `${src}
${offset}${err}${errEnd}`;
}
var Range = class {
static copy(orig) {
return new Range(orig.start, orig.end);
}
constructor(start, end) {
this.start = start;
this.end = end || start;
}
isEmpty() {
return typeof this.start !== "number" || !this.end || this.end <= this.start;
}
/**
* Set `origStart` and `origEnd` to point to the original source range for
* this node, which may differ due to dropped CR characters.
*
* @param {number[]} cr - Positions of dropped CR characters
* @param {number} offset - Starting index of `cr` from the last call
* @returns {number} - The next offset, matching the one found for `origStart`
*/
setOrigRange(cr, offset) {
const {
start,
end
} = this;
if (cr.length === 0 || end <= cr[0]) {
this.origStart = start;
this.origEnd = end;
return offset;
}
let i = offset;
while (i < cr.length) {
if (cr[i] > start)
break;
else
++i;
}
this.origStart = start + i;
const nextOffset = i;
while (i < cr.length) {
if (cr[i] >= end)
break;
else
++i;
}
this.origEnd = end + i;
return nextOffset;
}
};
var Node = class {
static addStringTerminator(src, offset, str) {
if (str[str.length - 1] === "\n")
return str;
const next = Node.endOfWhiteSpace(src, offset);
return next >= src.length || src[next] === "\n" ? str + "\n" : str;
}
// ^(---|...)
static atDocumentBoundary(src, offset, sep) {
const ch0 = src[offset];
if (!ch0)
return true;
const prev = src[offset - 1];
if (prev && prev !== "\n")
return false;
if (sep) {
if (ch0 !== sep)
return false;
} else {
if (ch0 !== Char.DIRECTIVES_END && ch0 !== Char.DOCUMENT_END)
return false;
}
const ch1 = src[offset + 1];
const ch2 = src[offset + 2];
if (ch1 !== ch0 || ch2 !== ch0)
return false;
const ch3 = src[offset + 3];
return !ch3 || ch3 === "\n" || ch3 === " " || ch3 === " ";
}
static endOfIdentifier(src, offset) {
let ch = src[offset];
const isVerbatim = ch === "<";
const notOk = isVerbatim ? ["\n", " ", " ", ">"] : ["\n", " ", " ", "[", "]", "{", "}", ","];
while (ch && notOk.indexOf(ch) === -1)
ch = src[offset += 1];
if (isVerbatim && ch === ">")
offset += 1;
return offset;
}
static endOfIndent(src, offset) {
let ch = src[offset];
while (ch === " ")
ch = src[offset += 1];
return offset;
}
static endOfLine(src, offset) {
let ch = src[offset];
while (ch && ch !== "\n")
ch = src[offset += 1];
return offset;
}
static endOfWhiteSpace(src, offset) {
let ch = src[offset];
while (ch === " " || ch === " ")
ch = src[offset += 1];
return offset;
}
static startOfLine(src, offset) {
let ch = src[offset - 1];
if (ch === "\n")
return offset;
while (ch && ch !== "\n")
ch = src[offset -= 1];
return offset + 1;
}
/**
* End of indentation, or null if the line's indent level is not more
* than `indent`
*
* @param {string} src
* @param {number} indent
* @param {number} lineStart
* @returns {?number}
*/
static endOfBlockIndent(src, indent, lineStart) {
const inEnd = Node.endOfIndent(src, lineStart);
if (inEnd > lineStart + indent) {
return inEnd;
} else {
const wsEnd = Node.endOfWhiteSpace(src, inEnd);
const ch = src[wsEnd];
if (!ch || ch === "\n")
return wsEnd;
}
return null;
}
static atBlank(src, offset, endAsBlank) {
const ch = src[offset];
return ch === "\n" || ch === " " || ch === " " || endAsBlank && !ch;
}
static nextNodeIsIndented(ch, indentDiff, indicatorAsIndent) {
if (!ch || indentDiff < 0)
return false;
if (indentDiff > 0)
return true;
return indicatorAsIndent && ch === "-";
}
// should be at line or string end, or at next non-whitespace char
static normalizeOffset(src, offset) {
const ch = src[offset];
return !ch ? offset : ch !== "\n" && src[offset - 1] === "\n" ? offset - 1 : Node.endOfWhiteSpace(src, offset);
}
// fold single newline into space, multiple newlines to N - 1 newlines
// presumes src[offset] === '\n'
static foldNewline(src, offset, indent) {
let inCount = 0;
let error = false;
let fold = "";
let ch = src[offset + 1];
while (ch === " " || ch === " " || ch === "\n") {
switch (ch) {
case "\n":
inCount = 0;
offset += 1;
fold += "\n";
break;
case " ":
if (inCount <= indent)
error = true;
offset = Node.endOfWhiteSpace(src, offset + 2) - 1;
break;
case " ":
inCount += 1;
offset += 1;
break;
}
ch = src[offset + 1];
}
if (!fold)
fold = " ";
if (ch && inCount <= indent)
error = true;
return {
fold,
offset,
error
};
}
constructor(type, props, context) {
Object.defineProperty(this, "context", {
value: context || null,
writable: true
});
this.error = null;
this.range = null;
this.valueRange = null;
this.props = props || [];
this.type = type;
this.value = null;
}
getPropValue(idx, key, skipKey) {
if (!this.context)
return null;
const {
src
} = this.context;
const prop = this.props[idx];
return prop && src[prop.start] === key ? src.slice(prop.start + (skipKey ? 1 : 0), prop.end) : null;
}
get anchor() {
for (let i = 0; i < this.props.length; ++i) {
const anchor = this.getPropValue(i, Char.ANCHOR, true);
if (anchor != null)
return anchor;
}
return null;
}
get comment() {
const comments = [];
for (let i = 0; i < this.props.length; ++i) {
const comment = this.getPropValue(i, Char.COMMENT, true);
if (comment != null)
comments.push(comment);
}
return comments.length > 0 ? comments.join("\n") : null;
}
commentHasRequiredWhitespace(start) {
const {
src
} = this.context;
if (this.header && start === this.header.end)
return false;
if (!this.valueRange)
return false;
const {
end
} = this.valueRange;
return start !== end || Node.atBlank(src, end - 1);
}
get hasComment() {
if (this.context) {
const {
src
} = this.context;
for (let i = 0; i < this.props.length; ++i) {
if (src[this.props[i].start] === Char.COMMENT)
return true;
}
}
return false;
}
get hasProps() {
if (this.context) {
const {
src
} = this.context;
for (let i = 0; i < this.props.length; ++i) {
if (src[this.props[i].start] !== Char.COMMENT)
return true;
}
}
return false;
}
get includesTrailingLines() {
return false;
}
get jsonLike() {
const jsonLikeTypes = [Type.FLOW_MAP, Type.FLOW_SEQ, Type.QUOTE_DOUBLE, Type.QUOTE_SINGLE];
return jsonLikeTypes.indexOf(this.type) !== -1;
}
get rangeAsLinePos() {
if (!this.range || !this.context)
return void 0;
const start = getLinePos(this.range.start, this.context.root);
if (!start)
return void 0;
const end = getLinePos(this.range.end, this.context.root);
return {
start,
end
};
}
get rawValue() {
if (!this.valueRange || !this.context)
return null;
const {
start,
end
} = this.valueRange;
return this.context.src.slice(start, end);
}
get tag() {
for (let i = 0; i < this.props.length; ++i) {
const tag = this.getPropValue(i, Char.TAG, false);
if (tag != null) {
if (tag[1] === "<") {
return {
verbatim: tag.slice(2, -1)
};
} else {
const [_, handle, suffix] = tag.match(/^(.*!)([^!]*)$/);
return {
handle,
suffix
};
}
}
}
return null;
}
get valueRangeContainsNewline() {
if (!this.valueRange || !this.context)
return false;
const {
start,
end
} = this.valueRange;
const {
src
} = this.context;
for (let i = start; i < end; ++i) {
if (src[i] === "\n")
return true;
}
return false;
}
parseComment(start) {
const {
src
} = this.context;
if (src[start] === Char.COMMENT) {
const end = Node.endOfLine(src, start + 1);
const commentRange = new Range(start, end);
this.props.push(commentRange);
return end;
}
return start;
}
/**
* Populates the `origStart` and `origEnd` values of all ranges for this
* node. Extended by child classes to handle descendant nodes.
*
* @param {number[]} cr - Positions of dropped CR characters
* @param {number} offset - Starting index of `cr` from the last call
* @returns {number} - The next offset, matching the one found for `origStart`
*/
setOrigRanges(cr, offset) {
if (this.range)
offset = this.range.setOrigRange(cr, offset);
if (this.valueRange)
this.valueRange.setOrigRange(cr, offset);
this.props.forEach((prop) => prop.setOrigRange(cr, offset));
return offset;
}
toString() {
const {
context: {
src
},
range,
value: value2
} = this;
if (value2 != null)
return value2;
const str = src.slice(range.start, range.end);
return Node.addStringTerminator(src, range.end, str);
}
};
var YAMLError = class extends Error {
constructor(name, source, message) {
if (!message || !(source instanceof Node))
throw new Error(`Invalid arguments for new ${name}`);
super();
this.name = name;
this.message = message;
this.source = source;
}
makePretty() {
if (!this.source)
return;
this.nodeType = this.source.type;
const cst = this.source.context && this.source.context.root;
if (typeof this.offset === "number") {
this.range = new Range(this.offset, this.offset + 1);
const start = cst && getLinePos(this.offset, cst);
if (start) {
const end = {
line: start.line,
col: start.col + 1
};
this.linePos = {
start,
end
};
}
delete this.offset;
} else {
this.range = this.source.range;
this.linePos = this.source.rangeAsLinePos;
}
if (this.linePos) {
const {
line,
col
} = this.linePos.start;
this.message += ` at line ${line}, column ${col}`;
const ctx = cst && getPrettyContext(this.linePos, cst);
if (ctx)
this.message += `:
${ctx}
`;
}
delete this.source;
}
};
var YAMLReferenceError = class extends YAMLError {
constructor(source, message) {
super("YAMLReferenceError", source, message);
}
};
var YAMLSemanticError = class extends YAMLError {
constructor(source, message) {
super("YAMLSemanticError", source, message);
}
};
var YAMLSyntaxError = class extends YAMLError {
constructor(source, message) {
super("YAMLSyntaxError", source, message);
}
};
var YAMLWarning = class extends YAMLError {
constructor(source, message) {
super("YAMLWarning", source, message);
}
};
function _defineProperty(obj, key, value2) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value2,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value2;
}
return obj;
}
var PlainValue = class extends Node {
static endOfLine(src, start, inFlow) {
let ch = src[start];
let offset = start;
while (ch && ch !== "\n") {
if (inFlow && (ch === "[" || ch === "]" || ch === "{" || ch === "}" || ch === ","))
break;
const next = src[offset + 1];
if (ch === ":" && (!next || next === "\n" || next === " " || next === " " || inFlow && next === ","))
break;
if ((ch === " " || ch === " ") && next === "#")
break;
offset += 1;
ch = next;
}
return offset;
}
get strValue() {
if (!this.valueRange || !this.context)
return null;
let {
start,
end
} = this.valueRange;
const {
src
} = this.context;
let ch = src[end - 1];
while (start < end && (ch === "\n" || ch === " " || ch === " "))
ch = src[--end - 1];
let str = "";
for (let i = start; i < end; ++i) {
const ch2 = src[i];
if (ch2 === "\n") {
const {
fold,
offset
} = Node.foldNewline(src, i, -1);
str += fold;
i = offset;
} else if (ch2 === " " || ch2 === " ") {
const wsStart = i;
let next = src[i + 1];
while (i < end && (next === " " || next === " ")) {
i += 1;
next = src[i + 1];
}
if (next !== "\n")
str += i > wsStart ? src.slice(wsStart, i + 1) : ch2;
} else {
str += ch2;
}
}
const ch0 = src[start];
switch (ch0) {
case " ": {
const msg = "Plain value cannot start with a tab character";
const errors = [new YAMLSemanticError(this, msg)];
return {
errors,
str
};
}
case "@":
case "`": {
const msg = `Plain value cannot start with reserved character ${ch0}`;
const errors = [new YAMLSemanticError(this, msg)];
return {
errors,
str
};
}
default:
return str;
}
}
parseBlockValue(start) {
const {
indent,
inFlow,
src
} = this.context;
let offset = start;
let valueEnd = start;
for (let ch = src[offset]; ch === "\n"; ch = src[offset]) {
if (Node.atDocumentBoundary(src, offset + 1))
break;
const end = Node.endOfBlockIndent(src, indent, offset + 1);
if (end === null || src[end] === "#")
break;
if (src[end] === "\n") {
offset = end;
} else {
valueEnd = PlainValue.endOfLine(src, end, inFlow);
offset = valueEnd;
}
}
if (this.valueRange.isEmpty())
this.valueRange.start = start;
this.valueRange.end = valueEnd;
return valueEnd;
}
/**
* Parses a plain value from the source
*
* Accepted forms are:
* ```
* #comment
*
* first line
*
* first line #comment
*
* first line
* block
* lines
*
* #comment
* block
* lines
* ```
* where block lines are empty or have an indent level greater than `indent`.
*
* @param {ParseContext} context
* @param {number} start - Index of first character
* @returns {number} - Index of the character after this scalar, may be `\n`
*/
parse(context, start) {
this.context = context;
const {
inFlow,
src
} = context;
let offset = start;
const ch = src[offset];
if (ch && ch !== "#" && ch !== "\n") {
offset = PlainValue.endOfLine(src, start, inFlow);
}
this.valueRange = new Range(start, offset);
offset = Node.endOfWhiteSpace(src, offset);
offset = this.parseComment(offset);
if (!this.hasComment || this.valueRange.isEmpty()) {
offset = this.parseBlockValue(offset);
}
return offset;
}
};
exports.Char = Char;
exports.Node = Node;
exports.PlainValue = PlainValue;
exports.Range = Range;
exports.Type = Type;
exports.YAMLError = YAMLError;
exports.YAMLReferenceError = YAMLReferenceError;
exports.YAMLSemanticError = YAMLSemanticError;
exports.YAMLSyntaxError = YAMLSyntaxError;
exports.YAMLWarning = YAMLWarning;
exports._defineProperty = _defineProperty;
exports.defaultTagPrefix = defaultTagPrefix;
exports.defaultTags = defaultTags;
}
});
var require_parse_cst = (0, import_chunk_HYZYPRER.__commonJS)({
"../../../node_modules/.pnpm/yaml@1.10.2/node_modules/yaml/dist/parse-cst.js"(exports) {
"use strict";
var PlainValue = require_PlainValue_ec8e588e();
var BlankLine = class extends PlainValue.Node {
constructor() {
super(PlainValue.Type.BLANK_LINE);
}
/* istanbul ignore next */
get includesTrailingLines() {
return true;
}
/**
* Parses a blank line from the source
*
* @param {ParseContext} context
* @param {number} start - Index of first \n character
* @returns {number} - Index of the character after this
*/
parse(context, start) {
this.context = context;
this.range = new PlainValue.Range(start, start + 1);
return start + 1;
}
};
var CollectionItem = class extends PlainValue.Node {
constructor(type, props) {
super(type, props);
this.node = null;
}
get includesTrailingLines() {
return !!this.node && this.node.includesTrailingLines;
}
/**
* @param {ParseContext} context
* @param {number} start - Index of first character
* @returns {number} - Index of the character after this
*/
parse(context, start) {
this.context = context;
const {
parseNode,
src
} = context;
let {
atLineStart,
lineStart
} = context;
if (!atLineStart && this.type === PlainValue.Type.SEQ_ITEM)
this.error = new PlainValue.YAMLSemanticError(this, "Sequence items must not have preceding content on the same line");
const indent = atLineStart ? start - lineStart : context.indent;
let offset = PlainValue.Node.endOfWhiteSpace(src, start + 1);
let ch = src[offset];
const inlineComment = ch === "#";
const comments = [];
let blankLine = null;
while (ch === "\n" || ch === "#") {
if (ch === "#") {
const end2 = PlainValue.Node.endOfLine(src, offset + 1);
comments.push(new PlainValue.Range(offset, end2));
offset = end2;
} else {
atLineStart = true;
lineStart = offset + 1;
const wsEnd = PlainValue.Node.endOfWhiteSpace(src, lineStart);
if (src[wsEnd] === "\n" && comments.length === 0) {
blankLine = new BlankLine();
lineStart = blankLine.parse({
src
}, lineStart);
}
offset = PlainValue.Node.endOfIndent(src, lineStart);
}
ch = src[offset];
}
if (PlainValue.Node.nextNodeIsIndented(ch, offset - (lineStart + indent), this.type !== PlainValue.Type.SEQ_ITEM)) {
this.node = parseNode({
atLineStart,
inCollection: false,
indent,
lineStart,
parent: this
}, offset);
} else if (ch && lineStart > start + 1) {
offset = lineStart - 1;
}
if (this.node) {
if (blankLine) {
const items = context.parent.items || context.parent.contents;
if (items)
items.push(blankLine);
}
if (comments.length)
Array.prototype.push.apply(this.props, comments);
offset = this.node.range.end;
} else {
if (inlineComment) {
const c = comments[0];
this.props.push(c);
offset = c.end;
} else {
offset = PlainValue.Node.endOfLine(src, start + 1);
}
}
const end = this.node ? this.node.valueRange.end : offset;
this.valueRange = new PlainValue.Range(start, end);
return offset;
}
setOrigRanges(cr, offset) {
offset = super.setOrigRanges(cr, offset);
return this.node ? this.node.setOrigRanges(cr, offset) : offset;
}
toString() {
const {
context: {
src
},
node,
range,
value: value2
} = this;
if (value2 != null)
return value2;
const str = node ? src.slice(range.start, node.range.start) + String(node) : src.slice(range.start, range.end);
return PlainValue.Node.addStringTerminator(src, range.end, str);
}
};
var Comment = class extends PlainValue.Node {
constructor() {
super(PlainValue.Type.COMMENT);
}
/**
* Parses a comment line from the source
*
* @param {ParseContext} context
* @param {number} start - Index of first character
* @returns {number} - Index of the character after this scalar
*/
parse(context, start) {
this.context = context;
const offset = this.parseComment(start);
this.range = new PlainValue.Range(start, offset);
return offset;
}
};
function grabCollectionEndComments(node) {
let cnode = node;
while (cnode instanceof CollectionItem)
cnode = cnode.node;
if (!(cnode instanceof Collection))
return null;
const len = cnode.items.length;
let ci = -1;
for (let i = len - 1; i >= 0; --i) {
const n = cnode.items[i];
if (n.type === PlainValue.Type.COMMENT) {
const {
indent,
lineStart
} = n.context;
if (indent > 0 && n.range.start >= lineStart + indent)
break;
ci = i;
} else if (n.type === PlainValue.Type.BLANK_LINE)
ci = i;
else
break;
}
if (ci === -1)
return null;
const ca = cnode.items.splice(ci, len - ci);
const prevEnd = ca[0].range.start;
while (true) {
cnode.range.end = prevEnd;
if (cnode.valueRange && cnode.valueRange.end > prevEnd)
cnode.valueRange.end = prevEnd;
if (cnode === node)
break;
cnode = cnode.context.parent;
}
return ca;
}
var Collection = class extends PlainValue.Node {
static nextContentHasIndent(src, offset, indent) {
const lineStart = PlainValue.Node.endOfLine(src, offset) + 1;
offset = PlainValue.Node.endOfWhiteSpace(src, lineStart);
const ch = src[offset];
if (!ch)
return false;
if (offset >= lineStart + indent)
return true;
if (ch !== "#" && ch !== "\n")
return false;
return Collection.nextContentHasIndent(src, offset, indent);
}
constructor(firstItem) {
super(firstItem.type === PlainValue.Type.SEQ_ITEM ? PlainValue.Type.SEQ : PlainValue.Type.MAP);
for (let i = firstItem.props.length - 1; i >= 0; --i) {
if (firstItem.props[i].start < firstItem.context.lineStart) {
this.props = firstItem.props.slice(0, i + 1);
firstItem.props = firstItem.props.slice(i + 1);
const itemRange = firstItem.props[0] || firstItem.valueRange;
firstItem.range.start = itemRange.start;
break;
}
}
this.items = [firstItem];
const ec = grabCollectionEndComments(firstItem);
if (ec)
Array.prototype.push.apply(this.items, ec);
}
get includesTrailingLines() {
return this.items.length > 0;
}
/**
* @param {ParseContext} context
* @param {number} start - Index of first character
* @returns {number} - Index of the character after this
*/
parse(context, start) {
this.context = context;
const {
parseNode,
src
} = context;
let lineStart = PlainValue.Node.startOfLine(src, start);
const firstItem = this.items[0];
firstItem.context.parent = this;
this.valueRange = PlainValue.Range.copy(firstItem.valueRange);
const indent = firstItem.range.start - firstItem.context.lineStart;
let offset = start;
offset = PlainValue.Node.normalizeOffset(src, offset);
let ch = src[offset];
let atLineStart = PlainValue.Node.endOfWhiteSpace(src, lineStart) === offset;
let prevIncludesTrailingLines = false;
while (ch) {
while (ch === "\n" || ch === "#") {
if (atLineStart && ch === "\n" && !prevIncludesTrailingLines) {
const blankLine = new BlankLine();
offset = blankLine.parse({
src
}, offset);
this.valueRange.end = offset;
if (offset >= src.length) {
ch = null;
break;
}
this.items.push(blankLine);
offset -= 1;
} else if (ch === "#") {
if (offset < lineStart + indent && !Collection.nextContentHasIndent(src, offset, indent)) {
return offset;
}
const comment = new Comment();
offset = comment.parse({
indent,
lineStart,
src
}, offset);
this.items.push(comment);
this.valueRange.end = offset;
if (offset >= src.length) {
ch = null;
break;
}
}
lineStart = offset + 1;
offset = PlainValue.Node.endOfIndent(src, lineStart);
if (PlainValue.Node.atBlank(src, offset)) {
const wsEnd = PlainValue.Node.endOfWhiteSpace(src, offset);
const next = src[wsEnd];
if (!next || next === "\n" || next === "#") {
offset = wsEnd;
}
}
ch = src[offset];
atLineStart = true;
}
if (!ch) {
break;
}
if (offset !== lineStart + indent && (atLineStart || ch !== ":")) {
if (offset < lineStart + indent) {
if (lineStart > start)
offset = lineStart;
break;
} else if (!this.error) {
const msg = "All collection items must start at the same column";
this.error = new PlainValue.YAMLSyntaxError(this, msg);
}
}
if (firstItem.type === PlainValue.Type.SEQ_ITEM) {
if (ch !== "-") {
if (lineStart > start)
offset = lineStart;
break;
}
} else if (ch === "-" && !this.error) {
const next = src[offset + 1];
if (!next || next === "\n" || next === " " || next === " ") {
const msg = "A collection cannot be both a mapping and a sequence";
this.error = new PlainValue.YAMLSyntaxError(this, msg);
}
}
const node = parseNode({
atLineStart,
inCollection: true,
indent,
lineStart,
parent: this
}, offset);
if (!node)
return offset;
this.items.push(node);
this.valueRange.end = node.valueRange.end;
offset = PlainValue.Node.normalizeOffset(src, node.range.end);
ch = src[offset];
atLineStart = false;
prevIncludesTrailingLines = node.includesTrailingLines;
if (ch) {
let ls = offset - 1;
let prev = src[ls];
while (prev === " " || prev === " ")
prev = src[--ls];
if (prev === "\n") {
lineStart = ls + 1;
atLineStart = true;
}
}
const ec = grabCollectionEndComments(node);
if (ec)
Array.prototype.push.apply(this.items, ec);
}
return offset;
}
setOrigRanges(cr, offset) {
offset = super.setOrigRanges(cr, offset);
this.items.forEach((node) => {
offset = node.setOrigRanges(cr, offset);
});
return offset;
}
toString() {
const {
context: {
src
},
items,
range,
value: value2
} = this;
if (value2 != null)
return value2;
let str = src.slice(range.start, items[0].range.start) + String(items[0]);
for (let i = 1; i < items.length; ++i) {
const item = items[i];
const {
atLineStart,
indent
} = item.context;
if (atLineStart)
for (let i2 = 0; i2 < indent; ++i2)
str += " ";
str += String(item);
}
return PlainValue.Node.addStringTerminator(src, range.end, str);
}
};
var Directive = class extends PlainValue.Node {
constructor() {
super(PlainValue.Type.DIRECTIVE);
this.name = null;
}
get parameters() {
const raw = this.rawValue;
return raw ? raw.trim().split(/[ \t]+/) : [];
}
parseName(start) {
const {
src
} = this.context;
let offset = start;
let ch = src[offset];
while (ch && ch !== "\n" && ch !== " " && ch !== " ")
ch = src[offset += 1];
this.name = src.slice(start, offset);
return offset;
}
parseParameters(start) {
const {
src
} = this.context;
let offset = start;
let ch = src[offset];
while (ch && ch !== "\n" && ch !== "#")
ch = src[offset += 1];
this.valueRange = new PlainValue.Range(start, offset);
return offset;
}
parse(context, start) {
this.context = context;
let offset = this.parseName(start + 1);
offset = this.parseParameters(offset);
offset = this.parseComment(offset);
this.range = new PlainValue.Range(start, offset);
return offset;
}
};
var Document = class extends PlainValue.Node {
static startCommentOrEndBlankLine(src, start) {
const offset = PlainValue.Node.endOfWhiteSpace(src, start);
const ch = src[offset];
return ch === "#" || ch === "\n" ? offset : start;
}
constructor() {
super(PlainValue.Type.DOCUMENT);
this.directives = null;
this.contents = null;
this.directivesEndMarker = null;
this.documentEndMarker = null;
}
parseDirectives(start) {
const {
src
} = this.context;
this.directives = [];
let atLineStart = true;
let hasDirectives = false;
let offset = start;
while (!PlainValue.Node.atDocumentBoundary(src, offset, PlainValue.Char.DIRECTIVES_END)) {
offset = Document.startCommentOrEndBlankLine(src, offset);
switch (src[offset]) {
case "\n":
if (atLineStart) {
const blankLine = new BlankLine();
offset = blankLine.parse({
src
}, offset);
if (offset < src.length) {
this.directives.push(blankLine);
}
} else {
offset += 1;
atLineStart = true;
}
break;
case "#":
{
const comment = new Comment();
offset = comment.parse({
src
}, offset);
this.directives.push(comment);
atLineStart = false;
}
break;
case "%":
{
const directive = new Directive();
offset = directive.parse({
parent: this,
src
},