ooxml-ui 0.30.1 → 0.31.0

package/dist/pptx/render/ink-stroke-view.d.ts

@@ -0,0 +1,78 @@
+import type { PressureCircle } from './ink-rendering.js';
+/**
+ * The single per-stroke rendering decision shared by both freehand ink
+ * representations this project has (a Draw-tab `InkPptxElement` and a loaded
+ * `p:contentPart`'s `ContentPartInkStroke`): given one stroke's path, style,
+ * and optional pressure/tilt data, decide whether it paints as a plain
+ * constant-width path, pressure-sensitive circles, or tilt-driven calligraphic
+ * nib marks.
+ *
+ * Lifted out of `content-part-strokes.ts` (which used to inline this exact
+ * logic) when `ink-group-strokes.ts` needed the identical decision for
+ * `InkPptxElement`; every binding's ink renderer had been hand-rolling its own
+ * (subtly drifted) copy of the pressure-circle half of this already.
+ *
+ * @module render/ink-stroke-view
+ */
+import type { NibMark } from './ink-tilt-nib.js';
+/** Everything one stroke needs to decide its render mode. */
+export interface InkStrokeViewInput {
+    path: string;
+    color: string;
+    width: number;
+    opacity: number;
+    /** Per-point pressure (0-1); rendered as variable-width circles when it varies. */
+    pressures?: number[];
+    /**
+     * Legacy per-point WIDTH values (already in the same units as `width`, not
+     * a 0-1 pressure reading) for older authored data that predates the
+     * `pressures` channel. Used only when `pressures` itself has no usable
+     * variation.
+     */
+    legacyPointWidths?: number[];
+    /** Per-point pen-tilt lean direction (radians); pairs with `tiltMagnitudes`. */
+    tiltAngles?: number[];
+    /** Per-point pen-tilt lean strength (0 upright, 1 maximally leaned). */
+    tiltMagnitudes?: number[];
+    /**
+     * Whether this stroke was drawn with the highlighter tool, when the source
+     * data records an explicit tool (Draw-tab `InkPptxElement.inkTool`). Left
+     * `undefined` for a loaded `p:contentPart` stroke, which carries no such
+     * flag: {@link buildInkStrokeView} then falls back to the opacity heuristic
+     * (see {@link HIGHLIGHTER_OPACITY_CEILING}).
+     */
+    isHighlighter?: boolean;
+}
+/** One rendered stroke: a constant-width path, pressure circles, or tilt nib marks. */
+export interface InkStrokeView {
+    d: string;
+    color: string;
+    width: number;
+    opacity: number;
+    /** Per-point pressure circles; `null` renders the plain path. Mutually exclusive with `nibMarks`. */
+    circles: PressureCircle[] | null;
+    /**
+     * Per-point calligraphic nib marks, built from the stroke's tilt channels;
+     * `null` when the stroke declared no (or all-zero) tilt data, in which
+     * case `circles` (or the plain path) renders as before this feature
+     * existed.
+     */
+    nibMarks: NibMark[] | null;
+    /**
+     * CSS `mix-blend-mode` this stroke should paint with: `'multiply'` for a
+     * highlighter-style stroke, so overlapping highlighter strokes darken
+     * where they cross (and a highlighter stroke darkens whatever slide
+     * content sits underneath it) the way a real highlighter pen does, instead
+     * of plain alpha compositing. `'normal'` for every other stroke. A binding
+     * applies this as an inline `mix-blend-mode` style on the stroke's own
+     * `<path>`/`<g>` (not on the element's outer `<svg>`): setting it on the
+     * container instead would blend the whole element's already-composited
+     * output against the backdrop as one unit, so strokes sharing that
+     * container would still alpha-composite (not multiply) against each
+     * other.
+     */
+    blendMode: 'normal' | 'multiply';
+}
+/** Decide a stroke's render mode: plain path, pressure circles, or tilt nib marks. */
+export declare function buildInkStrokeView(input: InkStrokeViewInput): InkStrokeView;
+//# sourceMappingURL=ink-stroke-view.d.ts.map

package/dist/pptx/render/ink-stroke-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ink-stroke-view.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/ink-stroke-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAOtD;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG9C,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,uFAAuF;AACvF,MAAM,WAAW,aAAa;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,qGAAqG;IACrG,OAAO,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAC3B;;;;;;;;;;;;OAYG;IACH,SAAS,EAAE,QAAQ,GAAG,UAAU,CAAC;CACjC;AA4CD,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,kBAAkB,GAAG,aAAa,CAsB3E"}

