@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/utils/units.d.ts

@@ -0,0 +1,99 @@
+//#region src/utils/units.d.ts
+/**
+ * Unit Conversion Utilities - Convert OOXML units to CSS/pixels
+ *
+ * OOXML uses various unit systems that need conversion for rendering:
+ * - Twips: 1/20 of a point (1440 twips = 1 inch)
+ * - EMUs (English Metric Units): 914400 EMUs = 1 inch
+ * - Half-points: 1/2 of a point (144 half-points = 1 inch)
+ * - Points: 72 points = 1 inch
+ * - Eighths of a point: 1/8 of a point (576 eighths = 1 inch)
+ *
+ * Standard assumption: 96 DPI (pixels per inch)
+ */
+/** Twips per inch (1 inch = 1440 twips) */
+declare const TWIPS_PER_INCH = 1440;
+/**
+ * Word's auto paragraph spacing in px. HTML-origin paragraphs use
+ * `w:beforeAutospacing`/`w:afterAutospacing` instead of explicit before/after;
+ * Word ignores any explicit value on such paragraphs and renders ~14px. The
+ * value is empirical (Word's rendered auto gap), not derivable from a twips
+ * conversion. See eigenpal/docx-editor#823.
+ */
+declare const AUTO_PARAGRAPH_SPACING_PX = 14;
+/** Pixels per inch at standard DPI */
+declare const PIXELS_PER_INCH = 96;
+/**
+ * Convert twips to pixels (at 96 DPI)
+ *
+ * 1 inch = 1440 twips = 96 pixels
+ * → 1 twip = 96/1440 pixels = 1/15 pixels
+ */
+declare function twipsToPixels(twips: number): number;
+/**
+ * Convert pixels to twips
+ */
+declare function pixelsToTwips(px: number): number;
+/**
+ * Convert EMUs to pixels (at 96 DPI)
+ *
+ * 1 inch = 914400 EMUs = 96 pixels
+ * Returns 0 for null/undefined/NaN inputs.
+ */
+declare function emuToPixels(emu: number | undefined | null): number;
+/**
+ * Convert pixels to EMUs.
+ *
+ * EMU coordinates in OOXML are integer-typed (xs:long); rounding here keeps
+ * floating-point drift (e.g. 52 px → 495299.99999999994) out of the document.
+ */
+declare function pixelsToEmu(px: number): number;
+/**
+ * Convert EMUs to twips. Twips are integer-typed in OOXML; round here.
+ */
+declare function emuToTwips(emu: number): number;
+/**
+ * Convert twips to EMUs. EMUs are integer-typed in OOXML; round here.
+ */
+declare function twipsToEmu(twips: number): number;
+/**
+ * Convert points to pixels (at 96 DPI)
+ *
+ * 1 inch = 72 points = 96 pixels
+ * → 1 point = 96/72 pixels = 4/3 pixels
+ */
+declare function pointsToPixels(points: number): number;
+/**
+ * Convert half-points to pixels (at 96 DPI)
+ *
+ * Half-points are commonly used for font sizes in OOXML (w:sz).
+ */
+declare function halfPointsToPixels(halfPoints: number): number;
+/**
+ * Convert half-points to points
+ */
+declare function halfPointsToPoints(halfPoints: number): number;
+/**
+ * Convert points to half-points
+ */
+declare function pointsToHalfPoints(points: number): number;
+/**
+ * Convert eighths of a point to pixels (at 96 DPI)
+ *
+ * Eighths of a point are used for border widths in OOXML.
+ */
+declare function eighthsToPixels(eighths: number): number;
+/**
+ * Round a pixel value to avoid sub-pixel rendering issues
+ */
+declare function roundPixels(px: number, decimalPlaces?: number): number;
+/**
+ * Clamp a value between min and max
+ */
+declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Format a pixel value as CSS string
+ */
+declare function formatPx(px: number): string;
+//#endregion
+export { AUTO_PARAGRAPH_SPACING_PX, PIXELS_PER_INCH, TWIPS_PER_INCH, clamp, eighthsToPixels, emuToPixels, emuToTwips, formatPx, halfPointsToPixels, halfPointsToPoints, pixelsToEmu, pixelsToTwips, pointsToHalfPoints, pointsToPixels, roundPixels, twipsToEmu, twipsToPixels };

