@effected/yaml 0.1.0

package/internal/composer/state.js

@@ -0,0 +1,117 @@
+//#region src/internal/composer/state.ts
+let lineStartsText;
+let lineStartsCache = [];
+function getLineStarts(text) {
+	if (lineStartsText === text) return lineStartsCache;
+	const starts = [0];
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") starts.push(i + 1);
+	lineStartsText = text;
+	lineStartsCache = starts;
+	return starts;
+}
+function lineCol(text, offset) {
+	const starts = getLineStarts(text);
+	const pos = Math.min(Math.max(offset, 0), text.length);
+	let lo = 0;
+	let hi = starts.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		if (starts[mid] <= pos) lo = mid;
+		else hi = mid - 1;
+	}
+	return {
+		line: lo,
+		column: pos - starts[lo]
+	};
+}
+/**
+* Returns true if offsetA and offsetB are on the same source line (no newline between them).
+*/
+function sameLine(text, offsetA, offsetB) {
+	const lo = Math.min(offsetA, offsetB);
+	const hi = Math.max(offsetA, offsetB);
+	for (let i = lo; i < hi && i < text.length; i++) if (text[i] === "\n") return false;
+	return true;
+}
+/** Returns true if there is non-whitespace content before `offset` on the same line. */
+function hasNonWhitespaceBeforeOnLine(text, offset) {
+	for (let i = offset - 1; i >= 0; i--) {
+		const ch = text[i];
+		if (ch === "\n" || ch === "\r") return false;
+		if (ch !== " " && ch !== "	") return true;
+	}
+	return false;
+}
+/**
+* Returns the column of the first non-whitespace character on the line
+* containing the given offset. Used to compute the "effective" indent of a
+* line when properties (tag/anchor) precede the actual content scalar —
+* the indent is the leftmost column on the line, not the scalar's column.
+*/
+function lineIndentColumn(text, offset) {
+	let lineStart = offset;
+	while (lineStart > 0 && text[lineStart - 1] !== "\n") lineStart--;
+	let i = lineStart;
+	while (i < text.length && (text[i] === " " || text[i] === "	")) i++;
+	return i - lineStart;
+}
+function hasMeta(m) {
+	return m.anchor !== void 0 || m.tag !== void 0 || m.comment !== void 0;
+}
+function clearMeta(m) {
+	delete m.anchor;
+	delete m.tag;
+	delete m.comment;
+}
+function createState(text, flow, options) {
+	return {
+		text,
+		anchors: /* @__PURE__ */ new Map(),
+		aliasCount: 0,
+		errors: [],
+		warnings: [],
+		options: {
+			strict: options?.strict ?? true,
+			maxAliasCount: options?.maxAliasCount ?? 100,
+			uniqueKeys: options?.uniqueKeys ?? true
+		},
+		tagMap: /* @__PURE__ */ new Map(),
+		flow,
+		depth: 0
+	};
+}
+/**
+* Maximum collection-nesting depth the composer will recurse into. The
+* composer (and every downstream tree walker: value extraction, stringify,
+* the visitor) recurses per node, so unbounded nesting is a stack-overflow
+* denial-of-service vector. 256 is far beyond any real document and leaves
+* a wide margin under the observed overflow point (~900 nesting levels with
+* the composer's multi-frame recursion chain per level).
+*/
+const MAX_NESTING_DEPTH = 256;
+/**
+* Enter one collection-nesting level. Returns `false` — after recording a
+* single fatal `NestingDepthExceeded` diagnostic — when the depth budget is
+* exhausted; the caller must then return a leaf placeholder instead of
+* recursing. Balance every `true` return with {@link exitNesting}.
+*/
+function enterNesting(state, cst) {
+	if (state.depth >= 256) {
+		if (!state.errors.some((e) => e.code === "NestingDepthExceeded")) state.errors.push({
+			code: "NestingDepthExceeded",
+			message: `Nesting depth exceeded maximum of ${256}`,
+			offset: cst.offset,
+			length: 1
+		});
+		return false;
+	}
+	state.depth++;
+	return true;
+}
+/** Leave one collection-nesting level. */
+function exitNesting(state) {
+	state.depth--;
+}
+
+//#endregion
+export { clearMeta, createState, enterNesting, exitNesting, getLineStarts, hasMeta, hasNonWhitespaceBeforeOnLine, lineCol, lineIndentColumn, sameLine };

package/internal/composer/tags.js

@@ -0,0 +1,88 @@
+//#region src/internal/composer/tags.ts
+/**
+* Resolve a tag shorthand using the document's %TAG directives.
+* For example, with `%TAG !! tag:example.com,2000:app/`, the tag `!!int`
+* resolves to `tag:example.com,2000:app/int`.
+*
+* Returns the resolved tag URI, or the original tag if no directive matches.
+*/
+function resolveTagHandle(tag, state) {
+	if (tag.startsWith("!<") && tag.endsWith(">")) return tag.slice(2, -1);
+	if (tag.startsWith("!!")) {
+		const prefix = state.tagMap.get("!!");
+		if (prefix) return prefix + tag.slice(2);
+		return `tag:yaml.org,2002:${tag.slice(2)}`;
+	}
+	const namedMatch = tag.match(/^(![\w-]*!)(.*)$/);
+	if (namedMatch) {
+		const handle = namedMatch[1];
+		const suffix = namedMatch[2];
+		if (handle) {
+			const prefix = state.tagMap.get(handle);
+			if (prefix) return prefix + (suffix ?? "");
+		}
+	}
+	if (tag.startsWith("!") && tag.length > 1 && !tag.startsWith("!!")) {
+		const prefix = state.tagMap.get("!");
+		if (prefix) return prefix + tag.slice(1);
+		return tag;
+	}
+	return tag;
+}
+function parseDirective(source) {
+	const trimmed = source.trim();
+	if (!trimmed.startsWith("%")) return null;
+	const parts = trimmed.slice(1).split(/\s+/);
+	const name = parts[0];
+	if (!name) return null;
+	const parameters = [];
+	for (const p of parts.slice(1)) {
+		if (p.startsWith("#")) break;
+		parameters.push(p);
+	}
+	return {
+		name,
+		parameters
+	};
+}
+/**
+* QLJ7: validate that any `!handle!suffix` tag reference in this document
+* is declared by a `%TAG` directive in the SAME document. %TAG directives
+* are local to a single document and do not leak across `---` boundaries.
+* The `!!` shorthand and the primary `!` handle are always available.
+*/
+function validateTagHandlesInDocument(docCst, state) {
+	const children = docCst.children ?? [];
+	const localHandles = /* @__PURE__ */ new Set();
+	for (const child of children) {
+		if (child.type !== "directive") continue;
+		const directive = parseDirective(child.source);
+		if (directive && directive.name === "TAG" && directive.parameters.length >= 2) {
+			const handle = directive.parameters[0];
+			if (handle) localHandles.add(handle);
+		}
+	}
+	const stack = [docCst];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node) continue;
+		if (node.type === "tag") {
+			const src = node.source;
+			if (src.startsWith("!<") || src.startsWith("!!") || src === "!") continue;
+			const m = src.match(/^(![\w-]*!)/);
+			if (m) {
+				const handle = m[1];
+				if (handle && !localHandles.has(handle)) state.errors.push({
+					code: "UnresolvedTag",
+					message: `Tag handle ${handle} is not declared in this document`,
+					offset: node.offset,
+					length: node.length
+				});
+			}
+		}
+		if (node.children) for (const c of node.children) stack.push(c);
+	}
+}
+
+//#endregion
+export { parseDirective, resolveTagHandle, validateTagHandlesInDocument };