package/dist/pptx/render/ink-tilt-nib.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Pen-tilt calligraphic nib rendering.
+ *
+ * A stylus or digitizer pen can report its tilt (how far it leans off
+ * perpendicular, and which way) alongside position and pressure. This module
+ * turns that per-point tilt data into "nib marks": ellipses widened
+ * perpendicular to the pen's lean direction, approximating the look of a
+ * chisel-tip calligraphy pen. It is the tilt counterpart of the plain
+ * pressure-circle rendering in `./ink-rendering`.
+ *
+ * Framework-agnostic: only depends on `./ink-rendering`'s point/width types,
+ * so every binding (React, Vue, Angular, Svelte, Vanilla) consumes one copy.
+ *
+ * @module ink-tilt-nib
+ */
+import type { PathPoint, PressureConfig } from './ink-rendering.js';
+/** Decoded per-point pen-tilt lean, derived from a raw `(x, y)` tilt-offset vector pair. */
+export interface TiltVectorChannels {
+    /** Lean direction at each point, in radians. */
+    angles: number[];
+    /** Lean strength at each point, 0 (upright) to 1 (maximally leaned), normalised to this series' own peak. */
+    magnitudes: number[];
+}
+/**
+ * Derive per-point angle (radians) + magnitude (0-1, normalised against the
+ * largest magnitude anywhere in `xs`/`ys`) from parallel tilt vector arrays,
+ * or `undefined` when both arrays are empty.
+ *
+ * This is the Draw tool's own live-capture counterpart of
+ * `pointsToTilt`/`tiltChannelsFromXY` in
+ * `ooxml-core/src/pptx/core/utils/inkml-trace-decode.ts`, which decodes the
+ * same convention from a loaded InkML file's `OTx`/`OTy` channels. The two
+ * are intentionally NOT unified into one shared function: `shared` cannot
+ * import a `core`-internal (non-public) utility, and this geometry is a
+ * handful of lines with no framework or format dependency, so a documented,
+ * cross-referenced mirror is cheaper than adding new public `core` API
+ * surface for it. Any change to the normalisation convention (peak-relative
+ * magnitude) must be made in both places.
+ *
+ * Units are irrelevant here (the maths is purely geometric): the Draw tool
+ * calls this with `PointerEvent.tiltX`/`tiltY` degrees; the InkML reader
+ * calls its own copy with arbitrary device units. Only the resulting radians
+ * + normalised magnitude matter downstream.
+ */
+export declare function tiltChannelsFromVectors(xs: readonly number[], ys: readonly number[]): TiltVectorChannels | undefined;
+/**
+ * Configuration for tilt-driven "nib" rendering, extending {@link PressureConfig}
+ * with how strongly tilt magnitude elongates the nib's wide axis.
+ */
+export interface NibMarkConfig extends PressureConfig {
+    /**
+     * How strongly tilt magnitude widens the perpendicular axis relative to
+     * the base radius (0 disables elongation, 1 doubles it at full lean).
+     * Default 0.6, chosen to be a visible but subtle chisel-nib look.
+     */
+    elongation?: number;
+}
+/**
+ * One calligraphic nib mark: an ellipse whose wide axis sits perpendicular to
+ * the pen's tilt-lean direction at that point, approximating a chisel-tip
+ * nib. Degrades to a circle (`rPerp === rTilt`) wherever tilt magnitude is 0.
+ */
+export interface NibMark {
+    cx: number;
+    cy: number;
+    /** Radius along the tilt-lean direction (the nib's narrow axis). */
+    rTilt: number;
+    /** Radius perpendicular to the tilt-lean direction (the nib's wide axis). */
+    rPerp: number;
+    /**
+     * Rotation, in degrees, to apply to an SVG `<ellipse rx={rPerp} ry={rTilt}>`
+     * (e.g. via `transform="rotate(rotationDeg cx cy)"`) so its wide axis
+     * points perpendicular to the lean direction.
+     */
+    rotationDeg: number;
+}
+/**
+ * Generate calligraphic nib marks for a set of path points, given per-point
+ * (or interpolated) width, tilt-lean angle and tilt-lean magnitude data.
+ *
+ * This is the tilt counterpart of `generatePressureCircles`: instead of a
+ * plain circle, each point becomes an ellipse widened perpendicular to the
+ * pen's lean direction, the way a chisel-tip pen's mark widens depending on
+ * which way it is held. A point with zero tilt magnitude renders as a plain
+ * circle (`rPerp === rTilt`), so a stroke with a flat/upright tilt channel is
+ * visually indistinguishable from the existing pressure-circle rendering.
+ */
+export declare function generateNibMarks(points: PathPoint[], widths: number[], tiltAngles: number[], tiltMagnitudes: number[], config: NibMarkConfig): NibMark[];
+//# sourceMappingURL=ink-tilt-nib.d.ts.map

package/dist/pptx/render/ink-tilt-nib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ink-tilt-nib.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/ink-tilt-nib.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjE,4FAA4F;AAC5F,MAAM,WAAW,kBAAkB;IAClC,gDAAgD;IAChD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6GAA6G;IAC7G,UAAU,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACtC,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,GACnB,kBAAkB,GAAG,SAAS,CAmBhC;AAED;;;GAGG;AACH,MAAM,WAAW,aAAc,SAAQ,cAAc;IACpD;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;CACpB;AA8BD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,SAAS,EAAE,EACnB,MAAM,EAAE,MAAM,EAAE,EAChB,UAAU,EAAE,MAAM,EAAE,EACpB,cAAc,EAAE,MAAM,EAAE,EACxB,MAAM,EAAE,aAAa,GACnB,OAAO,EAAE,CAmBX"}

