blecsd 0.3.0 → 0.6.0

package/dist/virtualViewport-fIlbIGPt.d.ts

@@ -0,0 +1,657 @@
+import { W as World, E as Entity } from './types-B8LmNkzG.js';
+import { z } from 'zod';
+
+/**
+ * Dimensions component for entity sizing in the terminal grid.
+ * @module components/dimensions
+ */
+
+/**
+ * Special value indicating "auto" (content-based) dimension.
+ * When used, the dimension is calculated based on content.
+ */
+declare const AUTO_DIMENSION = -1;
+/**
+ * Encodes a percentage value for storage in typed arrays.
+ * Percentages are stored as negative values: -2 = 0%, -102 = 100%
+ *
+ * @param percent - Percentage value (0-100)
+ * @returns Encoded value for storage
+ *
+ * @example
+ * ```typescript
+ * const encoded = encodePercentage(50); // Returns -52
+ * ```
+ */
+declare function encodePercentage(percent: number): number;
+/**
+ * Decodes a percentage value from typed array storage.
+ *
+ * @param value - Encoded value from storage
+ * @returns Percentage value (0-100) or null if not a percentage
+ *
+ * @example
+ * ```typescript
+ * const percent = decodePercentage(-52); // Returns 50
+ * const notPercent = decodePercentage(100); // Returns null
+ * ```
+ */
+declare function decodePercentage(value: number): number | null;
+/**
+ * Checks if a value represents a percentage.
+ *
+ * @param value - Value to check
+ * @returns true if the value is an encoded percentage
+ */
+declare function isPercentage(value: number): boolean;
+/**
+ * Dimensions component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `width`, `height`: Size in terminal cells (floats), or encoded percentages
+ * - `minWidth`, `minHeight`: Minimum size constraints
+ * - `maxWidth`, `maxHeight`: Maximum size constraints
+ * - `shrink`: Whether to shrink to content (0=no, 1=yes)
+ *
+ * Percentage values are encoded as negative numbers: -2 = 0%, -102 = 100%
+ * Use `encodePercentage()` and `decodePercentage()` for conversion.
+ *
+ * @example
+ * ```typescript
+ * import { Dimensions, setDimensions, getDimensions } from 'blecsd';
+ *
+ * setDimensions(world, entity, 80, 24);
+ *
+ * const dims = getDimensions(world, entity);
+ * console.log(dims.width, dims.height); // 80, 24
+ * ```
+ */
+declare const Dimensions: {
+    /** Width in terminal cells (or encoded percentage) */
+    width: Float32Array<ArrayBuffer>;
+    /** Height in terminal cells (or encoded percentage) */
+    height: Float32Array<ArrayBuffer>;
+    /** Minimum width constraint */
+    minWidth: Float32Array<ArrayBuffer>;
+    /** Minimum height constraint */
+    minHeight: Float32Array<ArrayBuffer>;
+    /** Maximum width constraint */
+    maxWidth: Float32Array<ArrayBuffer>;
+    /** Maximum height constraint */
+    maxHeight: Float32Array<ArrayBuffer>;
+    /** 0 = fixed size, 1 = shrink to content */
+    shrink: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Dimension value that can be a number, percentage string, or 'auto'.
+ */
+type DimensionValue = number | `${number}%` | 'auto';
+/**
+ * Dimensions data returned by getDimensions.
+ */
+interface DimensionsData {
+    readonly width: number;
+    readonly height: number;
+    readonly minWidth: number;
+    readonly minHeight: number;
+    readonly maxWidth: number;
+    readonly maxHeight: number;
+    readonly shrink: boolean;
+}
+/**
+ * Constraints data for min/max dimensions.
+ */
+interface DimensionConstraints {
+    readonly minWidth?: number;
+    readonly minHeight?: number;
+    readonly maxWidth?: number;
+    readonly maxHeight?: number;
+}
+/**
+ * Sets the dimensions of an entity.
+ * Adds the Dimensions component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param width - Width value (number, percentage string like "50%", or "auto")
+ * @param height - Height value (number, percentage string like "50%", or "auto")
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setDimensions } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * // Fixed size
+ * setDimensions(world, entity, 80, 24);
+ *
+ * // Percentage width
+ * setDimensions(world, entity, '50%', 24);
+ *
+ * // Auto height
+ * setDimensions(world, entity, 80, 'auto');
+ * ```
+ */
+declare function setDimensions(world: World, eid: Entity, width: DimensionValue, height: DimensionValue): Entity;
+/**
+ * Gets the dimensions data of an entity.
+ * Returns undefined if the entity doesn't have a Dimensions component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Dimensions data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getDimensions } from 'blecsd';
+ *
+ * const dims = getDimensions(world, entity);
+ * if (dims) {
+ *   console.log(`Size: ${dims.width}x${dims.height}`);
+ * }
+ * ```
+ */
+declare function getDimensions(world: World, eid: Entity): DimensionsData | undefined;
+/**
+ * Sets dimension constraints (min/max) for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param constraints - Constraint values to set
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setConstraints } from 'blecsd';
+ *
+ * setConstraints(world, entity, {
+ *   minWidth: 10,
+ *   maxWidth: 100,
+ *   minHeight: 5,
+ * });
+ * ```
+ */
+declare function setConstraints(world: World, eid: Entity, constraints: DimensionConstraints): Entity;
+/**
+ * Sets the shrink-to-content flag for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param shrink - true to shrink to content, false for fixed size
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setShrink } from 'blecsd';
+ *
+ * // Enable shrink-to-content
+ * setShrink(world, entity, true);
+ * ```
+ */
+declare function setShrink(world: World, eid: Entity, shrink: boolean): Entity;
+/**
+ * Checks if an entity should shrink to content.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if shrink is enabled, false otherwise
+ */
+declare function shouldShrink(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity has a Dimensions component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Dimensions component
+ */
+declare function hasDimensions(world: World, eid: Entity): boolean;
+/**
+ * Gets the width of an entity, resolving percentages against a container width.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param containerWidth - Container width to resolve percentages against
+ * @returns Resolved width value, or undefined if no Dimensions component
+ *
+ * @example
+ * ```typescript
+ * import { getResolvedWidth, setDimensions } from 'blecsd';
+ *
+ * setDimensions(world, entity, '50%', 24);
+ * const width = getResolvedWidth(world, entity, 100); // Returns 50
+ * ```
+ */
+declare function getResolvedWidth(world: World, eid: Entity, containerWidth: number): number | undefined;
+/**
+ * Gets the height of an entity, resolving percentages against a container height.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param containerHeight - Container height to resolve percentages against
+ * @returns Resolved height value, or undefined if no Dimensions component
+ *
+ * @example
+ * ```typescript
+ * import { getResolvedHeight, setDimensions } from 'blecsd';
+ *
+ * setDimensions(world, entity, 80, '25%');
+ * const height = getResolvedHeight(world, entity, 80); // Returns 20
+ * ```
+ */
+declare function getResolvedHeight(world: World, eid: Entity, containerHeight: number): number | undefined;
+
+/**
+ * VirtualViewport Component for Viewport Windowing
+ *
+ * ECS component that tracks which portion of a large dataset is currently visible.
+ * Works with VirtualizedLineStore for text, or any other indexed content.
+ *
+ * @module components/virtualViewport
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setVirtualViewport, scrollToLine, getVisibleRange } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * // Configure viewport for a list with 1000 items
+ * setVirtualViewport(world, entity, {
+ *   totalLineCount: 1000,
+ *   visibleLineCount: 25,
+ *   overscanBefore: 5,
+ *   overscanAfter: 5,
+ * });
+ *
+ * // Scroll to line 500
+ * scrollToLine(world, entity, 500);
+ *
+ * // Get visible range (includes overscan)
+ * const range = getVisibleRange(world, entity);
+ * // range = { start: 495, end: 530 }
+ * ```
+ */
+
+/**
+ * Schema for VirtualViewport configuration options.
+ *
+ * @example
+ * ```typescript
+ * import { VirtualViewportOptionsSchema } from 'blecsd';
+ *
+ * const options = VirtualViewportOptionsSchema.parse({
+ *   totalLineCount: 10000,
+ *   visibleLineCount: 25,
+ *   overscanBefore: 5,
+ * });
+ * ```
+ */
+declare const VirtualViewportOptionsSchema: z.ZodObject<{
+    firstVisibleLine: z.ZodOptional<z.ZodNumber>;
+    visibleLineCount: z.ZodOptional<z.ZodNumber>;
+    totalLineCount: z.ZodOptional<z.ZodNumber>;
+    overscanBefore: z.ZodOptional<z.ZodNumber>;
+    overscanAfter: z.ZodOptional<z.ZodNumber>;
+    estimatedLineHeight: z.ZodOptional<z.ZodNumber>;
+    isVariableHeight: z.ZodOptional<z.ZodBoolean>;
+    selectedLine: z.ZodOptional<z.ZodNumber>;
+    cursorLine: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Schema for visible range output.
+ */
+declare const VisibleRangeSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    visibleStart: z.ZodNumber;
+    visibleEnd: z.ZodNumber;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Schema for scroll info output.
+ */
+declare const ScrollInfoSchema: z.ZodObject<{
+    currentLine: z.ZodNumber;
+    totalLines: z.ZodNumber;
+    viewportSize: z.ZodNumber;
+    maxScrollLine: z.ZodNumber;
+    scrollPercent: z.ZodNumber;
+    atTop: z.ZodBoolean;
+    atBottom: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * VirtualViewport component store using SoA (Structure of Arrays).
+ *
+ * Tracks viewport windowing for virtualized content rendering.
+ * Only the visible portion (plus overscan) should be rendered.
+ */
+declare const VirtualViewport: {
+    /** First visible line index in the viewport */
+    firstVisibleLine: Uint32Array<ArrayBuffer>;
+    /** Number of lines visible in the viewport */
+    visibleLineCount: Uint32Array<ArrayBuffer>;
+    /** Total number of lines in the content */
+    totalLineCount: Uint32Array<ArrayBuffer>;
+    /** Extra lines to render above viewport for smooth scrolling */
+    overscanBefore: Uint8Array<ArrayBuffer>;
+    /** Extra lines to render below viewport for smooth scrolling */
+    overscanAfter: Uint8Array<ArrayBuffer>;
+    /** Estimated height of each line in rows (for variable height estimation) */
+    estimatedLineHeight: Uint8Array<ArrayBuffer>;
+    /** Whether lines have variable height (0=fixed, 1=variable) */
+    isVariableHeight: Uint8Array<ArrayBuffer>;
+    /** Whether viewport needs re-render (dirty flag) */
+    isDirty: Uint8Array<ArrayBuffer>;
+    /** Selected line index (-1 = none) using Int32 to allow -1 */
+    selectedLine: Int32Array<ArrayBuffer>;
+    /** Cursor line for interactive lists (-1 = none) */
+    cursorLine: Int32Array<ArrayBuffer>;
+};
+/**
+ * Configuration options for VirtualViewport.
+ */
+interface VirtualViewportOptions {
+    /** First visible line index */
+    firstVisibleLine?: number;
+    /** Number of visible lines */
+    visibleLineCount?: number;
+    /** Total line count in content */
+    totalLineCount?: number;
+    /** Overscan lines before viewport */
+    overscanBefore?: number;
+    /** Overscan lines after viewport */
+    overscanAfter?: number;
+    /** Estimated line height (for variable height) */
+    estimatedLineHeight?: number;
+    /** Whether lines have variable height */
+    isVariableHeight?: boolean;
+    /** Selected line index */
+    selectedLine?: number;
+    /** Cursor line index */
+    cursorLine?: number;
+}
+/**
+ * Visible range including overscan.
+ */
+interface VisibleRange {
+    /** Start line index (with overscan) */
+    readonly start: number;
+    /** End line index (exclusive, with overscan) */
+    readonly end: number;
+    /** First actually visible line (without overscan) */
+    readonly visibleStart: number;
+    /** Last actually visible line (exclusive, without overscan) */
+    readonly visibleEnd: number;
+    /** Total lines in range */
+    readonly count: number;
+}
+/**
+ * Full viewport data.
+ */
+interface VirtualViewportData {
+    readonly firstVisibleLine: number;
+    readonly visibleLineCount: number;
+    readonly totalLineCount: number;
+    readonly overscanBefore: number;
+    readonly overscanAfter: number;
+    readonly estimatedLineHeight: number;
+    readonly isVariableHeight: boolean;
+    readonly isDirty: boolean;
+    readonly selectedLine: number;
+    readonly cursorLine: number;
+}
+/**
+ * Scroll position info.
+ */
+interface ScrollInfo {
+    /** Current line */
+    readonly currentLine: number;
+    /** Total lines */
+    readonly totalLines: number;
+    /** Viewport size */
+    readonly viewportSize: number;
+    /** Maximum scrollable line */
+    readonly maxScrollLine: number;
+    /** Scroll percentage (0-100) */
+    readonly scrollPercent: number;
+    /** Whether at top */
+    readonly atTop: boolean;
+    /** Whether at bottom */
+    readonly atBottom: boolean;
+}
+/**
+ * Sets up a VirtualViewport on an entity.
+ * Input is validated against VirtualViewportOptionsSchema.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Viewport configuration
+ * @returns The entity ID for chaining
+ * @throws {z.ZodError} If options are invalid
+ *
+ * @example
+ * ```typescript
+ * setVirtualViewport(world, entity, {
+ *   totalLineCount: 10000,
+ *   visibleLineCount: 25,
+ * });
+ * ```
+ */
+declare function setVirtualViewport(world: World, eid: Entity, options: VirtualViewportOptions): Entity;
+/**
+ * Gets VirtualViewport data for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Viewport data or undefined if no component
+ */
+declare function getVirtualViewport(world: World, eid: Entity): VirtualViewportData | undefined;
+/**
+ * Checks if entity has VirtualViewport.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if has component
+ */
+declare function hasVirtualViewport(world: World, eid: Entity): boolean;
+/**
+ * Sets the first visible line (viewport start).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Line index to scroll to
+ * @returns The entity ID for chaining
+ */
+declare function setViewportStart(world: World, eid: Entity, lineIndex: number): Entity;
+/**
+ * Gets the visible range including overscan.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Visible range or undefined if no component
+ *
+ * @example
+ * ```typescript
+ * const range = getVisibleRange(world, entity);
+ * // Render lines from range.start to range.end
+ * const lines = getLineRange(store, range.start, range.end);
+ * ```
+ */
+declare function getVisibleRange(world: World, eid: Entity): VisibleRange | undefined;
+/**
+ * Checks if a line is currently visible (in viewport, not just overscan).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Line index to check
+ * @returns true if line is visible
+ */
+declare function isLineVisible(world: World, eid: Entity, lineIndex: number): boolean;
+/**
+ * Checks if a line is in the render range (visible + overscan).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Line index to check
+ * @returns true if line should be rendered
+ */
+declare function isLineInRenderRange(world: World, eid: Entity, lineIndex: number): boolean;
+/**
+ * Scrolls to a specific line, centering it if possible.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Target line index
+ * @returns The entity ID for chaining
+ */
+declare function scrollToLine(world: World, eid: Entity, lineIndex: number): Entity;
+/**
+ * Scrolls by a number of lines.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param delta - Lines to scroll (positive = down, negative = up)
+ * @returns The entity ID for chaining
+ */
+declare function scrollByLines(world: World, eid: Entity, delta: number): Entity;
+/**
+ * Scrolls by pages.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param pages - Pages to scroll (positive = down, negative = up)
+ * @returns The entity ID for chaining
+ */
+declare function scrollByPages(world: World, eid: Entity, pages: number): Entity;
+/**
+ * Scrolls to the top.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function scrollToTop(world: World, eid: Entity): Entity;
+/**
+ * Scrolls to the bottom.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function scrollToBottom(world: World, eid: Entity): Entity;
+/**
+ * Gets scroll information.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Scroll info or undefined if no component
+ */
+declare function getScrollInfo(world: World, eid: Entity): ScrollInfo | undefined;
+/**
+ * Updates the total line count (when content changes).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param totalLines - New total line count
+ * @returns The entity ID for chaining
+ */
+declare function setTotalLineCount(world: World, eid: Entity, totalLines: number): Entity;
+/**
+ * Updates the viewport size (when container resizes).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param visibleLines - New visible line count
+ * @returns The entity ID for chaining
+ */
+declare function setVisibleLineCount(world: World, eid: Entity, visibleLines: number): Entity;
+/**
+ * Sets overscan values.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param before - Lines to render before viewport
+ * @param after - Lines to render after viewport
+ * @returns The entity ID for chaining
+ */
+declare function setOverscan(world: World, eid: Entity, before: number, after: number): Entity;
+/**
+ * Sets the selected line.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Selected line (-1 for none)
+ * @returns The entity ID for chaining
+ */
+declare function setSelectedLine(world: World, eid: Entity, lineIndex: number): Entity;
+/**
+ * Gets the selected line.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Selected line index or -1 if none
+ */
+declare function getSelectedLine(world: World, eid: Entity): number;
+/**
+ * Sets the cursor line (for keyboard navigation).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param lineIndex - Cursor line (-1 for none)
+ * @returns The entity ID for chaining
+ */
+declare function setCursorLine(world: World, eid: Entity, lineIndex: number): Entity;
+/**
+ * Gets the cursor line.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Cursor line index or -1 if none
+ */
+declare function getCursorLine(world: World, eid: Entity): number;
+/**
+ * Moves cursor up/down and auto-scrolls to keep it visible.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param delta - Lines to move (negative = up, positive = down)
+ * @returns The entity ID for chaining
+ */
+declare function moveCursor(world: World, eid: Entity, delta: number): Entity;
+/**
+ * Ensures the cursor is visible, scrolling if needed.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function ensureCursorVisible(world: World, eid: Entity): Entity;
+/**
+ * Checks if viewport needs re-render.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if dirty
+ */
+declare function isViewportDirty(world: World, eid: Entity): boolean;
+/**
+ * Clears the dirty flag after rendering.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function clearViewportDirty(world: World, eid: Entity): Entity;
+/**
+ * Forces viewport to be dirty (triggers re-render).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function invalidateViewport(world: World, eid: Entity): Entity;
+
+export { isLineInRenderRange as A, getCursorLine as B, setCursorLine as C, type DimensionValue as D, moveCursor as E, getSelectedLine as F, setSelectedLine as G, setViewportStart as H, setTotalLineCount as I, setVisibleLineCount as J, setOverscan as K, AUTO_DIMENSION as L, type DimensionConstraints as M, Dimensions as N, type DimensionsData as O, type VirtualViewportData as P, type VirtualViewportOptions as Q, VirtualViewportOptionsSchema as R, ScrollInfoSchema as S, type ScrollInfo as T, type VisibleRange as U, VirtualViewport as V, VisibleRangeSchema as W, scrollToBottom as a, scrollToLine as b, scrollToTop as c, setDimensions as d, ensureCursorVisible as e, getResolvedWidth as f, getDimensions as g, hasDimensions as h, getResolvedHeight as i, setConstraints as j, setShrink as k, shouldShrink as l, encodePercentage as m, decodePercentage as n, isPercentage as o, getVirtualViewport as p, hasVirtualViewport as q, setVirtualViewport as r, scrollByLines as s, getScrollInfo as t, getVisibleRange as u, isViewportDirty as v, clearViewportDirty as w, invalidateViewport as x, scrollByPages as y, isLineVisible as z };

package/dist/{virtualizedLineStore-DwPEvPkk.d.ts → virtualizedLineStore-DfyhojPZ.d.ts}

@@ -294,4 +294,4 @@ declare function exportLineRange(store: VirtualizedLineStore, startLine: number,
  */
 declare function trimToLineCount(store: VirtualizedLineStore, maxLines: number): VirtualizedLineStore;
 
-export { CHUNKED_THRESHOLD as C, LineIndexSchema as L, TrimParamsSchema as T, type VirtualizedLineStore as V, LineRangeParamsSchema as a, type LineStoreStats as b, type LineInfo as c, type LineRange as d, VisibleLinesParamsSchema as e, appendLines as f, appendToStore as g, createEmptyLineStore as h, createLineStore as i, createLineStoreFromLines as j, exportContent as k, exportLineRange as l, getByteSize as m, getLineAtIndex as n, getLineForOffset as o, getLineInfo as p, getLineCount as q, getLineRange as r, getVisibleLines as s, getOffsetForLine as t, getStoreStats as u, isStoreEmpty as v, trimToLineCount as w };
+export { CHUNKED_THRESHOLD as C, LineIndexSchema as L, TrimParamsSchema as T, type VirtualizedLineStore as V, createLineStoreFromLines as a, createEmptyLineStore as b, createLineStore as c, appendToStore as d, appendLines as e, getLineRange as f, getLineAtIndex as g, getLineCount as h, getLineForOffset as i, getOffsetForLine as j, getLineInfo as k, getVisibleLines as l, exportContent as m, exportLineRange as n, getStoreStats as o, getByteSize as p, isStoreEmpty as q, LineRangeParamsSchema as r, type LineStoreStats as s, trimToLineCount as t, type LineInfo as u, type LineRange as v, VisibleLinesParamsSchema as w };