cngpac 0.0.1

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/Document.mjs

@@ -0,0 +1,295 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_directives } from "./directives.mjs";
+import { require_anchors } from "./anchors.mjs";
+import { require_applyReviver } from "./applyReviver.mjs";
+import { require_toJS } from "../nodes/toJS.mjs";
+import { require_Alias } from "../nodes/Alias.mjs";
+import { require_createNode } from "./createNode.mjs";
+import { require_Collection } from "../nodes/Collection.mjs";
+import { require_Pair } from "../nodes/Pair.mjs";
+import { require_Schema } from "../schema/Schema.mjs";
+import { require_stringifyDocument } from "../stringify/stringifyDocument.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/Document.js
+var require_Document = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Alias = require_Alias();
+	var Collection = require_Collection();
+	var identity = require_identity();
+	var Pair = require_Pair();
+	var toJS = require_toJS();
+	var Schema = require_Schema();
+	var stringifyDocument = require_stringifyDocument();
+	var anchors = require_anchors();
+	var applyReviver = require_applyReviver();
+	var createNode = require_createNode();
+	var directives = require_directives();
+	var Document = class Document {
+		constructor(value, replacer, options) {
+			/** A comment before this Document */
+			this.commentBefore = null;
+			/** A comment immediately after this Document */
+			this.comment = null;
+			/** Errors encountered during parsing. */
+			this.errors = [];
+			/** Warnings encountered during parsing. */
+			this.warnings = [];
+			Object.defineProperty(this, identity.NODE_TYPE, { value: identity.DOC });
+			let _replacer = null;
+			if (typeof replacer === "function" || Array.isArray(replacer)) _replacer = replacer;
+			else if (options === void 0 && replacer) {
+				options = replacer;
+				replacer = void 0;
+			}
+			const opt = Object.assign({
+				intAsBigInt: false,
+				keepSourceTokens: false,
+				logLevel: "warn",
+				prettyErrors: true,
+				strict: true,
+				stringKeys: false,
+				uniqueKeys: true,
+				version: "1.2"
+			}, options);
+			this.options = opt;
+			let { version } = opt;
+			if (options?._directives) {
+				this.directives = options._directives.atDocument();
+				if (this.directives.yaml.explicit) version = this.directives.yaml.version;
+			} else this.directives = new directives.Directives({ version });
+			this.setSchema(version, options);
+			this.contents = value === void 0 ? null : this.createNode(value, _replacer, options);
+		}
+		/**
+		* Create a deep copy of this Document and its contents.
+		*
+		* Custom Node values that inherit from `Object` still refer to their original instances.
+		*/
+		clone() {
+			const copy = Object.create(Document.prototype, { [identity.NODE_TYPE]: { value: identity.DOC } });
+			copy.commentBefore = this.commentBefore;
+			copy.comment = this.comment;
+			copy.errors = this.errors.slice();
+			copy.warnings = this.warnings.slice();
+			copy.options = Object.assign({}, this.options);
+			if (this.directives) copy.directives = this.directives.clone();
+			copy.schema = this.schema.clone();
+			copy.contents = identity.isNode(this.contents) ? this.contents.clone(copy.schema) : this.contents;
+			if (this.range) copy.range = this.range.slice();
+			return copy;
+		}
+		/** Adds a value to the document. */
+		add(value) {
+			if (assertCollection(this.contents)) this.contents.add(value);
+		}
+		/** Adds a value to the document. */
+		addIn(path, value) {
+			if (assertCollection(this.contents)) this.contents.addIn(path, value);
+		}
+		/**
+		* Create a new `Alias` node, ensuring that the target `node` has the required anchor.
+		*
+		* If `node` already has an anchor, `name` is ignored.
+		* Otherwise, the `node.anchor` value will be set to `name`,
+		* or if an anchor with that name is already present in the document,
+		* `name` will be used as a prefix for a new unique anchor.
+		* If `name` is undefined, the generated anchor will use 'a' as a prefix.
+		*/
+		createAlias(node, name) {
+			if (!node.anchor) {
+				const prev = anchors.anchorNames(this);
+				node.anchor = !name || prev.has(name) ? anchors.findNewAnchor(name || "a", prev) : name;
+			}
+			return new Alias.Alias(node.anchor);
+		}
+		createNode(value, replacer, options) {
+			let _replacer = void 0;
+			if (typeof replacer === "function") {
+				value = replacer.call({ "": value }, "", value);
+				_replacer = replacer;
+			} else if (Array.isArray(replacer)) {
+				const keyToStr = (v) => typeof v === "number" || v instanceof String || v instanceof Number;
+				const asStr = replacer.filter(keyToStr).map(String);
+				if (asStr.length > 0) replacer = replacer.concat(asStr);
+				_replacer = replacer;
+			} else if (options === void 0 && replacer) {
+				options = replacer;
+				replacer = void 0;
+			}
+			const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options ?? {};
+			const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors(this, anchorPrefix || "a");
+			const ctx = {
+				aliasDuplicateObjects: aliasDuplicateObjects ?? true,
+				keepUndefined: keepUndefined ?? false,
+				onAnchor,
+				onTagObj,
+				replacer: _replacer,
+				schema: this.schema,
+				sourceObjects
+			};
+			const node = createNode.createNode(value, tag, ctx);
+			if (flow && identity.isCollection(node)) node.flow = true;
+			setAnchors();
+			return node;
+		}
+		/**
+		* Convert a key and a value into a `Pair` using the current schema,
+		* recursively wrapping all values as `Scalar` or `Collection` nodes.
+		*/
+		createPair(key, value, options = {}) {
+			const k = this.createNode(key, null, options);
+			const v = this.createNode(value, null, options);
+			return new Pair.Pair(k, v);
+		}
+		/**
+		* Removes a value from the document.
+		* @returns `true` if the item was found and removed.
+		*/
+		delete(key) {
+			return assertCollection(this.contents) ? this.contents.delete(key) : false;
+		}
+		/**
+		* Removes a value from the document.
+		* @returns `true` if the item was found and removed.
+		*/
+		deleteIn(path) {
+			if (Collection.isEmptyPath(path)) {
+				if (this.contents == null) return false;
+				this.contents = null;
+				return true;
+			}
+			return assertCollection(this.contents) ? this.contents.deleteIn(path) : false;
+		}
+		/**
+		* Returns item at `key`, or `undefined` if not found. By default unwraps
+		* scalar values from their surrounding node; to disable set `keepScalar` to
+		* `true` (collections are always returned intact).
+		*/
+		get(key, keepScalar) {
+			return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : void 0;
+		}
+		/**
+		* Returns item at `path`, or `undefined` if not found. By default unwraps
+		* scalar values from their surrounding node; to disable set `keepScalar` to
+		* `true` (collections are always returned intact).
+		*/
+		getIn(path, keepScalar) {
+			if (Collection.isEmptyPath(path)) return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
+			return identity.isCollection(this.contents) ? this.contents.getIn(path, keepScalar) : void 0;
+		}
+		/**
+		* Checks if the document includes a value with the key `key`.
+		*/
+		has(key) {
+			return identity.isCollection(this.contents) ? this.contents.has(key) : false;
+		}
+		/**
+		* Checks if the document includes a value at `path`.
+		*/
+		hasIn(path) {
+			if (Collection.isEmptyPath(path)) return this.contents !== void 0;
+			return identity.isCollection(this.contents) ? this.contents.hasIn(path) : false;
+		}
+		/**
+		* Sets a value in this document. For `!!set`, `value` needs to be a
+		* boolean to add/remove the item from the set.
+		*/
+		set(key, value) {
+			if (this.contents == null) this.contents = Collection.collectionFromPath(this.schema, [key], value);
+			else if (assertCollection(this.contents)) this.contents.set(key, value);
+		}
+		/**
+		* Sets a value in this document. For `!!set`, `value` needs to be a
+		* boolean to add/remove the item from the set.
+		*/
+		setIn(path, value) {
+			if (Collection.isEmptyPath(path)) this.contents = value;
+			else if (this.contents == null) this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
+			else if (assertCollection(this.contents)) this.contents.setIn(path, value);
+		}
+		/**
+		* Change the YAML version and schema used by the document.
+		* A `null` version disables support for directives, explicit tags, anchors, and aliases.
+		* It also requires the `schema` option to be given as a `Schema` instance value.
+		*
+		* Overrides all previously set schema options.
+		*/
+		setSchema(version, options = {}) {
+			if (typeof version === "number") version = String(version);
+			let opt;
+			switch (version) {
+				case "1.1":
+					if (this.directives) this.directives.yaml.version = "1.1";
+					else this.directives = new directives.Directives({ version: "1.1" });
+					opt = {
+						resolveKnownTags: false,
+						schema: "yaml-1.1"
+					};
+					break;
+				case "1.2":
+				case "next":
+					if (this.directives) this.directives.yaml.version = version;
+					else this.directives = new directives.Directives({ version });
+					opt = {
+						resolveKnownTags: true,
+						schema: "core"
+					};
+					break;
+				case null:
+					if (this.directives) delete this.directives;
+					opt = null;
+					break;
+				default: {
+					const sv = JSON.stringify(version);
+					throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);
+				}
+			}
+			if (options.schema instanceof Object) this.schema = options.schema;
+			else if (opt) this.schema = new Schema.Schema(Object.assign(opt, options));
+			else throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
+		}
+		toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+			const ctx = {
+				anchors: /* @__PURE__ */ new Map(),
+				doc: this,
+				keep: !json,
+				mapAsMap: mapAsMap === true,
+				mapKeyWarned: false,
+				maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100
+			};
+			const res = toJS.toJS(this.contents, jsonArg ?? "", ctx);
+			if (typeof onAnchor === "function") for (const { count, res } of ctx.anchors.values()) onAnchor(res, count);
+			return typeof reviver === "function" ? applyReviver.applyReviver(reviver, { "": res }, "", res) : res;
+		}
+		/**
+		* A JSON representation of the document `contents`.
+		*
+		* @param jsonArg Used by `JSON.stringify` to indicate the array index or
+		*   property name.
+		*/
+		toJSON(jsonArg, onAnchor) {
+			return this.toJS({
+				json: true,
+				jsonArg,
+				mapAsMap: false,
+				onAnchor
+			});
+		}
+		/** A YAML representation of the document. */
+		toString(options = {}) {
+			if (this.errors.length > 0) throw new Error("Document with errors cannot be stringified");
+			if ("indent" in options && (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) {
+				const s = JSON.stringify(options.indent);
+				throw new Error(`"indent" option must be a positive integer, not ${s}`);
+			}
+			return stringifyDocument.stringifyDocument(this, options);
+		}
+	};
+	function assertCollection(contents) {
+		if (identity.isCollection(contents)) return true;
+		throw new Error("Expected a YAML collection as document contents");
+	}
+	exports.Document = Document;
+}));
+//#endregion
+export default require_Document();
+export { require_Document };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/anchors.mjs