package/dist/pptx/render/inline-caret.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Caret placement for the inline text editors.
+ *
+ * Every binding seeds the contenteditable surface with the element's existing
+ * text and then focuses it; without an explicit selection the browser leaves
+ * the caret at the START, so typing prepends. The product contract (React,
+ * Vue and Angular behaviour, now shared by all five) is caret at the END so
+ * typing appends. Framework-agnostic: DOM globals only.
+ */
+/**
+ * Focus behaviour helper: collapse the selection to the very end of `el`'s
+ * content. Safe to call right after mounting/seeding a contenteditable.
+ */
+export declare function placeCaretAtEnd(el: HTMLElement): void;
+/** A screen point (the click that opened the editor). */
+export interface CaretPoint {
+    clientX: number;
+    clientY: number;
+}
+/**
+ * Remember where the click that opens an inline editor landed. PowerPoint puts
+ * the insertion point where you click a selected shape's text -- in a card's
+ * title, not after its last word -- so a binding records the click here just
+ * before it switches the element into editing, and the editor picks it up on
+ * mount ({@link takePendingCaretPoint}). One-shot and short-lived, so a stale
+ * click can never move a later editor's caret.
+ */
+export declare function setPendingCaretPoint(point: CaretPoint | null): void;
+/** The recorded click, once (see {@link setPendingCaretPoint}); `null` when none or expired. */
+export declare function takePendingCaretPoint(): CaretPoint | null;
+/**
+ * Put the caret at `point` inside `el` (where the user clicked), or at the end
+ * when there's no point or it isn't over `el`'s text -- the
+ * {@link placeCaretAtEnd} contract.
+ */
+export declare function placeCaretAt(el: HTMLElement, point: CaretPoint | null | undefined): void;
+//# sourceMappingURL=inline-caret.d.ts.map

package/dist/pptx/render/inline-caret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-caret.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-caret.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,CAerD;AAED,yDAAyD;AACzD,MAAM,WAAW,UAAU;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAMD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAEnE;AAED,gGAAgG;AAChG,wBAAgB,qBAAqB,IAAI,UAAU,GAAG,IAAI,CAMzD;AAuBD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAWxF"}

package/dist/pptx/render/inline-editor-selection.d.ts

@@ -0,0 +1,24 @@
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { InlineTextEditSnapshot } from './inline-list-types.js';
+import type { InlineTextSelection } from './inline-selection-utils.js';
+export type InlineEditorSelectionResult = {
+    kind: 'supported';
+    selection: InlineTextSelection | null;
+    snapshot?: InlineTextEditSnapshot;
+} | {
+    kind: 'unsupported';
+    reason: string;
+};
+/** A rich editor's unsupported selection must not mean format the whole element. */
+export declare function getInlineEditorSelectionResult(segments: TextSegment[] | undefined, options?: {
+    preserveCaret?: boolean;
+}): InlineEditorSelectionResult;
+/**
+ * Read the current browser selection and, if it falls within an
+ * `[data-inline-editor]` element, return the segment-level range.
+ *
+ * Returns `null` when there is no editable text selected, the selection is
+ * collapsed (just a cursor), or the selection is outside the inline editor.
+ */
+export declare function getInlineEditorSelection(segments: TextSegment[] | undefined): InlineTextSelection | null;
+//# sourceMappingURL=inline-editor-selection.d.ts.map

package/dist/pptx/render/inline-editor-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-editor-selection.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-editor-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,MAAM,MAAM,2BAA2B,GACpC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,sBAAsB,CAAA;CAAE,GAC/F;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,oFAAoF;AACpF,wBAAgB,8BAA8B,CAC7C,QAAQ,EAAE,WAAW,EAAE,GAAG,SAAS,EACnC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACvC,2BAA2B,CAiB7B;AASD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,WAAW,EAAE,GAAG,SAAS,GACjC,mBAAmB,GAAG,IAAI,CAE5B"}

package/dist/pptx/render/inline-list-activation.d.ts

@@ -0,0 +1,6 @@
+/** Capture the old DOM before the explicit plain-to-list render replaces it. */
+export declare function readListActivationSelection(root: HTMLElement, body: string): {
+    start: number;
+    end: number;
+} | undefined;
+//# sourceMappingURL=inline-list-activation.d.ts.map

package/dist/pptx/render/inline-list-activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-activation.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-activation.ts"],"names":[],"mappings":"AAEA,gFAAgF;AAChF,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM;;;cAsB1E"}

package/dist/pptx/render/inline-list-body.d.ts

@@ -0,0 +1,2 @@
+export { inlineListBodyText } from 'ooxml-core/pptx/editor/render/inline-list-body';
+//# sourceMappingURL=inline-list-body.d.ts.map

package/dist/pptx/render/inline-list-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-body.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-body.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC"}

