@opentui/core 0.0.0-20251202-71dcabc4 → 0.0.0-20251205-41c885f6

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

@@ -1,1215 +1,4 @@
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// ../../node_modules/bun-yoga/dist/darwin-arm64/libyoga.dylib
-var exports_libyoga = {};
-__export(exports_libyoga, {
-  default: () => libyoga_default
-});
-var libyoga_default = "./libyoga-j5nt7np1.dylib";
-var init_libyoga = () => {};
-
-// ../../node_modules/bun-yoga/dist/darwin-x64/libyoga.dylib
-var exports_libyoga2 = {};
-__export(exports_libyoga2, {
-  default: () => libyoga_default2
-});
-var libyoga_default2 = "./libyoga-2ksztx35.dylib";
-var init_libyoga2 = () => {};
-
-// ../../node_modules/bun-yoga/dist/linux-x64/libyoga.so
-var exports_libyoga3 = {};
-__export(exports_libyoga3, {
-  default: () => libyoga_default3
-});
-var libyoga_default3 = "./libyoga-wnbqxxhv.so";
-var init_libyoga3 = () => {};
-
-// ../../node_modules/bun-yoga/dist/linux-arm64/libyoga.so
-var exports_libyoga4 = {};
-__export(exports_libyoga4, {
-  default: () => libyoga_default4
-});
-var libyoga_default4 = "./libyoga-gh2tjwb7.so";
-var init_libyoga4 = () => {};
-
-// ../../node_modules/bun-yoga/dist/windows-x64/yoga.dll
-var exports_yoga = {};
-__export(exports_yoga, {
-  default: () => yoga_default
-});
-var yoga_default = "./yoga-jkgc6c1f.dll";
-var init_yoga = () => {};
-
-// ../../node_modules/bun-yoga/dist/index.js
-var require_dist = __commonJS((exports) => {
-  var __dirname = "/Users/runner/work/opentui/opentui/node_modules/bun-yoga/dist";
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.OVERFLOW_VISIBLE = exports.WRAP_WRAP_REVERSE = exports.WRAP_WRAP = exports.WRAP_NO_WRAP = exports.ALIGN_SPACE_EVENLY = exports.ALIGN_SPACE_AROUND = exports.ALIGN_SPACE_BETWEEN = exports.ALIGN_BASELINE = exports.ALIGN_STRETCH = exports.ALIGN_FLEX_END = exports.ALIGN_CENTER = exports.ALIGN_FLEX_START = exports.ALIGN_AUTO = exports.JUSTIFY_SPACE_EVENLY = exports.JUSTIFY_SPACE_AROUND = exports.JUSTIFY_SPACE_BETWEEN = exports.JUSTIFY_FLEX_END = exports.JUSTIFY_CENTER = exports.JUSTIFY_FLEX_START = exports.FLEX_DIRECTION_ROW_REVERSE = exports.FLEX_DIRECTION_ROW = exports.FLEX_DIRECTION_COLUMN_REVERSE = exports.FLEX_DIRECTION_COLUMN = exports.EDGE_ALL = exports.EDGE_VERTICAL = exports.EDGE_HORIZONTAL = exports.EDGE_END = exports.EDGE_START = exports.EDGE_BOTTOM = exports.EDGE_RIGHT = exports.EDGE_TOP = exports.EDGE_LEFT = exports.Wrap = exports.Unit = exports.PositionType = exports.Overflow = exports.NodeType = exports.MeasureMode = exports.LogLevel = exports.Justify = exports.Gutter = exports.FlexDirection = exports.ExperimentalFeature = exports.Errata = exports.Edge = exports.Display = exports.Direction = exports.Dimension = exports.BoxSizing = exports.Align = undefined;
-  exports.Config = exports.Node = exports.DIRECTION_RTL = exports.DIRECTION_LTR = exports.DIRECTION_INHERIT = exports.POSITION_TYPE_ABSOLUTE = exports.POSITION_TYPE_RELATIVE = exports.POSITION_TYPE_STATIC = exports.DISPLAY_NONE = exports.DISPLAY_FLEX = exports.OVERFLOW_SCROLL = exports.OVERFLOW_HIDDEN = undefined;
-  var bun_ffi_1 = __require("bun:ffi");
-  var path_1 = __require("path");
-  var fs_1 = __require("fs");
-  function getEmbeddedLib() {
-    try {
-      if (process.platform === "darwin" && process.arch === "arm64") {
-        return __require.resolve("/Users/runner/work/opentui/opentui/node_modules/bun-yoga/dist/darwin-arm64/libyoga.dylib");
-      } else if (process.platform === "darwin" && process.arch === "x64") {
-        return __require.resolve("/Users/runner/work/opentui/opentui/node_modules/bun-yoga/dist/darwin-x64/libyoga.dylib");
-      } else if (process.platform === "linux" && process.arch === "x64") {
-        return __require.resolve("/Users/runner/work/opentui/opentui/node_modules/bun-yoga/dist/linux-x64/libyoga.so");
-      } else if (process.platform === "linux" && process.arch === "arm64") {
-        return __require.resolve("/Users/runner/work/opentui/opentui/node_modules/bun-yoga/dist/linux-arm64/libyoga.so");
-      } else if (process.platform === "win32") {
-        return __require.resolve("/Users/runner/work/opentui/opentui/node_modules/bun-yoga/dist/windows-x64/yoga.dll");
-      }
-      return;
-    } catch {
-      return;
-    }
-  }
-  function getLibPath() {
-    if (process.platform === "win32") {
-      if ((0, fs_1.existsSync)((0, path_1.join)(__dirname, "..", "zig-out", "lib", `yoga.${bun_ffi_1.suffix}`))) {
-        return (0, path_1.join)(__dirname, "..", "zig-out", "lib", `yoga.${bun_ffi_1.suffix}`);
-      }
-      if ((0, fs_1.existsSync)((0, path_1.join)(__dirname, "..", "zig-out", "bin", `yoga.${bun_ffi_1.suffix}`))) {
-        return (0, path_1.join)(__dirname, "..", "zig-out", "bin", `yoga.${bun_ffi_1.suffix}`);
-      }
-    } else {
-      if ((0, fs_1.existsSync)((0, path_1.join)(__dirname, "..", "zig-out", "lib", `libyoga.${bun_ffi_1.suffix}`))) {
-        return (0, path_1.join)(__dirname, "..", "zig-out", "lib", `libyoga.${bun_ffi_1.suffix}`);
-      }
-    }
-    const embedded = getEmbeddedLib();
-    if (embedded) {
-      return embedded;
-    }
-    if (process.platform === "darwin" && process.arch === "arm64") {
-      if ((0, fs_1.existsSync)((0, path_1.join)(__dirname, "..", "dist", "darwin-arm64", `libyoga.${bun_ffi_1.suffix}`))) {
-        return (0, path_1.join)(__dirname, "..", "dist", "darwin-arm64", `libyoga.${bun_ffi_1.suffix}`);
-      }
-    } else if (process.platform === "darwin" && process.arch === "x64") {
-      if ((0, fs_1.existsSync)((0, path_1.join)(__dirname, "..", "dist", "darwin-x64", `libyoga.${bun_ffi_1.suffix}`))) {
-        return (0, path_1.join)(__dirname, "..", "dist", "darwin-x64", `libyoga.${bun_ffi_1.suffix}`);
-      }
-    } else if (process.platform === "linux" && process.arch === "x64") {
-      if ((0, fs_1.existsSync)((0, path_1.join)(__dirname, "..", "dist", "linux-x64", `libyoga.${bun_ffi_1.suffix}`))) {
-        return (0, path_1.join)(__dirname, "..", "dist", "linux-x64", `libyoga.${bun_ffi_1.suffix}`);
-      }
-    } else if (process.platform === "linux" && process.arch === "arm64") {
-      if ((0, fs_1.existsSync)((0, path_1.join)(__dirname, "..", "dist", "linux-arm64", `libyoga.${bun_ffi_1.suffix}`))) {
-        return (0, path_1.join)(__dirname, "..", "dist", "linux-arm64", `libyoga.${bun_ffi_1.suffix}`);
-      }
-    } else if (process.platform === "win32") {
-      if ((0, fs_1.existsSync)((0, path_1.join)(__dirname, "..", "dist", "windows-x64", `yoga.${bun_ffi_1.suffix}`))) {
-        return (0, path_1.join)(__dirname, "..", "dist", "windows-x64", `yoga.${bun_ffi_1.suffix}`);
-      }
-    }
-    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.`);
-  }
-  exports.Align = {
-    Auto: 0,
-    FlexStart: 1,
-    Center: 2,
-    FlexEnd: 3,
-    Stretch: 4,
-    Baseline: 5,
-    SpaceBetween: 6,
-    SpaceAround: 7,
-    SpaceEvenly: 8
-  };
-  exports.BoxSizing = {
-    BorderBox: 0,
-    ContentBox: 1
-  };
-  exports.Dimension = {
-    Width: 0,
-    Height: 1
-  };
-  exports.Direction = {
-    Inherit: 0,
-    LTR: 1,
-    RTL: 2
-  };
-  exports.Display = {
-    Flex: 0,
-    None: 1,
-    Contents: 2
-  };
-  exports.Edge = {
-    Left: 0,
-    Top: 1,
-    Right: 2,
-    Bottom: 3,
-    Start: 4,
-    End: 5,
-    Horizontal: 6,
-    Vertical: 7,
-    All: 8
-  };
-  exports.Errata = {
-    None: 0,
-    StretchFlexBasis: 1,
-    AbsolutePositionWithoutInsetsExcludesPadding: 2,
-    AbsolutePercentAgainstInnerSize: 4,
-    All: 2147483647,
-    Classic: 2147483646
-  };
-  exports.ExperimentalFeature = {
-    WebFlexBasis: 0
-  };
-  exports.FlexDirection = {
-    Column: 0,
-    ColumnReverse: 1,
-    Row: 2,
-    RowReverse: 3
-  };
-  exports.Gutter = {
-    Column: 0,
-    Row: 1,
-    All: 2
-  };
-  exports.Justify = {
-    FlexStart: 0,
-    Center: 1,
-    FlexEnd: 2,
-    SpaceBetween: 3,
-    SpaceAround: 4,
-    SpaceEvenly: 5
-  };
-  exports.LogLevel = {
-    Error: 0,
-    Warn: 1,
-    Info: 2,
-    Debug: 3,
-    Verbose: 4,
-    Fatal: 5
-  };
-  exports.MeasureMode = {
-    Undefined: 0,
-    Exactly: 1,
-    AtMost: 2
-  };
-  exports.NodeType = {
-    Default: 0,
-    Text: 1
-  };
-  exports.Overflow = {
-    Visible: 0,
-    Hidden: 1,
-    Scroll: 2
-  };
-  exports.PositionType = {
-    Static: 0,
-    Relative: 1,
-    Absolute: 2
-  };
-  exports.Unit = {
-    Undefined: 0,
-    Point: 1,
-    Percent: 2,
-    Auto: 3
-  };
-  exports.Wrap = {
-    NoWrap: 0,
-    Wrap: 1,
-    WrapReverse: 2
-  };
-  exports.EDGE_LEFT = exports.Edge.Left;
-  exports.EDGE_TOP = exports.Edge.Top;
-  exports.EDGE_RIGHT = exports.Edge.Right;
-  exports.EDGE_BOTTOM = exports.Edge.Bottom;
-  exports.EDGE_START = exports.Edge.Start;
-  exports.EDGE_END = exports.Edge.End;
-  exports.EDGE_HORIZONTAL = exports.Edge.Horizontal;
-  exports.EDGE_VERTICAL = exports.Edge.Vertical;
-  exports.EDGE_ALL = exports.Edge.All;
-  exports.FLEX_DIRECTION_COLUMN = exports.FlexDirection.Column;
-  exports.FLEX_DIRECTION_COLUMN_REVERSE = exports.FlexDirection.ColumnReverse;
-  exports.FLEX_DIRECTION_ROW = exports.FlexDirection.Row;
-  exports.FLEX_DIRECTION_ROW_REVERSE = exports.FlexDirection.RowReverse;
-  exports.JUSTIFY_FLEX_START = exports.Justify.FlexStart;
-  exports.JUSTIFY_CENTER = exports.Justify.Center;
-  exports.JUSTIFY_FLEX_END = exports.Justify.FlexEnd;
-  exports.JUSTIFY_SPACE_BETWEEN = exports.Justify.SpaceBetween;
-  exports.JUSTIFY_SPACE_AROUND = exports.Justify.SpaceAround;
-  exports.JUSTIFY_SPACE_EVENLY = exports.Justify.SpaceEvenly;
-  exports.ALIGN_AUTO = exports.Align.Auto;
-  exports.ALIGN_FLEX_START = exports.Align.FlexStart;
-  exports.ALIGN_CENTER = exports.Align.Center;
-  exports.ALIGN_FLEX_END = exports.Align.FlexEnd;
-  exports.ALIGN_STRETCH = exports.Align.Stretch;
-  exports.ALIGN_BASELINE = exports.Align.Baseline;
-  exports.ALIGN_SPACE_BETWEEN = exports.Align.SpaceBetween;
-  exports.ALIGN_SPACE_AROUND = exports.Align.SpaceAround;
-  exports.ALIGN_SPACE_EVENLY = exports.Align.SpaceEvenly;
-  exports.WRAP_NO_WRAP = exports.Wrap.NoWrap;
-  exports.WRAP_WRAP = exports.Wrap.Wrap;
-  exports.WRAP_WRAP_REVERSE = exports.Wrap.WrapReverse;
-  exports.OVERFLOW_VISIBLE = exports.Overflow.Visible;
-  exports.OVERFLOW_HIDDEN = exports.Overflow.Hidden;
-  exports.OVERFLOW_SCROLL = exports.Overflow.Scroll;
-  exports.DISPLAY_FLEX = exports.Display.Flex;
-  exports.DISPLAY_NONE = exports.Display.None;
-  exports.POSITION_TYPE_STATIC = exports.PositionType.Static;
-  exports.POSITION_TYPE_RELATIVE = exports.PositionType.Relative;
-  exports.POSITION_TYPE_ABSOLUTE = exports.PositionType.Absolute;
-  exports.DIRECTION_INHERIT = exports.Direction.Inherit;
-  exports.DIRECTION_LTR = exports.Direction.LTR;
-  exports.DIRECTION_RTL = exports.Direction.RTL;
-  function parseValue(value) {
-    if (value === undefined) {
-      return { unit: exports.Unit.Undefined, asNumber: undefined };
-    }
-    if (value === "auto") {
-      return { unit: exports.Unit.Auto, asNumber: undefined };
-    }
-    if (typeof value === "string" && value.endsWith("%")) {
-      return { unit: exports.Unit.Percent, asNumber: parseFloat(value) };
-    }
-    return { unit: exports.Unit.Point, asNumber: value };
-  }
-  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 = (0, bun_ffi_1.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;
-    }
-    assertNotFreed() {
-      if (this._freed) {
-        throw new Error("Cannot access freed Yoga node");
-      }
-    }
-    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() {
-      this.assertNotFreed();
-      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() {
-      this.assertNotFreed();
-      const ptr = yg.ygNodeClone(this.ptr);
-      if (!ptr)
-        throw new Error("Failed to clone node");
-      return new Node(ptr);
-    }
-    copyStyle(node) {
-      this.assertNotFreed();
-      yg.ygNodeCopyStyle(this.ptr, node.ptr);
-    }
-    setIsReferenceBaseline(isReferenceBaseline) {
-      this.assertNotFreed();
-      yg.ygNodeSetIsReferenceBaseline(this.ptr, isReferenceBaseline);
-    }
-    isReferenceBaseline() {
-      this.assertNotFreed();
-      return yg.ygNodeIsReferenceBaseline(this.ptr);
-    }
-    setAlwaysFormsContainingBlock(alwaysFormsContainingBlock) {
-      this.assertNotFreed();
-      yg.ygNodeSetAlwaysFormsContainingBlock(this.ptr, alwaysFormsContainingBlock);
-    }
-    insertChild(child, index) {
-      this.assertNotFreed();
-      yg.ygNodeInsertChild(this.ptr, child.ptr, index);
-    }
-    removeChild(child) {
-      this.assertNotFreed();
-      yg.ygNodeRemoveChild(this.ptr, child.ptr);
-    }
-    removeAllChildren() {
-      this.assertNotFreed();
-      yg.ygNodeRemoveAllChildren(this.ptr);
-    }
-    getChild(index) {
-      this.assertNotFreed();
-      const ptr = yg.ygNodeGetChild(this.ptr, index);
-      return ptr ? new Node(ptr) : null;
-    }
-    getChildCount() {
-      this.assertNotFreed();
-      return Number(yg.ygNodeGetChildCount(this.ptr));
-    }
-    getParent() {
-      this.assertNotFreed();
-      const ptr = yg.ygNodeGetParent(this.ptr);
-      return ptr ? new Node(ptr) : null;
-    }
-    calculateLayout(width, height, direction = exports.Direction.LTR) {
-      this.assertNotFreed();
-      const w = width === "auto" || width === undefined ? NaN : width;
-      const h = height === "auto" || height === undefined ? NaN : height;
-      yg.ygNodeCalculateLayout(this.ptr, w, h, direction);
-    }
-    hasNewLayout() {
-      this.assertNotFreed();
-      return yg.ygNodeGetHasNewLayout(this.ptr);
-    }
-    markLayoutSeen() {
-      this.assertNotFreed();
-      yg.ygNodeSetHasNewLayout(this.ptr, false);
-    }
-    markDirty() {
-      this.assertNotFreed();
-      yg.ygNodeMarkDirty(this.ptr);
-    }
-    isDirty() {
-      this.assertNotFreed();
-      return yg.ygNodeIsDirty(this.ptr);
-    }
-    getComputedLayout() {
-      this.assertNotFreed();
-      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() {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetLeft(this.ptr);
-    }
-    getComputedTop() {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetTop(this.ptr);
-    }
-    getComputedRight() {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetRight(this.ptr);
-    }
-    getComputedBottom() {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetBottom(this.ptr);
-    }
-    getComputedWidth() {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetWidth(this.ptr);
-    }
-    getComputedHeight() {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetHeight(this.ptr);
-    }
-    getComputedBorder(edge) {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetBorder(this.ptr, edge);
-    }
-    getComputedMargin(edge) {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetMargin(this.ptr, edge);
-    }
-    getComputedPadding(edge) {
-      this.assertNotFreed();
-      return yg.ygNodeLayoutGetPadding(this.ptr, edge);
-    }
-    setDirection(direction) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetDirection(this.ptr, direction);
-    }
-    getDirection() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetDirection(this.ptr);
-    }
-    setFlexDirection(flexDirection) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetFlexDirection(this.ptr, flexDirection);
-    }
-    getFlexDirection() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetFlexDirection(this.ptr);
-    }
-    setJustifyContent(justifyContent) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetJustifyContent(this.ptr, justifyContent);
-    }
-    getJustifyContent() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetJustifyContent(this.ptr);
-    }
-    setAlignContent(alignContent) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetAlignContent(this.ptr, alignContent);
-    }
-    getAlignContent() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetAlignContent(this.ptr);
-    }
-    setAlignItems(alignItems) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetAlignItems(this.ptr, alignItems);
-    }
-    getAlignItems() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetAlignItems(this.ptr);
-    }
-    setAlignSelf(alignSelf) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetAlignSelf(this.ptr, alignSelf);
-    }
-    getAlignSelf() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetAlignSelf(this.ptr);
-    }
-    setPositionType(positionType) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetPositionType(this.ptr, positionType);
-    }
-    getPositionType() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetPositionType(this.ptr);
-    }
-    setFlexWrap(flexWrap) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetFlexWrap(this.ptr, flexWrap);
-    }
-    getFlexWrap() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetFlexWrap(this.ptr);
-    }
-    setOverflow(overflow) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetOverflow(this.ptr, overflow);
-    }
-    getOverflow() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetOverflow(this.ptr);
-    }
-    setDisplay(display) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetDisplay(this.ptr, display);
-    }
-    getDisplay() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetDisplay(this.ptr);
-    }
-    setBoxSizing(boxSizing) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetBoxSizing(this.ptr, boxSizing);
-    }
-    getBoxSizing() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetBoxSizing(this.ptr);
-    }
-    setFlex(flex) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetFlex(this.ptr, flex);
-    }
-    getFlex() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetFlex(this.ptr);
-    }
-    setFlexGrow(flexGrow) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetFlexGrow(this.ptr, flexGrow);
-    }
-    getFlexGrow() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetFlexGrow(this.ptr);
-    }
-    setFlexShrink(flexShrink) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetFlexShrink(this.ptr, flexShrink);
-    }
-    getFlexShrink() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetFlexShrink(this.ptr);
-    }
-    setFlexBasis(flexBasis) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(flexBasis);
-      if (unit === exports.Unit.Auto) {
-        yg.ygNodeStyleSetFlexBasisAuto(this.ptr);
-      } else if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetFlexBasisPercent(this.ptr, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetFlexBasis(this.ptr, asNumber);
-      }
-    }
-    setFlexBasisPercent(flexBasis) {
-      this.assertNotFreed();
-      if (flexBasis !== undefined) {
-        yg.ygNodeStyleSetFlexBasisPercent(this.ptr, flexBasis);
-      }
-    }
-    setFlexBasisAuto() {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetFlexBasisAuto(this.ptr);
-    }
-    setPosition(edge, position) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(position);
-      if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetPositionPercent(this.ptr, edge, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetPosition(this.ptr, edge, asNumber);
-      }
-    }
-    setPositionPercent(edge, position) {
-      this.assertNotFreed();
-      if (position !== undefined) {
-        yg.ygNodeStyleSetPositionPercent(this.ptr, edge, position);
-      }
-    }
-    setPositionAuto(edge) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetPositionAuto(this.ptr, edge);
-    }
-    setMargin(edge, margin) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(margin);
-      if (unit === exports.Unit.Auto) {
-        yg.ygNodeStyleSetMarginAuto(this.ptr, edge);
-      } else if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetMarginPercent(this.ptr, edge, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetMargin(this.ptr, edge, asNumber);
-      }
-    }
-    setMarginPercent(edge, margin) {
-      this.assertNotFreed();
-      if (margin !== undefined) {
-        yg.ygNodeStyleSetMarginPercent(this.ptr, edge, margin);
-      }
-    }
-    setMarginAuto(edge) {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetMarginAuto(this.ptr, edge);
-    }
-    setPadding(edge, padding) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(padding);
-      if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetPaddingPercent(this.ptr, edge, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetPadding(this.ptr, edge, asNumber);
-      }
-    }
-    setPaddingPercent(edge, padding) {
-      this.assertNotFreed();
-      if (padding !== undefined) {
-        yg.ygNodeStyleSetPaddingPercent(this.ptr, edge, padding);
-      }
-    }
-    setBorder(edge, border) {
-      this.assertNotFreed();
-      if (border !== undefined) {
-        yg.ygNodeStyleSetBorder(this.ptr, edge, border);
-      }
-    }
-    getBorder(edge) {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetBorder(this.ptr, edge);
-    }
-    setGap(gutter, gap) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(gap);
-      if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetGapPercent(this.ptr, gutter, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetGap(this.ptr, gutter, asNumber);
-      }
-    }
-    setGapPercent(gutter, gap) {
-      this.assertNotFreed();
-      if (gap !== undefined) {
-        yg.ygNodeStyleSetGapPercent(this.ptr, gutter, gap);
-      }
-    }
-    setWidth(width) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(width);
-      if (unit === exports.Unit.Auto) {
-        yg.ygNodeStyleSetWidthAuto(this.ptr);
-      } else if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetWidthPercent(this.ptr, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetWidth(this.ptr, asNumber);
-      }
-    }
-    setWidthPercent(width) {
-      this.assertNotFreed();
-      if (width !== undefined) {
-        yg.ygNodeStyleSetWidthPercent(this.ptr, width);
-      }
-    }
-    setWidthAuto() {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetWidthAuto(this.ptr);
-    }
-    setHeight(height) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(height);
-      if (unit === exports.Unit.Auto) {
-        yg.ygNodeStyleSetHeightAuto(this.ptr);
-      } else if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetHeightPercent(this.ptr, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetHeight(this.ptr, asNumber);
-      }
-    }
-    setHeightPercent(height) {
-      this.assertNotFreed();
-      if (height !== undefined) {
-        yg.ygNodeStyleSetHeightPercent(this.ptr, height);
-      }
-    }
-    setHeightAuto() {
-      this.assertNotFreed();
-      yg.ygNodeStyleSetHeightAuto(this.ptr);
-    }
-    setMinWidth(minWidth) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(minWidth);
-      if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetMinWidthPercent(this.ptr, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetMinWidth(this.ptr, asNumber);
-      }
-    }
-    setMinWidthPercent(minWidth) {
-      this.assertNotFreed();
-      if (minWidth !== undefined) {
-        yg.ygNodeStyleSetMinWidthPercent(this.ptr, minWidth);
-      }
-    }
-    setMinHeight(minHeight) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(minHeight);
-      if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetMinHeightPercent(this.ptr, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetMinHeight(this.ptr, asNumber);
-      }
-    }
-    setMinHeightPercent(minHeight) {
-      this.assertNotFreed();
-      if (minHeight !== undefined) {
-        yg.ygNodeStyleSetMinHeightPercent(this.ptr, minHeight);
-      }
-    }
-    setMaxWidth(maxWidth) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(maxWidth);
-      if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetMaxWidthPercent(this.ptr, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetMaxWidth(this.ptr, asNumber);
-      }
-    }
-    setMaxWidthPercent(maxWidth) {
-      this.assertNotFreed();
-      if (maxWidth !== undefined) {
-        yg.ygNodeStyleSetMaxWidthPercent(this.ptr, maxWidth);
-      }
-    }
-    setMaxHeight(maxHeight) {
-      this.assertNotFreed();
-      const { unit, asNumber } = parseValue(maxHeight);
-      if (unit === exports.Unit.Percent) {
-        yg.ygNodeStyleSetMaxHeightPercent(this.ptr, asNumber);
-      } else if (unit === exports.Unit.Point && asNumber !== undefined) {
-        yg.ygNodeStyleSetMaxHeight(this.ptr, asNumber);
-      }
-    }
-    setMaxHeightPercent(maxHeight) {
-      this.assertNotFreed();
-      if (maxHeight !== undefined) {
-        yg.ygNodeStyleSetMaxHeightPercent(this.ptr, maxHeight);
-      }
-    }
-    setAspectRatio(aspectRatio) {
-      this.assertNotFreed();
-      if (aspectRatio !== undefined) {
-        yg.ygNodeStyleSetAspectRatio(this.ptr, aspectRatio);
-      }
-    }
-    getAspectRatio() {
-      this.assertNotFreed();
-      return yg.ygNodeStyleGetAspectRatio(this.ptr);
-    }
-    getWidth() {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetWidthPacked(this.ptr));
-    }
-    getHeight() {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetHeightPacked(this.ptr));
-    }
-    getMinWidth() {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetMinWidthPacked(this.ptr));
-    }
-    getMinHeight() {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetMinHeightPacked(this.ptr));
-    }
-    getMaxWidth() {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetMaxWidthPacked(this.ptr));
-    }
-    getMaxHeight() {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetMaxHeightPacked(this.ptr));
-    }
-    getMargin(edge) {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetMarginPacked(this.ptr, edge));
-    }
-    getPadding(edge) {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetPaddingPacked(this.ptr, edge));
-    }
-    getPosition(edge) {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetPositionPacked(this.ptr, edge));
-    }
-    getGap(gutter) {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetGapPacked(this.ptr, gutter));
-    }
-    getFlexBasis() {
-      this.assertNotFreed();
-      return unpackValue(yg.ygNodeStyleGetFlexBasisPacked(this.ptr));
-    }
-    setMeasureFunc(measureFunc) {
-      this.assertNotFreed();
-      this.unsetMeasureFunc();
-      if (measureFunc) {
-        this.measureCallback = new bun_ffi_1.JSCallback((nodePtr, width, widthMode, height, heightMode) => {
-          const result = measureFunc(width, widthMode, height, heightMode);
-          yg.ygStoreMeasureResult(result.width, result.height);
-        }, {
-          args: [
-            bun_ffi_1.FFIType.ptr,
-            bun_ffi_1.FFIType.f32,
-            bun_ffi_1.FFIType.u32,
-            bun_ffi_1.FFIType.f32,
-            bun_ffi_1.FFIType.u32
-          ],
-          returns: bun_ffi_1.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() {
-      this.assertNotFreed();
-      return yg.ygNodeHasMeasureFunc(this.ptr);
-    }
-    setBaselineFunc(baselineFunc) {
-      this.assertNotFreed();
-      this.unsetBaselineFunc();
-      if (baselineFunc) {
-        this.baselineCallback = new bun_ffi_1.JSCallback((nodePtr, width, height) => {
-          const result = baselineFunc(width, height);
-          yg.ygStoreBaselineResult(result);
-        }, {
-          args: [bun_ffi_1.FFIType.ptr, bun_ffi_1.FFIType.f32, bun_ffi_1.FFIType.f32],
-          returns: bun_ffi_1.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() {
-      this.assertNotFreed();
-      return yg.ygNodeHasBaselineFunc(this.ptr);
-    }
-    setDirtiedFunc(dirtiedFunc) {
-      this.assertNotFreed();
-      this.unsetDirtiedFunc();
-      if (dirtiedFunc) {
-        const node = this;
-        this.dirtiedCallback = new bun_ffi_1.JSCallback((nodePtr) => {
-          dirtiedFunc(node);
-        }, {
-          args: [bun_ffi_1.FFIType.ptr],
-          returns: bun_ffi_1.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() {
-      this.assertNotFreed();
-      return yg.ygNodeGetDirtiedFunc(this.ptr) !== null;
-    }
-  }
-  exports.Node = Node;
-
-  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);
-    }
-  }
-  exports.Config = Config;
-  exports.default = {
-    Node,
-    Config,
-    Align: exports.Align,
-    BoxSizing: exports.BoxSizing,
-    Dimension: exports.Dimension,
-    Direction: exports.Direction,
-    Display: exports.Display,
-    Edge: exports.Edge,
-    Errata: exports.Errata,
-    ExperimentalFeature: exports.ExperimentalFeature,
-    FlexDirection: exports.FlexDirection,
-    Gutter: exports.Gutter,
-    Justify: exports.Justify,
-    LogLevel: exports.LogLevel,
-    MeasureMode: exports.MeasureMode,
-    NodeType: exports.NodeType,
-    Overflow: exports.Overflow,
-    PositionType: exports.PositionType,
-    Unit: exports.Unit,
-    Wrap: exports.Wrap,
-    EDGE_LEFT: exports.EDGE_LEFT,
-    EDGE_TOP: exports.EDGE_TOP,
-    EDGE_RIGHT: exports.EDGE_RIGHT,
-    EDGE_BOTTOM: exports.EDGE_BOTTOM,
-    EDGE_START: exports.EDGE_START,
-    EDGE_END: exports.EDGE_END,
-    EDGE_HORIZONTAL: exports.EDGE_HORIZONTAL,
-    EDGE_VERTICAL: exports.EDGE_VERTICAL,
-    EDGE_ALL: exports.EDGE_ALL,
-    FLEX_DIRECTION_COLUMN: exports.FLEX_DIRECTION_COLUMN,
-    FLEX_DIRECTION_COLUMN_REVERSE: exports.FLEX_DIRECTION_COLUMN_REVERSE,
-    FLEX_DIRECTION_ROW: exports.FLEX_DIRECTION_ROW,
-    FLEX_DIRECTION_ROW_REVERSE: exports.FLEX_DIRECTION_ROW_REVERSE,
-    JUSTIFY_FLEX_START: exports.JUSTIFY_FLEX_START,
-    JUSTIFY_CENTER: exports.JUSTIFY_CENTER,
-    JUSTIFY_FLEX_END: exports.JUSTIFY_FLEX_END,
-    JUSTIFY_SPACE_BETWEEN: exports.JUSTIFY_SPACE_BETWEEN,
-    JUSTIFY_SPACE_AROUND: exports.JUSTIFY_SPACE_AROUND,
-    JUSTIFY_SPACE_EVENLY: exports.JUSTIFY_SPACE_EVENLY,
-    ALIGN_AUTO: exports.ALIGN_AUTO,
-    ALIGN_FLEX_START: exports.ALIGN_FLEX_START,
-    ALIGN_CENTER: exports.ALIGN_CENTER,
-    ALIGN_FLEX_END: exports.ALIGN_FLEX_END,
-    ALIGN_STRETCH: exports.ALIGN_STRETCH,
-    ALIGN_BASELINE: exports.ALIGN_BASELINE,
-    ALIGN_SPACE_BETWEEN: exports.ALIGN_SPACE_BETWEEN,
-    ALIGN_SPACE_AROUND: exports.ALIGN_SPACE_AROUND,
-    ALIGN_SPACE_EVENLY: exports.ALIGN_SPACE_EVENLY,
-    WRAP_NO_WRAP: exports.WRAP_NO_WRAP,
-    WRAP_WRAP: exports.WRAP_WRAP,
-    WRAP_WRAP_REVERSE: exports.WRAP_WRAP_REVERSE,
-    OVERFLOW_VISIBLE: exports.OVERFLOW_VISIBLE,
-    OVERFLOW_HIDDEN: exports.OVERFLOW_HIDDEN,
-    OVERFLOW_SCROLL: exports.OVERFLOW_SCROLL,
-    DISPLAY_FLEX: exports.DISPLAY_FLEX,
-    DISPLAY_NONE: exports.DISPLAY_NONE,
-    POSITION_TYPE_STATIC: exports.POSITION_TYPE_STATIC,
-    POSITION_TYPE_RELATIVE: exports.POSITION_TYPE_RELATIVE,
-    POSITION_TYPE_ABSOLUTE: exports.POSITION_TYPE_ABSOLUTE,
-    DIRECTION_INHERIT: exports.DIRECTION_INHERIT,
-    DIRECTION_LTR: exports.DIRECTION_LTR,
-    DIRECTION_RTL: exports.DIRECTION_RTL
-  };
-});
-
 // src/lib/border.ts
 var BorderChars = {
   single: {
@@ -5638,266 +4427,282 @@ class StdinBuffer extends EventEmitter2 {
 }
 
 // src/lib/yoga.options.ts
-var import_bun_yoga = __toESM(require_dist(), 1);
+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 import_bun_yoga.Align.Auto;
+    return Align.Auto;
   }
   switch (value.toLowerCase()) {
     case "auto":
-      return import_bun_yoga.Align.Auto;
+      return Align.Auto;
     case "flex-start":
-      return import_bun_yoga.Align.FlexStart;
+      return Align.FlexStart;
     case "center":
-      return import_bun_yoga.Align.Center;
+      return Align.Center;
     case "flex-end":
-      return import_bun_yoga.Align.FlexEnd;
+      return Align.FlexEnd;
     case "stretch":
-      return import_bun_yoga.Align.Stretch;
+      return Align.Stretch;
     case "baseline":
-      return import_bun_yoga.Align.Baseline;
+      return Align.Baseline;
     case "space-between":
-      return import_bun_yoga.Align.SpaceBetween;
+      return Align.SpaceBetween;
     case "space-around":
-      return import_bun_yoga.Align.SpaceAround;
+      return Align.SpaceAround;
     case "space-evenly":
-      return import_bun_yoga.Align.SpaceEvenly;
+      return Align.SpaceEvenly;
     default:
-      return import_bun_yoga.Align.Auto;
+      return Align.Auto;
   }
 }
 function parseBoxSizing(value) {
   if (value == null) {
-    return import_bun_yoga.BoxSizing.BorderBox;
+    return BoxSizing.BorderBox;
   }
   switch (value.toLowerCase()) {
     case "border-box":
-      return import_bun_yoga.BoxSizing.BorderBox;
+      return BoxSizing.BorderBox;
     case "content-box":
-      return import_bun_yoga.BoxSizing.ContentBox;
+      return BoxSizing.ContentBox;
     default:
-      return import_bun_yoga.BoxSizing.BorderBox;
+      return BoxSizing.BorderBox;
   }
 }
 function parseDimension(value) {
   if (value == null) {
-    return import_bun_yoga.Dimension.Width;
+    return Dimension.Width;
   }
   switch (value.toLowerCase()) {
     case "width":
-      return import_bun_yoga.Dimension.Width;
+      return Dimension.Width;
     case "height":
-      return import_bun_yoga.Dimension.Height;
+      return Dimension.Height;
     default:
-      return import_bun_yoga.Dimension.Width;
+      return Dimension.Width;
   }
 }
 function parseDirection(value) {
   if (value == null) {
-    return import_bun_yoga.Direction.LTR;
+    return Direction.LTR;
   }
   switch (value.toLowerCase()) {
     case "inherit":
-      return import_bun_yoga.Direction.Inherit;
+      return Direction.Inherit;
     case "ltr":
-      return import_bun_yoga.Direction.LTR;
+      return Direction.LTR;
     case "rtl":
-      return import_bun_yoga.Direction.RTL;
+      return Direction.RTL;
     default:
-      return import_bun_yoga.Direction.LTR;
+      return Direction.LTR;
   }
 }
 function parseDisplay(value) {
   if (value == null) {
-    return import_bun_yoga.Display.Flex;
+    return Display.Flex;
   }
   switch (value.toLowerCase()) {
     case "flex":
-      return import_bun_yoga.Display.Flex;
+      return Display.Flex;
     case "none":
-      return import_bun_yoga.Display.None;
+      return Display.None;
     case "contents":
-      return import_bun_yoga.Display.Contents;
+      return Display.Contents;
     default:
-      return import_bun_yoga.Display.Flex;
+      return Display.Flex;
   }
 }
 function parseEdge(value) {
   if (value == null) {
-    return import_bun_yoga.Edge.All;
+    return Edge.All;
   }
   switch (value.toLowerCase()) {
     case "left":
-      return import_bun_yoga.Edge.Left;
+      return Edge.Left;
     case "top":
-      return import_bun_yoga.Edge.Top;
+      return Edge.Top;
     case "right":
-      return import_bun_yoga.Edge.Right;
+      return Edge.Right;
     case "bottom":
-      return import_bun_yoga.Edge.Bottom;
+      return Edge.Bottom;
     case "start":
-      return import_bun_yoga.Edge.Start;
+      return Edge.Start;
     case "end":
-      return import_bun_yoga.Edge.End;
+      return Edge.End;
     case "horizontal":
-      return import_bun_yoga.Edge.Horizontal;
+      return Edge.Horizontal;
     case "vertical":
-      return import_bun_yoga.Edge.Vertical;
+      return Edge.Vertical;
     case "all":
-      return import_bun_yoga.Edge.All;
+      return Edge.All;
     default:
-      return import_bun_yoga.Edge.All;
+      return Edge.All;
   }
 }
 function parseFlexDirection(value) {
   if (value == null) {
-    return import_bun_yoga.FlexDirection.Column;
+    return FlexDirection.Column;
   }
   switch (value.toLowerCase()) {
     case "column":
-      return import_bun_yoga.FlexDirection.Column;
+      return FlexDirection.Column;
     case "column-reverse":
-      return import_bun_yoga.FlexDirection.ColumnReverse;
+      return FlexDirection.ColumnReverse;
     case "row":
-      return import_bun_yoga.FlexDirection.Row;
+      return FlexDirection.Row;
     case "row-reverse":
-      return import_bun_yoga.FlexDirection.RowReverse;
+      return FlexDirection.RowReverse;
     default:
-      return import_bun_yoga.FlexDirection.Column;
+      return FlexDirection.Column;
   }
 }
 function parseGutter(value) {
   if (value == null) {
-    return import_bun_yoga.Gutter.All;
+    return Gutter.All;
   }
   switch (value.toLowerCase()) {
     case "column":
-      return import_bun_yoga.Gutter.Column;
+      return Gutter.Column;
     case "row":
-      return import_bun_yoga.Gutter.Row;
+      return Gutter.Row;
     case "all":
-      return import_bun_yoga.Gutter.All;
+      return Gutter.All;
     default:
-      return import_bun_yoga.Gutter.All;
+      return Gutter.All;
   }
 }
 function parseJustify(value) {
   if (value == null) {
-    return import_bun_yoga.Justify.FlexStart;
+    return Justify.FlexStart;
   }
   switch (value.toLowerCase()) {
     case "flex-start":
-      return import_bun_yoga.Justify.FlexStart;
+      return Justify.FlexStart;
     case "center":
-      return import_bun_yoga.Justify.Center;
+      return Justify.Center;
     case "flex-end":
-      return import_bun_yoga.Justify.FlexEnd;
+      return Justify.FlexEnd;
     case "space-between":
-      return import_bun_yoga.Justify.SpaceBetween;
+      return Justify.SpaceBetween;
     case "space-around":
-      return import_bun_yoga.Justify.SpaceAround;
+      return Justify.SpaceAround;
     case "space-evenly":
-      return import_bun_yoga.Justify.SpaceEvenly;
+      return Justify.SpaceEvenly;
     default:
-      return import_bun_yoga.Justify.FlexStart;
+      return Justify.FlexStart;
   }
 }
 function parseLogLevel(value) {
   if (value == null) {
-    return import_bun_yoga.LogLevel.Info;
+    return LogLevel.Info;
   }
   switch (value.toLowerCase()) {
     case "error":
-      return import_bun_yoga.LogLevel.Error;
+      return LogLevel.Error;
     case "warn":
-      return import_bun_yoga.LogLevel.Warn;
+      return LogLevel.Warn;
     case "info":
-      return import_bun_yoga.LogLevel.Info;
+      return LogLevel.Info;
     case "debug":
-      return import_bun_yoga.LogLevel.Debug;
+      return LogLevel.Debug;
     case "verbose":
-      return import_bun_yoga.LogLevel.Verbose;
+      return LogLevel.Verbose;
     case "fatal":
-      return import_bun_yoga.LogLevel.Fatal;
+      return LogLevel.Fatal;
     default:
-      return import_bun_yoga.LogLevel.Info;
+      return LogLevel.Info;
   }
 }
 function parseMeasureMode(value) {
   if (value == null) {
-    return import_bun_yoga.MeasureMode.Undefined;
+    return MeasureMode.Undefined;
   }
   switch (value.toLowerCase()) {
     case "undefined":
-      return import_bun_yoga.MeasureMode.Undefined;
+      return MeasureMode.Undefined;
     case "exactly":
-      return import_bun_yoga.MeasureMode.Exactly;
+      return MeasureMode.Exactly;
     case "at-most":
-      return import_bun_yoga.MeasureMode.AtMost;
+      return MeasureMode.AtMost;
     default:
-      return import_bun_yoga.MeasureMode.Undefined;
+      return MeasureMode.Undefined;
   }
 }
 function parseOverflow(value) {
   if (value == null) {
-    return import_bun_yoga.Overflow.Visible;
+    return Overflow.Visible;
   }
   switch (value.toLowerCase()) {
     case "visible":
-      return import_bun_yoga.Overflow.Visible;
+      return Overflow.Visible;
     case "hidden":
-      return import_bun_yoga.Overflow.Hidden;
+      return Overflow.Hidden;
     case "scroll":
-      return import_bun_yoga.Overflow.Scroll;
+      return Overflow.Scroll;
     default:
-      return import_bun_yoga.Overflow.Visible;
+      return Overflow.Visible;
   }
 }
 function parsePositionType(value) {
   if (value == null) {
-    return import_bun_yoga.PositionType.Relative;
+    return PositionType.Relative;
   }
   switch (value.toLowerCase()) {
     case "static":
-      return import_bun_yoga.PositionType.Static;
+      return PositionType.Static;
     case "relative":
-      return import_bun_yoga.PositionType.Relative;
+      return PositionType.Relative;
     case "absolute":
-      return import_bun_yoga.PositionType.Absolute;
+      return PositionType.Absolute;
     default:
-      return import_bun_yoga.PositionType.Static;
+      return PositionType.Static;
   }
 }
 function parseUnit(value) {
   if (value == null) {
-    return import_bun_yoga.Unit.Point;
+    return Unit.Point;
   }
   switch (value.toLowerCase()) {
     case "undefined":
-      return import_bun_yoga.Unit.Undefined;
+      return Unit.Undefined;
     case "point":
-      return import_bun_yoga.Unit.Point;
+      return Unit.Point;
     case "percent":
-      return import_bun_yoga.Unit.Percent;
+      return Unit.Percent;
     case "auto":
-      return import_bun_yoga.Unit.Auto;
+      return Unit.Auto;
     default:
-      return import_bun_yoga.Unit.Point;
+      return Unit.Point;
   }
 }
 function parseWrap(value) {
   if (value == null) {
-    return import_bun_yoga.Wrap.NoWrap;
+    return Wrap.NoWrap;
   }
   switch (value.toLowerCase()) {
     case "no-wrap":
-      return import_bun_yoga.Wrap.NoWrap;
+      return Wrap.NoWrap;
     case "wrap":
-      return import_bun_yoga.Wrap.Wrap;
+      return Wrap.Wrap;
     case "wrap-reverse":
-      return import_bun_yoga.Wrap.WrapReverse;
+      return Wrap.WrapReverse;
     default:
-      return import_bun_yoga.Wrap.NoWrap;
+      return Wrap.NoWrap;
   }
 }
 
@@ -8702,7 +7507,7 @@ function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux) {
   return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux);
 }
 // src/zig.ts
-import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr3 } from "bun:ffi";
+import { dlopen, toArrayBuffer as toArrayBuffer3, JSCallback, ptr as ptr2 } from "bun:ffi";
 import { existsSync as existsSync2 } from "fs";
 import { EventEmitter as EventEmitter5 } from "events";
 
@@ -8924,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" }],
@@ -10588,7 +8786,7 @@ class FFIRenderLib {
         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) {
@@ -10634,12 +8832,12 @@ class FFIRenderLib {
         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);
         }
@@ -10705,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);
@@ -10973,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);
@@ -10984,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;
     }
@@ -10992,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;
@@ -11001,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;
@@ -11061,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,
@@ -11073,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,
@@ -11102,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;
     }
@@ -11110,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;
     }
@@ -11124,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;
@@ -11134,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);
@@ -11154,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;
@@ -11195,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],
@@ -11225,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,
@@ -11237,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,
@@ -11266,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;
@@ -11321,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) {
@@ -11339,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;
@@ -11347,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;
@@ -11367,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);
@@ -11395,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;
@@ -11403,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;
@@ -11436,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;
@@ -11445,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;
@@ -11458,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) {
@@ -11475,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) {
@@ -11499,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,
@@ -11531,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;
     }
@@ -11543,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 };
   }
@@ -11585,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);
@@ -11640,9 +9838,9 @@ class TextBuffer {
   _textBytes;
   _memId;
   _appendedChunks = [];
-  constructor(lib, ptr4) {
+  constructor(lib, ptr3) {
     this.lib = lib;
-    this.bufferPtr = ptr4;
+    this.bufferPtr = ptr3;
   }
   static create(widthMethod) {
     const lib = resolveRenderLib();
@@ -11824,8 +10022,8 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
-var import_bun_yoga2 = __toESM(require_dist(), 1);
 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) {
@@ -11955,7 +10153,7 @@ class BaseRenderable extends EventEmitter6 {
     this._visible = value;
   }
 }
-var yogaConfig = import_bun_yoga2.default.Config.create();
+var yogaConfig = Yoga.Config.create();
 yogaConfig.setUseWebDefaults(false);
 yogaConfig.setPointScaleFactor(1);
 
@@ -12021,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 = import_bun_yoga2.default.Node.create(yogaConfig);
-    this.yogaNode.setDisplay(this._visible ? import_bun_yoga2.Display.Flex : import_bun_yoga2.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) {
@@ -12057,7 +10255,7 @@ class Renderable extends BaseRenderable {
       return;
     const wasVisible = this._visible;
     this._visible = value;
-    this.yogaNode.setDisplay(value ? import_bun_yoga2.Display.Flex : import_bun_yoga2.Display.None);
+    this.yogaNode.setDisplay(value ? Display2.Flex : Display2.None);
     if (this._live) {
       if (!wasVisible && value) {
         this.propagateLiveCount(1);
@@ -12376,40 +10574,40 @@ class Renderable extends BaseRenderable {
   setupMarginAndPadding(options) {
     const node = this.yogaNode;
     if (isMarginType(options.margin)) {
-      node.setMargin(import_bun_yoga2.Edge.Top, options.margin);
-      node.setMargin(import_bun_yoga2.Edge.Right, options.margin);
-      node.setMargin(import_bun_yoga2.Edge.Bottom, options.margin);
-      node.setMargin(import_bun_yoga2.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(import_bun_yoga2.Edge.Top, options.marginTop);
+      node.setMargin(Edge2.Top, options.marginTop);
     }
     if (isMarginType(options.marginRight)) {
-      node.setMargin(import_bun_yoga2.Edge.Right, options.marginRight);
+      node.setMargin(Edge2.Right, options.marginRight);
     }
     if (isMarginType(options.marginBottom)) {
-      node.setMargin(import_bun_yoga2.Edge.Bottom, options.marginBottom);
+      node.setMargin(Edge2.Bottom, options.marginBottom);
     }
     if (isMarginType(options.marginLeft)) {
-      node.setMargin(import_bun_yoga2.Edge.Left, options.marginLeft);
+      node.setMargin(Edge2.Left, options.marginLeft);
     }
     if (isPaddingType(options.padding)) {
-      node.setPadding(import_bun_yoga2.Edge.Top, options.padding);
-      node.setPadding(import_bun_yoga2.Edge.Right, options.padding);
-      node.setPadding(import_bun_yoga2.Edge.Bottom, options.padding);
-      node.setPadding(import_bun_yoga2.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(import_bun_yoga2.Edge.Top, options.paddingTop);
+      node.setPadding(Edge2.Top, options.paddingTop);
     }
     if (isPaddingType(options.paddingRight)) {
-      node.setPadding(import_bun_yoga2.Edge.Right, options.paddingRight);
+      node.setPadding(Edge2.Right, options.paddingRight);
     }
     if (isPaddingType(options.paddingBottom)) {
-      node.setPadding(import_bun_yoga2.Edge.Bottom, options.paddingBottom);
+      node.setPadding(Edge2.Bottom, options.paddingBottom);
     }
     if (isPaddingType(options.paddingLeft)) {
-      node.setPadding(import_bun_yoga2.Edge.Left, options.paddingLeft);
+      node.setPadding(Edge2.Left, options.paddingLeft);
     }
   }
   set position(positionType) {
@@ -12438,30 +10636,30 @@ class Renderable extends BaseRenderable {
     const { top, right, bottom, left } = position;
     if (isPositionType(top)) {
       if (top === "auto") {
-        node.setPositionAuto(import_bun_yoga2.Edge.Top);
+        node.setPositionAuto(Edge2.Top);
       } else {
-        node.setPosition(import_bun_yoga2.Edge.Top, top);
+        node.setPosition(Edge2.Top, top);
       }
     }
     if (isPositionType(right)) {
       if (right === "auto") {
-        node.setPositionAuto(import_bun_yoga2.Edge.Right);
+        node.setPositionAuto(Edge2.Right);
       } else {
-        node.setPosition(import_bun_yoga2.Edge.Right, right);
+        node.setPosition(Edge2.Right, right);
       }
     }
     if (isPositionType(bottom)) {
       if (bottom === "auto") {
-        node.setPositionAuto(import_bun_yoga2.Edge.Bottom);
+        node.setPositionAuto(Edge2.Bottom);
       } else {
-        node.setPosition(import_bun_yoga2.Edge.Bottom, bottom);
+        node.setPosition(Edge2.Bottom, bottom);
       }
     }
     if (isPositionType(left)) {
       if (left === "auto") {
-        node.setPositionAuto(import_bun_yoga2.Edge.Left);
+        node.setPositionAuto(Edge2.Left);
       } else {
-        node.setPosition(import_bun_yoga2.Edge.Left, left);
+        node.setPosition(Edge2.Left, left);
       }
     }
     this.requestRender();
@@ -12533,68 +10731,68 @@ class Renderable extends BaseRenderable {
   set margin(margin) {
     if (isMarginType(margin)) {
       const node = this.yogaNode;
-      node.setMargin(import_bun_yoga2.Edge.Top, margin);
-      node.setMargin(import_bun_yoga2.Edge.Right, margin);
-      node.setMargin(import_bun_yoga2.Edge.Bottom, margin);
-      node.setMargin(import_bun_yoga2.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(import_bun_yoga2.Edge.Top, margin);
+      this.yogaNode.setMargin(Edge2.Top, margin);
       this.requestRender();
     }
   }
   set marginRight(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(import_bun_yoga2.Edge.Right, margin);
+      this.yogaNode.setMargin(Edge2.Right, margin);
       this.requestRender();
     }
   }
   set marginBottom(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(import_bun_yoga2.Edge.Bottom, margin);
+      this.yogaNode.setMargin(Edge2.Bottom, margin);
       this.requestRender();
     }
   }
   set marginLeft(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(import_bun_yoga2.Edge.Left, margin);
+      this.yogaNode.setMargin(Edge2.Left, margin);
       this.requestRender();
     }
   }
   set padding(padding) {
     if (isPaddingType(padding)) {
       const node = this.yogaNode;
-      node.setPadding(import_bun_yoga2.Edge.Top, padding);
-      node.setPadding(import_bun_yoga2.Edge.Right, padding);
-      node.setPadding(import_bun_yoga2.Edge.Bottom, padding);
-      node.setPadding(import_bun_yoga2.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(import_bun_yoga2.Edge.Top, padding);
+      this.yogaNode.setPadding(Edge2.Top, padding);
       this.requestRender();
     }
   }
   set paddingRight(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(import_bun_yoga2.Edge.Right, padding);
+      this.yogaNode.setPadding(Edge2.Right, padding);
       this.requestRender();
     }
   }
   set paddingBottom(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(import_bun_yoga2.Edge.Bottom, padding);
+      this.yogaNode.setPadding(Edge2.Bottom, padding);
       this.requestRender();
     }
   }
   set paddingLeft(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(import_bun_yoga2.Edge.Left, padding);
+      this.yogaNode.setPadding(Edge2.Left, padding);
       this.requestRender();
     }
   }
@@ -13010,10 +11208,10 @@ class RootRenderable extends Renderable {
     if (this.yogaNode) {
       this.yogaNode.free();
     }
-    this.yogaNode = import_bun_yoga2.default.Node.create(yogaConfig);
+    this.yogaNode = Yoga.Node.create(yogaConfig);
     this.yogaNode.setWidth(ctx.width);
     this.yogaNode.setHeight(ctx.height);
-    this.yogaNode.setFlexDirection(import_bun_yoga2.FlexDirection.Column);
+    this.yogaNode.setFlexDirection(FlexDirection2.Column);
     this.calculateLayout();
   }
   render(buffer, deltaTime) {
@@ -13054,7 +11252,7 @@ class RootRenderable extends Renderable {
     }
   }
   calculateLayout() {
-    this.yogaNode.calculateLayout(this.width, this.height, import_bun_yoga2.Direction.LTR);
+    this.yogaNode.calculateLayout(this.width, this.height, Direction2.LTR);
     this.emit("layout-changed" /* LAYOUT_CHANGED */);
   }
   resize(width, height) {
@@ -15380,7 +13578,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, require_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=4463EA6925DD17AC64756E2164756E21
-//# sourceMappingURL=index-r6acnfwr.js.map
+//# debugId=D2D576D668A923C064756E2164756E21
+//# sourceMappingURL=index-x5bb5xvn.js.map