cngpac 0.0.1

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/YAMLSeq.mjs

@@ -0,0 +1,115 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+import { require_toJS } from "./toJS.mjs";
+import { require_Scalar } from "./Scalar.mjs";
+import { require_createNode } from "../doc/createNode.mjs";
+import { require_Collection } from "./Collection.mjs";
+import { require_stringifyCollection } from "../stringify/stringifyCollection.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/YAMLSeq.js
+var require_YAMLSeq = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var createNode = require_createNode();
+	var stringifyCollection = require_stringifyCollection();
+	var Collection = require_Collection();
+	var identity = require_identity();
+	var Scalar = require_Scalar();
+	var toJS = require_toJS();
+	var YAMLSeq = class extends Collection.Collection {
+		static get tagName() {
+			return "tag:yaml.org,2002:seq";
+		}
+		constructor(schema) {
+			super(identity.SEQ, schema);
+			this.items = [];
+		}
+		add(value) {
+			this.items.push(value);
+		}
+		/**
+		* Removes a value from the collection.
+		*
+		* `key` must contain a representation of an integer for this to succeed.
+		* It may be wrapped in a `Scalar`.
+		*
+		* @returns `true` if the item was found and removed.
+		*/
+		delete(key) {
+			const idx = asItemIndex(key);
+			if (typeof idx !== "number") return false;
+			return this.items.splice(idx, 1).length > 0;
+		}
+		get(key, keepScalar) {
+			const idx = asItemIndex(key);
+			if (typeof idx !== "number") return void 0;
+			const it = this.items[idx];
+			return !keepScalar && identity.isScalar(it) ? it.value : it;
+		}
+		/**
+		* Checks if the collection includes a value with the key `key`.
+		*
+		* `key` must contain a representation of an integer for this to succeed.
+		* It may be wrapped in a `Scalar`.
+		*/
+		has(key) {
+			const idx = asItemIndex(key);
+			return typeof idx === "number" && idx < this.items.length;
+		}
+		/**
+		* Sets a value in this collection. For `!!set`, `value` needs to be a
+		* boolean to add/remove the item from the set.
+		*
+		* If `key` does not contain a representation of an integer, this will throw.
+		* It may be wrapped in a `Scalar`.
+		*/
+		set(key, value) {
+			const idx = asItemIndex(key);
+			if (typeof idx !== "number") throw new Error(`Expected a valid index, not ${key}.`);
+			const prev = this.items[idx];
+			if (identity.isScalar(prev) && Scalar.isScalarValue(value)) prev.value = value;
+			else this.items[idx] = value;
+		}
+		toJSON(_, ctx) {
+			const seq = [];
+			if (ctx?.onCreate) ctx.onCreate(seq);
+			let i = 0;
+			for (const item of this.items) seq.push(toJS.toJS(item, String(i++), ctx));
+			return seq;
+		}
+		toString(ctx, onComment, onChompKeep) {
+			if (!ctx) return JSON.stringify(this);
+			return stringifyCollection.stringifyCollection(this, ctx, {
+				blockItemPrefix: "- ",
+				flowChars: {
+					start: "[",
+					end: "]"
+				},
+				itemIndent: (ctx.indent || "") + "  ",
+				onChompKeep,
+				onComment
+			});
+		}
+		static from(schema, obj, ctx) {
+			const { replacer } = ctx;
+			const seq = new this(schema);
+			if (obj && Symbol.iterator in Object(obj)) {
+				let i = 0;
+				for (let it of obj) {
+					if (typeof replacer === "function") {
+						const key = obj instanceof Set ? it : String(i++);
+						it = replacer.call(obj, key, it);
+					}
+					seq.items.push(createNode.createNode(it, void 0, ctx));
+				}
+			}
+			return seq;
+		}
+	};
+	function asItemIndex(key) {
+		let idx = identity.isScalar(key) ? key.value : key;
+		if (idx && typeof idx === "string") idx = Number(idx);
+		return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null;
+	}
+	exports.YAMLSeq = YAMLSeq;
+}));
+//#endregion
+export default require_YAMLSeq();
+export { require_YAMLSeq };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/addPairToJSMap.mjs

