@arbidocs/blocks 0.4.100 → 0.4.102

package/node_modules/@docx-editor.dev/core/dist/review-pane-D9jm8DcY.d.ts

@@ -0,0 +1,128 @@
+/**
+ * When the review pane opens by itself.
+ *
+ * - `'auto'`: the pane opens when a document with review items loads, and when a tracked
+ *   change is made while it is closed, in both cases when the pane has items to list. With
+ *   `revisionsIn: 'balloons'` the pane lists no tracked change and no reply to one, so
+ *   tracked changes and their replies alone do not open it.
+ * - `'manual'`: the pane stays closed until the host or the user opens it. Use it when the
+ *   host shows review items its own way, such as in balloons or margin markers.
+ *
+ * @public
+ */
+type ReviewPaneOpening = 'auto' | 'manual';
+/**
+ * What the open review pane does when its full card column does not fit beside the page at
+ * the page's zoom.
+ *
+ * - `'float'`: the pane shrinks to a strip of markers, and the open card floats over the
+ *   page.
+ * - `'shrinkPage'`: under a fit zoom mode, the page may shrink down to the mode's
+ *   `minZoom` (or 10%) so that the full column fits. The pane changes to the marker strip
+ *   only when the column does not fit at that floor either. A fixed zoom behaves as
+ *   `'float'`.
+ * - `'scroll'`: the page keeps the size it has beside the closed pane's marker strip, and
+ *   the full column stands beside it. The document and the column scroll together: the
+ *   viewport scrolls sideways to reach the cards.
+ *
+ * The setting applies to the review pane only. The navigation pane stays docked at its side
+ * in every mode: it never scrolls with the document, and it takes its room beside the page
+ * exactly as it does with no review pane.
+ *
+ * @public
+ */
+type ReviewPaneOverflow = 'float' | 'shrinkPage' | 'scroll';
+/**
+ * Where tracked changes open.
+ *
+ * - `'pane'`: the review pane lists tracked changes as cards beside the comments.
+ * - `'balloons'`: the pane lists comments only, except comments that reply to a tracked
+ *   change: the change's balloon shows those. A tracked change opens in a balloon at its
+ *   text when the reader clicks it, or when Next Change, Previous Change, or
+ *   `setActiveReviewItem(key, { announce: true })` reaches it.
+ *
+ * @public
+ */
+type RevisionDisplay = 'pane' | 'balloons';
+/**
+ * How a collapsed comment marker looks.
+ *
+ * - `'initials'`: a badge with the thread author's initials in the author's color, a reply
+ *   count, and a check mark when the thread is resolved.
+ * - `'icon'`: the comment icon.
+ *
+ * @public
+ */
+type CommentMarkerStyle = 'initials' | 'icon';
+/**
+ * Review pane settings to change. Every field is optional, and an omitted field keeps its
+ * current value.
+ *
+ * @public
+ */
+interface ReviewPaneOptions {
+    /** Default `'auto'`. */
+    readonly opening?: ReviewPaneOpening;
+    /** Default `'float'`. */
+    readonly overflow?: ReviewPaneOverflow;
+    /** Default `'pane'`. */
+    readonly revisionsIn?: RevisionDisplay;
+    /** Default `'icon'`. */
+    readonly commentMarkers?: CommentMarkerStyle;
+}
+/**
+ * The review pane settings in force, with every field resolved.
+ *
+ * @public
+ */
+interface ResolvedReviewPane {
+    /** When the pane opens by itself. */
+    readonly opening: ReviewPaneOpening;
+    /** What the open pane does when its card column does not fit beside the page. */
+    readonly overflow: ReviewPaneOverflow;
+    /** Where tracked changes open. */
+    readonly revisionsIn: RevisionDisplay;
+    /** How a collapsed comment marker looks. */
+    readonly commentMarkers: CommentMarkerStyle;
+}
+/** The settings an editor starts with when nothing sets them. @public */
+declare const DEFAULT_REVIEW_PANE: ResolvedReviewPane;
+/**
+ * Merge `options` over `base`. Throws a `TypeError` for an unknown field or value, so a
+ * misspelled setting fails loudly instead of being ignored. Returns `base` itself when
+ * nothing changes, so the snapshot keeps its reference.
+ *
+ * @public
+ */
+declare function resolveReviewPane(options: ReviewPaneOptions | undefined, base?: ResolvedReviewPane): ResolvedReviewPane;
+/**
+ * The fields of a review item that decide whether the review pane lists it. A
+ * `ReviewItem` and a review item placement both have them.
+ *
+ * @public
+ */
+interface ReviewPaneItemFields {
+    /** The item kind, as `ReviewItem.kind` gives it. */
+    readonly kind: 'revision' | 'comment' | 'custom';
+    /** For a comment, the tracked change it replies to. */
+    readonly parentRevisionId?: string;
+}
+/**
+ * Whether the review pane lists a card for `item` under `revisionsIn`.
+ *
+ * With `'balloons'`, a balloon at the text shows every tracked change and every comment
+ * that replies to a tracked change, so the pane lists neither. Give the item as an
+ * unfiltered `getReviewItems()` read returns it: a query that excludes revision kinds
+ * removes `parentRevisionId` from replies to the changes it drops.
+ *
+ * The engine applies this rule to every review item when it decides whether the pane opens
+ * by itself or closes after a settings change. A review pane must apply the same rule before
+ * its own filters, such as a hidden kind or a host filter. Those filters can hide every card,
+ * and then the pane that the engine opens is empty.
+ *
+ * @public
+ */
+declare function reviewPaneListsItem(revisionsIn: RevisionDisplay, item: ReviewPaneItemFields): boolean;
+
+export { DEFAULT_REVIEW_PANE as D, reviewPaneListsItem as f, resolveReviewPane as r };
+export type { CommentMarkerStyle as C, ReviewPaneOptions as R, ResolvedReviewPane as a, ReviewPaneOverflow as b, ReviewPaneItemFields as c, ReviewPaneOpening as d, RevisionDisplay as e };

