blecsd 0.4.0 → 0.6.2

package/dist/interactiveSystem-Dtv3xERg.d.ts

@@ -0,0 +1,2292 @@
+import { W as World, E as Entity } from './types-B8LmNkzG.js';
+
+/**
+ * Content component for text content storage.
+ * @module components/content
+ */
+
+/**
+ * Text alignment enumeration.
+ */
+declare enum TextAlign {
+    Left = 0,
+    Center = 1,
+    Right = 2
+}
+/**
+ * Vertical alignment enumeration.
+ */
+declare enum TextVAlign {
+    Top = 0,
+    Middle = 1,
+    Bottom = 2
+}
+/**
+ * Content store: functional interface for managing string content.
+ * Since bitecs uses typed arrays, strings must be stored separately.
+ */
+declare const contentStore: {
+    /** Sets content for an entity and returns the content ID. */
+    set(_eid: Entity, text: string): number;
+    /** Gets content by ID. */
+    get(id: number): string;
+    /** Deletes content by ID. */
+    delete(id: number): void;
+    /** Clears all content. */
+    clear(): void;
+};
+/**
+ * Content component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `contentId`: Reference to content in ContentStore
+ * - `length`: Content length in characters
+ * - `hash`: Content hash for change detection
+ * - `wrap`: Whether to wrap text (0=no, 1=yes)
+ * - `align`: Horizontal text alignment
+ * - `valign`: Vertical text alignment
+ * - `parseTags`: Whether to parse markup tags (0=no, 1=yes)
+ * - `tabSize`: Tab character width in spaces (default: 8)
+ *
+ * @example
+ * ```typescript
+ * import { Content, setContent, getContent, TextAlign } from 'blecsd';
+ *
+ * setContent(world, entity, 'Hello, World!', { align: TextAlign.Center });
+ * const text = getContent(world, entity);
+ * console.log(text); // 'Hello, World!'
+ * ```
+ */
+declare const Content: {
+    /** Reference to content store */
+    contentId: Uint32Array<ArrayBuffer>;
+    /** Content length in characters */
+    length: Uint32Array<ArrayBuffer>;
+    /** Content hash for change detection */
+    hash: Uint32Array<ArrayBuffer>;
+    /** Text wrap (0=no, 1=yes) */
+    wrap: Uint8Array<ArrayBuffer>;
+    /** Horizontal alignment (0=left, 1=center, 2=right) */
+    align: Uint8Array<ArrayBuffer>;
+    /** Vertical alignment (0=top, 1=middle, 2=bottom) */
+    valign: Uint8Array<ArrayBuffer>;
+    /** Parse markup tags (0=no, 1=yes) */
+    parseTags: Uint8Array<ArrayBuffer>;
+    /** Tab character width in spaces (default: 8) */
+    tabSize: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Content configuration options.
+ */
+interface ContentOptions {
+    /** Whether to wrap text */
+    wrap?: boolean;
+    /** Horizontal text alignment */
+    align?: TextAlign;
+    /** Vertical text alignment */
+    valign?: TextVAlign;
+    /** Whether to parse markup tags */
+    parseTags?: boolean;
+    /** Tab character width in spaces (1-16, default: 8) */
+    tabSize?: number;
+}
+/**
+ * Content data returned by getContentData.
+ */
+interface ContentData {
+    readonly text: string;
+    readonly length: number;
+    readonly hash: number;
+    readonly wrap: boolean;
+    readonly align: TextAlign;
+    readonly valign: TextVAlign;
+    readonly parseTags: boolean;
+    readonly tabSize: number;
+}
+/**
+ * Sets the text content of an entity.
+ * Adds the Content component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param text - The text content
+ * @param options - Optional content configuration
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setContent, TextAlign } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * // Set content with options
+ * setContent(world, entity, 'Hello, World!', {
+ *   align: TextAlign.Center,
+ *   wrap: true,
+ * });
+ *
+ * // Simple text content
+ * setContent(world, entity, 'Plain text');
+ * ```
+ */
+declare function setContent(world: World, eid: Entity, text: string, options?: ContentOptions): Entity;
+/**
+ * Gets the text content of an entity.
+ * Returns empty string if no Content component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The text content or empty string
+ *
+ * @example
+ * ```typescript
+ * import { getContent } from 'blecsd';
+ *
+ * const text = getContent(world, entity);
+ * console.log(text);
+ * ```
+ */
+declare function getContent(world: World, eid: Entity): string;
+/**
+ * Gets the full content data of an entity.
+ * Returns undefined if no Content component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Content data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getContentData, TextAlign } from 'blecsd';
+ *
+ * const data = getContentData(world, entity);
+ * if (data) {
+ *   console.log(`Text: ${data.text}, Align: ${data.align}`);
+ * }
+ * ```
+ */
+declare function getContentData(world: World, eid: Entity): ContentData | undefined;
+/**
+ * Sets the text content of an entity, stripping any ANSI escape codes.
+ * Use this when you want to set plain text without formatting codes.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param text - The text to set (ANSI codes will be stripped)
+ * @param options - Optional content options
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setText, getText } from 'blecsd';
+ *
+ * // ANSI codes are stripped
+ * setText(world, entity, '\x1b[31mRed Text\x1b[0m');
+ * console.log(getText(world, entity)); // 'Red Text'
+ * ```
+ */
+declare function setText(world: World, eid: Entity, text: string, options?: ContentOptions): Entity;
+/**
+ * Gets the text content of an entity with ANSI codes stripped.
+ * Returns empty string if no Content component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The plain text content without ANSI codes
+ *
+ * @example
+ * ```typescript
+ * import { setContent, getText } from 'blecsd';
+ *
+ * // Content may contain ANSI codes
+ * setContent(world, entity, '\x1b[31mRed\x1b[0m');
+ * console.log(getText(world, entity)); // 'Red'
+ * ```
+ */
+declare function getText(world: World, eid: Entity): string;
+/**
+ * Appends text to an entity's content.
+ * Adds the Content component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param text - The text to append
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setContent, appendContent } from 'blecsd';
+ *
+ * setContent(world, entity, 'Hello');
+ * appendContent(world, entity, ', World!');
+ * // Content is now 'Hello, World!'
+ * ```
+ */
+declare function appendContent(world: World, eid: Entity, text: string): Entity;
+/**
+ * Clears the content of an entity.
+ * Removes the content from the store but keeps the component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { clearContent } from 'blecsd';
+ *
+ * clearContent(world, entity);
+ * ```
+ */
+declare function clearContent(world: World, eid: Entity): Entity;
+/**
+ * Checks if an entity has a Content component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Content component
+ */
+declare function hasContent(world: World, eid: Entity): boolean;
+/**
+ * Gets the content length of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Content length or 0 if no Content component
+ */
+declare function getContentLength(world: World, eid: Entity): number;
+/**
+ * Gets the content hash of an entity.
+ * Useful for change detection.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Content hash or 0 if no Content component
+ */
+declare function getContentHash(world: World, eid: Entity): number;
+/**
+ * Sets the text alignment of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param align - Horizontal alignment
+ * @returns The entity ID for chaining
+ */
+declare function setTextAlign(world: World, eid: Entity, align: TextAlign): Entity;
+/**
+ * Sets the vertical alignment of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param valign - Vertical alignment
+ * @returns The entity ID for chaining
+ */
+declare function setTextVAlign(world: World, eid: Entity, valign: TextVAlign): Entity;
+/**
+ * Sets the text wrap setting of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param wrap - Whether to wrap text
+ * @returns The entity ID for chaining
+ */
+declare function setTextWrap(world: World, eid: Entity, wrap: boolean): Entity;
+/**
+ * Checks if text wrapping is enabled for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if text wrapping is enabled
+ */
+declare function isTextWrapped(world: World, eid: Entity): boolean;
+/**
+ * Sets whether to parse markup tags in content.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param parse - Whether to parse tags
+ * @returns The entity ID for chaining
+ */
+declare function setParseTags(world: World, eid: Entity, parse: boolean): Entity;
+/**
+ * Checks if tag parsing is enabled for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if tag parsing is enabled
+ */
+declare function isParsingTags(world: World, eid: Entity): boolean;
+/**
+ * Resets the content store. Useful for testing.
+ * @internal
+ */
+declare function resetContentStore(): void;
+
+/**
+ * Focusable component for focus management.
+ * @module components/focusable
+ */
+
+/** Default focus effect foreground color (white) */
+declare const DEFAULT_FOCUS_FG = 4294967295;
+/** Default focus effect background color (transparent) */
+declare const DEFAULT_FOCUS_BG = 0;
+/**
+ * Focusable component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `focusable`: Whether entity can receive focus (0=no, 1=yes)
+ * - `focused`: Whether entity currently has focus (0=no, 1=yes)
+ * - `tabIndex`: Tab order (-1 = not in tab order, 0+ = order)
+ * - `focusEffectFg`, `focusEffectBg`: Colors for focus effect
+ *
+ * @example
+ * ```typescript
+ * import { Focusable, setFocusable, focus, blur, isFocused } from 'blecsd';
+ *
+ * setFocusable(world, entity, true);
+ * focus(world, entity);
+ *
+ * if (isFocused(world, entity)) {
+ *   console.log('Entity has focus');
+ * }
+ * ```
+ */
+declare const Focusable: {
+    /** Whether entity can receive focus (0=no, 1=yes) */
+    focusable: Uint8Array<ArrayBuffer>;
+    /** Whether entity currently has focus (0=no, 1=yes) */
+    focused: Uint8Array<ArrayBuffer>;
+    /** Tab order (-1 = not in tab order) */
+    tabIndex: Int16Array<ArrayBuffer>;
+    /** Focus effect foreground color */
+    focusEffectFg: Uint32Array<ArrayBuffer>;
+    /** Focus effect background color */
+    focusEffectBg: Uint32Array<ArrayBuffer>;
+};
+/**
+ * Focusable configuration options.
+ */
+interface FocusableOptions {
+    /** Whether entity can receive focus */
+    focusable?: boolean;
+    /** Tab order (-1 = not in tab order) */
+    tabIndex?: number;
+    /** Focus effect foreground color */
+    focusEffectFg?: number;
+    /** Focus effect background color */
+    focusEffectBg?: number;
+}
+/**
+ * Focus data returned by getFocusable.
+ */
+interface FocusableData {
+    readonly focusable: boolean;
+    readonly focused: boolean;
+    readonly tabIndex: number;
+    readonly focusEffectFg: number;
+    readonly focusEffectBg: number;
+}
+/**
+ * Makes an entity focusable with the given options.
+ * Adds the Focusable component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Focusable configuration options
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setFocusable } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * setFocusable(world, entity, { focusable: true, tabIndex: 1 });
+ * ```
+ */
+declare function setFocusable(world: World, eid: Entity, options: FocusableOptions): Entity;
+/**
+ * Makes an entity focusable (simple boolean setter).
+ * Adds the Focusable component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param focusable - Whether entity can receive focus
+ * @returns The entity ID for chaining
+ */
+declare function makeFocusable(world: World, eid: Entity, focusable: boolean): Entity;
+/**
+ * Checks if an entity is currently focused.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has focus
+ *
+ * @example
+ * ```typescript
+ * import { isFocused } from 'blecsd';
+ *
+ * if (isFocused(world, entity)) {
+ *   // Handle focused state
+ * }
+ * ```
+ */
+declare function isFocused(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity can receive focus.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity can receive focus
+ */
+declare function isFocusable(world: World, eid: Entity): boolean;
+/**
+ * Focuses an entity, unfocusing any previously focused entity.
+ * Only works if the entity is focusable.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { focus } from 'blecsd';
+ *
+ * focus(world, entity); // Entity now has focus
+ * ```
+ */
+declare function focus(world: World, eid: Entity): Entity;
+/**
+ * Removes focus from an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { blur } from 'blecsd';
+ *
+ * blur(world, entity); // Entity loses focus
+ * ```
+ */
+declare function blur(world: World, eid: Entity): Entity;
+/**
+ * Gets the focus data of an entity.
+ * Returns undefined if no Focusable component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Focusable data or undefined
+ */
+declare function getFocusable(world: World, eid: Entity): FocusableData | undefined;
+/**
+ * Checks if an entity has a Focusable component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Focusable component
+ */
+declare function hasFocusable(world: World, eid: Entity): boolean;
+/**
+ * Gets the currently focused entity.
+ *
+ * @returns The focused entity or null if none
+ */
+declare function getFocusedEntity(): Entity | null;
+/**
+ * Sets the tab index of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param index - Tab index (-1 = not in tab order)
+ * @returns The entity ID for chaining
+ */
+declare function setTabIndex(world: World, eid: Entity, index: number): Entity;
+/**
+ * Gets the tab index of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Tab index or -1 if not in tab order
+ */
+declare function getTabIndex(world: World, eid: Entity): number;
+/**
+ * Checks if an entity is in the tab order.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is in tab order
+ */
+declare function isInTabOrder(world: World, eid: Entity): boolean;
+/**
+ * Gets entities in tab order.
+ * Returns entities sorted by tabIndex (ascending).
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entities to consider
+ * @returns Sorted array of entities in tab order
+ *
+ * @example
+ * ```typescript
+ * import { getTabOrder } from 'blecsd';
+ *
+ * const orderedEntities = getTabOrder(world, allEntities);
+ * for (const eid of orderedEntities) {
+ *   // Process in tab order
+ * }
+ * ```
+ */
+declare function getTabOrder(world: World, entities: Entity[]): Entity[];
+/**
+ * Focuses the next entity in tab order.
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entities in the focusable set
+ * @returns The newly focused entity or null if none
+ */
+declare function focusNext(world: World, entities: Entity[]): Entity | null;
+/**
+ * Focuses the previous entity in tab order.
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entities in the focusable set
+ * @returns The newly focused entity or null if none
+ */
+declare function focusPrev(world: World, entities: Entity[]): Entity | null;
+/**
+ * Resets the focus state. Useful for testing.
+ * @internal
+ */
+declare function resetFocusState(): void;
+
+/**
+ * Hierarchy component for parent/child entity relationships.
+ * Uses a linked list structure for efficient traversal.
+ * @module components/hierarchy
+ */
+
+/** Null entity value (no parent/child/sibling) */
+declare const NULL_ENTITY = 0;
+/**
+ * Hierarchy component store using SoA (Structure of Arrays) for performance.
+ *
+ * Uses a doubly-linked list for siblings and parent pointers for tree structure:
+ * - `parent`: Parent entity ID (0 = no parent, root level)
+ * - `firstChild`: First child entity in the children list
+ * - `nextSibling`: Next sibling in the parent's children list
+ * - `prevSibling`: Previous sibling in the parent's children list
+ * - `childCount`: Number of direct children
+ * - `depth`: Tree depth (0 = root level)
+ *
+ * @example
+ * ```typescript
+ * import { Hierarchy, appendChild, getChildren } from 'blecsd';
+ *
+ * appendChild(world, parent, child1);
+ * appendChild(world, parent, child2);
+ *
+ * const children = getChildren(world, parent);
+ * console.log(children); // [child1, child2]
+ * ```
+ */
+declare const Hierarchy: {
+    /** Parent entity ID (0 = no parent) */
+    parent: Uint32Array<ArrayBuffer>;
+    /** First child entity */
+    firstChild: Uint32Array<ArrayBuffer>;
+    /** Next sibling entity */
+    nextSibling: Uint32Array<ArrayBuffer>;
+    /** Previous sibling entity */
+    prevSibling: Uint32Array<ArrayBuffer>;
+    /** Number of children */
+    childCount: Uint16Array<ArrayBuffer>;
+    /** Tree depth (0 = root) */
+    depth: Uint16Array<ArrayBuffer>;
+};
+/**
+ * Hierarchy data returned by getHierarchy.
+ */
+interface HierarchyData {
+    readonly parent: Entity;
+    readonly firstChild: Entity;
+    readonly nextSibling: Entity;
+    readonly prevSibling: Entity;
+    readonly childCount: number;
+    readonly depth: number;
+}
+/**
+ * Sets the parent of an entity, removing it from any current parent.
+ *
+ * @param world - The ECS world
+ * @param child - The child entity
+ * @param parent - The new parent entity (0 or NULL_ENTITY for no parent)
+ * @returns The child entity for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setParent } from 'blecsd';
+ *
+ * setParent(world, child, parent);
+ * setParent(world, child, 0); // Make orphan
+ * ```
+ */
+declare function setParent(world: World, child: Entity, parent: Entity): Entity;
+/**
+ * Appends a child to a parent entity.
+ *
+ * @param world - The ECS world
+ * @param parent - The parent entity
+ * @param child - The child entity to append
+ * @returns The parent entity for chaining
+ *
+ * @example
+ * ```typescript
+ * import { appendChild } from 'blecsd';
+ *
+ * appendChild(world, parent, child1);
+ * appendChild(world, parent, child2);
+ * ```
+ */
+declare function appendChild(world: World, parent: Entity, child: Entity): Entity;
+/**
+ * Removes a child from a parent entity.
+ *
+ * @param world - The ECS world
+ * @param parent - The parent entity
+ * @param child - The child entity to remove
+ * @returns The parent entity for chaining
+ *
+ * @example
+ * ```typescript
+ * import { removeChild } from 'blecsd';
+ *
+ * removeChild(world, parent, child);
+ * ```
+ */
+declare function removeChild(world: World, parent: Entity, child: Entity): Entity;
+/**
+ * Gets all direct children of an entity.
+ *
+ * @param world - The ECS world
+ * @param parent - The parent entity
+ * @returns Array of child entities
+ *
+ * @example
+ * ```typescript
+ * import { getChildren } from 'blecsd';
+ *
+ * const children = getChildren(world, parent);
+ * for (const child of children) {
+ *   // Process child
+ * }
+ * ```
+ */
+declare function getChildren(world: World, parent: Entity): Entity[];
+/**
+ * Gets all ancestors of an entity (parent, grandparent, etc.).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns Array of ancestor entities (immediate parent first)
+ *
+ * @example
+ * ```typescript
+ * import { getAncestors } from 'blecsd';
+ *
+ * const ancestors = getAncestors(world, entity);
+ * const parent = ancestors[0];
+ * const grandparent = ancestors[1];
+ * ```
+ */
+declare function getAncestors(world: World, eid: Entity): Entity[];
+/**
+ * Gets all descendants of an entity (children, grandchildren, etc.).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns Array of descendant entities (depth-first order)
+ *
+ * @example
+ * ```typescript
+ * import { getDescendants } from 'blecsd';
+ *
+ * const descendants = getDescendants(world, entity);
+ * for (const desc of descendants) {
+ *   // Process descendant
+ * }
+ * ```
+ */
+declare function getDescendants(world: World, eid: Entity): Entity[];
+/**
+ * Gets the parent of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns Parent entity or NULL_ENTITY if no parent
+ *
+ * @example
+ * ```typescript
+ * import { getParent, NULL_ENTITY } from 'blecsd';
+ *
+ * const parent = getParent(world, entity);
+ * if (parent !== NULL_ENTITY) {
+ *   // Has a parent
+ * }
+ * ```
+ */
+declare function getParent(world: World, eid: Entity): Entity;
+/**
+ * Gets the hierarchy data of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns Hierarchy data or undefined if no Hierarchy component
+ */
+declare function getHierarchy(world: World, eid: Entity): HierarchyData | undefined;
+/**
+ * Checks if an entity has a Hierarchy component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns true if entity has Hierarchy component
+ */
+declare function hasHierarchy(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is a root (has no parent).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns true if entity has no parent
+ */
+declare function isRoot(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is a leaf (has no children).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns true if entity has no children
+ */
+declare function isLeaf(world: World, eid: Entity): boolean;
+/**
+ * Gets the depth of an entity in the tree.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns Tree depth (0 = root level)
+ */
+declare function getDepth(world: World, eid: Entity): number;
+/**
+ * Gets the next sibling of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns Next sibling entity or NULL_ENTITY
+ */
+declare function getNextSibling(world: World, eid: Entity): Entity;
+/**
+ * Gets the previous sibling of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns Previous sibling entity or NULL_ENTITY
+ */
+declare function getPrevSibling(world: World, eid: Entity): Entity;
+/**
+ * Prepends a child to a parent entity (inserts at the beginning).
+ *
+ * @param world - The ECS world
+ * @param parent - The parent entity
+ * @param child - The child entity to prepend
+ * @returns The parent entity for chaining
+ *
+ * @example
+ * ```typescript
+ * import { prepend, getChildren } from 'blecsd';
+ *
+ * appendChild(world, parent, child2);
+ * prepend(world, parent, child1);
+ * getChildren(world, parent); // [child1, child2]
+ * ```
+ */
+declare function prepend(world: World, parent: Entity, child: Entity): Entity;
+/**
+ * Inserts a child at a specific index in the parent's children list.
+ *
+ * @param world - The ECS world
+ * @param parent - The parent entity
+ * @param child - The child entity to insert
+ * @param index - The index to insert at (0 = first, negative counts from end)
+ * @returns The parent entity for chaining
+ *
+ * @example
+ * ```typescript
+ * import { insertAt, getChildren } from 'blecsd';
+ *
+ * appendChild(world, parent, child1);
+ * appendChild(world, parent, child3);
+ * insertAt(world, parent, child2, 1);
+ * getChildren(world, parent); // [child1, child2, child3]
+ * ```
+ */
+declare function insertAt(world: World, parent: Entity, child: Entity, index: number): Entity;
+/**
+ * Inserts a child before a sibling entity.
+ *
+ * @param world - The ECS world
+ * @param child - The child entity to insert
+ * @param sibling - The sibling to insert before
+ * @returns The child entity for chaining
+ *
+ * @example
+ * ```typescript
+ * import { insertBefore, getChildren } from 'blecsd';
+ *
+ * appendChild(world, parent, child1);
+ * appendChild(world, parent, child3);
+ * insertBefore(world, child2, child3);
+ * getChildren(world, parent); // [child1, child2, child3]
+ * ```
+ */
+declare function insertBefore(world: World, child: Entity, sibling: Entity): Entity;
+/**
+ * Inserts a child after a sibling entity.
+ *
+ * @param world - The ECS world
+ * @param child - The child entity to insert
+ * @param sibling - The sibling to insert after
+ * @returns The child entity for chaining
+ *
+ * @example
+ * ```typescript
+ * import { insertAfter, getChildren } from 'blecsd';
+ *
+ * appendChild(world, parent, child1);
+ * appendChild(world, parent, child3);
+ * insertAfter(world, child2, child1);
+ * getChildren(world, parent); // [child1, child2, child3]
+ * ```
+ */
+declare function insertAfter(world: World, child: Entity, sibling: Entity): Entity;
+/**
+ * Detaches an entity from its parent.
+ * Convenience method equivalent to setParent(world, eid, NULL_ENTITY).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity to detach
+ * @returns The entity for chaining
+ *
+ * @example
+ * ```typescript
+ * import { detach, getParent, NULL_ENTITY } from 'blecsd';
+ *
+ * appendChild(world, parent, child);
+ * detach(world, child);
+ * getParent(world, child); // NULL_ENTITY
+ * ```
+ */
+declare function detach(world: World, eid: Entity): Entity;
+/**
+ * Gets the last child of an entity.
+ *
+ * @param world - The ECS world
+ * @param parent - The parent entity
+ * @returns Last child entity or NULL_ENTITY
+ *
+ * @example
+ * ```typescript
+ * import { getLastChild, NULL_ENTITY } from 'blecsd';
+ *
+ * const lastChild = getLastChild(world, parent);
+ * if (lastChild !== NULL_ENTITY) {
+ *   // Process last child
+ * }
+ * ```
+ */
+declare function getLastChild(world: World, parent: Entity): Entity;
+/**
+ * Gets the first child of an entity.
+ *
+ * @param world - The ECS world
+ * @param parent - The parent entity
+ * @returns First child entity or NULL_ENTITY
+ *
+ * @example
+ * ```typescript
+ * import { getFirstChild, NULL_ENTITY } from 'blecsd';
+ *
+ * const firstChild = getFirstChild(world, parent);
+ * if (firstChild !== NULL_ENTITY) {
+ *   // Process first child
+ * }
+ * ```
+ */
+declare function getFirstChild(world: World, parent: Entity): Entity;
+/**
+ * Gets the index of a child within its parent's children list.
+ *
+ * @param world - The ECS world
+ * @param child - The child entity
+ * @returns Index (0-based) or -1 if not a child
+ *
+ * @example
+ * ```typescript
+ * import { getChildIndex } from 'blecsd';
+ *
+ * appendChild(world, parent, child1);
+ * appendChild(world, parent, child2);
+ * getChildIndex(world, child1); // 0
+ * getChildIndex(world, child2); // 1
+ * ```
+ */
+declare function getChildIndex(world: World, child: Entity): number;
+/**
+ * Gets a child at a specific index.
+ *
+ * @param world - The ECS world
+ * @param parent - The parent entity
+ * @param index - The index (0-based)
+ * @returns Child entity or NULL_ENTITY if out of bounds
+ *
+ * @example
+ * ```typescript
+ * import { getChildAt, NULL_ENTITY } from 'blecsd';
+ *
+ * appendChild(world, parent, child1);
+ * appendChild(world, parent, child2);
+ * getChildAt(world, parent, 0); // child1
+ * getChildAt(world, parent, 1); // child2
+ * getChildAt(world, parent, 5); // NULL_ENTITY
+ * ```
+ */
+declare function getChildAt(world: World, parent: Entity, index: number): Entity;
+/**
+ * Callback function for tree traversal.
+ * Return `false` to stop traversal early.
+ */
+type TraversalCallback = (entity: Entity, depth: number) => boolean | undefined;
+/**
+ * Iterates over all descendants of an entity, calling a callback for each.
+ * Uses depth-first traversal order.
+ *
+ * @param world - The ECS world
+ * @param eid - The root entity (not included in iteration)
+ * @param callback - Function called for each descendant. Return false to stop.
+ * @returns true if traversal completed, false if stopped early
+ *
+ * @example
+ * ```typescript
+ * import { forDescendants } from 'blecsd';
+ *
+ * // Process all descendants
+ * forDescendants(world, root, (entity, depth) => {
+ *   console.log(`Entity ${entity} at depth ${depth}`);
+ * });
+ *
+ * // Stop early when condition met
+ * forDescendants(world, root, (entity) => {
+ *   if (entity === target) return false; // stop
+ * });
+ * ```
+ */
+declare function forDescendants(world: World, eid: Entity, callback: TraversalCallback): boolean;
+/**
+ * Iterates over all ancestors of an entity, calling a callback for each.
+ * Starts with the immediate parent and works up to the root.
+ *
+ * @param world - The ECS world
+ * @param eid - The starting entity (not included in iteration)
+ * @param callback - Function called for each ancestor. Return false to stop.
+ * @returns true if traversal completed, false if stopped early
+ *
+ * @example
+ * ```typescript
+ * import { forAncestors } from 'blecsd';
+ *
+ * // Process all ancestors
+ * forAncestors(world, entity, (ancestor, level) => {
+ *   console.log(`Ancestor ${ancestor} at level ${level}`);
+ * });
+ *
+ * // Find first ancestor matching condition
+ * let found: Entity | null = null;
+ * forAncestors(world, entity, (ancestor) => {
+ *   if (hasComponent(world, ancestor, SomeComponent)) {
+ *     found = ancestor;
+ *     return false; // stop
+ *   }
+ * });
+ * ```
+ */
+declare function forAncestors(world: World, eid: Entity, callback: TraversalCallback): boolean;
+/**
+ * Checks if an entity is a descendant of another.
+ *
+ * @param world - The ECS world
+ * @param ancestor - The potential ancestor entity
+ * @param descendant - The potential descendant entity
+ * @returns true if descendant is a descendant of ancestor
+ *
+ * @example
+ * ```typescript
+ * import { hasDescendant } from 'blecsd';
+ *
+ * if (hasDescendant(world, container, widget)) {
+ *   console.log('widget is inside container');
+ * }
+ * ```
+ */
+declare function hasDescendant(world: World, ancestor: Entity, descendant: Entity): boolean;
+/**
+ * Checks if an entity is an ancestor of another.
+ *
+ * @param world - The ECS world
+ * @param descendant - The potential descendant entity
+ * @param ancestor - The potential ancestor entity
+ * @returns true if ancestor is an ancestor of descendant
+ *
+ * @example
+ * ```typescript
+ * import { hasAncestor } from 'blecsd';
+ *
+ * if (hasAncestor(world, widget, container)) {
+ *   console.log('widget is inside container');
+ * }
+ * ```
+ */
+declare function hasAncestor(world: World, descendant: Entity, ancestor: Entity): boolean;
+/**
+ * Gets the root ancestor of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns The root ancestor, or the entity itself if it has no parent
+ *
+ * @example
+ * ```typescript
+ * import { getRoot } from 'blecsd';
+ *
+ * const root = getRoot(world, deeplyNestedEntity);
+ * // root is the topmost ancestor
+ * ```
+ */
+declare function getRoot(world: World, eid: Entity): Entity;
+/**
+ * Gets the common ancestor of two entities.
+ *
+ * @param world - The ECS world
+ * @param a - First entity
+ * @param b - Second entity
+ * @returns The common ancestor, or NULL_ENTITY if none exists
+ *
+ * @example
+ * ```typescript
+ * import { getCommonAncestor, NULL_ENTITY } from 'blecsd';
+ *
+ * const common = getCommonAncestor(world, entityA, entityB);
+ * if (common !== NULL_ENTITY) {
+ *   console.log('Found common ancestor:', common);
+ * }
+ * ```
+ */
+declare function getCommonAncestor(world: World, a: Entity, b: Entity): Entity;
+/**
+ * Gets all siblings of an entity (excluding itself).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity
+ * @returns Array of sibling entities
+ *
+ * @example
+ * ```typescript
+ * import { getSiblings } from 'blecsd';
+ *
+ * const siblings = getSiblings(world, entity);
+ * console.log(`Entity has ${siblings.length} siblings`);
+ * ```
+ */
+declare function getSiblings(world: World, eid: Entity): Entity[];
+
+/**
+ * Position component for entity positioning in the terminal grid.
+ * @module components/position
+ */
+
+/**
+ * Position component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `x`, `y`: Coordinates in the terminal grid (floats for smooth movement)
+ * - `z`: Z-index for layering (higher values render on top)
+ * - `absolute`: 0 = position relative to parent, 1 = absolute screen position
+ *
+ * @example
+ * ```typescript
+ * import { Position, setPosition, getPosition } from 'blecsd';
+ *
+ * // Position is automatically added when using setPosition
+ * setPosition(world, entity, 10, 5);
+ *
+ * // Get current position
+ * const pos = getPosition(world, entity);
+ * console.log(pos.x, pos.y); // 10, 5
+ * ```
+ */
+declare const Position: {
+    /** X coordinate in terminal cells */
+    x: Float32Array<ArrayBuffer>;
+    /** Y coordinate in terminal cells */
+    y: Float32Array<ArrayBuffer>;
+    /** Z-index for layering (0-65535) */
+    z: Uint16Array<ArrayBuffer>;
+    /** 0 = relative to parent, 1 = absolute screen position */
+    absolute: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Position data returned by getPosition.
+ */
+interface PositionData {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly absolute: boolean;
+}
+/**
+ * Sets the position of an entity.
+ * Adds the Position component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param z - Z-index for layering (default: 0)
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setPosition } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * // Set position
+ * setPosition(world, entity, 10, 5);
+ *
+ * // With z-index
+ * setPosition(world, entity, 10, 5, 100);
+ * ```
+ */
+declare function setPosition(world: World, eid: Entity, x: number, y: number, z?: number): Entity;
+/**
+ * Gets the position data of an entity.
+ * Returns undefined if the entity doesn't have a Position component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Position data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getPosition } from 'blecsd';
+ *
+ * const pos = getPosition(world, entity);
+ * if (pos) {
+ *   console.log(`Entity at (${pos.x}, ${pos.y}) z=${pos.z}`);
+ * }
+ * ```
+ */
+declare function getPosition(world: World, eid: Entity): PositionData | undefined;
+/**
+ * Sets whether the entity uses absolute positioning.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param absolute - true for absolute, false for relative to parent
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setAbsolute } from 'blecsd';
+ *
+ * // Make entity use absolute screen coordinates
+ * setAbsolute(world, entity, true);
+ * ```
+ */
+declare function setAbsolute(world: World, eid: Entity, absolute: boolean): Entity;
+/**
+ * Checks if an entity uses absolute positioning.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if absolute, false if relative or no Position component
+ *
+ * @example
+ * ```typescript
+ * import { isAbsolute } from 'blecsd';
+ *
+ * if (isAbsolute(world, entity)) {
+ *   // Use screen coordinates directly
+ * }
+ * ```
+ */
+declare function isAbsolute(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity has a Position component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Position component
+ *
+ * @example
+ * ```typescript
+ * import { hasPosition } from 'blecsd';
+ *
+ * if (hasPosition(world, entity)) {
+ *   // Safe to call getPosition
+ * }
+ * ```
+ */
+declare function hasPosition(world: World, eid: Entity): boolean;
+/**
+ * Moves an entity by a delta amount.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param dx - Delta X (added to current x)
+ * @param dy - Delta Y (added to current y)
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { moveBy } from 'blecsd';
+ *
+ * // Move entity 1 cell right, 2 cells down
+ * moveBy(world, entity, 1, 2);
+ * ```
+ */
+declare function moveBy(world: World, eid: Entity, dx: number, dy: number): Entity;
+/**
+ * Sets the z-index of an entity for layering.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param z - Z-index (0-65535, higher = on top)
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setZIndex } from 'blecsd';
+ *
+ * // Bring entity to front
+ * setZIndex(world, entity, 1000);
+ * ```
+ */
+declare function setZIndex(world: World, eid: Entity, z: number): Entity;
+/**
+ * Gets the z-index of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Z-index value, or 0 if no Position component
+ *
+ * @example
+ * ```typescript
+ * import { getZIndex } from 'blecsd';
+ *
+ * const z = getZIndex(world, entity);
+ * console.log(`Entity z-index: ${z}`);
+ * ```
+ */
+declare function getZIndex(world: World, eid: Entity): number;
+/**
+ * Brings an entity to the front of a set of entities.
+ * Sets the z-index to one more than the maximum in the provided array.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity to bring to front
+ * @param siblings - Array of sibling entities to compare against
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { bringToFront, getSiblings } from 'blecsd';
+ *
+ * // Bring entity to front of its siblings
+ * const siblings = getSiblings(world, entity);
+ * bringToFront(world, entity, siblings);
+ * ```
+ */
+declare function bringToFront(world: World, eid: Entity, siblings: readonly Entity[]): Entity;
+/**
+ * Sends an entity to the back of a set of entities.
+ * Sets the z-index to one less than the minimum in the provided array.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity to send to back
+ * @param siblings - Array of sibling entities to compare against
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { sendToBack, getSiblings } from 'blecsd';
+ *
+ * // Send entity to back of its siblings
+ * const siblings = getSiblings(world, entity);
+ * sendToBack(world, entity, siblings);
+ * ```
+ */
+declare function sendToBack(world: World, eid: Entity, siblings: readonly Entity[]): Entity;
+/**
+ * Moves an entity one step forward in z-order among siblings.
+ * Finds the next higher z-index and sets this entity above it.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity to move forward
+ * @param siblings - Array of sibling entities
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { moveForward, getSiblings } from 'blecsd';
+ *
+ * const siblings = getSiblings(world, entity);
+ * moveForward(world, entity, siblings);
+ * ```
+ */
+declare function moveForward(world: World, eid: Entity, siblings: readonly Entity[]): Entity;
+/**
+ * Moves an entity one step backward in z-order among siblings.
+ * Finds the next lower z-index and sets this entity below it.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity to move backward
+ * @param siblings - Array of sibling entities
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { moveBackward, getSiblings } from 'blecsd';
+ *
+ * const siblings = getSiblings(world, entity);
+ * moveBackward(world, entity, siblings);
+ * ```
+ */
+declare function moveBackward(world: World, eid: Entity, siblings: readonly Entity[]): Entity;
+/**
+ * Normalizes z-indices of a set of entities.
+ * Reassigns z-indices to sequential values starting from 0.
+ * Useful after many front/back operations to prevent z-index overflow.
+ *
+ * @param world - The ECS world
+ * @param entities - Entities to normalize
+ *
+ * @example
+ * ```typescript
+ * import { normalizeZIndices, getSiblings } from 'blecsd';
+ *
+ * // After many z-order changes, normalize indices
+ * const siblings = getSiblings(world, parent);
+ * normalizeZIndices(world, siblings);
+ * ```
+ */
+declare function normalizeZIndices(world: World, entities: readonly Entity[]): void;
+/**
+ * Swaps the z-indices of two entities.
+ *
+ * @param world - The ECS world
+ * @param a - First entity
+ * @param b - Second entity
+ *
+ * @example
+ * ```typescript
+ * import { swapZIndex } from 'blecsd';
+ *
+ * // Swap z-order of two entities
+ * swapZIndex(world, entityA, entityB);
+ * ```
+ */
+declare function swapZIndex(world: World, a: Entity, b: Entity): void;
+/**
+ * Position keyword type for alignment shortcuts.
+ */
+type PositionKeyword = 'center' | 'top-left' | 'tl' | 'top-right' | 'tr' | 'bottom-left' | 'bl' | 'bottom-right' | 'br';
+/**
+ * Sets entity position using a keyword for quick alignment.
+ * Requires parent with Dimensions component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param keyword - Position keyword
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setPositionKeyword } from 'blecsd';
+ *
+ * // Center within parent
+ * setPositionKeyword(world, dialog, 'center');
+ *
+ * // Top-left corner
+ * setPositionKeyword(world, logo, 'top-left');
+ *
+ * // Bottom-right corner
+ * setPositionKeyword(world, statusBar, 'bottom-right');
+ * ```
+ */
+declare function setPositionKeyword(world: World, eid: Entity, keyword: PositionKeyword): Entity;
+/**
+ * Sets entity position using percentage of parent size.
+ * Requires parent with Dimensions component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param xPercent - X position as percentage (0-100)
+ * @param yPercent - Y position as percentage (0-100)
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setPositionPercent } from 'blecsd';
+ *
+ * // Center horizontally, 25% from top
+ * setPositionPercent(world, header, 50, 25);
+ *
+ * // Bottom-right quadrant
+ * setPositionPercent(world, footer, 75, 75);
+ * ```
+ */
+declare function setPositionPercent(world: World, eid: Entity, xPercent: number, yPercent: number): Entity;
+
+/**
+ * Velocity and Acceleration components for entity movement.
+ * @module components/velocity
+ */
+
+/**
+ * Velocity component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `x`, `y`: Velocity in cells per second
+ * - `maxSpeed`: Maximum speed (0 = unlimited)
+ * - `friction`: Friction factor 0-1 (0 = no friction, 1 = instant stop)
+ *
+ * @example
+ * ```typescript
+ * import { Velocity, setVelocity, getVelocity } from 'blecsd';
+ *
+ * // Set entity velocity
+ * setVelocity(world, entity, 5, 0); // Move right at 5 cells/sec
+ *
+ * // Get current velocity
+ * const vel = getVelocity(world, entity);
+ * console.log(`Speed: ${Math.sqrt(vel.x*vel.x + vel.y*vel.y)}`);
+ * ```
+ */
+declare const Velocity: {
+    /** X velocity in cells per second */
+    x: Float32Array<ArrayBuffer>;
+    /** Y velocity in cells per second */
+    y: Float32Array<ArrayBuffer>;
+    /** Maximum speed (0 = unlimited) */
+    maxSpeed: Float32Array<ArrayBuffer>;
+    /** Friction factor (0-1, 0 = no friction) */
+    friction: Float32Array<ArrayBuffer>;
+};
+/**
+ * Velocity data returned by getVelocity.
+ */
+interface VelocityData {
+    readonly x: number;
+    readonly y: number;
+    readonly maxSpeed: number;
+    readonly friction: number;
+}
+/**
+ * Options for setting velocity.
+ */
+interface VelocityOptions {
+    /** X velocity in cells per second */
+    x?: number;
+    /** Y velocity in cells per second */
+    y?: number;
+    /** Maximum speed (0 = unlimited) */
+    maxSpeed?: number;
+    /** Friction factor (0-1) */
+    friction?: number;
+}
+/**
+ * Sets the velocity of an entity.
+ * Adds the Velocity component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param x - X velocity in cells per second
+ * @param y - Y velocity in cells per second
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setVelocity, setPosition } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * setPosition(world, entity, 10, 10);
+ * setVelocity(world, entity, 5, -2); // Right 5, up 2 cells/sec
+ * ```
+ */
+declare function setVelocity(world: World, eid: Entity, x: number, y: number): Entity;
+/**
+ * Sets velocity with options.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Velocity options
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setVelocityOptions } from 'blecsd';
+ *
+ * setVelocityOptions(world, entity, {
+ *   x: 5,
+ *   y: 0,
+ *   maxSpeed: 10,
+ *   friction: 0.1,
+ * });
+ * ```
+ */
+declare function setVelocityOptions(world: World, eid: Entity, options: VelocityOptions): Entity;
+/**
+ * Gets the velocity data of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Velocity data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getVelocity } from 'blecsd';
+ *
+ * const vel = getVelocity(world, entity);
+ * if (vel) {
+ *   const speed = Math.sqrt(vel.x * vel.x + vel.y * vel.y);
+ *   console.log(`Moving at ${speed} cells/sec`);
+ * }
+ * ```
+ */
+declare function getVelocity(world: World, eid: Entity): VelocityData | undefined;
+/**
+ * Checks if an entity has a Velocity component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Velocity component
+ */
+declare function hasVelocity(world: World, eid: Entity): boolean;
+/**
+ * Sets the maximum speed for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param maxSpeed - Maximum speed (0 = unlimited)
+ * @returns The entity ID for chaining
+ */
+declare function setMaxSpeed(world: World, eid: Entity, maxSpeed: number): Entity;
+/**
+ * Sets the friction for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param friction - Friction factor (0-1)
+ * @returns The entity ID for chaining
+ */
+declare function setFriction(world: World, eid: Entity, friction: number): Entity;
+/**
+ * Adds to current velocity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param dx - Delta X velocity
+ * @param dy - Delta Y velocity
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { addVelocity } from 'blecsd';
+ *
+ * // Apply impulse
+ * addVelocity(world, entity, 0, -10); // Jump impulse
+ * ```
+ */
+declare function addVelocity(world: World, eid: Entity, dx: number, dy: number): Entity;
+/**
+ * Gets the current speed (magnitude of velocity).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Current speed or 0 if no velocity component
+ */
+declare function getSpeed(world: World, eid: Entity): number;
+/**
+ * Stops an entity (sets velocity to zero).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function stopEntity(world: World, eid: Entity): Entity;
+/**
+ * Removes velocity from an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function removeVelocity(world: World, eid: Entity): Entity;
+/**
+ * Acceleration component store using SoA (Structure of Arrays) for performance.
+ *
+ * Acceleration is applied to velocity each frame.
+ *
+ * @example
+ * ```typescript
+ * import { Acceleration, setAcceleration, getAcceleration } from 'blecsd';
+ *
+ * // Set gravity
+ * setAcceleration(world, entity, 0, 9.8); // Gravity down
+ *
+ * // Get current acceleration
+ * const accel = getAcceleration(world, entity);
+ * ```
+ */
+declare const Acceleration: {
+    /** X acceleration in cells per second squared */
+    x: Float32Array<ArrayBuffer>;
+    /** Y acceleration in cells per second squared */
+    y: Float32Array<ArrayBuffer>;
+};
+/**
+ * Acceleration data returned by getAcceleration.
+ */
+interface AccelerationData {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Sets the acceleration of an entity.
+ * Adds the Acceleration component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param x - X acceleration in cells per second squared
+ * @param y - Y acceleration in cells per second squared
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setAcceleration } from 'blecsd';
+ *
+ * // Apply gravity
+ * setAcceleration(world, entity, 0, 20);
+ *
+ * // Apply thrust
+ * setAcceleration(world, player, thrustX, thrustY);
+ * ```
+ */
+declare function setAcceleration(world: World, eid: Entity, x: number, y: number): Entity;
+/**
+ * Gets the acceleration data of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Acceleration data or undefined
+ */
+declare function getAcceleration(world: World, eid: Entity): AccelerationData | undefined;
+/**
+ * Checks if an entity has an Acceleration component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Acceleration component
+ */
+declare function hasAcceleration(world: World, eid: Entity): boolean;
+/**
+ * Clears acceleration (sets to zero).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function clearAcceleration(world: World, eid: Entity): Entity;
+/**
+ * Removes acceleration from an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function removeAcceleration(world: World, eid: Entity): Entity;
+/**
+ * Applies acceleration to velocity for a single entity.
+ *
+ * @param eid - The entity ID
+ * @param deltaTime - Time elapsed in seconds
+ */
+declare function applyAccelerationToEntity(eid: Entity, deltaTime: number): void;
+/**
+ * Applies friction to velocity for a single entity.
+ *
+ * @param eid - The entity ID
+ * @param deltaTime - Time elapsed in seconds
+ */
+declare function applyFrictionToEntity(eid: Entity, deltaTime: number): void;
+/**
+ * Clamps velocity to max speed for a single entity.
+ *
+ * @param eid - The entity ID
+ */
+declare function clampSpeedForEntity(eid: Entity): void;
+/**
+ * Applies velocity to position for a single entity.
+ *
+ * @param eid - The entity ID
+ * @param deltaTime - Time elapsed in seconds
+ */
+declare function applyVelocityToEntity(eid: Entity, deltaTime: number): void;
+/**
+ * Updates movement for a single entity (full update cycle).
+ * Applies: acceleration -> velocity -> friction -> clamp -> position.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param deltaTime - Time elapsed in seconds
+ *
+ * @example
+ * ```typescript
+ * import { updateEntityMovement } from 'blecsd';
+ *
+ * // Manual movement update
+ * updateEntityMovement(world, entity, 0.016);
+ * ```
+ */
+declare function updateEntityMovement(world: World, eid: Entity, deltaTime: number): void;
+
+/**
+ * Interactive component for mouse/keyboard interaction.
+ * @module components/interactive
+ */
+/** Default hover effect foreground color (white) */
+declare const DEFAULT_HOVER_FG = 4294967295;
+/** Default hover effect background color (transparent) */
+declare const DEFAULT_HOVER_BG = 0;
+/**
+ * Interactive component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `clickable`: Whether entity responds to clicks (0=no, 1=yes)
+ * - `draggable`: Whether entity can be dragged (0=no, 1=yes)
+ * - `hoverable`: Whether entity responds to hover (0=no, 1=yes)
+ * - `hovered`: Current hover state (0=no, 1=yes)
+ * - `pressed`: Current pressed state (0=no, 1=yes)
+ * - `keyable`: Whether entity receives key events (0=no, 1=yes)
+ * - `hoverEffectFg`, `hoverEffectBg`: Colors for hover effect
+ *
+ * @example
+ * ```typescript
+ * import { Interactive, setClickable, isHovered, isPressed } from 'blecsd';
+ *
+ * setInteractive(world, entity, { clickable: true, hoverable: true });
+ *
+ * if (isHovered(world, entity)) {
+ *   console.log('Mouse over entity');
+ * }
+ * ```
+ */
+declare const Interactive: {
+    /** Whether entity responds to clicks (0=no, 1=yes) */
+    clickable: Uint8Array<ArrayBuffer>;
+    /** Whether entity can be dragged (0=no, 1=yes) */
+    draggable: Uint8Array<ArrayBuffer>;
+    /** Whether entity responds to hover (0=no, 1=yes) */
+    hoverable: Uint8Array<ArrayBuffer>;
+    /** Current hover state (0=no, 1=yes) */
+    hovered: Uint8Array<ArrayBuffer>;
+    /** Current pressed state (0=no, 1=yes) */
+    pressed: Uint8Array<ArrayBuffer>;
+    /** Whether entity receives key events (0=no, 1=yes) */
+    keyable: Uint8Array<ArrayBuffer>;
+    /** Whether entity can receive focus (0=no, 1=yes) */
+    focusable: Uint8Array<ArrayBuffer>;
+    /** Current focus state (0=no, 1=yes) */
+    focused: Uint8Array<ArrayBuffer>;
+    /** Tab index for focus order (-1=skip, 0+=order) */
+    tabIndex: Int16Array<ArrayBuffer>;
+    /** Whether entity is enabled (0=disabled, 1=enabled) */
+    enabled: Uint8Array<ArrayBuffer>;
+    /** Hover effect foreground color */
+    hoverEffectFg: Uint32Array<ArrayBuffer>;
+    /** Hover effect background color */
+    hoverEffectBg: Uint32Array<ArrayBuffer>;
+    /** Focus effect foreground color */
+    focusEffectFg: Uint32Array<ArrayBuffer>;
+    /** Focus effect background color */
+    focusEffectBg: Uint32Array<ArrayBuffer>;
+};
+/**
+ * Interactive configuration options.
+ */
+interface InteractiveOptions {
+    /** Whether entity responds to clicks */
+    clickable?: boolean;
+    /** Whether entity can be dragged */
+    draggable?: boolean;
+    /** Whether entity responds to hover */
+    hoverable?: boolean;
+    /** Whether entity receives key events */
+    keyable?: boolean;
+    /** Whether entity can receive focus */
+    focusable?: boolean;
+    /** Tab index for focus order (-1=skip, 0+=order) */
+    tabIndex?: number;
+    /** Whether entity is enabled (can receive input/focus) */
+    enabled?: boolean;
+    /** Hover effect foreground color */
+    hoverEffectFg?: number;
+    /** Hover effect background color */
+    hoverEffectBg?: number;
+    /** Focus effect foreground color */
+    focusEffectFg?: number;
+    /** Focus effect background color */
+    focusEffectBg?: number;
+}
+/**
+ * Interactive data returned by getInteractive.
+ */
+interface InteractiveData {
+    readonly clickable: boolean;
+    readonly draggable: boolean;
+    readonly hoverable: boolean;
+    readonly hovered: boolean;
+    readonly pressed: boolean;
+    readonly enabled: boolean;
+    readonly keyable: boolean;
+    readonly focusable: boolean;
+    readonly focused: boolean;
+    readonly tabIndex: number;
+    readonly hoverEffectFg: number;
+    readonly hoverEffectBg: number;
+    readonly focusEffectFg: number;
+    readonly focusEffectBg: number;
+}
+
+/**
+ * Interactive system for managing mouse/keyboard interaction state.
+ * @module systems/interactiveSystem
+ */
+
+/**
+ * Makes an entity interactive with the given options.
+ * Adds the Interactive component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Interactive configuration options
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setInteractive } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * setInteractive(world, entity, {
+ *   clickable: true,
+ *   hoverable: true,
+ *   hoverEffectBg: 0x333333ff,
+ * });
+ * ```
+ */
+declare function setInteractive(world: World, eid: Entity, options: InteractiveOptions): Entity;
+/**
+ * Sets whether an entity is clickable.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param clickable - Whether entity responds to clicks
+ * @returns The entity ID for chaining
+ */
+declare function setClickable(world: World, eid: Entity, clickable: boolean): Entity;
+/**
+ * Sets whether an entity is draggable.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param draggable - Whether entity can be dragged
+ * @returns The entity ID for chaining
+ */
+declare function setDraggable(world: World, eid: Entity, draggable: boolean): Entity;
+/**
+ * Sets whether an entity is hoverable.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param hoverable - Whether entity responds to hover
+ * @returns The entity ID for chaining
+ */
+declare function setHoverable(world: World, eid: Entity, hoverable: boolean): Entity;
+/**
+ * Sets whether an entity receives key events.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param keyable - Whether entity receives key events
+ * @returns The entity ID for chaining
+ */
+declare function setKeyable(world: World, eid: Entity, keyable: boolean): Entity;
+/**
+ * Checks if an entity is currently hovered.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is hovered
+ *
+ * @example
+ * ```typescript
+ * import { isHovered } from 'blecsd';
+ *
+ * if (isHovered(world, entity)) {
+ *   // Apply hover styling
+ * }
+ * ```
+ */
+declare function isHovered(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is currently pressed.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is pressed
+ *
+ * @example
+ * ```typescript
+ * import { isPressed } from 'blecsd';
+ *
+ * if (isPressed(world, entity)) {
+ *   // Apply pressed styling
+ * }
+ * ```
+ */
+declare function isPressed(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is clickable.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is clickable
+ */
+declare function isClickable(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is draggable.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is draggable
+ */
+declare function isDraggable(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is hoverable.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is hoverable
+ */
+declare function isHoverable(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity receives key events.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity receives key events
+ */
+declare function isKeyable(world: World, eid: Entity): boolean;
+/**
+ * Sets the hover state of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param hovered - Whether entity is hovered
+ * @returns The entity ID for chaining
+ */
+declare function setHovered(world: World, eid: Entity, hovered: boolean): Entity;
+/**
+ * Sets the pressed state of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param pressed - Whether entity is pressed
+ * @returns The entity ID for chaining
+ */
+declare function setPressed(world: World, eid: Entity, pressed: boolean): Entity;
+/**
+ * Sets the focus state of an entity.
+ * Note: This only sets the component state. Use the focus system for
+ * proper focus management with events.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param focused - Whether entity is focused
+ * @returns The entity ID for chaining
+ */
+declare function setFocusedState(world: World, eid: Entity, focused: boolean): Entity;
+/**
+ * Gets the focus effect colors.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Focus effect colors or undefined
+ */
+declare function getFocusEffect(world: World, eid: Entity): {
+    fg: number;
+    bg: number;
+} | undefined;
+/**
+ * Sets the focus effect colors.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param fg - Focus effect foreground color
+ * @param bg - Focus effect background color
+ * @returns The entity ID for chaining
+ */
+declare function setFocusEffect(world: World, eid: Entity, fg: number, bg: number): Entity;
+/**
+ * Gets the interactive data of an entity.
+ * Returns undefined if no Interactive component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Interactive data or undefined
+ */
+declare function getInteractive(world: World, eid: Entity): InteractiveData | undefined;
+/**
+ * Checks if an entity has an Interactive component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Interactive component
+ */
+declare function hasInteractive(world: World, eid: Entity): boolean;
+/**
+ * Clears the hover and pressed states of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function clearInteractionState(world: World, eid: Entity): Entity;
+/**
+ * Enables mouse events on an entity.
+ * Sets clickable and hoverable to true.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { enableMouse, isClickable, isHoverable } from 'blecsd';
+ *
+ * enableMouse(world, button);
+ *
+ * isClickable(world, button); // true
+ * isHoverable(world, button); // true
+ * ```
+ */
+declare function enableMouse(world: World, eid: Entity): Entity;
+/**
+ * Disables mouse events on an entity.
+ * Sets clickable and hoverable to false.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { enableMouse, disableMouse, isClickable } from 'blecsd';
+ *
+ * enableMouse(world, button);
+ * disableMouse(world, button);
+ *
+ * isClickable(world, button); // false
+ * ```
+ */
+declare function disableMouse(world: World, eid: Entity): Entity;
+/**
+ * Enables key events on an entity.
+ * Sets keyable to true.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { enableKeys, isKeyable } from 'blecsd';
+ *
+ * enableKeys(world, textInput);
+ *
+ * isKeyable(world, textInput); // true
+ * ```
+ */
+declare function enableKeys(world: World, eid: Entity): Entity;
+/**
+ * Disables key events on an entity.
+ * Sets keyable to false.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { enableKeys, disableKeys, isKeyable } from 'blecsd';
+ *
+ * enableKeys(world, textInput);
+ * disableKeys(world, textInput);
+ *
+ * isKeyable(world, textInput); // false
+ * ```
+ */
+declare function disableKeys(world: World, eid: Entity): Entity;
+/**
+ * Enables all input (mouse and keys) on an entity.
+ * Sets clickable, hoverable, and keyable to true.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { enableInput, isClickable, isHoverable, isKeyable } from 'blecsd';
+ *
+ * enableInput(world, widget);
+ *
+ * isClickable(world, widget); // true
+ * isHoverable(world, widget); // true
+ * isKeyable(world, widget);   // true
+ * ```
+ */
+declare function enableInput(world: World, eid: Entity): Entity;
+/**
+ * Disables all input (mouse and keys) on an entity.
+ * Sets clickable, hoverable, and keyable to false.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { enableInput, disableInput, isClickable } from 'blecsd';
+ *
+ * enableInput(world, widget);
+ * disableInput(world, widget);
+ *
+ * isClickable(world, widget); // false
+ * ```
+ */
+declare function disableInput(world: World, eid: Entity): Entity;
+/**
+ * Checks if an entity has mouse input enabled.
+ * Returns true if either clickable or hoverable is enabled.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if mouse input is enabled
+ */
+declare function hasMouseEnabled(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity has key input enabled.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if key input is enabled
+ */
+declare function hasKeysEnabled(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity has any input enabled (mouse or keys).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if any input is enabled
+ */
+declare function hasInputEnabled(world: World, eid: Entity): boolean;
+/**
+ * Enables an entity, allowing it to receive input and focus.
+ * Disabled entities are skipped in focus traversal and ignore input.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { enable, disable, isEnabled } from 'blecsd';
+ *
+ * // Disable a button temporarily
+ * disable(world, button);
+ *
+ * // Re-enable it later
+ * enable(world, button);
+ * ```
+ */
+declare function enable(world: World, eid: Entity): Entity;
+/**
+ * Disables an entity, preventing it from receiving input and focus.
+ * Disabled entities are skipped in focus traversal and ignore input.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { enable, disable, isEnabled } from 'blecsd';
+ *
+ * // Disable a form field while loading
+ * disable(world, formField);
+ *
+ * // Re-enable when ready
+ * enable(world, formField);
+ * ```
+ */
+declare function disable(world: World, eid: Entity): Entity;
+/**
+ * Checks if an entity is enabled.
+ * Disabled entities cannot receive input or focus.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is enabled (default: true)
+ *
+ * @example
+ * ```typescript
+ * import { isEnabled, disable } from 'blecsd';
+ *
+ * if (isEnabled(world, button)) {
+ *   // Process click
+ * } else {
+ *   // Show disabled styling
+ * }
+ * ```
+ */
+declare function isEnabled(world: World, eid: Entity): boolean;
+
+export { detach as $, setTextAlign as A, setTextVAlign as B, setTextWrap as C, setParseTags as D, isParsingTags as E, isTextWrapped as F, getFocusable as G, hasFocusable as H, setFocusable as I, focus as J, blur as K, isFocusable as L, isFocused as M, makeFocusable as N, getFocusedEntity as O, Position as P, getTabIndex as Q, setTabIndex as R, getTabOrder as S, TextAlign as T, isInTabOrder as U, Velocity as V, resetFocusState as W, getHierarchy as X, hasHierarchy as Y, appendChild as Z, removeChild as _, disableKeys as a, setVelocityOptions as a$, setParent as a0, insertAt as a1, insertBefore as a2, insertAfter as a3, getParent as a4, getChildren as a5, getFirstChild as a6, getLastChild as a7, getChildAt as a8, getChildIndex as a9, setDraggable as aA, isHoverable as aB, setHoverable as aC, isKeyable as aD, setKeyable as aE, isHovered as aF, setHovered as aG, isPressed as aH, setPressed as aI, getFocusEffect as aJ, setFocusEffect as aK, setFocusedState as aL, clearInteractionState as aM, hasPosition as aN, moveBy as aO, setPositionKeyword as aP, setPositionPercent as aQ, setAbsolute as aR, isAbsolute as aS, bringToFront as aT, sendToBack as aU, moveForward as aV, moveBackward as aW, swapZIndex as aX, hasVelocity as aY, addVelocity as aZ, removeVelocity as a_, getSiblings as aa, getNextSibling as ab, getPrevSibling as ac, getRoot as ad, getDepth as ae, getAncestors as af, getDescendants as ag, getCommonAncestor as ah, hasAncestor as ai, hasDescendant as aj, forAncestors as ak, forDescendants as al, isRoot as am, isLeaf as an, getInteractive as ao, hasInteractive as ap, setInteractive as aq, enable as ar, disable as as, isEnabled as at, hasInputEnabled as au, hasKeysEnabled as av, hasMouseEnabled as aw, isClickable as ax, setClickable as ay, isDraggable as az, disableMouse as b, getSpeed as b0, setMaxSpeed as b1, setFriction as b2, stopEntity as b3, applyVelocityToEntity as b4, clampSpeedForEntity as b5, applyFrictionToEntity as b6, updateEntityMovement as b7, getAcceleration as b8, hasAcceleration as b9, type VelocityData as bA, type VelocityOptions as bB, contentStore as bC, resetContentStore as bD, setAcceleration as ba, clearAcceleration as bb, removeAcceleration as bc, applyAccelerationToEntity as bd, Acceleration as be, type AccelerationData as bf, Content as bg, type ContentData as bh, type ContentOptions as bi, DEFAULT_FOCUS_BG as bj, DEFAULT_FOCUS_FG as bk, DEFAULT_HOVER_BG as bl, DEFAULT_HOVER_FG as bm, Focusable as bn, type FocusableData as bo, type FocusableOptions as bp, Hierarchy as bq, type HierarchyData as br, Interactive as bs, type InteractiveData as bt, type InteractiveOptions as bu, NULL_ENTITY as bv, type PositionData as bw, type PositionKeyword as bx, TextVAlign as by, type TraversalCallback as bz, enableKeys as c, disableInput as d, enableInput as e, enableMouse as f, focusNext as g, focusPrev as h, getPosition as i, getText as j, getVelocity as k, getZIndex as l, setText as m, normalizeZIndices as n, setVelocity as o, prepend as p, setZIndex as q, setContent as r, setPosition as s, getContent as t, hasContent as u, getContentData as v, getContentHash as w, getContentLength as x, appendContent as y, clearContent as z };