@arbidocs/blocks 0.4.101 → 0.4.102

package/node_modules/@docx-editor.dev/core/dist/semantic-paint-BME37OMv.d.ts

@@ -0,0 +1,326 @@
+import { d as ResolvedRevisionMarkup } from './revision-projection-DZ4kKVev.js';
+import { a as PageRecord, C as ContentControlBoundaryRecord, S as SemanticLayout } from './semantic-records-4B3WwFAi.js';
+import { S as SemanticRootStoryKind } from './semantic-record-queries-CBlZqZNa.js';
+import { V as ValidatedImageBytesHandle, R as RenderableImageMime } from './image-resources-BN-hUgCn.js';
+
+/**
+ * Everything a host can say about ONE author's presentation. Every field is optional and
+ * every field is presentation-only — nothing here is ever serialised into the document.
+ *
+ * Deliberately about the PAINTED DOCUMENT (which only the painter can style) plus the
+ * author's identity data. Review-card DESIGN is not configured here: the review chrome
+ * follows `color` as its accent automatically, and everything further is composition —
+ * a custom card reading this style through the review surface's `useReviewAuthor`, or
+ * CSS on the cards' `data-review-author`/`data-review-author-slot` hooks.
+ *
+ * @public
+ */
+interface RevisionAuthorStyle {
+    /**
+     * Ink and decoration colour of this author's changes in the document — and the accent
+     * the review chrome keys on (avatar disc, card variable, marker).
+     */
+    color?: string;
+    /** Background wash behind this author's changes in the document. */
+    background?: string;
+    /**
+     * Background of the highlight band over this author's OPEN change — the one the caret
+     * is in. Applied inline, so it outranks the `--doc-revision-*-active-bg` kind tokens,
+     * and the kind-coloured rule under the band goes with it: a custom background with a
+     * green or red rule beneath it would contradict the decoration it sits behind, and a
+     * `transparent` that left a floating rule would not read as cleared at all.
+     */
+    activeBackground?: string;
+    /**
+     * Class names added to every painted span of this author's changes, for styling the
+     * typed fields do not cover. Keep the rules metric-safe (outlines, shadows, accents):
+     * the engine measures the text it paints, and a class that resizes glyphs drifts the
+     * page from its layout.
+     */
+    spanClassName?: string;
+    /** Avatar image for this author; the packaged card renders it in place of initials. */
+    avatarUrl?: string;
+}
+/**
+ * Per-author style assignments.
+ *
+ * Keys match `w:author` exactly; a value is a CSS colour or a full
+ * {@link RevisionAuthorStyle}. `others` says what authors WITHOUT an entry take: the
+ * `--doc-review-author-N` ramp by default, or `'kind'` to leave them on the kind colours —
+ * which is how "highlight these reviewers, leave everyone else green and red" is said.
+ *
+ * @public
+ */
+interface RevisionAuthorAssignments {
+    /** Authors without an entry: the ramp (default), or the `'kind'` colours. */
+    readonly others?: 'kind' | 'author';
+    readonly authors: Readonly<Record<string, string | RevisionAuthorStyle>>;
+}
+/**
+ * How painted tracked changes are coloured.
+ *
+ * - `'author'` (the DEFAULT) — every change takes its author's colour from the
+ *   `--doc-review-author-N` ramp. An attached document seeds slots by order of first
+ *   appearance, then keeps those assignments stable for that session. Word's own default,
+ *   and the reason it is this engine's: a paragraph three people edited has to read as three
+ *   people. Restyle a slot under `.docx-editor` to change the ramp.
+ * - `'kind'` — insertions and deletions take the two kind colours
+ *   (`--doc-revision-insertion` / `--doc-revision-deletion`), so "added" and "removed" are
+ *   what a reader tells apart at a glance, whoever proposed them.
+ * - {@link RevisionAuthorAssignments} — style the named authors; `others` decides whether
+ *   the rest take the ramp (the default) or the kind colours.
+ *
+ * Presentation only: nothing here is ever serialised into the document.
+ *
+ * @public
+ */
+type RevisionStyles = 'kind' | 'author' | RevisionAuthorAssignments;
+/**
+ * One document author, resolved: who, which ramp slot, and what they draw in.
+ *
+ * @public
+ */
+interface ReviewAuthorInfo {
+    /** The `w:author` string, exactly as the file carries it. */
+    readonly author: string;
+    /**
+     * Stable session rank, seeded by order of first appearance — an UNBOUNDED index.
+     *
+     * The ramp defines {@link REVIEW_AUTHOR_SLOTS} colours and every DOM hook wraps into it,
+     * so the ninth author ranks 8 here and carries `data-review-author-slot="0"`. Building a
+     * selector from this value needs the same wrap: `slot % 8`.
+     */
+    readonly slot: number;
+    /**
+     * The colour this author is DRAWN IN by the review chrome — their declared colour, or
+     * their ramp slot's token.
+     *
+     * Not necessarily what the document paints. `'kind'`, and `others: 'kind'` for an author
+     * with no declaration, colour the painted text by insertion/deletion instead, while the
+     * cards keep the per-author accent this reports.
+     */
+    readonly color: string;
+    /** The host-supplied style, normalised; absent when the author rides the ramp. */
+    readonly style?: RevisionAuthorStyle;
+}
+/**
+ * The resolved form the painter consumes: the document's author→slot map, the host's
+ * per-author styles, what UNSTYLED authors take, and the paint-reuse key for all of it.
+ * `null` means the default kind colouring for everyone.
+ */
+interface RevisionStyleContext {
+    readonly authorSlots: ReadonlyMap<string, number>;
+    readonly styles: ReadonlyMap<string, RevisionAuthorStyle>;
+    /** `spanClassName` pre-split into tokens, so paint does not split per span. */
+    readonly classTokens: ReadonlyMap<string, readonly string[]>;
+    /** Authors without a style: `'kind'` colours, or the ramp. */
+    readonly others: 'kind' | 'author';
+    /** See {@link revisionStyleContextKey}. Computed once, with the context. */
+    readonly key: string;
+}
+
+/** Host port for safe blob URLs — only called for {@link ImageResourceState.kind} `ready`. */
+interface PaintImageUrlPort {
+    create(handle: ValidatedImageBytesHandle, mime: RenderableImageMime): string;
+    revoke(url: string): void;
+}
+/** Localized refusal labels; adapters supply i18n-backed implementations. */
+interface DrawingPaintStrings {
+    readonly unsupportedFormat: (format: string) => string;
+    readonly nonPictureGraphic: (kind: string) => string;
+    readonly missingResource: string;
+    readonly externalResource: string;
+    readonly invalidResource: string;
+    readonly contentMismatch: string;
+    readonly decodeFailed: string;
+    readonly resourceLimit: string;
+    readonly pendingResource: string;
+}
+
+/** Which bars a paint draws. @public */
+type ChangeBarsMode = 'all-markup' | 'simple-markup' | 'none';
+/** Which story a bar stands beside; the header-editing chrome dims every other story's. */
+type BarStory = Exclude<SemanticRootStoryKind, 'note-separator'>;
+/** One rule in sheet coordinates (points from the page's top-left corner). */
+interface BarRun {
+    author?: string;
+    color?: string;
+    top: number;
+    bottom: number;
+    story: BarStory;
+    insertion: boolean;
+    deletion: boolean;
+    format: boolean;
+}
+/** Page change bars in page coordinates. @public */
+interface PageChangeBars {
+    readonly mode: ChangeBarsMode;
+    readonly color?: string;
+    /** Whether the bars take the pointer as Word's toggle. */
+    readonly toggle: boolean;
+    /** Sheet-relative x of the column, already scaled and snapped to a whole pixel. */
+    readonly left: number;
+    readonly runs: readonly BarRun[];
+    /** Cheap identity of `left` + `runs`, for the block-adoption path to compare. */
+    readonly signature: string;
+}
+/**
+ * The rules one page needs, in sheet coordinates: every root story the page paints, the
+ * blocks of each (tracked rows and rotated cells included), and the text-box stories its
+ * anchored drawings carry, each at the origin the painter places it at.
+ * @public
+ */
+declare function collectPageChangeBars(page: PageRecord, scale: number, mode: ChangeBarsMode, toggle?: boolean, markup?: ResolvedRevisionMarkup, facingPages?: boolean, colors?: RevisionStyleContext): PageChangeBars;
+
+/**
+ * When a field's result is drawn on its grey block, following Word's own View option.
+ *
+ * `when-selected` is Word's default and the reason the option exists at all: a document dense
+ * with cross-references turns largely grey under `always`, and under `never` a reader cannot
+ * tell computed text from typed text at all.
+ */
+type FieldShadingMode = 'never' | 'when-selected' | 'always';
+/** Word's default: shaded only while the caret is inside the field. */
+declare const DEFAULT_FIELD_SHADING: FieldShadingMode;
+/**
+ * How a layout is painted into DOM. Every field is optional.
+ *
+ * The painted pages ARE the editable surface, so everything here is presentation-only — nothing
+ * set through these options is ever serialised back into the document.
+ */
+interface PaintOptions {
+    /** Points to CSS pixels. 96/72 renders a point as a CSS point at 100% zoom. */
+    readonly scale?: number;
+    /** Generated paragraphs that paint as non-editable navigation surfaces. */
+    readonly readOnlyParagraphIds?: ReadonlySet<string>;
+    /**
+     * Empty-TOC begin paragraphs that paint subtle identifiable furniture. Paint-only — never
+     * serialised into the document.
+     */
+    readonly emptyTocPlaceholderIds?: ReadonlySet<string>;
+    /** Marks painted pages as presentational, so assistive tech reads the editable projection. */
+    readonly ariaHidden?: boolean;
+    /**
+     * Page indices to build in detail (task 9.4).
+     *
+     * Omitted means all of them. A page left out keeps its size and position but no content,
+     * so the document's height and page count are unchanged and scrolling to it reveals it
+     * instead of reflowing everything underneath.
+     */
+    readonly materialize?: ReadonlySet<number>;
+    /**
+     * Family-alias lookup for fonts the host registered on behalf of THIS document (see
+     * {@link PaintContext.fontAlias}). Painted runs emit the alias ahead of the declared
+     * family, so a file can never shadow a family name the host page uses.
+     */
+    readonly fontAlias?: (family: string) => string | undefined;
+    /** See {@link PaintContext.defaultFontFamily}. */
+    readonly defaultFontFamily?: string;
+    /** See {@link PaintContext.fieldShading}. */
+    readonly fieldShading?: FieldShadingMode;
+    /** Paint paragraph-end and manual-line-break furniture. Tracked marks also follow Show/Hide. */
+    readonly showParagraphMarks?: boolean;
+    /** See {@link PaintContext.shadeFormFields}. */
+    readonly shadeFormFields?: boolean;
+    /**
+     * How tracked changes are coloured: by AUTHOR through the `--doc-review-author-N`
+     * ramp (the default, as in Word), by kind, or by author with host-pinned colours.
+     * See {@link RevisionStyles}.
+     */
+    readonly revisionStyles?: RevisionStyles;
+    readonly revisionMarkup?: ResolvedRevisionMarkup;
+    readonly revisionKindColors?: boolean;
+    readonly facingPages?: boolean;
+    /**
+     * Which change bars the margin draws: All Markup's neutral rule beside attributed lines
+     * (the default, whatever the layout's projection — a layout that carries attribution gets
+     * its bars), Simple Markup's red rule beside the change sites a resolved layout published,
+     * or none, which the review chrome names for its resolved views.
+     */
+    readonly changeBars?: ChangeBarsMode;
+    /**
+     * Whether a change bar takes the pointer as Word's does — a click swaps Simple and All
+     * Markup. Only a host that can act on the press should set it; the bars stay inert
+     * furniture otherwise.
+     */
+    readonly changeBarsToggle?: boolean;
+    /**
+     * Relationship id of the header/footer story currently open for editing.
+     *
+     * When set, the matching `[data-docx-hf]` container is editable and every body
+     * `.docx-page-content` box is inert; all other furniture stays read-only.
+     *
+     * Deliberately OUTSIDE the paint-reuse key: entering a header must not rebuild
+     * body sheets. Chrome is applied to already-painted nodes in place, the way TOC
+     * hover is.
+     */
+    readonly activeHeaderFooterRId?: string;
+    /**
+     * Sheet that hosts the active visual occurrence of a shared furniture part.
+     *
+     * Required with {@link activeHeaderFooterRId} so only one painted copy receives
+     * `data-docx-hf-active` / the engine caret when the same rId appears on many pages.
+     * Also outside the paint-reuse key — moving the caret across shared copies retints
+     * markers in place rather than replacing every page.
+     */
+    readonly activeHeaderFooterPageIndex?: number;
+    /**
+     * On-demand content-control boundary chrome (show-all and/or caret-entry).
+     *
+     * Furniture only — never contributes layout records or changes page geometry. Omitted or
+     * empty means no control chrome is painted. Folded into the paint-reuse key so a toggle
+     * rebuilds furniture without a layout pass.
+     */
+    readonly contentControlChrome?: {
+        readonly showAll?: boolean;
+        /** Control ids whose boundaries are visible because the caret is inside them. */
+        readonly activeIds?: ReadonlySet<string>;
+        /**
+         * Control ids whose boundaries are visible because the pointer is over them.
+         * Used for TOC hover chrome without projecting a persistent caret-active state.
+         *
+         * Deliberately OUTSIDE the paint-reuse key: hover must never rebuild a page. The
+         * surface toggles `data-hover` / `data-boundary-visible` on the painted chrome it
+         * already has, and this set only tells a page that rebuilds for some OTHER reason
+         * which of its controls is currently under the pointer.
+         */
+        readonly hoverIds?: ReadonlySet<string>;
+        /**
+         * Control ids whose boundary furniture is painted by something else.
+         *
+         * An empty TOC paints its own placeholder box on the begin paragraph, so drawing the
+         * control boundary as well left two rounded rectangles (of different heights) plus a
+         * label chip stacked over one empty region.
+         */
+        readonly suppressedIds?: ReadonlySet<string>;
+        /** Checkbox control ids whose canonical `w14:checked` state is on. */
+        readonly checkedIds?: ReadonlySet<string>;
+        /** Non-SDT structured regions that intentionally reuse content-control chrome. */
+        readonly additionalBoundaries?: readonly ContentControlBoundaryRecord[];
+        /** Control ids that represent TOC regions (hover-only chrome; never caret-sticky). */
+        readonly tocControlIds?: ReadonlySet<string>;
+        /**
+         * No control may be written right now — viewing mode, or a protected document.
+         *
+         * The widget is a `<button>` the ENGINE paints, and a click on it commits a tree op, so
+         * an enabled-looking checkbox on a read-only document is not a cosmetic lie: it is the
+         * write itself. Disabling it here also stops the pointer lane, which already skips a
+         * widget carrying `data-disabled-reason`.
+         */
+        readonly readOnly?: boolean;
+    };
+    readonly drawingStrings?: DrawingPaintStrings;
+    readonly imageUrlPort?: PaintImageUrlPort;
+}
+
+/**
+ * Paint a whole layout into a container, reusing the pages that did not change.
+ *
+ * The DOM is built with `createElement` and `textContent` only — no file-derived string is
+ * ever parsed as markup — and stray children (nothing this module painted) are removed, so
+ * the container's content is always exactly the painted pages.
+ */
+declare function paintSemanticLayout(container: HTMLElement, layout: SemanticLayout, options?: PaintOptions): void;
+
+export { DEFAULT_FIELD_SHADING as D, collectPageChangeBars as e, paintSemanticLayout as p };
+export type { ChangeBarsMode as C, FieldShadingMode as F, PageChangeBars as P, ReviewAuthorInfo as R, PaintOptions as a, RevisionAuthorAssignments as b, RevisionAuthorStyle as c, RevisionStyles as d, DrawingPaintStrings as f };

