@opentui/core 0.0.0-20251201-fe4cc80e → 0.0.0-20251202-71dcabc4

package/{index-533e9nca.js → index-r6acnfwr.js}

@@ -25,1109 +25,1190 @@ var __export = (target, all) => {
       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 require_libyoga = __commonJS((exports, module) => {
-  module.exports = "./libyoga-j5nt7np1.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 require_libyoga2 = __commonJS((exports, module) => {
-  module.exports = "./libyoga-2ksztx35.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 require_libyoga3 = __commonJS((exports, module) => {
-  module.exports = "./libyoga-wnbqxxhv.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 require_libyoga4 = __commonJS((exports, module) => {
-  module.exports = "./libyoga-gh2tjwb7.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 require_yoga = __commonJS((exports, module) => {
-  module.exports = "./yoga-jkgc6c1f.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 exports_dist = {};
-__export(exports_dist, {
-  default: () => dist_default,
-  Wrap: () => Wrap,
-  WRAP_WRAP_REVERSE: () => WRAP_WRAP_REVERSE,
-  WRAP_WRAP: () => WRAP_WRAP,
-  WRAP_NO_WRAP: () => WRAP_NO_WRAP,
-  Unit: () => Unit,
-  PositionType: () => PositionType,
-  POSITION_TYPE_STATIC: () => POSITION_TYPE_STATIC,
-  POSITION_TYPE_RELATIVE: () => POSITION_TYPE_RELATIVE,
-  POSITION_TYPE_ABSOLUTE: () => POSITION_TYPE_ABSOLUTE,
-  Overflow: () => Overflow,
-  OVERFLOW_VISIBLE: () => OVERFLOW_VISIBLE,
-  OVERFLOW_SCROLL: () => OVERFLOW_SCROLL,
-  OVERFLOW_HIDDEN: () => OVERFLOW_HIDDEN,
-  NodeType: () => NodeType,
-  Node: () => Node,
-  MeasureMode: () => MeasureMode,
-  LogLevel: () => LogLevel,
-  Justify: () => Justify,
-  JUSTIFY_SPACE_EVENLY: () => JUSTIFY_SPACE_EVENLY,
-  JUSTIFY_SPACE_BETWEEN: () => JUSTIFY_SPACE_BETWEEN,
-  JUSTIFY_SPACE_AROUND: () => JUSTIFY_SPACE_AROUND,
-  JUSTIFY_FLEX_START: () => JUSTIFY_FLEX_START,
-  JUSTIFY_FLEX_END: () => JUSTIFY_FLEX_END,
-  JUSTIFY_CENTER: () => JUSTIFY_CENTER,
-  Gutter: () => Gutter,
-  FlexDirection: () => FlexDirection,
-  FLEX_DIRECTION_ROW_REVERSE: () => FLEX_DIRECTION_ROW_REVERSE,
-  FLEX_DIRECTION_ROW: () => FLEX_DIRECTION_ROW,
-  FLEX_DIRECTION_COLUMN_REVERSE: () => FLEX_DIRECTION_COLUMN_REVERSE,
-  FLEX_DIRECTION_COLUMN: () => FLEX_DIRECTION_COLUMN,
-  ExperimentalFeature: () => ExperimentalFeature,
-  Errata: () => Errata,
-  Edge: () => Edge,
-  EDGE_VERTICAL: () => EDGE_VERTICAL,
-  EDGE_TOP: () => EDGE_TOP,
-  EDGE_START: () => EDGE_START,
-  EDGE_RIGHT: () => EDGE_RIGHT,
-  EDGE_LEFT: () => EDGE_LEFT,
-  EDGE_HORIZONTAL: () => EDGE_HORIZONTAL,
-  EDGE_END: () => EDGE_END,
-  EDGE_BOTTOM: () => EDGE_BOTTOM,
-  EDGE_ALL: () => EDGE_ALL,
-  Display: () => Display,
-  Direction: () => Direction,
-  Dimension: () => Dimension,
-  DISPLAY_NONE: () => DISPLAY_NONE,
-  DISPLAY_FLEX: () => DISPLAY_FLEX,
-  DIRECTION_RTL: () => DIRECTION_RTL,
-  DIRECTION_LTR: () => DIRECTION_LTR,
-  DIRECTION_INHERIT: () => DIRECTION_INHERIT,
-  Config: () => Config,
-  BoxSizing: () => BoxSizing,
-  Align: () => Align,
-  ALIGN_STRETCH: () => ALIGN_STRETCH,
-  ALIGN_SPACE_EVENLY: () => ALIGN_SPACE_EVENLY,
-  ALIGN_SPACE_BETWEEN: () => ALIGN_SPACE_BETWEEN,
-  ALIGN_SPACE_AROUND: () => ALIGN_SPACE_AROUND,
-  ALIGN_FLEX_START: () => ALIGN_FLEX_START,
-  ALIGN_FLEX_END: () => ALIGN_FLEX_END,
-  ALIGN_CENTER: () => ALIGN_CENTER,
-  ALIGN_BASELINE: () => ALIGN_BASELINE,
-  ALIGN_AUTO: () => ALIGN_AUTO
-});
-import { dlopen, suffix, JSCallback, FFIType } from "bun:ffi";
-import { join } from "path";
-import { existsSync } from "fs";
-import { arch, platform } from "os";
-function getPlatformTarget() {
-  const p = platform();
-  const a = arch();
-  if (p === "darwin") {
-    return a === "arm64" ? "darwin-arm64" : "darwin-x64";
-  } else if (p === "linux") {
-    return a === "arm64" ? "linux-arm64" : "linux-x64";
-  } else if (p === "win32") {
-    return "windows-x64";
-  }
-  throw new Error(`Unsupported platform: ${p}-${a}`);
-}
-function getEmbeddedLib() {
-  const target = getPlatformTarget();
-  try {
-    switch (target) {
-      case "darwin-arm64":
-        return require_libyoga();
-      case "darwin-x64":
-        return require_libyoga2();
-      case "linux-x64":
-        return require_libyoga3();
-      case "linux-arm64":
-        return require_libyoga4();
-      case "windows-x64":
-        return require_yoga();
-      default:
-        return;
+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;
     }
-  } catch {
-    return;
   }
-}
-function getLibPath() {
-  const libName = platform() === "win32" ? `yoga.${suffix}` : `libyoga.${suffix}`;
-  const target = getPlatformTarget();
-  const devPath = join(import.meta.dir, "..", "zig-out", "lib", libName);
-  if (existsSync(devPath)) {
-    return devPath;
-  }
-  if (platform() === "win32") {
-    const devPathBin = join(import.meta.dir, "..", "zig-out", "bin", libName);
-    if (existsSync(devPathBin)) {
-      return devPathBin;
+  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 && existsSync(embedded)) {
-    return embedded;
-  }
-  const distPath = join(import.meta.dir, "..", "dist", target, libName);
-  if (existsSync(distPath)) {
-    return distPath;
-  }
-  throw new Error(`Could not find native library ${libName}. ` + `Looked in:
-  - ${devPath}
-  - ${distPath}
+    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.`);
-}
-var Align = {
-  Auto: 0,
-  FlexStart: 1,
-  Center: 2,
-  FlexEnd: 3,
-  Stretch: 4,
-  Baseline: 5,
-  SpaceBetween: 6,
-  SpaceAround: 7,
-  SpaceEvenly: 8
-};
-var BoxSizing = {
-  BorderBox: 0,
-  ContentBox: 1
-};
-var Dimension = {
-  Width: 0,
-  Height: 1
-};
-var Direction = {
-  Inherit: 0,
-  LTR: 1,
-  RTL: 2
-};
-var Display = {
-  Flex: 0,
-  None: 1,
-  Contents: 2
-};
-var Edge = {
-  Left: 0,
-  Top: 1,
-  Right: 2,
-  Bottom: 3,
-  Start: 4,
-  End: 5,
-  Horizontal: 6,
-  Vertical: 7,
-  All: 8
-};
-var Errata = {
-  None: 0,
-  StretchFlexBasis: 1,
-  AbsolutePositionWithoutInsetsExcludesPadding: 2,
-  AbsolutePercentAgainstInnerSize: 4,
-  All: 2147483647,
-  Classic: 2147483646
-};
-var ExperimentalFeature = {
-  WebFlexBasis: 0
-};
-var FlexDirection = {
-  Column: 0,
-  ColumnReverse: 1,
-  Row: 2,
-  RowReverse: 3
-};
-var Gutter = {
-  Column: 0,
-  Row: 1,
-  All: 2
-};
-var Justify = {
-  FlexStart: 0,
-  Center: 1,
-  FlexEnd: 2,
-  SpaceBetween: 3,
-  SpaceAround: 4,
-  SpaceEvenly: 5
-};
-var LogLevel = {
-  Error: 0,
-  Warn: 1,
-  Info: 2,
-  Debug: 3,
-  Verbose: 4,
-  Fatal: 5
-};
-var MeasureMode = {
-  Undefined: 0,
-  Exactly: 1,
-  AtMost: 2
-};
-var NodeType = {
-  Default: 0,
-  Text: 1
-};
-var Overflow = {
-  Visible: 0,
-  Hidden: 1,
-  Scroll: 2
-};
-var PositionType = {
-  Static: 0,
-  Relative: 1,
-  Absolute: 2
-};
-var Unit = {
-  Undefined: 0,
-  Point: 1,
-  Percent: 2,
-  Auto: 3
-};
-var Wrap = {
-  NoWrap: 0,
-  Wrap: 1,
-  WrapReverse: 2
-};
-var EDGE_LEFT = Edge.Left;
-var EDGE_TOP = Edge.Top;
-var EDGE_RIGHT = Edge.Right;
-var EDGE_BOTTOM = Edge.Bottom;
-var EDGE_START = Edge.Start;
-var EDGE_END = Edge.End;
-var EDGE_HORIZONTAL = Edge.Horizontal;
-var EDGE_VERTICAL = Edge.Vertical;
-var EDGE_ALL = Edge.All;
-var FLEX_DIRECTION_COLUMN = FlexDirection.Column;
-var FLEX_DIRECTION_COLUMN_REVERSE = FlexDirection.ColumnReverse;
-var FLEX_DIRECTION_ROW = FlexDirection.Row;
-var FLEX_DIRECTION_ROW_REVERSE = FlexDirection.RowReverse;
-var JUSTIFY_FLEX_START = Justify.FlexStart;
-var JUSTIFY_CENTER = Justify.Center;
-var JUSTIFY_FLEX_END = Justify.FlexEnd;
-var JUSTIFY_SPACE_BETWEEN = Justify.SpaceBetween;
-var JUSTIFY_SPACE_AROUND = Justify.SpaceAround;
-var JUSTIFY_SPACE_EVENLY = Justify.SpaceEvenly;
-var ALIGN_AUTO = Align.Auto;
-var ALIGN_FLEX_START = Align.FlexStart;
-var ALIGN_CENTER = Align.Center;
-var ALIGN_FLEX_END = Align.FlexEnd;
-var ALIGN_STRETCH = Align.Stretch;
-var ALIGN_BASELINE = Align.Baseline;
-var ALIGN_SPACE_BETWEEN = Align.SpaceBetween;
-var ALIGN_SPACE_AROUND = Align.SpaceAround;
-var ALIGN_SPACE_EVENLY = Align.SpaceEvenly;
-var WRAP_NO_WRAP = Wrap.NoWrap;
-var WRAP_WRAP = Wrap.Wrap;
-var WRAP_WRAP_REVERSE = Wrap.WrapReverse;
-var OVERFLOW_VISIBLE = Overflow.Visible;
-var OVERFLOW_HIDDEN = Overflow.Hidden;
-var OVERFLOW_SCROLL = Overflow.Scroll;
-var DISPLAY_FLEX = Display.Flex;
-var DISPLAY_NONE = Display.None;
-var POSITION_TYPE_STATIC = PositionType.Static;
-var POSITION_TYPE_RELATIVE = PositionType.Relative;
-var POSITION_TYPE_ABSOLUTE = PositionType.Absolute;
-var DIRECTION_INHERIT = Direction.Inherit;
-var DIRECTION_LTR = Direction.LTR;
-var DIRECTION_RTL = Direction.RTL;
-function parseValue(value) {
-  if (value === undefined) {
-    return { unit: Unit.Undefined, asNumber: undefined };
-  }
-  if (value === "auto") {
-    return { unit: Unit.Auto, asNumber: undefined };
   }
-  if (typeof value === "string" && value.endsWith("%")) {
-    return { unit: Unit.Percent, asNumber: parseFloat(value) };
-  }
-  return { unit: Unit.Point, asNumber: value };
-}
-function unpackValue(packed) {
-  const p = BigInt(packed);
-  const unit = Number(p & 0xffffffffn);
-  const valueBits = Number(p >> 32n & 0xffffffffn);
-  const buffer = new ArrayBuffer(4);
-  const view = new DataView(buffer);
-  view.setUint32(0, valueBits, true);
-  const value = view.getFloat32(0, true);
-  return { unit, value };
-}
-var lib = dlopen(getLibPath(), {
-  ygConfigNew: { args: [], returns: "ptr" },
-  ygConfigFree: { args: ["ptr"], returns: "void" },
-  ygConfigGetDefault: { args: [], returns: "ptr" },
-  ygConfigSetUseWebDefaults: { args: ["ptr", "bool"], returns: "void" },
-  ygConfigGetUseWebDefaults: { args: ["ptr"], returns: "bool" },
-  ygConfigSetPointScaleFactor: { args: ["ptr", "f32"], returns: "void" },
-  ygConfigGetPointScaleFactor: { args: ["ptr"], returns: "f32" },
-  ygConfigSetErrata: { args: ["ptr", "i32"], returns: "void" },
-  ygConfigGetErrata: { args: ["ptr"], returns: "i32" },
-  ygConfigSetExperimentalFeatureEnabled: {
-    args: ["ptr", "i32", "bool"],
-    returns: "void"
-  },
-  ygConfigIsExperimentalFeatureEnabled: {
-    args: ["ptr", "i32"],
-    returns: "bool"
-  },
-  ygNodeNew: { args: [], returns: "ptr" },
-  ygNodeNewWithConfig: { args: ["ptr"], returns: "ptr" },
-  ygNodeClone: { args: ["ptr"], returns: "ptr" },
-  ygNodeFree: { args: ["ptr"], returns: "void" },
-  ygNodeFreeRecursive: { args: ["ptr"], returns: "void" },
-  ygNodeReset: { args: ["ptr"], returns: "void" },
-  ygNodeCopyStyle: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeSetIsReferenceBaseline: { args: ["ptr", "bool"], returns: "void" },
-  ygNodeIsReferenceBaseline: { args: ["ptr"], returns: "bool" },
-  ygNodeSetAlwaysFormsContainingBlock: {
-    args: ["ptr", "bool"],
-    returns: "void"
-  },
-  ygNodeInsertChild: { args: ["ptr", "ptr", "u64"], returns: "void" },
-  ygNodeRemoveChild: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeRemoveAllChildren: { args: ["ptr"], returns: "void" },
-  ygNodeGetChild: { args: ["ptr", "u64"], returns: "ptr" },
-  ygNodeGetChildCount: { args: ["ptr"], returns: "u64" },
-  ygNodeGetParent: { args: ["ptr"], returns: "ptr" },
-  ygNodeCalculateLayout: { args: ["ptr", "f32", "f32", "i32"], returns: "void" },
-  ygNodeGetHasNewLayout: { args: ["ptr"], returns: "bool" },
-  ygNodeSetHasNewLayout: { args: ["ptr", "bool"], returns: "void" },
-  ygNodeMarkDirty: { args: ["ptr"], returns: "void" },
-  ygNodeIsDirty: { args: ["ptr"], returns: "bool" },
-  ygNodeLayoutGetLeft: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetTop: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetRight: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetBottom: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetWidth: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetHeight: { args: ["ptr"], returns: "f32" },
-  ygNodeLayoutGetBorder: { args: ["ptr", "i32"], returns: "f32" },
-  ygNodeLayoutGetMargin: { args: ["ptr", "i32"], returns: "f32" },
-  ygNodeLayoutGetPadding: { args: ["ptr", "i32"], returns: "f32" },
-  ygNodeStyleSetDirection: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetDirection: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetFlexDirection: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetFlexDirection: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetJustifyContent: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetJustifyContent: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetAlignContent: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetAlignContent: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetAlignItems: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetAlignItems: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetAlignSelf: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetAlignSelf: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetPositionType: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetPositionType: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetFlexWrap: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetFlexWrap: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetOverflow: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetOverflow: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetDisplay: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetDisplay: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetBoxSizing: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleGetBoxSizing: { args: ["ptr"], returns: "i32" },
-  ygNodeStyleSetFlex: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleGetFlex: { args: ["ptr"], returns: "f32" },
-  ygNodeStyleSetFlexGrow: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleGetFlexGrow: { args: ["ptr"], returns: "f32" },
-  ygNodeStyleSetFlexShrink: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleGetFlexShrink: { args: ["ptr"], returns: "f32" },
-  ygNodeStyleSetFlexBasis: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetFlexBasisPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetFlexBasisAuto: { args: ["ptr"], returns: "void" },
-  ygNodeStyleSetPosition: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetPositionPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetPositionAuto: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleSetMargin: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetMarginPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetMarginAuto: { args: ["ptr", "i32"], returns: "void" },
-  ygNodeStyleSetPadding: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetPaddingPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetBorder: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleGetBorder: { args: ["ptr", "i32"], returns: "f32" },
-  ygNodeStyleSetGap: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetGapPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
-  ygNodeStyleSetWidth: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetWidthPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetWidthAuto: { args: ["ptr"], returns: "void" },
-  ygNodeStyleSetHeight: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetHeightPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetHeightAuto: { args: ["ptr"], returns: "void" },
-  ygNodeStyleSetMinWidth: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMinWidthPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMinHeight: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMinHeightPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMaxWidth: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMaxWidthPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMaxHeight: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetMaxHeightPercent: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleSetAspectRatio: { args: ["ptr", "f32"], returns: "void" },
-  ygNodeStyleGetAspectRatio: { args: ["ptr"], returns: "f32" },
-  ygNodeSetContext: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeGetContext: { args: ["ptr"], returns: "ptr" },
-  ygNodeSetMeasureFunc: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetMeasureFunc: { args: ["ptr"], returns: "void" },
-  ygNodeHasMeasureFunc: { args: ["ptr"], returns: "bool" },
-  ygNodeSetBaselineFunc: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetBaselineFunc: { args: ["ptr"], returns: "void" },
-  ygNodeHasBaselineFunc: { args: ["ptr"], returns: "bool" },
-  ygNodeSetDirtiedFunc: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetDirtiedFunc: { args: ["ptr"], returns: "void" },
-  ygNodeGetDirtiedFunc: { args: ["ptr"], returns: "ptr" },
-  ygCreateSize: { args: ["f32", "f32"], returns: "u64" },
-  ygStoreMeasureResult: { args: ["f32", "f32"], returns: "void" },
-  ygStoreBaselineResult: { args: ["f32"], returns: "void" },
-  ygNodeSetMeasureFuncTrampoline: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetMeasureFuncTrampoline: { args: ["ptr"], returns: "void" },
-  ygNodeSetBaselineFuncTrampoline: { args: ["ptr", "ptr"], returns: "void" },
-  ygNodeUnsetBaselineFuncTrampoline: { args: ["ptr"], returns: "void" },
-  ygNodeFreeCallbacks: { args: ["ptr"], returns: "void" },
-  ygNodeStyleGetWidthPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetHeightPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMinWidthPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMinHeightPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMaxWidthPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMaxHeightPacked: { args: ["ptr"], returns: "u64" },
-  ygNodeStyleGetMarginPacked: { args: ["ptr", "i32"], returns: "u64" },
-  ygNodeStyleGetPaddingPacked: { args: ["ptr", "i32"], returns: "u64" },
-  ygNodeStyleGetPositionPacked: { args: ["ptr", "i32"], returns: "u64" },
-  ygNodeStyleGetGapPacked: { args: ["ptr", "i32"], returns: "u64" },
-  ygNodeStyleGetFlexBasisPacked: { args: ["ptr"], returns: "u64" }
-});
-var yg = lib.symbols;
+  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;
-  measureCallback = null;
-  baselineCallback = null;
-  dirtiedCallback = null;
-  constructor(ptr) {
-    this.ptr = ptr;
-  }
-  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() {
-    this.unsetMeasureFunc();
-    this.unsetBaselineFunc();
-    this.unsetDirtiedFunc();
-    yg.ygNodeFree(this.ptr);
-  }
-  freeRecursive() {
-    this.cleanupCallbacks();
-    yg.ygNodeFreeRecursive(this.ptr);
-  }
-  reset() {
-    this.cleanupCallbacks();
-    yg.ygNodeReset(this.ptr);
-  }
-  cleanupCallbacks() {
-    if (this.measureCallback) {
-      this.measureCallback.close();
-      this.measureCallback = null;
+  class Node {
+    ptr;
+    _freed = false;
+    measureCallback = null;
+    baselineCallback = null;
+    dirtiedCallback = null;
+    constructor(ptr) {
+      this.ptr = ptr;
     }
-    if (this.baselineCallback) {
-      this.baselineCallback.close();
-      this.baselineCallback = null;
+    isFreed() {
+      return this._freed;
     }
-    if (this.dirtiedCallback) {
-      this.dirtiedCallback.close();
-      this.dirtiedCallback = null;
+    assertNotFreed() {
+      if (this._freed) {
+        throw new Error("Cannot access freed Yoga node");
+      }
     }
-  }
-  clone() {
-    const ptr = yg.ygNodeClone(this.ptr);
-    if (!ptr)
-      throw new Error("Failed to clone node");
-    return new Node(ptr);
-  }
-  copyStyle(node) {
-    yg.ygNodeCopyStyle(this.ptr, node.ptr);
-  }
-  setIsReferenceBaseline(isReferenceBaseline) {
-    yg.ygNodeSetIsReferenceBaseline(this.ptr, isReferenceBaseline);
-  }
-  isReferenceBaseline() {
-    return yg.ygNodeIsReferenceBaseline(this.ptr);
-  }
-  setAlwaysFormsContainingBlock(alwaysFormsContainingBlock) {
-    yg.ygNodeSetAlwaysFormsContainingBlock(this.ptr, alwaysFormsContainingBlock);
-  }
-  insertChild(child, index) {
-    yg.ygNodeInsertChild(this.ptr, child.ptr, index);
-  }
-  removeChild(child) {
-    yg.ygNodeRemoveChild(this.ptr, child.ptr);
-  }
-  removeAllChildren() {
-    yg.ygNodeRemoveAllChildren(this.ptr);
-  }
-  getChild(index) {
-    const ptr = yg.ygNodeGetChild(this.ptr, index);
-    return ptr ? new Node(ptr) : null;
-  }
-  getChildCount() {
-    return Number(yg.ygNodeGetChildCount(this.ptr));
-  }
-  getParent() {
-    const ptr = yg.ygNodeGetParent(this.ptr);
-    return ptr ? new Node(ptr) : null;
-  }
-  calculateLayout(width, height, direction = Direction.LTR) {
-    const w = width === "auto" || width === undefined ? NaN : width;
-    const h = height === "auto" || height === undefined ? NaN : height;
-    yg.ygNodeCalculateLayout(this.ptr, w, h, direction);
-  }
-  hasNewLayout() {
-    return yg.ygNodeGetHasNewLayout(this.ptr);
-  }
-  markLayoutSeen() {
-    yg.ygNodeSetHasNewLayout(this.ptr, false);
-  }
-  markDirty() {
-    yg.ygNodeMarkDirty(this.ptr);
-  }
-  isDirty() {
-    return yg.ygNodeIsDirty(this.ptr);
-  }
-  getComputedLayout() {
-    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() {
-    return yg.ygNodeLayoutGetLeft(this.ptr);
-  }
-  getComputedTop() {
-    return yg.ygNodeLayoutGetTop(this.ptr);
-  }
-  getComputedRight() {
-    return yg.ygNodeLayoutGetRight(this.ptr);
-  }
-  getComputedBottom() {
-    return yg.ygNodeLayoutGetBottom(this.ptr);
-  }
-  getComputedWidth() {
-    return yg.ygNodeLayoutGetWidth(this.ptr);
-  }
-  getComputedHeight() {
-    return yg.ygNodeLayoutGetHeight(this.ptr);
-  }
-  getComputedBorder(edge) {
-    return yg.ygNodeLayoutGetBorder(this.ptr, edge);
-  }
-  getComputedMargin(edge) {
-    return yg.ygNodeLayoutGetMargin(this.ptr, edge);
-  }
-  getComputedPadding(edge) {
-    return yg.ygNodeLayoutGetPadding(this.ptr, edge);
-  }
-  setDirection(direction) {
-    yg.ygNodeStyleSetDirection(this.ptr, direction);
-  }
-  getDirection() {
-    return yg.ygNodeStyleGetDirection(this.ptr);
-  }
-  setFlexDirection(flexDirection) {
-    yg.ygNodeStyleSetFlexDirection(this.ptr, flexDirection);
-  }
-  getFlexDirection() {
-    return yg.ygNodeStyleGetFlexDirection(this.ptr);
-  }
-  setJustifyContent(justifyContent) {
-    yg.ygNodeStyleSetJustifyContent(this.ptr, justifyContent);
-  }
-  getJustifyContent() {
-    return yg.ygNodeStyleGetJustifyContent(this.ptr);
-  }
-  setAlignContent(alignContent) {
-    yg.ygNodeStyleSetAlignContent(this.ptr, alignContent);
-  }
-  getAlignContent() {
-    return yg.ygNodeStyleGetAlignContent(this.ptr);
-  }
-  setAlignItems(alignItems) {
-    yg.ygNodeStyleSetAlignItems(this.ptr, alignItems);
-  }
-  getAlignItems() {
-    return yg.ygNodeStyleGetAlignItems(this.ptr);
-  }
-  setAlignSelf(alignSelf) {
-    yg.ygNodeStyleSetAlignSelf(this.ptr, alignSelf);
-  }
-  getAlignSelf() {
-    return yg.ygNodeStyleGetAlignSelf(this.ptr);
-  }
-  setPositionType(positionType) {
-    yg.ygNodeStyleSetPositionType(this.ptr, positionType);
-  }
-  getPositionType() {
-    return yg.ygNodeStyleGetPositionType(this.ptr);
-  }
-  setFlexWrap(flexWrap) {
-    yg.ygNodeStyleSetFlexWrap(this.ptr, flexWrap);
-  }
-  getFlexWrap() {
-    return yg.ygNodeStyleGetFlexWrap(this.ptr);
-  }
-  setOverflow(overflow) {
-    yg.ygNodeStyleSetOverflow(this.ptr, overflow);
-  }
-  getOverflow() {
-    return yg.ygNodeStyleGetOverflow(this.ptr);
-  }
-  setDisplay(display) {
-    yg.ygNodeStyleSetDisplay(this.ptr, display);
-  }
-  getDisplay() {
-    return yg.ygNodeStyleGetDisplay(this.ptr);
-  }
-  setBoxSizing(boxSizing) {
-    yg.ygNodeStyleSetBoxSizing(this.ptr, boxSizing);
-  }
-  getBoxSizing() {
-    return yg.ygNodeStyleGetBoxSizing(this.ptr);
-  }
-  setFlex(flex) {
-    yg.ygNodeStyleSetFlex(this.ptr, flex);
-  }
-  getFlex() {
-    return yg.ygNodeStyleGetFlex(this.ptr);
-  }
-  setFlexGrow(flexGrow) {
-    yg.ygNodeStyleSetFlexGrow(this.ptr, flexGrow);
-  }
-  getFlexGrow() {
-    return yg.ygNodeStyleGetFlexGrow(this.ptr);
-  }
-  setFlexShrink(flexShrink) {
-    yg.ygNodeStyleSetFlexShrink(this.ptr, flexShrink);
-  }
-  getFlexShrink() {
-    return yg.ygNodeStyleGetFlexShrink(this.ptr);
-  }
-  setFlexBasis(flexBasis) {
-    const { unit, asNumber } = parseValue(flexBasis);
-    if (unit === Unit.Auto) {
-      yg.ygNodeStyleSetFlexBasisAuto(this.ptr);
-    } else if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetFlexBasisPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetFlexBasis(this.ptr, asNumber);
+    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);
     }
-  }
-  setFlexBasisPercent(flexBasis) {
-    if (flexBasis !== undefined) {
-      yg.ygNodeStyleSetFlexBasisPercent(this.ptr, flexBasis);
+    static createDefault() {
+      return Node.create();
     }
-  }
-  setFlexBasisAuto() {
-    yg.ygNodeStyleSetFlexBasisAuto(this.ptr);
-  }
-  setPosition(edge, position) {
-    const { unit, asNumber } = parseValue(position);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetPositionPercent(this.ptr, edge, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetPosition(this.ptr, edge, asNumber);
+    static createWithConfig(config) {
+      return Node.create(config);
     }
-  }
-  setPositionPercent(edge, position) {
-    if (position !== undefined) {
-      yg.ygNodeStyleSetPositionPercent(this.ptr, edge, position);
+    static destroy(node) {
+      node.free();
     }
-  }
-  setPositionAuto(edge) {
-    yg.ygNodeStyleSetPositionAuto(this.ptr, edge);
-  }
-  setMargin(edge, margin) {
-    const { unit, asNumber } = parseValue(margin);
-    if (unit === Unit.Auto) {
-      yg.ygNodeStyleSetMarginAuto(this.ptr, edge);
-    } else if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMarginPercent(this.ptr, edge, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMargin(this.ptr, edge, asNumber);
+    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)
+      };
     }
-  }
-  setMarginPercent(edge, margin) {
-    if (margin !== undefined) {
-      yg.ygNodeStyleSetMarginPercent(this.ptr, edge, margin);
+    getComputedLeft() {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetLeft(this.ptr);
     }
-  }
-  setMarginAuto(edge) {
-    yg.ygNodeStyleSetMarginAuto(this.ptr, edge);
-  }
-  setPadding(edge, padding) {
-    const { unit, asNumber } = parseValue(padding);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetPaddingPercent(this.ptr, edge, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetPadding(this.ptr, edge, asNumber);
+    getComputedTop() {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetTop(this.ptr);
     }
-  }
-  setPaddingPercent(edge, padding) {
-    if (padding !== undefined) {
-      yg.ygNodeStyleSetPaddingPercent(this.ptr, edge, padding);
+    getComputedRight() {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetRight(this.ptr);
     }
-  }
-  setBorder(edge, border) {
-    if (border !== undefined) {
-      yg.ygNodeStyleSetBorder(this.ptr, edge, border);
+    getComputedBottom() {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetBottom(this.ptr);
     }
-  }
-  getBorder(edge) {
-    return yg.ygNodeStyleGetBorder(this.ptr, edge);
-  }
-  setGap(gutter, gap) {
-    const { unit, asNumber } = parseValue(gap);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetGapPercent(this.ptr, gutter, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetGap(this.ptr, gutter, asNumber);
+    getComputedWidth() {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetWidth(this.ptr);
     }
-  }
-  setGapPercent(gutter, gap) {
-    if (gap !== undefined) {
-      yg.ygNodeStyleSetGapPercent(this.ptr, gutter, gap);
+    getComputedHeight() {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetHeight(this.ptr);
     }
-  }
-  setWidth(width) {
-    const { unit, asNumber } = parseValue(width);
-    if (unit === Unit.Auto) {
-      yg.ygNodeStyleSetWidthAuto(this.ptr);
-    } else if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetWidthPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetWidth(this.ptr, asNumber);
+    getComputedBorder(edge) {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetBorder(this.ptr, edge);
     }
-  }
-  setWidthPercent(width) {
-    if (width !== undefined) {
-      yg.ygNodeStyleSetWidthPercent(this.ptr, width);
+    getComputedMargin(edge) {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetMargin(this.ptr, edge);
     }
-  }
-  setWidthAuto() {
-    yg.ygNodeStyleSetWidthAuto(this.ptr);
-  }
-  setHeight(height) {
-    const { unit, asNumber } = parseValue(height);
-    if (unit === Unit.Auto) {
-      yg.ygNodeStyleSetHeightAuto(this.ptr);
-    } else if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetHeightPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetHeight(this.ptr, asNumber);
+    getComputedPadding(edge) {
+      this.assertNotFreed();
+      return yg.ygNodeLayoutGetPadding(this.ptr, edge);
     }
-  }
-  setHeightPercent(height) {
-    if (height !== undefined) {
-      yg.ygNodeStyleSetHeightPercent(this.ptr, height);
+    setDirection(direction) {
+      this.assertNotFreed();
+      yg.ygNodeStyleSetDirection(this.ptr, direction);
     }
-  }
-  setHeightAuto() {
-    yg.ygNodeStyleSetHeightAuto(this.ptr);
-  }
-  setMinWidth(minWidth) {
-    const { unit, asNumber } = parseValue(minWidth);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMinWidthPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMinWidth(this.ptr, asNumber);
+    getDirection() {
+      this.assertNotFreed();
+      return yg.ygNodeStyleGetDirection(this.ptr);
     }
-  }
-  setMinWidthPercent(minWidth) {
-    if (minWidth !== undefined) {
-      yg.ygNodeStyleSetMinWidthPercent(this.ptr, minWidth);
+    setFlexDirection(flexDirection) {
+      this.assertNotFreed();
+      yg.ygNodeStyleSetFlexDirection(this.ptr, flexDirection);
     }
-  }
-  setMinHeight(minHeight) {
-    const { unit, asNumber } = parseValue(minHeight);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMinHeightPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMinHeight(this.ptr, asNumber);
+    getFlexDirection() {
+      this.assertNotFreed();
+      return yg.ygNodeStyleGetFlexDirection(this.ptr);
     }
-  }
-  setMinHeightPercent(minHeight) {
-    if (minHeight !== undefined) {
-      yg.ygNodeStyleSetMinHeightPercent(this.ptr, minHeight);
+    setJustifyContent(justifyContent) {
+      this.assertNotFreed();
+      yg.ygNodeStyleSetJustifyContent(this.ptr, justifyContent);
+    }
+    getJustifyContent() {
+      this.assertNotFreed();
+      return yg.ygNodeStyleGetJustifyContent(this.ptr);
     }
-  }
-  setMaxWidth(maxWidth) {
-    const { unit, asNumber } = parseValue(maxWidth);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMaxWidthPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMaxWidth(this.ptr, asNumber);
+    setAlignContent(alignContent) {
+      this.assertNotFreed();
+      yg.ygNodeStyleSetAlignContent(this.ptr, alignContent);
     }
-  }
-  setMaxWidthPercent(maxWidth) {
-    if (maxWidth !== undefined) {
-      yg.ygNodeStyleSetMaxWidthPercent(this.ptr, maxWidth);
+    getAlignContent() {
+      this.assertNotFreed();
+      return yg.ygNodeStyleGetAlignContent(this.ptr);
     }
-  }
-  setMaxHeight(maxHeight) {
-    const { unit, asNumber } = parseValue(maxHeight);
-    if (unit === Unit.Percent) {
-      yg.ygNodeStyleSetMaxHeightPercent(this.ptr, asNumber);
-    } else if (unit === Unit.Point && asNumber !== undefined) {
-      yg.ygNodeStyleSetMaxHeight(this.ptr, asNumber);
+    setAlignItems(alignItems) {
+      this.assertNotFreed();
+      yg.ygNodeStyleSetAlignItems(this.ptr, alignItems);
     }
-  }
-  setMaxHeightPercent(maxHeight) {
-    if (maxHeight !== undefined) {
-      yg.ygNodeStyleSetMaxHeightPercent(this.ptr, maxHeight);
+    getAlignItems() {
+      this.assertNotFreed();
+      return yg.ygNodeStyleGetAlignItems(this.ptr);
     }
-  }
-  setAspectRatio(aspectRatio) {
-    if (aspectRatio !== undefined) {
-      yg.ygNodeStyleSetAspectRatio(this.ptr, aspectRatio);
+    setAlignSelf(alignSelf) {
+      this.assertNotFreed();
+      yg.ygNodeStyleSetAlignSelf(this.ptr, alignSelf);
     }
-  }
-  getAspectRatio() {
-    return yg.ygNodeStyleGetAspectRatio(this.ptr);
-  }
-  getWidth() {
-    return unpackValue(yg.ygNodeStyleGetWidthPacked(this.ptr));
-  }
-  getHeight() {
-    return unpackValue(yg.ygNodeStyleGetHeightPacked(this.ptr));
-  }
-  getMinWidth() {
-    return unpackValue(yg.ygNodeStyleGetMinWidthPacked(this.ptr));
-  }
-  getMinHeight() {
-    return unpackValue(yg.ygNodeStyleGetMinHeightPacked(this.ptr));
-  }
-  getMaxWidth() {
-    return unpackValue(yg.ygNodeStyleGetMaxWidthPacked(this.ptr));
-  }
-  getMaxHeight() {
-    return unpackValue(yg.ygNodeStyleGetMaxHeightPacked(this.ptr));
-  }
-  getMargin(edge) {
-    return unpackValue(yg.ygNodeStyleGetMarginPacked(this.ptr, edge));
-  }
-  getPadding(edge) {
-    return unpackValue(yg.ygNodeStyleGetPaddingPacked(this.ptr, edge));
-  }
-  getPosition(edge) {
-    return unpackValue(yg.ygNodeStyleGetPositionPacked(this.ptr, edge));
-  }
-  getGap(gutter) {
-    return unpackValue(yg.ygNodeStyleGetGapPacked(this.ptr, gutter));
-  }
-  getFlexBasis() {
-    return unpackValue(yg.ygNodeStyleGetFlexBasisPacked(this.ptr));
-  }
-  setMeasureFunc(measureFunc) {
-    this.unsetMeasureFunc();
-    if (measureFunc) {
-      this.measureCallback = new JSCallback((nodePtr, width, widthMode, height, heightMode) => {
-        const result = measureFunc(width, widthMode, height, heightMode);
-        yg.ygStoreMeasureResult(result.width, result.height);
-      }, {
-        args: [
-          FFIType.ptr,
-          FFIType.f32,
-          FFIType.u32,
-          FFIType.f32,
-          FFIType.u32
-        ],
-        returns: FFIType.void
-      });
-      if (this.measureCallback.ptr) {
-        yg.ygNodeSetMeasureFuncTrampoline(this.ptr, this.measureCallback.ptr);
+    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);
       }
     }
-  }
-  unsetMeasureFunc() {
-    if (this.measureCallback) {
-      this.measureCallback.close();
-      this.measureCallback = null;
+    setFlexBasisPercent(flexBasis) {
+      this.assertNotFreed();
+      if (flexBasis !== undefined) {
+        yg.ygNodeStyleSetFlexBasisPercent(this.ptr, flexBasis);
+      }
     }
-    yg.ygNodeUnsetMeasureFuncTrampoline(this.ptr);
-  }
-  hasMeasureFunc() {
-    return yg.ygNodeHasMeasureFunc(this.ptr);
-  }
-  setBaselineFunc(baselineFunc) {
-    this.unsetBaselineFunc();
-    if (baselineFunc) {
-      this.baselineCallback = new JSCallback((nodePtr, width, height) => {
-        const result = baselineFunc(width, height);
-        yg.ygStoreBaselineResult(result);
-      }, {
-        args: [FFIType.ptr, FFIType.f32, FFIType.f32],
-        returns: FFIType.void
-      });
-      if (this.baselineCallback.ptr) {
-        yg.ygNodeSetBaselineFuncTrampoline(this.ptr, this.baselineCallback.ptr);
+    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);
       }
     }
-  }
-  unsetBaselineFunc() {
-    if (this.baselineCallback) {
-      this.baselineCallback.close();
-      this.baselineCallback = null;
+    setPositionPercent(edge, position) {
+      this.assertNotFreed();
+      if (position !== undefined) {
+        yg.ygNodeStyleSetPositionPercent(this.ptr, edge, position);
+      }
     }
-    yg.ygNodeUnsetBaselineFuncTrampoline(this.ptr);
-  }
-  hasBaselineFunc() {
-    return yg.ygNodeHasBaselineFunc(this.ptr);
-  }
-  setDirtiedFunc(dirtiedFunc) {
-    this.unsetDirtiedFunc();
-    if (dirtiedFunc) {
-      const node = this;
-      this.dirtiedCallback = new JSCallback((nodePtr) => {
-        dirtiedFunc(node);
-      }, {
-        args: [FFIType.ptr],
-        returns: FFIType.void
-      });
-      if (this.dirtiedCallback.ptr) {
-        yg.ygNodeSetDirtiedFunc(this.ptr, this.dirtiedCallback.ptr);
+    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);
       }
     }
-  }
-  unsetDirtiedFunc() {
-    if (this.dirtiedCallback) {
-      this.dirtiedCallback.close();
-      this.dirtiedCallback = null;
+    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;
     }
-    yg.ygNodeUnsetDirtiedFunc(this.ptr);
-  }
-  hasDirtiedFunc() {
-    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);
-  }
-}
-var dist_default = {
-  Node,
-  Config,
-  Align,
-  BoxSizing,
-  Dimension,
-  Direction,
-  Display,
-  Edge,
-  Errata,
-  ExperimentalFeature,
-  FlexDirection,
-  Gutter,
-  Justify,
-  LogLevel,
-  MeasureMode,
-  NodeType,
-  Overflow,
-  PositionType,
-  Unit,
-  Wrap,
-  EDGE_LEFT,
-  EDGE_TOP,
-  EDGE_RIGHT,
-  EDGE_BOTTOM,
-  EDGE_START,
-  EDGE_END,
-  EDGE_HORIZONTAL,
-  EDGE_VERTICAL,
-  EDGE_ALL,
-  FLEX_DIRECTION_COLUMN,
-  FLEX_DIRECTION_COLUMN_REVERSE,
-  FLEX_DIRECTION_ROW,
-  FLEX_DIRECTION_ROW_REVERSE,
-  JUSTIFY_FLEX_START,
-  JUSTIFY_CENTER,
-  JUSTIFY_FLEX_END,
-  JUSTIFY_SPACE_BETWEEN,
-  JUSTIFY_SPACE_AROUND,
-  JUSTIFY_SPACE_EVENLY,
-  ALIGN_AUTO,
-  ALIGN_FLEX_START,
-  ALIGN_CENTER,
-  ALIGN_FLEX_END,
-  ALIGN_STRETCH,
-  ALIGN_BASELINE,
-  ALIGN_SPACE_BETWEEN,
-  ALIGN_SPACE_AROUND,
-  ALIGN_SPACE_EVENLY,
-  WRAP_NO_WRAP,
-  WRAP_WRAP,
-  WRAP_WRAP_REVERSE,
-  OVERFLOW_VISIBLE,
-  OVERFLOW_HIDDEN,
-  OVERFLOW_SCROLL,
-  DISPLAY_FLEX,
-  DISPLAY_NONE,
-  POSITION_TYPE_STATIC,
-  POSITION_TYPE_RELATIVE,
-  POSITION_TYPE_ABSOLUTE,
-  DIRECTION_INHERIT,
-  DIRECTION_LTR,
-  DIRECTION_RTL
-};
+  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 = {
@@ -5557,265 +5638,266 @@ class StdinBuffer extends EventEmitter2 {
 }
 
 // src/lib/yoga.options.ts
+var import_bun_yoga = __toESM(require_dist(), 1);
 function parseAlign(value) {
   if (value == null) {
-    return Align.Auto;
+    return import_bun_yoga.Align.Auto;
   }
   switch (value.toLowerCase()) {
     case "auto":
-      return Align.Auto;
+      return import_bun_yoga.Align.Auto;
     case "flex-start":
-      return Align.FlexStart;
+      return import_bun_yoga.Align.FlexStart;
     case "center":
-      return Align.Center;
+      return import_bun_yoga.Align.Center;
     case "flex-end":
-      return Align.FlexEnd;
+      return import_bun_yoga.Align.FlexEnd;
     case "stretch":
-      return Align.Stretch;
+      return import_bun_yoga.Align.Stretch;
     case "baseline":
-      return Align.Baseline;
+      return import_bun_yoga.Align.Baseline;
     case "space-between":
-      return Align.SpaceBetween;
+      return import_bun_yoga.Align.SpaceBetween;
     case "space-around":
-      return Align.SpaceAround;
+      return import_bun_yoga.Align.SpaceAround;
     case "space-evenly":
-      return Align.SpaceEvenly;
+      return import_bun_yoga.Align.SpaceEvenly;
     default:
-      return Align.Auto;
+      return import_bun_yoga.Align.Auto;
   }
 }
 function parseBoxSizing(value) {
   if (value == null) {
-    return BoxSizing.BorderBox;
+    return import_bun_yoga.BoxSizing.BorderBox;
   }
   switch (value.toLowerCase()) {
     case "border-box":
-      return BoxSizing.BorderBox;
+      return import_bun_yoga.BoxSizing.BorderBox;
     case "content-box":
-      return BoxSizing.ContentBox;
+      return import_bun_yoga.BoxSizing.ContentBox;
     default:
-      return BoxSizing.BorderBox;
+      return import_bun_yoga.BoxSizing.BorderBox;
   }
 }
 function parseDimension(value) {
   if (value == null) {
-    return Dimension.Width;
+    return import_bun_yoga.Dimension.Width;
   }
   switch (value.toLowerCase()) {
     case "width":
-      return Dimension.Width;
+      return import_bun_yoga.Dimension.Width;
     case "height":
-      return Dimension.Height;
+      return import_bun_yoga.Dimension.Height;
     default:
-      return Dimension.Width;
+      return import_bun_yoga.Dimension.Width;
   }
 }
 function parseDirection(value) {
   if (value == null) {
-    return Direction.LTR;
+    return import_bun_yoga.Direction.LTR;
   }
   switch (value.toLowerCase()) {
     case "inherit":
-      return Direction.Inherit;
+      return import_bun_yoga.Direction.Inherit;
     case "ltr":
-      return Direction.LTR;
+      return import_bun_yoga.Direction.LTR;
     case "rtl":
-      return Direction.RTL;
+      return import_bun_yoga.Direction.RTL;
     default:
-      return Direction.LTR;
+      return import_bun_yoga.Direction.LTR;
   }
 }
 function parseDisplay(value) {
   if (value == null) {
-    return Display.Flex;
+    return import_bun_yoga.Display.Flex;
   }
   switch (value.toLowerCase()) {
     case "flex":
-      return Display.Flex;
+      return import_bun_yoga.Display.Flex;
     case "none":
-      return Display.None;
+      return import_bun_yoga.Display.None;
     case "contents":
-      return Display.Contents;
+      return import_bun_yoga.Display.Contents;
     default:
-      return Display.Flex;
+      return import_bun_yoga.Display.Flex;
   }
 }
 function parseEdge(value) {
   if (value == null) {
-    return Edge.All;
+    return import_bun_yoga.Edge.All;
   }
   switch (value.toLowerCase()) {
     case "left":
-      return Edge.Left;
+      return import_bun_yoga.Edge.Left;
     case "top":
-      return Edge.Top;
+      return import_bun_yoga.Edge.Top;
     case "right":
-      return Edge.Right;
+      return import_bun_yoga.Edge.Right;
     case "bottom":
-      return Edge.Bottom;
+      return import_bun_yoga.Edge.Bottom;
     case "start":
-      return Edge.Start;
+      return import_bun_yoga.Edge.Start;
     case "end":
-      return Edge.End;
+      return import_bun_yoga.Edge.End;
     case "horizontal":
-      return Edge.Horizontal;
+      return import_bun_yoga.Edge.Horizontal;
     case "vertical":
-      return Edge.Vertical;
+      return import_bun_yoga.Edge.Vertical;
     case "all":
-      return Edge.All;
+      return import_bun_yoga.Edge.All;
     default:
-      return Edge.All;
+      return import_bun_yoga.Edge.All;
   }
 }
 function parseFlexDirection(value) {
   if (value == null) {
-    return FlexDirection.Column;
+    return import_bun_yoga.FlexDirection.Column;
   }
   switch (value.toLowerCase()) {
     case "column":
-      return FlexDirection.Column;
+      return import_bun_yoga.FlexDirection.Column;
     case "column-reverse":
-      return FlexDirection.ColumnReverse;
+      return import_bun_yoga.FlexDirection.ColumnReverse;
     case "row":
-      return FlexDirection.Row;
+      return import_bun_yoga.FlexDirection.Row;
     case "row-reverse":
-      return FlexDirection.RowReverse;
+      return import_bun_yoga.FlexDirection.RowReverse;
     default:
-      return FlexDirection.Column;
+      return import_bun_yoga.FlexDirection.Column;
   }
 }
 function parseGutter(value) {
   if (value == null) {
-    return Gutter.All;
+    return import_bun_yoga.Gutter.All;
   }
   switch (value.toLowerCase()) {
     case "column":
-      return Gutter.Column;
+      return import_bun_yoga.Gutter.Column;
     case "row":
-      return Gutter.Row;
+      return import_bun_yoga.Gutter.Row;
     case "all":
-      return Gutter.All;
+      return import_bun_yoga.Gutter.All;
     default:
-      return Gutter.All;
+      return import_bun_yoga.Gutter.All;
   }
 }
 function parseJustify(value) {
   if (value == null) {
-    return Justify.FlexStart;
+    return import_bun_yoga.Justify.FlexStart;
   }
   switch (value.toLowerCase()) {
     case "flex-start":
-      return Justify.FlexStart;
+      return import_bun_yoga.Justify.FlexStart;
     case "center":
-      return Justify.Center;
+      return import_bun_yoga.Justify.Center;
     case "flex-end":
-      return Justify.FlexEnd;
+      return import_bun_yoga.Justify.FlexEnd;
     case "space-between":
-      return Justify.SpaceBetween;
+      return import_bun_yoga.Justify.SpaceBetween;
     case "space-around":
-      return Justify.SpaceAround;
+      return import_bun_yoga.Justify.SpaceAround;
     case "space-evenly":
-      return Justify.SpaceEvenly;
+      return import_bun_yoga.Justify.SpaceEvenly;
     default:
-      return Justify.FlexStart;
+      return import_bun_yoga.Justify.FlexStart;
   }
 }
 function parseLogLevel(value) {
   if (value == null) {
-    return LogLevel.Info;
+    return import_bun_yoga.LogLevel.Info;
   }
   switch (value.toLowerCase()) {
     case "error":
-      return LogLevel.Error;
+      return import_bun_yoga.LogLevel.Error;
     case "warn":
-      return LogLevel.Warn;
+      return import_bun_yoga.LogLevel.Warn;
     case "info":
-      return LogLevel.Info;
+      return import_bun_yoga.LogLevel.Info;
     case "debug":
-      return LogLevel.Debug;
+      return import_bun_yoga.LogLevel.Debug;
     case "verbose":
-      return LogLevel.Verbose;
+      return import_bun_yoga.LogLevel.Verbose;
     case "fatal":
-      return LogLevel.Fatal;
+      return import_bun_yoga.LogLevel.Fatal;
     default:
-      return LogLevel.Info;
+      return import_bun_yoga.LogLevel.Info;
   }
 }
 function parseMeasureMode(value) {
   if (value == null) {
-    return MeasureMode.Undefined;
+    return import_bun_yoga.MeasureMode.Undefined;
   }
   switch (value.toLowerCase()) {
     case "undefined":
-      return MeasureMode.Undefined;
+      return import_bun_yoga.MeasureMode.Undefined;
     case "exactly":
-      return MeasureMode.Exactly;
+      return import_bun_yoga.MeasureMode.Exactly;
     case "at-most":
-      return MeasureMode.AtMost;
+      return import_bun_yoga.MeasureMode.AtMost;
     default:
-      return MeasureMode.Undefined;
+      return import_bun_yoga.MeasureMode.Undefined;
   }
 }
 function parseOverflow(value) {
   if (value == null) {
-    return Overflow.Visible;
+    return import_bun_yoga.Overflow.Visible;
   }
   switch (value.toLowerCase()) {
     case "visible":
-      return Overflow.Visible;
+      return import_bun_yoga.Overflow.Visible;
     case "hidden":
-      return Overflow.Hidden;
+      return import_bun_yoga.Overflow.Hidden;
     case "scroll":
-      return Overflow.Scroll;
+      return import_bun_yoga.Overflow.Scroll;
     default:
-      return Overflow.Visible;
+      return import_bun_yoga.Overflow.Visible;
   }
 }
 function parsePositionType(value) {
   if (value == null) {
-    return PositionType.Relative;
+    return import_bun_yoga.PositionType.Relative;
   }
   switch (value.toLowerCase()) {
     case "static":
-      return PositionType.Static;
+      return import_bun_yoga.PositionType.Static;
     case "relative":
-      return PositionType.Relative;
+      return import_bun_yoga.PositionType.Relative;
     case "absolute":
-      return PositionType.Absolute;
+      return import_bun_yoga.PositionType.Absolute;
     default:
-      return PositionType.Static;
+      return import_bun_yoga.PositionType.Static;
   }
 }
 function parseUnit(value) {
   if (value == null) {
-    return Unit.Point;
+    return import_bun_yoga.Unit.Point;
   }
   switch (value.toLowerCase()) {
     case "undefined":
-      return Unit.Undefined;
+      return import_bun_yoga.Unit.Undefined;
     case "point":
-      return Unit.Point;
+      return import_bun_yoga.Unit.Point;
     case "percent":
-      return Unit.Percent;
+      return import_bun_yoga.Unit.Percent;
     case "auto":
-      return Unit.Auto;
+      return import_bun_yoga.Unit.Auto;
     default:
-      return Unit.Point;
+      return import_bun_yoga.Unit.Point;
   }
 }
 function parseWrap(value) {
   if (value == null) {
-    return Wrap.NoWrap;
+    return import_bun_yoga.Wrap.NoWrap;
   }
   switch (value.toLowerCase()) {
     case "no-wrap":
-      return Wrap.NoWrap;
+      return import_bun_yoga.Wrap.NoWrap;
     case "wrap":
-      return Wrap.Wrap;
+      return import_bun_yoga.Wrap.Wrap;
     case "wrap-reverse":
-      return Wrap.WrapReverse;
+      return import_bun_yoga.Wrap.WrapReverse;
     default:
-      return Wrap.NoWrap;
+      return import_bun_yoga.Wrap.NoWrap;
   }
 }
 
@@ -6666,7 +6748,7 @@ function getParsers() {
 
 // src/lib/tree-sitter/client.ts
 import { resolve as resolve2, isAbsolute } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 import { parse } from "path";
 registerEnvVar({
   name: "OTUI_TREE_SITTER_WORKER_PATH",
@@ -6727,7 +6809,7 @@ class TreeSitterClient extends EventEmitter3 {
       worker_path = this.options.workerPath;
     } else {
       worker_path = new URL("./parser.worker.js", import.meta.url).href;
-      if (!existsSync2(resolve2(import.meta.dirname, "parser.worker.js"))) {
+      if (!existsSync(resolve2(import.meta.dirname, "parser.worker.js"))) {
         worker_path = new URL("./parser.worker.ts", import.meta.url).href;
       }
     }
@@ -8371,15 +8453,15 @@ class TerminalPalette {
   writeFn;
   activeListeners = [];
   activeTimers = [];
-  inTmux;
-  constructor(stdin, stdout, writeFn, isTmux) {
+  inLegacyTmux;
+  constructor(stdin, stdout, writeFn, isLegacyTmux) {
     this.stdin = stdin;
     this.stdout = stdout;
     this.writeFn = writeFn || ((data) => stdout.write(data));
-    this.inTmux = isTmux ?? false;
+    this.inLegacyTmux = isLegacyTmux ?? false;
   }
   writeOsc(osc) {
-    const data = this.inTmux ? wrapForTmux(osc) : osc;
+    const data = this.inLegacyTmux ? wrapForTmux(osc) : osc;
     return this.writeFn(data);
   }
   cleanup() {
@@ -8616,12 +8698,12 @@ class TerminalPalette {
     };
   }
 }
-function createTerminalPalette(stdin, stdout, writeFn, isTmux) {
-  return new TerminalPalette(stdin, stdout, writeFn, isTmux);
+function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux) {
+  return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux);
 }
 // src/zig.ts
-import { dlopen as dlopen2, toArrayBuffer as toArrayBuffer4, JSCallback as JSCallback2, ptr as ptr3 } from "bun:ffi";
-import { existsSync as existsSync3 } from "fs";
+import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr3 } from "bun:ffi";
+import { existsSync as existsSync2 } from "fs";
 import { EventEmitter as EventEmitter5 } from "events";
 
 // src/buffer.ts
@@ -8688,9 +8770,9 @@ class OptimizedBuffer {
     }
     return this._rawBuffers;
   }
-  constructor(lib2, ptr, width, height, options) {
+  constructor(lib, ptr, width, height, options) {
     this.id = options.id || `fb_${OptimizedBuffer.fbIdCounter++}`;
-    this.lib = lib2;
+    this.lib = lib;
     this.respectAlpha = options.respectAlpha || false;
     this._width = width;
     this._height = height;
@@ -8698,10 +8780,10 @@ class OptimizedBuffer {
     this.bufferPtr = ptr;
   }
   static create(width, height, widthMethod, options = {}) {
-    const lib2 = resolveRenderLib();
+    const lib = resolveRenderLib();
     const respectAlpha = options.respectAlpha || false;
     const id = options.id && options.id.trim() !== "" ? options.id : "unnamed buffer";
-    const buffer = lib2.createOptimizedBuffer(width, height, widthMethod, respectAlpha, id);
+    const buffer = lib.createOptimizedBuffer(width, height, widthMethod, respectAlpha, id);
     return buffer;
   }
   get widthMethod() {
@@ -9543,7 +9625,7 @@ var targetLibPath = module.default;
 if (/\$bunfs/.test(targetLibPath)) {
   targetLibPath = targetLibPath.replace("../", "");
 }
-if (!existsSync3(targetLibPath)) {
+if (!existsSync2(targetLibPath)) {
   throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
 }
 registerEnvVar({
@@ -9572,7 +9654,7 @@ registerEnvVar({
 });
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
-  const rawSymbols = dlopen2(resolvedLibPath, {
+  const rawSymbols = dlopen(resolvedLibPath, {
     setLogCallback: {
       args: ["ptr"],
       returns: "void"
@@ -10500,7 +10582,7 @@ class FFIRenderLib {
     if (this.logCallbackWrapper) {
       return;
     }
-    const logCallback = new JSCallback2((level, msgPtr, msgLenBigInt) => {
+    const logCallback = new JSCallback((level, msgPtr, msgLenBigInt) => {
       try {
         const msgLen = typeof msgLenBigInt === "bigint" ? Number(msgLenBigInt) : msgLenBigInt;
         if (msgLen === 0 || !msgPtr) {
@@ -10545,7 +10627,7 @@ class FFIRenderLib {
     if (this.eventCallbackWrapper) {
       return;
     }
-    const eventCallback = new JSCallback2((namePtr, nameLenBigInt, dataPtr, dataLenBigInt) => {
+    const eventCallback = new JSCallback((namePtr, nameLenBigInt, dataPtr, dataLenBigInt) => {
       try {
         const nameLen = typeof nameLenBigInt === "bigint" ? Number(nameLenBigInt) : nameLenBigInt;
         const dataLen = typeof dataLenBigInt === "bigint" ? Number(dataLenBigInt) : dataLenBigInt;
@@ -11558,13 +11640,13 @@ class TextBuffer {
   _textBytes;
   _memId;
   _appendedChunks = [];
-  constructor(lib2, ptr4) {
-    this.lib = lib2;
+  constructor(lib, ptr4) {
+    this.lib = lib;
     this.bufferPtr = ptr4;
   }
   static create(widthMethod) {
-    const lib2 = resolveRenderLib();
-    return lib2.createTextBuffer(widthMethod);
+    const lib = resolveRenderLib();
+    return lib.createTextBuffer(widthMethod);
   }
   guard() {
     if (this._destroyed)
@@ -11742,6 +11824,7 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
+var import_bun_yoga2 = __toESM(require_dist(), 1);
 import { EventEmitter as EventEmitter6 } from "events";
 
 // src/lib/renderable.validations.ts
@@ -11872,7 +11955,7 @@ class BaseRenderable extends EventEmitter6 {
     this._visible = value;
   }
 }
-var yogaConfig = dist_default.Config.create();
+var yogaConfig = import_bun_yoga2.default.Config.create();
 yogaConfig.setUseWebDefaults(false);
 yogaConfig.setPointScaleFactor(1);
 
@@ -11938,8 +12021,8 @@ class Renderable extends BaseRenderable {
     this.buffered = options.buffered ?? false;
     this._live = options.live ?? false;
     this._liveCount = this._live && this._visible ? 1 : 0;
-    this.yogaNode = dist_default.Node.create(yogaConfig);
-    this.yogaNode.setDisplay(this._visible ? Display.Flex : Display.None);
+    this.yogaNode = import_bun_yoga2.default.Node.create(yogaConfig);
+    this.yogaNode.setDisplay(this._visible ? import_bun_yoga2.Display.Flex : import_bun_yoga2.Display.None);
     this.setupYogaProperties(options);
     this.applyEventOptions(options);
     if (this.buffered) {
@@ -11974,7 +12057,7 @@ class Renderable extends BaseRenderable {
       return;
     const wasVisible = this._visible;
     this._visible = value;
-    this.yogaNode.setDisplay(value ? Display.Flex : Display.None);
+    this.yogaNode.setDisplay(value ? import_bun_yoga2.Display.Flex : import_bun_yoga2.Display.None);
     if (this._live) {
       if (!wasVisible && value) {
         this.propagateLiveCount(1);
@@ -12293,40 +12376,40 @@ class Renderable extends BaseRenderable {
   setupMarginAndPadding(options) {
     const node = this.yogaNode;
     if (isMarginType(options.margin)) {
-      node.setMargin(Edge.Top, options.margin);
-      node.setMargin(Edge.Right, options.margin);
-      node.setMargin(Edge.Bottom, options.margin);
-      node.setMargin(Edge.Left, options.margin);
+      node.setMargin(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);
     }
     if (isMarginType(options.marginTop)) {
-      node.setMargin(Edge.Top, options.marginTop);
+      node.setMargin(import_bun_yoga2.Edge.Top, options.marginTop);
     }
     if (isMarginType(options.marginRight)) {
-      node.setMargin(Edge.Right, options.marginRight);
+      node.setMargin(import_bun_yoga2.Edge.Right, options.marginRight);
     }
     if (isMarginType(options.marginBottom)) {
-      node.setMargin(Edge.Bottom, options.marginBottom);
+      node.setMargin(import_bun_yoga2.Edge.Bottom, options.marginBottom);
     }
     if (isMarginType(options.marginLeft)) {
-      node.setMargin(Edge.Left, options.marginLeft);
+      node.setMargin(import_bun_yoga2.Edge.Left, options.marginLeft);
     }
     if (isPaddingType(options.padding)) {
-      node.setPadding(Edge.Top, options.padding);
-      node.setPadding(Edge.Right, options.padding);
-      node.setPadding(Edge.Bottom, options.padding);
-      node.setPadding(Edge.Left, options.padding);
+      node.setPadding(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);
     }
     if (isPaddingType(options.paddingTop)) {
-      node.setPadding(Edge.Top, options.paddingTop);
+      node.setPadding(import_bun_yoga2.Edge.Top, options.paddingTop);
     }
     if (isPaddingType(options.paddingRight)) {
-      node.setPadding(Edge.Right, options.paddingRight);
+      node.setPadding(import_bun_yoga2.Edge.Right, options.paddingRight);
     }
     if (isPaddingType(options.paddingBottom)) {
-      node.setPadding(Edge.Bottom, options.paddingBottom);
+      node.setPadding(import_bun_yoga2.Edge.Bottom, options.paddingBottom);
     }
     if (isPaddingType(options.paddingLeft)) {
-      node.setPadding(Edge.Left, options.paddingLeft);
+      node.setPadding(import_bun_yoga2.Edge.Left, options.paddingLeft);
     }
   }
   set position(positionType) {
@@ -12355,30 +12438,30 @@ class Renderable extends BaseRenderable {
     const { top, right, bottom, left } = position;
     if (isPositionType(top)) {
       if (top === "auto") {
-        node.setPositionAuto(Edge.Top);
+        node.setPositionAuto(import_bun_yoga2.Edge.Top);
       } else {
-        node.setPosition(Edge.Top, top);
+        node.setPosition(import_bun_yoga2.Edge.Top, top);
       }
     }
     if (isPositionType(right)) {
       if (right === "auto") {
-        node.setPositionAuto(Edge.Right);
+        node.setPositionAuto(import_bun_yoga2.Edge.Right);
       } else {
-        node.setPosition(Edge.Right, right);
+        node.setPosition(import_bun_yoga2.Edge.Right, right);
       }
     }
     if (isPositionType(bottom)) {
       if (bottom === "auto") {
-        node.setPositionAuto(Edge.Bottom);
+        node.setPositionAuto(import_bun_yoga2.Edge.Bottom);
       } else {
-        node.setPosition(Edge.Bottom, bottom);
+        node.setPosition(import_bun_yoga2.Edge.Bottom, bottom);
       }
     }
     if (isPositionType(left)) {
       if (left === "auto") {
-        node.setPositionAuto(Edge.Left);
+        node.setPositionAuto(import_bun_yoga2.Edge.Left);
       } else {
-        node.setPosition(Edge.Left, left);
+        node.setPosition(import_bun_yoga2.Edge.Left, left);
       }
     }
     this.requestRender();
@@ -12450,68 +12533,68 @@ class Renderable extends BaseRenderable {
   set margin(margin) {
     if (isMarginType(margin)) {
       const node = this.yogaNode;
-      node.setMargin(Edge.Top, margin);
-      node.setMargin(Edge.Right, margin);
-      node.setMargin(Edge.Bottom, margin);
-      node.setMargin(Edge.Left, margin);
+      node.setMargin(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);
       this.requestRender();
     }
   }
   set marginTop(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(Edge.Top, margin);
+      this.yogaNode.setMargin(import_bun_yoga2.Edge.Top, margin);
       this.requestRender();
     }
   }
   set marginRight(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(Edge.Right, margin);
+      this.yogaNode.setMargin(import_bun_yoga2.Edge.Right, margin);
       this.requestRender();
     }
   }
   set marginBottom(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(Edge.Bottom, margin);
+      this.yogaNode.setMargin(import_bun_yoga2.Edge.Bottom, margin);
       this.requestRender();
     }
   }
   set marginLeft(margin) {
     if (isMarginType(margin)) {
-      this.yogaNode.setMargin(Edge.Left, margin);
+      this.yogaNode.setMargin(import_bun_yoga2.Edge.Left, margin);
       this.requestRender();
     }
   }
   set padding(padding) {
     if (isPaddingType(padding)) {
       const node = this.yogaNode;
-      node.setPadding(Edge.Top, padding);
-      node.setPadding(Edge.Right, padding);
-      node.setPadding(Edge.Bottom, padding);
-      node.setPadding(Edge.Left, padding);
+      node.setPadding(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);
       this.requestRender();
     }
   }
   set paddingTop(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(Edge.Top, padding);
+      this.yogaNode.setPadding(import_bun_yoga2.Edge.Top, padding);
       this.requestRender();
     }
   }
   set paddingRight(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(Edge.Right, padding);
+      this.yogaNode.setPadding(import_bun_yoga2.Edge.Right, padding);
       this.requestRender();
     }
   }
   set paddingBottom(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(Edge.Bottom, padding);
+      this.yogaNode.setPadding(import_bun_yoga2.Edge.Bottom, padding);
       this.requestRender();
     }
   }
   set paddingLeft(padding) {
     if (isPaddingType(padding)) {
-      this.yogaNode.setPadding(Edge.Left, padding);
+      this.yogaNode.setPadding(import_bun_yoga2.Edge.Left, padding);
       this.requestRender();
     }
   }
@@ -12927,10 +13010,10 @@ class RootRenderable extends Renderable {
     if (this.yogaNode) {
       this.yogaNode.free();
     }
-    this.yogaNode = dist_default.Node.create(yogaConfig);
+    this.yogaNode = import_bun_yoga2.default.Node.create(yogaConfig);
     this.yogaNode.setWidth(ctx.width);
     this.yogaNode.setHeight(ctx.height);
-    this.yogaNode.setFlexDirection(FlexDirection.Column);
+    this.yogaNode.setFlexDirection(import_bun_yoga2.FlexDirection.Column);
     this.calculateLayout();
   }
   render(buffer, deltaTime) {
@@ -12971,7 +13054,7 @@ class RootRenderable extends Renderable {
     }
   }
   calculateLayout() {
-    this.yogaNode.calculateLayout(this.width, this.height, Direction.LTR);
+    this.yogaNode.calculateLayout(this.width, this.height, import_bun_yoga2.Direction.LTR);
     this.emit("layout-changed" /* LAYOUT_CHANGED */);
   }
   resize(width, height) {
@@ -14237,13 +14320,13 @@ Captured output:
   get controlState() {
     return this._controlState;
   }
-  constructor(lib2, rendererPtr, stdin, stdout, width, height, config = {}) {
+  constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
     super();
     rendererTracker.addRenderer(this);
     this.stdin = stdin;
     this.stdout = stdout;
     this.realStdoutWrite = stdout.write;
-    this.lib = lib2;
+    this.lib = lib;
     this._terminalWidth = stdout.columns;
     this._terminalHeight = stdout.rows;
     this.width = width;
@@ -14254,7 +14337,7 @@ Captured output:
       capture.on("write", this.captureCallback);
       this.renderOffset = height - this._splitHeight;
       this.height = this._splitHeight;
-      lib2.setRenderOffset(rendererPtr, this.renderOffset);
+      lib.setRenderOffset(rendererPtr, this.renderOffset);
     }
     this.rendererPtr = rendererPtr;
     this.exitOnCtrlC = config.exitOnCtrlC === undefined ? true : config.exitOnCtrlC;
@@ -14848,19 +14931,19 @@ Captured output:
     this.lib.dumpStdoutBuffer(this.rendererPtr, timestamp);
   }
   static setCursorPosition(renderer, x, y, visible = true) {
-    const lib2 = resolveRenderLib();
-    lib2.setCursorPosition(renderer.rendererPtr, x, y, visible);
+    const lib = resolveRenderLib();
+    lib.setCursorPosition(renderer.rendererPtr, x, y, visible);
   }
   static setCursorStyle(renderer, style, blinking = false, color) {
-    const lib2 = resolveRenderLib();
-    lib2.setCursorStyle(renderer.rendererPtr, style, blinking);
+    const lib = resolveRenderLib();
+    lib.setCursorStyle(renderer.rendererPtr, style, blinking);
     if (color) {
-      lib2.setCursorColor(renderer.rendererPtr, color);
+      lib.setCursorColor(renderer.rendererPtr, color);
     }
   }
   static setCursorColor(renderer, color) {
-    const lib2 = resolveRenderLib();
-    lib2.setCursorColor(renderer.rendererPtr, color);
+    const lib = resolveRenderLib();
+    lib.setCursorColor(renderer.rendererPtr, color);
   }
   setCursorPosition(x, y, visible = true) {
     this.lib.setCursorPosition(this.rendererPtr, x, y, visible);
@@ -15079,6 +15162,10 @@ Captured output:
       } catch (error) {
         console.error("Error in frame callback:", error);
       }
+      if (this._isDestroyed) {
+        this.rendering = false;
+        return;
+      }
     }
     const end = performance.now();
     this.renderStats.frameCallbackTime = end - start;
@@ -15281,8 +15368,8 @@ Captured output:
       return this._paletteDetectionPromise;
     }
     if (!this._paletteDetector) {
-      const isTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux");
-      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isTmux);
+      const isLegacyTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux") && this.capabilities?.terminal?.version?.localeCompare("3.6") < 0;
+      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isLegacyTmux);
     }
     this._paletteDetectionPromise = this._paletteDetector.detect(options).then((result) => {
       this._cachedPalette = result;
@@ -15293,7 +15380,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_dist, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __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 };
 
-//# debugId=3153067811E5610D64756E2164756E21
-//# sourceMappingURL=index-533e9nca.js.map
+//# debugId=4463EA6925DD17AC64756E2164756E21
+//# sourceMappingURL=index-r6acnfwr.js.map