package/node_modules/@docx-editor.dev/core/dist/review-paragraph-order-DT-n6ouC.d.ts

@@ -0,0 +1,85 @@
+import { N as OoxmlNode, Z as OoxmlElement, _ as OoxmlContentControlNode, V as OoxmlGenericElementNode, $ as OoxmlContentControlContentNode, C as CommentRecord, O as OoxmlPart } from './types-barrel-D3xCgQX6.js';
+
+/** 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. Block callers use
+ * {@link MAX_CONTENT_CONTROL_NESTING}; paragraph callers use
+ * {@link MAX_INLINE_CONTAINER_DEPTH} across all transparent containers.
+ */
+declare function contentControlContentChildren(control: OoxmlNode): readonly OoxmlNode[];
+/**
+ * Collect paragraph and table blocks from a sibling list, flattening through transparent block
+ * 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 transparent block wrappers — 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 and their bounded containers in document order.
+ *
+ * `visit` receives each direct `w:r` and any other inline node the caller treats as opaque
+ * (bookmarks, drawings, …). Hyperlinks and controls are descended transparently. Callers
+ * that address the runs inside tracked revisions can opt into descending those wrappers too.
+ */
+declare function walkParagraphInline(children: readonly OoxmlNode[], depth: number, visit: (child: OoxmlNode) => void, options?: {
+    readonly descendRevisions?: boolean;
+}): void;
+
+/**
+ * Plain text of a comment's body, as a card shows it: a non-breaking hyphen is U+2011, an
+ * optional hyphen shows nothing, and a symbol shows its glyph. 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, at most three characters.
+ * Characters are code points, so a surrogate pair is never split.
+ */
+declare function commentInitials(comment: CommentRecord): string;
+
+/**
+ * Paragraph node id → document position, from the tree rather than from layout.
+ *
+ * Memoized on the immutable root: a derivation pass can ask repeatedly, and the shared answer
+ * stays read-only so a caller cannot poison later readers.
+ */
+declare function paragraphOrderOfPart(part: OoxmlPart): ReadonlyMap<string, number>;
+/**
+ * Like {@link paragraphOrderOfPart}, but descends into paragraphs so textbox paragraphs rank
+ * immediately after their host. Shallow order remains available for separate-story walks.
+ */
+declare function deepParagraphOrderOfPart(part: OoxmlPart): ReadonlyMap<string, number>;
+
+export { MAX_CONTENT_CONTROL_NESTING as M, commentBodyText as a, commentInitials as b, collectFlowBlocks as c, contentControlContentOf as d, deepParagraphOrderOfPart as e, isContentControlContent as f, walkParagraphInline as g, walkStoryBlocks as h, isContentControl as i, contentControlContentChildren as j, paragraphOrderOfPart as p, walkAllStoryParagraphs as w };