@@ -0,0 +1,59 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+import { require_toJS } from "./toJS.mjs";
+import { require_stringify } from "../stringify/stringify.mjs";
+import { require_log } from "../log.mjs";
+import { require_merge } from "../schema/yaml-1.1/merge.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/addPairToJSMap.js
+var require_addPairToJSMap = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var log = require_log();
+	var merge = require_merge();
+	var stringify = require_stringify();
+	var identity = require_identity();
+	var toJS = require_toJS();
+	function addPairToJSMap(ctx, map, { key, value }) {
+		if (identity.isNode(key) && key.addToJSMap) key.addToJSMap(ctx, map, value);
+		else if (merge.isMergeKey(ctx, key)) merge.addMergeToJSMap(ctx, map, value);
+		else {
+			const jsKey = toJS.toJS(key, "", ctx);
+			if (map instanceof Map) map.set(jsKey, toJS.toJS(value, jsKey, ctx));
+			else if (map instanceof Set) map.add(jsKey);
+			else {
+				const stringKey = stringifyKey(key, jsKey, ctx);
+				const jsValue = toJS.toJS(value, stringKey, ctx);
+				if (stringKey in map) Object.defineProperty(map, stringKey, {
+					value: jsValue,
+					writable: true,
+					enumerable: true,
+					configurable: true
+				});
+				else map[stringKey] = jsValue;
+			}
+		}
+		return map;
+	}
+	function stringifyKey(key, jsKey, ctx) {
+		if (jsKey === null) return "";
+		if (typeof jsKey !== "object") return String(jsKey);
+		if (identity.isNode(key) && ctx?.doc) {
+			const strCtx = stringify.createStringifyContext(ctx.doc, {});
+			strCtx.anchors = /* @__PURE__ */ new Set();
+			for (const node of ctx.anchors.keys()) strCtx.anchors.add(node.anchor);
+			strCtx.inFlow = true;
+			strCtx.inStringifyKey = true;
+			const strKey = key.toString(strCtx);
+			if (!ctx.mapKeyWarned) {
+				let jsonStr = JSON.stringify(strKey);
+				if (jsonStr.length > 40) jsonStr = jsonStr.substring(0, 36) + "...\"";
+				log.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+				ctx.mapKeyWarned = true;
+			}
+			return strKey;
+		}
+		return JSON.stringify(jsKey);
+	}
+	exports.addPairToJSMap = addPairToJSMap;
+}));
+//#endregion
+export default require_addPairToJSMap();
+export { require_addPairToJSMap };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/identity.mjs

