@phtngyn/cms 0.1.0-beta.0

package/src/AuthoringSchema-BQ5kbhVB.js

@@ -0,0 +1,926 @@
+import { n as CmsMarkdownDocument } from "./models-Citx8jBi.js";
+import { a as createEditorNodeId, c as createCmsComarkRenderData, f as toMutableComarkAttributes, l as mutableJson, n as editorMetadata, o as editorNodeId, u as mutableJsonObject } from "./metadata-Czvi3E4K.js";
+import { Effect, Option, Predicate, Schema } from "effect";
+import { resolveAttributes } from "comark/utils";
+import { createMarkdownParser } from "comark/parse";
+import alert from "comark/plugins/alert";
+import attributes from "comark/plugins/attributes";
+import components from "comark/plugins/components";
+import frontmatter from "comark/plugins/frontmatter";
+import headings from "comark/plugins/headings";
+import security from "comark/plugins/security";
+import taskList from "comark/plugins/task-list";
+import toc from "comark/plugins/toc";
+import { Extension } from "@tiptap/core";
+import { ySyncPluginKey } from "@tiptap/y-tiptap";
+
+//#region ../document/src/internal/comark/bindings.ts
+const isJsonObject$3 = Schema.is(Schema.JsonObject);
+const decodeJson = Schema.decodeUnknownOption(Schema.Json);
+/** Normalizes bindings exactly as Comark's framework renderers do before passing props to a component. */
+function resolveCmsComarkAttributes(attributes, renderData) {
+	const resolved = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(resolveAttributes(toMutableComarkAttributes(attributes), renderData, { parseJson: true }))) {
+		if (Predicate.isUndefined(value)) {
+			resolved.set(name, void 0);
+			continue;
+		}
+		const decoded = decodeJson(value);
+		if (Option.isNone(decoded)) throw new Error(`Comark resolved non-JSON attribute "${name}".`);
+		resolved.set(name, decoded.value);
+	}
+	return resolved;
+}
+/** Projects bindings to editable values while retaining enough metadata to reconstruct their authored form. */
+function projectCmsEditorComponentAttributes(attributes, renderData) {
+	const resolved = resolveCmsComarkAttributes(attributes, renderData);
+	const props = {};
+	for (const [name, value] of resolved) if (!Predicate.isUndefined(value)) props[name] = mutableJson(value);
+	const bindings = {};
+	for (const [authoredName, authoredValue] of Object.entries(attributes)) {
+		if (!authoredName.startsWith(":") || authoredName.length === 1) continue;
+		const name = authoredName.slice(1);
+		if (!resolved.has(name)) continue;
+		const literal = jsonLiteral(authoredValue);
+		if (!Predicate.isString(authoredValue) || literal !== authoredValue) {
+			bindings[name] = { kind: "literal" };
+			continue;
+		}
+		const resolvedValue = resolved.get(name);
+		bindings[name] = Object.assign({
+			expression: authoredValue,
+			kind: "expression"
+		}, Predicate.isUndefined(resolvedValue) ? void 0 : { resolved: mutableJson(resolvedValue) });
+	}
+	return {
+		bindings,
+		props,
+		renderData: withCmsComarkProps(renderData, resolved)
+	};
+}
+/** Reconstructs authored bindings, keeping expressions until a user replaces their resolved value. */
+function encodeCmsEditorComponentAttributes(props, bindings) {
+	const attributes = mutableJsonObject(props);
+	for (const [name, encodedBinding] of Object.entries(bindings)) {
+		const binding = jsonObject$2(encodedBinding);
+		const kind = binding.kind;
+		if (kind !== "literal" && kind !== "expression") continue;
+		const current = props[name];
+		if (Predicate.isUndefined(current)) {
+			const expression = binding.expression;
+			if (kind === "expression" && Predicate.isString(expression)) attributes[`:${name}`] = expression;
+			continue;
+		}
+		delete attributes[name];
+		const expression = binding.expression;
+		const resolved = binding.resolved;
+		attributes[`:${name}`] = kind === "expression" && Predicate.isString(expression) && Object.hasOwn(binding, "resolved") && sameJson(current, resolved) ? expression : mutableJson(current);
+	}
+	return attributes;
+}
+function withCmsComarkProps(renderData, attributes) {
+	return attributes.size > 0 ? {
+		...renderData,
+		props: Object.fromEntries(attributes)
+	} : renderData;
+}
+/** Restores typed component bindings that Comark's block-YAML roundtrip can emit as plain attributes. */
+function normalizeCmsComponentBindings(document, components) {
+	if (!components) return document;
+	return CmsMarkdownDocument.make({
+		frontmatter: document.frontmatter,
+		meta: document.meta,
+		nodes: document.nodes.map((node) => normalizeComponentNode(node, components))
+	});
+}
+function matchesCmsComponentPropType(value, type) {
+	switch (type) {
+		case "array": return Array.isArray(value);
+		case "boolean": return Predicate.isBoolean(value);
+		case "number": return Predicate.isNumber(value);
+		case "object": return isJsonObject$3(value);
+		case "string": return Predicate.isString(value);
+	}
+}
+function normalizeComponentNode(node, components) {
+	if (Predicate.isString(node) || node[0] === null) return node;
+	const [tag, originalAttributes, ...originalChildren] = node;
+	const attributes = mutableJsonObject(originalAttributes);
+	const definition = components.get(tag.toLocaleLowerCase());
+	if (definition) for (const prop of definition.props) {
+		if (prop.type === "string" || `:${prop.name}` in attributes || !(prop.name in attributes)) continue;
+		const value = attributes[prop.name];
+		if (Predicate.isUndefined(value)) continue;
+		if (!matchesCmsComponentPropType(jsonLiteral(value), prop.type)) continue;
+		delete attributes[prop.name];
+		attributes[`:${prop.name}`] = value;
+	}
+	return [
+		tag,
+		attributes,
+		...originalChildren.map((child) => normalizeComponentNode(child, components))
+	];
+}
+function jsonLiteral(value) {
+	if (!Predicate.isString(value)) return value;
+	try {
+		const decoded = decodeJson(JSON.parse(value));
+		return Option.isSome(decoded) ? decoded.value : value;
+	} catch {
+		return value;
+	}
+}
+function jsonObject$2(value) {
+	return isJsonObject$3(value) ? value : {};
+}
+function sameJson(left, right) {
+	return !Predicate.isUndefined(right) && JSON.stringify(left) === JSON.stringify(right);
+}
+
+//#endregion
+//#region ../document/src/internal/comark/source-mapping.ts
+const SOURCE_MAPPINGS_META_KEY = "__cmsSourceMappings";
+const BLOCK_TAGS = /* @__PURE__ */ new Map([
+	["blockquote_open", "blockquote"],
+	["bullet_list_open", "ul"],
+	["list_item_open", "li"],
+	["ordered_list_open", "ol"],
+	["paragraph_open", "p"],
+	["table_open", "table"],
+	["tbody_open", "tbody"],
+	["td_open", "td"],
+	["th_open", "th"],
+	["thead_open", "thead"],
+	["tr_open", "tr"]
+]);
+const ComarkToken = Schema.Struct({
+	attrs: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.Tuple([Schema.String, Schema.String])))),
+	hidden: Schema.optionalKey(Schema.Boolean),
+	level: Schema.optionalKey(Schema.Finite),
+	map: Schema.optionalKey(Schema.NullOr(Schema.Tuple([Schema.Finite, Schema.Finite]))),
+	nesting: Schema.optionalKey(Schema.Finite),
+	tag: Schema.optionalKey(Schema.String),
+	type: Schema.optionalKey(Schema.String)
+});
+const WRAPPER_TAGS = /* @__PURE__ */ new Set([
+	"blockquote",
+	"ol",
+	"pre",
+	"table",
+	"ul"
+]);
+/** Captures the durable source before frontmatter or other pre-parse stages mutate it. */
+function sourceCapturePlugin() {
+	return {
+		name: "cms-source-capture",
+		pre(state) {
+			state.__cmsOriginalMarkdown = state.markdown;
+		}
+	};
+}
+/** Translate Comark block token line maps into exact JavaScript source offsets. */
+function sourceMappingPlugin() {
+	return {
+		name: "cms-source-mapping",
+		post(state) {
+			const source = state.__cmsOriginalMarkdown ?? state.markdown;
+			const descriptors = createBlockDescriptors(state.tokens.flatMap((token) => {
+				const decoded = Schema.decodeUnknownOption(ComarkToken)(token);
+				return decoded._tag === "Some" ? [decoded.value] : [];
+			}), source, state.markdown, state.parsedLines ?? 0);
+			const mappings = [];
+			mapNodes(state.tree.nodes, descriptors, [], mappings);
+			state.tree.meta[SOURCE_MAPPINGS_META_KEY] = mappings;
+		}
+	};
+}
+function createBlockDescriptors(tokens, source, parsedMarkdown, parsedLines) {
+	const roots = [];
+	const stack = [];
+	const sourceLineStarts = indexLineStarts(source);
+	const parsedLineStarts = indexLineStarts(parsedMarkdown);
+	const parsedOffset = source.lastIndexOf(parsedMarkdown);
+	const slotMaps = createSlotTokenMaps(tokens, parsedMarkdown);
+	for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex++) {
+		const token = tokens[tokenIndex];
+		if (!token) continue;
+		const tag = blockTag(token);
+		const tokenMap = token.map ?? slotMaps.get(tokenIndex);
+		if (!tag || !tokenMap) continue;
+		const level = token.level ?? 0;
+		while (true) {
+			const current = stack.at(-1);
+			if (!current || current.level < level) break;
+			stack.pop();
+		}
+		const descriptor = {
+			children: [],
+			range: rangeFromParsedLines(source, sourceLineStarts, parsedMarkdown, parsedLineStarts, parsedOffset, tokenMap[0], tokenMap[1] + (token.type === "mdc_block_open" ? 1 : 0), parsedLines),
+			tag
+		};
+		((stack.at(-1)?.descriptor)?.children ?? roots).push(descriptor);
+		if (token.nesting === 1) stack.push({
+			descriptor,
+			level
+		});
+	}
+	return roots.map(collapseComarkWrapper).map(groupProjectedSlotContent);
+}
+function blockTag(token) {
+	if (token.hidden || !token.type) return void 0;
+	if (token.type === "heading_open") return token.tag;
+	if (token.type === "mdc_block_open" || token.type === "mdc_block_shorthand" && token.nesting !== -1) return token.tag || "component";
+	if (token.type === "mdc_block_slot" && token.nesting === 1) return "template";
+	if ([
+		"fence",
+		"fenced_code_block",
+		"code_block"
+	].includes(token.type)) return "pre";
+	if (token.type === "math_block") return "math";
+	if (token.type === "html_block") return "*";
+	if (token.type === "hr") return "hr";
+	return BLOCK_TAGS.get(token.type);
+}
+function createSlotTokenMaps(tokens, parsedMarkdown) {
+	const maps = /* @__PURE__ */ new Map();
+	const markers = slotMarkers(parsedMarkdown);
+	const stack = [];
+	let nextMarker = 0;
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (!token || token.type !== "mdc_block_slot") continue;
+		if (token.nesting === 1) {
+			const name = token.attrs?.[0]?.[0]?.replace(/^#/u, "");
+			let markerIndex = nextMarker;
+			while (markerIndex < markers.length && markers[markerIndex]?.name !== name) markerIndex++;
+			const marker = markers[markerIndex];
+			if (marker) {
+				stack.push({
+					index,
+					marker: marker.line
+				});
+				nextMarker = markerIndex + 1;
+			}
+			continue;
+		}
+		if (token.nesting !== -1) continue;
+		const open = stack.pop();
+		if (!open) continue;
+		let endLine = open.marker + 1;
+		for (let childIndex = open.index + 1; childIndex < index; childIndex++) {
+			const child = tokens[childIndex];
+			const map = child?.map ?? maps.get(childIndex);
+			if (child && map) endLine = Math.max(endLine, map[1] + (child.type === "mdc_block_open" ? 1 : 0));
+		}
+		maps.set(open.index, [open.marker, endLine]);
+	}
+	return maps;
+}
+function slotMarkers(source) {
+	return source.split(/\r?\n/u).flatMap((line, index) => {
+		const name = line.match(/^\s*#([^\s{]+)/u)?.[1];
+		return name ? [{
+			line: index,
+			name
+		}] : [];
+	});
+}
+function collapseComarkWrapper(descriptor) {
+	const children = descriptor.children.map(collapseComarkWrapper);
+	if (WRAPPER_TAGS.has(descriptor.tag) && children.length === 1 && children[0]?.tag === descriptor.tag) return {
+		...descriptor,
+		children: children[0].children
+	};
+	return {
+		...descriptor,
+		children
+	};
+}
+/** Comark projects siblings after a named slot into that active slot. */
+function groupProjectedSlotContent(descriptor) {
+	const grouped = [];
+	let activeSlot;
+	for (const rawChild of descriptor.children) {
+		const child = groupProjectedSlotContent(rawChild);
+		if (child.tag === "template") {
+			activeSlot = child;
+			grouped.push(child);
+			continue;
+		}
+		if (!activeSlot) {
+			grouped.push(child);
+			continue;
+		}
+		activeSlot.children.push(child);
+		if (child.range.end.offset > activeSlot.range.end.offset) activeSlot.range = {
+			start: activeSlot.range.start,
+			end: child.range.end
+		};
+	}
+	return {
+		...descriptor,
+		children: grouped
+	};
+}
+function mapNodes(nodes, descriptors, parentPath, mappings) {
+	let descriptorIndex = 0;
+	for (let nodeIndex = 0; nodeIndex < nodes.length; nodeIndex++) {
+		const node = nodes[nodeIndex];
+		if (!node || !isElementNode$1(node)) continue;
+		let matchIndex = descriptorIndex;
+		while (matchIndex < descriptors.length && descriptors[matchIndex]?.tag !== "*" && descriptors[matchIndex]?.tag !== node[0]) matchIndex++;
+		const descriptor = descriptors[matchIndex];
+		if (!descriptor) continue;
+		descriptorIndex = matchIndex + 1;
+		const nodePath = [...parentPath, nodeIndex];
+		mappings.push({
+			nodePath,
+			range: descriptor.range
+		});
+		const [, , ...children] = node;
+		mapNodes(children, descriptor.children, nodePath, mappings);
+	}
+}
+function isElementNode$1(node) {
+	return Array.isArray(node) && Predicate.isString(node[0]);
+}
+function indexLineStarts(source) {
+	const starts = [0];
+	for (let offset = 0; offset < source.length; offset++) if (source.charCodeAt(offset) === 10) starts.push(offset + 1);
+	return starts;
+}
+function rangeFromParsedLines(source, sourceLineStarts, parsedMarkdown, parsedLineStarts, parsedOffset, startLine, endLine, fallbackLineOffset) {
+	const startOffset = parsedOffset >= 0 ? parsedOffset + (parsedLineStarts[startLine] ?? parsedMarkdown.length) : sourceLineStarts[startLine + fallbackLineOffset] ?? source.length;
+	const endOffset = parsedOffset >= 0 ? parsedOffset + (parsedLineStarts[endLine] ?? parsedMarkdown.length) : sourceLineStarts[endLine + fallbackLineOffset] ?? source.length;
+	return {
+		start: pointAt(source, sourceLineStarts, startOffset),
+		end: pointAt(source, sourceLineStarts, Math.max(startOffset, endOffset))
+	};
+}
+function pointAt(source, lineStarts, rawOffset) {
+	const offset = Math.min(Math.max(rawOffset, 0), source.length);
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		if ((lineStarts[middle] ?? source.length) <= offset) low = middle;
+		else high = middle - 1;
+	}
+	return {
+		offset,
+		line: low + 1,
+		column: offset - (lineStarts[low] ?? 0) + 1
+	};
+}
+
+//#endregion
+//#region ../document/src/internal/comark/grammar.ts
+/**
+* Changes when parsing, normalization, or projection semantics change. Stored
+* with compiled documents so migrations can identify stale derived content.
+*/
+const DOCUMENT_ENGINE_FINGERPRINT = "comark@0.6.2/frontmatter+alert+task-list+components+attributes+security+headings+toc+source-mapping/v1";
+/** One explicit grammar for authoring, preview, delivery, and analysis projections. */
+function createDocumentParser() {
+	return createMarkdownParser({
+		autoClose: false,
+		registerDefaultPlugins: false,
+		plugins: [
+			sourceCapturePlugin(),
+			frontmatter(),
+			alert(),
+			taskList(),
+			components(),
+			attributes(),
+			security(),
+			headings(),
+			toc({
+				depth: 5,
+				searchDepth: 6
+			}),
+			sourceMappingPlugin()
+		]
+	});
+}
+
+//#endregion
+//#region ../document/src/internal/editor/attributes.ts
+function compactJsonAttributes(attributes) {
+	return Object.fromEntries(Object.entries(attributes).filter((entry) => entry[1] !== void 0));
+}
+function nonEmptyStringAttribute(value) {
+	return Predicate.isString(value) && value ? value : void 0;
+}
+function finiteNumberAttribute(value, fallback) {
+	const number = Predicate.isNumber(value) ? value : Number(value);
+	return Number.isFinite(number) ? number : fallback;
+}
+
+//#endregion
+//#region ../document/src/internal/editor/image.ts
+const isJsonObject$2 = Schema.is(Schema.JsonObject);
+const EditorImageLayout = Schema.Literals([
+	"natural",
+	"content",
+	"full"
+]);
+const isEditorImageLayout = Schema.is(EditorImageLayout);
+const EDITOR_IMAGE_LAYOUT_ATTRIBUTE = "data-cms-layout";
+const IMAGE_DECORATIVE_ATTRIBUTE = "data-cms-decorative";
+const IMAGE_SEMANTIC_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"alt",
+	IMAGE_DECORATIVE_ATTRIBUTE,
+	EDITOR_IMAGE_LAYOUT_ATTRIBUTE,
+	"src",
+	"title"
+]);
+function decodeEditorImageAttributes(attributes) {
+	const cmsProps = Object.fromEntries(Object.entries(attributes).filter(([name]) => !IMAGE_SEMANTIC_ATTRIBUTES.has(name)));
+	return compactJsonAttributes({
+		alt: attributes[IMAGE_DECORATIVE_ATTRIBUTE] !== void 0 ? "" : Predicate.isString(attributes.alt) ? attributes.alt : null,
+		cmsProps: Object.keys(cmsProps).length ? cmsProps : null,
+		layout: normalizeEditorImageLayout(attributes[EDITOR_IMAGE_LAYOUT_ATTRIBUTE]),
+		src: stringValue(attributes.src) || null,
+		title: stringValue(attributes.title) || null
+	});
+}
+function encodeEditorImageAttributes(value) {
+	const attributes = jsonObject$1(value);
+	const alt = attributes.alt;
+	const layout = normalizeEditorImageLayout(attributes.layout);
+	return compactJsonAttributes(Object.assign({}, jsonObject$1(attributes.cmsProps), {
+		alt: Predicate.isString(alt) ? alt : void 0,
+		[IMAGE_DECORATIVE_ATTRIBUTE]: alt === "" ? "true" : void 0,
+		[EDITOR_IMAGE_LAYOUT_ATTRIBUTE]: layout === "natural" ? void 0 : layout,
+		src: stringValue(attributes.src) || void 0,
+		title: stringValue(attributes.title) || void 0
+	}));
+}
+function normalizeEditorImageLayout(value) {
+	return isEditorImageLayout(value) ? value : "natural";
+}
+function jsonObject$1(value) {
+	return isJsonObject$2(value) ? value : {};
+}
+function stringValue(value) {
+	return Predicate.isString(value) || Predicate.isNumber(value) ? String(value) : "";
+}
+
+//#endregion
+//#region ../document/src/internal/editor/marks.ts
+const EDITOR_MARKS = [
+	["bold", "strong"],
+	["code", "code"],
+	["italic", "em"],
+	["link", "a"],
+	["strike", "del"],
+	["underline", "u"]
+];
+const EDITOR_MARK_TYPES = EDITOR_MARKS.map(([type]) => type);
+const editorToComark = new Map(EDITOR_MARKS);
+const comarkToEditor$1 = new Map(EDITOR_MARKS.map(([type, tag]) => [tag, type]));
+function comarkTagForEditorMark(type) {
+	return editorToComark.get(type);
+}
+function editorMarkForComarkTag(tag) {
+	return comarkToEditor$1.get(tag);
+}
+function isEditorMark(type) {
+	return editorToComark.has(type);
+}
+function isComarkMark(tag) {
+	return comarkToEditor$1.has(tag);
+}
+
+//#endregion
+//#region ../document/src/internal/comark/to-editor.ts
+const isJsonObject$1 = Schema.is(Schema.JsonObject);
+const OPAQUE_BLOCK_TAGS = /* @__PURE__ */ new Set([
+	"math",
+	"table",
+	"tbody",
+	"td",
+	"th",
+	"thead",
+	"tr"
+]);
+function comarkToEditor(nodes, renderData = {
+	data: {},
+	frontmatter: {},
+	meta: {},
+	props: {}
+}) {
+	return decodeBlocks(nodes, { usedIds: /* @__PURE__ */ new Set() }, renderData);
+}
+function decodeBlocks(nodes, context, renderData, wrapInlineContent = false) {
+	const content = [];
+	let inlineNodes = [];
+	const flushInlineNodes = () => {
+		const inline = decodeInlines(inlineNodes, context, renderData);
+		if (inline.length) content.push({
+			type: "paragraph",
+			attrs: wrapInlineContent ? { cmsSynthetic: true } : { cmsNodeId: claimIdentity(context) },
+			content: inline
+		});
+		inlineNodes = [];
+	};
+	for (const node of nodes) {
+		if (Predicate.isString(node) || isInlineElement(node)) {
+			inlineNodes.push(node);
+			continue;
+		}
+		flushInlineNodes();
+		content.push(decodeBlock(node, context, renderData));
+	}
+	flushInlineNodes();
+	return content;
+}
+function decodeBlock(node, context, renderData) {
+	if (node[0] === null) return opaqueBlock(node, "Comment", claimIdentity(context, node[1]));
+	const [tag, rawAttributes, ...children] = node;
+	const attrs = cleanAttrs(rawAttributes);
+	const childRenderData = withCmsComarkProps(renderData, resolveCmsComarkAttributes(rawAttributes, renderData));
+	const metadata = editorMetadata(rawAttributes);
+	const cmsNodeId = claimIdentity(context, rawAttributes);
+	const commonAttrs = compactJsonAttributes({
+		cmsNodeId,
+		cmsProps: attrs
+	});
+	if (/^h[1-6]$/u.test(tag)) return {
+		type: "heading",
+		attrs: mergeJsonAttributes(commonAttrs, { level: Number(tag.slice(1)) }),
+		content: decodeInlines(children, context, childRenderData)
+	};
+	switch (tag) {
+		case "p": return {
+			type: "paragraph",
+			attrs: commonAttrs,
+			content: decodeInlines(children, context, childRenderData)
+		};
+		case "blockquote": return {
+			type: "blockquote",
+			attrs: commonAttrs,
+			content: decodeBlocks(children, context, childRenderData)
+		};
+		case "ul": return {
+			type: "bulletList",
+			attrs: commonAttrs,
+			content: decodeListItems(children, context, childRenderData)
+		};
+		case "ol": return {
+			type: "orderedList",
+			attrs: mergeJsonAttributes(commonAttrs, { start: finiteNumberAttribute(attrs.start, 1) }),
+			content: decodeListItems(children, context, childRenderData)
+		};
+		case "li": return {
+			type: "listItem",
+			attrs: commonAttrs,
+			content: decodeBlocks(children, context, childRenderData)
+		};
+		case "pre": {
+			const code = children.find(isElementNode);
+			return {
+				type: "codeBlock",
+				attrs: mergeJsonAttributes(commonAttrs, { language: nonEmptyStringAttribute(attrs.language) ?? nonEmptyStringAttribute(code?.[1].class)?.replace(/^language-/u, "") }),
+				content: textContent$1(code ? elementChildren(code) : children)
+			};
+		}
+		case "hr": return {
+			type: "horizontalRule",
+			attrs: commonAttrs
+		};
+		default:
+			if (OPAQUE_BLOCK_TAGS.has(tag)) return opaqueBlock(node, tag, cmsNodeId);
+			const projection = projectCmsEditorComponentAttributes(rawAttributes, renderData);
+			return {
+				type: "cmsBlock",
+				attrs: compactJsonAttributes({
+					bindings: projection.bindings,
+					cmsNodeId,
+					props: projection.props,
+					tag
+				}),
+				content: decodeComponentSlots(children, context, projection.renderData, metadata?.implicitSlotId)
+			};
+	}
+}
+function decodeComponentSlots(children, context, renderData, implicitSlotId) {
+	const templates = children.filter(isSlotTemplate);
+	const regular = children.filter((node) => !isSlotTemplate(node));
+	const slots = templates.map((node) => decodeSlot(node, context, renderData));
+	if (!regular.length) return slots;
+	const defaultContent = slotContent(decodeBlocks(regular, context, renderData, true));
+	const explicitDefault = slots.find((slot) => slot.attrs?.name === "default");
+	if (explicitDefault) {
+		explicitDefault.content = [...explicitDefault.content ?? [], ...defaultContent];
+		return slots;
+	}
+	return [{
+		type: "cmsSlot",
+		attrs: {
+			cmsNodeId: claimIdentityValue(context, implicitSlotId),
+			implicit: true,
+			name: "default",
+			props: {}
+		},
+		content: defaultContent
+	}, ...slots];
+}
+function decodeSlot(node, context, renderData) {
+	const attrs = cleanAttrs(node[1]);
+	const childRenderData = withCmsComarkProps(renderData, resolveCmsComarkAttributes(node[1], renderData));
+	const name = slotName(attrs);
+	const { name: _name, ...slotProps } = attrs;
+	return {
+		type: "cmsSlot",
+		attrs: {
+			cmsNodeId: claimIdentity(context, node[1]),
+			implicit: false,
+			name,
+			props: slotProps
+		},
+		content: slotContent(decodeBlocks(elementChildren(node), context, childRenderData, true))
+	};
+}
+function decodeListItems(nodes, context, renderData) {
+	return nodes.filter(isElementNode).filter((node) => node[0] === "li").map((node) => decodeBlock(node, context, renderData));
+}
+function decodeInlines(nodes, context, renderData, inheritedMarks = []) {
+	const result = [];
+	for (const node of nodes) {
+		if (Predicate.isString(node)) {
+			if (node) result.push(withMarks({
+				type: "text",
+				text: node
+			}, inheritedMarks));
+			continue;
+		}
+		if (node[0] === null) {
+			result.push(withMarks({
+				type: "cmsInlineOpaque",
+				attrs: {
+					label: "Comment",
+					node: stripInternalMetadata(node)
+				}
+			}, inheritedMarks));
+			continue;
+		}
+		const markType = editorMarkForComarkTag(node[0]);
+		if (markType) {
+			const attrs = cleanAttrs(node[1]);
+			const childRenderData = withCmsComarkProps(renderData, resolveCmsComarkAttributes(node[1], renderData));
+			const markAttrs = markType === "link" ? mergeJsonAttributes(attrs, { cmsProps: attrs }) : Object.keys(attrs).length ? { cmsProps: attrs } : void 0;
+			const mark = markAttrs === void 0 ? { type: markType } : {
+				attrs: markAttrs,
+				type: markType
+			};
+			result.push(...decodeInlines(elementChildren(node), context, childRenderData, [...inheritedMarks, mark]));
+			continue;
+		}
+		if (node[0] === "br") {
+			result.push(withMarks({ type: "hardBreak" }, inheritedMarks));
+			continue;
+		}
+		if (node[0] === "img") {
+			result.push(withMarks({
+				type: "image",
+				attrs: mergeJsonAttributes(decodeEditorImageAttributes(cleanAttrs(node[1])), { cmsNodeId: claimIdentity(context, node[1]) })
+			}, inheritedMarks));
+			continue;
+		}
+		result.push(withMarks({
+			type: "cmsInlineOpaque",
+			attrs: {
+				label: node[0],
+				node: stripInternalMetadata(node)
+			}
+		}, inheritedMarks));
+	}
+	return result;
+}
+function claimIdentity(context, attributes) {
+	return claimIdentityValue(context, attributes ? editorMetadata(attributes)?.nodeId : void 0);
+}
+function claimIdentityValue(context, candidate) {
+	const existing = editorNodeId(candidate);
+	if (existing !== void 0 && !context.usedIds.has(existing)) {
+		context.usedIds.add(existing);
+		return existing;
+	}
+	for (let attempt = 0; attempt < 100; attempt++) {
+		const created = createEditorNodeId();
+		if (!context.usedIds.has(created)) {
+			context.usedIds.add(created);
+			return created;
+		}
+	}
+	throw new Error("The editor identity factory did not produce a unique identity.");
+}
+function opaqueBlock(node, label, cmsNodeId) {
+	return {
+		type: "cmsOpaque",
+		attrs: {
+			cmsNodeId,
+			label,
+			node: stripInternalMetadata(node)
+		}
+	};
+}
+function stripInternalMetadata(node) {
+	if (node[0] === null) return [
+		null,
+		cleanAttrs(node[1]),
+		node[2]
+	];
+	const [tag, attributes, ...children] = node;
+	return [
+		tag,
+		cleanAttrs(attributes),
+		...children.map((child) => Predicate.isString(child) ? child : stripInternalMetadata(child))
+	];
+}
+function slotContent(content) {
+	return content.length ? content : [{
+		type: "paragraph",
+		attrs: { cmsSynthetic: true }
+	}];
+}
+function slotName(attrs) {
+	return nonEmptyStringAttribute(attrs.name) ?? "default";
+}
+function cleanAttrs(attrs) {
+	const { $: _internal, "data-cms-node": _marker, ...clean } = attrs;
+	return structuredClone(clean);
+}
+function textContent$1(nodes) {
+	const text = nodes.map((node) => Predicate.isString(node) ? node : node[0] === null ? node[2] : textContent$1(elementChildren(node))?.map((child) => child.text ?? "").join("") ?? "").join("");
+	return text ? [{
+		type: "text",
+		text
+	}] : void 0;
+}
+function isInlineElement(node) {
+	return node[0] !== null && (isComarkMark(node[0]) || node[0] === "br" || node[0] === "img" || jsonObject(node[1].$).block === 0);
+}
+function isSlotTemplate(node) {
+	return isElementNode(node) && node[0] === "template";
+}
+function isElementNode(node) {
+	return Array.isArray(node) && Predicate.isString(node[0]);
+}
+function elementChildren(node) {
+	const [, , ...children] = node;
+	return children;
+}
+function jsonObject(value) {
+	return isJsonObject$1(value) ? value : {};
+}
+function mergeJsonAttributes(attributes, additions) {
+	return compactJsonAttributes(Object.assign({}, attributes, additions));
+}
+function withMarks(content, marks) {
+	return marks.length ? Object.assign({}, content, { marks }) : content;
+}
+
+//#endregion
+//#region ../document/src/internal/editor/errors.ts
+var EditorDocumentInvalid = class extends Schema.TaggedError()("EditorDocument.Invalid", {
+	message: Schema.NonEmptyString,
+	cause: Schema.Defect()
+}) {};
+var EditorRenderFailed = class extends Schema.TaggedError()("EditorDocument.RenderFailed", { cause: Schema.Defect() }) {};
+
+//#endregion
+//#region ../document/src/AuthoringSchema.ts
+/** Compiles insertion content with the same grammar used for publication. */
+const parseAuthoringContent = Effect.fn("AuthoringSchema.parseContent")(function* (markdown) {
+	const body = yield* Effect.tryPromise({
+		try: () => createDocumentParser()(markdown),
+		catch: (cause) => new EditorDocumentInvalid({
+			cause,
+			message: "Invalid initial Markdown content."
+		})
+	});
+	return (yield* Schema.decodeUnknownEffect(CmsMarkdownDocument)(body)).nodes;
+});
+const isJsonObject = Schema.is(Schema.JsonObject);
+/** Validates authored blocks during single-document compilation as well as catalog publication. */
+function validateAuthoringDocument(body, components) {
+	if (!components || ![...components.values()].some((component) => component.authoring)) return [];
+	function visit(node) {
+		const component = node.type === "cmsBlock" ? components?.get(String(node.attrs?.tag).toLowerCase()) : void 0;
+		return [...component?.authoring ? createAuthoringSchema(component.name, component.authoring).validate(node, "publish") : [], ...(node.content ?? []).flatMap(visit)];
+	}
+	return comarkToEditor(body.nodes, createCmsComarkRenderData(body)).flatMap(visit);
+}
+function createAuthoringSchema(name, definition) {
+	const fields = new Map(definition.props.map((field) => [field.name, field]));
+	const slots = new Map(definition.slots.map((slot) => [slot.name, slot]));
+	if (fields.size !== definition.props.length || slots.size !== definition.slots.length) throw new Error(`${definition.label}: authoring names must be unique.`);
+	const initialProps = {
+		...Object.fromEntries(definition.props.flatMap((field) => field.defaultValue === void 0 ? [] : [[field.name, field.defaultValue]])),
+		...definition.initialProps
+	};
+	for (const field of definition.props) {
+		if (field.defaultValue === void 0) continue;
+		const issue = propertyIssue(field, field.defaultValue, "working");
+		if (issue) throw new Error(`Invalid default for ${definition.label}: ${issue}`);
+	}
+	function createSlot(slotName) {
+		const slot = slots.get(slotName);
+		if (!slot) throw new Error(`${definition.label}: unknown content region ${slotName}.`);
+		const content = slot.initial ? comarkToEditor(slot.initial) : [];
+		return {
+			type: "cmsSlot",
+			attrs: {
+				cmsNodeId: createEditorNodeId(),
+				name: slotName,
+				implicit: slotName === "default",
+				props: {}
+			},
+			content: content.length ? content : [{
+				type: "paragraph",
+				attrs: { cmsNodeId: createEditorNodeId() }
+			}]
+		};
+	}
+	function createContent() {
+		return {
+			type: "cmsBlock",
+			attrs: {
+				cmsNodeId: createEditorNodeId(),
+				tag: name,
+				props: structuredClone(initialProps)
+			},
+			content: definition.slots.filter((slot) => slot.required || slot.initial !== void 0).map((slot) => createSlot(slot.name))
+		};
+	}
+	function validate(node, purpose) {
+		const issues = [];
+		const attributes = node.attrs?.props;
+		const values = isJsonObject(attributes) ? attributes : {};
+		for (const key of Object.keys(values)) if (!fields.has(key)) issues.push(`${definition.label}: ${key} is not editable.`);
+		for (const field of definition.props) {
+			const issue = propertyIssue(field, values[field.name] ?? (values[field.name] === null ? null : field.defaultValue), purpose);
+			if (issue) issues.push(issue);
+		}
+		const used = /* @__PURE__ */ new Set();
+		for (const region of node.content ?? []) {
+			const key = String(region.attrs?.name ?? "default");
+			const slot = slots.get(key);
+			if (!slot || region.type !== "cmsSlot") {
+				issues.push(`${definition.label}: unsupported content region ${key}.`);
+				continue;
+			}
+			if (used.has(key)) issues.push(`${slot.label} can only appear once.`);
+			used.add(key);
+			if (!validRegion(slot, region.content ?? [])) issues.push(`${slot.label} contains unsupported formatting or blocks.`);
+		}
+		for (const slot of definition.slots) if (slot.required && !used.has(slot.name)) issues.push(`${slot.label} is required.`);
+		return issues;
+	}
+	const schema = {
+		definition,
+		createContent,
+		createSlot,
+		validate,
+		setProperty(current, key, value) {
+			const field = fields.get(key);
+			if (!field) throw new Error(`${definition.label}: ${key} is not editable.`);
+			const issue = propertyIssue(field, value, "working");
+			if (issue) throw new Error(issue);
+			const next = Object.fromEntries(Object.entries(current));
+			if (value === void 0) delete next[key];
+			else next[key] = value;
+			return next;
+		}
+	};
+	const issues = validate(createContent(), "publish");
+	if (issues.length) throw new Error(`Invalid initial content for ${definition.label}: ${issues.join(" ")}`);
+	return schema;
+}
+function propertyIssue(field, value, purpose) {
+	if (value === void 0) return field.required && purpose === "publish" ? `${field.label} is required.` : void 0;
+	if (value === null && field.nullable) return void 0;
+	if (!(field.type === "string" ? Predicate.isString(value) : field.type === "number" ? Predicate.isNumber(value) && Number.isFinite(value) : Predicate.isBoolean(value))) return `${field.label} must be ${field.type}.`;
+	if (field.options.length && !field.options.some((option) => option.value === value)) return `${field.label} must use one of its available choices.`;
+}
+function validRegion(slot, content) {
+	const types = /* @__PURE__ */ new Set([
+		"paragraph",
+		"text",
+		"hardBreak"
+	]);
+	const marks = /* @__PURE__ */ new Set();
+	if (slot.input === "text" && content.length > 1) return false;
+	if (slot.input === "rich-text") for (const feature of slot.features) if (feature === "bullet-list") {
+		types.add("bulletList");
+		types.add("listItem");
+	} else marks.add(feature);
+	const valid = (node) => types.has(node.type ?? "") && (node.marks ?? []).every((mark) => marks.has(mark.type)) && (node.content ?? []).every(valid);
+	return content.every(valid);
+}
+
+//#endregion
+export { withCmsComarkProps as C, resolveCmsComarkAttributes as S, createDocumentParser as _, EditorRenderFailed as a, matchesCmsComponentPropType as b, comarkTagForEditorMark as c, encodeEditorImageAttributes as d, normalizeEditorImageLayout as f, DOCUMENT_ENGINE_FINGERPRINT as g, nonEmptyStringAttribute as h, EditorDocumentInvalid as i, isEditorMark as l, finiteNumberAttribute as m, parseAuthoringContent as n, comarkToEditor as o, compactJsonAttributes as p, validateAuthoringDocument as r, EDITOR_MARK_TYPES as s, createAuthoringSchema as t, EDITOR_IMAGE_LAYOUT_ATTRIBUTE as u, SOURCE_MAPPINGS_META_KEY as v, normalizeCmsComponentBindings as x, encodeCmsEditorComponentAttributes as y };
+//# sourceMappingURL=AuthoringSchema-BQ5kbhVB.js.map