package/node_modules/@docx-editor.dev/core/dist/revision-projection-DZ4kKVev.d.ts

@@ -0,0 +1,242 @@
+import { N as OoxmlNode } from './types-barrel-D3xCgQX6.js';
+
+/** Named revision colors. Identifiers are stable and never contain CSS. @public */
+declare const REVISION_MARKUP_COLORS: readonly ['black', 'blue', 'turquoise', 'green', 'pink', 'red', 'yellow', 'white', 'darkBlue', 'teal', 'darkGreen', 'violet', 'darkRed', 'darkYellow', 'gray50', 'gray25', 'lightBlue', 'lightYellow', 'lightOrange', 'lightPurple', 'lightGreen', 'gray'];
+/** @public */
+type RevisionMarkupNamedColor = (typeof REVISION_MARKUP_COLORS)[number];
+/** @public */
+type RevisionMarkupColor = RevisionMarkupNamedColor | 'byAuthor' | 'auto';
+/** @public */
+type RevisionMarkupMark = 'none' | 'colorOnly' | 'bold' | 'italic' | 'underline' | 'doubleUnderline' | 'strikethrough' | 'doubleStrikethrough';
+/** @public */
+type RevisionDeletionMark = RevisionMarkupMark | 'hidden' | 'caret' | 'pound';
+/** @public */
+type RevisionChangedLinesMark = 'none' | 'leftBorder' | 'rightBorder' | 'outsideBorder';
+/** @public */
+interface RevisionMarkupStyle<Mark extends string = RevisionMarkupMark> {
+    readonly mark: Mark;
+    readonly color: RevisionMarkupColor;
+}
+/** Viewer-only text styling. Document highlighting remains unchanged. @public */
+interface RevisionMarkupTextStyle<Mark extends string = RevisionMarkupMark> extends RevisionMarkupStyle<Mark> {
+    /** Background color behind revision text. Defaults to `none`. */
+    readonly background: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+}
+/** Fully resolved, immutable viewer preferences. @public */
+interface ResolvedRevisionMarkup {
+    readonly insertions: RevisionMarkupTextStyle;
+    readonly deletions: RevisionMarkupTextStyle<RevisionDeletionMark>;
+    readonly movedFrom: RevisionMarkupTextStyle<RevisionDeletionMark>;
+    readonly movedTo: RevisionMarkupTextStyle;
+    readonly formatting: RevisionMarkupTextStyle;
+    readonly changedLines: RevisionMarkupStyle<RevisionChangedLinesMark>;
+    readonly cells: {
+        readonly inserted: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly deleted: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly merged: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly split: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+    };
+    readonly trackMoves: boolean;
+    readonly trackFormatting: boolean;
+}
+/** Partial viewer preferences. Omitted values keep the previous value. @public */
+type RevisionMarkupOptions = {
+    readonly [K in keyof ResolvedRevisionMarkup]?: ResolvedRevisionMarkup[K] extends boolean ? boolean : Partial<ResolvedRevisionMarkup[K]>;
+};
+/** Initial viewer preferences. @public */
+declare const DEFAULT_REVISION_MARKUP: ResolvedRevisionMarkup;
+/** Validate and merge preferences without modifying the input. @public */
+declare function resolveRevisionMarkup(input?: RevisionMarkupOptions, previous?: ResolvedRevisionMarkup): ResolvedRevisionMarkup;
+/** A local settings draft owned by the editor. @public */
+interface RevisionMarkupDialogSession {
+    /** Aborts on close, replacement, load, detach, destroy, or renderer disposal. */
+    readonly signal: AbortSignal;
+    /** Read the immutable draft. */
+    get(): ResolvedRevisionMarkup;
+    /** Merge validated options into the draft without committing preferences. */
+    set(options: RevisionMarkupOptions): void;
+    /** Restore default preferences in the draft only. */
+    reset(): void;
+    /** Observe draft changes, including effective external preference changes. */
+    subscribe(listener: () => void): () => void;
+    canApply(): boolean;
+    /** Commit the draft and close. Returns false after cancellation. */
+    apply(): boolean;
+    /** Close without committing the draft. */
+    cancel(): void;
+}
+/** Host rendering for the Track changes options dialog. @public */
+interface RevisionMarkupChromeHandlers {
+    readonly onRequest?: (session: RevisionMarkupDialogSession) => void;
+}
+
+/**
+ * What a revision wrapper asserts about the content inside it.
+ *
+ * `moveFrom` / `moveTo` are deliberately distinct from `delete` / `insert`: a move is one
+ * decision with two halves, and presenting it as an unrelated deletion and insertion invites
+ * resolving one without the other, which duplicates or loses the content.
+ */
+type RevisionKind = 'insert' | 'delete' | 'moveFrom' | 'moveTo' | 'format';
+/**
+ * One revision wrapper's provenance, as authored.
+ *
+ * `id` is the verbatim `@w:id` string rather than a number: `ST_DecimalNumber` restricts
+ * `xsd:integer` with no bounds, so a file may carry a value outside the safe integer range, and
+ * parsing it to a number would silently merge two distinct revisions.
+ *
+ * `date` is absent when the file omits it. `@w:date` is optional on `CT_TrackChange`, and
+ * inventing one is a silent content change.
+ */
+interface RevisionAttribution {
+    readonly kind: RevisionKind;
+    readonly id: string;
+    readonly author: string;
+    readonly date?: string;
+    /** The wrapper's node id, so a surface can address this exact site. */
+    readonly nodeId: string;
+}
+/**
+ * Which revisions layout resolves before producing pages.
+ *
+ * - `all-markup` shows both halves of every change.
+ * - `proposed` shows what the document becomes if every change is accepted.
+ * - `original` shows what it was before any of them.
+ *
+ * The last two are specified as equal to accept-all and reject-all OUTPUT, which is what makes
+ * them testable, without either applying an op.
+ */
+type RevisionDisplayMode = 'all-markup' | 'proposed' | 'original';
+/**
+ * The views the review chrome offers, in Word's terms: the three layout projections plus
+ * Simple Markup, which reads as the proposed result with a red change bar beside every line
+ * a change touched — the document as accepting everything would leave it, and where.
+ */
+type ReviewDisplayMode = RevisionDisplayMode | 'simple-markup';
+/**
+ * How a document renders tracked changes when nothing says otherwise.
+ *
+ * `all-markup` matches Word's own default: a reader who opens a document with pending changes
+ * sees them, rather than a clean-looking document hiding edits nobody has accepted.
+ */
+declare const DEFAULT_REVISION_DISPLAY_MODE: RevisionDisplayMode;
+/**
+ * A view-time tracked-change filter. Revisions rejected by `includes` use the filter's accepted
+ * or rejected projection, while included revisions keep the display mode's normal projection.
+ *
+ * `cacheKey` is a canonical, content-based identity for layout caches. The set itself is kept
+ * because author names are attacker-controlled strings and must never be parsed back from a
+ * delimiter-based key.
+ */
+interface RevisionFilter {
+    readonly revisionMarkup?: ResolvedRevisionMarkup;
+    readonly hiddenAuthors: ReadonlySet<string>;
+    readonly includes?: (revision: RevisionAttribution) => boolean;
+    readonly includesNode?: (nodeId: string, author: string) => boolean;
+    /** Accepted/original projection for a revision excluded by `includesNode`. */
+    readonly excludedNodeMode?: (nodeId: string, author: string) => 'proposed' | 'original';
+    /**
+     * In a resolved view, content the view keeps paints as ORDINARY text: no author ink, no
+     * decoration, no change bar of its own. This is Word's No Markup, Original and Simple
+     * Markup, which the review chrome asks for. Without it the accepted projection keeps the
+     * attribution on kept insertions, which is what the engine paints when no review module
+     * is registered — colour by author, deletions resolved — and what its roster reads.
+     */
+    readonly resolvedMarkup?: 'plain';
+    readonly cacheKey: string;
+}
+/** @deprecated Use {@link RevisionFilter}. */
+interface RevisionAuthorFilter extends RevisionFilter {
+}
+/** Build a canonical reviewer filter. An empty input returns `undefined` for the fast path. */
+declare function revisionAuthorFilter(hiddenAuthors: Iterable<string>): RevisionAuthorFilter | undefined;
+/**
+ * Whether content under this stack of revisions is laid out in the given mode.
+ *
+ * Containment governs, so a single enclosing wrapper the mode resolves away suppresses
+ * everything inside it regardless of what the inner wrappers say. An insertion inside a
+ * deletion does not survive the proposed result: the deletion it sits in was accepted.
+ */
+declare function revisionsVisible(revisions: readonly RevisionAttribution[], mode: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): boolean;
+/**
+ * Every revision on a paragraph's own MARK, from `w:pPr/w:rPr/w:ins|w:del|w:moveFrom|w:moveTo`.
+ *
+ * All four members of `EG_ParaRPrTrackChanges`. A moved paragraph carries `w:moveFrom` on the
+ * mark of the copy it left and `w:moveTo` on the mark of the copy it arrived at, so a move
+ * that spans whole paragraphs is recorded here and nowhere else.
+ *
+ * `EG_ParaRPrTrackChanges` records that the pilcrow itself was inserted or deleted, which is how
+ * Word writes a paragraph split or merge. It is not content — there is no text to decorate — so
+ * a surface shows it as a mark of its own beside the paragraph, the way Word draws a struck-
+ * through ¶.
+ *
+ * A LIST, because the group is `ins? del? moveFrom? moveTo?` and the first two can both be
+ * there: that pair is what Word writes when a second author proposes removing a mark the first
+ * proposed adding, and it is what this engine's own writer emits (`tree-op-tracked.ts`).
+ * Answering with the first one hid the second author's decision from the PAGE. The review pane
+ * walks the tree itself and always listed both, which is the worse shape of the two: a card
+ * offering a decision the reader could see no sign of.
+ *
+ * Ordered as the file orders them, which is the order the group declares.
+ *
+ * Property-position `w:ins`/`w:del` stay `generic` in the tree deliberately, so this reads them
+ * by name rather than by kind.
+ */
+declare function paragraphMarkRevisionsOf(paragraph: OoxmlNode): readonly RevisionAttribution[];
+/**
+ * The tracked FORMAT change on a paragraph's own mark, from `w:pPr/w:rPr/w:rPrChange`.
+ *
+ * `CT_ParaRPr` ends with it (§17.13.5.32), and Word writes it when a user changes the mark's
+ * own run properties with tracking on. It reaches the fragment rather than a span because it
+ * decorates no characters, and it is not in `props`: a fragment's `props` carry the mark's
+ * `w:rPr` by NAME only, with none of its children.
+ *
+ * Note that `w:rPrChange/w:rPr` is `CT_ParaRPrOriginal`, which may carry its own revision
+ * marks. Those describe the mark as it WAS and must not be read as live ones, which is why
+ * this reads the change element's own attributes and never descends into it.
+ */
+declare function paragraphMarkFormatRevisionOf(paragraph: OoxmlNode): RevisionAttribution | null;
+/**
+ * The single decision a one-field reader sees.
+ *
+ * A DELETION wins when a mark carries both, for the reason paint draws it that way: a break
+ * proposed and then unproposed ends up removed, so that is the decision a reader who can only
+ * see one must see. One function decides it, so the deprecated field, the deprecated function
+ * and the painted glyph cannot answer differently.
+ */
+declare function shownMarkRevision(revisions: readonly RevisionAttribution[]): RevisionAttribution | undefined;
+/**
+ * Does this decision, taken, remove the paragraph mark?
+ *
+ * A deletion does, and so does a `moveFrom`: the copy the paragraph moved OUT of goes away
+ * when the move is accepted. `insert` and `moveTo` are the other half of each pair, and they
+ * keep the break. Paint, the change bar and the resolved views all ask this one question, so
+ * a `moveFrom` cannot end up struck through in the margin and blue on the glyph.
+ */
+declare function markRevisionRemovesMark(revision: RevisionAttribution): boolean;
+/**
+ * The one decision on a paragraph's mark that a single-field reader sees.
+ *
+ * @deprecated Reads one of the revisions a mark can carry. Use {@link paragraphMarkRevisionsOf},
+ * which answers with all of them.
+ */
+declare function paragraphMarkRevisionOf(paragraph: OoxmlNode): RevisionAttribution | null;
+/**
+ * The tracked FORMAT change on a property list, from `w:rPrChange` or `w:pPrChange`.
+ *
+ * A property change alters no characters, so it has no span of its own to strike or underline.
+ * Word marks the affected text and says what changed; the minimum a reader needs is to see that
+ * this text's formatting is itself a pending decision.
+ *
+ * Read from the flattened property list because that is what layout already carries — the
+ * change wrapper is a `w:rPr`/`w:pPr` child like any other.
+ */
+declare function formatRevisionOf(properties: readonly {
+    readonly localName: string;
+    readonly attributes?: Readonly<Record<string, string>>;
+}[]): RevisionAttribution | null;
+/** True when this stack of revisions marks its content as deleted from the live document. */
+declare function revisionsAreDeletion(revisions: readonly RevisionAttribution[]): boolean;
+
+export { revisionsVisible as A, shownMarkRevision as B, DEFAULT_REVISION_MARKUP as D, REVISION_MARKUP_COLORS as f, DEFAULT_REVISION_DISPLAY_MODE as p, resolveRevisionMarkup as r, formatRevisionOf as t, markRevisionRemovesMark as u, paragraphMarkFormatRevisionOf as v, paragraphMarkRevisionOf as w, paragraphMarkRevisionsOf as x, revisionAuthorFilter as y, revisionsAreDeletion as z };
+export type { RevisionMarkupDialogSession as R, ReviewDisplayMode as a, RevisionDisplayMode as b, RevisionAuthorFilter as c, ResolvedRevisionMarkup as d, RevisionMarkupOptions as e, RevisionChangedLinesMark as g, RevisionDeletionMark as h, RevisionMarkupChromeHandlers as i, RevisionMarkupColor as j, RevisionMarkupMark as k, RevisionMarkupNamedColor as l, RevisionMarkupStyle as m, RevisionMarkupTextStyle as n, RevisionAttribution as o, RevisionFilter as q, RevisionKind as s };