@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-RFVRPYR2.mjs

@@ -0,0 +1,856 @@
+// src/interactives/game-ui/game-theme.ts
+var DEFAULT_THEME = {
+  surface: "#141821e6",
+  raised: "#222a38ff",
+  border: "#ffffff1f",
+  accent: "#f5b833ff",
+  on_accent: "#1a1205ff",
+  text: "#f4f6faff",
+  muted: "#a6aebcff",
+  track: "#ffffff26",
+  danger: "#ef4b4bff",
+  success: "#3ccf7aff",
+  gold: "#ffd447ff",
+  radius: 12,
+  padding: 12,
+  gap: 8,
+  small: 12,
+  body: 15,
+  title: 19,
+  font: 0,
+  panel: null,
+  press_scale: 0.94,
+  motion: 0.16
+};
+function theme(overrides = {}) {
+  return { ...DEFAULT_THEME, ...overrides };
+}
+
+// src/interactives/game-ui/wire.ts
+var UI_MAGIC = 826889539, UI_VERSION = 1, UI_HEADER_BYTES = 12, UI_RECORD_HEADER_WORDS = 2, UI_EVENT_BYTES = 32, NO_NODE = 4294967295;
+var UiOp = {
+  create: 1,
+  destroy: 2,
+  insert: 3,
+  remove: 4,
+  root: 5,
+  world_root: 6,
+  unroot: 7,
+  prop: 8,
+  text: 9,
+  number: 10,
+  string: 11,
+  text_ref: 12,
+  label: 13,
+  value: 14,
+  placeholder: 15,
+  image: 16,
+  path: 17,
+  transition: 18,
+  scroll_to: 19,
+  focus: 20,
+  blur: 21,
+  font: 22,
+  anchor: 23,
+  occluded: 24,
+  style: 25,
+  style_clear: 26,
+  tokens: 27,
+  slots: 28,
+  exclusions: 29,
+  text_options: 30,
+  vector_load: 31,
+  vector_unload: 32,
+  vector: 33,
+  vector_detach: 34,
+  vector_play: 35,
+  vector_input: 36,
+  vector_input_name: 37,
+  vector_data: 38,
+  vector_seek: 39
+}, UiVectorPlay = { machine: 0, animation: 1, stop: 2 }, UiVectorData = { number: 0, bool: 1, color: 2, id: 3, fire: 4 };
+function padWords(bytes) {
+  return Math.floor((bytes + 4 - 1) / 4);
+}
+var UiTextOption = { dictionaries: 1, data: 2 }, UiExclusionShape = { rect: 0, ellipse: 1, polygon: 2 }, UI_EXCLUSION_HEADER_WORDS = 7, UI_MAX_EXCLUSIONS = 8, EXCLUSION_POINTS_SHIFT = 8, MAX_EXCLUSION_POINTS = 65535, UI_TOKENS_REPLACE = 1, UI_SLOT_REFERENCE = 2147483648, UI_STYLE_REFERENCED = 1 << 24, UI_STYLE_SAFE_EDGES = 1 << 25, STYLE_COUNT_SHIFT = 16, STYLE_COUNT_MASK = 255, PAIR = 2, UiKind = { box: 0, text: 1, image: 2, shape: 3, scroll: 4, input: 5, vector: 6 }, UiProp = {
+  width: 0,
+  height: 1,
+  min_width: 2,
+  min_height: 3,
+  max_width: 4,
+  max_height: 5,
+  basis: 6,
+  padding: 7,
+  margin: 8,
+  border_width: 9,
+  inset_top: 10,
+  inset_right: 11,
+  inset_bottom: 12,
+  inset_left: 13,
+  gap: 14,
+  grow: 15,
+  shrink: 16,
+  aspect: 17,
+  direction: 18,
+  justify: 19,
+  align_items: 20,
+  align_self: 21,
+  align_content: 22,
+  position: 23,
+  wrap: 24,
+  display_none: 25,
+  fill: 32,
+  border_color: 33,
+  radii: 34,
+  opacity: 35,
+  translate: 36,
+  scale: 37,
+  rotate: 38,
+  origin: 39,
+  z_index: 40,
+  hidden: 41,
+  clip: 42,
+  pointer_events_none: 43,
+  flags: 44,
+  shadow: 45,
+  gradient: 46,
+  disabled: 47,
+  focusable: 48,
+  font_family: 64,
+  font_weight: 65,
+  font_size: 66,
+  line_height: 67,
+  letter_spacing: 68,
+  text_align: 69,
+  text_color: 70,
+  text_wrap: 71,
+  vertical_align: 72,
+  placeholder_color: 73,
+  text_wrap_style: 74,
+  image_tint: 80,
+  image_uv: 81,
+  nine_slice: 82,
+  nine_slice_uv: 83,
+  shape_kind: 96,
+  stroke_color: 97,
+  stroke_width: 98,
+  scroll_axes: 112,
+  role: 128,
+  traits: 129,
+  actions: 130
+}, UiUnit = { auto: 0, points: 1, percent: 2 }, UiFlag = {
+  tap: 8,
+  press: 16,
+  drag: 32,
+  long_press: 64,
+  layer: 128,
+  secure: 8192
+}, UiNumberFormat = { integer: 0, fixed: 1, timer: 2, timer_hours: 3, compact: 4, percent: 5 }, UiEasing = {
+  linear: 0,
+  ease: 1,
+  ease_in: 2,
+  ease_out: 3,
+  ease_in_out: 4,
+  back_out: 5,
+  bezier: 6,
+  spring: 7
+}, UiTransition = {
+  opacity: 1,
+  translate_x: 2,
+  translate_y: 4,
+  scale_x: 8,
+  scale_y: 16,
+  rotate: 32,
+  fill: 64,
+  text_color: 128
+}, UiAnchor = {
+  top_left: 0,
+  top: 1,
+  top_right: 2,
+  left: 3,
+  center: 4,
+  right: 5,
+  bottom_left: 6,
+  bottom: 7,
+  bottom_right: 8,
+  fill: 9
+}, UiRole = {
+  none: 0,
+  group: 1,
+  text: 2,
+  button: 3,
+  image: 4,
+  header: 5,
+  link: 6,
+  adjustable: 7,
+  tab: 8,
+  tab_list: 9,
+  progress: 10,
+  text_field: 11,
+  scroll_view: 12,
+  alert: 13
+}, UiTrait = { selected: 1, disabled: 2, hidden: 4, live: 8, modal: 16 }, UiAction = { activate: 1, increment: 2, decrement: 4, dismiss: 8, scroll: 16 }, UiEventKind = {
+  press: 1,
+  release: 2,
+  tap: 3,
+  long_press: 4,
+  drag_start: 5,
+  drag_move: 6,
+  drag_end: 7,
+  scroll: 8,
+  focus: 9,
+  action: 10,
+  passthrough: 11,
+  change: 12,
+  blur: 13,
+  vector: 14
+}, UiFocusFlag = { secure: 1, numeric: 2 }, UI_EVENT_KIND_OFFSET = 0, UI_EVENT_PHASE_OFFSET = 1, UI_EVENT_POINTER_OFFSET = 2, UI_EVENT_NODE_OFFSET = 4, UI_EVENT_X_OFFSET = 8, UI_EVENT_Y_OFFSET = 12, UI_EVENT_DX_OFFSET = 16, UI_EVENT_DY_OFFSET = 20, UI_EVENT_VALUE_OFFSET = 24, UI_EVENT_TIME_OFFSET = 28, ASCII_LIMIT = 128, TWO_BYTE_LIMIT = 2048, SURROGATE_HIGH = 55296, SURROGATE_LOW = 56320, SURROGATE_END = 57344, SURROGATE_BITS = 10, SUPPLEMENTARY_BASE = 65536, REPLACEMENT_CHARACTER = 65533, CONTINUATION = 128, CONTINUATION_BITS = 63, LEAD_TWO = 192, LEAD_THREE = 224, LEAD_FOUR = 240, LITTLE_ENDIAN = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
+function encodeUtf8(text, buffer, at, length2 = text.length) {
+  let out = at;
+  for (let i = 0; i < length2; i++) {
+    let point = text.charCodeAt(i);
+    if (point >= (55296) && point < (57344)) {
+      let next = i + 1 < length2 ? text.charCodeAt(i + 1) : 0;
+      point < (56320) && next >= (56320) && next < (57344) ? (point = (65536) + (point - (55296) << (10)) + (next - (56320)), i++) : point = (65533);
+    }
+    point < (128) ? buffer[out++] = point : point < (2048) ? (buffer[out++] = (192) | point >> 6, buffer[out++] = (128) | point & (63)) : point < (65536) ? (buffer[out++] = (224) | point >> 12, buffer[out++] = (128) | point >> 6 & (63), buffer[out++] = (128) | point & (63)) : (buffer[out++] = (240) | point >> 18, buffer[out++] = (128) | point >> 12 & (63), buffer[out++] = (128) | point >> 6 & (63), buffer[out++] = (128) | point & (63));
+  }
+  return out - at;
+}
+var HIDE_OCCLUDED = 1, PatchWriter = class {
+  constructor(capacity = 16384, reserve = 0) {
+    this.count = 0;
+    this.reserve = reserve, this.buffer = new Uint8Array(capacity), this.view = new DataView(this.buffer.buffer), this.words = new Uint32Array(this.buffer.buffer, 0, capacity >> 2), this.floats = new Float32Array(this.buffer.buffer, 0, capacity >> 2), this.cursor = 0, this.reset();
+  }
+  get bytes() {
+    return this.buffer;
+  }
+  get length() {
+    return this.cursor;
+  }
+  get records() {
+    return this.count;
+  }
+  get empty() {
+    return this.count === 0;
+  }
+  reset() {
+    this.count = 0;
+    let start = this.reserve;
+    this.view.setUint32(start, 826889539, true), this.view.setUint16(start + 4, 1, true), this.view.setUint16(start + 4 + 2, 0, true), this.view.setUint32(start + 8, 0, true), this.cursor = start + 12;
+  }
+  finish() {
+    return this.view.setUint32(this.reserve + 8, this.count, true), this.cursor;
+  }
+  ensure(bytes) {
+    let needed = this.cursor + bytes;
+    if (needed <= this.buffer.length) return;
+    let size = this.buffer.length * 2;
+    for (; size < needed; ) size *= 2;
+    let next = new Uint8Array(size);
+    next.set(this.buffer.subarray(0, this.cursor)), this.buffer = next, this.view = new DataView(next.buffer), this.words = new Uint32Array(next.buffer, 0, size >> 2), this.floats = new Float32Array(next.buffer, 0, size >> 2);
+  }
+  record(op, words, aux, node) {
+    this.ensure(words * 4);
+    let at = this.cursor;
+    this.buffer[at] = op, this.buffer[at + 1] = words, this.view.setUint16(at + 2, aux, true), this.view.setUint32(at + 4, node >>> 0, true), this.cursor = at + 8, this.count++;
+  }
+  u32(value) {
+    let at = this.cursor;
+    LITTLE_ENDIAN && (at & 3) === 0 ? this.words[at >> 2] = value : this.view.setUint32(at, value >>> 0, true), this.cursor = at + 4;
+  }
+  f32(value) {
+    let at = this.cursor;
+    LITTLE_ENDIAN && (at & 3) === 0 ? this.floats[at >> 2] = value : this.view.setFloat32(at, value, true), this.cursor = at + 4;
+  }
+  simple(op, node, aux = 0) {
+    this.record(op, 2, aux, node);
+  }
+  create(node, kind) {
+    this.simple(UiOp.create, node, kind);
+  }
+  destroy(node) {
+    this.simple(UiOp.destroy, node);
+  }
+  insert(node, parent, before = 4294967295) {
+    this.record(UiOp.insert, 4, 0, node), this.u32(parent), this.u32(before);
+  }
+  remove(node) {
+    this.simple(UiOp.remove, node);
+  }
+  root(node, anchor, safe_area, x, y, z) {
+    this.record(UiOp.root, 7, 0, node), this.u32(anchor), this.u32(safe_area ? 1 : 0), this.f32(x), this.f32(y), this.u32(z | 0);
+  }
+  worldRoot(node, root) {
+    this.record(UiOp.world_root, 15, 0, node), this.f32(root.position[0]), this.f32(root.position[1]), this.f32(root.position[2]), this.f32(root.pivot[0]), this.f32(root.pivot[1]), this.f32(root.offset[0]), this.f32(root.offset[1]), this.f32(root.reference_distance), this.f32(root.min_scale), this.f32(root.max_scale), this.u32(root.hide_when_occluded ? (1) : 0), this.f32(root.occluded_opacity), this.u32(root.z | 0);
+  }
+  unroot(node) {
+    this.simple(UiOp.unroot, node);
+  }
+  propWord(node, prop, word, unit = 0) {
+    this.record(UiOp.prop, 3, prop | unit << 8, node), this.u32(word);
+  }
+  propFloat(node, prop, value, unit = 0) {
+    this.record(UiOp.prop, 3, prop | unit << 8, node), this.f32(value);
+  }
+  propWordAt(node, prop, values, index, unit = 0) {
+    this.record(UiOp.prop, 3, prop | unit << 8, node), this.u32(values[index]);
+  }
+  propFloatAt(node, prop, values, index, unit = 0) {
+    this.record(UiOp.prop, 3, prop | unit << 8, node);
+    let at = this.cursor;
+    LITTLE_ENDIAN && (at & 3) === 0 ? this.floats[at >> 2] = values[index] : this.view.setFloat32(at, values[index], true), this.cursor = at + 4;
+  }
+  propFloats(node, prop, values) {
+    let count = values.length;
+    this.open(UiOp.prop, prop, node, count);
+    let at = this.cursor;
+    if (LITTLE_ENDIAN && (at & 3) === 0) {
+      let floats = this.floats, w = at >> 2;
+      for (let i = 0; i < count; i++) floats[w + i] = values[i];
+    } else
+      for (let i = 0; i < count; i++) this.view.setFloat32(at + i * 4, values[i], true);
+    this.cursor = at + count * 4;
+  }
+  propF32(node, prop, values) {
+    let count = values.length;
+    this.open(UiOp.prop, prop, node, count);
+    let at = this.cursor;
+    if (LITTLE_ENDIAN && (at & 3) === 0) {
+      let floats = this.floats, w = at >> 2;
+      for (let i = 0; i < count; i++) floats[w + i] = values[i];
+    } else
+      for (let i = 0; i < count; i++) this.view.setFloat32(at + i * 4, values[i], true);
+    this.cursor = at + count * 4;
+  }
+  propWords(node, prop, values) {
+    this.open(UiOp.prop, prop, node, values.length);
+    for (let i = 0; i < values.length; i++) this.u32(values[i]);
+  }
+  propMixed(node, prop, words, floats) {
+    this.open(UiOp.prop, prop, node, words.length + floats.length);
+    for (let i = 0; i < words.length; i++) this.u32(words[i]);
+    let count = floats.length, at = this.cursor;
+    if (LITTLE_ENDIAN && (at & 3) === 0) {
+      let out = this.floats, w = at >> 2;
+      for (let i = 0; i < count; i++) out[w + i] = floats[i];
+    } else
+      for (let i = 0; i < count; i++) this.view.setFloat32(at + i * 4, floats[i], true);
+    this.cursor = at + count * 4;
+  }
+  textual(op, node, text, length2 = text.length) {
+    let worst = length2 * 3, headerBytes = 16;
+    this.ensure(headerBytes + worst + 4);
+    let start = this.cursor, payload = start + headerBytes, buffer = this.buffer, written = length2;
+    for (let i = 0; i < length2; i++) {
+      let unit = text.charCodeAt(i);
+      if (unit >= (128)) {
+        written = encodeUtf8(text, buffer, payload, length2);
+        break;
+      }
+      buffer[payload + i] = unit;
+    }
+    let padded = written + 4 - 1 & -4;
+    this.buffer.fill(0, payload + written, payload + padded);
+    let compactWords = 3 + padded / 4;
+    if (compactWords <= 255) {
+      this.buffer.copyWithin(start + 12, payload, payload + padded), this.record(op, compactWords, 0, node), this.u32(written), this.cursor += padded;
+      return;
+    }
+    this.record(op, 0, 0, node), this.u32(compactWords + 1), this.u32(written), this.cursor += padded;
+  }
+  text(node, text) {
+    this.textual(UiOp.text, node, text);
+  }
+  textPrefix(node, text, length2) {
+    this.textual(UiOp.text, node, text, length2 < 0 ? 0 : length2 > text.length ? text.length : length2);
+  }
+  string(id, text) {
+    this.textual(UiOp.string, id, text);
+  }
+  label(node, text) {
+    this.textual(UiOp.label, node, text);
+  }
+  value(node, text) {
+    this.textual(UiOp.value, node, text);
+  }
+  placeholder(node, text) {
+    this.textual(UiOp.placeholder, node, text);
+  }
+  textRef(node, id) {
+    this.record(UiOp.text_ref, 3, 0, node), this.u32(id);
+  }
+  number(node, value, format, decimals, separator) {
+    this.record(UiOp.number, 5, 0, node), this.view.setFloat64(this.cursor, value, true), this.cursor += 8, this.buffer[this.cursor] = format, this.buffer[this.cursor + 1] = decimals, this.buffer[this.cursor + 2] = separator, this.buffer[this.cursor + 3] = 0, this.cursor += 4;
+  }
+  image(node, asset, width, height) {
+    this.record(UiOp.image, 5, 0, node), this.u32(asset), this.f32(width), this.f32(height);
+  }
+  path(node, points) {
+    let words = points.length - points.length % 2;
+    this.ensure((3 + words) * 4), 2 + words > 255 ? (this.record(UiOp.path, 0, 0, node), this.u32(3 + words)) : this.record(UiOp.path, 2 + words, 0, node);
+    let at = this.cursor;
+    if (LITTLE_ENDIAN && (at & 3) === 0) {
+      let floats = this.floats, w = at >> 2;
+      for (let i = 0; i < words; i++) floats[w + i] = points[i];
+    } else
+      for (let i = 0; i < words; i++) this.view.setFloat32(at + i * 4, points[i], true);
+    this.cursor = at + words * 4;
+  }
+  transition(node, mask, duration, easing, params) {
+    this.record(UiOp.transition, 8, mask, node), this.f32(duration), this.u32(easing);
+    for (let i = 0; i < 4; i++) this.f32(params === null ? 0 : params[i] ?? 0);
+  }
+  scrollTo(node, x, y) {
+    this.record(UiOp.scroll_to, 4, 0, node), this.f32(x), this.f32(y);
+  }
+  focus(node) {
+    this.simple(UiOp.focus, node);
+  }
+  blur(node) {
+    this.simple(UiOp.blur, node);
+  }
+  font(family, weight, font) {
+    this.record(UiOp.font, 5, 0, 0), this.u32(family), this.u32(weight), this.u32(font);
+  }
+  textOptions(flags) {
+    this.record(UiOp.text_options, 3, 0, 0), this.u32(flags);
+  }
+  textDictionaries(bytes) {
+    if (bytes.byteLength % 4 !== 0) throw new Error("break dictionaries must be a whole number of words");
+    this.open(UiOp.text_options, 0, 0, 1 + bytes.byteLength / 4), this.u32(UiTextOption.data), this.buffer.set(bytes, this.cursor), this.cursor += bytes.byteLength;
+  }
+  vectorLoad(asset, bytes) {
+    this.open(UiOp.vector_load, 0, asset, 1 + padWords(bytes.byteLength)), this.sizedBytes(bytes);
+  }
+  vectorUnload(asset) {
+    this.record(UiOp.vector_unload, 2, 0, asset);
+  }
+  vector(node, asset, artboard) {
+    this.record(UiOp.vector, 4, 0, node), this.u32(asset), this.u32(artboard);
+  }
+  vectorDetach(node) {
+    this.record(UiOp.vector_detach, 2, 0, node);
+  }
+  vectorPlay(node, kind, index) {
+    this.record(UiOp.vector_play, 4, 0, node), this.u32(kind), this.u32(index);
+  }
+  vectorSeek(node, kind, index, seconds) {
+    this.record(UiOp.vector_seek, 5, 0, node), this.u32(kind), this.u32(index), this.f32(seconds);
+  }
+  vectorInput(node, input, value) {
+    this.record(UiOp.vector_input, 4, 0, node), this.u32(input), this.f32(value);
+  }
+  vectorInputName(node, name, value) {
+    this.open(UiOp.vector_input_name, 0, node, 2 + padWords(name.byteLength)), this.f32(value), this.sizedBytes(name);
+  }
+  vectorData(node, kind, path, value, bits) {
+    this.open(UiOp.vector_data, kind, node, 3 + padWords(path.byteLength)), this.f32(value), this.u32(bits), this.sizedBytes(path);
+  }
+  sizedBytes(bytes) {
+    let padded = padWords(bytes.byteLength) * 4;
+    this.u32(bytes.byteLength), this.buffer.set(bytes, this.cursor), this.buffer.fill(0, this.cursor + bytes.byteLength, this.cursor + padded), this.cursor += padded;
+  }
+  anchor(node, x, y, z) {
+    this.record(UiOp.anchor, 5, 0, node), this.f32(x), this.f32(y), this.f32(z);
+  }
+  anchorFrom(node, values, offset) {
+    this.record(UiOp.anchor, 5, 0, node);
+    let at = this.cursor;
+    if (LITTLE_ENDIAN && (at & 3) === 0) {
+      let floats = this.floats, w = at >> 2;
+      floats[w] = values[offset], floats[w + 1] = values[offset + 1], floats[w + 2] = values[offset + 2];
+    } else {
+      let view = this.view;
+      view.setFloat32(at, values[offset], true), view.setFloat32(at + 4, values[offset + 1], true), view.setFloat32(at + 8, values[offset + 2], true);
+    }
+    this.cursor = at + 12;
+  }
+  occluded(node, occluded) {
+    this.record(UiOp.occluded, 3, 0, node), this.u32(occluded ? 1 : 0);
+  }
+  open(op, aux, node, payload) {
+    this.ensure((3 + payload) * 4), 2 + payload > 255 ? (this.record(op, 0, aux, node), this.u32(3 + payload)) : this.record(op, 2 + payload, aux, node);
+  }
+  style(node, mask, words, slotBase = 0) {
+    let count = words.length;
+    this.open(UiOp.style, mask, node, count);
+    let at = 0;
+    for (; at < count; ) {
+      let head = words[at++];
+      this.u32(head);
+      let values = head >>> (16) & (255), refs = 0;
+      (head & UI_STYLE_REFERENCED) !== 0 && (refs = words[at++], this.u32(refs)), (head & UI_STYLE_SAFE_EDGES) !== 0 && this.u32(words[at++]);
+      for (let i = 0; i < values; i++) {
+        let word = words[at++], slot = (refs & 1 << i) !== 0 && (word & (2147483648)) !== 0;
+        this.u32(slot ? ((2147483648) | (word & ~(2147483648)) + slotBase) >>> 0 : word);
+      }
+    }
+  }
+  styleClear(node) {
+    this.simple(UiOp.style_clear, node);
+  }
+  exclusions(node, entries, count = entries.length) {
+    let payload = 0;
+    for (let i = 0; i < count; i++) {
+      let points = entries[i].points, words = points === null ? 0 : points.length - points.length % 2;
+      if (words / 2 > (65535)) throw new Error(`an exclusion polygon has ${words / 2} points; the limit is ${(65535)}`);
+      payload += (7) + words;
+    }
+    this.open(UiOp.exclusions, 0, node, payload);
+    for (let i = 0; i < count; i++) {
+      let entry = entries[i], points = entry.points, pairs = points === null ? 0 : (points.length - points.length % 2) / 2;
+      if (this.u32((entry.shape | pairs << (8)) >>> 0), this.u32(entry.sibling), this.f32(entry.margin), this.f32(entry.x), this.f32(entry.y), this.f32(entry.width), this.f32(entry.height), points !== null) for (let k = 0; k < pairs * 2; k++) this.f32(points[k]);
+    }
+  }
+  tokens(replace, count) {
+    this.open(UiOp.tokens, replace ? (1) : 0, 0, count * (2));
+  }
+  pair(first, second) {
+    this.u32(first), this.u32(second);
+  }
+  slot(index, bits) {
+    this.record(UiOp.slots, 2 + (2), 0, 0), this.u32(index), this.u32(bits);
+  }
+  slotAt(index, values, at) {
+    this.record(UiOp.slots, 2 + (2), 0, 0), this.u32(index);
+    let cursor = this.cursor;
+    LITTLE_ENDIAN && (cursor & 3) === 0 ? this.words[cursor >> 2] = values[at] : this.view.setUint32(cursor, values[at], true), this.cursor = cursor + 4;
+  }
+};
+function readEvent(view, offset, out) {
+  out.kind = view.getUint8(offset + (0)), out.phase = view.getUint8(offset + (1)), out.pointer = view.getUint16(offset + (2), true), out.node = view.getUint32(offset + (4), true), out.x = view.getFloat32(offset + (8), true), out.y = view.getFloat32(offset + (12), true), out.dx = view.getFloat32(offset + (16), true), out.dy = view.getFloat32(offset + (20), true), out.value = view.getFloat32(offset + (24), true), out.time_ms = view.getUint32(offset + (28), true);
+}
+function textEventPadding(textBytes) {
+  return Math.ceil(textBytes / 32) * 32;
+}
+function textEventCapacity(text) {
+  return 32 + textEventPadding(text.length * 3);
+}
+function writeTextEvent(target, offset, kind, node, text, time_ms, composition = null) {
+  let view = new DataView(target.buffer, target.byteOffset, target.byteLength), payload = offset + 32, written = encodeUtf8(text, target, payload), padded = textEventPadding(written);
+  return target.fill(0, offset, offset + 32), target.fill(0, payload + written, payload + padded), view.setUint8(offset + (0), kind), view.setUint32(offset + (4), node >>> 0, true), composition !== null && (view.setFloat32(offset + (8), composition.start, true), view.setFloat32(offset + (12), composition.end, true)), view.setFloat32(offset + (24), written, true), view.setUint32(offset + (28), time_ms >>> 0, true), 32 + padded;
+}
+function textComposition(event) {
+  return event.kind !== UiEventKind.change || event.y <= event.x ? null : { start: event.x, end: event.y };
+}
+function codePointOffset(text, utf16) {
+  let points = 0, limit = Math.min(utf16, text.length);
+  for (let i = 0; i < limit; i++) {
+    let unit = text.charCodeAt(i);
+    if (unit >= (55296) && unit < (56320) && i + 1 < limit) {
+      let next = text.charCodeAt(i + 1);
+      next >= (56320) && next < (57344) && i++;
+    }
+    points++;
+  }
+  return points;
+}
+function eventStride(kind, view, offset) {
+  return kind !== UiEventKind.change ? 32 : 32 + textEventPadding(view.getFloat32(offset + (24), true));
+}
+
+// src/interactives/game-ui/style.ts
+var UiStyleError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "UiStyleError";
+  }
+}, HEX = 16, SHORT_HEX = 3, SHORT_HEX_ALPHA = 4, RGB_HEX = 6, RGBA_HEX = 8, OPAQUE = 255, BYTE_SHIFT = 8, NIBBLE = 17, MAX_STOPS = 4, SHADOW_WORDS = 1, SHADOW_FLOATS = 4, GRADIENT_FLOATS = 8, PERCENT_SUFFIX = "%", PREFIX = "#", SCRATCH = 16, colorCache = /* @__PURE__ */ new Map();
+function parseColor(color) {
+  if (typeof color == "number") return color >>> 0;
+  let cached = colorCache.get(color);
+  if (cached !== void 0) return cached;
+  let body = color.startsWith(PREFIX) ? color.slice(1) : color, value;
+  if (body.length === (3) || body.length === (4)) {
+    value = 0;
+    for (let i = 0; i < body.length; i++) value = value << (8) | Number.parseInt(body[i], (16)) * (17);
+    body.length === (3) && (value = value << (8) | (255));
+  } else if (body.length === (6))
+    value = Number.parseInt(body, (16)) << (8) | (255);
+  else if (body.length === (8))
+    value = Number.parseInt(body, (16));
+  else
+    throw new UiStyleError(`color ${color} must be #rgb, #rgba, #rrggbb or #rrggbbaa`);
+  if (Number.isNaN(value)) throw new UiStyleError(`color ${color} is not hexadecimal`);
+  return value >>>= 0, colorCache.set(color, value), value;
+}
+var DIRECTION = { row: 0, column: 1, "row-reverse": 2, "column-reverse": 3 }, JUSTIFY = { start: 0, end: 1, center: 2, "space-between": 3, "space-around": 4, "space-evenly": 5 }, ALIGN = { auto: 0, start: 1, end: 2, center: 3, stretch: 4 }, TEXT_ALIGN = { start: 0, end: 1, left: 2, center: 3, right: 4 }, VERTICAL = { top: 0, center: 1, bottom: 2 }, TEXT_WRAP_STYLE = { greedy: 0, balance: 1, pretty: 2 }, SHAPE = { rect: 0, ellipse: 1, path: 2 }, AXES = { none: 0, x: 1, y: 2, both: 3 }, GRADIENT_KIND = { linear: 0, radial: 1 }, StyleCache = class {
+  constructor() {
+    this.sent = /* @__PURE__ */ new Map();
+  }
+  changed(prop, values, count) {
+    let previous = this.sent.get(prop);
+    if (previous !== void 0 && previous.length === count) {
+      let same = true;
+      for (let i = 0; i < count; i++)
+        if (!Object.is(previous[i], values[i])) {
+          same = false;
+          break;
+        }
+      if (same) return false;
+    }
+    (previous === void 0 || previous.length !== count) && (previous = new Float64Array(count), this.sent.set(prop, previous));
+    for (let i = 0; i < count; i++) previous[i] = values[i];
+    return true;
+  }
+  forget(prop) {
+    this.sent.delete(prop);
+  }
+}, scratch = new Float64Array((16));
+function length(value) {
+  if (typeof value == "number") return [value, UiUnit.points];
+  if (value === "auto") return [0, UiUnit.auto];
+  if (value.endsWith(PERCENT_SUFFIX)) return [Number.parseFloat(value), UiUnit.percent];
+  throw new UiStyleError(`length ${value} must be a number, a percentage or auto`);
+}
+function edges(value) {
+  return typeof value == "number" ? [value, value, value, value] : value;
+}
+function emitLength(writer, cache, node, prop, value) {
+  let [amount, unit] = length(value);
+  scratch[0] = amount, scratch[1] = unit, cache.changed(prop, scratch, 2) && writer.propFloat(node, prop, amount, unit);
+}
+function emitFloat(writer, cache, node, prop, value) {
+  scratch[0] = value, cache.changed(prop, scratch, 1) && writer.propFloat(node, prop, value);
+}
+function emitWord(writer, cache, node, prop, value) {
+  scratch[0] = value >>> 0, cache.changed(prop, scratch, 1) && writer.propWord(node, prop, value);
+}
+function emitFloats(writer, cache, node, prop, values) {
+  for (let i = 0; i < values.length; i++) scratch[i] = values[i];
+  cache.changed(prop, scratch, values.length) && writer.propFloats(node, prop, values);
+}
+function emitWords(writer, cache, node, prop, values) {
+  for (let i = 0; i < values.length; i++) scratch[i] = values[i] >>> 0;
+  cache.changed(prop, scratch, values.length) && writer.propWords(node, prop, values);
+}
+function lookup(table, key, name) {
+  let value = table[key];
+  if (value === void 0) throw new UiStyleError(`${name} ${key} is not supported`);
+  return value;
+}
+function shadow(writer, cache, node, value) {
+  if (value === null) {
+    scratch.fill(0, 0, (1) + (4)), cache.changed(UiProp.shadow, scratch, (1) + (4)) && writer.propMixed(node, UiProp.shadow, [0], [0, 0, 0, 0]);
+    return;
+  }
+  let color = parseColor(value.color), floats = [value.x ?? 0, value.y ?? 0, value.blur ?? 0, value.spread ?? 0];
+  scratch[0] = color;
+  for (let i = 0; i < (4); i++) scratch[1 + i] = floats[i];
+  cache.changed(UiProp.shadow, scratch, (1) + (4)) && writer.propMixed(node, UiProp.shadow, [color], floats);
+}
+function gradient(writer, cache, node, value) {
+  if (value === null) {
+    cache.forget(UiProp.gradient), writer.propWords(node, UiProp.gradient, []);
+    return;
+  }
+  if (value.stops.length === 0 || value.stops.length > (4))
+    throw new UiStyleError(`a gradient needs between 1 and ${(4)} stops`);
+  let kind = lookup(GRADIENT_KIND, value.kind ?? "linear", "gradient"), colors = [0, 0, 0, 0], floats = Array.from({ length: (8) }, () => 0);
+  for (let i = 0; i < (4); i++) {
+    let stop = value.stops[Math.min(i, value.stops.length - 1)];
+    colors[i] = parseColor(stop[0]), floats[i] = stop[1];
+  }
+  let from = value.from ?? [0, 0], to = value.to ?? [0, 1];
+  floats[(4)] = from[0], floats[(4) + 1] = from[1], floats[(4) + 2] = to[0], floats[(4) + 3] = to[1], scratch[0] = kind;
+  for (let i = 0; i < (4); i++) scratch[1 + i] = colors[i];
+  for (let i = 0; i < (8); i++) scratch[1 + (4) + i] = floats[i];
+  cache.changed(UiProp.gradient, scratch, 1 + (4) + (8)) && writer.propMixed(node, UiProp.gradient, [kind, ...colors], floats);
+}
+function writeStyle(writer, cache, node, style) {
+  for (let key in style) {
+    let value = style[key];
+    if (value !== void 0)
+      switch (key) {
+        case "width":
+          emitLength(writer, cache, node, UiProp.width, value);
+          break;
+        case "height":
+          emitLength(writer, cache, node, UiProp.height, value);
+          break;
+        case "minWidth":
+          emitLength(writer, cache, node, UiProp.min_width, value);
+          break;
+        case "minHeight":
+          emitLength(writer, cache, node, UiProp.min_height, value);
+          break;
+        case "maxWidth":
+          emitLength(writer, cache, node, UiProp.max_width, value);
+          break;
+        case "maxHeight":
+          emitLength(writer, cache, node, UiProp.max_height, value);
+          break;
+        case "basis":
+          emitLength(writer, cache, node, UiProp.basis, value);
+          break;
+        case "top":
+          emitLength(writer, cache, node, UiProp.inset_top, value);
+          break;
+        case "right":
+          emitLength(writer, cache, node, UiProp.inset_right, value);
+          break;
+        case "bottom":
+          emitLength(writer, cache, node, UiProp.inset_bottom, value);
+          break;
+        case "left":
+          emitLength(writer, cache, node, UiProp.inset_left, value);
+          break;
+        case "padding":
+          emitFloats(writer, cache, node, UiProp.padding, edges(value));
+          break;
+        case "margin":
+          emitFloats(writer, cache, node, UiProp.margin, edges(value));
+          break;
+        case "borderWidth":
+          emitFloats(writer, cache, node, UiProp.border_width, edges(value));
+          break;
+        case "radius":
+          emitFloats(writer, cache, node, UiProp.radii, edges(value));
+          break;
+        case "nineSlice":
+          emitFloats(writer, cache, node, UiProp.nine_slice, edges(value));
+          break;
+        case "nineSliceUv":
+          emitFloats(writer, cache, node, UiProp.nine_slice_uv, edges(value));
+          break;
+        case "uv":
+          emitFloats(writer, cache, node, UiProp.image_uv, value);
+          break;
+        case "gap": {
+          let gap = value;
+          emitFloats(writer, cache, node, UiProp.gap, typeof gap == "number" ? [gap, gap] : gap);
+          break;
+        }
+        case "grow":
+          emitFloat(writer, cache, node, UiProp.grow, value);
+          break;
+        case "shrink":
+          emitFloat(writer, cache, node, UiProp.shrink, value);
+          break;
+        case "aspect":
+          emitFloat(writer, cache, node, UiProp.aspect, value);
+          break;
+        case "opacity":
+          emitFloat(writer, cache, node, UiProp.opacity, value);
+          break;
+        case "rotate":
+          emitFloat(writer, cache, node, UiProp.rotate, value);
+          break;
+        case "fontSize":
+          emitFloat(writer, cache, node, UiProp.font_size, value);
+          break;
+        case "lineHeight":
+          emitFloat(writer, cache, node, UiProp.line_height, value);
+          break;
+        case "letterSpacing":
+          emitFloat(writer, cache, node, UiProp.letter_spacing, value);
+          break;
+        case "strokeWidth":
+          emitFloat(writer, cache, node, UiProp.stroke_width, value);
+          break;
+        case "translate":
+          emitFloats(writer, cache, node, UiProp.translate, value);
+          break;
+        case "scale": {
+          let scale = value;
+          emitFloats(writer, cache, node, UiProp.scale, typeof scale == "number" ? [scale, scale] : scale);
+          break;
+        }
+        case "origin":
+          emitFloats(writer, cache, node, UiProp.origin, value);
+          break;
+        case "direction":
+          emitWord(writer, cache, node, UiProp.direction, lookup(DIRECTION, value, "direction"));
+          break;
+        case "justify":
+          emitWord(writer, cache, node, UiProp.justify, lookup(JUSTIFY, value, "justify"));
+          break;
+        case "alignItems":
+          emitWord(writer, cache, node, UiProp.align_items, lookup(ALIGN, value, "alignItems"));
+          break;
+        case "alignSelf":
+          emitWord(writer, cache, node, UiProp.align_self, lookup(ALIGN, value, "alignSelf"));
+          break;
+        case "alignContent":
+          emitWord(writer, cache, node, UiProp.align_content, lookup(ALIGN, value, "alignContent"));
+          break;
+        case "position":
+          emitWord(writer, cache, node, UiProp.position, value === "absolute" ? 1 : 0);
+          break;
+        case "wrap":
+          emitWord(writer, cache, node, UiProp.wrap, value ? 1 : 0);
+          break;
+        case "display":
+          emitWord(writer, cache, node, UiProp.display_none, value === "none" ? 1 : 0);
+          break;
+        case "zIndex":
+          emitWord(writer, cache, node, UiProp.z_index, value | 0);
+          break;
+        case "hidden":
+          emitWord(writer, cache, node, UiProp.hidden, value ? 1 : 0);
+          break;
+        case "clip":
+          emitWord(writer, cache, node, UiProp.clip, value ? 1 : 0);
+          break;
+        case "pointerEvents":
+          emitWord(writer, cache, node, UiProp.pointer_events_none, value === "none" ? 1 : 0);
+          break;
+        case "fill":
+          emitWord(writer, cache, node, UiProp.fill, parseColor(value));
+          break;
+        case "textColor":
+          emitWord(writer, cache, node, UiProp.text_color, parseColor(value));
+          break;
+        case "placeholderColor":
+          emitWord(writer, cache, node, UiProp.placeholder_color, parseColor(value));
+          break;
+        case "tint":
+          emitWord(writer, cache, node, UiProp.image_tint, parseColor(value));
+          break;
+        case "stroke":
+          emitWord(writer, cache, node, UiProp.stroke_color, parseColor(value));
+          break;
+        case "borderColor": {
+          let border = value, colors = Array.isArray(border) ? border.map(parseColor) : [parseColor(border), parseColor(border), parseColor(border), parseColor(border)];
+          emitWords(writer, cache, node, UiProp.border_color, colors);
+          break;
+        }
+        case "fontFamily":
+          emitWord(writer, cache, node, UiProp.font_family, value);
+          break;
+        case "fontWeight":
+          emitWord(writer, cache, node, UiProp.font_weight, value);
+          break;
+        case "textAlign":
+          emitWord(writer, cache, node, UiProp.text_align, lookup(TEXT_ALIGN, value, "textAlign"));
+          break;
+        case "verticalAlign":
+          emitWord(writer, cache, node, UiProp.vertical_align, lookup(VERTICAL, value, "verticalAlign"));
+          break;
+        case "textWrap":
+          emitWord(writer, cache, node, UiProp.text_wrap, value ? 1 : 0);
+          break;
+        case "textWrapStyle":
+          emitWord(writer, cache, node, UiProp.text_wrap_style, lookup(TEXT_WRAP_STYLE, value, "textWrapStyle"));
+          break;
+        case "shape":
+          emitWord(writer, cache, node, UiProp.shape_kind, lookup(SHAPE, value, "shape"));
+          break;
+        case "scrollAxes":
+          emitWord(writer, cache, node, UiProp.scroll_axes, lookup(AXES, value, "scrollAxes"));
+          break;
+        case "shadow":
+          shadow(writer, cache, node, value);
+          break;
+        case "gradient":
+          gradient(writer, cache, node, value);
+          break;
+        case "layer":
+          break;
+        default:
+          throw new UiStyleError(`style ${key} is not supported`);
+      }
+  }
+}
+
+export { ALIGN, AXES, DEFAULT_THEME, DIRECTION, GRADIENT_KIND, JUSTIFY, NO_NODE, PatchWriter, SHAPE, StyleCache, TEXT_ALIGN, TEXT_WRAP_STYLE, UI_EVENT_BYTES, UI_EVENT_DX_OFFSET, UI_EVENT_DY_OFFSET, UI_EVENT_KIND_OFFSET, UI_EVENT_NODE_OFFSET, UI_EVENT_PHASE_OFFSET, UI_EVENT_POINTER_OFFSET, UI_EVENT_TIME_OFFSET, UI_EVENT_VALUE_OFFSET, UI_EVENT_X_OFFSET, UI_EVENT_Y_OFFSET, UI_EXCLUSION_HEADER_WORDS, UI_HEADER_BYTES, UI_MAGIC, UI_MAX_EXCLUSIONS, UI_RECORD_HEADER_WORDS, UI_SLOT_REFERENCE, UI_STYLE_REFERENCED, UI_STYLE_SAFE_EDGES, UI_TOKENS_REPLACE, UI_VERSION, UiAction, UiAnchor, UiEasing, UiEventKind, UiExclusionShape, UiFlag, UiFocusFlag, UiKind, UiNumberFormat, UiOp, UiProp, UiRole, UiStyleError, UiTextOption, UiTrait, UiTransition, UiUnit, UiVectorData, UiVectorPlay, VERTICAL, codePointOffset, eventStride, parseColor, readEvent, textComposition, textEventCapacity, textEventPadding, theme, writeStyle, writeTextEvent };