@harbour-enterprises/superdoc 1.9.0-next.1 → 1.9.0-next.2

package/dist/super-editor/src/core/presentation-editor/dom/CoordinateTransform.d.ts

@@ -1,125 +0,0 @@
-/**
- * Calculates the horizontal offset of a page element within the viewport.
- *
- * Pages are horizontally centered within the painter host container. When the viewport
- * is wider than the page, this offset must be included in overlay coordinate calculations
- * to prevent selections from appearing shifted left of the actual content.
- *
- * @param options - Configuration object containing DOM elements and page information
- * @returns The horizontal offset in layout-space units, or null if calculation fails
- *
- * @remarks
- * Coordinate spaces:
- * - getBoundingClientRect returns values in screen space (includes zoom transform)
- * - Return value is in layout space (divided by zoom to normalize)
- * - Layout space matches the coordinate system used for overlay positioning
- *
- * The function accounts for:
- * - Horizontal centering of pages within the painter container
- * - Zoom transformation applied to the viewport
- * - Variable page widths (narrower than viewport)
- *
- * Returns null if:
- * - painterHost or viewportHost is null
- * - Page element with matching data-page-index is not found
- *
- * This offset is critical for accurate overlay positioning when the viewport is wider
- * than the page content, which commonly occurs on large displays or at low zoom levels.
- *
- * @example
- * ```typescript
- * const offsetX = getPageOffsetX({
- *   painterHost,
- *   viewportHost,
- *   zoom: 1.5,
- *   pageIndex: 2
- * });
- *
- * if (offsetX !== null) {
- *   // Use offsetX when converting page-local coordinates to overlay coordinates
- *   const overlayX = pageLocalX + offsetX;
- * }
- * ```
- */
-export declare function getPageOffsetX(options: {
-    painterHost: HTMLElement | null;
-    viewportHost: HTMLElement | null;
-    zoom: number;
-    pageIndex: number;
-}): number | null;
-/**
- * Converts page-local coordinates to overlay-absolute coordinates.
- *
- * This function transforms coordinates from page-relative layout space to the absolute
- * positioning system used by the selection overlay. It handles multi-page layouts,
- * horizontal centering, and validates all input parameters for safety.
- *
- * @param options - Configuration object containing coordinate system parameters
- * @returns Overlay coordinates as {x, y}, or null if validation fails
- *
- * @remarks
- * Coordinate transformation process:
- * 1. Validate input parameters (pageIndex, pageLocalX, pageLocalY must be finite)
- * 2. Calculate horizontal offset for page centering (via getPageOffsetX)
- * 3. Add page stacking offset for multi-page layout (pageIndex * (pageHeight + pageGap))
- * 4. Return final overlay coordinates in layout space
- *
- * Coordinate spaces explained:
- * - Page-local space: Coordinates relative to the top-left corner of a single page
- * - Overlay space: Absolute coordinates within the selection overlay container
- * - Both spaces use layout units (not screen pixels)
- * - Zoom transform is applied to the viewport container (not to coordinate values)
- *
- * Input validation:
- * - pageIndex must be finite and non-negative (warns and returns null otherwise)
- * - pageLocalX must be finite (warns and returns null otherwise)
- * - pageLocalY must be finite (warns and returns null otherwise)
- * - Warnings include diagnostic information for debugging
- *
- * Multi-page layout:
- * - Pages are stacked vertically with gaps between them
- * - Y coordinate includes offset for all pages above the target page
- * - Page stacking formula: pageIndex * (pageHeight + pageGap)
- *
- * Horizontal centering:
- * - Pages are centered within the painter host container
- * - getPageOffsetX calculates the centering offset dynamically
- * - Falls back to 0 offset if calculation fails
- *
- * The zoom transform is applied via CSS transform: scale() on the viewport container,
- * so coordinate calculations remain in layout space rather than screen space.
- *
- * @example
- * ```typescript
- * // Convert a caret position to overlay coordinates
- * const overlayCoords = convertPageLocalToOverlayCoords({
- *   painterHost,
- *   viewportHost,
- *   zoom: 1.0,
- *   pageIndex: 0,
- *   pageLocalX: 100,
- *   pageLocalY: 200,
- *   pageHeight: 792,
- *   pageGap: 20
- * });
- *
- * if (overlayCoords) {
- *   caretElement.style.left = `${overlayCoords.x}px`;
- *   caretElement.style.top = `${overlayCoords.y}px`;
- * }
- * ```
- */
-export declare function convertPageLocalToOverlayCoords(options: {
-    painterHost: HTMLElement | null;
-    viewportHost: HTMLElement | null;
-    zoom: number;
-    pageIndex: number;
-    pageLocalX: number;
-    pageLocalY: number;
-    pageHeight: number;
-    pageGap: number;
-}): {
-    x: number;
-    y: number;
-} | null;
-//# sourceMappingURL=CoordinateTransform.d.ts.map