package/dist/utils/units.js

@@ -0,0 +1,139 @@
+//#region src/utils/units.ts
+/**
+* Unit Conversion Utilities - Convert OOXML units to CSS/pixels
+*
+* OOXML uses various unit systems that need conversion for rendering:
+* - Twips: 1/20 of a point (1440 twips = 1 inch)
+* - EMUs (English Metric Units): 914400 EMUs = 1 inch
+* - Half-points: 1/2 of a point (144 half-points = 1 inch)
+* - Points: 72 points = 1 inch
+* - Eighths of a point: 1/8 of a point (576 eighths = 1 inch)
+*
+* Standard assumption: 96 DPI (pixels per inch)
+*/
+/** Standard DPI for screen rendering */
+const STANDARD_DPI = 96;
+/** Twips per inch (1 inch = 1440 twips) */
+const TWIPS_PER_INCH = 1440;
+/**
+* Word's auto paragraph spacing in px. HTML-origin paragraphs use
+* `w:beforeAutospacing`/`w:afterAutospacing` instead of explicit before/after;
+* Word ignores any explicit value on such paragraphs and renders ~14px. The
+* value is empirical (Word's rendered auto gap), not derivable from a twips
+* conversion. See eigenpal/docx-editor#823.
+*/
+const AUTO_PARAGRAPH_SPACING_PX = 14;
+/** EMUs per inch (1 inch = 914400 EMUs) */
+const EMUS_PER_INCH = 914400;
+/** Points per inch (1 inch = 72 points) */
+const POINTS_PER_INCH = 72;
+/** Half-points per inch (1 inch = 144 half-points) */
+const HALF_POINTS_PER_INCH = 144;
+/** Eighths of a point per inch (1 inch = 576) */
+const EIGHTHS_PER_INCH = 576;
+/** Pixels per inch at standard DPI */
+const PIXELS_PER_INCH = STANDARD_DPI;
+/**
+* Convert twips to pixels (at 96 DPI)
+*
+* 1 inch = 1440 twips = 96 pixels
+* → 1 twip = 96/1440 pixels = 1/15 pixels
+*/
+function twipsToPixels(twips) {
+	return twips / TWIPS_PER_INCH * 96;
+}
+/**
+* Convert pixels to twips
+*/
+function pixelsToTwips(px) {
+	return px / 96 * TWIPS_PER_INCH;
+}
+/**
+* Convert EMUs to pixels (at 96 DPI)
+*
+* 1 inch = 914400 EMUs = 96 pixels
+* Returns 0 for null/undefined/NaN inputs.
+*/
+function emuToPixels(emu) {
+	if (emu === void 0 || emu === null || Number.isNaN(emu)) return 0;
+	return Math.round(emu * 96 / EMUS_PER_INCH);
+}
+/**
+* Convert pixels to EMUs.
+*
+* EMU coordinates in OOXML are integer-typed (xs:long); rounding here keeps
+* floating-point drift (e.g. 52 px → 495299.99999999994) out of the document.
+*/
+function pixelsToEmu(px) {
+	return Math.round(px / 96 * EMUS_PER_INCH);
+}
+/**
+* Convert EMUs to twips. Twips are integer-typed in OOXML; round here.
+*/
+function emuToTwips(emu) {
+	return Math.round(emu / EMUS_PER_INCH * TWIPS_PER_INCH);
+}
+/**
+* Convert twips to EMUs. EMUs are integer-typed in OOXML; round here.
+*/
+function twipsToEmu(twips) {
+	return Math.round(twips / TWIPS_PER_INCH * EMUS_PER_INCH);
+}
+/**
+* Convert points to pixels (at 96 DPI)
+*
+* 1 inch = 72 points = 96 pixels
+* → 1 point = 96/72 pixels = 4/3 pixels
+*/
+function pointsToPixels(points) {
+	return points / POINTS_PER_INCH * 96;
+}
+/**
+* Convert half-points to pixels (at 96 DPI)
+*
+* Half-points are commonly used for font sizes in OOXML (w:sz).
+*/
+function halfPointsToPixels(halfPoints) {
+	return halfPoints / HALF_POINTS_PER_INCH * 96;
+}
+/**
+* Convert half-points to points
+*/
+function halfPointsToPoints(halfPoints) {
+	return halfPoints / 2;
+}
+/**
+* Convert points to half-points
+*/
+function pointsToHalfPoints(points) {
+	return points * 2;
+}
+/**
+* Convert eighths of a point to pixels (at 96 DPI)
+*
+* Eighths of a point are used for border widths in OOXML.
+*/
+function eighthsToPixels(eighths) {
+	return eighths / EIGHTHS_PER_INCH * 96;
+}
+/**
+* Round a pixel value to avoid sub-pixel rendering issues
+*/
+function roundPixels(px, decimalPlaces = 2) {
+	const factor = 10 ** decimalPlaces;
+	return Math.round(px * factor) / factor;
+}
+/**
+* Clamp a value between min and max
+*/
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+/**
+* Format a pixel value as CSS string
+*/
+function formatPx(px) {
+	return `${roundPixels(px)}px`;
+}
+//#endregion
+export { AUTO_PARAGRAPH_SPACING_PX, PIXELS_PER_INCH, TWIPS_PER_INCH, clamp, eighthsToPixels, emuToPixels, emuToTwips, formatPx, halfPointsToPixels, halfPointsToPoints, pixelsToEmu, pixelsToTwips, pointsToHalfPoints, pointsToPixels, roundPixels, twipsToEmu, twipsToPixels };

