@stll/folio-core 0.51.0 → 0.52.0

package/dist/compare/inline-provenance.js

@@ -3,7 +3,7 @@ import { expectHyperlinkMarkAttrs, expectRunPropertyChangeMarkAttrs, expectTable
 import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.js";
 import { applyMarksToRunFormattingRepresentation, expandRunFormattingCarrier, runFormattingCarrierReviewText } from "../prosemirror/runFormattingInlineCarriers.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
-import { paragraphRunStyleContextAt } from "../prosemirror/runStyleFormatting.js";
+import { nearestParagraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";
 import { isTableCellRetainedInReviewView } from "../prosemirror/tableCellRevisionVisibility.js";
 import { canonicalJson } from "../utils/canonicalJson.js";
 //#region src/compare/inline-provenance.ts
@@ -19,10 +19,11 @@ const hyperlinkIdentity = (node) => {
 	});
 };
 const isInserted = (node) => node.marks.some(({ type }) => type.name === "insertion");
-const carrierRepresentations = (carrier) => carrier.representations.map((representation) => ({
+const carrierRepresentations = ({ carrier, paragraph }) => carrier.representations.map((representation) => ({
 	...representation,
 	from: representation.position,
-	to: representation.position + representation.node.nodeSize
+	to: representation.position + representation.node.nodeSize,
+	paragraph
 }));
 const targetBlockIdLookup = (anchors) => {
 	const ordered = Object.values(anchors).toSorted((left, right) => left.from - right.from || left.to - right.to);
@@ -53,7 +54,13 @@ const collectCarriers = ({ doc, targetSnapshot }) => {
 	const carriers = [];
 	const targetBlockIdAt = targetSnapshot ? targetBlockIdLookup(targetSnapshot.anchors) : void 0;
 	let unanchoredTargetCarrier = false;
+	const openParagraphs = [];
 	doc.descendants((node, position) => {
+		while ((openParagraphs.at(-1)?.end ?? Number.POSITIVE_INFINITY) <= position) openParagraphs.pop();
+		if (node.type.name === "paragraph") openParagraphs.push({
+			node,
+			end: position + node.nodeSize
+		});
 		if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && !isTableCellRetainedInReviewView(expectTableCellAttrs(node).cellMarker?.kind, "final")) return false;
 		if (!node.isInline) return true;
 		const carrier = expandRunFormattingCarrier(node, position);
@@ -69,6 +76,7 @@ const collectCarriers = ({ doc, targetSnapshot }) => {
 		}
 		carriers.push({
 			carrier,
+			paragraph: openParagraphs.at(-1)?.node ?? null,
 			text: runFormattingCarrierReviewText(carrier),
 			targetBlockId
 		});
@@ -106,8 +114,8 @@ const matchCarrierStreams = ({ live, target }) => {
 		const targetIsText = targetCarrier.carrier.disposition === "text-run";
 		if (!liveIsText || !targetIsText) {
 			if (liveOffset !== 0 || targetOffset !== 0 || !sameCarrierShape(liveCarrier, targetCarrier)) return null;
-			const liveRepresentations = carrierRepresentations(liveCarrier.carrier);
-			const targetRepresentations = carrierRepresentations(targetCarrier.carrier);
+			const liveRepresentations = carrierRepresentations(liveCarrier);
+			const targetRepresentations = carrierRepresentations(targetCarrier);
 			for (const [index, liveRepresentation] of liveRepresentations.entries()) {
 				const targetRepresentation = targetRepresentations.at(index);
 				if (!targetRepresentation) return null;
@@ -123,8 +131,8 @@ const matchCarrierStreams = ({ live, target }) => {
 		}
 		const sharedLength = Math.min(liveText.length, targetText.length);
 		if (sharedLength === 0 || liveText.slice(0, sharedLength) !== targetText.slice(0, sharedLength)) return null;
-		const liveRepresentation = carrierRepresentations(liveCarrier.carrier).at(0);
-		const targetRepresentation = carrierRepresentations(targetCarrier.carrier).at(0);
+		const liveRepresentation = carrierRepresentations(liveCarrier).at(0);
+		const targetRepresentation = carrierRepresentations(targetCarrier).at(0);
 		if (!liveRepresentation || !targetRepresentation) return null;
 		matched.push({
 			live: {
@@ -152,12 +160,8 @@ const matchCarrierStreams = ({ live, target }) => {
 	}
 	return matched;
 };
-const authoredFormattingAt = ({ doc, representation, styleResolver }) => readAuthoredRunFormatting({
-	context: paragraphRunStyleContextAt({
-		doc,
-		pos: representation.from,
-		styleResolver
-	}),
+const authoredFormattingAt = ({ representation, styleResolver }) => readAuthoredRunFormatting({
+	context: nearestParagraphRunStyleContext(representation.paragraph, styleResolver),
 	marks: representation.node.marks,
 	styleResolver
 });
@@ -190,12 +194,10 @@ const matchInlineProvenance = ({ state, targetSnapshot, revisionStamp, originalR
 	const planned = [];
 	for (const segment of matched) {
 		const liveFormatting = authoredFormattingAt({
-			doc: state.doc,
 			representation: segment.live,
 			styleResolver: liveStyleResolver
 		});
 		const targetFormatting = authoredFormattingAt({
-			doc: targetDocument,
 			representation: segment.target,
 			styleResolver: targetStyleResolver
 		});
@@ -220,11 +222,7 @@ const matchInlineProvenance = ({ state, targetSnapshot, revisionStamp, originalR
 	let nextRevisionId = revisionStamp.idSeed;
 	const changedTargetBlockIds = /* @__PURE__ */ new Set();
 	for (const change of planned.toReversed()) {
-		const context = paragraphRunStyleContextAt({
-			doc: state.doc,
-			pos: change.live.from,
-			styleResolver: liveStyleResolver
-		});
+		const context = nearestParagraphRunStyleContext(change.live.paragraph, liveStyleResolver);
 		const formattingMarks = reconcileRunFormattingMarks({
 			authoredFormatting: change.formatting,
 			context,
@@ -321,11 +319,9 @@ const sameAuthoredInlineProvenance = (baseSnapshot, targetSnapshot) => {
 	const baseStyleResolver = styleResolverOf(baseSnapshot);
 	const targetStyleResolver = styleResolverOf(targetSnapshot);
 	return matched.every(({ live, target }) => hyperlinkIdentity(live.node) === hyperlinkIdentity(target.node) && canonicalJson(authoredFormattingAt({
-		doc: baseDocument,
 		representation: live,
 		styleResolver: baseStyleResolver
 	})) === canonicalJson(authoredFormattingAt({
-		doc: targetDocument,
 		representation: target,
 		styleResolver: targetStyleResolver
 	})));

package/dist/compare/section-boundary-properties.js

@@ -108,9 +108,22 @@ const boundaryParagraphEntriesOf = (document) => {
 	if (!children) return null;
 	return children.flatMap((child) => child.type === "paragraph" ? [child.paragraph] : []);
 };
+const hasSectionEndpoint = (document) => {
+	let found = false;
+	document.forEach((node) => {
+		if (node.type.name === "paragraph" && expectParagraphAttrs(node)._sectionProperties !== void 0) found = true;
+	});
+	return found;
+};
 /** Stage section deltas after document operations, against the accepted projection. */
 const stageSectionBoundaryProperties = ({ state, target, originalRevisionIdSeed, revisionStamp, author, maxRanges, mapTargetProperties }) => {
 	if (!Number.isSafeInteger(maxRanges) || maxRanges < 0) return { status: "budget-exceeded" };
+	if (!hasSectionEndpoint(target)) return {
+		status: "matched",
+		transaction: state.tr,
+		nextRevisionId: revisionStamp.idSeed,
+		rangeCount: 0
+	};
 	const reviewedState = resolveAllChangesInHeadlessStateWithMapping(state, "accept");
 	const reviewed = boundaryParagraphEntriesOf(reviewedState.state.doc);
 	const targets = boundaryParagraphEntriesOf(target);

package/dist/generated/text_shaper.js

@@ -1,6 +1,32 @@
 // @ts-nocheck -- generated and verified by build-shaper-wasm.ts
 /* @ts-self-types="./text_shaper.d.ts" */
 
+/**
+ * Resolve the bidirectional levels and visual order of one line.
+ *
+ * `right_to_left` is the paragraph direction, or `None` for rules P2 and P3.
+ * Returns `[paragraphLevel, charCount, level * charCount, visualIndex *
+ * charCount]`, counting characters as Unicode scalar values.
+ * @param {string} text
+ * @param {boolean | null} [right_to_left]
+ * @returns {Int32Array}
+ */
+export function resolveBidi(text, right_to_left) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.resolveBidi(retptr, ptr0, len0, isLikeNone(right_to_left) ? 0xFFFFFF : right_to_left ? 1 : 0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v2 = getArrayI32FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export3(r0, r1 * 4, 4);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Shape one run of text with one face.
  *

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.51.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,
     "./*": {