package/dist/super-editor/src/core/presentation-editor/dom/CoordinateTransform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CoordinateTransform.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/dom/CoordinateTransform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE;IACtC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,MAAM,GAAG,IAAI,CAqBhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE;IACvD,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA8ClC"}

package/dist/super-editor/src/core/presentation-editor/dom/DomPositionIndex.d.ts

@@ -1,135 +0,0 @@
-/**
- * Represents a single entry in the DOM position index.
- *
- * @remarks
- * Each entry maps a ProseMirror position range to a DOM element that was painted
- * with data-pm-start and data-pm-end attributes.
- */
-export type DomPositionIndexEntry = {
-    /** The starting ProseMirror position (inclusive) */
-    pmStart: number;
-    /** The ending ProseMirror position (inclusive) */
-    pmEnd: number;
-    /** The DOM element representing this position range */
-    el: HTMLElement;
-};
-/**
- * Options for controlling how the DOM position index is rebuilt.
- */
-type RebuildOptions = {
-    /**
-     * When true (default), only index "leaf" elements, meaning elements with
-     * `data-pm-start`/`data-pm-end` that do not themselves contain any descendant
-     * elements with PM range attributes.
-     *
-     * This prevents indexing container elements like pages/lines/fragments which
-     * would otherwise overlap with run-level spans and complicate lookups.
-     */
-    leafOnly?: boolean;
-};
-/**
- * A lightweight index for mapping ProseMirror positions to painted DOM elements.
- *
- * This is rebuilt after each paint and can be used to efficiently locate the
- * DOM element corresponding to a given PM position, without repeated full-DOM scans.
- */
-export declare class DomPositionIndex {
-    #private;
-    get size(): number;
-    /**
-     * Rebuilds the index by scanning the container for elements with PM position attributes.
-     *
-     * @param container - The root DOM element to scan (typically the painter host)
-     * @param options - Options controlling index behavior
-     *
-     * @remarks
-     * This method performs the following steps:
-     * 1. Queries all elements with both data-pm-start and data-pm-end attributes
-     * 2. Filters out inline SDT wrapper elements (which are metadata containers)
-     * 3. If leafOnly is true (default), filters out container elements that have descendant
-     *    PM-position elements, keeping only leaf elements
-     * 4. Validates that pmStart and pmEnd are finite numbers with pmEnd >= pmStart
-     * 5. Sorts entries by pmStart (ascending), then by pmEnd (ascending)
-     *
-     * The leafOnly filtering prevents indexing container elements like pages, lines, and
-     * fragments which would otherwise overlap with run-level spans and complicate lookups.
-     *
-     * The sorting ensures that binary search operations work correctly and that entries
-     * with the same start position are ordered by their end position.
-     *
-     * Safe to call multiple times - each call completely replaces the index. The previous
-     * index is discarded.
-     */
-    rebuild(container: HTMLElement, options?: RebuildOptions): void;
-    /**
-     * Finds the index entry whose position range contains the given position.
-     *
-     * @param pos - The ProseMirror position to look up
-     * @returns The entry containing this position, or null if none found
-     *
-     * @remarks
-     * Uses binary search (upper bound) to efficiently find the rightmost entry whose
-     * pmStart is less than or equal to pos, then validates that pos is within the
-     * entry's [pmStart, pmEnd] range.
-     *
-     * Time complexity: O(log n) where n is the number of entries.
-     *
-     * Returns null if:
-     * - The position is not a finite number
-     * - The index is empty
-     * - No entry contains the position (position is in a gap between entries)
-     *
-     * For positions that fall exactly on entry boundaries:
-     * - If pos equals entry.pmStart, the entry is returned
-     * - If pos equals entry.pmEnd, the entry is returned
-     * - Due to sorting, if multiple entries could match, the first in sort order is returned
-     */
-    findEntryAtPosition(pos: number): DomPositionIndexEntry | null;
-    findElementAtPosition(pos: number): HTMLElement | null;
-    /**
-     * Finds all index entries whose position ranges overlap with the given range.
-     *
-     * @param from - The start of the query range (inclusive)
-     * @param to - The end of the query range (exclusive)
-     * @returns Array of entries that overlap the range, in index order
-     *
-     * @remarks
-     * An entry overlaps the query range [start, end) if:
-     * - entry.pmStart < end (entry starts before query range ends)
-     * - entry.pmEnd > start (entry ends after query range starts)
-     *
-     * The algorithm:
-     * 1. Normalizes the range (swaps from/to if necessary)
-     * 2. Uses binary search to find the first potentially overlapping entry
-     * 3. Scans forward, collecting overlapping entries until entries start beyond the range
-     *
-     * Time complexity: O(log n + k) where n is total entries and k is the number of matching entries.
-     *
-     * Returns empty array if:
-     * - Either from or to is not a finite number
-     * - from equals to (zero-length range)
-     * - The index is empty
-     * - No entries overlap the range
-     *
-     * Edge cases:
-     * - Zero-length ranges (from === to) return empty array
-     * - Reversed ranges are automatically normalized (from > to is handled)
-     */
-    findEntriesInRange(from: number, to: number): DomPositionIndexEntry[];
-    /**
-     * Finds all DOM elements whose position ranges overlap with the given range.
-     *
-     * @param from - The start of the query range (inclusive)
-     * @param to - The end of the query range (exclusive)
-     * @returns Array of DOM elements that overlap the range, in index order
-     *
-     * @remarks
-     * This is a convenience method that calls findEntriesInRange() and extracts the
-     * element references from each entry.
-     *
-     * See findEntriesInRange() for details on the overlap algorithm and edge cases.
-     */
-    findElementsInRange(from: number, to: number): HTMLElement[];
-}
-export {};
-//# sourceMappingURL=DomPositionIndex.d.ts.map

