@opentui/core 0.0.0-20251202-52296102 → 0.0.0-20251205-41c885f6

package/{index-re80811e.js → index-x5bb5xvn.js}

@@ -1,1286 +1,4 @@
 // @bun
-import {
-  __export,
-  __require,
-  __toESM
-} from "./index-g8dczzvv.js";
-
-// ../../node_modules/bun-yoga/dist/index.js
-var exports_dist = {};
-__export(exports_dist, {
-  default: () => dist_default,
-  Wrap: () => Wrap,
-  WRAP_WRAP_REVERSE: () => WRAP_WRAP_REVERSE,
-  WRAP_WRAP: () => WRAP_WRAP,
-  WRAP_NO_WRAP: () => WRAP_NO_WRAP,
-  Unit: () => Unit,
-  PositionType: () => PositionType,
-  POSITION_TYPE_STATIC: () => POSITION_TYPE_STATIC,
-  POSITION_TYPE_RELATIVE: () => POSITION_TYPE_RELATIVE,
-  POSITION_TYPE_ABSOLUTE: () => POSITION_TYPE_ABSOLUTE,
-  Overflow: () => Overflow,
-  OVERFLOW_VISIBLE: () => OVERFLOW_VISIBLE,
-  OVERFLOW_SCROLL: () => OVERFLOW_SCROLL,
-  OVERFLOW_HIDDEN: () => OVERFLOW_HIDDEN,
-  NodeType: () => NodeType,
-  Node: () => Node,
-  MeasureMode: () => MeasureMode,
-  LogLevel: () => LogLevel,
-  Justify: () => Justify,
-  JUSTIFY_SPACE_EVENLY: () => JUSTIFY_SPACE_EVENLY,
-  JUSTIFY_SPACE_BETWEEN: () => JUSTIFY_SPACE_BETWEEN,
-  JUSTIFY_SPACE_AROUND: () => JUSTIFY_SPACE_AROUND,
-  JUSTIFY_FLEX_START: () => JUSTIFY_FLEX_START,
-  JUSTIFY_FLEX_END: () => JUSTIFY_FLEX_END,
-  JUSTIFY_CENTER: () => JUSTIFY_CENTER,
-  Gutter: () => Gutter,
-  FlexDirection: () => FlexDirection,
-  FLEX_DIRECTION_ROW_REVERSE: () => FLEX_DIRECTION_ROW_REVERSE,
-  FLEX_DIRECTION_ROW: () => FLEX_DIRECTION_ROW,
-  FLEX_DIRECTION_COLUMN_REVERSE: () => FLEX_DIRECTION_COLUMN_REVERSE,
-  FLEX_DIRECTION_COLUMN: () => FLEX_DIRECTION_COLUMN,
-  ExperimentalFeature: () => ExperimentalFeature,
-  Errata: () => Errata,
-  Edge: () => Edge,
-  EDGE_VERTICAL: () => EDGE_VERTICAL,
-  EDGE_TOP: () => EDGE_TOP,
-  EDGE_START: () => EDGE_START,
-  EDGE_RIGHT: () => EDGE_RIGHT,
-  EDGE_LEFT: () => EDGE_LEFT,
-  EDGE_HORIZONTAL: () => EDGE_HORIZONTAL,
-  EDGE_END: () => EDGE_END,
-  EDGE_BOTTOM: () => EDGE_BOTTOM,
-  EDGE_ALL: () => EDGE_ALL,
-  Display: () => Display,
-  Direction: () => Direction,
-  Dimension: () => Dimension,
-  DISPLAY_NONE: () => DISPLAY_NONE,
-  DISPLAY_FLEX: () => DISPLAY_FLEX,
-  DIRECTION_RTL: () => DIRECTION_RTL,
-  DIRECTION_LTR: () => DIRECTION_LTR,
-  DIRECTION_INHERIT: () => DIRECTION_INHERIT,
-  Config: () => Config,
-  BoxSizing: () => BoxSizing,
-  Align: () => Align,
-  ALIGN_STRETCH: () => ALIGN_STRETCH,
-  ALIGN_SPACE_EVENLY: () => ALIGN_SPACE_EVENLY,
-  ALIGN_SPACE_BETWEEN: () => ALIGN_SPACE_BETWEEN,
-  ALIGN_SPACE_AROUND: () => ALIGN_SPACE_AROUND,
-  ALIGN_FLEX_START: () => ALIGN_FLEX_START,
-  ALIGN_FLEX_END: () => ALIGN_FLEX_END,
-  ALIGN_CENTER: () => ALIGN_CENTER,
-  ALIGN_BASELINE: () => ALIGN_BASELINE,
-  ALIGN_AUTO: () => ALIGN_AUTO
-});
-import { dlopen, suffix, JSCallback, FFIType } from "bun:ffi";
-import { join } from "path";
-import { existsSync } from "fs";
-var __dirname = "/Users/runner/work/opentui/opentui/node_modules/bun-yoga/dist";
-var embeddedLib = await (async () => {
-  try {
-    if (process.platform === "darwin" && process.arch === "arm64") {
-      return (await import("./libyoga-m7gmcz0e.js", { with: { type: "file" } })).default;
-    } else if (process.platform === "darwin" && process.arch === "x64") {
-      return (await import("./libyoga-jkq1dr7g.js", { with: { type: "file" } })).default;
-    } else if (process.platform === "linux" && process.arch === "x64") {
-      return (await import("./libyoga-zt51h244.js", { with: { type: "file" } })).default;
-    } else if (process.platform === "linux" && process.arch === "arm64") {
-      return (await import("./libyoga-jjdjx62k.js", { with: { type: "file" } })).default;
-    } else if (process.platform === "win32") {
-      return (await import("./yoga-merwjcba.js", { with: { type: "file" } })).default;
-    }
-  } catch {}
-  return;
-})();
-function getLibPath() {
-  if (process.platform === "win32") {
-    if (existsSync(join(__dirname, "..", "zig-out", "lib", `yoga.${suffix}`))) {
-      return join(__dirname, "..", "zig-out", "lib", `yoga.${suffix}`);
-    }
-    if (existsSync(join(__dirname, "..", "zig-out", "bin", `yoga.${suffix}`))) {
-      return join(__dirname, "..", "zig-out", "bin", `yoga.${suffix}`);
-    }
-  } else {
-    if (existsSync(join(__dirname, "..", "zig-out", "lib", `libyoga.${suffix}`))) {
-      return join(__dirname, "..", "zig-out", "lib", `libyoga.${suffix}`);
-    }
-  }
-  if (embeddedLib && existsSync(embeddedLib)) {
-    return embeddedLib;
-  }
-  throw new Error(`Could not find native library. Platform: ${process.platform}-${process.arch}
-Make sure to run 'zig build' or install the package with binaries.`);
-}
-var Align = {
-  Auto: 0,
-  FlexStart: 1,
-  Center: 2,
-  FlexEnd: 3,
-  Stretch: 4,
-  Baseline: 5,
-  SpaceBetween: 6,
-  SpaceAround: 7,
-  SpaceEvenly: 8
-};
-var BoxSizing = {
-  BorderBox: 0,
-  ContentBox: 1
-};
-var Dimension = {
-  Width: 0,
-  Height: 1
-};
-var Direction = {
-  Inherit: 0,
-  LTR: 1,
-  RTL: 2
-};
-var Display = {
-  Flex: 0,
-  None: 1,
-  Contents: 2
-};
-var Edge = {
-  Left: 0,
-  Top: 1,
-  Right: 2,
-  Bottom: 3,
-  Start: 4,
-  End: 5,
-  Horizontal: 6,
-  Vertical: 7,
-  All: 8
-};
-var Errata = {
-  None: 0,
-  StretchFlexBasis: 1,
-  AbsolutePositionWithoutInsetsExcludesPadding: 2,
-  AbsolutePercentAgainstInnerSize: 4,
-  All: 2147483647,
-  Classic: 2147483646
-};
-var ExperimentalFeature = {
-  WebFlexBasis: 0
-};
-var FlexDirection = {
-  Column: 0,
-  ColumnReverse: 1,
-  Row: 2,
-  RowReverse: 3
-};
-var Gutter = {
-  Column: 0,
-  Row: 1,
-  All: 2
-};
-var Justify = {
-  FlexStart: 0,
-  Center: 1,
-  FlexEnd: 2,
-  SpaceBetween: 3,
-  SpaceAround: 4,
-  SpaceEvenly: 5
-};
-var LogLevel = {
-  Error: 0,
-  Warn: 1,
-  Info: 2,
-  Debug: 3,
-  Verbose: 4,
-  Fatal: 5
-};
-var MeasureMode = {
-  Undefined: 0,
-  Exactly: 1,
-  AtMost: 2
-};
-var NodeType = {
-  Default: 0,
-  Text: 1
-};
-var Overflow = {
-  Visible: 0,
-  Hidden: 1,
-  Scroll: 2
-};
-var PositionType = {
-  Static: 0,
-  Relative: 1,
-  Absolute: 2
-};
-var Unit = {
-  Undefined: 0,
-  Point: 1,
-  Percent: 2,
-  Auto: 3
-};
-var Wrap = {
-  NoWrap: 0,
-  Wrap: 1,
-  WrapReverse: 2
-};
-var EDGE_LEFT = Edge.Left;
-var EDGE_TOP = Edge.Top;
-var EDGE_RIGHT = Edge.Right;
-var EDGE_BOTTOM = Edge.Bottom;
-var EDGE_START = Edge.Start;
-var EDGE_END = Edge.End;
-var EDGE_HORIZONTAL = Edge.Horizontal;
-var EDGE_VERTICAL = Edge.Vertical;
-var EDGE_ALL = Edge.All;
-var FLEX_DIRECTION_COLUMN = FlexDirection.Column;
-var FLEX_DIRECTION_COLUMN_REVERSE = FlexDirection.ColumnReverse;
-var FLEX_DIRECTION_ROW = FlexDirection.Row;
-var FLEX_DIRECTION_ROW_REVERSE = FlexDirection.RowReverse;
-var JUSTIFY_FLEX_START = Justify.FlexStart;
-var JUSTIFY_CENTER = Justify.Center;
-var JUSTIFY_FLEX_END = Justify.FlexEnd;
-var JUSTIFY_SPACE_BETWEEN = Justify.SpaceBetween;
-var JUSTIFY_SPACE_AROUND = Justify.SpaceAround;
-var JUSTIFY_SPACE_EVENLY = Justify.SpaceEvenly;
-var ALIGN_AUTO = Align.Auto;
-var ALIGN_FLEX_START = Align.FlexStart;
-var ALIGN_CENTER = Align.Center;
-var ALIGN_FLEX_END = Align.FlexEnd;
-var ALIGN_STRETCH = Align.Stretch;
-var ALIGN_BASELINE = Align.Baseline;
-var ALIGN_SPACE_BETWEEN = Align.SpaceBetween;
-var ALIGN_SPACE_AROUND = Align.SpaceAround;
-var ALIGN_SPACE_EVENLY = Align.SpaceEvenly;
-var WRAP_NO_WRAP = Wrap.NoWrap;
-var WRAP_WRAP = Wrap.Wrap;
-var WRAP_WRAP_REVERSE = Wrap.WrapReverse;
-var OVERFLOW_VISIBLE = Overflow.Visible;
-var OVERFLOW_HIDDEN = Overflow.Hidden;
-var OVERFLOW_SCROLL = Overflow.Scroll;
-var DISPLAY_FLEX = Display.Flex;
-var DISPLAY_NONE = Display.None;
-var POSITION_TYPE_STATIC = PositionType.Static;
-var POSITION_TYPE_RELATIVE = PositionType.Relative;
-var POSITION_TYPE_ABSOLUTE = PositionType.Absolute;
-var DIRECTION_INHERIT = Direction.Inherit;
-var DIRECTION_LTR = Direction.LTR;
-var DIRECTION_RTL = Direction.RTL;
-function parseValue(value) {
-  if (value === undefined) {
-    return { unit: Unit.Undefined, asNumber: undefined };
-  }
-  if (value === "auto") {
-    return { unit: Unit.Auto, asNumber: undefined };
-  }
-  if (typeof value === "string" && value.endsWith("%")) {
-    return { unit: Unit.Percent, asNumber: parseFloat(value) };
-  }
-  return { unit: Unit.Point, asNumber: value };
-}
-var UNDEFINED_VALUE = { unit: Unit.Undefined, value: NaN };
-function unpackValue(packed) {
-  const p = BigInt(packed);
-  const unit = Number(p & 0xffffffffn);
-  const valueBits = Number(p >> 32n & 0xffffffffn);
-  const buffer = new ArrayBuffer(4);
-  const view = new DataView(buffer);
-  view.setUint32(0, valueBits, true);
-  const value = view.getFloat32(0, true);
-  return { unit, value };
-}
-var lib = dlopen(getLibPath(), {
-  ygConfigNew: { args: [], returns: "ptr" },
-  ygConfigFree: { args: ["ptr"], returns: "void" },
-  ygConfigGetDefault: { args: [], returns: "ptr" },
-  ygConfigSetUseWebDefaults: { args: ["ptr", "bool"], returns: "void" },
-  ygConfigGetUseWebDefaults: { args: ["ptr"], returns: "bool" },
-  ygConfigSetPointScaleFactor: { args: ["ptr", "f32"], returns: "void" },
-  ygConfigGetPointScaleFactor: { args: ["ptr"], returns: "f32" },
-  ygConfigSetErrata: { args: ["ptr", "i32"], returns: "void" },
-  ygConfigGetErrata: { args: ["ptr"], returns: "i32" },
-  ygConfigSetExperimentalFeatureEnabled: {
-    args: ["ptr", "i32", "bool"],
-    returns: "void"
-  },
-  ygConfigIsExperimentalFeatureEnabled: {
-    args: ["ptr", "i32"],
-    returns: "bool"
-  },
-  ygNodeNew: { args: [], returns: "ptr" },
-  ygNodeNewWithConfig: { args: ["ptr"], returns: "ptr" },
-  ygNodeClone: { args: ["ptr"], returns: "ptr" },
-  ygNodeFree: { args: ["ptr"], returns: "void" },
-  ygNodeFreeRecursive: { args: ["ptr"], returns: "void" },
-  ygNodeReset: { args: ["ptr"], returns: "void" },
-  ygNodeCopyStyle: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeSetIsReferenceBaseline: { args: ["ptr", "bool"], returns: "void" },
-  ygNodeIsReferenceBaseline: { args: ["ptr"], returns: "bool" },
-  ygNodeSetAlwaysFormsContainingBlock: {
-    args: ["ptr", "bool"],
-    returns: "void"
-  },
-  ygNodeInsertChild: { args: ["ptr", "ptr", "u64"], returns: "void" },
-  ygNodeRemoveChild: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeRemoveAllChildren: { args: ["ptr"], returns: "void" },
-  ygNodeGetChild: { args: ["ptr", "u64"], returns: "ptr" },
-  ygNodeGetChildCount: { args: ["ptr"], returns: "u64" },
-  ygNodeGetParent: { args: ["ptr"], returns: "ptr" },
-  ygNodeCalculateLayout: { args: ["ptr", "f32", "f32", "i32"], returns: "void" },
-  ygNodeGetHasNewLayout: { args: ["ptr"], returns: "bool" },
-  ygNodeSetHasNewLayout: { args: ["ptr", "bool"], returns: "void" },
-  ygNodeMarkDirty: { args: ["ptr"], returns: "void" },
-  ygNodeIsDirty: { args: ["ptr"], returns: "bool" },
-  ygNodeLayoutGetLeft: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetTop: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetRight: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetBottom: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetWidth: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetHeight: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetBorder: { args: ["ptr", "i32"], returns: "f32" },
-  ygNodeLayoutGetMargin: { args: ["ptr", "i32"], returns: "f32" },
-  ygNodeLayoutGetPadding: { args: ["ptr", "i32"], returns: "f32" },
-  ygNodeStyleSetDirection: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetDirection: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetFlexDirection: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetFlexDirection: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetJustifyContent: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetJustifyContent: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetAlignContent: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetAlignContent: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetAlignItems: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetAlignItems: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetAlignSelf: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetAlignSelf: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetPositionType: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetPositionType: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetFlexWrap: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetFlexWrap: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetOverflow: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetOverflow: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetDisplay: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetDisplay: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetBoxSizing: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetBoxSizing: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetFlex: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleGetFlex: { args: ["ptr"], returns: "f32" },
-  ygNodeStyleSetFlexGrow: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleGetFlexGrow: { args: ["ptr"], returns: "f32" },
-  ygNodeStyleSetFlexShrink: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleGetFlexShrink: { args: ["ptr"], returns: "f32" },
-  ygNodeStyleSetFlexBasis: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetFlexBasisPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetFlexBasisAuto: { args: ["ptr"], returns: "void" },
-  ygNodeStyleSetPosition: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetPositionPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetPositionAuto: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleSetMargin: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetMarginPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetMarginAuto: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleSetPadding: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetPaddingPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetBorder: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleGetBorder: { args: ["ptr", "i32"], returns: "f32" },
-  ygNodeStyleSetGap: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetGapPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetWidth: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetWidthPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetWidthAuto: { args: ["ptr"], returns: "void" },
-  ygNodeStyleSetHeight: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetHeightPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetHeightAuto: { args: ["ptr"], returns: "void" },
-  ygNodeStyleSetMinWidth: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMinWidthPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMinHeight: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMinHeightPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMaxWidth: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMaxWidthPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMaxHeight: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMaxHeightPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetAspectRatio: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleGetAspectRatio: { args: ["ptr"], returns: "f32" },
-  ygNodeSetContext: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeGetContext: { args: ["ptr"], returns: "ptr" },
-  ygNodeSetMeasureFunc: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetMeasureFunc: { args: ["ptr"], returns: "void" },
-  ygNodeHasMeasureFunc: { args: ["ptr"], returns: "bool" },
-  ygNodeSetBaselineFunc: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetBaselineFunc: { args: ["ptr"], returns: "void" },
-  ygNodeHasBaselineFunc: { args: ["ptr"], returns: "bool" },
-  ygNodeSetDirtiedFunc: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetDirtiedFunc: { args: ["ptr"], returns: "void" },
-  ygNodeGetDirtiedFunc: { args: ["ptr"], returns: "ptr" },
-  ygCreateSize: { args: ["f32", "f32"], returns: "u64" },
-  ygStoreMeasureResult: { args: ["f32", "f32"], returns: "void" },
-  ygStoreBaselineResult: { args: ["f32"], returns: "void" },
-  ygNodeSetMeasureFuncTrampoline: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetMeasureFuncTrampoline: { args: ["ptr"], returns: "void" },
-  ygNodeSetBaselineFuncTrampoline: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetBaselineFuncTrampoline: { args: ["ptr"], returns: "void" },
-  ygNodeFreeCallbacks: { args: ["ptr"], returns: "void" },
-  ygNodeStyleGetWidthPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetHeightPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMinWidthPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMinHeightPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMaxWidthPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMaxHeightPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMarginPacked: { args: ["ptr", "i32"], returns: "u64" },
-  ygNodeStyleGetPaddingPacked: { args: ["ptr", "i32"], returns: "u64" },
-  ygNodeStyleGetPositionPacked: { args: ["ptr", "i32"], returns: "u64" },
-  ygNodeStyleGetGapPacked: { args: ["ptr", "i32"], returns: "u64" },
-  ygNodeStyleGetFlexBasisPacked: { args: ["ptr"], returns: "u64" }
-});
-var yg = lib.symbols;
-
-class Node {
-  ptr;
-  _freed = false;
-  measureCallback = null;
-  baselineCallback = null;
-  dirtiedCallback = null;
-  constructor(ptr) {
-    this.ptr = ptr;
-  }
-  isFreed() {
-    return this._freed;
-  }
-  static create(config) {
-    const ptr = config ? yg.ygNodeNewWithConfig(config["ptr"]) : yg.ygNodeNew();
-    if (!ptr)
-      throw new Error("Failed to create node");
-    return new Node(ptr);
-  }
-  static createDefault() {
-    return Node.create();
-  }
-  static createWithConfig(config) {
-    return Node.create(config);
-  }
-  static destroy(node) {
-    node.free();
-  }
-  free() {
-    if (this._freed)
-      return;
-    this.unsetMeasureFunc();
-    this.unsetBaselineFunc();
-    this.unsetDirtiedFunc();
-    yg.ygNodeFree(this.ptr);
-    this._freed = true;
-  }
-  freeRecursive() {
-    if (this._freed)
-      return;
-    this.cleanupCallbacks();
-    yg.ygNodeFreeRecursive(this.ptr);
-    this._freed = true;
-  }
-  reset() {
-    if (this._freed)
-      return;
-    this.cleanupCallbacks();
-    yg.ygNodeReset(this.ptr);
-  }
-  cleanupCallbacks() {
-    if (this.measureCallback) {
-      this.measureCallback.close();
-      this.measureCallback = null;
-    }
-    if (this.baselineCallback) {
-      this.baselineCallback.close();
-      this.baselineCallback = null;
-    }
-    if (this.dirtiedCallback) {
-      this.dirtiedCallback.close();
-      this.dirtiedCallback = null;
-    }
-  }
-  clone() {
-    if (this._freed)
-      throw new Error("Cannot clone freed node");
-    const ptr = yg.ygNodeClone(this.ptr);
-    if (!ptr)
-      throw new Error("Failed to clone node");
-    return new Node(ptr);
-  }
-  copyStyle(node) {
-    if (this._freed)
-      return;
-    yg.ygNodeCopyStyle(this.ptr, node.ptr);
-  }
-  setIsReferenceBaseline(isReferenceBaseline) {
-    if (this._freed)
-      return;
-    yg.ygNodeSetIsReferenceBaseline(this.ptr, isReferenceBaseline);
-  }
-  isReferenceBaseline() {
-    if (this._freed)
-      return false;
-    return yg.ygNodeIsReferenceBaseline(this.ptr);
-  }
-  setAlwaysFormsContainingBlock(alwaysFormsContainingBlock) {
-    if (this._freed)
-      return;
-    yg.ygNodeSetAlwaysFormsContainingBlock(this.ptr, alwaysFormsContainingBlock);
-  }
-  insertChild(child, index) {
-    if (this._freed)
-      return;
-    yg.ygNodeInsertChild(this.ptr, child.ptr, index);
-  }
-  removeChild(child) {
-    if (this._freed)
-      return;
-    yg.ygNodeRemoveChild(this.ptr, child.ptr);
-  }
-  removeAllChildren() {
-    if (this._freed)
-      return;
-    yg.ygNodeRemoveAllChildren(this.ptr);
-  }
-  getChild(index) {
-    if (this._freed)
-      return null;
-    const ptr = yg.ygNodeGetChild(this.ptr, index);
-    return ptr ? new Node(ptr) : null;
-  }
-  getChildCount() {
-    if (this._freed)
-      return 0;
-    return Number(yg.ygNodeGetChildCount(this.ptr));
-  }
-  getParent() {
-    if (this._freed)
-      return null;
-    const ptr = yg.ygNodeGetParent(this.ptr);
-    return ptr ? new Node(ptr) : null;
-  }
-  calculateLayout(width, height, direction = Direction.LTR) {
-    if (this._freed)
-      return;
-    const w = width === "auto" || width === undefined ? NaN : width;
-    const h = height === "auto" || height === undefined ? NaN : height;
-    yg.ygNodeCalculateLayout(this.ptr, w, h, direction);
-  }
-  hasNewLayout() {
-    if (this._freed)
-      return false;
-    return yg.ygNodeGetHasNewLayout(this.ptr);
-  }
-  markLayoutSeen() {
-    if (this._freed)
-      return;
-    yg.ygNodeSetHasNewLayout(this.ptr, false);
-  }
-  markDirty() {
-    if (this._freed)
-      return;
-    yg.ygNodeMarkDirty(this.ptr);
-  }
-  isDirty() {
-    if (this._freed)
-      return true;
-    return yg.ygNodeIsDirty(this.ptr);
-  }
-  getComputedLayout() {
-    if (this._freed)
-      return { left: 0, top: 0, right: 0, bottom: 0, width: 0, height: 0 };
-    return {
-      left: yg.ygNodeLayoutGetLeft(this.ptr),
-      top: yg.ygNodeLayoutGetTop(this.ptr),
-      right: yg.ygNodeLayoutGetRight(this.ptr),
-      bottom: yg.ygNodeLayoutGetBottom(this.ptr),
-      width: yg.ygNodeLayoutGetWidth(this.ptr),
-      height: yg.ygNodeLayoutGetHeight(this.ptr)
-    };
-  }
-  getComputedLeft() {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetLeft(this.ptr);
-  }
-  getComputedTop() {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetTop(this.ptr);
-  }
-  getComputedRight() {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetRight(this.ptr);
-  }
-  getComputedBottom() {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetBottom(this.ptr);
-  }
-  getComputedWidth() {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetWidth(this.ptr);
-  }
-  getComputedHeight() {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetHeight(this.ptr);
-  }
-  getComputedBorder(edge) {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetBorder(this.ptr, edge);
-  }
-  getComputedMargin(edge) {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetMargin(this.ptr, edge);
-  }
-  getComputedPadding(edge) {
-    if (this._freed)
-      return 0;
-    return yg.ygNodeLayoutGetPadding(this.ptr, edge);
-  }
-  setDirection(direction) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetDirection(this.ptr, direction);
-  }
-  getDirection() {
-    if (this._freed)
-      return Direction.Inherit;
-    return yg.ygNodeStyleGetDirection(this.ptr);
-  }
-  setFlexDirection(flexDirection) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetFlexDirection(this.ptr, flexDirection);
-  }
-  getFlexDirection() {
-    if (this._freed)
-      return FlexDirection.Column;
-    return yg.ygNodeStyleGetFlexDirection(this.ptr);
-  }
-  setJustifyContent(justifyContent) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetJustifyContent(this.ptr, justifyContent);
-  }
-  getJustifyContent() {
-    if (this._freed)
-      return Justify.FlexStart;
-    return yg.ygNodeStyleGetJustifyContent(this.ptr);
-  }
-  setAlignContent(alignContent) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetAlignContent(this.ptr, alignContent);
-  }
-  getAlignContent() {
-    if (this._freed)
-      return Align.Auto;
-    return yg.ygNodeStyleGetAlignContent(this.ptr);
-  }
-  setAlignItems(alignItems) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetAlignItems(this.ptr, alignItems);
-  }
-  getAlignItems() {
-    if (this._freed)
-      return Align.Auto;
-    return yg.ygNodeStyleGetAlignItems(this.ptr);
-  }
-  setAlignSelf(alignSelf) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetAlignSelf(this.ptr, alignSelf);
-  }
-  getAlignSelf() {
-    if (this._freed)
-      return Align.Auto;
-    return yg.ygNodeStyleGetAlignSelf(this.ptr);
-  }
-  setPositionType(positionType) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetPositionType(this.ptr, positionType);
-  }
-  getPositionType() {
-    if (this._freed)
-      return PositionType.Static;
-    return yg.ygNodeStyleGetPositionType(this.ptr);
-  }
-  setFlexWrap(flexWrap) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetFlexWrap(this.ptr, flexWrap);
-  }
-  getFlexWrap() {
-    if (this._freed)
-      return Wrap.NoWrap;
-    return yg.ygNodeStyleGetFlexWrap(this.ptr);
-  }
-  setOverflow(overflow) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetOverflow(this.ptr, overflow);
-  }
-  getOverflow() {
-    if (this._freed)
-      return Overflow.Visible;
-    return yg.ygNodeStyleGetOverflow(this.ptr);
-  }
-  setDisplay(display) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetDisplay(this.ptr, display);
-  }
-  getDisplay() {
-    if (this._freed)
-      return Display.Flex;
-    return yg.ygNodeStyleGetDisplay(this.ptr);
-  }
-  setBoxSizing(boxSizing) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetBoxSizing(this.ptr, boxSizing);
-  }
-  getBoxSizing() {
-    if (this._freed)
-      return BoxSizing.BorderBox;
-    return yg.ygNodeStyleGetBoxSizing(this.ptr);
-  }
-  setFlex(flex) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetFlex(this.ptr, flex);
-  }
-  getFlex() {
-    if (this._freed)
-      return NaN;
-    return yg.ygNodeStyleGetFlex(this.ptr);
-  }
-  setFlexGrow(flexGrow) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetFlexGrow(this.ptr, flexGrow);
-  }
-  getFlexGrow() {
-    if (this._freed)
-      return NaN;
-    return yg.ygNodeStyleGetFlexGrow(this.ptr);
-  }
-  setFlexShrink(flexShrink) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetFlexShrink(this.ptr, flexShrink);
-  }
-  getFlexShrink() {
-    if (this._freed)
-      return NaN;
-    return yg.ygNodeStyleGetFlexShrink(this.ptr);
-  }
-  setFlexBasis(flexBasis) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(flexBasis);
-    if (unit === Unit.Auto) {
-      yg.ygNodeStyleSetFlexBasisAuto(this.ptr);
-    } else if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetFlexBasisPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetFlexBasis(this.ptr, asNumber);
-    }
-  }
-  setFlexBasisPercent(flexBasis) {
-    if (this._freed)
-      return;
-    if (flexBasis !== undefined) {
-      yg.ygNodeStyleSetFlexBasisPercent(this.ptr, flexBasis);
-    }
-  }
-  setFlexBasisAuto() {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetFlexBasisAuto(this.ptr);
-  }
-  setPosition(edge, position) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(position);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetPositionPercent(this.ptr, edge, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetPosition(this.ptr, edge, asNumber);
-    }
-  }
-  setPositionPercent(edge, position) {
-    if (this._freed)
-      return;
-    if (position !== undefined) {
-      yg.ygNodeStyleSetPositionPercent(this.ptr, edge, position);
-    }
-  }
-  setPositionAuto(edge) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetPositionAuto(this.ptr, edge);
-  }
-  setMargin(edge, margin) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(margin);
-    if (unit === Unit.Auto) {
-      yg.ygNodeStyleSetMarginAuto(this.ptr, edge);
-    } else if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMarginPercent(this.ptr, edge, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMargin(this.ptr, edge, asNumber);
-    }
-  }
-  setMarginPercent(edge, margin) {
-    if (this._freed)
-      return;
-    if (margin !== undefined) {
-      yg.ygNodeStyleSetMarginPercent(this.ptr, edge, margin);
-    }
-  }
-  setMarginAuto(edge) {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetMarginAuto(this.ptr, edge);
-  }
-  setPadding(edge, padding) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(padding);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetPaddingPercent(this.ptr, edge, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetPadding(this.ptr, edge, asNumber);
-    }
-  }
-  setPaddingPercent(edge, padding) {
-    if (this._freed)
-      return;
-    if (padding !== undefined) {
-      yg.ygNodeStyleSetPaddingPercent(this.ptr, edge, padding);
-    }
-  }
-  setBorder(edge, border) {
-    if (this._freed)
-      return;
-    if (border !== undefined) {
-      yg.ygNodeStyleSetBorder(this.ptr, edge, border);
-    }
-  }
-  getBorder(edge) {
-    if (this._freed)
-      return NaN;
-    return yg.ygNodeStyleGetBorder(this.ptr, edge);
-  }
-  setGap(gutter, gap) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(gap);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetGapPercent(this.ptr, gutter, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetGap(this.ptr, gutter, asNumber);
-    }
-  }
-  setGapPercent(gutter, gap) {
-    if (this._freed)
-      return;
-    if (gap !== undefined) {
-      yg.ygNodeStyleSetGapPercent(this.ptr, gutter, gap);
-    }
-  }
-  setWidth(width) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(width);
-    if (unit === Unit.Auto) {
-      yg.ygNodeStyleSetWidthAuto(this.ptr);
-    } else if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetWidthPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetWidth(this.ptr, asNumber);
-    }
-  }
-  setWidthPercent(width) {
-    if (this._freed)
-      return;
-    if (width !== undefined) {
-      yg.ygNodeStyleSetWidthPercent(this.ptr, width);
-    }
-  }
-  setWidthAuto() {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetWidthAuto(this.ptr);
-  }
-  setHeight(height) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(height);
-    if (unit === Unit.Auto) {
-      yg.ygNodeStyleSetHeightAuto(this.ptr);
-    } else if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetHeightPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetHeight(this.ptr, asNumber);
-    }
-  }
-  setHeightPercent(height) {
-    if (this._freed)
-      return;
-    if (height !== undefined) {
-      yg.ygNodeStyleSetHeightPercent(this.ptr, height);
-    }
-  }
-  setHeightAuto() {
-    if (this._freed)
-      return;
-    yg.ygNodeStyleSetHeightAuto(this.ptr);
-  }
-  setMinWidth(minWidth) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(minWidth);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMinWidthPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMinWidth(this.ptr, asNumber);
-    }
-  }
-  setMinWidthPercent(minWidth) {
-    if (this._freed)
-      return;
-    if (minWidth !== undefined) {
-      yg.ygNodeStyleSetMinWidthPercent(this.ptr, minWidth);
-    }
-  }
-  setMinHeight(minHeight) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(minHeight);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMinHeightPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMinHeight(this.ptr, asNumber);
-    }
-  }
-  setMinHeightPercent(minHeight) {
-    if (this._freed)
-      return;
-    if (minHeight !== undefined) {
-      yg.ygNodeStyleSetMinHeightPercent(this.ptr, minHeight);
-    }
-  }
-  setMaxWidth(maxWidth) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(maxWidth);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMaxWidthPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMaxWidth(this.ptr, asNumber);
-    }
-  }
-  setMaxWidthPercent(maxWidth) {
-    if (this._freed)
-      return;
-    if (maxWidth !== undefined) {
-      yg.ygNodeStyleSetMaxWidthPercent(this.ptr, maxWidth);
-    }
-  }
-  setMaxHeight(maxHeight) {
-    if (this._freed)
-      return;
-    const { unit, asNumber } = parseValue(maxHeight);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMaxHeightPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMaxHeight(this.ptr, asNumber);
-    }
-  }
-  setMaxHeightPercent(maxHeight) {
-    if (this._freed)
-      return;
-    if (maxHeight !== undefined) {
-      yg.ygNodeStyleSetMaxHeightPercent(this.ptr, maxHeight);
-    }
-  }
-  setAspectRatio(aspectRatio) {
-    if (this._freed)
-      return;
-    if (aspectRatio !== undefined) {
-      yg.ygNodeStyleSetAspectRatio(this.ptr, aspectRatio);
-    }
-  }
-  getAspectRatio() {
-    if (this._freed)
-      return NaN;
-    return yg.ygNodeStyleGetAspectRatio(this.ptr);
-  }
-  getWidth() {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetWidthPacked(this.ptr));
-  }
-  getHeight() {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetHeightPacked(this.ptr));
-  }
-  getMinWidth() {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetMinWidthPacked(this.ptr));
-  }
-  getMinHeight() {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetMinHeightPacked(this.ptr));
-  }
-  getMaxWidth() {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetMaxWidthPacked(this.ptr));
-  }
-  getMaxHeight() {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetMaxHeightPacked(this.ptr));
-  }
-  getMargin(edge) {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetMarginPacked(this.ptr, edge));
-  }
-  getPadding(edge) {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetPaddingPacked(this.ptr, edge));
-  }
-  getPosition(edge) {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetPositionPacked(this.ptr, edge));
-  }
-  getGap(gutter) {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetGapPacked(this.ptr, gutter));
-  }
-  getFlexBasis() {
-    if (this._freed)
-      return UNDEFINED_VALUE;
-    return unpackValue(yg.ygNodeStyleGetFlexBasisPacked(this.ptr));
-  }
-  setMeasureFunc(measureFunc) {
-    if (this._freed)
-      return;
-    this.unsetMeasureFunc();
-    if (measureFunc) {
-      this.measureCallback = new JSCallback((nodePtr, width, widthMode, height, heightMode) => {
-        const result = measureFunc(width, widthMode, height, heightMode);
-        yg.ygStoreMeasureResult(result.width, result.height);
-      }, {
-        args: [
-          FFIType.ptr,
-          FFIType.f32,
-          FFIType.u32,
-          FFIType.f32,
-          FFIType.u32
-        ],
-        returns: FFIType.void
-      });
-      if (this.measureCallback.ptr) {
-        yg.ygNodeSetMeasureFuncTrampoline(this.ptr, this.measureCallback.ptr);
-      }
-    }
-  }
-  unsetMeasureFunc() {
-    if (this._freed)
-      return;
-    if (this.measureCallback) {
-      this.measureCallback.close();
-      this.measureCallback = null;
-    }
-    yg.ygNodeUnsetMeasureFuncTrampoline(this.ptr);
-  }
-  hasMeasureFunc() {
-    if (this._freed)
-      return false;
-    return yg.ygNodeHasMeasureFunc(this.ptr);
-  }
-  setBaselineFunc(baselineFunc) {
-    if (this._freed)
-      return;
-    this.unsetBaselineFunc();
-    if (baselineFunc) {
-      this.baselineCallback = new JSCallback((nodePtr, width, height) => {
-        const result = baselineFunc(width, height);
-        yg.ygStoreBaselineResult(result);
-      }, {
-        args: [FFIType.ptr, FFIType.f32, FFIType.f32],
-        returns: FFIType.void
-      });
-      if (this.baselineCallback.ptr) {
-        yg.ygNodeSetBaselineFuncTrampoline(this.ptr, this.baselineCallback.ptr);
-      }
-    }
-  }
-  unsetBaselineFunc() {
-    if (this._freed)
-      return;
-    if (this.baselineCallback) {
-      this.baselineCallback.close();
-      this.baselineCallback = null;
-    }
-    yg.ygNodeUnsetBaselineFuncTrampoline(this.ptr);
-  }
-  hasBaselineFunc() {
-    if (this._freed)
-      return false;
-    return yg.ygNodeHasBaselineFunc(this.ptr);
-  }
-  setDirtiedFunc(dirtiedFunc) {
-    if (this._freed)
-      return;
-    this.unsetDirtiedFunc();
-    if (dirtiedFunc) {
-      const node = this;
-      this.dirtiedCallback = new JSCallback((nodePtr) => {
-        dirtiedFunc(node);
-      }, {
-        args: [FFIType.ptr],
-        returns: FFIType.void
-      });
-      if (this.dirtiedCallback.ptr) {
-        yg.ygNodeSetDirtiedFunc(this.ptr, this.dirtiedCallback.ptr);
-      }
-    }
-  }
-  unsetDirtiedFunc() {
-    if (this._freed)
-      return;
-    if (this.dirtiedCallback) {
-      this.dirtiedCallback.close();
-      this.dirtiedCallback = null;
-    }
-    yg.ygNodeUnsetDirtiedFunc(this.ptr);
-  }
-  hasDirtiedFunc() {
-    if (this._freed)
-      return false;
-    return yg.ygNodeGetDirtiedFunc(this.ptr) !== null;
-  }
-}
-
-class Config {
-  ptr;
-  constructor(ptr) {
-    this.ptr = ptr;
-  }
-  static create() {
-    const ptr = yg.ygConfigNew();
-    if (!ptr)
-      throw new Error("Failed to create config");
-    return new Config(ptr);
-  }
-  static destroy(config) {
-    config.free();
-  }
-  free() {
-    yg.ygConfigFree(this.ptr);
-  }
-  setUseWebDefaults(useWebDefaults) {
-    yg.ygConfigSetUseWebDefaults(this.ptr, useWebDefaults);
-  }
-  useWebDefaults() {
-    return yg.ygConfigGetUseWebDefaults(this.ptr);
-  }
-  setPointScaleFactor(pointScaleFactor) {
-    yg.ygConfigSetPointScaleFactor(this.ptr, pointScaleFactor);
-  }
-  getPointScaleFactor() {
-    return yg.ygConfigGetPointScaleFactor(this.ptr);
-  }
-  setErrata(errata) {
-    yg.ygConfigSetErrata(this.ptr, errata);
-  }
-  getErrata() {
-    return yg.ygConfigGetErrata(this.ptr);
-  }
-  setExperimentalFeatureEnabled(feature, enabled) {
-    yg.ygConfigSetExperimentalFeatureEnabled(this.ptr, feature, enabled);
-  }
-  isExperimentalFeatureEnabled(feature) {
-    return yg.ygConfigIsExperimentalFeatureEnabled(this.ptr, feature);
-  }
-}
-var dist_default = {
-  Node,
-  Config,
-  Align,
-  BoxSizing,
-  Dimension,
-  Direction,
-  Display,
-  Edge,
-  Errata,
-  ExperimentalFeature,
-  FlexDirection,
-  Gutter,
-  Justify,
-  LogLevel,
-  MeasureMode,
-  NodeType,
-  Overflow,
-  PositionType,
-  Unit,
-  Wrap,
-  EDGE_LEFT,
-  EDGE_TOP,
-  EDGE_RIGHT,
-  EDGE_BOTTOM,
-  EDGE_START,
-  EDGE_END,
-  EDGE_HORIZONTAL,
-  EDGE_VERTICAL,
-  EDGE_ALL,
-  FLEX_DIRECTION_COLUMN,
-  FLEX_DIRECTION_COLUMN_REVERSE,
-  FLEX_DIRECTION_ROW,
-  FLEX_DIRECTION_ROW_REVERSE,
-  JUSTIFY_FLEX_START,
-  JUSTIFY_CENTER,
-  JUSTIFY_FLEX_END,
-  JUSTIFY_SPACE_BETWEEN,
-  JUSTIFY_SPACE_AROUND,
-  JUSTIFY_SPACE_EVENLY,
-  ALIGN_AUTO,
-  ALIGN_FLEX_START,
-  ALIGN_CENTER,
-  ALIGN_FLEX_END,
-  ALIGN_STRETCH,
-  ALIGN_BASELINE,
-  ALIGN_SPACE_BETWEEN,
-  ALIGN_SPACE_AROUND,
-  ALIGN_SPACE_EVENLY,
-  WRAP_NO_WRAP,
-  WRAP_WRAP,
-  WRAP_WRAP_REVERSE,
-  OVERFLOW_VISIBLE,
-  OVERFLOW_HIDDEN,
-  OVERFLOW_SCROLL,
-  DISPLAY_FLEX,
-  DISPLAY_NONE,
-  POSITION_TYPE_STATIC,
-  POSITION_TYPE_RELATIVE,
-  POSITION_TYPE_ABSOLUTE,
-  DIRECTION_INHERIT,
-  DIRECTION_LTR,
-  DIRECTION_RTL
-};
-
 // src/lib/border.ts
 var BorderChars = {
   single: {
@@ -5709,6 +4427,23 @@ class StdinBuffer extends EventEmitter2 {
 }
 
 // src/lib/yoga.options.ts
+import {
+  BoxSizing,
+  Align,
+  Dimension,
+  Direction,
+  Display,
+  Edge,
+  FlexDirection,
+  Gutter,
+  Justify,
+  LogLevel,
+  MeasureMode,
+  Overflow,
+  PositionType,
+  Unit,
+  Wrap
+} from "bun-yoga";
 function parseAlign(value) {
   if (value == null) {
     return Align.Auto;
@@ -6818,7 +5553,7 @@ function getParsers() {
 
 // src/lib/tree-sitter/client.ts
 import { resolve as resolve2, isAbsolute } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 import { parse } from "path";
 registerEnvVar({
   name: "OTUI_TREE_SITTER_WORKER_PATH",
@@ -6879,7 +5614,7 @@ class TreeSitterClient extends EventEmitter3 {
       worker_path = this.options.workerPath;
     } else {
       worker_path = new URL("./parser.worker.js", import.meta.url).href;
-      if (!existsSync2(resolve2(import.meta.dirname, "parser.worker.js"))) {
+      if (!existsSync(resolve2(import.meta.dirname, "parser.worker.js"))) {
         worker_path = new URL("./parser.worker.ts", import.meta.url).href;
       }
     }
@@ -8772,8 +7507,8 @@ function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux) {
   return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux);
 }
 // src/zig.ts
-import { dlopen as dlopen2, toArrayBuffer as toArrayBuffer4, JSCallback as JSCallback2, ptr as ptr3 } from "bun:ffi";
-import { existsSync as existsSync3 } from "fs";
+import { dlopen, toArrayBuffer as toArrayBuffer3, JSCallback, ptr as ptr2 } from "bun:ffi";
+import { existsSync as existsSync2 } from "fs";
 import { EventEmitter as EventEmitter5 } from "events";
 
 // src/buffer.ts
@@ -8840,9 +7575,9 @@ class OptimizedBuffer {
     }
     return this._rawBuffers;
   }
-  constructor(lib2, ptr, width, height, options) {
+  constructor(lib, ptr, width, height, options) {
     this.id = options.id || `fb_${OptimizedBuffer.fbIdCounter++}`;
-    this.lib = lib2;
+    this.lib = lib;
     this.respectAlpha = options.respectAlpha || false;
     this._width = width;
     this._height = height;
@@ -8850,10 +7585,10 @@ class OptimizedBuffer {
     this.bufferPtr = ptr;
   }
   static create(width, height, widthMethod, options = {}) {
-    const lib2 = resolveRenderLib();
+    const lib = resolveRenderLib();
     const respectAlpha = options.respectAlpha || false;
     const id = options.id && options.id.trim() !== "" ? options.id : "unnamed buffer";
-    const buffer = lib2.createOptimizedBuffer(width, height, widthMethod, respectAlpha, id);
+    const buffer = lib.createOptimizedBuffer(width, height, widthMethod, respectAlpha, id);
     return buffer;
   }
   get widthMethod() {
@@ -8994,618 +7729,11 @@ class OptimizedBuffer {
   }
 }
 
-// ../../node_modules/bun-ffi-structs/index.js
-import { ptr, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
-function fatalError(...args) {
-  const message = args.join(" ");
-  console.error("FATAL ERROR:", message);
-  throw new Error(message);
-}
-var pointerSize = process.arch === "x64" || process.arch === "arm64" ? 8 : 4;
-var typeSizes = {
-  u8: 1,
-  bool_u8: 1,
-  bool_u32: 4,
-  u16: 2,
-  i16: 2,
-  u32: 4,
-  u64: 8,
-  f32: 4,
-  f64: 8,
-  pointer: pointerSize,
-  i32: 4
-};
-var primitiveKeys = Object.keys(typeSizes);
-function isPrimitiveType(type) {
-  return typeof type === "string" && primitiveKeys.includes(type);
-}
-var typeAlignments = { ...typeSizes };
-var typeGetters = {
-  u8: (view, offset) => view.getUint8(offset),
-  bool_u8: (view, offset) => Boolean(view.getUint8(offset)),
-  bool_u32: (view, offset) => Boolean(view.getUint32(offset, true)),
-  u16: (view, offset) => view.getUint16(offset, true),
-  i16: (view, offset) => view.getInt16(offset, true),
-  u32: (view, offset) => view.getUint32(offset, true),
-  u64: (view, offset) => view.getBigUint64(offset, true),
-  f32: (view, offset) => view.getFloat32(offset, true),
-  f64: (view, offset) => view.getFloat64(offset, true),
-  i32: (view, offset) => view.getInt32(offset, true),
-  pointer: (view, offset) => pointerSize === 8 ? view.getBigUint64(offset, true) : BigInt(view.getUint32(offset, true))
-};
-function isObjectPointerDef(type) {
-  return typeof type === "object" && type !== null && type.__type === "objectPointer";
-}
-function alignOffset(offset, align) {
-  return offset + (align - 1) & ~(align - 1);
-}
-function enumTypeError(value) {
-  throw new TypeError(`Invalid enum value: ${value}`);
-}
-function defineEnum(mapping, base = "u32") {
-  const reverse2 = Object.fromEntries(Object.entries(mapping).map(([k, v]) => [v, k]));
-  return {
-    __type: "enum",
-    type: base,
-    to(value) {
-      return typeof value === "number" ? value : mapping[value] ?? enumTypeError(String(value));
-    },
-    from(value) {
-      return reverse2[value] ?? enumTypeError(String(value));
-    },
-    enum: mapping
-  };
-}
-function isEnum(type) {
-  return typeof type === "object" && type.__type === "enum";
-}
-function isStruct(type) {
-  return typeof type === "object" && type.__type === "struct";
-}
-function primitivePackers(type) {
-  let pack;
-  let unpack;
-  switch (type) {
-    case "u8":
-      pack = (view, off, val) => view.setUint8(off, val);
-      unpack = (view, off) => view.getUint8(off);
-      break;
-    case "bool_u8":
-      pack = (view, off, val) => view.setUint8(off, val ? 1 : 0);
-      unpack = (view, off) => Boolean(view.getUint8(off));
-      break;
-    case "bool_u32":
-      pack = (view, off, val) => view.setUint32(off, val ? 1 : 0, true);
-      unpack = (view, off) => Boolean(view.getUint32(off, true));
-      break;
-    case "u16":
-      pack = (view, off, val) => view.setUint16(off, val, true);
-      unpack = (view, off) => view.getUint16(off, true);
-      break;
-    case "i16":
-      pack = (view, off, val) => view.setInt16(off, val, true);
-      unpack = (view, off) => view.getInt16(off, true);
-      break;
-    case "u32":
-      pack = (view, off, val) => view.setUint32(off, val, true);
-      unpack = (view, off) => view.getUint32(off, true);
-      break;
-    case "i32":
-      pack = (view, off, val) => view.setInt32(off, val, true);
-      unpack = (view, off) => view.getInt32(off, true);
-      break;
-    case "u64":
-      pack = (view, off, val) => view.setBigUint64(off, BigInt(val), true);
-      unpack = (view, off) => view.getBigUint64(off, true);
-      break;
-    case "f32":
-      pack = (view, off, val) => view.setFloat32(off, val, true);
-      unpack = (view, off) => view.getFloat32(off, true);
-      break;
-    case "f64":
-      pack = (view, off, val) => view.setFloat64(off, val, true);
-      unpack = (view, off) => view.getFloat64(off, true);
-      break;
-    case "pointer":
-      pack = (view, off, val) => {
-        pointerSize === 8 ? view.setBigUint64(off, val ? BigInt(val) : 0n, true) : view.setUint32(off, val ? Number(val) : 0, true);
-      };
-      unpack = (view, off) => {
-        const bint = pointerSize === 8 ? view.getBigUint64(off, true) : BigInt(view.getUint32(off, true));
-        return Number(bint);
-      };
-      break;
-    default:
-      fatalError(`Unsupported primitive type: ${type}`);
-  }
-  return { pack, unpack };
-}
-var { pack: pointerPacker, unpack: pointerUnpacker } = primitivePackers("pointer");
-function packObjectArray(val) {
-  const buffer = new ArrayBuffer(val.length * pointerSize);
-  const bufferView = new DataView(buffer);
-  for (let i = 0;i < val.length; i++) {
-    const instance = val[i];
-    const ptrValue = instance?.ptr ?? null;
-    pointerPacker(bufferView, i * pointerSize, ptrValue);
-  }
-  return bufferView;
-}
-var encoder = new TextEncoder;
-var decoder = new TextDecoder;
-function defineStruct(fields, structDefOptions) {
-  let offset = 0;
-  let maxAlign = 1;
-  const layout = [];
-  const lengthOfFields = {};
-  const lengthOfRequested = [];
-  const arrayFieldsMetadata = {};
-  for (const [name, typeOrStruct, options = {}] of fields) {
-    if (options.condition && !options.condition()) {
-      continue;
-    }
-    let size = 0, align = 0;
-    let pack;
-    let unpack;
-    let needsLengthOf = false;
-    let lengthOfDef = null;
-    if (isPrimitiveType(typeOrStruct)) {
-      size = typeSizes[typeOrStruct];
-      align = typeAlignments[typeOrStruct];
-      ({ pack, unpack } = primitivePackers(typeOrStruct));
-    } else if (typeof typeOrStruct === "string" && typeOrStruct === "cstring") {
-      size = pointerSize;
-      align = pointerSize;
-      pack = (view, off, val) => {
-        const bufPtr = val ? ptr(encoder.encode(val + "\x00")) : null;
-        pointerPacker(view, off, bufPtr);
-      };
-      unpack = (view, off) => {
-        const ptrVal = pointerUnpacker(view, off);
-        return ptrVal;
-      };
-    } else if (typeof typeOrStruct === "string" && typeOrStruct === "char*") {
-      size = pointerSize;
-      align = pointerSize;
-      pack = (view, off, val) => {
-        const bufPtr = val ? ptr(encoder.encode(val)) : null;
-        pointerPacker(view, off, bufPtr);
-      };
-      unpack = (view, off) => {
-        const ptrVal = pointerUnpacker(view, off);
-        return ptrVal;
-      };
-      needsLengthOf = true;
-    } else if (isEnum(typeOrStruct)) {
-      const base = typeOrStruct.type;
-      size = typeSizes[base];
-      align = typeAlignments[base];
-      const { pack: packEnum } = primitivePackers(base);
-      pack = (view, off, val) => {
-        const num = typeOrStruct.to(val);
-        packEnum(view, off, num);
-      };
-      unpack = (view, off) => {
-        const raw = typeGetters[base](view, off);
-        return typeOrStruct.from(raw);
-      };
-    } else if (isStruct(typeOrStruct)) {
-      if (options.asPointer === true) {
-        size = pointerSize;
-        align = pointerSize;
-        pack = (view, off, val, obj, options2) => {
-          if (!val) {
-            pointerPacker(view, off, null);
-            return;
-          }
-          const nestedBuf = typeOrStruct.pack(val, options2);
-          pointerPacker(view, off, ptr(nestedBuf));
-        };
-        unpack = (view, off) => {
-          throw new Error("Not implemented yet");
-        };
-      } else {
-        size = typeOrStruct.size;
-        align = typeOrStruct.align;
-        pack = (view, off, val, obj, options2) => {
-          const nestedBuf = typeOrStruct.pack(val, options2);
-          const nestedView = new Uint8Array(nestedBuf);
-          const dView = new Uint8Array(view.buffer);
-          dView.set(nestedView, off);
-        };
-        unpack = (view, off) => {
-          const slice = view.buffer.slice(off, off + size);
-          return typeOrStruct.unpack(slice);
-        };
-      }
-    } else if (isObjectPointerDef(typeOrStruct)) {
-      size = pointerSize;
-      align = pointerSize;
-      pack = (view, off, value) => {
-        const ptrValue = value?.ptr ?? null;
-        if (ptrValue === undefined) {
-          console.warn(`Field '${name}' expected object with '.ptr' property, but got undefined pointer value from:`, value);
-          pointerPacker(view, off, null);
-        } else {
-          pointerPacker(view, off, ptrValue);
-        }
-      };
-      unpack = (view, off) => {
-        return pointerUnpacker(view, off);
-      };
-    } else if (Array.isArray(typeOrStruct) && typeOrStruct.length === 1 && typeOrStruct[0] !== undefined) {
-      const [def] = typeOrStruct;
-      size = pointerSize;
-      align = pointerSize;
-      let arrayElementSize;
-      if (isEnum(def)) {
-        arrayElementSize = typeSizes[def.type];
-        pack = (view, off, val, obj) => {
-          if (!val || val.length === 0) {
-            pointerPacker(view, off, null);
-            return;
-          }
-          const buffer = new ArrayBuffer(val.length * arrayElementSize);
-          const bufferView = new DataView(buffer);
-          for (let i = 0;i < val.length; i++) {
-            const num = def.to(val[i]);
-            bufferView.setUint32(i * arrayElementSize, num, true);
-          }
-          pointerPacker(view, off, ptr(buffer));
-        };
-        unpack = null;
-        needsLengthOf = true;
-        lengthOfDef = def;
-      } else if (isStruct(def)) {
-        arrayElementSize = def.size;
-        pack = (view, off, val, obj, options2) => {
-          if (!val || val.length === 0) {
-            pointerPacker(view, off, null);
-            return;
-          }
-          const buffer = new ArrayBuffer(val.length * arrayElementSize);
-          const bufferView = new DataView(buffer);
-          for (let i = 0;i < val.length; i++) {
-            def.packInto(val[i], bufferView, i * arrayElementSize, options2);
-          }
-          pointerPacker(view, off, ptr(buffer));
-        };
-        unpack = (view, off) => {
-          throw new Error("Not implemented yet");
-        };
-      } else if (isPrimitiveType(def)) {
-        arrayElementSize = typeSizes[def];
-        const { pack: primitivePack } = primitivePackers(def);
-        pack = (view, off, val) => {
-          if (!val || val.length === 0) {
-            pointerPacker(view, off, null);
-            return;
-          }
-          const buffer = new ArrayBuffer(val.length * arrayElementSize);
-          const bufferView = new DataView(buffer);
-          for (let i = 0;i < val.length; i++) {
-            primitivePack(bufferView, i * arrayElementSize, val[i]);
-          }
-          pointerPacker(view, off, ptr(buffer));
-        };
-        unpack = null;
-        needsLengthOf = true;
-        lengthOfDef = def;
-      } else if (isObjectPointerDef(def)) {
-        arrayElementSize = pointerSize;
-        pack = (view, off, val) => {
-          if (!val || val.length === 0) {
-            pointerPacker(view, off, null);
-            return;
-          }
-          const packedView = packObjectArray(val);
-          pointerPacker(view, off, ptr(packedView.buffer));
-        };
-        unpack = () => {
-          throw new Error("not implemented yet");
-        };
-      } else {
-        throw new Error(`Unsupported array element type for ${name}: ${JSON.stringify(def)}`);
-      }
-      const lengthOfField = Object.values(lengthOfFields).find((f) => f.lengthOf === name);
-      if (lengthOfField && isPrimitiveType(lengthOfField.type)) {
-        const { pack: lengthPack } = primitivePackers(lengthOfField.type);
-        arrayFieldsMetadata[name] = {
-          elementSize: arrayElementSize,
-          arrayOffset: offset,
-          lengthOffset: lengthOfField.offset,
-          lengthPack
-        };
-      }
-    } else {
-      throw new Error(`Unsupported field type for ${name}: ${JSON.stringify(typeOrStruct)}`);
-    }
-    offset = alignOffset(offset, align);
-    if (options.unpackTransform) {
-      const originalUnpack = unpack;
-      unpack = (view, off) => options.unpackTransform(originalUnpack(view, off));
-    }
-    if (options.packTransform) {
-      const originalPack = pack;
-      pack = (view, off, val, obj, packOptions) => originalPack(view, off, options.packTransform(val), obj, packOptions);
-    }
-    if (options.optional) {
-      const originalPack = pack;
-      if (isStruct(typeOrStruct) && !options.asPointer) {
-        pack = (view, off, val, obj, packOptions) => {
-          if (val || options.mapOptionalInline) {
-            originalPack(view, off, val, obj, packOptions);
-          }
-        };
-      } else {
-        pack = (view, off, val, obj, packOptions) => originalPack(view, off, val ?? 0, obj, packOptions);
-      }
-    }
-    if (options.lengthOf) {
-      const originalPack = pack;
-      pack = (view, off, val, obj, packOptions) => {
-        const targetValue = obj[options.lengthOf];
-        let length = 0;
-        if (targetValue) {
-          if (typeof targetValue === "string") {
-            length = Buffer.byteLength(targetValue);
-          } else {
-            length = targetValue.length;
-          }
-        }
-        return originalPack(view, off, length, obj, packOptions);
-      };
-    }
-    let validateFunctions;
-    if (options.validate) {
-      validateFunctions = Array.isArray(options.validate) ? options.validate : [options.validate];
-    }
-    const layoutField = {
-      name,
-      offset,
-      size,
-      align,
-      validate: validateFunctions,
-      optional: !!options.optional || !!options.lengthOf || options.default !== undefined,
-      default: options.default,
-      pack,
-      unpack,
-      type: typeOrStruct,
-      lengthOf: options.lengthOf
-    };
-    layout.push(layoutField);
-    if (options.lengthOf) {
-      lengthOfFields[options.lengthOf] = layoutField;
-    }
-    if (needsLengthOf) {
-      const def = typeof typeOrStruct === "string" && typeOrStruct === "char*" ? "char*" : lengthOfDef;
-      if (!def)
-        fatalError(`Internal error: needsLengthOf=true but def is null for ${name}`);
-      lengthOfRequested.push({ requester: layoutField, def });
-    }
-    offset += size;
-    maxAlign = Math.max(maxAlign, align);
-  }
-  for (const { requester, def } of lengthOfRequested) {
-    const lengthOfField = lengthOfFields[requester.name];
-    if (!lengthOfField) {
-      if (def === "char*") {
-        continue;
-      }
-      throw new Error(`lengthOf field not found for array field ${requester.name}`);
-    }
-    if (def === "char*") {
-      requester.unpack = (view, off) => {
-        const ptrAddress = pointerUnpacker(view, off);
-        const length = lengthOfField.unpack(view, lengthOfField.offset);
-        if (ptrAddress === 0) {
-          return null;
-        }
-        const byteLength = typeof length === "bigint" ? Number(length) : length;
-        if (byteLength === 0) {
-          return "";
-        }
-        const buffer = toArrayBuffer2(ptrAddress, 0, byteLength);
-        return decoder.decode(buffer);
-      };
-    } else if (isPrimitiveType(def)) {
-      const elemSize = typeSizes[def];
-      const { unpack: primitiveUnpack } = primitivePackers(def);
-      requester.unpack = (view, off) => {
-        const result = [];
-        const length = lengthOfField.unpack(view, lengthOfField.offset);
-        const ptrAddress = pointerUnpacker(view, off);
-        if (ptrAddress === 0n && length > 0) {
-          throw new Error(`Array field ${requester.name} has null pointer but length ${length}.`);
-        }
-        if (ptrAddress === 0n || length === 0) {
-          return [];
-        }
-        const buffer = toArrayBuffer2(ptrAddress, 0, length * elemSize);
-        const bufferView = new DataView(buffer);
-        for (let i = 0;i < length; i++) {
-          result.push(primitiveUnpack(bufferView, i * elemSize));
-        }
-        return result;
-      };
-    } else {
-      const elemSize = def.type === "u32" ? 4 : 8;
-      requester.unpack = (view, off) => {
-        const result = [];
-        const length = lengthOfField.unpack(view, lengthOfField.offset);
-        const ptrAddress = pointerUnpacker(view, off);
-        if (ptrAddress === 0n && length > 0) {
-          throw new Error(`Array field ${requester.name} has null pointer but length ${length}.`);
-        }
-        if (ptrAddress === 0n || length === 0) {
-          return [];
-        }
-        const buffer = toArrayBuffer2(ptrAddress, 0, length * elemSize);
-        const bufferView = new DataView(buffer);
-        for (let i = 0;i < length; i++) {
-          result.push(def.from(bufferView.getUint32(i * elemSize, true)));
-        }
-        return result;
-      };
-    }
-  }
-  const totalSize = alignOffset(offset, maxAlign);
-  const description = layout.map((f) => ({
-    name: f.name,
-    offset: f.offset,
-    size: f.size,
-    align: f.align,
-    optional: f.optional,
-    type: f.type,
-    lengthOf: f.lengthOf
-  }));
-  const layoutByName = new Map(description.map((f) => [f.name, f]));
-  const arrayFields = new Map(Object.entries(arrayFieldsMetadata));
-  return {
-    __type: "struct",
-    size: totalSize,
-    align: maxAlign,
-    hasMapValue: !!structDefOptions?.mapValue,
-    layoutByName,
-    arrayFields,
-    pack(obj, options) {
-      const buf = new ArrayBuffer(totalSize);
-      const view = new DataView(buf);
-      let mappedObj = obj;
-      if (structDefOptions?.mapValue) {
-        mappedObj = structDefOptions.mapValue(obj);
-      }
-      for (const field of layout) {
-        const value = mappedObj[field.name] ?? field.default;
-        if (!field.optional && value === undefined) {
-          fatalError(`Packing non-optional field '${field.name}' but value is undefined (and no default provided)`);
-        }
-        if (field.validate) {
-          for (const validateFn of field.validate) {
-            validateFn(value, field.name, {
-              hints: options?.validationHints,
-              input: mappedObj
-            });
-          }
-        }
-        field.pack(view, field.offset, value, mappedObj, options);
-      }
-      return view.buffer;
-    },
-    packInto(obj, view, offset2, options) {
-      let mappedObj = obj;
-      if (structDefOptions?.mapValue) {
-        mappedObj = structDefOptions.mapValue(obj);
-      }
-      for (const field of layout) {
-        const value = mappedObj[field.name] ?? field.default;
-        if (!field.optional && value === undefined) {
-          console.warn(`packInto missing value for non-optional field '${field.name}' at offset ${offset2 + field.offset}. Writing default or zero.`);
-        }
-        if (field.validate) {
-          for (const validateFn of field.validate) {
-            validateFn(value, field.name, {
-              hints: options?.validationHints,
-              input: mappedObj
-            });
-          }
-        }
-        field.pack(view, offset2 + field.offset, value, mappedObj, options);
-      }
-    },
-    unpack(buf) {
-      if (buf.byteLength < totalSize) {
-        fatalError(`Buffer size (${buf.byteLength}) is smaller than struct size (${totalSize}) for unpacking.`);
-      }
-      const view = new DataView(buf);
-      const result = structDefOptions?.default ? { ...structDefOptions.default } : {};
-      for (const field of layout) {
-        if (!field.unpack) {
-          continue;
-        }
-        try {
-          result[field.name] = field.unpack(view, field.offset);
-        } catch (e) {
-          console.error(`Error unpacking field '${field.name}' at offset ${field.offset}:`, e);
-          throw e;
-        }
-      }
-      if (structDefOptions?.reduceValue) {
-        return structDefOptions.reduceValue(result);
-      }
-      return result;
-    },
-    packList(objects, options) {
-      if (objects.length === 0) {
-        return new ArrayBuffer(0);
-      }
-      const buffer = new ArrayBuffer(totalSize * objects.length);
-      const view = new DataView(buffer);
-      for (let i = 0;i < objects.length; i++) {
-        let mappedObj = objects[i];
-        if (structDefOptions?.mapValue) {
-          mappedObj = structDefOptions.mapValue(objects[i]);
-        }
-        for (const field of layout) {
-          const value = mappedObj[field.name] ?? field.default;
-          if (!field.optional && value === undefined) {
-            fatalError(`Packing non-optional field '${field.name}' at index ${i} but value is undefined (and no default provided)`);
-          }
-          if (field.validate) {
-            for (const validateFn of field.validate) {
-              validateFn(value, field.name, {
-                hints: options?.validationHints,
-                input: mappedObj
-              });
-            }
-          }
-          field.pack(view, i * totalSize + field.offset, value, mappedObj, options);
-        }
-      }
-      return buffer;
-    },
-    unpackList(buf, count) {
-      if (count === 0) {
-        return [];
-      }
-      const expectedSize = totalSize * count;
-      if (buf.byteLength < expectedSize) {
-        fatalError(`Buffer size (${buf.byteLength}) is smaller than expected size (${expectedSize}) for unpacking ${count} structs.`);
-      }
-      const view = new DataView(buf);
-      const results = [];
-      for (let i = 0;i < count; i++) {
-        const offset2 = i * totalSize;
-        const result = structDefOptions?.default ? { ...structDefOptions.default } : {};
-        for (const field of layout) {
-          if (!field.unpack) {
-            continue;
-          }
-          try {
-            result[field.name] = field.unpack(view, offset2 + field.offset);
-          } catch (e) {
-            console.error(`Error unpacking field '${field.name}' at index ${i}, offset ${offset2 + field.offset}:`, e);
-            throw e;
-          }
-        }
-        if (structDefOptions?.reduceValue) {
-          results.push(structDefOptions.reduceValue(result));
-        } else {
-          results.push(result);
-        }
-      }
-      return results;
-    },
-    describe() {
-      return description;
-    }
-  };
-}
-
 // src/zig-structs.ts
-import { ptr as ptr2, toArrayBuffer as toArrayBuffer3 } from "bun:ffi";
-var rgbaPackTransform = (rgba) => rgba ? ptr2(rgba.buffer) : null;
-var rgbaUnpackTransform = (ptr3) => ptr3 ? RGBA.fromArray(new Float32Array(toArrayBuffer3(ptr3))) : undefined;
+import { defineStruct, defineEnum } from "bun-ffi-structs";
+import { ptr, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
+var rgbaPackTransform = (rgba) => rgba ? ptr(rgba.buffer) : null;
+var rgbaUnpackTransform = (ptr2) => ptr2 ? RGBA.fromArray(new Float32Array(toArrayBuffer2(ptr2))) : undefined;
 var StyledChunkStruct = defineStruct([
   ["text", "char*"],
   ["text_len", "u64", { lengthOf: "text" }],
@@ -9695,7 +7823,7 @@ var targetLibPath = module.default;
 if (/\$bunfs/.test(targetLibPath)) {
   targetLibPath = targetLibPath.replace("../", "");
 }
-if (!existsSync3(targetLibPath)) {
+if (!existsSync2(targetLibPath)) {
   throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
 }
 registerEnvVar({
@@ -9724,7 +7852,7 @@ registerEnvVar({
 });
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
-  const rawSymbols = dlopen2(resolvedLibPath, {
+  const rawSymbols = dlopen(resolvedLibPath, {
     setLogCallback: {
       args: ["ptr"],
       returns: "void"
@@ -10652,13 +8780,13 @@ class FFIRenderLib {
     if (this.logCallbackWrapper) {
       return;
     }
-    const logCallback = new JSCallback2((level, msgPtr, msgLenBigInt) => {
+    const logCallback = new JSCallback((level, msgPtr, msgLenBigInt) => {
       try {
         const msgLen = typeof msgLenBigInt === "bigint" ? Number(msgLenBigInt) : msgLenBigInt;
         if (msgLen === 0 || !msgPtr) {
           return;
         }
-        const msgBuffer = toArrayBuffer4(msgPtr, 0, msgLen);
+        const msgBuffer = toArrayBuffer3(msgPtr, 0, msgLen);
         const msgBytes = new Uint8Array(msgBuffer);
         const message = this.decoder.decode(msgBytes);
         switch (level) {
@@ -10697,19 +8825,19 @@ class FFIRenderLib {
     if (this.eventCallbackWrapper) {
       return;
     }
-    const eventCallback = new JSCallback2((namePtr, nameLenBigInt, dataPtr, dataLenBigInt) => {
+    const eventCallback = new JSCallback((namePtr, nameLenBigInt, dataPtr, dataLenBigInt) => {
       try {
         const nameLen = typeof nameLenBigInt === "bigint" ? Number(nameLenBigInt) : nameLenBigInt;
         const dataLen = typeof dataLenBigInt === "bigint" ? Number(dataLenBigInt) : dataLenBigInt;
         if (nameLen === 0 || !namePtr) {
           return;
         }
-        const nameBuffer = toArrayBuffer4(namePtr, 0, nameLen);
+        const nameBuffer = toArrayBuffer3(namePtr, 0, nameLen);
         const nameBytes = new Uint8Array(nameBuffer);
         const eventName = this.decoder.decode(nameBytes);
         let eventData;
         if (dataLen > 0 && dataPtr) {
-          eventData = toArrayBuffer4(dataPtr, 0, dataLen).slice();
+          eventData = toArrayBuffer3(dataPtr, 0, dataLen).slice();
         } else {
           eventData = new ArrayBuffer(0);
         }
@@ -10775,32 +8903,32 @@ class FFIRenderLib {
     return new OptimizedBuffer(this, bufferPtr, width, height, { id: "current buffer", widthMethod: "unicode" });
   }
   bufferGetCharPtr(buffer) {
-    const ptr4 = this.opentui.symbols.bufferGetCharPtr(buffer);
-    if (!ptr4) {
+    const ptr3 = this.opentui.symbols.bufferGetCharPtr(buffer);
+    if (!ptr3) {
       throw new Error("Failed to get char pointer");
     }
-    return ptr4;
+    return ptr3;
   }
   bufferGetFgPtr(buffer) {
-    const ptr4 = this.opentui.symbols.bufferGetFgPtr(buffer);
-    if (!ptr4) {
+    const ptr3 = this.opentui.symbols.bufferGetFgPtr(buffer);
+    if (!ptr3) {
       throw new Error("Failed to get fg pointer");
     }
-    return ptr4;
+    return ptr3;
   }
   bufferGetBgPtr(buffer) {
-    const ptr4 = this.opentui.symbols.bufferGetBgPtr(buffer);
-    if (!ptr4) {
+    const ptr3 = this.opentui.symbols.bufferGetBgPtr(buffer);
+    if (!ptr3) {
       throw new Error("Failed to get bg pointer");
     }
-    return ptr4;
+    return ptr3;
   }
   bufferGetAttributesPtr(buffer) {
-    const ptr4 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
-    if (!ptr4) {
+    const ptr3 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
+    if (!ptr3) {
       throw new Error("Failed to get attributes pointer");
     }
-    return ptr4;
+    return ptr3;
   }
   bufferGetRespectAlpha(buffer) {
     return this.opentui.symbols.bufferGetRespectAlpha(buffer);
@@ -11043,7 +9171,7 @@ class FFIRenderLib {
       return;
     }
     const chunksBuffer = StyledChunkStruct.packList(nonEmptyChunks);
-    this.opentui.symbols.textBufferSetStyledText(buffer, ptr3(chunksBuffer), nonEmptyChunks.length);
+    this.opentui.symbols.textBufferSetStyledText(buffer, ptr2(chunksBuffer), nonEmptyChunks.length);
   }
   textBufferGetLineCount(buffer) {
     return this.opentui.symbols.textBufferGetLineCount(buffer);
@@ -11054,7 +9182,7 @@ class FFIRenderLib {
   }
   getPlainTextBytes(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferGetPlainText(buffer, ptr3(outBuffer), maxLength);
+    const actualLen = this.textBufferGetPlainText(buffer, ptr2(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -11062,7 +9190,7 @@ class FFIRenderLib {
   }
   textBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.textBufferGetTextRange(buffer, startOffset, endOffset, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.textBufferGetTextRange(buffer, startOffset, endOffset, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0) {
       return null;
@@ -11071,7 +9199,7 @@ class FFIRenderLib {
   }
   textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0) {
       return null;
@@ -11131,7 +9259,7 @@ class FFIRenderLib {
   }
   textBufferViewGetLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.textBufferViewGetLineInfoDirect(view, ptr3(outBuffer));
+    this.textBufferViewGetLineInfoDirect(view, ptr2(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
     return {
       maxLineWidth: struct.maxWidth,
@@ -11143,7 +9271,7 @@ class FFIRenderLib {
   }
   textBufferViewGetLogicalLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.textBufferViewGetLogicalLineInfoDirect(view, ptr3(outBuffer));
+    this.textBufferViewGetLogicalLineInfoDirect(view, ptr2(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
     return {
       maxLineWidth: struct.maxWidth,
@@ -11172,7 +9300,7 @@ class FFIRenderLib {
   }
   textBufferViewGetSelectedTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferViewGetSelectedText(view, ptr3(outBuffer), maxLength);
+    const actualLen = this.textBufferViewGetSelectedText(view, ptr2(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -11180,7 +9308,7 @@ class FFIRenderLib {
   }
   textBufferViewGetPlainTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferViewGetPlainText(view, ptr3(outBuffer), maxLength);
+    const actualLen = this.textBufferViewGetPlainText(view, ptr2(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -11194,7 +9322,7 @@ class FFIRenderLib {
   }
   textBufferViewMeasureForDimensions(view, width, height) {
     const resultBuffer = new ArrayBuffer(MeasureResultStruct.size);
-    const resultPtr = ptr3(new Uint8Array(resultBuffer));
+    const resultPtr = ptr2(new Uint8Array(resultBuffer));
     const success = this.opentui.symbols.textBufferViewMeasureForDimensions(view, width, height, resultPtr);
     if (!success) {
       return null;
@@ -11204,11 +9332,11 @@ class FFIRenderLib {
   }
   textBufferAddHighlightByCharRange(buffer, highlight) {
     const packedHighlight = HighlightStruct.pack(highlight);
-    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr3(packedHighlight));
+    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr2(packedHighlight));
   }
   textBufferAddHighlight(buffer, lineIdx, highlight) {
     const packedHighlight = HighlightStruct.pack(highlight);
-    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr3(packedHighlight));
+    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr2(packedHighlight));
   }
   textBufferRemoveHighlightsByRef(buffer, hlRef) {
     this.opentui.symbols.textBufferRemoveHighlightsByRef(buffer, hlRef);
@@ -11224,12 +9352,12 @@ class FFIRenderLib {
   }
   textBufferGetLineHighlights(buffer, lineIdx) {
     const outCountBuf = new BigUint64Array(1);
-    const nativePtr = this.opentui.symbols.textBufferGetLineHighlightsPtr(buffer, lineIdx, ptr3(outCountBuf));
+    const nativePtr = this.opentui.symbols.textBufferGetLineHighlightsPtr(buffer, lineIdx, ptr2(outCountBuf));
     if (!nativePtr)
       return [];
     const count = Number(outCountBuf[0]);
     const byteLen = count * HighlightStruct.size;
-    const raw = toArrayBuffer4(nativePtr, 0, byteLen);
+    const raw = toArrayBuffer3(nativePtr, 0, byteLen);
     const results = HighlightStruct.unpackList(raw, count);
     this.opentui.symbols.textBufferFreeLineHighlights(nativePtr, count);
     return results;
@@ -11265,7 +9393,7 @@ class FFIRenderLib {
     const y = new Uint32Array(1);
     const width = new Uint32Array(1);
     const height = new Uint32Array(1);
-    this.opentui.symbols.editorViewGetViewport(view, ptr3(x), ptr3(y), ptr3(width), ptr3(height));
+    this.opentui.symbols.editorViewGetViewport(view, ptr2(x), ptr2(y), ptr2(width), ptr2(height));
     return {
       offsetX: x[0],
       offsetY: y[0],
@@ -11295,7 +9423,7 @@ class FFIRenderLib {
   }
   editorViewGetLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr3(outBuffer));
+    this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr2(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
     return {
       maxLineWidth: struct.maxWidth,
@@ -11307,7 +9435,7 @@ class FFIRenderLib {
   }
   editorViewGetLogicalLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr3(outBuffer));
+    this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr2(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
     return {
       maxLineWidth: struct.maxWidth,
@@ -11336,7 +9464,7 @@ class FFIRenderLib {
   }
   editBufferGetText(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferGetText(buffer, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetText(buffer, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -11391,7 +9519,7 @@ class FFIRenderLib {
   }
   editBufferGetCursorPosition(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr3(cursorBuffer));
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr2(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferGetId(buffer) {
@@ -11409,7 +9537,7 @@ class FFIRenderLib {
   }
   editBufferUndo(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferUndo(buffer, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferUndo(buffer, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -11417,7 +9545,7 @@ class FFIRenderLib {
   }
   editBufferRedo(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferRedo(buffer, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferRedo(buffer, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -11437,22 +9565,22 @@ class FFIRenderLib {
   }
   editBufferGetNextWordBoundary(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr3(cursorBuffer));
+    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr2(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferGetPrevWordBoundary(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr3(cursorBuffer));
+    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr2(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferGetEOL(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetEOL(buffer, ptr3(cursorBuffer));
+    this.opentui.symbols.editBufferGetEOL(buffer, ptr2(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferOffsetToPosition(buffer, offset) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, ptr3(cursorBuffer));
+    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, ptr2(cursorBuffer));
     if (!success)
       return null;
     return LogicalCursorStruct.unpack(cursorBuffer);
@@ -11465,7 +9593,7 @@ class FFIRenderLib {
   }
   editBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferGetTextRange(buffer, startOffset, endOffset, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetTextRange(buffer, startOffset, endOffset, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -11473,7 +9601,7 @@ class FFIRenderLib {
   }
   editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -11506,7 +9634,7 @@ class FFIRenderLib {
   }
   editorViewGetSelectedTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editorViewGetSelectedTextBytes(view, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetSelectedTextBytes(view, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -11515,12 +9643,12 @@ class FFIRenderLib {
   editorViewGetCursor(view) {
     const row = new Uint32Array(1);
     const col = new Uint32Array(1);
-    this.opentui.symbols.editorViewGetCursor(view, ptr3(row), ptr3(col));
+    this.opentui.symbols.editorViewGetCursor(view, ptr2(row), ptr2(col));
     return { row: row[0], col: col[0] };
   }
   editorViewGetText(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editorViewGetText(view, ptr3(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetText(view, ptr2(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -11528,7 +9656,7 @@ class FFIRenderLib {
   }
   editorViewGetVisualCursor(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetVisualCursor(view, ptr3(cursorBuffer));
+    this.opentui.symbols.editorViewGetVisualCursor(view, ptr2(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewMoveUpVisual(view) {
@@ -11545,17 +9673,17 @@ class FFIRenderLib {
   }
   editorViewGetNextWordBoundary(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr3(cursorBuffer));
+    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr2(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewGetPrevWordBoundary(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr3(cursorBuffer));
+    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr2(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewGetEOL(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetEOL(view, ptr3(cursorBuffer));
+    this.opentui.symbols.editorViewGetEOL(view, ptr2(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   bufferPushScissorRect(buffer, x, y, width, height) {
@@ -11569,7 +9697,7 @@ class FFIRenderLib {
   }
   getTerminalCapabilities(renderer) {
     const capsBuffer = new ArrayBuffer(TerminalCapabilitiesStruct.size);
-    this.opentui.symbols.getTerminalCapabilities(renderer, ptr3(capsBuffer));
+    this.opentui.symbols.getTerminalCapabilities(renderer, ptr2(capsBuffer));
     const caps = TerminalCapabilitiesStruct.unpack(capsBuffer);
     return {
       kitty_keyboard: caps.kitty_keyboard,
@@ -11601,7 +9729,7 @@ class FFIRenderLib {
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
     const outPtrBuffer = new ArrayBuffer(8);
     const outLenBuffer = new ArrayBuffer(8);
-    const success = this.opentui.symbols.encodeUnicode(textBytes, textBytes.length, ptr3(outPtrBuffer), ptr3(outLenBuffer), widthMethodCode);
+    const success = this.opentui.symbols.encodeUnicode(textBytes, textBytes.length, ptr2(outPtrBuffer), ptr2(outLenBuffer), widthMethodCode);
     if (!success) {
       return null;
     }
@@ -11613,7 +9741,7 @@ class FFIRenderLib {
       return { ptr: resultPtr, data: [] };
     }
     const byteLen = resultLen * EncodedCharStruct.size;
-    const raw = toArrayBuffer4(resultPtr, 0, byteLen);
+    const raw = toArrayBuffer3(resultPtr, 0, byteLen);
     const data = EncodedCharStruct.unpackList(raw, resultLen);
     return { ptr: resultPtr, data };
   }
@@ -11655,7 +9783,7 @@ class FFIRenderLib {
       return;
     }
     const chunksBuffer = StyledChunkStruct.packList(nonEmptyChunks);
-    this.opentui.symbols.editorViewSetPlaceholderStyledText(view, ptr3(chunksBuffer), nonEmptyChunks.length);
+    this.opentui.symbols.editorViewSetPlaceholderStyledText(view, ptr2(chunksBuffer), nonEmptyChunks.length);
   }
   editorViewSetTabIndicator(view, indicator) {
     this.opentui.symbols.editorViewSetTabIndicator(view, indicator);
@@ -11710,13 +9838,13 @@ class TextBuffer {
   _textBytes;
   _memId;
   _appendedChunks = [];
-  constructor(lib2, ptr4) {
-    this.lib = lib2;
-    this.bufferPtr = ptr4;
+  constructor(lib, ptr3) {
+    this.lib = lib;
+    this.bufferPtr = ptr3;
   }
   static create(widthMethod) {
-    const lib2 = resolveRenderLib();
-    return lib2.createTextBuffer(widthMethod);
+    const lib = resolveRenderLib();
+    return lib.createTextBuffer(widthMethod);
   }
   guard() {
     if (this._destroyed)
@@ -11895,6 +10023,7 @@ class TextBuffer {
 
 // src/Renderable.ts
 import { EventEmitter as EventEmitter6 } from "events";
+import Yoga, { Direction as Direction2, Display as Display2, Edge as Edge2, FlexDirection as FlexDirection2 } from "bun-yoga";
 
 // src/lib/renderable.validations.ts
 function validateOptions(id, options) {
@@ -12024,7 +10153,7 @@ class BaseRenderable extends EventEmitter6 {
     this._visible = value;
   }
 }
-var yogaConfig = dist_default.Config.create();
+var yogaConfig = Yoga.Config.create();
 yogaConfig.setUseWebDefaults(false);
 yogaConfig.setPointScaleFactor(1);
 
@@ -12090,8 +10219,8 @@ class Renderable extends BaseRenderable {
     this.buffered = options.buffered ?? false;
     this._live = options.live ?? false;
     this._liveCount = this._live && this._visible ? 1 : 0;
-    this.yogaNode = dist_default.Node.create(yogaConfig);
-    this.yogaNode.setDisplay(this._visible ? Display.Flex : Display.None);
+    this.yogaNode = Yoga.Node.create(yogaConfig);
+    this.yogaNode.setDisplay(this._visible ? Display2.Flex : Display2.None);
     this.setupYogaProperties(options);
     this.applyEventOptions(options);
     if (this.buffered) {
@@ -12126,7 +10255,7 @@ class Renderable extends BaseRenderable {
       return;
     const wasVisible = this._visible;
     this._visible = value;
-    this.yogaNode.setDisplay(value ? Display.Flex : Display.None);
+    this.yogaNode.setDisplay(value ? Display2.Flex : Display2.None);
     if (this._live) {
       if (!wasVisible && value) {
         this.propagateLiveCount(1);
@@ -12445,40 +10574,40 @@ class Renderable extends BaseRenderable {
   setupMarginAndPadding(options) {
     const node = this.yogaNode;
     if (isMarginType(options.margin)) {
-      node.setMargin(Edge.Top, options.margin);
-      node.setMargin(Edge.Right, options.margin);
-      node.setMargin(Edge.Bottom, options.margin);
-      node.setMargin(Edge.Left, options.margin);
+      node.setMargin(Edge2.Top, options.margin);
+      node.setMargin(Edge2.Right, options.margin);
+      node.setMargin(Edge2.Bottom, options.margin);
+      node.setMargin(Edge2.Left, options.margin);
     }
     if (isMarginType(options.marginTop)) {
-      node.setMargin(Edge.Top, options.marginTop);
+      node.setMargin(Edge2.Top, options.marginTop);
     }
     if (isMarginType(options.marginRight)) {
-      node.setMargin(Edge.Right, options.marginRight);
+      node.setMargin(Edge2.Right, options.marginRight);
     }
     if (isMarginType(options.marginBottom)) {
-      node.setMargin(Edge.Bottom, options.marginBottom);
+      node.setMargin(Edge2.Bottom, options.marginBottom);
     }
     if (isMarginType(options.marginLeft)) {
-      node.setMargin(Edge.Left, options.marginLeft);
+      node.setMargin(Edge2.Left, options.marginLeft);
     }
     if (isPaddingType(options.padding)) {
-      node.setPadding(Edge.Top, options.padding);
-      node.setPadding(Edge.Right, options.padding);
-      node.setPadding(Edge.Bottom, options.padding);
-      node.setPadding(Edge.Left, options.padding);
+      node.setPadding(Edge2.Top, options.padding);
+      node.setPadding(Edge2.Right, options.padding);
+      node.setPadding(Edge2.Bottom, options.padding);
+      node.setPadding(Edge2.Left, options.padding);
     }
     if (isPaddingType(options.paddingTop)) {
-      node.setPadding(Edge.Top, options.paddingTop);
+      node.setPadding(Edge2.Top, options.paddingTop);
     }
     if (isPaddingType(options.paddingRight)) {
-      node.setPadding(Edge.Right, options.paddingRight);
+      node.setPadding(Edge2.Right, options.paddingRight);
     }
     if (isPaddingType(options.paddingBottom)) {
-      node.setPadding(Edge.Bottom, options.paddingBottom);
+      node.setPadding(Edge2.Bottom, options.paddingBottom);
     }
     if (isPaddingType(options.paddingLeft)) {
-      node.setPadding(Edge.Left, options.paddingLeft);
+      node.setPadding(Edge2.Left, options.paddingLeft);
     }
   }
   set position(positionType) {
@@ -12507,30 +10636,30 @@ class Renderable extends BaseRenderable {
     const { top, right, bottom, left } = position;
     if (isPositionType(top)) {
       if (top === "auto") {
-        node.setPositionAuto(Edge.Top);
+        node.setPositionAuto(Edge2.Top);
       } else {
-        node.setPosition(Edge.Top, top);
+        node.setPosition(Edge2.Top, top);
       }
     }
     if (isPositionType(right)) {
       if (right === "auto") {
-        node.setPositionAuto(Edge.Right);
+        node.setPositionAuto(Edge2.Right);
       } else {
-        node.setPosition(Edge.Right, right);
+        node.setPosition(Edge2.Right, right);
       }
     }
     if (isPositionType(bottom)) {
       if (bottom === "auto") {
-        node.setPositionAuto(Edge.Bottom);
+        node.setPositionAuto(Edge2.Bottom);
       } else {
-        node.setPosition(Edge.Bottom, bottom);
+        node.setPosition(Edge2.Bottom, bottom);
       }
     }
     if (isPositionType(left)) {
       if (left === "auto") {
-        node.setPositionAuto(Edge.Left);
+        node.setPositionAuto(Edge2.Left);
       } else {
-        node.setPosition(Edge.Left, left);
+        node.setPosition(Edge2.Left, left);
       }
     }
     this.requestRender();
@@ -12602,68 +10731,68 @@ class Renderable extends BaseRenderable {
   set margin(margin) {
     if (isMarginType(margin)) {
       const node = this.yogaNode;
-      node.setMargin(Edge.Top, margin);
-      node.setMargin(Edge.Right, margin);
-      node.setMargin(Edge.Bottom, margin);
-      node.setMargin(Edge.Left, margin);
+      node.setMargin(Edge2.Top, margin);
+      node.setMargin(Edge2.Right, margin);
+      node.setMargin(Edge2.Bottom, margin);
+      node.setMargin(Edge2.Left, margin);
       this.requestRender();
     }
   }
   set marginTop(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(Edge.Top, margin);
+      this.yogaNode.setMargin(Edge2.Top, margin);
       this.requestRender();
     }
   }
   set marginRight(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(Edge.Right, margin);
+      this.yogaNode.setMargin(Edge2.Right, margin);
       this.requestRender();
     }
   }
   set marginBottom(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(Edge.Bottom, margin);
+      this.yogaNode.setMargin(Edge2.Bottom, margin);
       this.requestRender();
     }
   }
   set marginLeft(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(Edge.Left, margin);
+      this.yogaNode.setMargin(Edge2.Left, margin);
       this.requestRender();
     }
   }
   set padding(padding) {
     if (isPaddingType(padding)) {
       const node = this.yogaNode;
-      node.setPadding(Edge.Top, padding);
-      node.setPadding(Edge.Right, padding);
-      node.setPadding(Edge.Bottom, padding);
-      node.setPadding(Edge.Left, padding);
+      node.setPadding(Edge2.Top, padding);
+      node.setPadding(Edge2.Right, padding);
+      node.setPadding(Edge2.Bottom, padding);
+      node.setPadding(Edge2.Left, padding);
       this.requestRender();
     }
   }
   set paddingTop(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(Edge.Top, padding);
+      this.yogaNode.setPadding(Edge2.Top, padding);
       this.requestRender();
     }
   }
   set paddingRight(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(Edge.Right, padding);
+      this.yogaNode.setPadding(Edge2.Right, padding);
       this.requestRender();
     }
   }
   set paddingBottom(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(Edge.Bottom, padding);
+      this.yogaNode.setPadding(Edge2.Bottom, padding);
       this.requestRender();
     }
   }
   set paddingLeft(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(Edge.Left, padding);
+      this.yogaNode.setPadding(Edge2.Left, padding);
       this.requestRender();
     }
   }
@@ -13079,10 +11208,10 @@ class RootRenderable extends Renderable {
     if (this.yogaNode) {
       this.yogaNode.free();
     }
-    this.yogaNode = dist_default.Node.create(yogaConfig);
+    this.yogaNode = Yoga.Node.create(yogaConfig);
     this.yogaNode.setWidth(ctx.width);
     this.yogaNode.setHeight(ctx.height);
-    this.yogaNode.setFlexDirection(FlexDirection.Column);
+    this.yogaNode.setFlexDirection(FlexDirection2.Column);
     this.calculateLayout();
   }
   render(buffer, deltaTime) {
@@ -13123,7 +11252,7 @@ class RootRenderable extends Renderable {
     }
   }
   calculateLayout() {
-    this.yogaNode.calculateLayout(this.width, this.height, Direction.LTR);
+    this.yogaNode.calculateLayout(this.width, this.height, Direction2.LTR);
     this.emit("layout-changed" /* LAYOUT_CHANGED */);
   }
   resize(width, height) {
@@ -14389,13 +12518,13 @@ Captured output:
   get controlState() {
     return this._controlState;
   }
-  constructor(lib2, rendererPtr, stdin, stdout, width, height, config = {}) {
+  constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
     super();
     rendererTracker.addRenderer(this);
     this.stdin = stdin;
     this.stdout = stdout;
     this.realStdoutWrite = stdout.write;
-    this.lib = lib2;
+    this.lib = lib;
     this._terminalWidth = stdout.columns;
     this._terminalHeight = stdout.rows;
     this.width = width;
@@ -14406,7 +12535,7 @@ Captured output:
       capture.on("write", this.captureCallback);
       this.renderOffset = height - this._splitHeight;
       this.height = this._splitHeight;
-      lib2.setRenderOffset(rendererPtr, this.renderOffset);
+      lib.setRenderOffset(rendererPtr, this.renderOffset);
     }
     this.rendererPtr = rendererPtr;
     this.exitOnCtrlC = config.exitOnCtrlC === undefined ? true : config.exitOnCtrlC;
@@ -15000,19 +13129,19 @@ Captured output:
     this.lib.dumpStdoutBuffer(this.rendererPtr, timestamp);
   }
   static setCursorPosition(renderer, x, y, visible = true) {
-    const lib2 = resolveRenderLib();
-    lib2.setCursorPosition(renderer.rendererPtr, x, y, visible);
+    const lib = resolveRenderLib();
+    lib.setCursorPosition(renderer.rendererPtr, x, y, visible);
   }
   static setCursorStyle(renderer, style, blinking = false, color) {
-    const lib2 = resolveRenderLib();
-    lib2.setCursorStyle(renderer.rendererPtr, style, blinking);
+    const lib = resolveRenderLib();
+    lib.setCursorStyle(renderer.rendererPtr, style, blinking);
     if (color) {
-      lib2.setCursorColor(renderer.rendererPtr, color);
+      lib.setCursorColor(renderer.rendererPtr, color);
     }
   }
   static setCursorColor(renderer, color) {
-    const lib2 = resolveRenderLib();
-    lib2.setCursorColor(renderer.rendererPtr, color);
+    const lib = resolveRenderLib();
+    lib.setCursorColor(renderer.rendererPtr, color);
   }
   setCursorPosition(x, y, visible = true) {
     this.lib.setCursorPosition(this.rendererPtr, x, y, visible);
@@ -15449,7 +13578,7 @@ Captured output:
   }
 }
 
-export { Edge, Gutter, MeasureMode, exports_dist, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=1623532973D99D8964756E2164756E21
-//# sourceMappingURL=index-re80811e.js.map
+//# debugId=D2D576D668A923C064756E2164756E21
+//# sourceMappingURL=index-x5bb5xvn.js.map