@stll/folio-core 0.62.0 → 0.63.1

package/dist/document-operations.js

@@ -1,6 +1,7 @@
 import { applyFolioAIEditOperations, previewFolioAIEditOperationsWithResult } from "./ai-edits/apply.js";
 import { describeModelError, findIntroducedModelErrors } from "./ai-edits/result-validation.js";
 import { LIST_KINDS } from "./docx/listNumberingInstances.js";
+import { getSuggestions } from "./prosemirror/commands/comments.js";
 import { completeNumberingForDoc } from "./prosemirror/listInstanceReferences.js";
 import { outlineLevelFromAttrValue } from "./prosemirror/outlineLevelAttr.js";
 import { getStatedDocumentNumbering } from "./prosemirror/plugins/documentNumbering.js";
@@ -113,8 +114,10 @@ const isFolioDocumentOperationModeSupported = (operationType, mode) => {
 	return includesDocumentOperationMode(supportedModes, mode);
 };
 const isSupportedFolioDocumentOperationVersion = (value) => value === 1;
-var UnsupportedFolioDocumentOperationVersionError = class extends TaggedError("UnsupportedFolioDocumentOperationVersionError") {};
-var InvalidFolioDocumentOperationBatchError = class extends TaggedError("InvalidFolioDocumentOperationBatchError") {};
+const UnsupportedFolioDocumentOperationVersionErrorBase = TaggedError("UnsupportedFolioDocumentOperationVersionError");
+var UnsupportedFolioDocumentOperationVersionError = class extends UnsupportedFolioDocumentOperationVersionErrorBase {};
+const InvalidFolioDocumentOperationBatchErrorBase = TaggedError("InvalidFolioDocumentOperationBatchError");
+var InvalidFolioDocumentOperationBatchError = class extends InvalidFolioDocumentOperationBatchErrorBase {};
 const assertSupportedFolioDocumentOperationVersion = (value) => {
 	if (isSupportedFolioDocumentOperationVersion(value)) return value;
 	throw new UnsupportedFolioDocumentOperationVersionError({
@@ -1248,14 +1251,48 @@ const getFolioDocumentOperationReceiptsForStory = ({ operations, applied, story
 	});
 	return receipts;
 };
+/**
+* A suggested operation without a `suggestionId` is its own suggestion, named
+* by its id. An id a still pending suggestion already carries would fold the
+* two into one (accepted, rejected and exported together), so such an
+* operation gets a distinct id, and an operation of the batch grouping with it
+* by that id follows it.
+*/
+const withDistinctSuggestionIds = (batch, pending) => {
+	if (batch.mode !== "suggested" || pending.size === 0) return batch;
+	const taken = new Set(pending);
+	for (const operation of batch.operations) if ("suggestionId" in operation && operation.suggestionId !== void 0) taken.add(operation.suggestionId);
+	const renamed = /* @__PURE__ */ new Map();
+	for (const operation of batch.operations) {
+		if (operation.type === "commentOnRange" || "suggestionId" in operation && operation.suggestionId !== void 0 || !pending.has(operation.id)) continue;
+		let ordinal = 2;
+		while (taken.has(`${operation.id}#${String(ordinal)}`)) ordinal += 1;
+		const suggestionId = `${operation.id}#${String(ordinal)}`;
+		taken.add(suggestionId);
+		renamed.set(operation.id, suggestionId);
+	}
+	if (renamed.size === 0) return batch;
+	return {
+		...batch,
+		operations: batch.operations.map((operation) => {
+			if (operation.type === "commentOnRange") return operation;
+			const grouped = "suggestionId" in operation && operation.suggestionId !== void 0 ? renamed.get(operation.suggestionId) : renamed.get(operation.id);
+			return grouped === void 0 ? operation : {
+				...operation,
+				suggestionId: grouped
+			};
+		})
+	};
+};
 const NO_COMMIT = () => {};
 /** Skips reported in the order of the operations they belong to. */
 const inOperationOrder = (operations, skipped) => {
 	const indexById = new Map(operations.map(({ id }, index) => [id, index]));
 	return [...skipped].sort((left, right) => (indexById.get(left.id) ?? -1) - (indexById.get(right.id) ?? -1));
 };
-const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", author, createCommentId, createUndoHandle, revisionStamp, wordDiff, tableTemplates, replacementBackground, undefinedReferences }) => {
-	const parsedBatch = parseFolioDocumentOperationBatch(batch);
+const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", author, createCommentId, createUndoHandle, revisionStamp, wordDiff, tableTemplates, replacementBackground, undefinedReferences, pendingSuggestionIds, restagesSuggestions }) => {
+	const validatedBatch = parseFolioDocumentOperationBatch(batch);
+	const parsedBatch = restagesSuggestions === true ? validatedBatch : withDistinctSuggestionIds(validatedBatch, /* @__PURE__ */ new Set([...getSuggestions(view.state).map(({ suggestionId }) => suggestionId), ...pendingSuggestionIds ?? []]));
 	const isAtomic = parsedBatch.atomic === true;
 	const beforeDoc = view.state.doc;
 	const packageNumbering = getStatedDocumentNumbering(view.state);

package/dist/document-stories.d.ts

@@ -1,6 +1,6 @@
 import { FolioDocumentStoryHandle } from "./ai-edits/headless.js";
 //#region src/document-stories.d.ts
-type FolioDocumentStoryPair = {
+export type FolioDocumentStoryPair = {
   baseStory: FolioDocumentStoryHandle | null;
   revisedStory: FolioDocumentStoryHandle | null;
 };
@@ -20,6 +20,5 @@ type FolioDocumentStoryPair = {
  * other, and a document with more of them than the other leaves its surplus
  * unpaired rather than pairing a first-page header against a default one.
  */
-declare const pairFolioDocumentStories: (baseStories: readonly FolioDocumentStoryHandle[], revisedStories: readonly FolioDocumentStoryHandle[]) => FolioDocumentStoryPair[];
-//#endregion
-export { FolioDocumentStoryPair, pairFolioDocumentStories };
+export declare const pairFolioDocumentStories: (baseStories: readonly FolioDocumentStoryHandle[], revisedStories: readonly FolioDocumentStoryHandle[]) => FolioDocumentStoryPair[];
+//#endregion

package/dist/docx/altChunk.d.ts

@@ -1,8 +1,7 @@
 //#region src/docx/altChunk.d.ts
-declare const ALT_CHUNK_READER_DIAGNOSTIC = "[Unsupported w:altChunk content]";
-declare const ALT_CHUNK_PLAIN_TEXT_LIMIT_BYTES = 1000000;
+export declare const ALT_CHUNK_READER_DIAGNOSTIC = "[Unsupported w:altChunk content]";
+export declare const ALT_CHUNK_PLAIN_TEXT_LIMIT_BYTES = 1000000;
 /** The captured fragment's expanded name, not its source prefix, identifies w:altChunk. */
-declare const isAltChunkMarkup: (xml: string) => boolean;
-declare const getAltChunkRelationshipId: (xml: string) => string | undefined;
-//#endregion
-export { ALT_CHUNK_PLAIN_TEXT_LIMIT_BYTES, ALT_CHUNK_READER_DIAGNOSTIC, getAltChunkRelationshipId, isAltChunkMarkup };
+export declare const isAltChunkMarkup: (xml: string) => boolean;
+export declare const getAltChunkRelationshipId: (xml: string) => string | undefined;
+//#endregion

package/dist/docx/appVersionNormalization.d.ts

@@ -1,5 +1,6 @@
+import { TaggedErrorClass } from "better-result";
 //#region src/docx/appVersionNormalization.d.ts
-declare const AppVersionSchemaError_base: import("better-result").TaggedErrorClass<"AppVersionSchemaError">;
+declare const AppVersionSchemaErrorBase: TaggedErrorClass<"AppVersionSchemaError">;
 /**
  * A value reached the package that the schema form does not accept.
  *
@@ -7,7 +8,7 @@ declare const AppVersionSchemaError_base: import("better-result").TaggedErrorCla
  * throws this rather than letting the package go out carrying a version a
  * consumer refuses.
  */
-declare class AppVersionSchemaError extends AppVersionSchemaError_base<{
+export declare class AppVersionSchemaError extends AppVersionSchemaErrorBase<{
   message: string;
   appVersion: string;
 }> {}
@@ -18,7 +19,7 @@ declare class AppVersionSchemaError extends AppVersionSchemaError_base<{
  * clock, not folio's own version — so two saves of one document state the same
  * application version.
  */
-declare const appVersionInSchemaForm: (value: string) => string;
+export declare const appVersionInSchemaForm: (value: string) => string;
 /**
  * Rewrite the application version an extended-properties part states.
  *
@@ -26,6 +27,6 @@ declare const appVersionInSchemaForm: (value: string) => string;
  * states no version at all, so a save of a document that never carried a
  * malformed one is byte-identical.
  */
-declare const normalizeAppVersionInExtendedProperties: (xml: string) => string;
+export declare const normalizeAppVersionInExtendedProperties: (xml: string) => string;
 //#endregion
-export { AppVersionSchemaError, appVersionInSchemaForm, normalizeAppVersionInExtendedProperties };
+export {};

package/dist/docx/appVersionNormalization.js

@@ -18,6 +18,7 @@ import { TaggedError } from "better-result";
 * properties keeps carrying none — synthesizing metadata a document never
 * stated is a different decision.
 */
+const AppVersionSchemaErrorBase = TaggedError("AppVersionSchemaError");
 /** `XX.YYYY`: the only form the extended-properties `AppVersion` may take. */
 const SCHEMA_FORM = /^\d{1,2}\.\d{4}$/u;
 /** The leading integer, when the value opens with one the form allows. */
@@ -36,7 +37,7 @@ const CANONICAL_BUILD = "0000";
 * throws this rather than letting the package go out carrying a version a
 * consumer refuses.
 */
-var AppVersionSchemaError = class extends TaggedError("AppVersionSchemaError") {};
+var AppVersionSchemaError = class extends AppVersionSchemaErrorBase {};
 /**
 * `value` when it already fits, and a value derived from it when it does not.
 *

package/dist/docx/archiveInflation.d.ts

@@ -18,7 +18,7 @@ declare module "jszip" {
  * mebibyte under 15:1. A DEFLATE stream tops out near 1032:1, which is the
  * shape of an entry made of one repeated byte.
  */
-declare const DOCX_MAX_COMPRESSION_RATIO = 200;
+export declare const DOCX_MAX_COMPRESSION_RATIO = 200;
 /**
  * Inflated size below which the ratio cap does not apply.
  *
@@ -26,7 +26,7 @@ declare const DOCX_MAX_COMPRESSION_RATIO = 200;
  * so the ratio only has to bound entries (and packages) large enough to
  * matter. The byte caps still apply below this size.
  */
-declare const DOCX_COMPRESSION_RATIO_GRACE_BYTES: number;
+export declare const DOCX_COMPRESSION_RATIO_GRACE_BYTES: number;
 /**
  * Upper bound on the central-directory records in `bytes`, counted without
  * parsing the archive and stopping once the count passes `stopAfter`.
@@ -35,28 +35,28 @@ declare const DOCX_COMPRESSION_RATIO_GRACE_BYTES: number;
  * signature occurrences cannot be lower than the number of entries JSZip would
  * build, whatever the end-of-central-directory record claims.
  */
-declare const countCentralDirectoryRecords: (bytes: Uint8Array, stopAfter: number) => number;
+export declare const countCentralDirectoryRecords: (bytes: Uint8Array, stopAfter: number) => number;
 /** Sizes a loaded entry declares in the central directory. */
-type ZipEntrySizes = {
+export type ZipEntrySizes = {
   readonly compressedBytes: number | null;
   readonly uncompressedBytes: number | null;
 };
 /** Declared sizes of an entry JSZip loaded from an archive. */
-declare const getZipEntrySizes: (entry: JSZip.JSZipObject) => ZipEntrySizes;
+export declare const getZipEntrySizes: (entry: JSZip.JSZipObject) => ZipEntrySizes;
 /**
  * Whether a loaded entry is stored rather than compressed. A stored entry
  * reads back exactly the bytes the archive carries, so it cannot expand.
  */
-declare const isStoredZipEntry: (entry: JSZip.JSZipObject) => boolean;
+export declare const isStoredZipEntry: (entry: JSZip.JSZipObject) => boolean;
 /**
  * Whether the per-entry ratio cap applies to a part. Markup and text parts
  * never compress anywhere near the cap. Binary parts can: an uncompressed
  * bitmap of one colour compresses like a run of one byte. Those stay bounded
  * by the byte caps and the package-wide ratio instead.
  */
-declare const isRatioBoundedPart: (path: string) => boolean;
+export declare const isRatioBoundedPart: (path: string) => boolean;
 /** The per-entry ratio cap for `path`: `maxRatio`, or none for a binary part. */
-declare const compressionRatioLimitFor: (path: string, maxRatio: number) => number;
+export declare const compressionRatioLimitFor: (path: string, maxRatio: number) => number;
 type CompressionRatioCheck = {
   inflatedBytes: number;
   compressedBytes: number | null;
@@ -67,18 +67,18 @@ type CompressionRatioCheck = {
  * Sizes under {@link DOCX_COMPRESSION_RATIO_GRACE_BYTES} never do, and an
  * unknown compressed size is left to the byte caps.
  */
-declare const exceedsCompressionRatio: ({ inflatedBytes, compressedBytes, maxRatio }: CompressionRatioCheck) => boolean;
+export declare const exceedsCompressionRatio: ({ inflatedBytes, compressedBytes, maxRatio }: CompressionRatioCheck) => boolean;
 /**
  * Inflated bytes charged across one package. `aborted` stops every inflation
  * sharing the budget at its next chunk, once one of them has failed the
  * package.
  */
-type InflationBudget = {
+export type InflationBudget = {
   readonly maxTotalBytes: number;
   inflatedBytes: number;
   aborted: boolean;
 };
-declare const createInflationBudget: (maxTotalBytes: number) => InflationBudget;
+export declare const createInflationBudget: (maxTotalBytes: number) => InflationBudget;
 /**
  * The bound an inflation stopped at.
  *
@@ -88,15 +88,15 @@ declare const createInflationBudget: (maxTotalBytes: number) => InflationBudget;
  * - `total` — the package passed its cumulative budget.
  * - `aborted` — another inflation sharing the budget already failed.
  */
-type InflationLimit = "declared-size" | "compression-ratio" | "entry" | "total" | "aborted";
-type InflateEntryResult = {
+export type InflationLimit = "declared-size" | "compression-ratio" | "entry" | "total" | "aborted";
+export type InflateEntryResult = {
   readonly ok: true;
   readonly bytes: Uint8Array<ArrayBuffer>;
 } | {
   readonly ok: false;
   readonly limit: InflationLimit;
 };
-type InflateEntryOptions = {
+export type InflateEntryOptions = {
   entry: JSZip.JSZipObject;
   /** Most bytes this entry may inflate to. */
   maxEntryBytes: number;
@@ -122,6 +122,6 @@ type InflateEntryOptions = {
  * reject; limits resolve with `ok: false` for the caller to map onto its own
  * error or skip policy.
  */
-declare const inflateEntryWithinLimits: ({ entry, maxEntryBytes, maxCompressionRatio, budget, retain }: InflateEntryOptions) => Promise<InflateEntryResult>;
+export declare const inflateEntryWithinLimits: ({ entry, maxEntryBytes, maxCompressionRatio, budget, retain }: InflateEntryOptions) => Promise<InflateEntryResult>;
 //#endregion
-export { DOCX_COMPRESSION_RATIO_GRACE_BYTES, DOCX_MAX_COMPRESSION_RATIO, InflateEntryOptions, InflateEntryResult, InflationBudget, InflationLimit, ZipEntrySizes, compressionRatioLimitFor, countCentralDirectoryRecords, createInflationBudget, exceedsCompressionRatio, getZipEntrySizes, inflateEntryWithinLimits, isRatioBoundedPart, isStoredZipEntry };
+export {};

package/dist/docx/archiveInflation.js

@@ -14,7 +14,7 @@ const DOCX_MAX_COMPRESSION_RATIO = 200;
 * so the ratio only has to bound entries (and packages) large enough to
 * matter. The byte caps still apply below this size.
 */
-const DOCX_COMPRESSION_RATIO_GRACE_BYTES = 4 * 1024 * 1024;
+const DOCX_COMPRESSION_RATIO_GRACE_BYTES = 4194304;
 const CENTRAL_DIRECTORY_RECORD_SIGNATURE = [
 	80,
 	75,

package/dist/docx/attributeRemainder.d.ts

@@ -1,14 +1,15 @@
 import { ModelledAttributes } from "./propertyElementAttributes.js";
 import { XmlElement } from "./xmlParser.js";
 import { PreservedAttribute } from "@stll/docx-core/model";
+import { TaggedErrorClass } from "better-result";
 //#region src/docx/attributeRemainder.d.ts
-declare const InvalidPreservedAttributeError_base: import("better-result").TaggedErrorClass<"InvalidPreservedAttributeError">;
-declare class InvalidPreservedAttributeError extends InvalidPreservedAttributeError_base<{
+declare const InvalidPreservedAttributeErrorBase: TaggedErrorClass<"InvalidPreservedAttributeError">;
+export declare class InvalidPreservedAttributeError extends InvalidPreservedAttributeErrorBase<{
   message: string;
   name: string;
 }> {}
 /** Whether an attribute remainder can be emitted under a bound canonical name. */
-declare const isSerializablePreservedAttribute: ({ namespace, name }: Pick<PreservedAttribute, "namespace" | "name">) => boolean;
+export declare const isSerializablePreservedAttribute: ({ namespace, name }: Pick<PreservedAttribute, "namespace" | "name">) => boolean;
 /**
  * The modelled set of an element whose serializer writes no attribute at all.
  *
@@ -17,7 +18,7 @@ declare const isSerializablePreservedAttribute: ({ namespace, name }: Pick<Prese
  * at each call site, so the claim is visible and one place has to change when
  * one of them gains a modelled attribute.
  */
-declare const NO_MODELLED_ATTRIBUTES: ReadonlySet<string>;
+export declare const NO_MODELLED_ATTRIBUTES: ReadonlySet<string>;
 /**
  * What a part's root element states rather than carries, so the remainder skips it.
  *
@@ -29,7 +30,7 @@ declare const NO_MODELLED_ATTRIBUTES: ReadonlySet<string>;
  * the attribute twice. This is the same rule namespace declarations already
  * follow, one attribute further on.
  */
-declare const DERIVED_PART_ROOT_ATTRIBUTES: ReadonlySet<string>;
+export declare const DERIVED_PART_ROOT_ATTRIBUTES: ReadonlySet<string>;
 type AttributeRemainderOptions = {
   /** The element, as the source wrote it. */
   element: XmlElement;
@@ -50,7 +51,7 @@ type AttributeRemainderOptions = {
  *   empty list is never written, so a fully modelled element stays identical
  *   in the model.
  */
-declare const attributeRemainder: ({ element, modelled }: AttributeRemainderOptions) => PreservedAttribute[] | undefined;
+export declare const attributeRemainder: ({ element, modelled }: AttributeRemainderOptions) => PreservedAttribute[] | undefined;
 /**
  * The remainder of an attribute bag, with the modelled set derived from the
  * record's own fields.
@@ -63,7 +64,7 @@ declare const attributeRemainder: ({ element, modelled }: AttributeRemainderOpti
  * site is what keeps the predicate derived from the model: a field added
  * without an attribute to name does not compile.
  */
-declare const readAttributeBag: (element: XmlElement, modelled: ModelledAttributes<string>) => PreservedAttribute[] | undefined;
+export declare const readAttributeBag: (element: XmlElement, modelled: ModelledAttributes<string>) => PreservedAttribute[] | undefined;
 /**
  * The element's attributes, modelled first and the remainder after them.
  *
@@ -71,6 +72,6 @@ declare const readAttributeBag: (element: XmlElement, modelled: ModelledAttribut
  *   spelled — they win a collision, because the model is the editable copy
  * @returns the fragments to write, so an element with neither writes nothing
  */
-declare const serializePreservedAttributes: (modelled: readonly string[], preserved: readonly PreservedAttribute[] | undefined) => string[];
+export declare const serializePreservedAttributes: (modelled: readonly string[], preserved: readonly PreservedAttribute[] | undefined) => string[];
 //#endregion
-export { DERIVED_PART_ROOT_ATTRIBUTES, InvalidPreservedAttributeError, NO_MODELLED_ATTRIBUTES, attributeRemainder, isSerializablePreservedAttribute, readAttributeBag, serializePreservedAttributes };
+export {};

package/dist/docx/attributeRemainder.js

@@ -6,6 +6,40 @@ import { TaggedError } from "better-result";
 import { escapeXmlAttribute } from "@stll/docx-core";
 //#region src/docx/attributeRemainder.ts
 /**
+* The attribute remainder: what an element carried and its parser has no field for.
+*
+* The child dispatcher makes a container's unrecognised *children* a decision
+* somebody wrote down. Its attributes had no such branch at all: a parser reads
+* the ones it models off the element and the serializer rebuilds the start tag
+* from the model, so everything else goes. Word writes a revision-session id
+* (`w:rsidR` and its family) on nearly every paragraph, run, row and section,
+* and a save rewrote the whole document's revision history.
+*
+* Two rules make this safe, and both are the opposite of what a name-matching
+* remainder would do:
+*
+* - **Resolve, then decide.** folio reads an attribute by namespace URI plus
+*   local name, with a local-name fallback across prefixes, so an element that
+*   binds a second prefix to the WordprocessingML URI and writes `altw:rsidR`
+*   is read exactly as `w:rsidR` is. A remainder that matched the spelling
+*   would keep a second copy of an attribute the parser had already read. So
+*   the decision is made on the resolved local name, and what is written back
+*   is the canonical prefix for the resolved URI, never the source's.
+* - **The writer, not the predicate, prevents a double.** The modelled
+*   attributes are handed to {@link serializePreservedAttributes} as the
+*   fragments it is about to emit, and a remainder entry that would spell one
+*   of them again is dropped. The predicate below mirrors what each parser
+*   reads, and a mirror drifts; this is the guard that keeps the drift from
+*   reaching the part as a duplicate attribute, which makes it unopenable.
+*
+* A namespace declaration is not in the remainder. `partNamespaces.ts` derives
+* a rebuilt part's bindings from the prefixes the part actually uses, so
+* replaying the source element's own `xmlns:*` would fight the root's. For the
+* same reason an attribute whose namespace that table cannot spell is not kept:
+* writing it would emit an unbound prefix and fail the save, which is a worse
+* answer than recording the drop in the container contract.
+*/
+/**
 * Namespace URI to the prefix a rebuilt part binds for it.
 *
 * `xml` is reserved rather than declared — {@link OOXML_NAMESPACES} excludes
@@ -15,7 +49,8 @@ import { escapeXmlAttribute } from "@stll/docx-core";
 */
 const CANONICAL_PREFIX = new Map([...Object.entries(OOXML_NAMESPACES).map(([prefix, { uri }]) => [uri, prefix]), [XML_NAMESPACE_URI, "xml"]]);
 const XML_LOCAL_NAME = /^[\p{L}_][\p{L}\p{M}\p{N}._\-\u{00B7}\u{203F}-\u{2040}]*$/u;
-var InvalidPreservedAttributeError = class extends TaggedError("InvalidPreservedAttributeError") {};
+const InvalidPreservedAttributeErrorBase = TaggedError("InvalidPreservedAttributeError");
+var InvalidPreservedAttributeError = class extends InvalidPreservedAttributeErrorBase {};
 /** Whether an attribute remainder can be emitted under a bound canonical name. */
 const isSerializablePreservedAttribute = ({ namespace, name }) => name !== "xmlns" && XML_LOCAL_NAME.test(name) && (namespace === void 0 || CANONICAL_PREFIX.has(namespace));
 /**

package/dist/docx/blockContentParser.d.ts

@@ -24,7 +24,7 @@ type ParseBlockContentState = {
   previousList: PreviousListState;
   options: BlockContentScope;
 };
-declare const parseBlockContent: (parent: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, options?: ParseBlockContentOptions) => document_d_exports.BlockContent[];
+export declare const parseBlockContent: (parent: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, options?: ParseBlockContentOptions) => document_d_exports.BlockContent[];
 /** The parts and maps a block sequence is read against. */
 type BlockContentResources = {
   styles: StyleMap | null;
@@ -39,7 +39,7 @@ type BlockContentWalk = {
   state: ParseBlockContentState;
   modelled: document_d_exports.BlockContent[];
 };
-declare const BLOCK_CONTENT_HANDLERS: {
+export declare const BLOCK_CONTENT_HANDLERS: {
   readonly altChunk: "capture";
   readonly commentRangeEnd: "capture";
   readonly commentRangeStart: "capture";
@@ -54,16 +54,24 @@ declare const BLOCK_CONTENT_HANDLERS: {
   readonly del: "capture";
   readonly ins: "capture";
   readonly moveFrom: "capture";
-  readonly moveFromRangeEnd: "capture";
-  readonly moveFromRangeStart: "capture";
   readonly moveTo: "capture";
-  readonly moveToRangeEnd: "capture";
-  readonly moveToRangeStart: "capture";
   readonly permEnd: "capture";
   readonly permStart: "capture";
   readonly proofErr: "capture";
   readonly sectPr: OwnedElsewhere<"block-content", "sectPr">;
   readonly tcPr: OwnedElsewhere<"block-content", "tcPr">;
+  readonly moveFromRangeStart: (child: XmlElement, walk: {
+    modelled: document_d_exports.BlockContent[];
+  }) => void;
+  readonly moveFromRangeEnd: (child: XmlElement, walk: {
+    modelled: document_d_exports.BlockContent[];
+  }) => void;
+  readonly moveToRangeStart: (child: XmlElement, walk: {
+    modelled: document_d_exports.BlockContent[];
+  }) => void;
+  readonly moveToRangeEnd: (child: XmlElement, walk: {
+    modelled: document_d_exports.BlockContent[];
+  }) => void;
   readonly p: (child: XmlElement, { resources: { styles, theme, numbering, rels, media }, state, modelled }: BlockContentWalk) => void;
   readonly tbl: (child: XmlElement, { resources: { styles, theme, numbering, rels, media }, state, modelled }: BlockContentWalk) => "capture" | undefined;
   readonly sdt: (child: XmlElement, { resources: { styles, theme, numbering, rels, media }, state, modelled }: BlockContentWalk) => void;
@@ -72,4 +80,4 @@ declare const BLOCK_CONTENT_HANDLERS: {
   readonly bookmarkEnd: (child: XmlElement, { modelled }: BlockContentWalk) => void;
 };
 //#endregion
-export { BLOCK_CONTENT_HANDLERS, parseBlockContent };
+export {};

package/dist/docx/blockContentParser.js

@@ -2,6 +2,7 @@ import { blockCustomXmlShell } from "./blockCustomXmlShell.js";
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
 import { CAPTURE, dispatchChildrenWithContext, ownedElsewhere, withPreservedChildren } from "./containerChildren.js";
 import { computeListMarker } from "./listMarkerComputation.js";
+import { BLOCK_MOVE_RANGE_MARKER_HANDLERS } from "./markupRangeMarker.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { enrichParagraphTextBoxes } from "./paragraphTextBoxEnrichment.js";
 import { standalonePreviewLedger } from "./previewBudget.js";
@@ -102,6 +103,7 @@ const BLOCK_CONTENT_HANDLERS = {
 	bookmarkEnd: (child, { modelled }) => {
 		modelled.push(parseBookmarkEnd(child));
 	},
+	...BLOCK_MOVE_RANGE_MARKER_HANDLERS,
 	...BLOCK_CHILD_OWNERS,
 	altChunk: CAPTURE,
 	commentRangeEnd: CAPTURE,
@@ -117,18 +119,14 @@ const BLOCK_CONTENT_HANDLERS = {
 	del: CAPTURE,
 	ins: CAPTURE,
 	moveFrom: CAPTURE,
-	moveFromRangeEnd: CAPTURE,
-	moveFromRangeStart: CAPTURE,
 	moveTo: CAPTURE,
-	moveToRangeEnd: CAPTURE,
-	moveToRangeStart: CAPTURE,
 	permEnd: CAPTURE,
 	permStart: CAPTURE,
 	proofErr: CAPTURE
 };
 const parseBlockContentWithState = (parent, styles, theme, numbering, rels, media, state) => {
 	const modelled = [];
-	return withPreservedChildren(modelled, dispatchChildrenWithContext({
+	const preserved = dispatchChildrenWithContext({
 		element: parent,
 		container: "block-content",
 		capturePosition: () => modelled.length,
@@ -145,7 +143,8 @@ const parseBlockContentWithState = (parent, styles, theme, numbering, rels, medi
 			state,
 			modelled
 		}
-	}), (xml) => ({
+	});
+	return withPreservedChildren(modelled, preserved, (xml) => ({
 		type: "preservedBlock",
 		xml
 	}));

package/dist/docx/blockCustomXmlShell.d.ts

@@ -2,6 +2,5 @@ import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
 //#region src/docx/blockCustomXmlShell.d.ts
 /** Capture the wrapper independently of its modeled and preserved children. */
-declare const blockCustomXmlShell: (element: XmlElement) => Pick<document_d_exports.BlockCustomXml, "openingXml" | "closingXml">;
-//#endregion
-export { blockCustomXmlShell };
+export declare const blockCustomXmlShell: (element: XmlElement) => Pick<document_d_exports.BlockCustomXml, "openingXml" | "closingXml">;
+//#endregion

package/dist/docx/blockPlainText.d.ts

@@ -1,7 +1,6 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/blockPlainText.d.ts
 /** One entry per accepted block; deleted breaks and table structure resolve together. */
-declare const collectBlockTexts: (blocks: readonly document_d_exports.BlockContent[]) => string[];
-declare const blockPlainText: (blocks: readonly document_d_exports.BlockContent[]) => string;
-//#endregion
-export { blockPlainText, collectBlockTexts };
+export declare const collectBlockTexts: (blocks: readonly document_d_exports.BlockContent[]) => string[];
+export declare const blockPlainText: (blocks: readonly document_d_exports.BlockContent[]) => string;
+//#endregion

package/dist/docx/blockPlainText.js

@@ -41,7 +41,11 @@ const collectResolvedBlockTexts = (blocks) => {
 			else if (isOpaqueNestedRowMarkup(block.xml)) texts.push("[Unsupported nested w:tr content]");
 			break;
 		case "bookmarkStart":
-		case "bookmarkEnd": break;
+		case "bookmarkEnd":
+		case "moveFromRangeStart":
+		case "moveFromRangeEnd":
+		case "moveToRangeStart":
+		case "moveToRangeEnd": break;
 		default: panic(`Unsupported block in plain-text extraction: ${JSON.stringify(block)}`);
 	}
 	return texts;

package/dist/docx/bookmarkIdNormalization.d.ts

@@ -5,6 +5,5 @@
  * overlapping ambiguous ranges. Only colliding ids are repaired: those require
  * unique XML ids for a valid save. Every other source byte stays verbatim.
  */
-declare const normalizeBookmarkIdsInXmlParts: (parts: ReadonlyMap<string, string>) => ReadonlyMap<string, string>;
-//#endregion
-export { normalizeBookmarkIdsInXmlParts };
+export declare const normalizeBookmarkIdsInXmlParts: (parts: ReadonlyMap<string, string>) => ReadonlyMap<string, string>;
+//#endregion

package/dist/docx/bookmarkIds.d.ts

@@ -1,11 +1,10 @@
 import { Node } from "prosemirror-model";
 //#region src/docx/bookmarkIds.d.ts
-declare const reserveBookmarkIds: (ids: Iterable<number>) => void;
-declare const mintBookmarkId: () => number;
-declare const createBookmarkIdAllocator: (existingIds: Iterable<number>) => {
+export declare const reserveBookmarkIds: (ids: Iterable<number>) => void;
+export declare const mintBookmarkId: () => number;
+export declare const createBookmarkIdAllocator: (existingIds: Iterable<number>) => {
   reserve: (ids: Iterable<number>) => void;
   next: () => number;
 };
-declare const reserveProseBookmarkIds: (doc: Node) => void;
-//#endregion
-export { createBookmarkIdAllocator, mintBookmarkId, reserveBookmarkIds, reserveProseBookmarkIds };
+export declare const reserveProseBookmarkIds: (doc: Node) => void;
+//#endregion