package/dist/super-editor/src/core/presentation-editor/dom/DomPositionIndex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DomPositionIndex.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/dom/DomPositionIndex.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,EAAE,EAAE,WAAW,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,KAAK,cAAc,GAAG;IACpB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,gBAAgB;;IAG3B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,SAAS,EAAE,WAAW,EAAE,OAAO,GAAE,cAAmB,GAAG,IAAI;IA0GnE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI;IAyB9D,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAItD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,qBAAqB,EAAE;IAoCrE;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,EAAE;CAG7D"}

package/dist/super-editor/src/core/presentation-editor/dom/DomPositionIndexObserverManager.d.ts

@@ -1,94 +0,0 @@
-/**
- * Manages automatic rebuilding of the DomPositionIndex when the painter host's children change.
- *
- * @remarks
- * This class uses a MutationObserver to watch for changes to the painter host's immediate children
- * (page elements that are virtualized by mounting/unmounting). When changes are detected, it
- * schedules a debounced rebuild of the DomPositionIndex via requestAnimationFrame.
- *
- * The observer can be paused and resumed to avoid unnecessary rebuilds during known periods of
- * rapid DOM changes (e.g., during layout updates).
- *
- * Key design decisions:
- * - Only observes childList changes (not attributes or subtree) for performance
- * - Debounces rebuilds using requestAnimationFrame to batch multiple mutations
- * - Gracefully handles environments without MutationObserver support
- * - Skips rebuilds if the painter host becomes disconnected from the DOM
- */
-export declare class DomPositionIndexObserverManager {
-    #private;
-    /**
-     * Creates a new DomPositionIndexObserverManager.
-     *
-     * @param options - Configuration options
-     * @param options.windowRoot - The window object to use for MutationObserver and requestAnimationFrame
-     * @param options.getPainterHost - Function that returns the current painter host element (may change over time)
-     * @param options.onRebuild - Callback invoked when a rebuild should occur
-     */
-    constructor(options: {
-        windowRoot: Window & typeof globalThis;
-        getPainterHost: () => HTMLElement | null;
-        onRebuild: () => void;
-    });
-    /**
-     * Initializes the MutationObserver and begins observing the painter host.
-     *
-     * @remarks
-     * Creates a new MutationObserver that watches for child list changes and schedules
-     * rebuilds when mutations occur. Automatically calls resume() to start observing.
-     *
-     * If the environment does not support MutationObserver, this method returns early
-     * without error. If an observer already exists, it is disconnected before creating
-     * a new one.
-     *
-     * Safe to call multiple times (e.g., when the painter host changes).
-     */
-    setup(): void;
-    /**
-     * Pauses observation by disconnecting the MutationObserver.
-     *
-     * @remarks
-     * Use this during periods of known rapid DOM changes (e.g., layout updates) to avoid
-     * unnecessary rebuild scheduling. The observer can be reactivated by calling resume().
-     *
-     * Safe to call when no observer exists or when already paused.
-     */
-    pause(): void;
-    /**
-     * Resumes observation by reconnecting the MutationObserver to the painter host.
-     *
-     * @remarks
-     * Attempts to observe the painter host's childList changes. If the observer doesn't exist,
-     * the painter host is not available, or the observe() call fails, this method returns
-     * gracefully without throwing.
-     *
-     * Safe to call multiple times or when already observing.
-     */
-    resume(): void;
-    /**
-     * Permanently tears down the observer and cancels any scheduled rebuilds.
-     *
-     * @remarks
-     * After calling destroy(), this instance should not be used again. The observer is
-     * disconnected, all references are cleared, and any pending rebuild is cancelled.
-     *
-     * Safe to call multiple times.
-     */
-    destroy(): void;
-    /**
-     * Schedules a debounced rebuild of the DomPositionIndex.
-     *
-     * @remarks
-     * Uses requestAnimationFrame to debounce multiple rapid mutations into a single rebuild.
-     * If a rebuild is already scheduled, this method returns early without scheduling another.
-     *
-     * The rebuild callback is only invoked if:
-     * - The painter host still exists
-     * - The painter host is still connected to the DOM
-     *
-     * This prevents unnecessary rebuilds when the painter host has been removed or is being
-     * torn down.
-     */
-    scheduleRebuild(): void;
-}
-//# sourceMappingURL=DomPositionIndexObserverManager.d.ts.map