package/dist/pptx/render/inline-list-case.d.ts

@@ -0,0 +1,6 @@
+import type { InlineTextEditSnapshot } from './inline-list-types.js';
+import type { InlineTextSelection } from './inline-selection-utils.js';
+import type { ChangeCaseMode } from './text-case-transform.js';
+/** Explicit model transaction. The caller ends the native editing session before applying it. */
+export declare function transformInlineListCase(snapshot: InlineTextEditSnapshot, selection: InlineTextSelection | null, mode: ChangeCaseMode): InlineTextEditSnapshot;
+//# sourceMappingURL=inline-list-case.d.ts.map

package/dist/pptx/render/inline-list-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-case.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-case.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,iGAAiG;AACjG,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,sBAAsB,EAChC,SAAS,EAAE,mBAAmB,GAAG,IAAI,EACrC,IAAI,EAAE,cAAc,GAClB,sBAAsB,CAexB"}

package/dist/pptx/render/inline-list-controller.d.ts

@@ -0,0 +1,23 @@
+import type { InlineListSelectionResult } from './inline-list-selection.js';
+import type { InlineListReadResult, InlineListSeed } from './inline-list-types.js';
+export interface InlineListControllerOptions {
+    onRead?: (result: InlineListReadResult) => void;
+    /** Observe successful explicit formatting before its caller writes the model. */
+    onFormat?: (snapshot: import('./inline-list-types.js').InlineTextEditSnapshot) => void;
+    /** Includes descriptor identity, not just the selected element ID. */
+    isCurrent?: () => boolean;
+}
+export interface InlineListController {
+    read(): InlineListReadResult;
+    format(snapshot: import('./inline-list-types.js').InlineTextEditSnapshot): InlineListReadResult;
+    readSelection(selection?: Selection | null): InlineListSelectionResult;
+    refresh(): InlineListReadResult;
+    dispose(): void;
+}
+/** Undefined means the selection is not owned by a mounted list session. */
+export declare function getActiveInlineListSelection(selection?: Selection | null): InlineListSelectionResult | undefined;
+/** Selection-scoped convenience; toolbar adapters can retain their own controller instead. */
+export declare function applyActiveInlineListFormatting(snapshot: import('./inline-list-types.js').InlineTextEditSnapshot, selection?: Selection | null): InlineListReadResult | undefined;
+/** Attach after initial descriptor bindings. Does not seed or rewrite editable children. */
+export declare function attachInlineListController(root: HTMLElement, seed: InlineListSeed, options?: InlineListControllerOptions): InlineListController;
+//# sourceMappingURL=inline-list-controller.d.ts.map

package/dist/pptx/render/inline-list-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-controller.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-controller.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAEzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIhF,MAAM,WAAW,2BAA2B;IAC3C,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAChD,iFAAiF;IACjF,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,qBAAqB,EAAE,sBAAsB,KAAK,IAAI,CAAC;IACpF,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACpC,IAAI,IAAI,oBAAoB,CAAC;IAC7B,MAAM,CAAC,QAAQ,EAAE,OAAO,qBAAqB,EAAE,sBAAsB,GAAG,oBAAoB,CAAC;IAC7F,aAAa,CAAC,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,yBAAyB,CAAC;IACvE,OAAO,IAAI,oBAAoB,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;CAChB;AAKD,4EAA4E;AAC5E,wBAAgB,4BAA4B,CAC3C,SAAS,GAAE,SAAS,GAAG,IAAmE,GACxF,yBAAyB,GAAG,SAAS,CAYvC;AAED,8FAA8F;AAC9F,wBAAgB,+BAA+B,CAC9C,QAAQ,EAAE,OAAO,qBAAqB,EAAE,sBAAsB,EAC9D,SAAS,GAAE,SAAS,GAAG,IAAmE,GACxF,oBAAoB,GAAG,SAAS,CAYlC;AAED,4FAA4F;AAC5F,wBAAgB,0BAA0B,CACzC,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,cAAc,EACpB,OAAO,GAAE,2BAAgC,GACvC,oBAAoB,CA6GtB"}

package/dist/pptx/render/inline-list-decoration.d.ts

@@ -0,0 +1,4 @@
+import type { TextStyle } from 'ooxml-core/pptx';
+/** Presentation-only defaults after the list editor removes ancestor decoration. */
+export declare function withInlineListDecorationDefaults(style: TextStyle, defaults?: TextStyle): TextStyle;
+//# sourceMappingURL=inline-list-decoration.d.ts.map

package/dist/pptx/render/inline-list-decoration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-decoration.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-decoration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,oFAAoF;AACpF,wBAAgB,gCAAgC,CAC/C,KAAK,EAAE,SAAS,EAChB,QAAQ,CAAC,EAAE,SAAS,GAClB,SAAS,CAUX"}

package/dist/pptx/render/inline-list-dom.d.ts