package/dist/utils/urlSecurity.d.ts

@@ -0,0 +1,7 @@
+//#region src/utils/urlSecurity.d.ts
+declare function sanitizeExternalUrl(rawUrl: string | undefined): string | undefined;
+declare function normalizeUserUrl(rawUrl: string): string;
+declare function isAllowedUserUrl(rawUrl: string): boolean;
+declare function sanitizeLinkTarget(target: string | undefined): string;
+//#endregion
+export { isAllowedUserUrl, normalizeUserUrl, sanitizeExternalUrl, sanitizeLinkTarget };

package/dist/utils/urlSecurity.js

@@ -0,0 +1,65 @@
+//#region src/utils/urlSecurity.ts
+const ALLOWED_URL_PROTOCOLS = /* @__PURE__ */ new Set([
+	"http:",
+	"https:",
+	"mailto:",
+	"tel:"
+]);
+const ALLOWED_TARGETS = /* @__PURE__ */ new Set([
+	"_blank",
+	"_self",
+	"_parent",
+	"_top"
+]);
+function sanitizeExternalUrl(rawUrl) {
+	if (!rawUrl) return;
+	const trimmed = rawUrl.trim();
+	if (!trimmed) return;
+	try {
+		const parsed = new URL(trimmed);
+		if (!ALLOWED_URL_PROTOCOLS.has(parsed.protocol)) return;
+		if ((parsed.protocol === "mailto:" || parsed.protocol === "tel:") && parsed.pathname.trim() === "") return;
+		return parsed.href;
+	} catch {
+		return;
+	}
+}
+function normalizeUserUrl(rawUrl) {
+	const trimmed = rawUrl.trim();
+	if (!trimmed) return "";
+	const normalized = trimmed.toLowerCase();
+	if (normalized.startsWith("mailto:") || normalized.startsWith("tel:")) return sanitizeExternalUrl(trimmed) ?? "";
+	if (normalized.startsWith("http://") || normalized.startsWith("https://")) return sanitizeExternalUrl(trimmed) ?? "";
+	const colonIndex = trimmed.indexOf(":");
+	const firstPathSeparatorIndex = findFirstPathSeparatorIndex(trimmed);
+	if (colonIndex > 0 && !trimmed.startsWith("[") && (firstPathSeparatorIndex === -1 || colonIndex < firstPathSeparatorIndex)) {
+		const suffix = trimmed.slice(colonIndex + 1);
+		if (suffix.startsWith("//") || !startsWithPortSuffix(suffix)) return "";
+	}
+	return sanitizeExternalUrl(`https://${trimmed}`) ?? "";
+}
+function isAllowedUserUrl(rawUrl) {
+	return normalizeUserUrl(rawUrl) !== "";
+}
+function sanitizeLinkTarget(target) {
+	return target && ALLOWED_TARGETS.has(target) ? target : "_blank";
+}
+function findFirstPathSeparatorIndex(value) {
+	return [
+		value.indexOf("/"),
+		value.indexOf("?"),
+		value.indexOf("#")
+	].filter((index) => index >= 0).toSorted((a, b) => a - b).at(0) ?? -1;
+}
+function startsWithPortSuffix(value) {
+	if (value.length === 0) return false;
+	let index = 0;
+	while (index < value.length) {
+		const char = value.codePointAt(index) ?? 0;
+		if (char < 48 || char > 57) break;
+		index += 1;
+	}
+	return index > 0 && (index === value.length || "/?#".includes(value[index]));
+}
+//#endregion
+export { isAllowedUserUrl, normalizeUserUrl, sanitizeExternalUrl, sanitizeLinkTarget };