package/dist/super-editor/src/core/presentation-editor/dom/DomPositionIndexObserverManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DomPositionIndexObserverManager.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/dom/DomPositionIndexObserverManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,+BAA+B;;IAQ1C;;;;;;;OAOG;gBACS,OAAO,EAAE;QACnB,UAAU,EAAE,MAAM,GAAG,OAAO,UAAU,CAAC;QACvC,cAAc,EAAE,MAAM,WAAW,GAAG,IAAI,CAAC;QACzC,SAAS,EAAE,MAAM,IAAI,CAAC;KACvB;IAMD;;;;;;;;;;;;OAYG;IACH,KAAK,IAAI,IAAI;IAeb;;;;;;;;OAQG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;;OASG;IACH,MAAM,IAAI,IAAI;IAYd;;;;;;;;OAQG;IACH,OAAO,IAAI,IAAI;IAUf;;;;;;;;;;;;;OAaG;IACH,eAAe,IAAI,IAAI;CAYxB"}

package/dist/super-editor/src/core/presentation-editor/dom/DomSelectionGeometry.d.ts

@@ -1,134 +0,0 @@
-import { Layout } from '@superdoc/contracts';
-import { DomPositionIndex } from './DomPositionIndex.js';
-/**
- * A rectangle representing a selection highlight in document layout coordinates.
- */
-export type LayoutRect = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    pageIndex: number;
-};
-/**
- * A caret position in page-local coordinates.
- */
-export type PageLocalCaretPosition = {
-    pageIndex: number;
-    x: number;
-    y: number;
-};
-/**
- * Options for computing selection rectangles from DOM.
- */
-export type ComputeSelectionRectsFromDomOptions = {
-    /** The DOM container hosting the rendered pages */
-    painterHost: HTMLElement | null;
-    /** The layout object containing page and fragment information */
-    layout: Layout | null;
-    /** Index mapping PM positions to DOM elements */
-    domPositionIndex: DomPositionIndex;
-    /** Function to rebuild the DOM position index when stale */
-    rebuildDomPositionIndex: () => void;
-    /** Current zoom level (1.0 = 100%) */
-    zoom: number;
-    /** Height of each page in layout units */
-    pageHeight: number;
-    /** Gap between pages in layout units */
-    pageGap: number;
-};
-/**
- * Computes visual selection rectangles by querying the browser's DOM Range API.
- *
- * This function maps a ProseMirror selection range (from, to) to DOM elements using the
- * DomPositionIndex, creates a DOM Range spanning those elements, and extracts the visual
- * bounding rectangles. The rectangles are returned in document layout coordinates (not
- * viewport coordinates), suitable for rendering custom selection overlays.
- *
- * @param options - Configuration including painter host, layout, position index, and zoom
- * @param from - Start position of the selection in ProseMirror coordinates
- * @param to - End position of the selection in ProseMirror coordinates
- * @returns Array of rectangles representing the selection, or null if computation fails
- *
- * @remarks
- * - Automatically rebuilds the DOM position index if it's stale due to virtualization
- * - Deduplicates overlapping rectangles to avoid "double selection" visual artifacts
- * - Returns null on error (invalid positions, stale DOM, or Range API failures)
- * - Returns empty array if from === to (collapsed selection)
- * - Clamps selection to page boundaries using fragment PM ranges from layout
- */
-export declare function computeSelectionRectsFromDom(options: ComputeSelectionRectsFromDomOptions, from: number, to: number): LayoutRect[] | null;
-/**
- * Options for computing caret position in page-local coordinates.
- */
-export type ComputeDomCaretPageLocalOptions = {
-    /** The DOM container hosting the rendered pages */
-    painterHost: HTMLElement | null;
-    /** Index mapping PM positions to DOM elements */
-    domPositionIndex: DomPositionIndex;
-    /** Function to rebuild the DOM position index when stale */
-    rebuildDomPositionIndex: () => void;
-    /** Current zoom level (1.0 = 100%) */
-    zoom: number;
-};
-/**
- * Computes the visual caret position for a given ProseMirror position.
- *
- * Uses the DOM position index to locate the element corresponding to the given PM position,
- * then queries the browser's Range API to get the exact pixel coordinates of the caret.
- * Returns coordinates in page-local space (relative to the page element, accounting for zoom).
- *
- * @param options - Configuration including painter host, position index, and zoom
- * @param pos - The ProseMirror position to compute caret coordinates for
- * @returns Page-local caret position (pageIndex, x, y), or null if computation fails
- *
- * @remarks
- * - Automatically rebuilds the DOM position index if the entry's element is disconnected
- * - For text nodes, creates a collapsed range at the character offset to get precise coordinates
- * - For non-text elements, uses the element's bounding rect
- * - Uses line element bounds for vertical positioning to align caret with line height
- */
-export declare function computeDomCaretPageLocal(options: ComputeDomCaretPageLocalOptions, pos: number): PageLocalCaretPosition | null;
-/**
- * Deduplicates overlapping rectangles returned by Range.getClientRects().
- *
- * The browser can return multiple rects for the same visual line when the Range
- * spans across element boundaries (e.g., from one <span> to another). This happens
- * because getClientRects() returns rects for both:
- * 1. The line-box (containing element's box)
- * 2. The text content within that box
- *
- * These rects have nearly identical y coordinates but slightly different heights
- * and widths, causing a "double selection" visual artifact when rendered.
- *
- * This function detects rects that overlap significantly on the same visual line
- * and keeps only one, preferring the smaller (text-content) rect.
- *
- * @param rects - Array of DOMRect objects returned by Range.getClientRects(). Input is not mutated.
- * @returns A new array containing deduplicated rectangles, sorted by position
- *
- * @remarks
- * Algorithm phases:
- *
- * **Phase 1: Group rects by Y coordinate (same line)**
- * - Sorts all rects by y coordinate (then by x within same y)
- * - Groups rects that are within Y_SAME_LINE_THRESHOLD_PX (3px) of each other
- * - Rects on the same visual line will be in the same group
- *
- * **Phase 2: Within each group, deduplicate**
- * - First pass: Remove exact duplicates (same x, y, width, height within epsilon thresholds)
- *   - X_DUPLICATE_EPS_PX (1px) for x-coordinate matching
- *   - Y_SAME_LINE_THRESHOLD_PX (3px) for y-coordinate matching
- *   - SIZE_EPS_PX (0.5px) for width/height matching
- * - Second pass: Filter out larger container rects
- *   - For rects with >80% horizontal overlap (HORIZONTAL_OVERLAP_THRESHOLD)
- *   - Marks and removes rects that are larger in width or height (by SIZE_EPS_PX)
- *
- * **Edge cases handled:**
- * - Zero-height/zero-width rects: Processed normally, larger ones removed in favor of smaller
- * - Multiple words on same line: Preserved if horizontal overlap <80%
- * - Unsorted input: Automatically sorted before processing
- * - Sub-pixel rendering differences: Handled via epsilon thresholds
- */
-export declare function deduplicateOverlappingRects(rects: DOMRect[]): DOMRect[];
-//# sourceMappingURL=DomSelectionGeometry.d.ts.map