@@ -0,0 +1,67 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_visit } from "../visit.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/anchors.js
+var require_anchors = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var visit = require_visit();
+	/**
+	* Verify that the input string is a valid anchor.
+	*
+	* Will throw on errors.
+	*/
+	function anchorIsValid(anchor) {
+		if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
+			const msg = `Anchor must not contain whitespace or control characters: ${JSON.stringify(anchor)}`;
+			throw new Error(msg);
+		}
+		return true;
+	}
+	function anchorNames(root) {
+		const anchors = /* @__PURE__ */ new Set();
+		visit.visit(root, { Value(_key, node) {
+			if (node.anchor) anchors.add(node.anchor);
+		} });
+		return anchors;
+	}
+	/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
+	function findNewAnchor(prefix, exclude) {
+		for (let i = 1;; ++i) {
+			const name = `${prefix}${i}`;
+			if (!exclude.has(name)) return name;
+		}
+	}
+	function createNodeAnchors(doc, prefix) {
+		const aliasObjects = [];
+		const sourceObjects = /* @__PURE__ */ new Map();
+		let prevAnchors = null;
+		return {
+			onAnchor: (source) => {
+				aliasObjects.push(source);
+				prevAnchors ?? (prevAnchors = anchorNames(doc));
+				const anchor = findNewAnchor(prefix, prevAnchors);
+				prevAnchors.add(anchor);
+				return anchor;
+			},
+			setAnchors: () => {
+				for (const source of aliasObjects) {
+					const ref = sourceObjects.get(source);
+					if (typeof ref === "object" && ref.anchor && (identity.isScalar(ref.node) || identity.isCollection(ref.node))) ref.node.anchor = ref.anchor;
+					else {
+						const error = /* @__PURE__ */ new Error("Failed to resolve repeated object (this should not happen)");
+						error.source = source;
+						throw error;
+					}
+				}
+			},
+			sourceObjects
+		};
+	}
+	exports.anchorIsValid = anchorIsValid;
+	exports.anchorNames = anchorNames;
+	exports.createNodeAnchors = createNodeAnchors;
+	exports.findNewAnchor = findNewAnchor;
+}));
+//#endregion
+export default require_anchors();
+export { require_anchors };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/applyReviver.mjs

