@stll/folio-core 0.50.0 → 0.52.0

package/dist/prosemirror/extensions/features/ParagraphChangeTrackerExtension.js

@@ -18,9 +18,20 @@ const isTrackedSectionEndpointRemovalMeta = (value) => typeof value === "object"
 function countDocumentStructure(doc) {
 	let paragraphs = 0;
 	let sectionEndpoints = 0;
+	const blockRecords = [];
 	const endpointRecords = [];
 	const visit = (parent, parentPath) => {
 		parent.forEach((node, _offset, index) => {
+			const path = parentPath.length === 0 ? `${index}` : `${parentPath}.${index}`;
+			blockRecords.push(node.type.name === "paragraph" ? [
+				path,
+				node.type.name,
+				node.attrs["paraId"] ?? null
+			] : [
+				path,
+				node.type.name,
+				canonicalJson(node.attrs)
+			]);
 			if (node.type.name === "paragraph") {
 				paragraphs++;
 				const sectionProperties = sectionPropertiesOf(node);
@@ -34,34 +45,36 @@ function countDocumentStructure(doc) {
 				}
 				return;
 			}
-			if (node.childCount > 0) {
-				const path = parentPath.length === 0 ? `${index}` : `${parentPath}.${index}`;
-				visit(node, path);
-			}
+			if (node.childCount > 0) visit(node, path);
 		});
 	};
 	visit(doc, "");
 	return {
+		blockStructureFingerprint: JSON.stringify(blockRecords),
 		paragraphs,
 		sectionEndpoints,
 		sectionEndpointFingerprint: canonicalJson(endpointRecords)
 	};
 }