package/dist/super-editor/src/core/presentation-editor/dom/DomSelectionGeometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DomSelectionGeometry.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/dom/DomSelectionGeometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,uBAAuB,CAAC;AAGrF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpG;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjF;;GAEG;AACH,MAAM,MAAM,mCAAmC,GAAG;IAChD,mDAAmD;IACnD,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,iEAAiE;IACjE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,iDAAiD;IACjD,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,4DAA4D;IAC5D,uBAAuB,EAAE,MAAM,IAAI,CAAC;IACpC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,mCAAmC,EAC5C,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,UAAU,EAAE,GAAG,IAAI,CA2TrB;AAgKD;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG;IAC5C,mDAAmD;IACnD,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,iDAAiD;IACjD,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,4DAA4D;IAC5D,uBAAuB,EAAE,MAAM,IAAI,CAAC;IACpC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,+BAA+B,EACxC,GAAG,EAAE,MAAM,GACV,sBAAsB,GAAG,IAAI,CA2C/B;AAqED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAqFvE"}

package/dist/super-editor/src/core/presentation-editor/dom/HiddenHost.d.ts

@@ -1,23 +0,0 @@
-/**
- * Creates a hidden host element for the ProseMirror editor.
- *
- * The hidden host contains the actual ProseMirror editor DOM, which provides semantic
- * document structure for accessibility (screen readers, keyboard navigation) while being
- * visually hidden off-screen. The visual presentation is rendered separately in the
- * viewport host using the layout engine.
- *
- * @param doc - The document object to create the element in
- * @param widthPx - The width of the hidden host in pixels (should match document width)
- * @returns A configured hidden host div element
- *
- * @remarks
- * - Uses position: fixed with left: -9999px to move off-screen without affecting scroll
- * - Uses opacity: 0 (NOT visibility: hidden) to keep content focusable
- * - Does NOT set aria-hidden="true" because the editor must remain accessible
- * - Sets pointer-events: none and z-index: -1 to prevent interaction
- * - Sets user-select: none to prevent text selection in the hidden editor
- * - Sets overflow-anchor: none to prevent scroll anchoring issues when content changes
- * - The viewport host is aria-hidden, but this host provides semantic structure
- */
-export declare function createHiddenHost(doc: Document, widthPx: number): HTMLElement;
-//# sourceMappingURL=HiddenHost.d.ts.map