@@ -0,0 +1,8 @@
+import type { InlineListSeed } from './inline-list-types.js';
+/**
+ * One-time native list seed for DOM-based bindings. Existing shared run styling
+ * is reused; the controller paints markers and paragraph spacing externally.
+ * Refuses an occupied root or previously bound seed, never replacing live DOM.
+ */
+export declare function initializeInlineListDom(root: HTMLElement, seed: InlineListSeed): boolean;
+//# sourceMappingURL=inline-list-dom.d.ts.map

package/dist/pptx/render/inline-list-dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-dom.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-dom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAO1D;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAkDxF"}

package/dist/pptx/render/inline-list-format-style.d.ts

@@ -0,0 +1,9 @@
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { InlineListSeed } from './inline-list-types.js';
+/** Paint a command's full run style, including removal of previous declarations. */
+export declare function paintInlineListRun(seed: InlineListSeed, wrapper: HTMLElement, segment: TextSegment, fontScale: number): void;
+/** A decoration propagates through descendants, unlike inherited font weight. */
+export declare function sharedTextDecorationAncestors(node: Text, root: HTMLElement, decoration: 'underline' | 'line-through'): HTMLElement[];
+/** Clearing a single-text wrapper leaves no unaffected sibling to repaint. */
+export declare function clearSingleTextDecoration(node: Text, blockRoot: HTMLElement): void;
+//# sourceMappingURL=inline-list-format-style.d.ts.map

package/dist/pptx/render/inline-list-format-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-format-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-format-style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D,oFAAoF;AACpF,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,MAAM,GACf,IAAI,CAuBN;AAED,iFAAiF;AACjF,wBAAgB,6BAA6B,CAC5C,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,WAAW,GAAG,cAAc,GACtC,WAAW,EAAE,CAoBf;AAED,8EAA8E;AAC9E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,GAAG,IAAI,CAclF"}

package/dist/pptx/render/inline-list-format.d.ts

@@ -0,0 +1,4 @@
+import type { InlineListReadResult, InlineListSeed, InlineTextEditSnapshot } from './inline-list-types.js';
+/** Explicit model-format commands only. Never called to repair ordinary input. */
+export declare function reconcileInlineListFormatting(seed: InlineListSeed, root: HTMLElement, formatted: InlineTextEditSnapshot): InlineListReadResult;
+//# sourceMappingURL=inline-list-format.d.ts.map

package/dist/pptx/render/inline-list-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-format.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-format.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACX,oBAAoB,EACpB,cAAc,EACd,sBAAsB,EACtB,MAAM,qBAAqB,CAAC;AAmC7B,kFAAkF;AAClF,wBAAgB,6BAA6B,CAC5C,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,sBAAsB,GAC/B,oBAAoB,CA2LtB"}

package/dist/pptx/render/inline-list-model.d.ts

@@ -0,0 +1,18 @@
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { InlineListReadResult, InlineTextEditSnapshot } from './inline-list-types.js';
+export type InlineListModelChange = {
+    kind: 'current';
+} | {
+    kind: 'retire';
+} | {
+    kind: 'format';
+    snapshot: InlineTextEditSnapshot;
+};
+/** Observe existing model transactions; this does not create or manage history. */
+export declare function createInlineListModelObserver(element: PptxElement): {
+    /** Call after supported explicit DOM formatting and before its model transaction. */
+    expect(snapshot: InlineTextEditSnapshot): void;
+    /** Call on model updates and before pending save; failed format must retire the session. */
+    check(model: PptxElement | undefined, read: InlineListReadResult): InlineListModelChange;
+};
+//# sourceMappingURL=inline-list-model.d.ts.map

package/dist/pptx/render/inline-list-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-model.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAExF,MAAM,MAAM,qBAAqB,GAC9B;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,sBAAsB,CAAA;CAAE,CAAC;AAExD,mFAAmF;AACnF,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,WAAW;IAQhE,qFAAqF;IACrF,MAAM,WAAW,sBAAsB,GAAG,IAAI;IAM9C,4FAA4F;IAC5F,KAAK,QAAQ,WAAW,GAAG,SAAS,QAAQ,oBAAoB,GAAG,qBAAqB;EAwBzF"}

package/dist/pptx/render/inline-list-presentation.d.ts

@@ -0,0 +1,5 @@
+import type { TextSegment } from 'ooxml-core/pptx';
+import type { RenderParagraph } from './paragraph-types.js';
+/** Presentation only. Native children, their identities and Undo remain untouched. */
+export declare function inlineListPresentationCss(document: Document, scope: string, paragraphs: RenderParagraph[], segments: TextSegment[], fontScale?: number): string;
+//# sourceMappingURL=inline-list-presentation.d.ts.map

package/dist/pptx/render/inline-list-presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-presentation.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-presentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAiBzD,sFAAsF;AACtF,wBAAgB,yBAAyB,CACxC,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,eAAe,EAAE,EAC7B,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,SAAI,GACX,MAAM,CA0DR"}

package/dist/pptx/render/inline-list-provenance.d.ts