@@ -0,0 +1,53 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/identity.js
+var require_identity = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const ALIAS = Symbol.for("yaml.alias");
+	const DOC = Symbol.for("yaml.document");
+	const MAP = Symbol.for("yaml.map");
+	const PAIR = Symbol.for("yaml.pair");
+	const SCALAR = Symbol.for("yaml.scalar");
+	const SEQ = Symbol.for("yaml.seq");
+	const NODE_TYPE = Symbol.for("yaml.node.type");
+	const isAlias = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === ALIAS;
+	const isDocument = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === DOC;
+	const isMap = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP;
+	const isPair = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === PAIR;
+	const isScalar = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SCALAR;
+	const isSeq = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SEQ;
+	function isCollection(node) {
+		if (node && typeof node === "object") switch (node[NODE_TYPE]) {
+			case MAP:
+			case SEQ: return true;
+		}
+		return false;
+	}
+	function isNode(node) {
+		if (node && typeof node === "object") switch (node[NODE_TYPE]) {
+			case ALIAS:
+			case MAP:
+			case SCALAR:
+			case SEQ: return true;
+		}
+		return false;
+	}
+	const hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;
+	exports.ALIAS = ALIAS;
+	exports.DOC = DOC;
+	exports.MAP = MAP;
+	exports.NODE_TYPE = NODE_TYPE;
+	exports.PAIR = PAIR;
+	exports.SCALAR = SCALAR;
+	exports.SEQ = SEQ;
+	exports.hasAnchor = hasAnchor;
+	exports.isAlias = isAlias;
+	exports.isCollection = isCollection;
+	exports.isDocument = isDocument;
+	exports.isMap = isMap;
+	exports.isNode = isNode;
+	exports.isPair = isPair;
+	exports.isScalar = isScalar;
+	exports.isSeq = isSeq;
+}));
+//#endregion
+export default require_identity();
+export { require_identity };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/toJS.mjs

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/toJS.js
+var require_toJS = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	/**
+	* Recursively convert any node or its contents to native JavaScript
+	*
+	* @param value - The input value
+	* @param arg - If `value` defines a `toJSON()` method, use this
+	*   as its first argument
+	* @param ctx - Conversion context, originally set in Document#toJS(). If
+	*   `{ keep: true }` is not set, output should be suitable for JSON
+	*   stringification.
+	*/
+	function toJS(value, arg, ctx) {
+		if (Array.isArray(value)) return value.map((v, i) => toJS(v, String(i), ctx));
+		if (value && typeof value.toJSON === "function") {
+			if (!ctx || !identity.hasAnchor(value)) return value.toJSON(arg, ctx);
+			const data = {
+				aliasCount: 0,
+				count: 1,
+				res: void 0
+			};
+			ctx.anchors.set(value, data);
+			ctx.onCreate = (res) => {
+				data.res = res;
+				delete ctx.onCreate;
+			};
+			const res = value.toJSON(arg, ctx);
+			if (ctx.onCreate) ctx.onCreate(res);
+			return res;
+		}
+		if (typeof value === "bigint" && !ctx?.keep) return Number(value);
+		return value;
+	}
+	exports.toJS = toJS;
+}));
+//#endregion
+export default require_toJS();
+export { require_toJS };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/cst-scalar.mjs