package/node_modules/@docx-editor.dev/core/dist/semantic-record-queries-CBlZqZNa.d.ts

@@ -0,0 +1,177 @@
+import { I as InlineDrawingRecord, A as AnchoredDrawingRecord, P as ParagraphFragmentRecord, L as LineRecord, a as PageRecord, N as NoteAreaRecord, b as LayoutBox, H as HeaderFooterStoryRecord, c as NoteStoryRecord, B as BlockFragmentRecord, S as SemanticLayout, C as ContentControlBoundaryRecord, d as ContentControlLock } from './semantic-records-4B3WwFAi.js';
+
+/**
+ * Depth-first paragraph fragments of one page, in reading order.
+ *
+ * Table interiors flatten through rows and cells; header-repeat rows are skipped unless
+ * asked for, so interaction sees each caret stop exactly once while paint sees everything.
+ */
+declare function paragraphFragmentsOf(page: PageRecord, includeHeaderRepeats?: boolean): ParagraphFragmentRecord[];
+declare function paragraphFragmentsOfBlocks(blocks: readonly BlockFragmentRecord[], includeHeaderRepeats?: boolean): ParagraphFragmentRecord[];
+/** Every line in a layout, in reading order — the order caret navigation walks. */
+declare function linesOf(layout: SemanticLayout): LineRecord[];
+/** The fragment-plus-anchored-drawings shape every laid-out story shares. */
+interface StoryDrawingHost {
+    /** Root story fragments in their published reading order. */
+    readonly fragments: readonly BlockFragmentRecord[];
+    /** Story-level positioned drawings, when that story supports anchors. */
+    readonly anchoredDrawings?: readonly AnchoredDrawingRecord[];
+}
+/** Root story kinds published directly from one page record. @public */
+type SemanticRootStoryKind = 'body' | 'header' | 'footer' | 'footnote' | 'endnote' | 'note-separator';
+/** Story containing a visited semantic record. @public */
+type SemanticStoryKind = SemanticRootStoryKind | 'textbox';
+/**
+ * One root story in the engine's complete published page/story order.
+ *
+ * The story discriminant preserves the precise published host type so exporters can consume
+ * furniture and note metadata without casting or searching the page graph a second time.
+ * @public
+ */
+type SemanticStoryVisit = {
+    readonly page: PageRecord;
+    readonly story: 'body';
+    readonly host: PageRecord;
+    /** Absolute story bounds; body records are relative to the page content box. */
+    readonly box: LayoutBox;
+    /** Absolute origin to add to story-relative fragment and drawing coordinates. */
+    readonly origin: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly noteScopeId: null;
+    readonly noteAreaKind: null;
+} | {
+    readonly page: PageRecord;
+    readonly story: 'header' | 'footer';
+    readonly host: HeaderFooterStoryRecord;
+    readonly box: LayoutBox;
+    readonly origin: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly noteScopeId: null;
+    readonly noteAreaKind: null;
+} | {
+    readonly page: PageRecord;
+    readonly story: 'footnote' | 'endnote';
+    readonly host: NoteStoryRecord;
+    readonly box: LayoutBox;
+    readonly origin: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly noteScopeId: string;
+    readonly noteAreaKind: NoteAreaRecord['kind'];
+} | {
+    readonly page: PageRecord;
+    readonly story: 'note-separator';
+    readonly host: NonNullable<NoteAreaRecord['separator']>;
+    readonly box: LayoutBox;
+    readonly origin: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly noteScopeId: null;
+    readonly noteAreaKind: NoteAreaRecord['kind'];
+};
+/** Visit every root story in a semantic layout, preserving page/story order. @public */
+declare function forEachSemanticStory(layout: SemanticLayout, visit: (story: SemanticStoryVisit) => void): void;
+/** Location of one paragraph fragment within a recursively painted story graph. @public */
+interface StoryParagraphFragmentContext {
+    /** Absolute origin of the immediate story containing this record. */
+    readonly storyOrigin: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    /** Zero for the supplied story; increments for every textbox boundary. */
+    readonly textboxDepth: number;
+    /** Drawing whose textbox directly owns this fragment, or null for the root story. */
+    readonly textboxOwner: TextboxOwnerRecord | null;
+    /** Root-to-leaf owning drawings, empty for the supplied story. */
+    readonly textboxPath: readonly TextboxOwnerRecord[];
+}
+/** A drawing that owns a text-box story: anchored, or inline on a line. @public */
+type TextboxOwnerRecord = InlineDrawingRecord | AnchoredDrawingRecord;
+/** Location of one drawing within a recursively painted story graph. @public */
+interface StoryDrawingContext extends StoryParagraphFragmentContext {
+    /** Enclosing paragraph for an inline drawing; null for a story-level anchor. */
+    readonly paragraph: ParagraphFragmentRecord | null;
+    /** Enclosing line for an inline drawing; null for a story-level anchor. */
+    readonly line: LineRecord | null;
+}
+type RootDrawingOrigin = (drawing: AnchoredDrawingRecord) => Readonly<{
+    x: number;
+    y: number;
+}>;
+/** Drawing layer relative to its owning story's text. @public */
+type SemanticDrawingLayer = 'behind-text' | 'inline' | 'in-front-of-text';
+/**
+ * One drawing in bounded graph-enumeration order with exporter-grade provenance.
+ *
+ * Enumeration is deliberately not paint order: story anchors (and nested textboxes) are visited
+ * before inline line drawings. Renderers use `paintLayer` plus record geometry to compose layers.
+ * @public
+ */
+interface SemanticDrawingVisit extends StoryDrawingContext {
+    /** Physical page carrying this drawing occurrence. */
+    readonly page: PageRecord;
+    /** Immediate story classification; `textbox` after textbox descent. */
+    readonly story: SemanticStoryKind;
+    /** Root story from which textbox descent began. */
+    readonly rootStory: SemanticRootStoryKind;
+    /** Note scope for drawings in note stories; null elsewhere. */
+    readonly noteScopeId: string | null;
+    /** Owning note-area kind for note/separator drawings; null elsewhere. */
+    readonly noteAreaKind: NoteAreaRecord['kind'] | null;
+    /** Precise root host and absolute origin for story-relative geometry. */
+    readonly root: SemanticStoryVisit;
+    /** Absolute origin of this drawing's extent in page-stack coordinates. */
+    readonly drawingOrigin: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    /** Absolute painted bounds, including effects and clipping. */
+    readonly absolutePaintBounds: LayoutBox;
+    /** Absolute pointer/hit bounds. */
+    readonly absoluteHitBounds: LayoutBox;
+    /** Layer relative to text in the immediate owning story. */
+    readonly paintLayer: SemanticDrawingLayer;
+    /** Published drawing record; inline visits also carry paragraph and line. */
+    readonly drawing: InlineDrawingRecord | AnchoredDrawingRecord;
+}
+/** Visit every drawing through the canonical root-story and recursive textbox walks. @public */
+declare function forEachSemanticDrawing(layout: SemanticLayout, visit: (drawing: SemanticDrawingVisit) => void): void;
+/**
+ * Visit every paragraph fragment one story paints — its own (table interiors flattened,
+ * header repeats included) and the fragments inside each anchored drawing's text-box story,
+ * recursively.
+ *
+ * The fragment sibling of {@link forEachStoryDrawing}, sharing its depth bound, for
+ * consumers that read per-paragraph published fields (list markers) rather than drawings.
+ * The furniture list-marker token walks with this; a fragment it misses leaves a reused
+ * page showing a stale marker.
+ */
+declare function forEachStoryParagraphFragment(story: StoryDrawingHost, visit: (fragment: ParagraphFragmentRecord, context: StoryParagraphFragmentContext) => void, rootOrigin?: Readonly<{
+    x: number;
+    y: number;
+}>, rootDrawingOrigin?: RootDrawingOrigin): void;
+/** Every fragment belonging to one paragraph, in order, across page boundaries. */
+declare function fragmentsOfParagraph(layout: SemanticLayout, paragraphId: string): ParagraphFragmentRecord[];
+/** The line containing a model position, or null when the position is not laid out. */
+declare function lineAtPosition(layout: SemanticLayout, paragraphId: string, offset: number, 
+/** Lines to test, when the caller already knows which ones can carry the paragraph. */
+candidates?: Iterable<LineRecord>): LineRecord | null;
+/** Every content-control boundary on a layout, preferring the layout-level list. */
+declare function contentControlsOfLayout(layout: SemanticLayout): readonly ContentControlBoundaryRecord[];
+/**
+ * Axis-aligned union of boxes, or null when the list is empty.
+ *
+ * Used when a control's content spans several fragments or spans on one page.
+ */
+declare function unionLayoutBoxes(boxes: readonly LayoutBox[]): LayoutBox | null;
+/** Collapse raw + ancestor locks into one `ST_Lock` vocabulary value. */
+declare function effectiveContentControlLock(locks: readonly ContentControlLock[]): ContentControlLock;
+
+export { contentControlsOfLayout as h, effectiveContentControlLock as i, forEachSemanticDrawing as j, forEachSemanticStory as k, forEachStoryParagraphFragment as l, fragmentsOfParagraph as m, lineAtPosition as n, linesOf as o, paragraphFragmentsOf as p, paragraphFragmentsOfBlocks as q, unionLayoutBoxes as u };
+export type { SemanticRootStoryKind as S, TextboxOwnerRecord as T, SemanticStoryKind as a, SemanticStoryVisit as b, SemanticDrawingLayer as c, SemanticDrawingVisit as d, StoryDrawingContext as e, StoryDrawingHost as f, StoryParagraphFragmentContext as g };