@@ -0,0 +1,9 @@
+import type { InlineListSeed, InlineTextEditSnapshot } from './inline-list-types.js';
+/** Private DOM identity, never copied into an exported editor snapshot. */
+export declare function recordInlineListProvenance(seed: InlineListSeed, root: HTMLElement, snapshot: InlineTextEditSnapshot, blocks: readonly Node[], origins: readonly (Node | undefined)[], unchanged: boolean): void;
+/** Match only unique, actually retained DOM nodes, never inherited data tokens. */
+export declare function readInlineListProvenance(snapshot: InlineTextEditSnapshot, previous?: InlineTextEditSnapshot): {
+    paragraphSources: (number | null)[];
+    hiddenSources: (number | null)[];
+} | undefined;
+//# sourceMappingURL=inline-list-provenance.d.ts.map

package/dist/pptx/render/inline-list-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-provenance.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-provenance.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAgBlF,2EAA2E;AAC3E,wBAAgB,0BAA0B,CACzC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,sBAAsB,EAChC,MAAM,EAAE,SAAS,IAAI,EAAE,EACvB,OAAO,EAAE,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,EAAE,EACtC,SAAS,EAAE,OAAO,GAChB,IAAI,CAmCN;AAED,mFAAmF;AACnF,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,sBAAsB,EAChC,QAAQ,CAAC,EAAE,sBAAsB,GAC/B;IAAE,gBAAgB,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAAC,aAAa,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;CAAE,GAAG,SAAS,CAuBvF"}

package/dist/pptx/render/inline-list-reconcile.d.ts

@@ -0,0 +1,4 @@
+import type { InlineTextEditSnapshot } from './inline-list-types.js';
+/** AutoCorrect cannot move paragraph identity or turn a soft break into a paragraph. */
+export declare function reconcileInlineListSnapshot(snapshot: InlineTextEditSnapshot, transformedText: string): InlineTextEditSnapshot | undefined;
+//# sourceMappingURL=inline-list-reconcile.d.ts.map

package/dist/pptx/render/inline-list-reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-reconcile.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-reconcile.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAIlE,wFAAwF;AACxF,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,sBAAsB,EAChC,eAAe,EAAE,MAAM,GACrB,sBAAsB,GAAG,SAAS,CA2CpC"}

package/dist/pptx/render/inline-list-run-reader.d.ts

@@ -0,0 +1,9 @@
+import type { TextSegment, TextStyle } from 'ooxml-core/pptx';
+import type { InlineListSession } from './inline-list-types.js';
+/** Reads authored inline nodes only; no writes and no computed-style flattening. */
+export declare function readInlineListRuns(session: InlineListSession, block: HTMLElement, bodyStyle?: TextStyle): {
+    runs: TextSegment[];
+    origins: Node[];
+    unchanged: boolean;
+} | undefined;
+//# sourceMappingURL=inline-list-run-reader.d.ts.map

package/dist/pptx/render/inline-list-run-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-run-reader.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-run-reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAY7D,oFAAoF;AACpF,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,WAAW,EAClB,SAAS,CAAC,EAAE,SAAS,GACnB;IAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAAC,OAAO,EAAE,IAAI,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CA+F1E"}

package/dist/pptx/render/inline-list-run-style.d.ts

@@ -0,0 +1,4 @@
+import type { TextStyle } from 'ooxml-core/pptx';
+/** Only supported authored inline changes, not computed browser defaults. */
+export declare function inlineListStyleDelta(node: HTMLElement, baseline?: string, inheritedColor?: string): TextStyle;
+//# sourceMappingURL=inline-list-run-style.d.ts.map

package/dist/pptx/render/inline-list-run-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-run-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-run-style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,6EAA6E;AAC7E,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,WAAW,EACjB,QAAQ,SAAK,EACb,cAAc,CAAC,EAAE,MAAM,GACrB,SAAS,CA+DX"}

package/dist/pptx/render/inline-list-save.d.ts

@@ -0,0 +1,18 @@
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { InlineTextEditSnapshot } from './inline-list-types.js';
+import type { MasterViewDocument, MasterViewTarget, MasterViewWrite } from './master-view.js';
+/** The viewer-owned edit session identifies the part to overlay, never just a global element ID. */
+export interface PendingInlineTextEdit {
+    snapshot: InlineTextEditSnapshot;
+    text?: string;
+    target: {
+        slideId: string;
+    } | {
+        masterView: MasterViewTarget;
+    };
+}
+/** Overlay a current rich list draft for serialization, without committing editor state. */
+export declare function overlayInlineTextSnapshot(elements: readonly PptxElement[], snapshot?: InlineTextEditSnapshot, text?: string | undefined): readonly PptxElement[];
+/** Retain the same master/layout/auxiliary ownership rules used by ordinary commits. */
+export declare function overlayMasterViewInlineSnapshot(document: MasterViewDocument, target: MasterViewTarget | null | undefined, snapshot?: InlineTextEditSnapshot, text?: string | undefined): MasterViewWrite | null;
+//# sourceMappingURL=inline-list-save.d.ts.map