@@ -0,0 +1,274 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_stringifyString } from "../stringify/stringifyString.mjs";
+import { require_errors } from "../errors.mjs";
+import { require_resolve_block_scalar } from "../compose/resolve-block-scalar.mjs";
+import { require_resolve_flow_scalar } from "../compose/resolve-flow-scalar.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/cst-scalar.js
+var require_cst_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var resolveBlockScalar = require_resolve_block_scalar();
+	var resolveFlowScalar = require_resolve_flow_scalar();
+	var errors = require_errors();
+	var stringifyString = require_stringifyString();
+	function resolveAsScalar(token, strict = true, onError) {
+		if (token) {
+			const _onError = (pos, code, message) => {
+				const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
+				if (onError) onError(offset, code, message);
+				else throw new errors.YAMLParseError([offset, offset + 1], code, message);
+			};
+			switch (token.type) {
+				case "scalar":
+				case "single-quoted-scalar":
+				case "double-quoted-scalar": return resolveFlowScalar.resolveFlowScalar(token, strict, _onError);
+				case "block-scalar": return resolveBlockScalar.resolveBlockScalar({ options: { strict } }, token, _onError);
+			}
+		}
+		return null;
+	}
+	/**
+	* Create a new scalar token with `value`
+	*
+	* Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+	* as this function does not support any schema operations and won't check for such conflicts.
+	*
+	* @param value The string representation of the value, which will have its content properly indented.
+	* @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
+	* @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+	* @param context.indent The indent level of the token.
+	* @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
+	* @param context.offset The offset position of the token.
+	* @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+	*/
+	function createScalarToken(value, context) {
+		const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
+		const source = stringifyString.stringifyString({
+			type,
+			value
+		}, {
+			implicitKey,
+			indent: indent > 0 ? " ".repeat(indent) : "",
+			inFlow,
+			options: {
+				blockQuote: true,
+				lineWidth: -1
+			}
+		});
+		const end = context.end ?? [{
+			type: "newline",
+			offset: -1,
+			indent,
+			source: "\n"
+		}];
+		switch (source[0]) {
+			case "|":
+			case ">": {
+				const he = source.indexOf("\n");
+				const head = source.substring(0, he);
+				const body = source.substring(he + 1) + "\n";
+				const props = [{
+					type: "block-scalar-header",
+					offset,
+					indent,
+					source: head
+				}];
+				if (!addEndtoBlockProps(props, end)) props.push({
+					type: "newline",
+					offset: -1,
+					indent,
+					source: "\n"
+				});
+				return {
+					type: "block-scalar",
+					offset,
+					indent,
+					props,
+					source: body
+				};
+			}
+			case "\"": return {
+				type: "double-quoted-scalar",
+				offset,
+				indent,
+				source,
+				end
+			};
+			case "'": return {
+				type: "single-quoted-scalar",
+				offset,
+				indent,
+				source,
+				end
+			};
+			default: return {
+				type: "scalar",
+				offset,
+				indent,
+				source,
+				end
+			};
+		}
+	}
+	/**
+	* Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have.
+	*
+	* Best efforts are made to retain any comments previously associated with the `token`,
+	* though all contents within a collection's `items` will be overwritten.
+	*
+	* Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+	* as this function does not support any schema operations and won't check for such conflicts.
+	*
+	* @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
+	* @param value The string representation of the value, which will have its content properly indented.
+	* @param context.afterKey In most cases, values after a key should have an additional level of indentation.
+	* @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+	* @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
+	* @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+	*/
+	function setScalarValue(token, value, context = {}) {
+		let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
+		let indent = "indent" in token ? token.indent : null;
+		if (afterKey && typeof indent === "number") indent += 2;
+		if (!type) switch (token.type) {
+			case "single-quoted-scalar":
+				type = "QUOTE_SINGLE";
+				break;
+			case "double-quoted-scalar":
+				type = "QUOTE_DOUBLE";
+				break;
+			case "block-scalar": {
+				const header = token.props[0];
+				if (header.type !== "block-scalar-header") throw new Error("Invalid block scalar header");
+				type = header.source[0] === ">" ? "BLOCK_FOLDED" : "BLOCK_LITERAL";
+				break;
+			}
+			default: type = "PLAIN";
+		}
+		const source = stringifyString.stringifyString({
+			type,
+			value
+		}, {
+			implicitKey: implicitKey || indent === null,
+			indent: indent !== null && indent > 0 ? " ".repeat(indent) : "",
+			inFlow,
+			options: {
+				blockQuote: true,
+				lineWidth: -1
+			}
+		});
+		switch (source[0]) {
+			case "|":
+			case ">":
+				setBlockScalarValue(token, source);
+				break;
+			case "\"":
+				setFlowScalarValue(token, source, "double-quoted-scalar");
+				break;
+			case "'":
+				setFlowScalarValue(token, source, "single-quoted-scalar");
+				break;
+			default: setFlowScalarValue(token, source, "scalar");
+		}
+	}
+	function setBlockScalarValue(token, source) {
+		const he = source.indexOf("\n");
+		const head = source.substring(0, he);
+		const body = source.substring(he + 1) + "\n";
+		if (token.type === "block-scalar") {
+			const header = token.props[0];
+			if (header.type !== "block-scalar-header") throw new Error("Invalid block scalar header");
+			header.source = head;
+			token.source = body;
+		} else {
+			const { offset } = token;
+			const indent = "indent" in token ? token.indent : -1;
+			const props = [{
+				type: "block-scalar-header",
+				offset,
+				indent,
+				source: head
+			}];
+			if (!addEndtoBlockProps(props, "end" in token ? token.end : void 0)) props.push({
+				type: "newline",
+				offset: -1,
+				indent,
+				source: "\n"
+			});
+			for (const key of Object.keys(token)) if (key !== "type" && key !== "offset") delete token[key];
+			Object.assign(token, {
+				type: "block-scalar",
+				indent,
+				props,
+				source: body
+			});
+		}
+	}
+	/** @returns `true` if last token is a newline */
+	function addEndtoBlockProps(props, end) {
+		if (end) for (const st of end) switch (st.type) {
+			case "space":
+			case "comment":
+				props.push(st);
+				break;
+			case "newline":
+				props.push(st);
+				return true;
+		}
+		return false;
+	}
+	function setFlowScalarValue(token, source, type) {
+		switch (token.type) {
+			case "scalar":
+			case "double-quoted-scalar":
+			case "single-quoted-scalar":
+				token.type = type;
+				token.source = source;
+				break;
+			case "block-scalar": {
+				const end = token.props.slice(1);
+				let oa = source.length;
+				if (token.props[0].type === "block-scalar-header") oa -= token.props[0].source.length;
+				for (const tok of end) tok.offset += oa;
+				delete token.props;
+				Object.assign(token, {
+					type,
+					source,
+					end
+				});
+				break;
+			}
+			case "block-map":
+			case "block-seq": {
+				const nl = {
+					type: "newline",
+					offset: token.offset + source.length,
+					indent: token.indent,
+					source: "\n"
+				};
+				delete token.items;
+				Object.assign(token, {
+					type,
+					source,
+					end: [nl]
+				});
+				break;
+			}
+			default: {
+				const indent = "indent" in token ? token.indent : -1;
+				const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st) => st.type === "space" || st.type === "comment" || st.type === "newline") : [];
+				for (const key of Object.keys(token)) if (key !== "type" && key !== "offset") delete token[key];
+				Object.assign(token, {
+					type,
+					indent,
+					source,
+					end
+				});
+			}
+		}
+	}
+	exports.createScalarToken = createScalarToken;
+	exports.resolveAsScalar = resolveAsScalar;
+	exports.setScalarValue = setScalarValue;
+}));
+//#endregion
+export default require_cst_scalar();
+export { require_cst_scalar };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/cst-stringify.mjs

