@samva/markup 0.8.0 → 0.10.0

package/dist/ops-BvwqHl7V.js

@@ -1,630 +0,0 @@
-import { documentChannel } from "./ast.js";
-import { CHANNEL_TAG_SPECS, allowedChildren, parseSml } from "./parser.js";
-import { compileSml } from "./compile.js";
-import { a as isBreakingCompatibilityCheck, r as checkSmlCompatibility } from "./checks-D73Xizbw.js";
-import { printSml } from "./printer.js";
-import { Result, TaggedError } from "better-result";
-//#region src/internal/sha256.ts
-const ROUND_CONSTANTS = new Uint32Array([
-	1116352408,
-	1899447441,
-	3049323471,
-	3921009573,
-	961987163,
-	1508970993,
-	2453635748,
-	2870763221,
-	3624381080,
-	310598401,
-	607225278,
-	1426881987,
-	1925078388,
-	2162078206,
-	2614888103,
-	3248222580,
-	3835390401,
-	4022224774,
-	264347078,
-	604807628,
-	770255983,
-	1249150122,
-	1555081692,
-	1996064986,
-	2554220882,
-	2821834349,
-	2952996808,
-	3210313671,
-	3336571891,
-	3584528711,
-	113926993,
-	338241895,
-	666307205,
-	773529912,
-	1294757372,
-	1396182291,
-	1695183700,
-	1986661051,
-	2177026350,
-	2456956037,
-	2730485921,
-	2820302411,
-	3259730800,
-	3345764771,
-	3516065817,
-	3600352804,
-	4094571909,
-	275423344,
-	430227734,
-	506948616,
-	659060556,
-	883997877,
-	958139571,
-	1322822218,
-	1537002063,
-	1747873779,
-	1955562222,
-	2024104815,
-	2227730452,
-	2361852424,
-	2428436474,
-	2756734187,
-	3204031479,
-	3329325298
-]);
-const rotateRight = (value, count) => value >>> count | value << 32 - count;
-/**
-* Encode valid Unicode as UTF-8 while preserving lone UTF-16 surrogates as
-* their three-byte WTF-8 form. TextEncoder replaces every lone surrogate with
-* U+FFFD, which would make distinct JavaScript source strings hash identically.
-*/
-const encodeSource = (source) => {
-	const output = [];
-	for (let index = 0; index < source.length; index++) {
-		const first = source.charCodeAt(index);
-		let codePoint = first;
-		if (first >= 55296 && first <= 56319) {
-			const second = source.charCodeAt(index + 1);
-			if (second >= 56320 && second <= 57343) {
-				codePoint = 65536 + (first - 55296 << 10) + (second - 56320);
-				index++;
-			}
-		}
-		if (codePoint <= 127) output.push(codePoint);
-		else if (codePoint <= 2047) output.push(192 | codePoint >>> 6, 128 | codePoint & 63);
-		else if (codePoint <= 65535) output.push(224 | codePoint >>> 12, 128 | codePoint >>> 6 & 63, 128 | codePoint & 63);
-		else output.push(240 | codePoint >>> 18, 128 | codePoint >>> 12 & 63, 128 | codePoint >>> 6 & 63, 128 | codePoint & 63);
-	}
-	return Uint8Array.from(output);
-};
-/** Browser-safe synchronous SHA-256 for compiler identity tokens. */
-const sha256 = (source) => {
-	const bytes = encodeSource(source);
-	const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
-	const padded = new Uint8Array(paddedLength);
-	padded.set(bytes);
-	padded[bytes.length] = 128;
-	const view = new DataView(padded.buffer);
-	const bitLength = bytes.length * 8;
-	view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
-	view.setUint32(paddedLength - 4, bitLength >>> 0);
-	const state = new Uint32Array([
-		1779033703,
-		3144134277,
-		1013904242,
-		2773480762,
-		1359893119,
-		2600822924,
-		528734635,
-		1541459225
-	]);
-	const words = /* @__PURE__ */ new Uint32Array(64);
-	for (let offset = 0; offset < paddedLength; offset += 64) {
-		for (let index = 0; index < 16; index++) words[index] = view.getUint32(offset + index * 4);
-		for (let index = 16; index < 64; index++) {
-			const previous15 = words[index - 15];
-			const previous2 = words[index - 2];
-			const sigma0 = rotateRight(previous15, 7) ^ rotateRight(previous15, 18) ^ previous15 >>> 3;
-			const sigma1 = rotateRight(previous2, 17) ^ rotateRight(previous2, 19) ^ previous2 >>> 10;
-			words[index] = words[index - 16] + sigma0 + words[index - 7] + sigma1 >>> 0;
-		}
-		let a = state[0];
-		let b = state[1];
-		let c = state[2];
-		let d = state[3];
-		let e = state[4];
-		let f = state[5];
-		let g = state[6];
-		let h = state[7];
-		for (let index = 0; index < 64; index++) {
-			const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
-			const choice = e & f ^ ~e & g;
-			const temporary1 = h + sum1 + choice + ROUND_CONSTANTS[index] + words[index] >>> 0;
-			const temporary2 = (rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
-			h = g;
-			g = f;
-			f = e;
-			e = d + temporary1 >>> 0;
-			d = c;
-			c = b;
-			b = a;
-			a = temporary1 + temporary2 >>> 0;
-		}
-		state[0] = state[0] + a >>> 0;
-		state[1] = state[1] + b >>> 0;
-		state[2] = state[2] + c >>> 0;
-		state[3] = state[3] + d >>> 0;
-		state[4] = state[4] + e >>> 0;
-		state[5] = state[5] + f >>> 0;
-		state[6] = state[6] + g >>> 0;
-		state[7] = state[7] + h >>> 0;
-	}
-	return [...state].map((word) => word.toString(16).padStart(8, "0")).join("");
-};
-//#endregion
-//#region src/ops.ts
-var SmlOpError = class extends TaggedError("SmlOpError") {
-	constructor(args) {
-		super({
-			diagnostics: args.diagnostics,
-			message: args.diagnostics.map((diagnostic) => diagnostic.message).join("\n")
-		});
-	}
-};
-const zeroSpan = {
-	start: 0,
-	end: 0
-};
-const diagnostic = (code, message, span = zeroSpan) => ({
-	code,
-	message,
-	span
-});
-const cloneAttribute = (attribute) => ({ ...attribute });
-/**
-* Deep-copy a subtree, blanking every id to "". A duplicated node must not
-* alias the original's object graph or share its ids: batch ids resolve
-* against the pre-batch snapshot, and mapElement transforms every node whose
-* id matches — so two live copies sharing an id would both be rewritten by a
-* later op. Blank ids make the clone unaddressable (like any freshly created
-* node) until the next reprint reassigns positional ids.
-*/
-const cloneSubtree = (node) => {
-	if (node.kind === "element") return {
-		...node,
-		id: "",
-		attributes: node.attributes.map(cloneAttribute),
-		children: node.children.map(cloneSubtree)
-	};
-	return {
-		...node,
-		id: ""
-	};
-};
-const makeAttribute = (name, value) => ({
-	name,
-	value,
-	span: zeroSpan,
-	valueSpan: zeroSpan
-});
-const classAttr = (value) => makeAttribute("class", {
-	kind: "string",
-	value
-});
-const sourceRevision = (source) => `sml:${sha256(source)}`;
-const normalizeSml = (source) => {
-	const parsed = parseSml(source);
-	if (Result.isError(parsed)) return Result.err(parsed.error);
-	return Result.ok(printSml(parsed.value));
-};
-const findElement = (node, nodeId) => {
-	if (node.kind !== "element") return null;
-	if (node.id === nodeId) return node;
-	for (const child of node.children) {
-		const found = findElement(child, nodeId);
-		if (found !== null) return found;
-	}
-	return null;
-};
-const mapElement = (node, targetId, transform) => {
-	if (node.kind !== "element") return node;
-	if (node.id === targetId) return transform(node);
-	return {
-		...node,
-		children: node.children.map((child) => mapElement(child, targetId, transform))
-	};
-};
-const transformElement = (document, targetId, transform) => {
-	if (findElement(document.root, targetId) === null) return Result.err([diagnostic("op-target-not-found", `node "${targetId}" was not found in the current source`)]);
-	return Result.ok({
-		...document,
-		root: mapElement(document.root, targetId, transform)
-	});
-};
-const setElementAttribute = (element, name, value) => {
-	const rest = element.attributes.filter((attribute) => attribute.name !== name);
-	if (value === null || value.kind === "string" && value.value === "") return {
-		...element,
-		attributes: rest
-	};
-	const next = makeAttribute(name, value);
-	const attributes = element.attributes.some((attribute) => attribute.name === name) ? element.attributes.map((attribute) => attribute.name === name ? next : cloneAttribute(attribute)) : [...element.attributes, next];
-	return {
-		...element,
-		attributes
-	};
-};
-const setImageSchemeSource = (document, nodeId, scheme, value) => transformElement(document, nodeId, (element) => {
-	if (element.tag !== "Image") return element;
-	const src = value?.kind === "string" ? value.value : "";
-	const children = element.children.filter((child) => !(child.kind === "element" && child.tag === "Source" && child.attributes.some((attribute) => attribute.name === "scheme" && attribute.value.kind === "string" && attribute.value.value === scheme)));
-	if (src === "") return {
-		...element,
-		children
-	};
-	const sourceNode = {
-		kind: "element",
-		id: "",
-		tag: "Source",
-		attributes: [makeAttribute("scheme", {
-			kind: "string",
-			value: scheme
-		}), makeAttribute("src", {
-			kind: "string",
-			value: src
-		})],
-		children: [],
-		span: zeroSpan
-	};
-	return {
-		...element,
-		children: [...children, sourceNode]
-	};
-});
-const setProp = (document, op) => {
-	if (op.name === "src:dark") return setImageSchemeSource(document, op.nodeId, "dark", op.value);
-	return transformElement(document, op.nodeId, (element) => {
-		const value = op.name === "class" && op.value?.kind === "string" ? {
-			kind: "string",
-			value: op.value.value.trim().replace(/\s+/g, " ")
-		} : op.value;
-		return setElementAttribute(element, op.name, value);
-	});
-};
-const setChildren = (document, op) => transformElement(document, op.nodeId, (element) => ({
-	...element,
-	children: [...op.children]
-}));
-const makeColumn = () => ({
-	kind: "element",
-	id: "",
-	tag: "Column",
-	attributes: [classAttr("px-8")],
-	children: [{
-		kind: "element",
-		id: "",
-		tag: "Text",
-		attributes: [classAttr("text-base text-gray-700")],
-		children: [{
-			kind: "text",
-			id: "",
-			value: "Column",
-			span: zeroSpan
-		}],
-		span: zeroSpan
-	}],
-	span: zeroSpan
-});
-const makeBlock = (tag) => {
-	const base = (attributes, children) => ({
-		kind: "element",
-		id: "",
-		tag,
-		attributes,
-		children,
-		span: zeroSpan
-	});
-	const text = (value) => ({
-		kind: "text",
-		id: "",
-		value,
-		span: zeroSpan
-	});
-	switch (tag) {
-		case "Heading": return base([makeAttribute("level", {
-			kind: "number",
-			value: 2
-		}), classAttr("text-xl text-gray-900")], [text("Heading")]);
-		case "Text": return base([classAttr("text-base text-gray-700")], [text("Add your text here.")]);
-		case "Button": return base([makeAttribute("href", {
-			kind: "string",
-			value: "https://example.com"
-		}), classAttr("bg-blue-600 text-white px-20 py-12 rounded-md")], [text("Button")]);
-		case "Image": return base([
-			makeAttribute("src", {
-				kind: "string",
-				value: "https://placehold.co/600x200"
-			}),
-			makeAttribute("alt", {
-				kind: "string",
-				value: ""
-			}),
-			makeAttribute("width", {
-				kind: "number",
-				value: 600
-			})
-		], []);
-		case "Divider": return base([classAttr("border-gray-200")], []);
-		case "Spacer": return base([makeAttribute("height", {
-			kind: "number",
-			value: 24
-		})], []);
-		case "Section": return base([classAttr("py-16")], [makeBlock("Text")]);
-		case "Container": return base([classAttr("bg-white p-24")], [makeBlock("Text")]);
-		case "Row": return base([], [makeColumn(), makeColumn()]);
-		default: return base([], []);
-	}
-};
-const elementChildIndexToNodeIndex = (children, insertionIndex) => {
-	if (insertionIndex <= 0) {
-		const firstElement = children.findIndex((child) => child.kind === "element");
-		return firstElement === -1 ? children.length : firstElement;
-	}
-	let elementIndex = 0;
-	for (let index = 0; index < children.length; index++) {
-		if (children[index]?.kind !== "element") continue;
-		if (elementIndex === insertionIndex) return index;
-		elementIndex++;
-	}
-	return children.length;
-};
-const insertChildren = (document, childrenToInsert, referenceId, position) => {
-	if (childrenToInsert.length === 0) return Result.err([diagnostic("op-empty-insert", "insert operation produced no element nodes")]);
-	if (referenceId === null || referenceId === document.root.id) {
-		const children = position === "before" ? [...childrenToInsert, ...document.root.children] : [...document.root.children, ...childrenToInsert];
-		return Result.ok({
-			...document,
-			root: {
-				...document.root,
-				children
-			}
-		});
-	}
-	if (findElement(document.root, referenceId) === null) return Result.err([diagnostic("op-target-not-found", `node "${referenceId}" was not found in the current source`)]);
-	if (position === "inside") return transformElement(document, referenceId, (element) => ({
-		...element,
-		children: [...element.children, ...childrenToInsert]
-	}));
-	const insertInParent = (node) => {
-		if (node.kind !== "element") return node;
-		const index = node.children.findIndex((child) => child.kind === "element" && child.id === referenceId);
-		if (index >= 0) {
-			const at = position === "after" ? index + 1 : index;
-			return {
-				...node,
-				children: [
-					...node.children.slice(0, at),
-					...childrenToInsert,
-					...node.children.slice(at)
-				]
-			};
-		}
-		return {
-			...node,
-			children: node.children.map(insertInParent)
-		};
-	};
-	return Result.ok({
-		...document,
-		root: insertInParent(document.root)
-	});
-};
-const insertBlock = (document, op) => insertChildren(document, [makeBlock(op.tag)], op.referenceId, op.position);
-const insertSnippet = (document, op) => {
-	const rootTag = document.root.tag;
-	const parsed = parseSml(`<${rootTag}>${op.snippet}</${rootTag}>`);
-	if (Result.isError(parsed)) return Result.err(parsed.error.diagnostics);
-	const children = parsed.value.root.children.filter((child) => child.kind === "element");
-	return insertChildren(document, children, op.referenceId, op.position);
-};
-const removeNodeById = (document, nodeId) => {
-	if (document.root.id === nodeId) return Result.err([diagnostic("op-root-target", "the document root cannot be removed")]);
-	if (findElement(document.root, nodeId) === null) return Result.err([diagnostic("op-target-not-found", `node "${nodeId}" was not found in the current source`)]);
-	const prune = (node) => {
-		if (node.kind !== "element") return node;
-		return {
-			...node,
-			children: node.children.filter((child) => !(child.kind === "element" && child.id === nodeId)).map(prune)
-		};
-	};
-	return Result.ok({
-		...document,
-		root: prune(document.root)
-	});
-};
-const isDescendant = (ancestor, nodeId) => ancestor.children.some((child) => {
-	if (child.kind !== "element") return false;
-	return child.id === nodeId || isDescendant(child, nodeId);
-});
-const removeElement = (node, nodeId) => {
-	let removed = null;
-	const children = [];
-	for (const child of node.children) {
-		if (child.kind === "element" && child.id === nodeId) {
-			removed = child;
-			continue;
-		}
-		if (child.kind === "element") {
-			const result = removeElement(child, nodeId);
-			if (result.removed !== null) removed = result.removed;
-			children.push(result.node);
-		} else children.push(child);
-	}
-	return {
-		node: {
-			...node,
-			children
-		},
-		removed
-	};
-};
-const insertIntoParent = (node, targetParentId, insertionIndex, moved) => {
-	if (node.id === targetParentId) {
-		const at = elementChildIndexToNodeIndex(node.children, insertionIndex);
-		return {
-			...node,
-			children: [
-				...node.children.slice(0, at),
-				moved,
-				...node.children.slice(at)
-			]
-		};
-	}
-	return {
-		...node,
-		children: node.children.map((child) => child.kind === "element" ? insertIntoParent(child, targetParentId, insertionIndex, moved) : child)
-	};
-};
-const moveNode = (document, op) => {
-	if (document.root.id === op.nodeId) return Result.err([diagnostic("op-root-target", "the document root cannot be moved")]);
-	const moved = findElement(document.root, op.nodeId);
-	if (moved === null) return Result.err([diagnostic("op-target-not-found", `node "${op.nodeId}" was not found in the current source`)]);
-	const parent = findElement(document.root, op.targetParentId);
-	if (parent === null) return Result.err([diagnostic("op-target-not-found", `target parent "${op.targetParentId}" was not found in the current source`)]);
-	if (moved.id === parent.id || isDescendant(moved, parent.id)) return Result.err([diagnostic("op-invalid-reparent", "a node cannot be moved into itself or its descendants")]);
-	const channel = documentChannel(document);
-	const childModel = CHANNEL_TAG_SPECS[channel][parent.tag]?.content;
-	if (!(childModel === void 0 ? [] : allowedChildren(childModel)).includes(moved.tag)) return Result.err([diagnostic("op-invalid-reparent", `<${moved.tag}> is not allowed directly inside <${parent.tag}>`, parent.span)]);
-	const { node: rootWithoutMoved, removed } = removeElement(document.root, op.nodeId);
-	if (removed === null) return Result.err([diagnostic("op-target-not-found", `node "${op.nodeId}" was not found in the current source`)]);
-	return Result.ok({
-		...document,
-		root: insertIntoParent(rootWithoutMoved, op.targetParentId, op.insertionIndex, removed)
-	});
-};
-const duplicateNode = (document, nodeId) => {
-	if (document.root.id === nodeId) return Result.err([diagnostic("op-root-target", "the document root cannot be duplicated")]);
-	if (findElement(document.root, nodeId) === null) return Result.err([diagnostic("op-target-not-found", `node "${nodeId}" was not found in the current source`)]);
-	const insertClone = (node) => {
-		if (node.kind !== "element") return node;
-		const index = node.children.findIndex((child) => child.kind === "element" && child.id === nodeId);
-		if (index >= 0) {
-			const clone = cloneSubtree(node.children[index]);
-			return {
-				...node,
-				children: [
-					...node.children.slice(0, index + 1),
-					clone,
-					...node.children.slice(index + 1)
-				]
-			};
-		}
-		return {
-			...node,
-			children: node.children.map(insertClone)
-		};
-	};
-	return Result.ok({
-		...document,
-		root: insertClone(document.root)
-	});
-};
-const mutate = (document, op) => {
-	switch (op.type) {
-		case "setProp": return setProp(document, op);
-		case "setChildren": return setChildren(document, op);
-		case "insertBlock": return insertBlock(document, op);
-		case "insertSnippet": return insertSnippet(document, op);
-		case "moveNode": return moveNode(document, op);
-		case "duplicateNode": return duplicateNode(document, op.nodeId);
-		case "removeNode": return removeNodeById(document, op.nodeId);
-	}
-};
-const preflight = (source) => {
-	const reparsed = parseSml(source);
-	if (Result.isError(reparsed)) return Result.err(reparsed.error.diagnostics);
-	const compiled = compileSml(reparsed.value);
-	if (Result.isError(compiled)) return Result.err(compiled.error.diagnostics);
-	const compatibilityErrors = checkSmlCompatibility({ source }).filter(isBreakingCompatibilityCheck).map((message) => diagnostic("compatibility-error", message));
-	if (compatibilityErrors.length > 0) return Result.err(compatibilityErrors);
-	return Result.ok(reparsed.value);
-};
-const failedResult = (index, op, diagnostics) => ({
-	index,
-	status: "failed",
-	op,
-	diagnostics: [...diagnostics]
-});
-/**
-* Apply a batch of ops to SML source, returning the rewritten source, its new
-* revision, and a per-op result.
-*
-* Id contract: every id in the batch resolves against the id-space of the
-* source the caller read (the `expectedRevision` snapshot). Ids are positional
-* (`n0..nN` in document order) and are NOT rewritten between ops, so:
-*
-* - An op cannot target a node created earlier in the same batch — freshly
-*   inserted/duplicated nodes carry a blank id until the next reprint reassigns
-*   positional ids, and are unaddressable within the batch (fails with
-*   `op-target-not-found`).
-* - After `duplicateNode`, the duplicated id still addresses the ORIGINAL (the
-*   first match in document order); the clone is a blank-id copy.
-* - Structural ops (insert/remove/move) do not shift the ids of the nodes that
-*   survive, so a later op targeting a surviving sibling lands on the intended
-*   node regardless of what earlier ops did.
-*
-* Each op is still preflighted (reprint, reparse, compile, compatibility check)
-* as an independent validity gate; a failing op is recorded as `failed` and
-* does not advance the working document.
-*/
-const applyOps = (source, ops, options) => {
-	const parsed = parseSml(source);
-	if (Result.isError(parsed)) return Result.err(new SmlOpError({ diagnostics: parsed.error.diagnostics }));
-	const currentRevision = String(options?.currentRevision ?? sourceRevision(source));
-	if (options?.expectedRevision !== void 0 && String(options.expectedRevision) !== currentRevision) {
-		const stale = diagnostic("stale-revision", `source revision changed from ${String(options.expectedRevision)} to ${currentRevision}`);
-		return Result.ok({
-			source,
-			revision: currentRevision,
-			diagnostics: [stale],
-			results: ops.map((op, index) => failedResult(index, op, [stale]))
-		});
-	}
-	let currentSource = source;
-	let currentDocument = parsed.value;
-	const results = [];
-	const diagnostics = [];
-	ops.forEach((op, index) => {
-		const mutated = mutate(currentDocument, op);
-		if (Result.isError(mutated)) {
-			results.push(failedResult(index, op, mutated.error));
-			diagnostics.push(...mutated.error);
-			return;
-		}
-		const candidateSource = printSml(mutated.value);
-		const checked = preflight(candidateSource);
-		if (Result.isError(checked)) {
-			results.push(failedResult(index, op, checked.error));
-			diagnostics.push(...checked.error);
-			return;
-		}
-		currentSource = candidateSource;
-		currentDocument = mutated.value;
-		results.push({
-			index,
-			status: "applied",
-			op,
-			diagnostics: []
-		});
-	});
-	return Result.ok({
-		source: currentSource,
-		revision: sourceRevision(currentSource),
-		diagnostics,
-		results
-	});
-};
-const applyOp = (source, op, options) => applyOps(source, [op], options);
-//#endregion
-export { sourceRevision as a, normalizeSml as i, applyOp as n, applyOps as r, SmlOpError as t };
-
-//# sourceMappingURL=ops-BvwqHl7V.js.map