package/dist/pptx/render/inline-list-save.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-save.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-save.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAGlE,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE3F,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,sBAAsB,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,UAAU,EAAE,gBAAgB,CAAA;KAAE,CAAC;CAC/D;AAED,4FAA4F;AAC5F,wBAAgB,yBAAyB,CACxC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,QAAQ,CAAC,EAAE,sBAAsB,EACjC,IAAI,qBAAiB,GACnB,SAAS,WAAW,EAAE,CAuBxB;AAED,wFAAwF;AACxF,wBAAgB,+BAA+B,CAC9C,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,EAC3C,QAAQ,CAAC,EAAE,sBAAsB,EACjC,IAAI,qBAAiB,GACnB,eAAe,GAAG,IAAI,CAIxB"}

package/dist/pptx/render/inline-list-seed.d.ts

@@ -0,0 +1,17 @@
+import type { PptxElement, TextSegment, TextStyle } from 'ooxml-core/pptx';
+import type { InlineListParagraphFormat, InlineListSeed, InlineListSession } from './inline-list-types.js';
+/** Seed descriptors once; native edits own the mounted DOM for the entire session. */
+export declare function createInlineListSeed(element: PptxElement, options?: {
+    includePlain?: boolean;
+}): InlineListSeed | undefined;
+/** Internal accessor, intentionally omitted from package exports. */
+export declare function inlineListSession(seed: InlineListSeed): InlineListSession | undefined;
+export declare function bindInlineListParagraph(seed: InlineListSeed, node: Node, sourceIndex: number): boolean;
+export declare function bindInlineListRun(seed: InlineListSeed, node: Node, segmentIndex: number): boolean;
+export declare function inlineListDescendants(node: Node): Node[];
+/** Register explicit command output; applying the returned token is the adapter's edit. */
+export declare function registerInlineListParagraphFormat(seed: InlineListSeed, format: InlineListParagraphFormat): string | undefined;
+/** Character formatting tokens never grant field or paragraph source identity. */
+export declare function registerInlineListRunStyle(seed: InlineListSeed, style: TextStyle, renderedCss?: string): string | undefined;
+export declare function inlineListParagraphMetadata(source: TextSegment): Partial<TextSegment>;
+//# sourceMappingURL=inline-list-seed.d.ts.map

package/dist/pptx/render/inline-list-seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-seed.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-seed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAK3E,OAAO,KAAK,EACX,yBAAyB,EACzB,cAAc,EACd,iBAAiB,EACjB,MAAM,qBAAqB,CAAC;AAO7B,sFAAsF;AACtF,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GAClC,cAAc,GAAG,SAAS,CAsI5B;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,iBAAiB,GAAG,SAAS,CAErF;AAED,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,GACjB,OAAO,CAWT;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAgBjG;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,CAExD;AAED,2FAA2F;AAC3F,wBAAgB,iCAAiC,CAChD,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,yBAAyB,GAC/B,MAAM,GAAG,SAAS,CAWpB;AAaD,kFAAkF;AAClF,wBAAgB,0BAA0B,CACzC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAChB,WAAW,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAapB;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAcrF"}

package/dist/pptx/render/inline-list-selection.d.ts

@@ -0,0 +1,24 @@
+import type { InlineListSeed, InlineTextEditSnapshot } from './inline-list-types.js';
+import type { InlineTextSelection } from './inline-selection-utils.js';
+export type InlineListSelectionResult = {
+    kind: 'supported';
+    snapshot: InlineTextEditSnapshot;
+    selection: InlineTextSelection | null;
+    bodyRange?: {
+        start: number;
+        end: number;
+    };
+} | {
+    kind: 'unsupported';
+    reason: string;
+};
+/** Current DOM offsets, not cloned data-seg-idx attributes, identify the selected runs. */
+export declare function readInlineListSelection(seed: InlineListSeed, root: HTMLElement, selection?: Selection | null): InlineListSelectionResult;
+/** Read a native beforeinput target range before the DOM or caret moves. */
+export declare function readInlineListRange(seed: InlineListSeed, root: HTMLElement, range: Pick<AbstractRange, 'startContainer' | 'startOffset' | 'endContainer' | 'endOffset'> | null): InlineListSelectionResult;
+/** Restore the same authored characters after an explicit run-format split. */
+export declare function restoreInlineListBodySelection(seed: InlineListSeed, root: HTMLElement, bodyRange: {
+    start: number;
+    end: number;
+}): boolean;
+//# sourceMappingURL=inline-list-selection.d.ts.map

package/dist/pptx/render/inline-list-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-selection.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-selection.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAIpE,MAAM,MAAM,yBAAyB,GAClC;IACA,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,sBAAsB,CAAC;IACjC,SAAS,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACtC,SAAS,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1C,GACD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAoD3C,2FAA2F;AAC3F,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,SAAS,GAAE,SAAS,GAAG,IAA6D,GAClF,yBAAyB,CAE3B;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,IAAI,CACV,aAAa,EACb,gBAAgB,GAAG,aAAa,GAAG,cAAc,GAAG,WAAW,CAC/D,GAAG,IAAI,GACN,yBAAyB,CAqF3B;AAED,+EAA+E;AAC/E,wBAAgB,8BAA8B,CAC7C,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACvC,OAAO,CA6DT"}