@@ -0,0 +1,54 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/cst-stringify.js
+var require_cst_stringify = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Stringify a CST document, token, or collection item
+	*
+	* Fair warning: This applies no validation whatsoever, and
+	* simply concatenates the sources in their logical order.
+	*/
+	const stringify = (cst) => "type" in cst ? stringifyToken(cst) : stringifyItem(cst);
+	function stringifyToken(token) {
+		switch (token.type) {
+			case "block-scalar": {
+				let res = "";
+				for (const tok of token.props) res += stringifyToken(tok);
+				return res + token.source;
+			}
+			case "block-map":
+			case "block-seq": {
+				let res = "";
+				for (const item of token.items) res += stringifyItem(item);
+				return res;
+			}
+			case "flow-collection": {
+				let res = token.start.source;
+				for (const item of token.items) res += stringifyItem(item);
+				for (const st of token.end) res += st.source;
+				return res;
+			}
+			case "document": {
+				let res = stringifyItem(token);
+				if (token.end) for (const st of token.end) res += st.source;
+				return res;
+			}
+			default: {
+				let res = token.source;
+				if ("end" in token && token.end) for (const st of token.end) res += st.source;
+				return res;
+			}
+		}
+	}
+	function stringifyItem({ start, key, sep, value }) {
+		let res = "";
+		for (const st of start) res += st.source;
+		if (key) res += stringifyToken(key);
+		if (sep) for (const st of sep) res += st.source;
+		if (value) res += stringifyToken(value);
+		return res;
+	}
+	exports.stringify = stringify;
+}));
+//#endregion
+export default require_cst_stringify();
+export { require_cst_stringify };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/cst-visit.mjs