@@ -0,0 +1,43 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/applyReviver.js
+var require_applyReviver = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
+	* in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
+	* 2021 edition: https://tc39.es/ecma262/#sec-json.parse
+	*
+	* Includes extensions for handling Map and Set objects.
+	*/
+	function applyReviver(reviver, obj, key, val) {
+		if (val && typeof val === "object") if (Array.isArray(val)) for (let i = 0, len = val.length; i < len; ++i) {
+			const v0 = val[i];
+			const v1 = applyReviver(reviver, val, String(i), v0);
+			if (v1 === void 0) delete val[i];
+			else if (v1 !== v0) val[i] = v1;
+		}
+		else if (val instanceof Map) for (const k of Array.from(val.keys())) {
+			const v0 = val.get(k);
+			const v1 = applyReviver(reviver, val, k, v0);
+			if (v1 === void 0) val.delete(k);
+			else if (v1 !== v0) val.set(k, v1);
+		}
+		else if (val instanceof Set) for (const v0 of Array.from(val)) {
+			const v1 = applyReviver(reviver, val, v0, v0);
+			if (v1 === void 0) val.delete(v0);
+			else if (v1 !== v0) {
+				val.delete(v0);
+				val.add(v1);
+			}
+		}
+		else for (const [k, v0] of Object.entries(val)) {
+			const v1 = applyReviver(reviver, val, k, v0);
+			if (v1 === void 0) delete val[k];
+			else if (v1 !== v0) val[k] = v1;
+		}
+		return reviver.call(obj, key, val);
+	}
+	exports.applyReviver = applyReviver;
+}));
+//#endregion
+export default require_applyReviver();
+export { require_applyReviver };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/createNode.mjs