package/dist/watermark/index.d.ts

@@ -0,0 +1,39 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/watermark/index.d.ts
+/**
+ * Read the document's watermark. Walks every header part and returns
+ * the first watermark encountered (header insertion order). Returns
+ * `undefined` when no header carries one.
+ */
+declare function getDocumentWatermark(doc: document_d_exports.Document): document_d_exports.Watermark | undefined;
+/**
+ * Set (or clear) the document's watermark. Writes the modeled `watermark` to
+ * every existing header part (clearing the captured raw VML so the serializer
+ * synthesizes from the model), then extends coverage to the header parts a
+ * document needs but lacks — see {@link ensureWatermarkHeaderCoverage}. Pass
+ * `undefined` to remove the watermark from every header.
+ */
+declare function setDocumentWatermark(doc: document_d_exports.Document, watermark: document_d_exports.Watermark | undefined): document_d_exports.Document;
+/**
+ * Ensure the watermark shows on every page it should, even when the header
+ * parts a section needs are missing:
+ *
+ * - A document with no headers at all gets a default header carrying the
+ *   watermark.
+ * - A section with `w:titlePg` but no first-page header gets one (so the
+ *   watermark appears on the cover page, which would otherwise be blank).
+ * - When `w:evenAndOddHeaders` is on but a section has no even header, one is
+ *   created (so even pages are covered).
+ *
+ * A typed header is only created for a section that cannot inherit one of that
+ * type from itself or a preceding section (Word inherits forward only), so
+ * existing headers — and the watermark already written to them — are preserved.
+ * Created headers use freshly minted rIds that the save pipeline materializes
+ * into real parts.
+ */
+declare function ensureWatermarkHeaderCoverage(doc: document_d_exports.Document, watermark: document_d_exports.Watermark): document_d_exports.Document;
+type PictureWatermark = document_d_exports.PictureWatermark;
+type TextWatermark = document_d_exports.TextWatermark;
+type Watermark = document_d_exports.Watermark;
+export { type PictureWatermark, type TextWatermark, type Watermark, ensureWatermarkHeaderCoverage, getDocumentWatermark, setDocumentWatermark };

package/dist/watermark/index.js