@@ -0,0 +1,94 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/cst-visit.js
+var require_cst_visit = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const BREAK = Symbol("break visit");
+	const SKIP = Symbol("skip children");
+	const REMOVE = Symbol("remove item");
+	/**
+	* Apply a visitor to a CST document or item.
+	*
+	* Walks through the tree (depth-first) starting from the root, calling a
+	* `visitor` function with two arguments when entering each item:
+	*   - `item`: The current item, which included the following members:
+	*     - `start: SourceToken[]` – Source tokens before the key or value,
+	*       possibly including its anchor or tag.
+	*     - `key?: Token | null` – Set for pair values. May then be `null`, if
+	*       the key before the `:` separator is empty.
+	*     - `sep?: SourceToken[]` – Source tokens between the key and the value,
+	*       which should include the `:` map value indicator if `value` is set.
+	*     - `value?: Token` – The value of a sequence item, or of a map pair.
+	*   - `path`: The steps from the root to the current node, as an array of
+	*     `['key' | 'value', number]` tuples.
+	*
+	* The return value of the visitor may be used to control the traversal:
+	*   - `undefined` (default): Do nothing and continue
+	*   - `visit.SKIP`: Do not visit the children of this token, continue with
+	*      next sibling
+	*   - `visit.BREAK`: Terminate traversal completely
+	*   - `visit.REMOVE`: Remove the current item, then continue with the next one
+	*   - `number`: Set the index of the next step. This is useful especially if
+	*     the index of the current token has changed.
+	*   - `function`: Define the next visitor for this item. After the original
+	*     visitor is called on item entry, next visitors are called after handling
+	*     a non-empty `key` and when exiting the item.
+	*/
+	function visit(cst, visitor) {
+		if ("type" in cst && cst.type === "document") cst = {
+			start: cst.start,
+			value: cst.value
+		};
+		_visit(Object.freeze([]), cst, visitor);
+	}
+	/** Terminate visit traversal completely */
+	visit.BREAK = BREAK;
+	/** Do not visit the children of the current item */
+	visit.SKIP = SKIP;
+	/** Remove the current item */
+	visit.REMOVE = REMOVE;
+	/** Find the item at `path` from `cst` as the root */
+	visit.itemAtPath = (cst, path) => {
+		let item = cst;
+		for (const [field, index] of path) {
+			const tok = item?.[field];
+			if (tok && "items" in tok) item = tok.items[index];
+			else return void 0;
+		}
+		return item;
+	};
+	/**
+	* Get the immediate parent collection of the item at `path` from `cst` as the root.
+	*
+	* Throws an error if the collection is not found, which should never happen if the item itself exists.
+	*/
+	visit.parentCollection = (cst, path) => {
+		const parent = visit.itemAtPath(cst, path.slice(0, -1));
+		const field = path[path.length - 1][0];
+		const coll = parent?.[field];
+		if (coll && "items" in coll) return coll;
+		throw new Error("Parent collection not found");
+	};
+	function _visit(path, item, visitor) {
+		let ctrl = visitor(item, path);
+		if (typeof ctrl === "symbol") return ctrl;
+		for (const field of ["key", "value"]) {
+			const token = item[field];
+			if (token && "items" in token) {
+				for (let i = 0; i < token.items.length; ++i) {
+					const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+					if (typeof ci === "number") i = ci - 1;
+					else if (ci === BREAK) return BREAK;
+					else if (ci === REMOVE) {
+						token.items.splice(i, 1);
+						i -= 1;
+					}
+				}
+				if (typeof ctrl === "function" && field === "key") ctrl = ctrl(item, path);
+			}
+		}
+		return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
+	}
+	exports.visit = visit;
+}));
+//#endregion
+export default require_cst_visit();
+export { require_cst_visit };