package/dist/pptx/render/inline-list-snapshot.d.ts

@@ -0,0 +1,12 @@
+import type { InlineListReadResult, InlineListSeed, InlineTextEditSnapshot } from './inline-list-types.js';
+export declare function readInlineListSnapshot(seed: InlineListSeed, root: HTMLElement): InlineListReadResult;
+/** Internal connected-editor read; the baseline must be a captured DOM snapshot. */
+export declare function readInlineListNativeSnapshot(seed: InlineListSeed, root: HTMLElement, previous?: InlineTextEditSnapshot): (Extract<InlineListReadResult, {
+    kind: 'supported';
+}> & {
+    paragraphSources: (number | null)[];
+    hiddenSources: (number | null)[];
+}) | Extract<InlineListReadResult, {
+    kind: 'unsupported';
+}>;
+//# sourceMappingURL=inline-list-snapshot.d.ts.map

package/dist/pptx/render/inline-list-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-snapshot.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-snapshot.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACX,oBAAoB,EACpB,cAAc,EACd,sBAAsB,EACtB,MAAM,qBAAqB,CAAC;AAI7B,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,GACf,oBAAoB,CAmItB;AAED,oFAAoF;AACpF,wBAAgB,4BAA4B,CAC3C,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,CAAC,EAAE,sBAAsB,GAE/B,CAAC,OAAO,CAAC,oBAAoB,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,GAAG;IACxD,gBAAgB,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACpC,aAAa,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAChC,CAAC,GACF,OAAO,CAAC,oBAAoB,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,CAOxD"}

package/dist/pptx/render/inline-list-style.d.ts

@@ -0,0 +1,6 @@
+import type { PptxElement, TextStyle } from 'ooxml-core/pptx';
+import type { ElementBulletPatch } from './bullet-toggle.js';
+import type { InlineTextSelection } from './inline-selection-utils.js';
+/** Format the current rich draft. The caller must reconcile its live DOM before committing. */
+export declare function buildInlineListStylePatch(element: PptxElement, updates: Partial<TextStyle>, selection: InlineTextSelection | null): ElementBulletPatch | undefined;
+//# sourceMappingURL=inline-list-style.d.ts.map

package/dist/pptx/render/inline-list-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-list-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/inline-list-style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAKpE,+FAA+F;AAC/F,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,EAC3B,SAAS,EAAE,mBAAmB,GAAG,IAAI,GACnC,kBAAkB,GAAG,SAAS,CA6BhC"}

package/dist/pptx/render/inline-list-types.d.ts

@@ -0,0 +1,57 @@
+import type { PptxElement, TextSegment, TextStyle } from 'ooxml-core/pptx';
+import type { RenderParagraph } from './paragraph-types.js';
+/** Current editor payload. Missing segments explicitly denotes plain-text fallback. */
+export interface InlineTextEditSnapshot {
+    elementId: string;
+    text: string;
+    textSegments?: TextSegment[];
+}
+export interface InlineListRun {
+    token: string;
+    segmentIndex: number;
+    text: string;
+    style: Readonly<TextStyle>;
+    isLineBreak?: true;
+}
+export interface InlineListParagraph {
+    token: string;
+    sourceIndex: number;
+    runs: readonly InlineListRun[];
+    presentation: RenderParagraph;
+}
+/** Descriptor identity also identifies the private provenance registry. */
+export interface InlineListSeed {
+    elementId: string;
+    paragraphs: readonly InlineListParagraph[];
+}
+export type InlineListParagraphFormat = Pick<TextSegment, 'bulletInfo' | 'paragraphLevel' | 'paragraphProperties'>;
+export type InlineListReadResult = {
+    kind: 'supported';
+    snapshot: InlineTextEditSnapshot;
+    paragraphs: RenderParagraph[];
+} | {
+    kind: 'unsupported';
+    reason: string;
+    text: string;
+};
+/** Internal state is not exported from the package barrel. */
+export interface InlineListSession {
+    element: PptxElement;
+    segments: TextSegment[];
+    originalSegments: TextSegment[];
+    paragraphs: Array<{
+        segments: TextSegment[];
+        terminator?: TextSegment;
+    }>;
+    paragraphNodes: WeakMap<Node, number>;
+    runNodes: WeakMap<Node, number>;
+    boundParagraphs: Set<number>;
+    boundRuns: Set<number>;
+    paragraphTokens: Map<string, number>;
+    runTokens: Map<string, number>;
+    runCss: Map<number, string>;
+    runHtml: Map<number, string>;
+    runChildren: Map<number, Node[]>;
+    formats: Map<string, InlineListParagraphFormat>;
+}
+//# sourceMappingURL=inline-list-types.d.ts.map