@@ -0,0 +1,69 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_Alias } from "../nodes/Alias.mjs";
+import { require_Scalar } from "../nodes/Scalar.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/createNode.js
+var require_createNode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Alias = require_Alias();
+	var identity = require_identity();
+	var Scalar = require_Scalar();
+	const defaultTagPrefix = "tag:yaml.org,2002:";
+	function findTagObject(value, tagName, tags) {
+		if (tagName) {
+			const match = tags.filter((t) => t.tag === tagName);
+			const tagObj = match.find((t) => !t.format) ?? match[0];
+			if (!tagObj) throw new Error(`Tag ${tagName} not found`);
+			return tagObj;
+		}
+		return tags.find((t) => t.identify?.(value) && !t.format);
+	}
+	function createNode(value, tagName, ctx) {
+		if (identity.isDocument(value)) value = value.contents;
+		if (identity.isNode(value)) return value;
+		if (identity.isPair(value)) {
+			const map = ctx.schema[identity.MAP].createNode?.(ctx.schema, null, ctx);
+			map.items.push(value);
+			return map;
+		}
+		if (value instanceof String || value instanceof Number || value instanceof Boolean || typeof BigInt !== "undefined" && value instanceof BigInt) value = value.valueOf();
+		const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;
+		let ref = void 0;
+		if (aliasDuplicateObjects && value && typeof value === "object") {
+			ref = sourceObjects.get(value);
+			if (ref) {
+				ref.anchor ?? (ref.anchor = onAnchor(value));
+				return new Alias.Alias(ref.anchor);
+			} else {
+				ref = {
+					anchor: null,
+					node: null
+				};
+				sourceObjects.set(value, ref);
+			}
+		}
+		if (tagName?.startsWith("!!")) tagName = defaultTagPrefix + tagName.slice(2);
+		let tagObj = findTagObject(value, tagName, schema.tags);
+		if (!tagObj) {
+			if (value && typeof value.toJSON === "function") value = value.toJSON();
+			if (!value || typeof value !== "object") {
+				const node = new Scalar.Scalar(value);
+				if (ref) ref.node = node;
+				return node;
+			}
+			tagObj = value instanceof Map ? schema[identity.MAP] : Symbol.iterator in Object(value) ? schema[identity.SEQ] : schema[identity.MAP];
+		}
+		if (onTagObj) {
+			onTagObj(tagObj);
+			delete ctx.onTagObj;
+		}
+		const node = tagObj?.createNode ? tagObj.createNode(ctx.schema, value, ctx) : typeof tagObj?.nodeClass?.from === "function" ? tagObj.nodeClass.from(ctx.schema, value, ctx) : new Scalar.Scalar(value);
+		if (tagName) node.tag = tagName;
+		else if (!tagObj.default) node.tag = tagObj.tag;
+		if (ref) ref.node = node;
+		return node;
+	}
+	exports.createNode = createNode;
+}));
+//#endregion
+export default require_createNode();
+export { require_createNode };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/directives.mjs