@@ -0,0 +1,149 @@
+//#region src/watermark/index.ts
+/**
+* Read the document's watermark. Walks every header part and returns
+* the first watermark encountered (header insertion order). Returns
+* `undefined` when no header carries one.
+*/
+function getDocumentWatermark(doc) {
+	const headers = doc.package.headers;
+	if (!headers) return;
+	for (const header of headers.values()) if (header.watermark) return header.watermark;
+}
+/**
+* Set (or clear) the document's watermark. Writes the modeled `watermark` to
+* every existing header part (clearing the captured raw VML so the serializer
+* synthesizes from the model), then extends coverage to the header parts a
+* document needs but lacks — see {@link ensureWatermarkHeaderCoverage}. Pass
+* `undefined` to remove the watermark from every header.
+*/
+function setDocumentWatermark(doc, watermark) {
+	const headers = doc.package.headers;
+	const nextHeaders = /* @__PURE__ */ new Map();
+	if (headers) for (const [rId, header] of headers) {
+		const next = { ...header };
+		if (watermark === void 0) {
+			delete next.watermark;
+			delete next.watermarkBlockIndex;
+		} else next.watermark = { ...watermark };
+		delete next.rawWatermarkXml;
+		nextHeaders.set(rId, next);
+	}
+	const withExisting = {
+		...doc,
+		package: {
+			...doc.package,
+			headers: nextHeaders
+		}
+	};
+	if (watermark === void 0) return withExisting;
+	return ensureWatermarkHeaderCoverage(withExisting, watermark);
+}
+/**
+* Ensure the watermark shows on every page it should, even when the header
+* parts a section needs are missing:
+*
+* - A document with no headers at all gets a default header carrying the
+*   watermark.
+* - A section with `w:titlePg` but no first-page header gets one (so the
+*   watermark appears on the cover page, which would otherwise be blank).
+* - When `w:evenAndOddHeaders` is on but a section has no even header, one is
+*   created (so even pages are covered).
+*
+* A typed header is only created for a section that cannot inherit one of that
+* type from itself or a preceding section (Word inherits forward only), so
+* existing headers — and the watermark already written to them — are preserved.
+* Created headers use freshly minted rIds that the save pipeline materializes
+* into real parts.
+*/
+function ensureWatermarkHeaderCoverage(doc, watermark) {
+	const body = doc.package.document;
+	const headers = new Map(doc.package.headers);
+	const evenOddMode = doc.package.settings?.evenAndOddHeaders === true;
+	const resolvesType = (props, type) => props.headerReferences?.some((ref) => ref.type === type && headers.has(ref.rId)) ?? false;
+	const usedRIds = /* @__PURE__ */ new Set([
+		...doc.package.relationships?.keys() ?? [],
+		...headers.keys(),
+		...doc.package.footers?.keys() ?? []
+	]);
+	const coverageRIdByType = /* @__PURE__ */ new Map();
+	const coverageRId = (type) => {
+		const existing = coverageRIdByType.get(type);
+		if (existing !== void 0) return existing;
+		let candidate = `rId_wm_${type}`;
+		let suffix = 1;
+		while (usedRIds.has(candidate)) {
+			suffix += 1;
+			candidate = `rId_wm_${type}_${suffix}`;
+		}
+		usedRIds.add(candidate);
+		coverageRIdByType.set(type, candidate);
+		return candidate;
+	};
+	const slots = [];
+	for (const [index, block] of body.content.entries()) if (block.type === "paragraph" && block.sectionProperties) slots.push({
+		props: block.sectionProperties,
+		blockIndex: index
+	});
+	slots.push({
+		props: body.finalSectionProperties ?? {},
+		blockIndex: null
+	});
+	const additions = slots.map(() => []);
+	const planType = (type, sectionNeedsType) => {
+		let inherited = false;
+		for (const [index, slot] of slots.entries()) {
+			if (resolvesType(slot.props, type)) {
+				inherited = true;
+				continue;
+			}
+			if (sectionNeedsType(slot.props) && !inherited) {
+				additions[index]?.push({
+					type,
+					rId: coverageRId(type)
+				});
+				inherited = true;
+			}
+		}
+	};
+	planType("default", () => true);
+	planType("first", (props) => props.titlePg === true);
+	if (evenOddMode) planType("even", () => true);
+	if (additions.every((refs) => refs.length === 0)) return doc;
+	const coverageTypeByRId = /* @__PURE__ */ new Map();
+	for (const ref of additions.flat()) coverageTypeByRId.set(ref.rId, ref.type);
+	for (const [rId, type] of coverageTypeByRId) if (!headers.has(rId)) headers.set(rId, {
+		type: "header",
+		hdrFtrType: type,
+		content: [],
+		watermark: { ...watermark }
+	});
+	const withRefs = (props, refs) => refs.length === 0 ? props : {
+		...props,
+		headerReferences: [...props.headerReferences ?? [], ...refs]
+	};
+	const additionsByBlock = /* @__PURE__ */ new Map();
+	for (const [index, slot] of slots.entries()) if (slot.blockIndex !== null) additionsByBlock.set(slot.blockIndex, additions[index] ?? []);
+	const newContent = body.content.map((block, index) => {
+		const refs = additionsByBlock.get(index);
+		if (block.type === "paragraph" && block.sectionProperties && refs !== void 0 && refs.length > 0) return {
+			...block,
+			sectionProperties: withRefs(block.sectionProperties, refs)
+		};
+		return block;
+	});
+	const newFinal = withRefs(body.finalSectionProperties ?? {}, additions.at(-1) ?? []);
+	return {
+		...doc,
+		package: {
+			...doc.package,
+			headers,
+			document: {
+				...body,
+				content: newContent,
+				finalSectionProperties: newFinal
+			}
+		}
+	};
+}
+//#endregion
+export { ensureWatermarkHeaderCoverage, getDocumentWatermark, setDocumentWatermark };

