@docx-editor.dev/core 2.14.1 → 2.15.0

package/dist/review-items-CaAkgi5s.d.cts

@@ -1,360 +0,0 @@
-import { g as OoxmlElement, O as OoxmlPart, b as OoxmlPackage, R as RevisionAddress } from './tree-op-types-BUulYD5y.cjs';
-
-/** The `w15` namespace: `commentsExtended.xml` — thread parent and resolved state. */
-declare const W15_NAMESPACE_URI = "http://schemas.microsoft.com/office/word/2012/wordml";
-/** A position in one story: a paragraph node id plus a UTF-16 offset inside it. */
-interface CommentPosition {
-    readonly paragraphId: string;
-    readonly offset: number;
-}
-/**
- * Where a comment is anchored, as a range.
- *
- * `orphaned` records that the file did not give this comment a usable range — a reference with
- * no range markers, or a start with no end. The comment is still listed, marked orphaned,
- * rather than dropped: a reviewer's remark disappearing silently is worse than one that says
- * it lost its text.
- */
-interface CommentAnchor {
-    readonly commentId: string;
-    /** Canonical name of the part the range lives in, so a header comment is attributable. */
-    readonly partName: string;
-    readonly start: CommentPosition;
-    readonly end: CommentPosition;
-    readonly orphaned: boolean;
-}
-/** One comment as authored in `word/comments.xml`. */
-interface CommentRecord {
-    readonly id: string;
-    readonly author: string;
-    readonly initials?: string;
-    readonly date?: string;
-    /** Body paragraphs, as tree nodes, so the surface renders measured text rather than a string. */
-    readonly blocks: readonly OoxmlElement[];
-    /** `w14:paraId` of the last body paragraph — the key thread state is stored under. */
-    readonly paraId?: string;
-    /** `@w16cid:parentId` — the `w:id` of the comment this replies to, when the file names it. */
-    readonly parentCommentId?: string;
-}
-/** Thread state for one comment, read from `commentsExtended.xml`. */
-interface CommentThreadState {
-    /** `@w15:paraIdParent` — the comment this one replies to, absent for a top-level comment. */
-    readonly parentParaId?: string;
-    readonly done: boolean;
-}
-/**
- * Every comment anchor in one story, in document order.
- *
- * Overlapping and nested ranges are supported because each anchor is resolved independently —
- * Word produces both, and a model that assumed ranges nest cleanly would mis-anchor them.
- *
- * A start with no matching end anchors to the end of its own paragraph and is reported orphaned
- * rather than guessed at: extending it to the next end marker would attach a reviewer's remark
- * to text they never saw.
- */
-declare function commentAnchorsOfStory(part: OoxmlPart): CommentAnchor[];
-/**
- * The comments in `word/comments.xml`, in authored order.
- *
- * Every value here comes from a file an attacker fully controls, so nothing is interpreted:
- * author, initials and date are carried verbatim for a surface that will set them as TEXT.
- */
-declare function commentsOfPart(part: OoxmlPart): CommentRecord[];
-/**
- * Thread state by `w14:paraId`, from `commentsExtended.xml`.
- *
- * The part being PRESENT is not evidence of threading. `issue-68-large-comments-suggestions.docx`
- * ships it with 212 entries carrying `@w15:done` and not one `@w15:paraIdParent`, so it records
- * resolved state for a flat list. Absent parent means top-level, and that is a fact about the
- * file rather than a default this code chose.
- */
-declare function threadStateOfPart(part: OoxmlPart): Map<string, CommentThreadState>;
-/**
- * Whether the package holds any `w:comment` record — the cheap gate before a reap.
- *
- * Overflow cannot prove the package is comment-free, so it returns true and the reap still
- * runs rather than skipping cleanup.
- */
-declare function hasAnyComment(pkg: OoxmlPackage): boolean;
-
-/** A position in the model offset space of one story. */
-interface ReviewPosition {
-    readonly paragraphId: string;
-    readonly offset: number;
-}
-/** Where an item is anchored: a range in one story. */
-interface ReviewRange {
-    readonly partName: string;
-    readonly start: ReviewPosition;
-    readonly end: ReviewPosition;
-}
-/**
- * What kind of decision a revision card represents.
- *
- * Wider than the four content wrappers, because a reviewer has to be shown every pending
- * decision, including the ones that decorate no characters. A card the surface cannot show is
- * a change the reviewer never learns about — and `acceptAllRevisions` refuses if ANY revision
- * in the document is one the engine cannot resolve, so an invisible one makes Accept All fail
- * for a reason nothing on screen explains.
- */
-type ReviewRevisionKind = 'insert' | 'delete'
-/**
- * A deletion and an insertion that are one edit: text typed over a selection.
- *
- * Word shows these as a single `Replaced "x" with "y"` card, and resolving one half
- * without the other is never what the reviewer meant — accepting the deletion alone
- * leaves the replacement text unproposed, rejecting it alone leaves both.
- */
- | 'replace' | 'moveFrom' | 'moveTo'
-/** `w:rPrChange` / `w:pPrChange` — the words are unchanged, their formatting is not. */
- | 'format'
-/** `w:pPr/w:rPr/w:ins|w:del` — a paragraph split or merge. */
- | 'paragraphMark'
-/** A row, cell, section or grid revision. Supported row revisions are resolvable. */
- | 'structural';
-/**
- * One tracked change as a review card.
- *
- * Keyed per DECISION rather than per site: a revision spanning three ranges is one card, because
- * accepting it accepts all three.
- */
-interface ReviewRevisionItem {
-    readonly kind: 'revision';
-    /** Stable across renders and unique per DECISION, not per site. */
-    readonly id: string;
-    /** The payload `acceptRevision` / `rejectRevision` take. */
-    readonly address: RevisionAddress;
-    /**
-     * EVERY address this decision covers, `address` first.
-     *
-     * More than one only for a replacement, whose halves a foreign editor may have written
-     * as two independent revisions. Accept and reject walk all of them in one transaction:
-     * resolving one half and leaving the other is a state no reviewer asked for.
-     */
-    readonly addresses: readonly RevisionAddress[];
-    /** The words a replacement removes. Empty for every other kind. */
-    readonly replacedText: string;
-    readonly revisionKind: ReviewRevisionKind;
-    /**
-     * WHICH decision a `paragraphMark` records, absent for every other kind.
-     *
-     * `EG_ParaRPrTrackChanges` is `ins? del? moveFrom? moveTo?`, and the four say opposite
-     * things about one break. Without this a card called a deleted break an inserted one, which
-     * is the reverse of what Accept on that card does.
-     */
-    readonly markDirection?: 'insert' | 'delete' | 'moveFrom' | 'moveTo';
-    readonly author: string;
-    readonly date?: string;
-    /** Text the revision covers, for the card summary. Empty for changes with no characters. */
-    readonly text: string;
-    /** Every site this decision touches, in document order. */
-    readonly ranges: readonly ReviewRange[];
-    /**
-     * How deeply this change is NESTED inside other changes, 0 for an unenclosed one.
-     *
-     * `w:ins` wrapping `w:del` is content one reviewer added and another struck. Both stay
-     * pending, so both are cards, over one identical range — and a range then cannot say which
-     * change a caret is in. Word treats the innermost as the operative one, so it wins the caret
-     * and the change enclosing it stays listed and reachable.
-     */
-    readonly nesting: number;
-    /**
-     * How many leading `ranges` are the STRUCK half of a replacement.
-     *
-     * A replacement's card is one decision but its ranges are two colours — red over what is
-     * going, green over what takes its place. ABSENT when the halves do not split at a single
-     * point, which is what a file recording both under one revision id can produce; a surface
-     * then has no basis for two colours and should paint one neutral band rather than guess.
-     */
-    readonly replacedRangeCount?: number;
-    /**
-     * True when the engine cannot resolve this kind, so accept and reject must not be offered.
-     *
-     * Derived by the DERIVATION rather than from a caller-supplied predicate: the refusal list
-     * is internal, and a surface asked to compute it would have to guess. A card that offers a
-     * button the engine will refuse is worse than one that explains why it cannot.
-     */
-    readonly readOnly: boolean;
-    /** The other half of a move, or the other side of a delete/insert replacement. */
-    readonly pairedWith?: string;
-    /**
-     * Comments answering this change, in document order.
-     *
-     * A reply to a tracked change IS a comment: `w:ins` and `w:del` carry no body, so the text
-     * is written as a comment over the revision's own range and the range is what links them.
-     */
-    readonly replyIds: readonly string[];
-}
-/**
- * One comment as a review card. A reply carries `parentId`; OOXML gives replies no separate
- * element, so threads are reconstructed from that link.
- */
-interface ReviewCommentItem {
-    readonly kind: 'comment';
-    readonly id: string;
-    readonly comment: CommentRecord;
-    readonly range: ReviewRange | null;
-    readonly resolved: boolean;
-    /** The comment this replies to, absent for a top-level comment. */
-    readonly parentId?: string;
-    /** The REVISION this comment answers, when it covers exactly that change's characters. */
-    readonly parentRevisionId?: string;
-    /** Replies to this comment, in document order. Empty for a reply or a childless comment. */
-    readonly replyIds: readonly string[];
-    /** True when the file gave this comment no usable range. */
-    readonly orphaned: boolean;
-}
-/**
- * A card contributed by a recognized custom node (`defineCustomNode` with a `reviewCard`
- * hook), anchored at the node's range.
- *
- * Informational, never resolvable: there is nothing to accept or reject, so the engine
- * refuses those verbs on it. `title` and `detail` are HOST-authored (the definition's hook
- * produced them), but `attrs` and `text` originate in a file an attacker controls — a
- * surface renders every one of these as text, never markup.
- */
-interface ReviewCustomItem {
-    readonly kind: 'custom';
-    /** The SDT node's stable id in the canonical tree. */
-    readonly id: string;
-    /** The definition's `name`. */
-    readonly name: string;
-    /** The raw `w:tag` the node was recognized from. Untrusted input. */
-    readonly tag: string;
-    /** Attrs decoded from the tag, after the definition's recognition hook. Untrusted input. */
-    readonly attrs: Readonly<Record<string, string>>;
-    /** The SDT's literal content text. Untrusted input. */
-    readonly text: string;
-    /**
-     * The payload the node's control binds to, after the definition validated it.
-     *
-     * Undefined when the node carries none or the payload did not match — see the pro package's
-     * `RecognizedCustomNode.data`, which this is carried from.
-     */
-    readonly data?: unknown;
-    /**
-     * Whether this node asked for a sidebar card.
-     *
-     * False for a definition with no `reviewCard`: the item exists so the chip's own surfaces can
-     * read `attrs`, `text` and `data` off it, and the rail leaves it out. A surface listing cards
-     * filters on this rather than on an empty `title`.
-     */
-    readonly carded: boolean;
-    /** Card title, from the definition's `reviewCard` hook. Empty when `carded` is false. */
-    readonly title: string;
-    /** Card body, from the definition's `reviewCard` hook. */
-    readonly detail?: string;
-    /**
-     * Glyph for this node in the collapsed rail, as an SVG path in a `0 -960 960 960` viewBox.
-     *
-     * A PATH rather than a rendered node because this item crosses core, which is DOM-free and
-     * React-free — the same reason `title` and `detail` are strings. A host that wants arbitrary
-     * markup overrides the `Markers` part's `icon` instead, which lives in the adapter where JSX
-     * belongs. Absent falls back to the generic custom-node glyph.
-     *
-     * HOST-AUTHORED, never file data: it is interpolated into an SVG `d` attribute, and a path
-     * taken from a document would be attacker-controlled markup.
-     */
-    readonly icon?: string;
-    readonly range: ReviewRange | null;
-}
-/**
- * One pending decision in the review queue: a tracked change, a comment thread, or a pro
- * custom-node card. Discriminate on `kind`.
- *
- * The store's own derivation (`collectReviewItems`) only ever produces the first two; the
- * `kind: 'custom'` card is contributed by the pro review module, which recognizes the node.
- */
-type ReviewItem = ReviewRevisionItem | ReviewCommentItem | ReviewCustomItem;
-/** What the review queue derivation reads: one story part plus its comment parts. */
-interface ReviewModelInput {
-    /** The story the ranges live in — the main document, a header, a note. */
-    readonly storyPart: OoxmlPart;
-    /**
-     * Header/footer story parts, in section order. Their revisions and comment anchors join
-     * the queue: a tracked change in a header is a pending decision like any other, and a
-     * queue that only walked the body silently hid it from the rail AND from Accept All.
-     */
-    readonly furnitureParts?: readonly OoxmlPart[] | undefined;
-    /** `word/comments.xml`, absent when the package has none. */
-    readonly commentsPart?: OoxmlPart | undefined;
-    /** `word/commentsExtended.xml`, absent when the package has none. */
-    readonly commentsExtendedPart?: OoxmlPart | undefined;
-    /**
-     * Custom node definitions from the module registry, forwarded OPAQUELY.
-     *
-     * Core carries them the way the registry does — as unknowns — so the definition shape
-     * stays a capability-package concern. The pro derivation narrows them and contributes
-     * `kind: 'custom'` cards for definitions that opted in.
-     */
-    readonly customNodes?: readonly unknown[] | undefined;
-    /**
-     * Where a capability package reports a node it could not read. Supplied per editor, so a page
-     * with two of them keeps their diagnostics apart.
-     */
-    readonly reportCustomNodeDiagnostic?: ((diagnostic: unknown) => void) | undefined;
-    /**
-     * The payload each of the story's controls binds to, keyed by the control's node id.
-     *
-     * Resolved by the ENGINE and handed over, because a payload lives in a customXml data part
-     * and a derivation that only receives story parts has no way to reach one. Untrusted file
-     * input on both members; a capability package validates it against whatever shape it
-     * declared before handing it to a host.
-     */
-    readonly customNodePayloads?: ReadonlyMap<string, {
-        readonly nodeId: string;
-        readonly label: string;
-        readonly data: string;
-    }> | undefined;
-}
-/** The stable key a surface uses for the active item and for a React list. */
-declare function reviewItemKey(item: ReviewItem): string;
-/** Every range a decision touches. One card can cover several, in different paragraphs. */
-declare function reviewItemRanges(item: ReviewItem): readonly ReviewRange[];
-/** The first range of an item, in authored order, or null when it has none. */
-declare function firstReviewRange(item: ReviewItem): ReviewRange | null;
-/**
- * A single comparable number for document order.
- *
- * Paragraph index dominates offset, so a revision spanning paragraphs still sorts by where it
- * STARTS. An item with no resolvable range sorts last rather than to position zero, which is
- * where an orphan used to land — tearing an orphaned reply out of its own thread.
- */
-declare function reviewItemPositionRank(item: ReviewItem, order: ReadonlyMap<string, number>): number;
-/**
- * Every item covering a position, innermost first.
- *
- * Returning the whole stack rather than one winner is what lets a surface offer cycling, a
- * stacked card, or a "1 of 3" affordance. A comment wrapping a revision used to be unreachable
- * because only the tightest range was ever returned.
- */
-declare function reviewItemsAt(items: readonly ReviewItem[], position: ReviewPosition, order: ReadonlyMap<string, number>): ReviewItem[];
-/**
- * The item the caret is in, or null.
- *
- * A resolved comment never activates: a settled thread must not reopen itself as the reviewer
- * types near it.
- *
- * A REPLY resolves to the thread it belongs to. A reply is anchored over its parent's range,
- * so both cover the caret — and the reply, being newer, wins the innermost test. It is not a
- * card of its own (it renders inside its parent's), so the thread would have gone active with
- * nothing on screen showing it: the reply box vanished from a comment the moment somebody
- * replied to it.
- */
-declare function activeReviewItem(items: readonly ReviewItem[], position: ReviewPosition, order: ReadonlyMap<string, number>): ReviewItem | null;
-/**
- * Walk a reply up to the card that heads its thread. Guarded against a cyclic file.
- *
- * The head is not always a comment. A reply to a tracked change renders inside the REVISION's
- * card, so resolving it to itself opened an item nothing on screen was drawing — the reply box
- * vanished the moment somebody answered a change.
- *
- * EXPORTED because the paginated surface answers "which card is open" itself, against its own
- * dismissed-key state, rather than through {@link activeReviewItem}. Two copies of the
- * innermost-wins rule was survivable while a reply could only be a comment — the parent came
- * first in `comments.xml` order and won the tie by accident. It stopped being survivable the
- * moment a reply could answer a revision, which outranks it outright.
- */
-declare function reviewThreadRootOf(items: readonly ReviewItem[], comment: ReviewCommentItem): ReviewItem;
-
-export { type CommentRecord as C, type ReviewModelInput as R, W15_NAMESPACE_URI as W, type ReviewItem as a, type ReviewRevisionItem as b, type ReviewCommentItem as c, type ReviewCustomItem as d, type ReviewPosition as e, type ReviewRange as f, type ReviewRevisionKind as g, type CommentThreadState as h, type CommentAnchor as i, type CommentPosition as j, activeReviewItem as k, firstReviewRange as l, reviewItemPositionRank as m, reviewItemRanges as n, reviewItemsAt as o, reviewThreadRootOf as p, commentAnchorsOfStory as q, reviewItemKey as r, commentsOfPart as s, hasAnyComment as t, threadStateOfPart as u };