@@ -0,0 +1,170 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_visit } from "../visit.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/doc/directives.js
+var require_directives = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var visit = require_visit();
+	const escapeChars = {
+		"!": "%21",
+		",": "%2C",
+		"[": "%5B",
+		"]": "%5D",
+		"{": "%7B",
+		"}": "%7D"
+	};
+	const escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, (ch) => escapeChars[ch]);
+	var Directives = class Directives {
+		constructor(yaml, tags) {
+			/**
+			* The directives-end/doc-start marker `---`. If `null`, a marker may still be
+			* included in the document's stringified representation.
+			*/
+			this.docStart = null;
+			/** The doc-end marker `...`.  */
+			this.docEnd = false;
+			this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
+			this.tags = Object.assign({}, Directives.defaultTags, tags);
+		}
+		clone() {
+			const copy = new Directives(this.yaml, this.tags);
+			copy.docStart = this.docStart;
+			return copy;
+		}
+		/**
+		* During parsing, get a Directives instance for the current document and
+		* update the stream state according to the current version's spec.
+		*/
+		atDocument() {
+			const res = new Directives(this.yaml, this.tags);
+			switch (this.yaml.version) {
+				case "1.1":
+					this.atNextDocument = true;
+					break;
+				case "1.2":
+					this.atNextDocument = false;
+					this.yaml = {
+						explicit: Directives.defaultYaml.explicit,
+						version: "1.2"
+					};
+					this.tags = Object.assign({}, Directives.defaultTags);
+					break;
+			}
+			return res;
+		}
+		/**
+		* @param onError - May be called even if the action was successful
+		* @returns `true` on success
+		*/
+		add(line, onError) {
+			if (this.atNextDocument) {
+				this.yaml = {
+					explicit: Directives.defaultYaml.explicit,
+					version: "1.1"
+				};
+				this.tags = Object.assign({}, Directives.defaultTags);
+				this.atNextDocument = false;
+			}
+			const parts = line.trim().split(/[ \t]+/);
+			const name = parts.shift();
+			switch (name) {
+				case "%TAG": {
+					if (parts.length !== 2) {
+						onError(0, "%TAG directive should contain exactly two parts");
+						if (parts.length < 2) return false;
+					}
+					const [handle, prefix] = parts;
+					this.tags[handle] = prefix;
+					return true;
+				}
+				case "%YAML": {
+					this.yaml.explicit = true;
+					if (parts.length !== 1) {
+						onError(0, "%YAML directive should contain exactly one part");
+						return false;
+					}
+					const [version] = parts;
+					if (version === "1.1" || version === "1.2") {
+						this.yaml.version = version;
+						return true;
+					} else {
+						const isValid = /^\d+\.\d+$/.test(version);
+						onError(6, `Unsupported YAML version ${version}`, isValid);
+						return false;
+					}
+				}
+				default:
+					onError(0, `Unknown directive ${name}`, true);
+					return false;
+			}
+		}
+		/**
+		* Resolves a tag, matching handles to those defined in %TAG directives.
+		*
+		* @returns Resolved tag, which may also be the non-specific tag `'!'` or a
+		*   `'!local'` tag, or `null` if unresolvable.
+		*/
+		tagName(source, onError) {
+			if (source === "!") return "!";
+			if (source[0] !== "!") {
+				onError(`Not a valid tag: ${source}`);
+				return null;
+			}
+			if (source[1] === "<") {
+				const verbatim = source.slice(2, -1);
+				if (verbatim === "!" || verbatim === "!!") {
+					onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);
+					return null;
+				}
+				if (source[source.length - 1] !== ">") onError("Verbatim tags must end with a >");
+				return verbatim;
+			}
+			const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
+			if (!suffix) onError(`The ${source} tag has no suffix`);
+			const prefix = this.tags[handle];
+			if (prefix) try {
+				return prefix + decodeURIComponent(suffix);
+			} catch (error) {
+				onError(String(error));
+				return null;
+			}
+			if (handle === "!") return source;
+			onError(`Could not resolve tag: ${source}`);
+			return null;
+		}
+		/**
+		* Given a fully resolved tag, returns its printable string form,
+		* taking into account current tag prefixes and defaults.
+		*/
+		tagString(tag) {
+			for (const [handle, prefix] of Object.entries(this.tags)) if (tag.startsWith(prefix)) return handle + escapeTagName(tag.substring(prefix.length));
+			return tag[0] === "!" ? tag : `!<${tag}>`;
+		}
+		toString(doc) {
+			const lines = this.yaml.explicit ? [`%YAML ${this.yaml.version || "1.2"}`] : [];
+			const tagEntries = Object.entries(this.tags);
+			let tagNames;
+			if (doc && tagEntries.length > 0 && identity.isNode(doc.contents)) {
+				const tags = {};
+				visit.visit(doc.contents, (_key, node) => {
+					if (identity.isNode(node) && node.tag) tags[node.tag] = true;
+				});
+				tagNames = Object.keys(tags);
+			} else tagNames = [];
+			for (const [handle, prefix] of tagEntries) {
+				if (handle === "!!" && prefix === "tag:yaml.org,2002:") continue;
+				if (!doc || tagNames.some((tn) => tn.startsWith(prefix))) lines.push(`%TAG ${handle} ${prefix}`);
+			}
+			return lines.join("\n");
+		}
+	};
+	Directives.defaultYaml = {
+		explicit: false,
+		version: "1.2"
+	};
+	Directives.defaultTags = { "!!": "tag:yaml.org,2002:" };
+	exports.Directives = Directives;
+}));
+//#endregion
+export default require_directives();
+export { require_directives };