package/package.json

@@ -1,5 +1,125 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.0.1-placeholder.0",
-  "description": "Placeholder to bootstrap npm trusted publishing. Real releases publish as latest via the OIDC workflow."
+  "version": "0.1.0",
+  "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
+  "keywords": [
+    "document-model",
+    "docx",
+    "headless",
+    "ooxml",
+    "pagination",
+    "prosemirror",
+    "word"
+  ],
+  "homepage": "https://github.com/stella/folio",
+  "bugs": {
+    "url": "https://github.com/stella/folio/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "STLL",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stella/folio.git",
+    "directory": "packages/core"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./markdown": {
+      "types": "./dist/markdown/index.d.ts",
+      "import": "./dist/markdown/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./ai-edits": {
+      "types": "./dist/ai-edits/index.d.ts",
+      "import": "./dist/ai-edits/index.js"
+    },
+    "./content-controls": {
+      "types": "./dist/content-controls/index.d.ts",
+      "import": "./dist/content-controls/index.js"
+    },
+    "./layout-engine": {
+      "types": "./dist/layout-engine/index.d.ts",
+      "import": "./dist/layout-engine/index.js"
+    },
+    "./layout-painter": {
+      "types": "./dist/layout-painter/index.d.ts",
+      "import": "./dist/layout-painter/index.js"
+    },
+    "./layout-bridge/engine/measuring": {
+      "types": "./dist/layout-bridge/engine/measuring/index.d.ts",
+      "import": "./dist/layout-bridge/engine/measuring/index.js"
+    },
+    "./prosemirror": {
+      "types": "./dist/prosemirror/index.d.ts",
+      "import": "./dist/prosemirror/index.js"
+    },
+    "./prosemirror/attrs": {
+      "types": "./dist/prosemirror/attrs/index.d.ts",
+      "import": "./dist/prosemirror/attrs/index.js"
+    },
+    "./prosemirror/conversion": {
+      "types": "./dist/prosemirror/conversion/index.d.ts",
+      "import": "./dist/prosemirror/conversion/index.js"
+    },
+    "./prosemirror/schema": {
+      "types": "./dist/prosemirror/schema/index.d.ts",
+      "import": "./dist/prosemirror/schema/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsdown",
+    "prepack": "bun run build",
+    "pack:dry-run": "bun pm pack --dry-run",
+    "typecheck": "tsgo --noEmit -p tsconfig.build.json",
+    "test": "bun test src",
+    "test:property": "bun test $(grep -rlF 'fc.assert' src --include='*.test.ts')",
+    "perf": "bun scripts/profile-editor.ts"
+  },
+  "dependencies": {
+    "@stll/docx-core": "^0.1.0",
+    "@stll/docx-utils": "^0.1.0",
+    "@stll/template-conditions": "^0.1.0",
+    "better-result": "2.9.2",
+    "csstype": "^3.1.3",
+    "fast-xml-parser": "^5.9.3",
+    "jszip": "3.10.1",
+    "marked": "^18.0.5",
+    "prosemirror-commands": "^1.7.1",
+    "prosemirror-dropcursor": "^1.8.2",
+    "prosemirror-gapcursor": "^1.4.1",
+    "prosemirror-history": "^1.5.0",
+    "prosemirror-keymap": "^1.2.3",
+    "prosemirror-model": "^1.25.9",
+    "prosemirror-state": "^1.4.4",
+    "prosemirror-tables": "^1.8.5",
+    "prosemirror-transform": "^1.12.0",
+    "prosemirror-view": "^1.41.8",
+    "utif2": "^4.1.0",
+    "valibot": "1.4.1",
+    "y-prosemirror": "^1.3.7",
+    "yjs": "^13.6.31"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE.md"
+  ]
 }