package/dist/super-editor/src/core/presentation-editor/dom/HiddenHost.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HiddenHost.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/dom/HiddenHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAmB5E"}

package/dist/super-editor/src/core/presentation-editor/dom/PageDom.d.ts

@@ -1,18 +0,0 @@
-/**
- * Finds a page element in the painter host by its page index.
- *
- * Searches through all elements with data-page-index attributes in the painter host
- * and returns the first element whose data-page-index matches the requested pageIndex.
- *
- * @param painterHost - The DOM container hosting the rendered pages
- * @param pageIndex - The zero-based index of the page to find
- * @returns The page element if found, null otherwise
- *
- * @remarks
- * - Returns null if painterHost is null
- * - Uses querySelectorAll with [data-page-index] to find all page elements
- * - Parses data-page-index attribute as base-10 integer for comparison
- * - Returns the first matching element (pages should have unique indices)
- */
-export declare function getPageElementByIndex(painterHost: HTMLElement | null, pageIndex: number): HTMLElement | null;
-//# sourceMappingURL=PageDom.d.ts.map

package/dist/super-editor/src/core/presentation-editor/dom/PageDom.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PageDom.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/dom/PageDom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAY5G"}

package/dist/super-editor/src/core/presentation-editor/dom/PointerNormalization.d.ts

@@ -1,10 +0,0 @@
-export declare function normalizeClientPoint(options: {
-    viewportHost: HTMLElement;
-    visibleHost: HTMLElement;
-    zoom: number;
-    getPageOffsetX: (pageIndex: number) => number | null;
-}, clientX: number, clientY: number): {
-    x: number;
-    y: number;
-} | null;
-//# sourceMappingURL=PointerNormalization.d.ts.map

package/dist/super-editor/src/core/presentation-editor/dom/PointerNormalization.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PointerNormalization.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/dom/PointerNormalization.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAClC,OAAO,EAAE;IACP,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,WAAW,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CACtD,EACD,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAmCjC"}