taffy-js 0.2.4 → 0.2.5

package/taffy_js.d.ts

@@ -1,2074 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/**
- * Available space constraint for layout computation.
- *
- * Specifies how much space is available for a node during layout calculation.
- * This is passed to `computeLayout()` to define the container constraints.
- *
- * @remarks
- * - Use `number` when you have a fixed container size
- * - Use `"minContent"` to shrink-wrap to the minimum content size
- * - Use `"maxContent"` to expand to fit all content without wrapping
- *
- * @example
- * ```typescript
- * import init, { TaffyTree, Style, type AvailableSpace, type Size } from 'taffy-js';
- *
- * await init();
- * const tree = new TaffyTree();
- * const root: bigint = tree.newLeaf(new Style());
- *
- * // Fixed size container with type annotation
- * const fixedSpace: Size<AvailableSpace> = {
- *   width: 800,
- *   height: 600
- * };
- * tree.computeLayout(root, fixedSpace);
- *
- * // Flexible width, fixed height
- * const flexibleSpace: Size<AvailableSpace> = {
- *   width: "maxContent",
- *   height: 400
- * };
- * tree.computeLayout(root, flexibleSpace);
- * ```
- */
-export type AvailableSpace = number | "minContent" | "maxContent";
-
-/**
- * Generic size type with width and height.
- *
- * A two-dimensional container for width and height values. The type parameter `T`
- * determines what kind of values are stored.
- *
- * @typeParam T - The type of each dimension (e.g., `number`, `Dimension`, `AvailableSpace`)
- *
- * @property width - The horizontal dimension value
- * @property height - The vertical dimension value
- *
- * @example
- * ```typescript
- * import type { Size, Dimension, AvailableSpace } from 'taffy-js';
- *
- * // Size with explicit type parameters
- * const pixelSize: Size<number> = { width: 200, height: 100 };
- *
- * const dimensionSize: Size<Dimension> = {
- *   width: { Length: 200 },
- *   height: { Percent: 50 }
- * };
- *
- * const availableSize: Size<AvailableSpace> = {
- *   width: 800,
- *   height: "MaxContent"
- * };
- * ```
- */
-export interface Size<T> {
-  /** The horizontal dimension value */
-  width: T;
-  /** The vertical dimension value */
-  height: T;
-}
-
-/**
- * Custom measure function for leaf nodes with text or other dynamic content.
- *
- * This callback is invoked during layout computation for leaf nodes that need
- * custom sizing based on their content (e.g., text nodes that need text measurement).
- *
- * @param knownDimensions - Dimensions already determined by constraints. Each dimension
- *                          is `number` if known, or `null` if needs to be measured.
- * @param availableSpace - The available space constraints for the node. Can be definite
- *                         pixels, "minContent", or "maxContent".
- * @param node - The node ID (`bigint`) of the node being measured
- * @param context - User-provided context attached to the node via `newLeafWithContext()`
- * @param style - The node's current Style configuration
- *
- * @returns - The measured size of the content in pixels
- *
- * @example
- * ```typescript
- * import init, { TaffyTree, Style, type MeasureFunction, type Size } from 'taffy-js';
- *
- * interface TextContext {
- *   text: string;
- *   fontSize: number;
- * }
- *
- * await init();
- * const tree = new TaffyTree();
- *
- * const style = new Style();
- * const context: TextContext = { text: "Hello, World!", fontSize: 16 };
- * const textNode: bigint = tree.newLeafWithContext(style, context);
- *
- * // Typed measure function
- * const measureText: MeasureFunction = (
- *   knownDimensions,
- *   availableSpace,
- *   node,
- *   context,
- *   style
- * ): Size<number> => {
- *   const ctx = context as TextContext | undefined;
- *   if (!ctx?.text) return { width: 0, height: 0 };
- *
- *   const width = knownDimensions.width ?? measureTextWidth(ctx.text, ctx.fontSize);
- *   const height = knownDimensions.height ?? ctx.fontSize * 1.2;
- *
- *   return { width, height };
- * };
- *
- * tree.computeLayoutWithMeasure(
- *   textNode,
- *   { width: 200, height: "maxContent" },
- *   measureText
- * );
- * ```
- */
-export type MeasureFunction = (
-  knownDimensions: Size<number | null>,
-  availableSpace: Size<AvailableSpace>,
-  node: bigint,
-  context: any,
-  style: Style,
-) => Size<number>;
-
-/**
- * Dimension type supporting length, percentage, or auto values.
- *
- * Used for sizing properties like `width`, `height`, `flexBasis`, etc.
- *
- * @remarks
- * - `number`: Fixed size in pixels
- * - `"{number}%"`: Percentage of parent's size (0-100)
- * - `"auto"`: Size determined by content or layout algorithm
- *
- * @example
- * ```typescript
- * import { Style, type Dimension, type Size } from 'taffy-js';
- *
- * const style = new Style();
- *
- * // With explicit type annotations
- * const fixedSize: Size<Dimension> = {
- *   width: 200,
- *   height: 100
- * };
- *
- * const percentSize: Size<Dimension> = {
- *   width: "50%",
- *   height: "100%"
- * };
- *
- * const autoSize: Size<Dimension> = {
- *   width: "auto",
- *   height: "auto"
- * };
- *
- * style.size = fixedSize;
- * ```
- */
-export type Dimension = number | `${number}%` | "auto";
-
-/**
- * Length or percentage value (no auto support).
- *
- * Used for properties that require explicit values, such as `padding`, `border`, and `gap`.
- *
- * @remarks
- * - `number`: Fixed size in pixels
- * - `"{number}%"`: Percentage of parent's size (0-100)
- *
- * @example
- * ```typescript
- * import { Style, type LengthPercentage, type Rect, type Size } from 'taffy-js';
- *
- * const style = new Style();
- *
- * const padding: Rect<LengthPercentage> = {
- *   left: 10,
- *   right: 10,
- *   top: 5,
- *   bottom: 5
- * };
- *
- * const gap: Size<LengthPercentage> = {
- *   width: "5%",
- *   height: "5%"
- * };
- *
- * style.padding = padding;
- * style.gap = gap;
- * ```
- */
-export type LengthPercentage = number | `${number}%`;
-
-/**
- * Length, percentage, or auto value.
- *
- * Used for properties that support auto values, such as `margin` and `inset`.
- *
- * @remarks
- * - `number`: Fixed size in pixels
- * - `"{number}%"`: Percentage of parent's size (0-100)
- * - `"auto"`: Automatic value (behavior depends on property)
- *
- * @example
- * ```typescript
- * import { Style, type LengthPercentageAuto, type Rect } from 'taffy-js';
- *
- * const style = new Style();
- *
- * // Auto margins for horizontal centering
- * const centerMargin: Rect<LengthPercentageAuto> = {
- *   left: "auto",
- *   right: "auto",
- *   top: 0,
- *   bottom: 0
- * };
- *
- * style.margin = centerMargin;
- * ```
- */
-export type LengthPercentageAuto = number | `${number}%` | "auto";
-
-/**
- * Point with x and y coordinates/values.
- *
- * Used for properties that have separate horizontal (x) and vertical (y) values,
- * such as `overflow`.
- *
- * @typeParam T - The type of each coordinate
- *
- * @property x - The horizontal value
- * @property y - The vertical value
- *
- * @example
- * ```typescript
- * import { Style, Overflow, type Point } from 'taffy-js';
- *
- * const style = new Style();
- *
- * const overflow: Point<typeof Overflow[keyof typeof Overflow]> = {
- *   x: Overflow.Hidden,
- *   y: Overflow.Scroll
- * };
- *
- * style.overflow = overflow;
- * ```
- */
-export interface Point<T> {
-  /** The horizontal (x-axis) value */
-  x: T;
-  /** The vertical (y-axis) value */
-  y: T;
-}
-
-/**
- * Rectangle with left, right, top, and bottom values.
- *
- * Used for box model properties like `margin`, `padding`, `border`, and `inset`.
- *
- * @typeParam T - The type of each side value
- *
- * @property left - The left side value
- * @property right - The right side value
- * @property top - The top side value
- * @property bottom - The bottom side value
- *
- * @example
- * ```typescript
- * import { Style, type Rect, type LengthPercentage, type LengthPercentageAuto } from 'taffy-js';
- *
- * const style = new Style();
- *
- * // Typed padding
- * const padding: Rect<LengthPercentage> = {
- *   left: 10,
- *   right: 10,
- *   top: 10,
- *   bottom: 10
- * };
- *
- * // Typed margin with auto
- * const margin: Rect<LengthPercentageAuto> = {
- *   left: "auto",
- *   right: "auto",
- *   top: 10,
- *   bottom: 30
- * };
- *
- * style.padding = padding;
- * style.margin = margin;
- * ```
- */
-export interface Rect<T> {
-  /** The left side value */
-  left: T;
-  /** The right side value */
-  right: T;
-  /** The top side value */
-  top: T;
-  /** The bottom side value */
-  bottom: T;
-}
-
-/**
- * Detailed layout information (for grid layouts).
- *
- * Returned by `detailedLayoutInfo()` for nodes using CSS Grid layout.
- * Contains detailed information about grid tracks and item placement.
- *
- * @remarks
- * This is only available when the `detailed_layout_info` feature is enabled.
- *
- * @example
- * ```typescript
- * import type { DetailedLayoutInfo, DetailedGridInfo } from 'taffy-js';
- *
- * const info: DetailedLayoutInfo = tree.detailedLayoutInfo(gridNode);
- *
- * if (info !== "None" && typeof info === 'object' && 'Grid' in info) {
- *   const grid: DetailedGridInfo = info.Grid;
- *   console.log('Rows:', grid.rows.sizes);
- *   console.log('Columns:', grid.columns.sizes);
- * }
- * ```
- */
-export type DetailedLayoutInfo = DetailedGridInfo | null;
-
-/**
- * Detailed information about a grid layout.
- *
- * Contains information about grid rows, columns, and item placement.
- *
- * @property rows - Information about row tracks
- * @property columns - Information about column tracks
- * @property items - Array of item placement information
- */
-export interface DetailedGridInfo {
-  /** Information about the grid's row tracks */
-  rows: DetailedGridTracksInfo;
-  /** Information about the grid's column tracks */
-  columns: DetailedGridTracksInfo;
-  /** Placement information for each grid item */
-  items: DetailedGridItemsInfo[];
-}
-
-/**
- * Information about grid tracks (rows or columns).
- *
- * Provides detailed sizing and gutter information for a set of grid tracks.
- *
- * @property negative_implicit_tracks - Number of implicit tracks before explicit tracks
- * @property explicit_tracks - Number of explicitly defined tracks
- * @property positive_implicit_tracks - Number of implicit tracks after explicit tracks
- * @property gutters - Array of gutter sizes between tracks (in pixels)
- * @property sizes - Array of track sizes (in pixels)
- */
-export interface DetailedGridTracksInfo {
-  /** Number of implicit tracks before explicit tracks (for negative line numbers) */
-  negative_implicit_tracks: number;
-  /** Number of tracks explicitly defined in grid-template-rows/columns */
-  explicit_tracks: number;
-  /** Number of implicit tracks created after explicit tracks */
-  positive_implicit_tracks: number;
-  /** Gap sizes between tracks in pixels */
-  gutters: number[];
-  /** Computed sizes of each track in pixels */
-  sizes: number[];
-}
-
-/**
- * Information about a grid item's placement.
- *
- * Specifies which grid lines the item spans on both axes.
- * Line numbers are 1-indexed, with 1 being the first line.
- *
- * @property row_start - Starting row line number (1-indexed)
- * @property row_end - Ending row line number (exclusive)
- * @property column_start - Starting column line number (1-indexed)
- * @property column_end - Ending column line number (exclusive)
- */
-export interface DetailedGridItemsInfo {
-  /** Starting row line (1-indexed) */
-  row_start: number;
-  /** Ending row line (exclusive) */
-  row_end: number;
-  /** Starting column line (1-indexed) */
-  column_start: number;
-  /** Ending column line (exclusive) */
-  column_end: number;
-}
-
-/**
- * Multi-line content alignment enumeration
- *
- * Controls the distribution of space between and around content items along the cross axis
- * in a multi-line flex container. This corresponds to the CSS `align-content` property.
- *
- * **Note**: This property only has effect when `flex-wrap` is set to `Wrap` or `WrapReverse`.
- *
- * @example
- * ```typescript
- * import { AlignContent, FlexWrap } from 'taffy-js';
- *
- * style.flexWrap = FlexWrap.Wrap;
- * style.alignContent = AlignContent.SpaceBetween;  // Distribute lines evenly
- * ```
- */
-export enum AlignContent {
-  /**
-   * Lines packed toward the start of the cross axis
-   */
-  Start = 0,
-  /**
-   * Lines packed toward the end of the cross axis
-   */
-  End = 1,
-  /**
-   * Lines packed toward the start of the flex container
-   */
-  FlexStart = 2,
-  /**
-   * Lines packed toward the end of the flex container
-   */
-  FlexEnd = 3,
-  /**
-   * Lines centered within the container
-   */
-  Center = 4,
-  /**
-   * Lines stretched to fill the container
-   */
-  Stretch = 5,
-  /**
-   * Lines evenly distributed with first/last at edges
-   */
-  SpaceBetween = 6,
-  /**
-   * Lines evenly distributed with equal space around each
-   */
-  SpaceAround = 7,
-  /**
-   * Lines evenly distributed with equal space between each
-   */
-  SpaceEvenly = 8,
-}
-
-/**
- * Cross-axis alignment enumeration for all children
- *
- * Defines the default alignment for all flex/grid items along the cross axis.
- * This corresponds to the CSS `align-items` property.
- *
- * @example
- * ```typescript
- * import { AlignItems } from 'taffy-js';
- *
- * style.alignItems = AlignItems.Center;   // Center items on cross axis
- * style.alignItems = AlignItems.Stretch;  // Stretch items to fill container
- * ```
- */
-export enum AlignItems {
-  /**
-   * Items aligned to the start of the cross axis
-   */
-  Start = 0,
-  /**
-   * Items aligned to the end of the cross axis
-   */
-  End = 1,
-  /**
-   * Items aligned to the start of the flex container
-   */
-  FlexStart = 2,
-  /**
-   * Items aligned to the end of the flex container
-   */
-  FlexEnd = 3,
-  /**
-   * Items centered along the cross axis
-   */
-  Center = 4,
-  /**
-   * Items aligned to their text baselines
-   */
-  Baseline = 5,
-  /**
-   * Items stretched to fill the container
-   */
-  Stretch = 6,
-}
-
-/**
- * Cross-axis alignment enumeration for a single element
- *
- * Overrides the parent's `align-items` value for a specific child element.
- * This corresponds to the CSS `align-self` property.
- *
- * @example
- * ```typescript
- * import { AlignSelf } from 'taffy-js';
- *
- * style.alignSelf = AlignSelf.Auto;    // Use parent's align-items
- * style.alignSelf = AlignSelf.Center;  // Override to center this item
- * ```
- */
-export enum AlignSelf {
-  /**
-   * Inherits the parent container's `align-items` value
-   */
-  Auto = 0,
-  /**
-   * Item aligned to the start of the cross axis
-   */
-  Start = 1,
-  /**
-   * Item aligned to the end of the cross axis
-   */
-  End = 2,
-  /**
-   * Item aligned to the start of the flex container
-   */
-  FlexStart = 3,
-  /**
-   * Item aligned to the end of the flex container
-   */
-  FlexEnd = 4,
-  /**
-   * Item centered along the cross axis
-   */
-  Center = 5,
-  /**
-   * Item aligned to its text baseline
-   */
-  Baseline = 6,
-  /**
-   * Item stretched to fill the container
-   */
-  Stretch = 7,
-}
-
-/**
- * Box sizing enumeration
- *
- * Controls how the total width and height of an element is calculated.
- * This corresponds to the CSS `box-sizing` property.
- *
- * @example
- * ```typescript
- * import { BoxSizing } from 'taffy-js';
- *
- * style.boxSizing = BoxSizing.BorderBox;   // Size includes padding and border
- * style.boxSizing = BoxSizing.ContentBox;  // Size is content only
- * ```
- */
-export enum BoxSizing {
-  /**
-   * The width and height properties include padding and border
-   */
-  BorderBox = 0,
-  /**
-   * The width and height properties include only the content
-   */
-  ContentBox = 1,
-}
-
-/**
- * Display mode enumeration
- *
- * Controls the layout algorithm type for an element. This corresponds to the CSS `display` property
- * and determines how an element and its children are laid out.
- *
- * @example
- * ```typescript
- * import { Display } from 'taffy-js';
- *
- * style.display = Display.Flex;  // Enable flexbox layout
- * style.display = Display.Grid;  // Enable grid layout
- * style.display = Display.None;  // Hide element from layout
- * ```
- */
-export enum Display {
-  /**
-   * Block-level layout where element takes the full available width
-   */
-  Block = 0,
-  /**
-   * Flexbox layout for one-dimensional item arrangement
-   */
-  Flex = 1,
-  /**
-   * CSS Grid layout for two-dimensional item arrangement
-   */
-  Grid = 2,
-  /**
-   * Element is removed from layout calculation entirely
-   */
-  None = 3,
-}
-
-/**
- * Flex direction enumeration
- *
- * Defines the main axis direction for flex item layout. This corresponds to the CSS
- * `flex-direction` property and determines how flex items are placed within the container.
- *
- * @example
- * ```typescript
- * import { FlexDirection } from 'taffy-js';
- *
- * style.flexDirection = FlexDirection.Row;     // Horizontal, left to right
- * style.flexDirection = FlexDirection.Column;  // Vertical, top to bottom
- * ```
- */
-export enum FlexDirection {
-  /**
-   * Main axis runs horizontally from left to right
-   */
-  Row = 0,
-  /**
-   * Main axis runs vertically from top to bottom
-   */
-  Column = 1,
-  /**
-   * Main axis runs horizontally from right to left
-   */
-  RowReverse = 2,
-  /**
-   * Main axis runs vertically from bottom to top
-   */
-  ColumnReverse = 3,
-}
-
-/**
- * Flex wrap mode enumeration
- *
- * Controls whether flex items wrap onto multiple lines when they overflow the container.
- * This corresponds to the CSS `flex-wrap` property.
- *
- * @example
- * ```typescript
- * import { FlexWrap } from 'taffy-js';
- *
- * style.flexWrap = FlexWrap.NoWrap;  // All items on single line
- * style.flexWrap = FlexWrap.Wrap;    // Items wrap to new lines
- * ```
- */
-export enum FlexWrap {
-  /**
-   * All flex items are placed on a single line
-   */
-  NoWrap = 0,
-  /**
-   * Flex items wrap onto multiple lines from top to bottom
-   */
-  Wrap = 1,
-  /**
-   * Flex items wrap onto multiple lines from bottom to top
-   */
-  WrapReverse = 2,
-}
-
-/**
- * Main axis alignment enumeration
- *
- * Defines how flex items are aligned and spaced along the main axis.
- * This corresponds to the CSS `justify-content` property.
- *
- * @example
- * ```typescript
- * import { JustifyContent } from 'taffy-js';
- *
- * style.justifyContent = JustifyContent.Center;        // Center items
- * style.justifyContent = JustifyContent.SpaceBetween;  // Distribute evenly
- * ```
- */
-export enum JustifyContent {
-  /**
-   * Items packed toward the start of the main axis
-   */
-  Start = 0,
-  /**
-   * Items packed toward the end of the main axis
-   */
-  End = 1,
-  /**
-   * Items packed toward the start of the flex container
-   */
-  FlexStart = 2,
-  /**
-   * Items packed toward the end of the flex container
-   */
-  FlexEnd = 3,
-  /**
-   * Items centered along the main axis
-   */
-  Center = 4,
-  /**
-   * Items stretched along the main axis
-   */
-  Stretch = 5,
-  /**
-   * Items evenly distributed with first/last at edges
-   */
-  SpaceBetween = 6,
-  /**
-   * Items evenly distributed with equal space around each
-   */
-  SpaceAround = 7,
-  /**
-   * Items evenly distributed with equal space between each
-   */
-  SpaceEvenly = 8,
-}
-
-/**
- * Computed layout result containing position, size, and spacing values for a node.
- *
- * This class wraps the native [`taffy::Layout`] and provides read-only access
- * to all computed layout values. All dimensions are in pixels.
- *
- * @example
- * ```typescript
- * const layout = tree.getLayout(node);
- *
- * console.log("Position:", layout.x, layout.y);
- * console.log("Size:", layout.width, layout.height);
- * console.log("Content:", layout.contentWidth, layout.contentHeight);
- * console.log("Padding:", layout.paddingTop, layout.paddingRight, layout.paddingBottom, layout.paddingLeft);
- * console.log("Border:", layout.borderTop, layout.borderRight, layout.borderBottom, layout.borderLeft);
- * console.log("Margin:", layout.marginTop, layout.marginRight, layout.marginBottom, layout.marginLeft);
- * console.log("Scrollbar:", layout.scrollbarWidth, layout.scrollbarHeight);
- * console.log("Order:", layout.order);
- * ```
- */
-export class Layout {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Gets the top border width
-   *
-   * @returns - The computed top border width in pixels
-   */
-  readonly borderTop: number;
-  /**
-   * Gets the top margin
-   *
-   * @returns - The computed top margin in pixels
-   */
-  readonly marginTop: number;
-  /**
-   * Gets the left border width
-   *
-   * @returns - The computed left border width in pixels
-   */
-  readonly borderLeft: number;
-  /**
-   * Gets the left margin
-   *
-   * @returns - The computed left margin in pixels
-   */
-  readonly marginLeft: number;
-  /**
-   * Gets the top padding
-   *
-   * @returns - The computed top padding in pixels
-   */
-  readonly paddingTop: number;
-  /**
-   * Gets the right border width
-   *
-   * @returns - The computed right border width in pixels
-   */
-  readonly borderRight: number;
-  /**
-   * Gets the right margin
-   *
-   * @returns - The computed right margin in pixels
-   */
-  readonly marginRight: number;
-  /**
-   * Gets the left padding
-   *
-   * @returns - The computed left padding in pixels
-   */
-  readonly paddingLeft: number;
-  /**
-   * Gets the bottom border width
-   *
-   * @returns - The computed bottom border width in pixels
-   */
-  readonly borderBottom: number;
-  /**
-   * Gets the width of the scrollable content
-   *
-   * If the node has overflow content, this represents the total
-   * width of all content (may exceed `width`).
-   *
-   * @returns - The content width in pixels
-   */
-  readonly contentWidth: number;
-  /**
-   * Gets the bottom margin
-   *
-   * @returns - The computed bottom margin in pixels
-   */
-  readonly marginBottom: number;
-  /**
-   * Gets the right padding
-   *
-   * @returns - The computed right padding in pixels
-   */
-  readonly paddingRight: number;
-  /**
-   * Gets the height of the scrollable content
-   *
-   * If the node has overflow content, this represents the total
-   * height of all content (may exceed `height`).
-   *
-   * @returns - The content height in pixels
-   */
-  readonly contentHeight: number;
-  /**
-   * Gets the bottom padding
-   *
-   * @returns - The computed bottom padding in pixels
-   */
-  readonly paddingBottom: number;
-  /**
-   * Gets the width of the vertical scrollbar
-   *
-   * When overflow is set to scroll, this indicates the space
-   * reserved for the vertical scrollbar.
-   *
-   * @returns - The scrollbar width in pixels (0 if no scrollbar)
-   */
-  readonly scrollbarWidth: number;
-  /**
-   * Gets the height of the horizontal scrollbar
-   *
-   * When overflow is set to scroll, this indicates the space
-   * reserved for the horizontal scrollbar.
-   *
-   * @returns - The scrollbar height in pixels (0 if no scrollbar)
-   */
-  readonly scrollbarHeight: number;
-  /**
-   * Gets the X coordinate of the node's top-left corner
-   *
-   * This value is relative to the node's parent. For the root node,
-   * this is always 0.
-   *
-   * @returns - The horizontal position in pixels
-   */
-  readonly x: number;
-  /**
-   * Gets the Y coordinate of the node's top-left corner
-   *
-   * This value is relative to the node's parent. For the root node,
-   * this is always 0.
-   *
-   * @returns - The vertical position in pixels
-   */
-  readonly y: number;
-  /**
-   * Gets the rendering order of the node
-   *
-   * This value determines the z-order for overlapping elements.
-   * Lower values are rendered first (behind higher values).
-   *
-   * @returns - The rendering order as an unsigned 32-bit integer
-   */
-  readonly order: number;
-  /**
-   * Gets the computed width of the node
-   *
-   * This is the final width after layout computation, including
-   * any constraints from min/max size or flex properties.
-   *
-   * @returns - The width in pixels
-   */
-  readonly width: number;
-  /**
-   * Gets the computed height of the node
-   *
-   * This is the final height after layout computation, including
-   * any constraints from min/max size or flex properties.
-   *
-   * @returns - The height in pixels
-   */
-  readonly height: number;
-}
-
-/**
- * Overflow handling enumeration
- *
- * Defines how content that exceeds the container boundaries is handled.
- * This corresponds to the CSS `overflow` property.
- *
- * @example
- * ```typescript
- * import { Overflow } from 'taffy-js';
- *
- * style.overflow = { x: Overflow.Hidden, y: Overflow.Scroll };
- * ```
- */
-export enum Overflow {
-  /**
-   * Content is not clipped and may render outside the container
-   */
-  Visible = 0,
-  /**
-   * Content is clipped at the container boundary
-   */
-  Hidden = 1,
-  /**
-   * Always display scrollbars for scrollable content
-   */
-  Scroll = 2,
-  /**
-   * Display scrollbars only when content overflows (internally maps to Scroll)
-   */
-  Auto = 3,
-}
-
-/**
- * Position mode enumeration
- *
- * Controls how an element is positioned within its parent container.
- * This corresponds to the CSS `position` property.
- *
- * @example
- * ```typescript
- * import { Position } from 'taffy-js';
- *
- * style.position = Position.Relative;  // Normal document flow
- * style.position = Position.Absolute;  // Removed from flow, uses inset values
- * ```
- */
-export enum Position {
-  /**
-   * Element participates in normal document flow
-   */
-  Relative = 0,
-  /**
-   * Element is positioned relative to its nearest positioned ancestor
-   */
-  Absolute = 1,
-}
-
-/**
- * CSS layout configuration for a node, including flexbox, sizing, spacing, and alignment properties.
- *
- * This class holds all CSS layout properties for a node. Create an instance with
- * `new Style()` and configure properties before passing to `TaffyTree.newLeaf()`.
- *
- * @defaultValue
- * When created, all properties are set to their CSS default values:
- * - `display`: `Display.Block`
- * - `position`: `Position.Relative`
- * - `flexDirection`: `FlexDirection.Row`
- * - `flexWrap`: `FlexWrap.NoWrap`
- * - `flexGrow`: `0`
- * - `flexShrink`: `1`
- * - All alignment properties: `undefined` (use default behavior)
- * - All dimensions: `"Auto"`
- * - All spacing: `{ Length: 0 }`
- *
- */
-export class Style {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Creates a new Style instance with default values
-   *
-   * @returns - A new `Style` object with all properties set to CSS defaults
-   *
-   * @example
-   * ```typescript
-   * const style = new Style();
-   * console.log(style.display);  // Display.Block
-   * ```
-   */
-  constructor();
-  /**
-   * Gets the align-self property
-   *
-   * Overrides the parent's align-items for this specific element.
-   *
-   * @returns - The current [`AlignSelf`](JsAlignSelf) value (returns `Auto` if not set)
-   */
-  alignSelf: AlignSelf | undefined;
-  /**
-   * Gets the box sizing mode
-   *
-   * Determines whether padding and border are included in dimensions.
-   *
-   * @returns - The current [`BoxSizing`](JsBoxSizing) value
-   *
-   * @defaultValue `BoxSizing.BorderBox`
-   */
-  boxSizing: BoxSizing;
-  /**
-   * Gets the flex-basis
-   *
-   * The initial size of a flex item before growing/shrinking.
-   *
-   * @returns - A `Dimension` value (`{ Length: n }`, `{ Percent: n }`, or `"Auto"`)
-   */
-  flexBasis: Dimension;
-  /**
-   * Gets the border width
-   *
-   * Width of the element's border on each side.
-   *
-   * @returns - A `Rect<LengthPercentage>` with left, right, top, bottom border widths
-   */
-  border: Rect<LengthPercentage>;
-  /**
-   * Gets the margin
-   *
-   * Outer spacing around the element.
-   *
-   * @returns - A `Rect<LengthPercentageAuto>` with left, right, top, bottom margins
-   */
-  margin: Rect<LengthPercentageAuto>;
-  /**
-   * Gets the align-items property
-   *
-   * Defines the default alignment for all children on the cross axis.
-   *
-   * @returns - The current [`AlignItems`](JsAlignItems) value, or `undefined` if not set
-   */
-  alignItems: AlignItems | undefined;
-  /**
-   * Gets the flex shrink factor
-   *
-   * Determines how much the item shrinks relative to siblings when
-   * there is insufficient space.
-   *
-   * @returns - The flex shrink factor (default: 1)
-   */
-  flexShrink: number;
-  /**
-   * Gets the display mode
-   *
-   * Determines the layout algorithm used for this element and its children.
-   *
-   * @returns - The current [`Display`](JsDisplay) value
-   *
-   * @defaultValue - `Display.Block`
-   */
-  display: Display;
-  /**
-   * Gets the padding
-   *
-   * Inner spacing between the element's border and content.
-   *
-   * @returns - A `Rect<LengthPercentage>` with left, right, top, bottom padding
-   */
-  padding: Rect<LengthPercentage>;
-  /**
-   * Gets the aspect ratio
-   *
-   * The ratio of width to height. Used to maintain proportions.
-   *
-   * @returns - The aspect ratio value, or `undefined` if not set
-   */
-  aspectRatio: number | undefined;
-  /**
-   * Gets the maximum size constraints
-   *
-   * @returns - A `Size<Dimension>` object with maximum width and height
-   */
-  maxSize: Size<Dimension>;
-  /**
-   * Gets the minimum size constraints
-   *
-   * @returns - A `Size<Dimension>` object with minimum width and height
-   */
-  minSize: Size<Dimension>;
-  /**
-   * Gets the overflow behavior
-   *
-   * Controls how content that exceeds the container is handled.
-   *
-   * @returns - A `Point<Overflow>` with `x` and `y` overflow settings
-   */
-  overflow: Point<Overflow>;
-  /**
-   * Gets the position mode
-   *
-   * Determines how the element is positioned within its parent.
-   *
-   * @returns - The current [`Position`](JsPosition) value
-   *
-   * @defaultValue - `Position.Relative`
-   */
-  position: Position;
-  /**
-   * Gets the align-content property
-   *
-   * Controls distribution of space between lines in a multi-line flex container.
-   *
-   * @returns - The current [`AlignContent`](JsAlignContent) value, or `undefined` if not set
-   */
-  alignContent: AlignContent | undefined;
-  /**
-   * Gets the flex grow factor
-   *
-   * Determines how much the item grows relative to siblings when
-   * there is extra space available.
-   *
-   * @returns - The flex grow factor (default: 0)
-   */
-  flexGrow: number;
-  /**
-   * Gets the flex wrap mode
-   *
-   * Controls whether flex items wrap to new lines.
-   *
-   * @returns - The current [`FlexWrap`](JsFlexWrap) value
-   *
-   * @defaultValue - `FlexWrap.NoWrap`
-   */
-  flexWrap: FlexWrap;
-  /**
-   * Gets the flex direction
-   *
-   * Defines the main axis direction for flex items.
-   *
-   * @returns - The current [`FlexDirection`](JsFlexDirection) value
-   *
-   * @defaultValue - `FlexDirection.Row`
-   */
-  flexDirection: FlexDirection;
-  /**
-   * Gets the justify-content property
-   *
-   * Defines alignment and spacing of items along the main axis.
-   *
-   * @returns - The current [`JustifyContent`](JsJustifyContent) value, or `undefined` if not set
-   */
-  justifyContent: JustifyContent | undefined;
-  /**
-   * Gets the gap
-   *
-   * Spacing between flex/grid items.
-   *
-   * @returns - A `Size<LengthPercentage>` with column (width) and row (height) gaps
-   */
-  gap: Size<LengthPercentage>;
-  /**
-   * Gets the size (width and height)
-   *
-   * @returns - A `Size<Dimension>` object with `width` and `height` properties
-   */
-  size: Size<Dimension>;
-  /**
-   * Gets the inset
-   *
-   * Positioning offsets for absolutely positioned elements.
-   *
-   * @returns - A `Rect<LengthPercentageAuto>` with left, right, top, bottom offsets
-   */
-  inset: Rect<LengthPercentageAuto>;
-}
-
-/**
- * Error class thrown when a Taffy operation fails, containing a human-readable error message.
- *
- * This class wraps the native [`taffy::TaffyError`] type and exposes it to JavaScript
- * with a readable error message. It is thrown as a JavaScript exception on failure.
- *
- * @example
- * ```typescript
- * try {
- *  tree.remove(node);
- * } catch (e) {
- *   if (e instanceof TaffyError) {
- *      console.error(e.message);
- *   }
- * }
- * ```
- *
- * @remarks
- * The underlying Taffy errors include:
- * - `InvalidInputNode`: Node ID doesn't exist in the tree
- * - `InvalidParentNode`: Specified parent node doesn't exist
- * - `ChildIndexOutOfBounds`: Child index exceeds available children
- */
-export class TaffyError {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Gets the human-readable error message
-   *
-   * @returns - A string describing what went wrong.
-   *
-   * @remarks
-   * Examples:
-   * - "Node with id 1234 is not present in the Taffy tree"
-   * - "Index 5 is out of bounds for node with 3 children"
-   */
-  readonly message: string;
-}
-
-/**
- * The main layout tree class for creating nodes, computing layouts, and managing a tree of styled elements.
- *
- * TaffyTree is the entry point for the Taffy layout engine. It manages
- * a tree of nodes and computes their layouts using CSS Flexbox and Grid algorithms.
- *
- */
-export class TaffyTree {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Marks a node as dirty (requiring re-layout)
-   *
-   * Use this when a node's content has changed but its style hasn't.
-   * For example, when text content changes and needs remeasuring.
-   *
-   * @param node - The node ID to mark dirty
-   *
-   * @throws `TaffyError` if the node does not exist
-   *
-   * @example
-   * ```typescript
-   * // After updating text content
-   * tree.setNodeContext(nodeId, { text: "Updated text" });
-   * tree.markDirty(nodeId);
-   * tree.computeLayout(rootId, availableSpace);
-   * ```
-   */
-  markDirty(node: bigint): void;
-  /**
-   * Prints the tree structure to the console (for debugging)
-   *
-   * Outputs a text representation of the tree structure starting from
-   * the given node. Useful for debugging layout issues.
-   *
-   * @param node - The root node ID to print from
-   *
-   * @example
-   * ```typescript
-   * tree.printTree(rootId);
-   * // Output appears in browser console
-   * ```
-   */
-  printTree(node: bigint): void;
-  /**
-   * Gets the number of children of a node
-   *
-   * @param parent - The parent node ID
-   *
-   * @returns - The number of direct children
-   *
-   * @throws `TaffyError` if the node does not exist
-   *
-   * @example
-   * ```typescript
-   * const count: number = tree.childCount(parentId);
-   * ```
-   */
-  childCount(parent: bigint): number;
-  /**
-   * Removes a specific child from a parent
-   *
-   * @param parent - The parent node ID
-   * @param child - The child node ID to remove
-   *
-   * @returns - The removed child ID (`bigint`)
-   *
-   * @throws `TaffyError` if the parent or child node does not exist
-   *
-   * @example
-   * ```typescript
-   * tree.removeChild(parentId, childId);
-   * ```
-   */
-  removeChild(parent: bigint, child: bigint): bigint;
-  /**
-   * Replaces all children of a node
-   *
-   * Any existing children are removed and replaced with the new array.
-   *
-   * @param parent - The parent node ID
-   * @param children - Array of new child node IDs
-   *
-   * @throws `TaffyError` if the parent node does not exist
-   *
-   * @example
-   * ```typescript
-   * const children = BigUint64Array.from([child1, child2, child3]);
-   * tree.setChildren(parentId, children);
-   * ```
-   */
-  setChildren(parent: bigint, children: BigUint64Array): void;
-  /**
-   * Creates a new TaffyTree with pre-allocated capacity
-   *
-   * Use this when you know approximately how many nodes will be in the tree.
-   * This can improve performance by reducing memory reallocations.
-   *
-   * @param capacity - The number of nodes to pre-allocate space for
-   *
-   * @example
-   * ```typescript
-   * const tree: TaffyTree = TaffyTree.withCapacity(1000);
-   * ```
-   */
-  static withCapacity(capacity: number): TaffyTree;
-  /**
-   * Computes the layout for a subtree
-   *
-   * This is the main layout computation method. Call this on the root node
-   * to compute layouts for all nodes in the tree.
-   *
-   * @param node - The root node ID to compute layout for
-   * @param available_space - The available space constraints
-   *
-   * @example
-   * ```typescript
-   * // Fixed size container
-   * { width: { Definite: 800 }, height: { Definite: 600 } }
-   *
-   * // Flexible width, fixed height
-   * { width: "MaxContent", height: { Definite: 600 } }
-   *
-   * // Minimum content size
-   * { width: "MinContent", height: "MinContent" }
-   * ```
-   *
-   * @throws `TaffyError` if the node does not exist or available space is invalid
-   *
-   * @example
-   * ```typescript
-   * tree.computeLayout(rootId, { width: { Definite: 800 }, height: { Definite: 600 } });
-   * ```
-   */
-  computeLayout(node: bigint, available_space: Size<AvailableSpace>): void;
-  /**
-   * Enables rounding of layout values to whole pixels
-   *
-   * When enabled (default), computed layout values like position and size
-   * are rounded to the nearest integer. This prevents sub-pixel rendering
-   * issues in most rendering contexts.
-   *
-   * @example
-   * ```typescript
-   * tree.enableRounding();
-   * ```
-   */
-  enableRounding(): void;
-  /**
-   * Disables rounding of layout values
-   *
-   * When disabled, computed layout values retain their fractional precision.
-   * Use this when you need sub-pixel accuracy or when performing custom
-   * rounding.
-   *
-   * @example
-   * ```typescript
-   * tree.disableRounding();
-   * const layout = tree.getLayout(node);
-   * console.log(layout.x);
-   * ```
-   */
-  disableRounding(): void;
-  /**
-   * Gets the context value for a node
-   *
-   * @param node - The node ID
-   *
-   * @returns - The attached context value, or `undefined` if none is set
-   *
-   * @example
-   * ```typescript
-   * interface Context { text: string };
-   * const context = tree.getNodeContext(nodeId) as Context | undefined;
-   * if (context) {
-   *   console.log(context.text);
-   * }
-   * ```
-   */
-  getNodeContext(node: bigint): any;
-  /**
-   * Sets a context value for a node
-   *
-   * The context can be any JavaScript value and is passed to the measure
-   * function during layout computation.
-   *
-   * @param node - The node ID
-   * @param context - Any JavaScript value to attach
-   *
-   * @throws `TaffyError` if the node does not exist
-   *
-   * @example
-   * ```typescript
-   * interface Context { text: string };
-   * tree.setNodeContext(nodeId, { text: "Updated text" } as Context);
-   * ```
-   */
-  setNodeContext(node: bigint, context: any): void;
-  /**
-   * Gets the total number of nodes in the tree
-   *
-   * @returns - The total count of all nodes
-   *
-   * @example
-   * ```typescript
-   * const count: number = tree.totalNodeCount();
-   * ```
-   */
-  totalNodeCount(): number;
-  /**
-   * Gets the unrounded (fractional) layout for a node
-   *
-   * Returns the raw computed values before any rounding is applied.
-   * Useful when you need sub-pixel precision.
-   *
-   * @param node - The node ID
-   *
-   * @returns - The unrounded `Layout`
-   *
-   * @example
-   * ```typescript
-   * const layout: Layout = tree.unroundedLayout(nodeId);
-   * console.log(`Exact width: ${layout.width}`);
-   * ```
-   */
-  unroundedLayout(node: bigint): Layout;
-  /**
-   * Creates a new node with the given children
-   *
-   * Use this to create container nodes that have child elements.
-   * The children must already exist in the tree.
-   *
-   * @param style - The style configuration for the node
-   * @param children - Array of child node IDs (as BigUint64Array)
-   *
-   * @returns - The node ID (`bigint`)
-   *
-   * @throws `TaffyError` if the node cannot be created
-   *
-   * @example
-   * ```typescript
-   * const containerStyle = new Style();
-   * containerStyle.display = Display.Flex;
-   *
-   * const child1: bigint = tree.newLeaf(new Style());
-   * const child2: bigint = tree.newLeaf(new Style());
-   *
-   * const container: bigint = tree.newWithChildren(
-   *   containerStyle,
-   *   BigUint64Array.from([child1, child2])
-   * );
-   * ```
-   */
-  newWithChildren(style: Style, children: BigUint64Array): bigint;
-  /**
-   * Gets the child at a specific index
-   *
-   * @param parent - The parent node ID
-   * @param index - The index of the child (0-based)
-   *
-   * @returns - The child node ID (`bigint`)
-   *
-   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
-   *
-   * @example
-   * ```typescript
-   * const firstChild: bigint = tree.getChildAtIndex(parentId, 0);
-   * ```
-   */
-  getChildAtIndex(parent: bigint, index: number): bigint;
-  /**
-   * Gets a mutable reference to the context value for a node
-   *
-   * In JavaScript, this behaves the same as `getNodeContext()` since
-   * JavaScript objects are always passed by reference.
-   *
-   * @param node - The node ID
-   *
-   * @returns - The attached context value, or `undefined` if none is set
-   */
-  getNodeContextMut(node: bigint): any;
-  /**
-   * Inserts a child at a specific index
-   *
-   * @param parent - The parent node ID
-   * @param index - The position to insert at (0-based)
-   * @param child - The child node ID to insert
-   *
-   * @throws `TaffyError` if the parent or child node does not exist, or index is out of bounds
-   *
-   * @example
-   * ```typescript
-   * tree.insertChildAtIndex(parentId, 0, childId);
-   * ```
-   */
-  insertChildAtIndex(parent: bigint, index: number, child: bigint): void;
-  /**
-   * Creates a new leaf node with an attached context value
-   *
-   * The context can be any JavaScript value and is passed to the measure
-   * function during layout computation. This is useful for storing
-   * references to text content or other dynamic data.
-   *
-   * @param style - The style configuration for the node
-   * @param context - Any JavaScript value to attach to the node
-   * @returns - The node ID (`bigint`)
-   * @throws `TaffyError` if the node cannot be created
-   *
-   * @example
-   * ```typescript
-   * interface TextContext { text: string; isBold: boolean; }
-   *
-   * const style = new Style();
-   * const context: TextContext = { text: "Hello, World!", isBold: true };
-   * const nodeId: bigint = tree.newLeafWithContext(style, context);
-   * ```
-   */
-  newLeafWithContext(style: Style, context: any): bigint;
-  /**
-   * Removes a child at a specific index
-   *
-   * @param parent - The parent node ID
-   * @param index - The index of the child to remove (0-based)
-   *
-   * @returns - The removed child ID (`bigint`)
-   *
-   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
-   *
-   * @example
-   * ```typescript
-   * const removedId: bigint = tree.removeChildAtIndex(parentId, 0);
-   * ```
-   */
-  removeChildAtIndex(parent: bigint, index: number): bigint;
-  /**
-   * Removes a range of children
-   *
-   * Removes children from `start_index` (inclusive) to `end_index` (exclusive).
-   *
-   * @param parent - The parent node ID
-   * @param start_index - Start of range (inclusive)
-   * @param end_index - End of range (exclusive)
-   *
-   * @throws `TaffyError` if the parent node does not exist or range is invalid
-   *
-   * @example
-   * ```typescript
-   * tree.removeChildrenRange(parentId, 1, 3);
-   * ```
-   */
-  removeChildrenRange(
-    parent: bigint,
-    start_index: number,
-    end_index: number,
-  ): void;
-  /**
-   * Replaces a child at a specific index
-   *
-   * @param parent - The parent node ID
-   * @param index - The index of the child to replace (0-based)
-   * @param new_child - The new child node ID
-   *
-   * @returns - The replaced (old) child ID (`bigint`)
-   *
-   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
-   *
-   * @example
-   * ```typescript
-   * const oldChildId: bigint = tree.replaceChildAtIndex(parentId, 1, newChildId);
-   * ```
-   */
-  replaceChildAtIndex(parent: bigint, index: number, new_child: bigint): bigint;
-  /**
-   * Computes layout with a custom measure function for leaf nodes
-   *
-   * Use this when you have leaf nodes with dynamic content (like text)
-   * that needs to be measured during layout. The measure function is
-   * called for each leaf node that needs measurement.
-   *
-   * @param node - The root node ID to compute layout for
-   * @param available_space - The available space constraints
-   * @param measure_func - A function that measures leaf node content
-   *
-   * @throws `TaffyError` if the node does not exist or available space is invalid
-   *
-   * @example
-   * ```typescript
-   * tree.computeLayoutWithMeasure(
-   *   rootId,
-   *   { width: { Definite: 800 }, height: "MaxContent" },
-   *   (known, available, node, context, style) => {
-   *     if (context?.text) {
-   *       const measured = measureText(context.text, available.width);
-   *       return { width: measured.width, height: measured.height };
-   *     }
-   *     return { width: 0, height: 0 };
-   *   }
-   * );
-   * ```
-   */
-  computeLayoutWithMeasure(
-    node: bigint,
-    available_space: Size<AvailableSpace>,
-    measure_func: MeasureFunction,
-  ): void;
-  /**
-   * Gets context values for multiple nodes at once
-   *
-   * This is more efficient than calling `getNodeContext()` multiple times
-   * when you need to access contexts for many nodes.
-   *
-   * @param children - Array of node IDs
-   *
-   * @returns - Array of context values (undefined for nodes without context)
-   *
-   * @example
-   * ```typescript
-   * const nodes = BigUint64Array.from([id1, id2]);
-   * const contexts = tree.getDisjointNodeContextMut(nodes);
-   * ```
-   */
-  getDisjointNodeContextMut(children: BigUint64Array): any[];
-  /**
-   * Creates a new empty TaffyTree
-   *
-   * The tree starts with no nodes. Use `newLeaf()` or `newWithChildren()`
-   * to add nodes.
-   *
-   * @example
-   * ```typescript
-   * const tree: TaffyTree = new TaffyTree();
-   * ```
-   */
-  constructor();
-  /**
-   * Removes all nodes from the tree
-   *
-   * This clears the entire tree, removing all nodes and their relationships.
-   * Use this to reset the tree for reuse.
-   *
-   * @example
-   * ```typescript
-   * tree.clear();
-   * console.log(tree.totalNodeCount());
-   * ```
-   */
-  clear(): void;
-  /**
-   * Checks if a node is dirty (needs re-layout)
-   *
-   * A node is dirty if its style or content has changed since the last
-   * layout computation.
-   *
-   * @param node - The node ID to check
-   *
-   * @returns - true if dirty, false otherwise
-   *
-   * @throws `TaffyError` if the node does not exist
-   *
-   * @example
-   * ```typescript
-   * if (tree.dirty(nodeId)) {
-   *   tree.computeLayout(rootId, availableSpace);
-   * }
-   * ```
-   */
-  dirty(node: bigint): boolean;
-  /**
-   * Gets the style for a node
-   *
-   * @param node - The node ID
-   *
-   * @returns - The node's `Style`
-   *
-   * @throws `TaffyError` if the node does not exist
-   *
-   * @example
-   * ```typescript
-   * const style: Style = tree.getStyle(nodeId);
-   * console.log('Flex grow:', style.flexGrow);
-   * ```
-   */
-  getStyle(node: bigint): Style;
-  /**
-   * Gets the computed layout for a node
-   *
-   * Call this after `computeLayout()` to retrieve the computed position
-   * and size for a node.
-   *
-   * @param node - The node ID
-   *
-   * @returns - The computed `Layout`
-   *
-   * @throws `TaffyError` if the node does not exist
-   *
-   * @example
-   * ```typescript
-   * tree.computeLayout(rootId, { width: { Definite: 800 }, height: { Definite: 600 } });
-   * const layout: Layout = tree.getLayout(nodeId);
-   * console.log(`Position: (${layout.x}, ${layout.y}), Size: ${layout.width}x${layout.height}`);
-   * ```
-   */
-  getLayout(node: bigint): Layout;
-  /**
-   * Gets the parent of a node
-   *
-   * @param child - The child node ID
-   *
-   * @returns - The parent node ID, or `undefined` if the node has no parent
-   *
-   * @example
-   * ```typescript
-   * const parentId: bigint | undefined = tree.parent(childId);
-   * ```
-   */
-  parent(child: bigint): bigint | undefined;
-  /**
-   * Removes a node from the tree
-   *
-   * The node and all its descendants are removed. If the node has a parent,
-   * it is automatically removed from the parent's children.
-   *
-   * @param node - The node ID to remove
-   *
-   * @returns - The removed node ID (`bigint`)
-   *
-   * @throws `TaffyError` if the node does not exist
-   *
-   * @example
-   * ```typescript
-   * try {
-   *   const removedId: bigint = tree.remove(nodeId);
-   * } catch (e) {
-   *   console.error("Node doesn't exist");
-   * }
-   * ```
-   */
-  remove(node: bigint): bigint;
-  /**
-   * Gets all children of a node
-   *
-   * @param parent - The parent node ID
-   *
-   * @returns - Array of child node IDs (`BigUint64Array`)
-   *
-   * @throws `TaffyError` if the parent node does not exist
-   *
-   * @example
-   * ```typescript
-   * const children: BigUint64Array = tree.children(parentId);
-   * ```
-   */
-  children(parent: bigint): BigUint64Array;
-  /**
-   * Creates a new leaf node with the given style
-   *
-   * A leaf node has no children. Use this for elements that contain
-   * content (like text) rather than other elements.
-   *
-   * @param style - The style configuration for the node
-   * @returns - The node ID (`bigint`)
-   * @throws `TaffyError` if the node cannot be created
-   *
-   * @example
-   * ```typescript
-   * const style = new Style();
-   * style.size = { width: { Length: 100 }, height: { Length: 50 } };
-   * const nodeId: bigint = tree.newLeaf(style);
-   * ```
-   */
-  newLeaf(style: Style): bigint;
-  /**
-   * Appends a child node to a parent
-   *
-   * The child is added as the last child of the parent.
-   *
-   * @param parent - The parent node ID
-   * @param child - The child node ID to add
-   *
-   * @throws `TaffyError` if the parent or child node does not exist
-   *
-   * @example
-   * ```typescript
-   * tree.addChild(parentId, childId);
-   * ```
-   */
-  addChild(parent: bigint, child: bigint): void;
-  /**
-   * Sets the style for an existing node
-   *
-   * This replaces the node's current style with the provided one.
-   * The node will be marked as dirty and require re-layout.
-   *
-   * @param node - The node ID
-   * @param style - The new style configuration
-   *
-   * @throws `TaffyError` if the node does not exist
-   *
-   * @example
-   * ```typescript
-   * const newStyle = new Style();
-   * newStyle.flexGrow = 2;
-   * tree.setStyle(nodeId, newStyle);
-   * ```
-   */
-  setStyle(node: bigint, style: Style): void;
-}
-
-export type InitInput =
-  | RequestInfo
-  | URL
-  | Response
-  | BufferSource
-  | WebAssembly.Module;
-
-export interface InitOutput {
-  readonly memory: WebAssembly.Memory;
-  readonly __wbg_layout_free: (a: number, b: number) => void;
-  readonly __wbg_style_free: (a: number, b: number) => void;
-  readonly __wbg_taffyerror_free: (a: number, b: number) => void;
-  readonly __wbg_taffytree_free: (a: number, b: number) => void;
-  readonly layout_borderBottom: (a: number) => number;
-  readonly layout_borderLeft: (a: number) => number;
-  readonly layout_borderRight: (a: number) => number;
-  readonly layout_borderTop: (a: number) => number;
-  readonly layout_contentHeight: (a: number) => number;
-  readonly layout_contentWidth: (a: number) => number;
-  readonly layout_height: (a: number) => number;
-  readonly layout_marginBottom: (a: number) => number;
-  readonly layout_marginLeft: (a: number) => number;
-  readonly layout_marginRight: (a: number) => number;
-  readonly layout_marginTop: (a: number) => number;
-  readonly layout_order: (a: number) => number;
-  readonly layout_paddingBottom: (a: number) => number;
-  readonly layout_paddingLeft: (a: number) => number;
-  readonly layout_paddingRight: (a: number) => number;
-  readonly layout_paddingTop: (a: number) => number;
-  readonly layout_scrollbarHeight: (a: number) => number;
-  readonly layout_scrollbarWidth: (a: number) => number;
-  readonly layout_width: (a: number) => number;
-  readonly layout_x: (a: number) => number;
-  readonly layout_y: (a: number) => number;
-  readonly style_alignContent: (a: number) => number;
-  readonly style_alignItems: (a: number) => number;
-  readonly style_alignSelf: (a: number) => number;
-  readonly style_aspectRatio: (a: number) => number;
-  readonly style_border: (a: number) => any;
-  readonly style_boxSizing: (a: number) => number;
-  readonly style_display: (a: number) => number;
-  readonly style_flexBasis: (a: number) => any;
-  readonly style_flexDirection: (a: number) => number;
-  readonly style_flexGrow: (a: number) => number;
-  readonly style_flexShrink: (a: number) => number;
-  readonly style_flexWrap: (a: number) => number;
-  readonly style_gap: (a: number) => any;
-  readonly style_inset: (a: number) => any;
-  readonly style_justifyContent: (a: number) => number;
-  readonly style_margin: (a: number) => any;
-  readonly style_maxSize: (a: number) => any;
-  readonly style_minSize: (a: number) => any;
-  readonly style_new: () => number;
-  readonly style_overflow: (a: number) => any;
-  readonly style_padding: (a: number) => any;
-  readonly style_position: (a: number) => number;
-  readonly style_set_alignContent: (a: number, b: any) => void;
-  readonly style_set_alignItems: (a: number, b: any) => void;
-  readonly style_set_alignSelf: (a: number, b: any) => void;
-  readonly style_set_aspectRatio: (a: number, b: any) => void;
-  readonly style_set_border: (a: number, b: any) => void;
-  readonly style_set_boxSizing: (a: number, b: number) => void;
-  readonly style_set_display: (a: number, b: number) => void;
-  readonly style_set_flexBasis: (a: number, b: any) => void;
-  readonly style_set_flexDirection: (a: number, b: number) => void;
-  readonly style_set_flexGrow: (a: number, b: number) => void;
-  readonly style_set_flexShrink: (a: number, b: number) => void;
-  readonly style_set_flexWrap: (a: number, b: number) => void;
-  readonly style_set_gap: (a: number, b: any) => void;
-  readonly style_set_inset: (a: number, b: any) => void;
-  readonly style_set_justifyContent: (a: number, b: any) => void;
-  readonly style_set_margin: (a: number, b: any) => void;
-  readonly style_set_maxSize: (a: number, b: any) => void;
-  readonly style_set_minSize: (a: number, b: any) => void;
-  readonly style_set_overflow: (a: number, b: any) => void;
-  readonly style_set_padding: (a: number, b: any) => void;
-  readonly style_set_position: (a: number, b: number) => void;
-  readonly style_set_size: (a: number, b: any) => void;
-  readonly style_size: (a: number) => any;
-  readonly taffyerror_message: (a: number) => [number, number];
-  readonly taffytree_addChild: (
-    a: number,
-    b: bigint,
-    c: bigint,
-  ) => [number, number];
-  readonly taffytree_childCount: (a: number, b: bigint) => number;
-  readonly taffytree_children: (
-    a: number,
-    b: bigint,
-  ) => [number, number, number, number];
-  readonly taffytree_clear: (a: number) => void;
-  readonly taffytree_computeLayout: (
-    a: number,
-    b: bigint,
-    c: any,
-  ) => [number, number];
-  readonly taffytree_computeLayoutWithMeasure: (
-    a: number,
-    b: bigint,
-    c: any,
-    d: any,
-  ) => [number, number];
-  readonly taffytree_dirty: (a: number, b: bigint) => [number, number, number];
-  readonly taffytree_disableRounding: (a: number) => void;
-  readonly taffytree_enableRounding: (a: number) => void;
-  readonly taffytree_getChildAtIndex: (
-    a: number,
-    b: bigint,
-    c: number,
-  ) => [bigint, number, number];
-  readonly taffytree_getDisjointNodeContextMut: (
-    a: number,
-    b: number,
-    c: number,
-  ) => [number, number, number, number];
-  readonly taffytree_getLayout: (
-    a: number,
-    b: bigint,
-  ) => [number, number, number];
-  readonly taffytree_getNodeContext: (
-    a: number,
-    b: bigint,
-  ) => [number, number, number];
-  readonly taffytree_getNodeContextMut: (
-    a: number,
-    b: bigint,
-  ) => [number, number, number];
-  readonly taffytree_getStyle: (
-    a: number,
-    b: bigint,
-  ) => [number, number, number];
-  readonly taffytree_insertChildAtIndex: (
-    a: number,
-    b: bigint,
-    c: number,
-    d: bigint,
-  ) => [number, number];
-  readonly taffytree_markDirty: (a: number, b: bigint) => [number, number];
-  readonly taffytree_new: () => number;
-  readonly taffytree_newLeaf: (
-    a: number,
-    b: number,
-  ) => [bigint, number, number];
-  readonly taffytree_newLeafWithContext: (
-    a: number,
-    b: number,
-    c: any,
-  ) => [bigint, number, number];
-  readonly taffytree_newWithChildren: (
-    a: number,
-    b: number,
-    c: number,
-    d: number,
-  ) => [bigint, number, number];
-  readonly taffytree_parent: (a: number, b: bigint) => [number, bigint];
-  readonly taffytree_printTree: (a: number, b: bigint) => void;
-  readonly taffytree_remove: (a: number, b: bigint) => [bigint, number, number];
-  readonly taffytree_removeChild: (
-    a: number,
-    b: bigint,
-    c: bigint,
-  ) => [bigint, number, number];
-  readonly taffytree_removeChildAtIndex: (
-    a: number,
-    b: bigint,
-    c: number,
-  ) => [bigint, number, number];
-  readonly taffytree_removeChildrenRange: (
-    a: number,
-    b: bigint,
-    c: number,
-    d: number,
-  ) => [number, number];
-  readonly taffytree_replaceChildAtIndex: (
-    a: number,
-    b: bigint,
-    c: number,
-    d: bigint,
-  ) => [bigint, number, number];
-  readonly taffytree_setChildren: (
-    a: number,
-    b: bigint,
-    c: number,
-    d: number,
-  ) => [number, number];
-  readonly taffytree_setNodeContext: (
-    a: number,
-    b: bigint,
-    c: any,
-  ) => [number, number];
-  readonly taffytree_setStyle: (
-    a: number,
-    b: bigint,
-    c: number,
-  ) => [number, number];
-  readonly taffytree_totalNodeCount: (a: number) => number;
-  readonly taffytree_unroundedLayout: (a: number, b: bigint) => number;
-  readonly taffytree_withCapacity: (a: number) => number;
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_realloc: (
-    a: number,
-    b: number,
-    c: number,
-    d: number,
-  ) => number;
-  readonly __wbindgen_exn_store: (a: number) => void;
-  readonly __externref_table_alloc: () => number;
-  readonly __wbindgen_externrefs: WebAssembly.Table;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __externref_table_dealloc: (a: number) => void;
-  readonly __externref_drop_slice: (a: number, b: number) => void;
-  readonly __wbindgen_start: () => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-
-/**
- * Instantiates the given `module`, which can either be bytes or
- * a precompiled `WebAssembly.Module`.
- *
- * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
- *
- * @returns {InitOutput}
- */
-export function initSync(
-  module: { module: SyncInitInput } | SyncInitInput,
-): InitOutput;
-
-/**
- * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
- * for everything else, calls `WebAssembly.instantiate` directly.
- *
- * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
- *
- * @returns {Promise<InitOutput>}
- */
-export default function __wbg_init(
-  module_or_path?:
-    | { module_or_path: InitInput | Promise<InitInput> }
-    | InitInput
-    | Promise<InitInput>,
-): Promise<InitOutput>;