@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/Configuration-CMweD9bn.js

@@ -1,1191 +0,0 @@
-import { S as MarkdownNode, at as Locale, it as CollectionName, n as CmsMarkdownDocument, ot as RoutePattern } from "./models-VmGmG19-.js";
-import { i as decodeManagedMediaReference, r as decodeAuthoredDocumentReference } from "./References-CCPDAPve.js";
-import { r as FormCapabilities } from "./Forms-CfNPTiCr.js";
-import { c as resolveCmsComarkAttributes, d as createCmsComarkRenderData, l as withCmsComarkProps, r as formStructureIssues, s as projectCmsEditorComponentAttributes } from "./Forms-CX-hwmJF.js";
-import { a as createEditorNodeId, n as editorMetadata, o as editorNodeId } from "./metadata-DN9_K6Yl.js";
-import { Effect, Option, Predicate, Schema } from "effect";
-import { Extension } from "@tiptap/core";
-import { ySyncPluginKey } from "@tiptap/y-tiptap";
-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";
-
-//#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$3 = 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$3(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$2 = 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$1);
-			return {
-				type: "codeBlock",
-				attrs: mergeJsonAttributes(commonAttrs, { language: nonEmptyStringAttribute(attrs.language) ?? nonEmptyStringAttribute(code?.[1].class)?.replace(/^language-/u, "") }),
-				content: textContent(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.flatMap((node) => isElementNode$1(node) && node[0] === "li" ? [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(nodes) {
-	const text = nodes.map((node) => Predicate.isString(node) ? node : node[0] === null ? node[2] : textContent(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$1(node) && node[0] === "template";
-}
-function isElementNode$1(node) {
-	return Array.isArray(node) && Predicate.isString(node[0]);
-}
-function elementChildren(node) {
-	const [, , ...children] = node;
-	return children;
-}
-function jsonObject(value) {
-	return isJsonObject$2(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/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"
-]);
-function sourceCapturePlugin() {
-	return {
-		name: "cms-source-capture",
-		pre(state) {
-			state.__cmsOriginalMarkdown = state.markdown;
-		}
-	};
-}
-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 Option.isSome(decoded) ? [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(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(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";
-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/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/StructuredFields.ts
-function compileStructuredFields(definitions) {
-	const fields = new Map(definitions.map((field) => [field.name, field]));
-	if (fields.size !== definitions.length) throw new Error("Structured field names must be unique.");
-	for (const field of definitions) {
-		if (field.defaultValue === void 0) continue;
-		const issue = fieldIssue(field, field.defaultValue, "working");
-		if (issue) throw new Error(`Invalid default for ${field.label}: ${issue.message}`);
-	}
-	const listField = (name) => {
-		const field = fields.get(name);
-		if (!field || field.type !== "array" || field.input !== "list") throw new Error(`Structured field "${name}" is not a repeatable object.`);
-		return field;
-	};
-	const validateDetailed = (value, purpose) => {
-		const issues = [];
-		for (const name of Object.keys(value)) if (!fields.has(name)) issues.push({
-			message: `${name} is not editable.`,
-			path: [name]
-		});
-		for (const field of definitions) {
-			const issue = fieldIssue(field, value[field.name] ?? (value[field.name] === null ? null : field.defaultValue), purpose, [field.name]);
-			if (issue) issues.push(issue);
-		}
-		return issues;
-	};
-	return {
-		create: () => createObject(definitions),
-		set(current, name, value) {
-			const field = fields.get(name);
-			if (!field) throw new Error(`Structured field "${name}" is unavailable.`);
-			const issue = fieldIssue(field, value, "working");
-			if (issue) throw new Error(issue.message);
-			const next = Object.fromEntries(Object.entries(current));
-			if (value === void 0) delete next[name];
-			else next[name] = structuredClone(value);
-			return next;
-		},
-		validate: (value, purpose) => validateDetailed(value, purpose).map((issue) => issue.message),
-		validateDetailed,
-		validateIdentities: (value) => identityIssues(definitions, value),
-		createListItem(name) {
-			return createObject(listField(name).fields ?? [], true);
-		},
-		duplicateListItem(name, item) {
-			const field = listField(name);
-			const copied = cloneWithFreshIdentities(item, field.fields ?? []);
-			return Object.assign(createObject(field.fields ?? [], true), copied, { id: createEditorNodeId() });
-		},
-		moveListItem(items, id, offset) {
-			const index = items.findIndex((item) => item.id === id);
-			const target = index + offset;
-			if (index < 0 || target < 0 || target >= items.length) return items;
-			const next = [...items];
-			const item = next.splice(index, 1)[0];
-			if (!item) return items;
-			next.splice(target, 0, item);
-			return next;
-		},
-		removeListItem: (items, id) => items.filter((item) => item.id !== id)
-	};
-}
-function identityIssues(fields, value, parent = []) {
-	return fields.flatMap((field) => {
-		const current = value[field.name];
-		const path = [...parent, field.name];
-		if (field.type === "object" && isJsonObject$1(current)) return identityIssues(field.fields ?? [], current, path);
-		if (field.type !== "array" || !Array.isArray(current)) return [];
-		const seen = /* @__PURE__ */ new Set();
-		return current.flatMap((item, index) => {
-			if (!isJsonObject$1(item)) return [];
-			const id = item.id;
-			const issue = !Predicate.isString(id) || !id || seen.has(id) ? [{
-				message: `${field.label} items need unique identities.`,
-				path: [
-					...path,
-					index,
-					"id"
-				]
-			}] : [];
-			if (Predicate.isString(id) && id) seen.add(id);
-			return [...issue, ...identityIssues(field.fields ?? [], item, [...path, index])];
-		});
-	});
-}
-function createObject(fields, listItem = false) {
-	return {
-		...listItem ? { id: createEditorNodeId() } : void 0,
-		...Object.fromEntries(fields.flatMap((field) => field.required || field.defaultValue !== void 0 ? [[field.name, structuredClone(field.defaultValue ?? defaultValue(field))]] : []))
-	};
-}
-function defaultValue(field) {
-	if (field.type === "object") return createObject(field.fields ?? []);
-	if (field.type === "array") return [];
-	if (field.type === "string[]") return [];
-	if (field.type === "number") return 0;
-	if (field.type === "boolean") return false;
-	return field.options[0]?.value ?? "";
-}
-function cloneWithFreshIdentities(value, fields) {
-	const byName = new Map(fields.map((field) => [field.name, field]));
-	const copy = {};
-	for (const [name, child] of Object.entries(value)) {
-		if (name === "id") continue;
-		const field = byName.get(name);
-		if (field?.type === "object" && isJsonObject$1(child)) copy[name] = cloneWithFreshIdentities(child, field.fields ?? []);
-		else if (field?.type === "array" && Array.isArray(child)) copy[name] = child.map((item) => isJsonObject$1(item) ? Object.assign(cloneWithFreshIdentities(item, field.fields ?? []), { id: createEditorNodeId() }) : structuredClone(item));
-		else copy[name] = structuredClone(child);
-	}
-	return copy;
-}
-function fieldIssue(field, value, purpose, path = [field.name]) {
-	const issue = (message, issuePath = path) => ({
-		message,
-		path: issuePath
-	});
-	if (value === void 0) return field.required && purpose === "publish" ? issue(`${field.label} is required.`) : void 0;
-	if (value === null && field.nullable) return void 0;
-	if (!(field.type === "string" || field.type === "date" ? Predicate.isString(value) : field.type === "number" ? Predicate.isNumber(value) && Number.isFinite(value) : field.type === "boolean" ? Predicate.isBoolean(value) : field.type === "string[]" ? Array.isArray(value) && value.every(Predicate.isString) : field.type === "array" ? Array.isArray(value) : isJsonObject$1(value))) return issue(`${field.label} must be ${field.type}.`);
-	if (field.type === "object" || field.type === "array") {
-		const entries = Array.isArray(value) ? value : [value];
-		const ids = /* @__PURE__ */ new Set();
-		for (const [index, entry] of entries.entries()) {
-			const entryPath = field.type === "array" ? [...path, index] : path;
-			if (!isJsonObject$1(entry)) return issue(`${field.label} must contain objects.`, entryPath);
-			if (field.type === "array") {
-				const id = entry.id;
-				if (!Predicate.isString(id) || !id || ids.has(id)) return issue(`${field.label} items need unique identities.`, [...entryPath, "id"]);
-				ids.add(id);
-			}
-			for (const key of Object.keys(entry)) if (!(field.type === "array" && key === "id") && !field.fields?.some((child) => child.name === key)) return issue(`${field.label} contains an unavailable field.`, [...entryPath, key]);
-			for (const child of field.fields ?? []) {
-				const childIssue = fieldIssue(child, entry[child.name], purpose, [...entryPath, child.name]);
-				if (childIssue) return {
-					...childIssue,
-					message: `${field.label}: ${childIssue.message}`
-				};
-			}
-		}
-	}
-	if (purpose === "publish" && field.required && value === "" && [
-		"image",
-		"link",
-		"document",
-		"media"
-	].includes(field.input)) return issue(`${field.label} is required.`);
-	if (purpose === "publish" && Predicate.isString(value) && value && (field.input === "image" || field.input === "link") && !(field.input === "link" && decodeAuthoredDocumentReference(value)) && !validAuthoringUrl(value, field.input)) return issue(`${field.label} needs a valid ${field.input === "image" ? "image URL" : "link"}.`);
-	if (purpose === "publish" && Predicate.isString(value) && value && field.input === "document" && !decodeAuthoredDocumentReference(value)) return issue(`${field.label} needs a valid document reference.`);
-	if (purpose === "publish" && Predicate.isString(value) && value && field.input === "media" && !decodeManagedMediaReference(value)) return issue(`${field.label} needs a valid managed-media reference.`);
-	if (field.options.length) {
-		if ((Array.isArray(value) ? value : [value]).some((entry) => !field.options.some((option) => option.value === entry))) return issue(`${field.label} must use only available choices.`);
-	}
-}
-function isJsonObject$1(value) {
-	return Schema.is(Schema.JsonObject)(value);
-}
-/** URL values remain ordinary strings; identity-backed references use dedicated field inputs. */
-function validAuthoringUrl(value, input) {
-	if (value.trim() !== value || value.includes("\\")) return false;
-	for (const character of value) if (character.charCodeAt(0) <= 32) return false;
-	if (value.startsWith("/") && !value.startsWith("//")) return true;
-	if (input === "link" && value.startsWith("#")) return true;
-	try {
-		const url = new URL(value);
-		return [
-			"https:",
-			"http:",
-			...input === "link" ? ["mailto:", "tel:"] : []
-		].includes(url.protocol);
-	} catch {
-		return false;
-	}
-}
-
-//#endregion
-//#region ../document/src/AuthoringSchema.ts
-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);
-function collectionComponents(components, body) {
-	if (!body) return components;
-	return components.filter((component) => body.blocks?.includes(component.name) || component.authoring.group !== void 0 && body.groups?.includes(component.authoring.group));
-}
-/** Configuration errors belong to developers, before an installation adopts the catalog. */
-function validateCollectionBody(components, body) {
-	return [
-		...components.flatMap((component) => component.authoring.slots.flatMap((slot) => slot.input === "blocks" ? [...(slot.blocks ?? []).filter((name) => !components.some((candidate) => candidate.name === name)).map((name) => `Unknown block "${name}" in ${slot.label}.`), ...(slot.groups ?? []).filter((group) => !components.some((candidate) => candidate.authoring.group === group)).map((group) => `Unknown block group "${group}" in ${slot.label}.`)] : [])),
-		...(body?.blocks ?? []).filter((name) => !components.some((component) => component.name === name)).map((name) => `Unknown block "${name}".`),
-		...(body?.groups ?? []).filter((group) => !components.some((component) => component.authoring.group === group)).map((group) => `Unknown block group "${group}".`)
-	];
-}
-function contentIssues(node, schemas, allowed, purpose, collectionAllowed = allowed) {
-	const issues = [];
-	if (node.type === "cmsBlock") {
-		const name = String(node.attrs?.tag ?? "unknown").toLowerCase() || "unknown";
-		const schema = schemas.get(name);
-		if (!schema) issues.push({
-			component: name,
-			message: "This block is unavailable. Ask your site developer to restore its definition."
-		});
-		else {
-			if (!allowed.has(name)) issues.push({
-				component: name,
-				message: `${schema.definition.label} is not allowed in this content region.`
-			});
-			issues.push(...schema.validateDetailed(node, purpose));
-			if (purpose === "publish" && schema.definition.form) issues.push(...formStructureIssues(node.attrs?.props?.steps, schema.definition.form, name).map((message) => ({
-				component: name,
-				message
-			})));
-		}
-	}
-	if (node.type === "cmsOpaque" || node.type === "cmsInlineOpaque") issues.push({
-		component: String(node.attrs?.tag ?? node.type),
-		message: "This content is unsupported. Ask your site developer to update it before publishing."
-	});
-	if (node.type === "cmsBlock") {
-		const schema = schemas.get(String(node.attrs?.tag).toLowerCase());
-		for (const region of node.content ?? []) {
-			const slot = schema?.definition.slots.find((candidate) => candidate.name === region.attrs?.name);
-			const permitted = slot?.input === "blocks" ? new Set(collectionComponents([...schemas].map(([name, schema]) => ({
-				name,
-				authoring: schema.definition
-			})), slot.blocks === void 0 && slot.groups === void 0 ? void 0 : slot).map((component) => component.name).filter((name) => collectionAllowed.has(name))) : collectionAllowed;
-			issues.push(...contentIssues(region, schemas, permitted, purpose, collectionAllowed));
-		}
-		return issues;
-	}
-	return [...issues, ...(node.content ?? []).flatMap((child) => contentIssues(child, schemas, allowed, purpose, collectionAllowed))];
-}
-/** Resolves a component catalog once so document compilation can reuse its authoring rules. */
-function createAuthoringDocumentValidator(components) {
-	const definitions = [...components.values()];
-	const schemas = new Map(definitions.map((component) => [component.name, createAuthoringSchema(component.name, component.authoring)]));
-	return (body, bodyPolicy) => {
-		const allowed = new Set(collectionComponents(definitions, bodyPolicy).map((component) => component.name));
-		return comarkToEditor(body.nodes, createCmsComarkRenderData(body)).flatMap((node) => contentIssues(node, schemas, allowed, "publish"));
-	};
-}
-function createAuthoringSchema(name, definition) {
-	const structuredFields = compileStructuredFields(definition.props);
-	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.assign({}, structuredFields.create(), definition.initialProps);
-	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 validateDetailed(node, purpose) {
-		const issues = [];
-		const attributes = node.attrs?.props;
-		const values = isJsonObject(attributes) ? attributes : {};
-		issues.push(...structuredFields.validateDetailed(values, purpose).map((issue) => ({
-			component: name,
-			field: issue.path,
-			message: issue.message
-		})));
-		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({
-					component: name,
-					message: `${definition.label}: unsupported content region ${key}.`
-				});
-				continue;
-			}
-			if (used.has(key)) issues.push({
-				component: name,
-				message: `${slot.label} can only appear once.`
-			});
-			used.add(key);
-			if (!validRegion(slot, region.content ?? [])) issues.push({
-				component: name,
-				message: `${slot.label} contains unsupported formatting or blocks.`
-			});
-		}
-		for (const slot of definition.slots) if (slot.required && !used.has(slot.name)) issues.push({
-			component: name,
-			message: `${slot.label} is required.`
-		});
-		return issues;
-	}
-	const validate = (node, purpose) => validateDetailed(node, purpose).map((issue) => issue.message);
-	const schema = {
-		definition,
-		createContent,
-		createSlot,
-		validate,
-		validateDetailed,
-		setProperty(current, key, value) {
-			return structuredFields.set(current, key, value);
-		}
-	};
-	const issues = validate(createContent(), "publish");
-	if (issues.length) throw new Error(`Invalid initial content for ${definition.label}: ${issues.join(" ")}`);
-	return schema;
-}
-function validRegion(slot, content) {
-	if (slot.input === "blocks") return content.every((node) => node.type === "cmsBlock" || node.type === "paragraph" && !node.content?.length);
-	const types = /* @__PURE__ */ new Set([
-		"paragraph",
-		"text",
-		"hardBreak"
-	]);
-	const marks = /* @__PURE__ */ new Set();
-	if (slot.input !== "rich-text" && content.length > 1) return false;
-	if (slot.input === "inline-text" || 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
-//#region ../protocol/src/StructuredFields.ts
-const presentation = {
-	name: Schema.NonEmptyString,
-	label: Schema.NonEmptyString,
-	description: Schema.optionalKey(Schema.String),
-	defaultValue: Schema.optionalKey(Schema.Json),
-	required: Schema.Boolean,
-	nullable: Schema.Boolean
-};
-const stringOptions = Schema.Array(Schema.Struct({
-	value: Schema.String,
-	label: Schema.String
-}));
-const numberOptions = Schema.Array(Schema.Struct({
-	value: Schema.Finite,
-	label: Schema.String
-}));
-const noOptions = Schema.Tuple([]);
-const StructuredField = Schema.Union([
-	Schema.Struct({
-		...presentation,
-		type: Schema.tag("boolean"),
-		input: Schema.Literal("toggle"),
-		options: noOptions
-	}),
-	Schema.Struct({
-		...presentation,
-		type: Schema.tag("date"),
-		input: Schema.Literal("date"),
-		options: noOptions
-	}),
-	Schema.Struct({
-		...presentation,
-		type: Schema.tag("number"),
-		input: Schema.Literals(["number", "select"]),
-		options: numberOptions
-	}),
-	Schema.Struct({
-		...presentation,
-		type: Schema.tag("string"),
-		input: Schema.Literals([
-			"select",
-			"text",
-			"textarea",
-			"image",
-			"link",
-			"document",
-			"media"
-		]),
-		options: stringOptions
-	}),
-	Schema.Struct({
-		...presentation,
-		type: Schema.tag("string[]"),
-		input: Schema.Literal("multiselect"),
-		options: stringOptions
-	}),
-	Schema.Struct({
-		...presentation,
-		type: Schema.tag("object"),
-		input: Schema.Literal("object"),
-		options: noOptions,
-		fields: Schema.Array(Schema.suspend(() => StructuredField))
-	}),
-	Schema.Struct({
-		...presentation,
-		type: Schema.tag("array"),
-		input: Schema.Literal("list"),
-		options: noOptions,
-		fields: Schema.Array(Schema.suspend(() => StructuredField))
-	})
-]);
-
-//#endregion
-//#region ../protocol/src/Authoring.ts
-const inlineTextFeature = Schema.Literals([
-	"bold",
-	"italic",
-	"link",
-	"code"
-]);
-const richTextFeature = Schema.Union([inlineTextFeature, Schema.Literal("bullet-list")]);
-const slotBase = {
-	name: Schema.NonEmptyString,
-	label: Schema.NonEmptyString,
-	help: Schema.optionalKey(Schema.String),
-	required: Schema.Boolean,
-	initial: Schema.optionalKey(Schema.Array(MarkdownNode))
-};
-const noFeatures = Schema.Tuple([]);
-const BlockSlot = Schema.Union([
-	Schema.Struct({
-		...slotBase,
-		input: Schema.Literal("text"),
-		features: noFeatures
-	}),
-	Schema.Struct({
-		...slotBase,
-		input: Schema.Literal("inline-text"),
-		features: Schema.Array(inlineTextFeature)
-	}),
-	Schema.Struct({
-		...slotBase,
-		input: Schema.Literal("rich-text"),
-		features: Schema.Array(richTextFeature)
-	}),
-	Schema.Struct({
-		...slotBase,
-		input: Schema.Literal("blocks"),
-		features: noFeatures,
-		blocks: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
-		groups: Schema.optionalKey(Schema.Array(Schema.NonEmptyString))
-	})
-]);
-const BlockAuthoring = Schema.Struct({
-	version: Schema.Literal(1),
-	form: Schema.optionalKey(FormCapabilities),
-	label: Schema.NonEmptyString,
-	description: Schema.optionalKey(Schema.String),
-	group: Schema.optionalKey(Schema.String),
-	icon: Schema.optionalKey(Schema.String),
-	props: Schema.Array(StructuredField),
-	slots: Schema.Array(BlockSlot),
-	initialProps: Schema.JsonObject
-});
-
-//#endregion
-//#region ../protocol/src/Configuration.ts
-const CollectionBody = Schema.Struct({
-	blocks: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
-	groups: Schema.optionalKey(Schema.Array(Schema.NonEmptyString))
-});
-const CollectionRoutes = Schema.Struct({
-	home: RoutePattern,
-	entry: RoutePattern
-}).annotate({ identifier: "CollectionRoutes" });
-const CollectionDefinition = Schema.Struct({
-	collection: CollectionName,
-	body: Schema.optionalKey(CollectionBody),
-	label: Schema.NonEmptyString,
-	description: Schema.String,
-	routes: CollectionRoutes,
-	hierarchy: Schema.Boolean,
-	canCreate: Schema.Boolean,
-	authoringFields: Schema.Array(StructuredField)
-}).annotate({ identifier: "CollectionDefinition" });
-const LocaleConfiguration = Schema.Struct({
-	locales: Schema.Array(Locale),
-	defaultLocale: Locale,
-	fallbackLocale: Schema.NullOr(Locale),
-	prefix: Schema.NullOr(Schema.Literal("always"))
-}).annotate({ identifier: "LocaleConfiguration" });
-const DocumentConfiguration = Schema.Struct({
-	types: Schema.Array(CollectionDefinition),
-	locales: Schema.optionalKey(LocaleConfiguration)
-}).annotate({ identifier: "DocumentConfiguration" });
-const ComponentDefinition = Schema.Struct({
-	authoring: BlockAuthoring,
-	name: Schema.NonEmptyString
-}).annotate({ identifier: "ComponentDefinition" });
-const AuthoringCatalog = Schema.Struct({
-	revision: Schema.NonEmptyString,
-	components: Schema.Array(ComponentDefinition)
-});
-const MediaConfiguration = Schema.Struct({
-	enabled: Schema.Boolean,
-	maxUploadBytes: Schema.Int.check(Schema.isGreaterThan(0))
-});
-
-//#endregion
-export { compactJsonAttributes as C, normalizeEditorImageLayout as S, nonEmptyStringAttribute as T, EDITOR_MARK_TYPES as _, BlockAuthoring as a, EDITOR_IMAGE_LAYOUT_ATTRIBUTE as b, parseAuthoringContent as c, EditorDocumentInvalid as d, EditorRenderFailed as f, comarkToEditor as g, SOURCE_MAPPINGS_META_KEY as h, MediaConfiguration as i, validateCollectionBody as l, createDocumentParser as m, ComponentDefinition as n, createAuthoringDocumentValidator as o, DOCUMENT_ENGINE_FINGERPRINT as p, DocumentConfiguration as r, createAuthoringSchema as s, AuthoringCatalog as t, compileStructuredFields as u, comarkTagForEditorMark as v, finiteNumberAttribute as w, encodeEditorImageAttributes as x, isEditorMark as y };
-//# sourceMappingURL=Configuration-CMweD9bn.js.map