package/dist/review-reads-DEsV0OOW.d.cts

@@ -1,163 +0,0 @@
-import { a as OoxmlNode, g as OoxmlElement, h as OoxmlContentControlNode, d as OoxmlGenericElementNode, i as OoxmlContentControlContentNode, O as OoxmlPart } from './tree-op-types-BUulYD5y.cjs';
-import { C as CommentRecord, f as ReviewRange, R as ReviewModelInput, a as ReviewItem, e as ReviewPosition, h as CommentThreadState, c as ReviewCommentItem, b as ReviewRevisionItem } from './review-items-CaAkgi5s.cjs';
-
-/** Nested content-control wrappers deeper than this stop flattening; content stays preserved. */
-declare const MAX_CONTENT_CONTROL_NESTING = 32;
-type ContentControlLike = OoxmlContentControlNode | OoxmlGenericElementNode;
-type ContentControlContentLike = OoxmlContentControlContentNode | OoxmlGenericElementNode;
-/**
- * Block or inline structured-document-tag wrapper — typed or generic during migration.
- *
- * Generic fallback requires the WordprocessingML namespace so foreign-namespace
- * `<x:sdt>` elements stay opaque wrappers and are never treated as Word controls.
- */
-declare function isContentControl(node: OoxmlNode): node is ContentControlLike;
-/**
- * True when `node` is the control's content container (`w:sdtContent`).
- *
- * Generic `sdtContent` requires the WML namespace — same foreign-namespace rule as
- * {@link isContentControl}.
- */
-declare function isContentControlContent(node: OoxmlNode): node is ContentControlContentLike;
-/** Children of the first `w:sdtContent` under a control, or null when absent or not a control. */
-declare function contentControlContentOf(node: OoxmlNode): readonly OoxmlNode[] | null;
-/**
- * Children of every `w:sdtContent` under a control, in document order.
- *
- * Does not recurse into nested controls — callers that flatten blocks or inline runs do that
- * with their own depth counter against {@link MAX_CONTENT_CONTROL_NESTING}.
- */
-declare function contentControlContentChildren(control: OoxmlNode): readonly OoxmlNode[];
-/**
- * Collect paragraph and table blocks from a sibling list, flattening through content-control
- * wrappers up to {@link MAX_CONTENT_CONTROL_NESTING}.
- *
- * `accept` filters which typed blocks are kept (e.g. skip revision-removed paragraphs). When
- * nesting exceeds the bound the wrapper is skipped entirely — same fail-closed rule as the
- * historical `storyBlocks` walk.
- */
-declare function collectFlowBlocks(children: readonly OoxmlNode[], depth?: number, accept?: (block: OoxmlElement) => boolean): OoxmlElement[];
-/**
- * Story blocks in document order, flattening block-level content controls — same shape as
- * layout's `storyBlocks` and store `bodyBlocks`.
- */
-declare function walkStoryBlocks(children: readonly OoxmlNode[], depth: number, visit: (block: OoxmlElement) => void): void;
-/**
- * Every story paragraph in reading order — body, table cells, and flattened block controls.
- */
-declare function walkAllStoryParagraphs(children: readonly OoxmlNode[], sdtDepth: number, visit: (paragraph: OoxmlElement) => void): void;
-/**
- * Paragraph-level inline sequence — runs, hyperlinks, and inline content controls in order.
- *
- * `visit` receives each direct `w:r` and any other inline node the caller treats as opaque
- * (bookmarks, drawings, …). Hyperlinks and content controls are descended transparently.
- */
-declare function walkParagraphInline(children: readonly OoxmlNode[], depth: number, visit: (child: OoxmlNode) => void): void;
-
-/** Plain text of a comment's body, so a card never re-implements the run walk. */
-declare function commentBodyText(comment: CommentRecord): string;
-/** Author initials for an avatar, from `@w:initials` or the name. */
-declare function commentInitials(comment: CommentRecord): string;
-/**
- * Every revision in one story, one card per DECISION.
- *
- * Sites sharing an `(id, author, date)` triple are ONE revision — a tracked row insertion is
- * `w:trPr/w:ins` plus `w:cellIns` on every cell — so they coalesce into one card listing every
- * range it touches. Keying per site would show the reviewer four decisions where there is one,
- * and accepting any of them would make the other three vanish.
- *
- * Memoized per part root like the indexes it reads, and for the same reason: a heavily
- * tracked document produces tens of thousands of cards, and rebuilding them per read cost
- * more than everything the memos above saved. The paragraph-scoped view the local review
- * patch derives (`revisionItemsOfParagraph`'s synthetic paragraph-root part) is NOT cached:
- * each keystroke would insert a fresh root and churn the bounded ring. The instance is
- * SHARED, so the return type is readonly.
- */
-declare function revisionItemsOf(part: OoxmlPart): readonly ReviewRevisionItem[];
-/**
- * Comment cards, threaded however the file says so and flat when nothing says so.
- *
- * ECMA-376 §17.13.4.2 gives `CT_Comment` no parent pointer, so threading is never something
- * the standard states outright. Three sources, strongest first: `@w15:paraIdParent`, then
- * `@w16cid:parentId` — both in namespaces outside Part 1 — and finally a COINCIDENT anchor, a
- * comment whose `w:commentRangeStart`/`End` cover exactly the characters an earlier comment's
- * cover. The ranges are Part 1's own vocabulary and the only part of a thread that survives a
- * producer dropping the extension parts. Coincidence is the last resort and never overrides a
- * stated link.
- *
- * Deliberately not containment. A remark on one word inside another remark's sentence nests
- * without being a reply, and reading that as a thread would bury an independent comment inside
- * someone else's.
- */
-declare function commentItemsOf(comments: readonly CommentRecord[], anchors: readonly {
-    commentId: string;
-    partName: string;
-    start: ReviewPosition;
-    end: ReviewPosition;
-    orphaned: boolean;
-}[], threadState: ReadonlyMap<string, CommentThreadState>): ReviewCommentItem[];
-/**
- * Everything the review surface lists, in document order.
- *
- * Order is by paragraph position within the story, then by offset. A comment and the revision
- * it covers therefore arrive together, which is what lets a surface group them. Furniture
- * stories rank after the body in one merged order — their geometry (the page they first paint
- * on) is a layout question the queue deliberately does not answer.
- */
-declare function collectReviewItems(input: ReviewModelInput): ReviewItem[];
-/**
- * The shape {@link linkRevisionReplies} needs, stated STRUCTURALLY.
- *
- * The store's queue is revisions and comments; the layout lane's adds a third kind for custom
- * nodes, and neither union is assignable to the other. Both lanes have to run this pass — the
- * store on the full derivation, the session on the locally patched list — so the pass is
- * written against the fields it actually reads rather than against either union, and hands
- * back the caller's own item type.
- */
-interface LinkableReviewItem {
-    readonly kind: string;
-    readonly id: string;
-    readonly ranges?: readonly ReviewRange[];
-    readonly range?: ReviewRange | null;
-    readonly parentId?: string;
-    readonly parentRevisionId?: string;
-    readonly replyIds?: readonly string[];
-    readonly orphaned?: boolean;
-    /** How deeply a revision is nested; absent on the kinds that cannot nest. */
-    readonly nesting?: number;
-}
-/**
- * Attach each comment that answers a tracked change to the change it answers.
- *
- * A matching non-empty RANGE is the evidence. A stated comment reply beats an inferred revision
- * link, and the deepest revision on a shared span wins to match click targeting.
- *
- * The WHOLE conversation moves, not its head. A change's card renders `replyIds` as a flat list,
- * so linking only the top comment of a thread left every answer to that answer rendered by
- * nobody. Descendants ride along in authoring order.
- *
- * The pass is idempotent: every link is rebuilt from ranges, so locally patched queues cannot
- * retain stale `parentRevisionId` values after edits move a revision.
- */
-declare function linkRevisionReplies<T extends LinkableReviewItem>(items: readonly T[]): T[];
-/**
- * Paragraph node id → document position, from the TREE rather than from a layout.
- *
- * Memoized on the immutable root: one full derivation pass asks this question three times
- * (replacement pairing, the queue's merged order, the session's cached order), and each
- * answer was a fresh full-tree walk. The instance is SHARED, so the return type is
- * ReadonlyMap: a caller mutating it would poison every later reader of this root.
- */
-declare function paragraphOrderOfPart(part: OoxmlPart): ReadonlyMap<string, number>;
-/**
- * Like {@link paragraphOrderOfPart}, but descends INTO paragraphs, so paragraphs nested
- * in a run's content — a textbox's `w:txbxContent` — rank right after their host.
- *
- * A separate function on purpose: the shallow order feeds the review queue's card
- * ordering, and re-ranking nested paragraphs there would move cards. This one exists for
- * position containment tests ("is the caret inside this range"), where a paragraph the
- * shallow order cannot see is a position that can never match.
- */
-declare function deepParagraphOrderOfPart(part: OoxmlPart): ReadonlyMap<string, number>;
-
-export { type LinkableReviewItem as L, MAX_CONTENT_CONTROL_NESTING as M, commentBodyText as a, commentInitials as b, collectFlowBlocks as c, contentControlContentChildren as d, isContentControlContent as e, collectReviewItems as f, commentItemsOf as g, contentControlContentOf as h, isContentControl as i, deepParagraphOrderOfPart as j, walkParagraphInline as k, linkRevisionReplies as l, walkStoryBlocks as m, paragraphOrderOfPart as p, revisionItemsOf as r, walkAllStoryParagraphs as w };