+const isUsableParaId = (value) => typeof value === "string" && value.length > 0 && value !== "00000000";
 /**
 * Collect paraIds of all paragraphs that overlap with the given range
 */
 function collectAffectedParaIds(doc, from, to) {
 	const ids = /* @__PURE__ */ new Set();
+	const positions = /* @__PURE__ */ new Set();
 	let hasUntracked = false;
-	doc.nodesBetween(from, to, (node) => {
+	doc.nodesBetween(from, to, (node, pos) => {
 		if (node.type.name === "paragraph") {
+			positions.add(pos);
 			const paraId = node.attrs["paraId"];
-			if (paraId) ids.add(paraId);
+			if (isUsableParaId(paraId)) ids.add(paraId);
 			else hasUntracked = true;
 		}
 	});
 	return {
 		ids,
+		positions,
 		hasUntracked
 	};
 }
@@ -75,28 +88,40 @@ function collectAffectedParaIdsFromMarkLikeStep(doc, from, to) {
 	const hi = Math.max(from, to);
 	const primary = collectAffectedParaIds(doc, lo, hi > lo ? hi : lo + 1);
 	if (primary.ids.size > 0 || primary.hasUntracked) return primary;
-	try {
-		const $p = doc.resolve(lo);
-		for (let d = $p.depth; d >= 0; d--) {
-			const n = $p.node(d);
-			if (n.type.name === "paragraph") {
-				const paraId = n.attrs["paraId"];
-				if (paraId) return {
-					ids: /* @__PURE__ */ new Set([paraId]),
-					hasUntracked: false
-				};
-				return {
-					ids: /* @__PURE__ */ new Set(),
-					hasUntracked: true
-				};
-			}
+	const $p = doc.resolve(lo);
+	for (let depth = $p.depth; depth > 0; depth--) {
+		const node = $p.node(depth);
+		if (node.type.name === "paragraph") {
+			const paraId = node.attrs["paraId"];
+			return {
+				ids: new Set(isUsableParaId(paraId) ? [paraId] : []),
+				positions: /* @__PURE__ */ new Set([$p.before(depth)]),
+				hasUntracked: !isUsableParaId(paraId)
+			};
 		}
-	} catch {}
+	}
 	return {
 		ids: /* @__PURE__ */ new Set(),
+		positions: /* @__PURE__ */ new Set(),
 		hasUntracked: false
 	};
 }
+/** Map an edited paragraph's interior so markup replacement retains its ownership. */
+const mapParagraphPosition = (tr, position) => {
+	const mapped = tr.mapping.mapResult(position + 1, 1);
+	if (mapped.deletedAcross) return null;
+	const $position = tr.doc.resolve(mapped.pos);
+	for (let depth = $position.depth; depth > 0; depth--) if ($position.node(depth).type.name === "paragraph") return $position.before(depth);
+	return null;
+};
+const mapAffectedParagraphPositions = (tr, positions) => {
+	const mappedPositions = /* @__PURE__ */ new Set();
+	for (const position of positions) {
+		const mapped = mapParagraphPosition(tr, position);
+		if (mapped !== null) mappedPositions.add(mapped);
+	}
+	return mappedPositions;
+};
 function mapStepPosition(remap, pos, assoc) {
 	return remap.map(pos, assoc);
 }
@@ -107,6 +132,9 @@ function createParagraphChangeTrackerPlugin() {
 			init(_config, state) {
 				const counts = countDocumentStructure(state.doc);
 				return {
+					affectedParagraphPositions: /* @__PURE__ */ new Set(),
+					hasUntrackedSourceChanges: false,
+					blockStructureFingerprint: counts.blockStructureFingerprint,
 					changedParaIds: /* @__PURE__ */ new Set(),
 					structuralChange: false,
 					hasUntrackedChanges: false,
@@ -123,6 +151,9 @@ function createParagraphChangeTrackerPlugin() {
 				if (meta === CLEAR_META) {
 					const counts = countDocumentStructure(tr.doc);
 					return {
+						affectedParagraphPositions: /* @__PURE__ */ new Set(),
+						hasUntrackedSourceChanges: false,
+						blockStructureFingerprint: counts.blockStructureFingerprint,
 						changedParaIds: /* @__PURE__ */ new Set(),
 						structuralChange: false,
 						hasUntrackedChanges: false,
@@ -133,13 +164,22 @@ function createParagraphChangeTrackerPlugin() {
 					};
 				}
 				if (meta === IGNORE_META) {
-					const counts = tr.docChanged ? countDocumentStructure(tr.doc) : {
-						paragraphs: prevState.paragraphCount,
-						sectionEndpoints: prevState.sectionEndpointCount,
-						sectionEndpointFingerprint: prevState.sectionEndpointFingerprint
-					};
+					if (!tr.docChanged) return prevState;
+					const counts = countDocumentStructure(tr.doc);
+					const affectedParagraphPositions = mapAffectedParagraphPositions(tr, prevState.affectedParagraphPositions);
+					const changedParaIds = /* @__PURE__ */ new Set();
+					let unresolvedChanges = prevState.hasUntrackedSourceChanges;
+					for (const position of affectedParagraphPositions) {
+						const paraId = tr.doc.nodeAt(position)?.attrs["paraId"];
+						if (isUsableParaId(paraId)) changedParaIds.add(paraId);
+						else unresolvedChanges = true;
+					}
 					return {
 						...prevState,
+						affectedParagraphPositions,
+						changedParaIds,
+						hasUntrackedChanges: unresolvedChanges,
+						blockStructureFingerprint: counts.blockStructureFingerprint,
 						paragraphCount: counts.paragraphs,
 						sectionEndpointCount: counts.sectionEndpoints,
 						sectionEndpointRemoval: counts.sectionEndpointFingerprint === prevState.sectionEndpointFingerprint ? prevState.sectionEndpointRemoval : null,
@@ -162,6 +202,9 @@ function createParagraphChangeTrackerPlugin() {
 					};
 				} else sectionEndpointRemoval = null;
 				const newState = {
+					affectedParagraphPositions: mapAffectedParagraphPositions(tr, prevState.affectedParagraphPositions),
+					hasUntrackedSourceChanges: prevState.hasUntrackedSourceChanges,
+					blockStructureFingerprint: counts.blockStructureFingerprint,
 					changedParaIds: new Set(prevState.changedParaIds),
 					structuralChange: prevState.structuralChange || meta === STRUCTURAL_META,
 					hasUntrackedChanges: prevState.hasUntrackedChanges,
@@ -176,12 +219,13 @@ function createParagraphChangeTrackerPlugin() {
 						const from = mapStepPosition(remap, range.from, 1);
 						const to = mapStepPosition(remap, range.to, -1);
 						if (to <= from) continue;
-						const { ids, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						const { ids, positions, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						for (const position of positions) newState.affectedParagraphPositions.add(position);
 						for (const id of ids) newState.changedParaIds.add(id);
 						if (hasUntracked) newState.hasUntrackedChanges = true;
 					}
 				}
-				if (prevState.paragraphCount !== newCount) newState.structuralChange = true;
+				if (prevState.blockStructureFingerprint !== counts.blockStructureFingerprint) newState.structuralChange = true;
 				for (let stepIndex = 0; stepIndex < tr.steps.length; stepIndex++) {
 					const step = tr.steps[stepIndex];
 					const remap = tr.mapping.slice(stepIndex + 1);
@@ -189,7 +233,8 @@ function createParagraphChangeTrackerPlugin() {
 						const from = mapStepPosition(remap, step.from, 1);
 						const to = mapStepPosition(remap, step.to, -1);
 						if (to <= from) continue;
-						const { ids, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						const { ids, positions, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						for (const position of positions) newState.affectedParagraphPositions.add(position);
 						for (const id of ids) newState.changedParaIds.add(id);
 						if (hasUntracked) newState.hasUntrackedChanges = true;
 						continue;
@@ -199,7 +244,8 @@ function createParagraphChangeTrackerPlugin() {
 						const node = tr.doc.nodeAt(pos);
 						if (!node) continue;
 						const end = pos + node.nodeSize;
-						const { ids, hasUntracked } = collectAffectedParaIds(tr.doc, pos, end);
+						const { ids, positions, hasUntracked } = collectAffectedParaIds(tr.doc, pos, end);
+						for (const position of positions) newState.affectedParagraphPositions.add(position);
 						for (const id of ids) newState.changedParaIds.add(id);
 						if (hasUntracked) newState.hasUntrackedChanges = true;
 						continue;
@@ -208,11 +254,23 @@ function createParagraphChangeTrackerPlugin() {
 						const from = mapStepPosition(remap, newStart, 1);
 						const to = mapStepPosition(remap, newEnd, -1);
 						if (to < from) return;
-						const { ids, hasUntracked } = collectAffectedParaIds(tr.doc, from, to);
+						const { ids, positions, hasUntracked } = collectAffectedParaIds(tr.doc, from, to);
+						for (const position of positions) newState.affectedParagraphPositions.add(position);
 						for (const id of ids) newState.changedParaIds.add(id);
 						if (hasUntracked) newState.hasUntrackedChanges = true;
 					});
 				}
+				if (newState.hasUntrackedChanges || prevState.blockStructureFingerprint !== counts.blockStructureFingerprint) tr.before.descendants((node, position) => {
+					if (node.type.name !== "paragraph") return true;
+					if (!isUsableParaId(node.attrs["paraId"])) {
+						const mapped = mapParagraphPosition(tr, position);
+						if (mapped === null || newState.affectedParagraphPositions.has(mapped)) {
+							newState.hasUntrackedSourceChanges = true;
+							newState.hasUntrackedChanges = true;
+						}
+					}
+					return false;
+				});
 				return newState;
 			}
 		}
@@ -231,7 +289,7 @@ function getChangedParagraphIds(state) {
 	return getChangeTrackerState(state)?.changedParaIds ?? /* @__PURE__ */ new Set();
 }
 /**
-* Check if structural changes (paragraph add/delete) occurred
+* Check if paragraph membership, order, or block structure changed
 */
 function hasStructuralChanges(state) {
 	return getChangeTrackerState(state)?.structuralChange ?? false;

package/dist/prosemirror/runStyleFormatting.d.ts

@@ -52,6 +52,12 @@ type ParagraphRunStyleContextAtOptions = {
   styleResolver?: RunStyleResolver | null;
 };
 declare const paragraphRunStyleContextAt: ({ doc, pos, styleResolver }: ParagraphRunStyleContextAtOptions) => ParagraphRunStyleContext;
+/**
+ * {@link paragraphRunStyleContextAt} for a caller that already knows the
+ * nearest paragraph, or that there is none. A document walk knows it for free,
+ * where `doc.resolve` re-descends from the root once per run.
+ */
+declare const nearestParagraphRunStyleContext: (paragraph: Node | null, styleResolver?: RunStyleResolver | null) => ParagraphRunStyleContext;
 type ResolveEffectiveRunStyleFormattingOptions = {
   marks: readonly Mark[];
   paragraphFormatting: document_d_exports.TextFormatting | undefined;
@@ -60,4 +66,4 @@ type ResolveEffectiveRunStyleFormattingOptions = {
 /** Resolve the non-direct run cascade from shared document styles and the current paragraph. */
 declare const resolveEffectiveRunStyleFormatting: ({ marks, paragraphFormatting, styleResolver }: ResolveEffectiveRunStyleFormattingOptions) => document_d_exports.TextFormatting | undefined;
 //#endregion
-export { ParagraphRunStyleContext, RunStyleResolver, getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };
+export { ParagraphRunStyleContext, RunStyleResolver, getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, nearestParagraphRunStyleContext, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };

package/dist/prosemirror/runStyleFormatting.js

@@ -153,12 +153,18 @@ const paragraphRunStyleContextAt = ({ doc, pos, styleResolver }) => {
 		const ancestor = resolved.node(depth);
 		if (ancestor.type.name === "paragraph") return paragraphRunStyleContext(ancestor, styleResolver);
 	}
-	return {
-		baseParagraphFormatting: void 0,
-		paragraphFormatting: void 0,
-		paragraphMarkFormatting: void 0,
-		paragraphMarkPrecedesStyle: false
-	};
+	return nearestParagraphRunStyleContext(null, styleResolver);
+};
+/**
+* {@link paragraphRunStyleContextAt} for a caller that already knows the
+* nearest paragraph, or that there is none. A document walk knows it for free,
+* where `doc.resolve` re-descends from the root once per run.
+*/
+const nearestParagraphRunStyleContext = (paragraph, styleResolver) => paragraph ? paragraphRunStyleContext(paragraph, styleResolver) : {
+	baseParagraphFormatting: void 0,
+	paragraphFormatting: void 0,
+	paragraphMarkFormatting: void 0,
+	paragraphMarkPrecedesStyle: false
 };
 /** Resolve the non-direct run cascade from shared document styles and the current paragraph. */
 const resolveEffectiveRunStyleFormatting = ({ marks, paragraphFormatting, styleResolver }) => {
@@ -176,4 +182,4 @@ const resolveEffectiveRunStyleFormatting = ({ marks, paragraphFormatting, styleR
 	});
 };
 //#endregion
-export { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };
+export { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, nearestParagraphRunStyleContext, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };

package/dist/shaping/shaper.d.ts

@@ -14,6 +14,9 @@
  * the Unicode data that engine needs, and a document in Latin, Cyrillic or
  * Greek needs none of it: `getShaper` is called only once a run in a shaping
  * script is about to be measured or painted, and never before.
+ *
+ * The same artifact resolves the bidirectional algorithm, because splitting a
+ * line into runs that each read one way is what shaping needs first.
  */
 /** Which way a run advances. Resolved by the producer, never guessed here. */
 declare const SHAPING_DIRECTION: {
@@ -57,22 +60,62 @@ type ShapedRun = {
   /** Design units per em, so a caller scales without re-reading the face. */
   readonly unitsPerEm: number;
 };
+/** The paragraph direction of a line whose bidirectional levels are resolved. */
+declare const BIDI_DIRECTION: {
+  readonly leftToRight: "ltr";
+  readonly rightToLeft: "rtl";
+  /** Rules P2 and P3: the first strong character outside an isolate decides. */
+  readonly auto: "auto";
+};
+type BidiDirection = (typeof BIDI_DIRECTION)[keyof typeof BIDI_DIRECTION];
+type ResolveBidiRequest = {
+  /** One paragraph laid out as one line; a paragraph separator does not split it. */
+  readonly text: string;
+  readonly direction: BidiDirection;
+};
+/**
+ * One line after the Unicode Bidirectional Algorithm (UAX #9), rules P2
+ * through L2. Indices count code points, not UTF-16 units.
+ */
+type BidiLine = {
+  /** 0 when the paragraph reads left to right, 1 when right to left. */
+  readonly paragraphLevel: number;
+  /**
+   * Embedding level per code point, after rule L1; odd levels read right to
+   * left. Characters rule X9 removes (explicit formatting characters such as
+   * isolates) carry a level but draw nothing.
+   */
+  readonly levels: readonly number[];
+  /** Code-point indices in visual order, left to right (rule L2). */
+  readonly visualOrder: readonly number[];
+};
 type Shaper = {
   readonly shapeRun: (request: ShapeRunRequest) => ShapedRun;
+  readonly resolveBidi: (request: ResolveBidiRequest) => BidiLine;
 };
 declare const ShaperError_base: import("better-result").TaggedErrorClass<"ShaperError">;
 declare class ShaperError extends ShaperError_base<{
   message: string;
   cause?: unknown;
 }> {}
+/**
+ * Where the artifact comes from when the caller already holds it: a runtime
+ * that cannot fetch its own package files (a single-file executable, an
+ * embedded asset) hands over the WebAssembly bytes instead.
+ */
+type ShaperSource = {
+  readonly wasm: Uint8Array | ArrayBuffer;
+};
 /**
  * Loads the shaper, once, and hands back the single implementation both the
  * measurer and the PDF backend use.
  *
- * Calling this is what fetches the artifact, so a caller asks for it only after
- * establishing that some run actually needs shaping.
+ * Calling this without a source is what fetches the artifact, so a caller asks
+ * for it only after establishing that some run actually needs shaping. With a
+ * source, the bytes given are instantiated and nothing is fetched. Either way
+ * the first successful load is the one every later call shares.
  */
-declare const getShaper: () => Promise<Shaper>;
+declare const getShaper: (source?: ShaperSource) => Promise<Shaper>;
 /**
  * Whether the artifact has been loaded in this process.
  *
@@ -89,4 +132,4 @@ declare const shaperLoaded: () => boolean;
  */
 declare const resolvedShaper: () => Shaper | null;
 //#endregion
-export { SHAPING_DIRECTION, ShapeRunRequest, ShapedGlyph, ShapedRun, Shaper, ShaperError, ShapingDirection, getShaper, resolvedShaper, shaperLoaded };
+export { BIDI_DIRECTION, BidiDirection, BidiLine, ResolveBidiRequest, SHAPING_DIRECTION, ShapeRunRequest, ShapedGlyph, ShapedRun, Shaper, ShaperError, ShaperSource, ShapingDirection, getShaper, resolvedShaper, shaperLoaded };

package/dist/shaping/shaper.js

@@ -1,4 +1,4 @@
-import __wbg_init, { shapeRun } from "../generated/text_shaper.js";
+import __wbg_init, { resolveBidi, shapeRun } from "../generated/text_shaper.js";
 import { TaggedError } from "better-result";
 //#region src/shaping/shaper.ts
 /**
@@ -16,12 +16,22 @@ import { TaggedError } from "better-result";
 * the Unicode data that engine needs, and a document in Latin, Cyrillic or
 * Greek needs none of it: `getShaper` is called only once a run in a shaping
 * script is about to be measured or painted, and never before.
+*
+* The same artifact resolves the bidirectional algorithm, because splitting a
+* line into runs that each read one way is what shaping needs first.
 */
 /** Which way a run advances. Resolved by the producer, never guessed here. */
 const SHAPING_DIRECTION = {
 	leftToRight: "ltr",
 	rightToLeft: "rtl"
 };
+/** The paragraph direction of a line whose bidirectional levels are resolved. */
+const BIDI_DIRECTION = {
+	leftToRight: "ltr",
+	rightToLeft: "rtl",
+	/** Rules P2 and P3: the first strong character outside an isolate decides. */
+	auto: "auto"
+};
 var ShaperError = class extends TaggedError("ShaperError") {};
 /**
 * The flat buffer the WebAssembly entry returns:
@@ -51,26 +61,47 @@ const decode = (buffer) => {
 		unitsPerEm
 	};
 };
-const shaper = { shapeRun: ({ font, faceIndex = 0, text, direction, script = "", language = "", featuresOn = [], featuresOff = [] }) => {
-	try {
-		return decode(shapeRun(font, faceIndex, text, direction === SHAPING_DIRECTION.rightToLeft, script, language, [...featuresOn], [...featuresOff]));
-	} catch (cause) {
-		throw new ShaperError({
-			message: "Could not shape a run of text",
-			cause
-		});
+/** `[paragraphLevel, count, level * count, visualIndex * count]`. */
+const decodeBidi = (buffer) => {
+	const count = buffer[1] ?? 0;
+	const levelsAt = HEADER_FIELDS;
+	const orderAt = HEADER_FIELDS + count;
+	return {
+		paragraphLevel: buffer[0] ?? 0,
+		levels: Array.from(buffer.subarray(levelsAt, orderAt)),
+		visualOrder: Array.from(buffer.subarray(orderAt, orderAt + count))
+	};
+};
+const RIGHT_TO_LEFT_BY_BIDI_DIRECTION = {
+	ltr: false,
+	rtl: true,
+	auto: void 0
+};
+const shaper = {
+	resolveBidi: ({ text, direction }) => decodeBidi(resolveBidi(text, RIGHT_TO_LEFT_BY_BIDI_DIRECTION[direction])),
+	shapeRun: ({ font, faceIndex = 0, text, direction, script = "", language = "", featuresOn = [], featuresOff = [] }) => {
+		try {
+			return decode(shapeRun(font, faceIndex, text, direction === SHAPING_DIRECTION.rightToLeft, script, language, [...featuresOn], [...featuresOff]));
+		} catch (cause) {
+			throw new ShaperError({
+				message: "Could not shape a run of text",
+				cause
+			});
+		}
 	}
-} };
+};
 let loading;
 /**
 * Loads the shaper, once, and hands back the single implementation both the
 * measurer and the PDF backend use.
 *
-* Calling this is what fetches the artifact, so a caller asks for it only after
-* establishing that some run actually needs shaping.
+* Calling this without a source is what fetches the artifact, so a caller asks
+* for it only after establishing that some run actually needs shaping. With a
+* source, the bytes given are instantiated and nothing is fetched. Either way
+* the first successful load is the one every later call shares.
 */
-const getShaper = () => {
-	loading ??= __wbg_init().then(() => {
+const getShaper = (source) => {
+	loading ??= __wbg_init(source === void 0 ? void 0 : { module_or_path: source.wasm }).then(() => {
 		resolved = shaper;
 		return shaper;
 	}).catch((cause) => {
@@ -99,4 +130,4 @@ let resolved = null;
 */
 const resolvedShaper = () => resolved;
 //#endregion
-export { SHAPING_DIRECTION, ShaperError, getShaper, resolvedShaper, shaperLoaded };
+export { BIDI_DIRECTION, SHAPING_DIRECTION, ShaperError, getShaper, resolvedShaper, shaperLoaded };

package/dist/text-shaping.d.ts

@@ -0,0 +1,4 @@
+import { BIDI_DIRECTION, BidiLine, ResolveBidiRequest, SHAPING_DIRECTION, ShapeRunRequest, ShapedRun, Shaper, ShaperSource, getShaper } from "./shaping/shaper.js";
+import { SfntFont, parseSfnt } from "./fonts/sfnt/parse.js";
+import { TrueTypeSubset, subsetTrueType } from "./fonts/sfnt/subset.js";
+export { BIDI_DIRECTION, type BidiLine, type ResolveBidiRequest, SHAPING_DIRECTION, type SfntFont, type ShapeRunRequest, type ShapedRun, type Shaper, type ShaperSource, type TrueTypeSubset, getShaper, parseSfnt, subsetTrueType };

package/dist/text-shaping.js

@@ -0,0 +1,4 @@
+import { parseSfnt } from "./fonts/sfnt/parse.js";
+import { subsetTrueType } from "./fonts/sfnt/subset.js";
+import { BIDI_DIRECTION, SHAPING_DIRECTION, getShaper } from "./shaping/shaper.js";
+export { BIDI_DIRECTION, SHAPING_DIRECTION, getShaper, parseSfnt, subsetTrueType };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.50.0",
+  "version": "0.52.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",
@@ -106,6 +106,11 @@
       "types": "./dist/docx/documentClone.d.ts",
       "import": "./dist/docx/documentClone.js"
     },
+    "./text-shaping": {
+      "types": "./dist/text-shaping.d.ts",
+      "import": "./dist/text-shaping.js"
+    },
+    "./text-shaping/wasm": "./dist/generated/text_shaper_bg.wasm",
     "./docx/paragraphPropertySource": null,
     "./internal/*": null,
     "./*": {