quickwin 1.2.0 → 1.3.0

package/examples/test_root_window.js

@@ -15486,57 +15486,370 @@ function calculateFlexLayout(flex, parentW, parentH, children) {
 }
 
 // _build/lib/text-measure.js
+import * as ffi2 from "ffi";
+import * as gui2 from "gui";
+
+// _build/lib/ffi-bind.js
 import * as ffi from "ffi";
 import * as win from "win";
-import * as gui2 from "gui";
-function loadProc(lib, name) {
-  const ptr = win.GetProcAddress(lib, name);
-  if (!ptr)
-    throw new Error(`Cannot load ${name}`);
-  return ptr;
+
+// _build/lib/text-codec.js
+var _labelMap = {
+  "utf-8": "utf-8",
+  "utf8": "utf-8",
+  "unicode-1-1-utf-8": "utf-8",
+  "utf-16": "utf-16le",
+  "utf-16le": "utf-16le",
+  "utf-16be": "utf-16be"
+};
+function _normalizeLabel(label) {
+  if (!label)
+    return "utf-8";
+  const result = _labelMap[label.trim().toLowerCase()];
+  if (result)
+    return result;
+  throw new RangeError(`The encoding label "${label}" is not supported`);
+}
+function _decodeUTF8(buf, fatal) {
+  let out = "";
+  for (let i = 0; i < buf.length; ) {
+    const b = buf[i++];
+    if (b < 128) {
+      out += String.fromCharCode(b);
+      continue;
+    }
+    if (b < 192) {
+      out += fatal ? (() => {
+        throw new TypeError("unexpected continuation byte");
+      })() : "\uFFFD";
+      continue;
+    }
+    let c, min;
+    if (b < 224) {
+      if (i >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b2 = buf[i++];
+      if ((b2 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c = (b & 31) << 6 | b2 & 63;
+      min = 128;
+    } else if (b < 240) {
+      if (i + 1 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b2 = buf[i++];
+      const b3 = buf[i++];
+      if ((b2 & 192) !== 128 || (b3 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c = (b & 15) << 12 | (b2 & 63) << 6 | b3 & 63;
+      min = 2048;
+    } else if (b < 248) {
+      if (i + 2 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b2 = buf[i++];
+      const b3 = buf[i++];
+      const b4 = buf[i++];
+      if ((b2 & 192) !== 128 || (b3 & 192) !== 128 || (b4 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c = (b & 7) << 18 | (b2 & 63) << 12 | (b3 & 63) << 6 | b4 & 63;
+      min = 65536;
+    } else {
+      out += fatal ? (() => {
+        throw new TypeError("invalid utf-8 start");
+      })() : "\uFFFD";
+      continue;
+    }
+    if (c < min || c >= 55296 && c <= 57343 || c > 1114111) {
+      out += fatal ? (() => {
+        throw new TypeError("invalid utf-8 codepoint");
+      })() : "\uFFFD";
+      continue;
+    }
+    if (c <= 65535)
+      out += String.fromCharCode(c);
+    else {
+      c -= 65536;
+      out += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    }
+  }
+  return out;
+}
+function _decodeUTF16(buf, le, fatal) {
+  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let out = "";
+  for (let i = 0; i + 1 < buf.length; i += 2) {
+    let c = dv.getUint16(i, le);
+    if (c >= 55296 && c <= 56319) {
+      i += 2;
+      if (i + 1 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("truncated surrogate pair");
+        })() : "\uFFFD";
+        break;
+      }
+      const c2 = dv.getUint16(i, le);
+      if (c2 >= 56320 && c2 <= 57343) {
+        out += String.fromCharCode(c, c2);
+      } else {
+        out += fatal ? (() => {
+          throw new TypeError("invalid surrogate pair");
+        })() : "\uFFFD";
+        i -= 2;
+      }
+    } else if (c >= 56320 && c <= 57343) {
+      out += fatal ? (() => {
+        throw new TypeError("unexpected trailing surrogate");
+      })() : "\uFFFD";
+    } else {
+      out += String.fromCharCode(c);
+    }
+  }
+  return out;
+}
+var TextDecoderImpl = class {
+  _encoding;
+  _fatal;
+  _ignoreBOM;
+  constructor(label, options) {
+    this._encoding = _normalizeLabel(label);
+    this._fatal = options?.fatal ?? false;
+    this._ignoreBOM = options?.ignoreBOM ?? false;
+  }
+  get encoding() {
+    return this._encoding;
+  }
+  get fatal() {
+    return this._fatal;
+  }
+  get ignoreBOM() {
+    return this._ignoreBOM;
+  }
+  decode(buffer) {
+    if (!buffer)
+      return "";
+    const arr = buffer instanceof Uint8Array ? buffer : buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    if (this._encoding === "utf-8") {
+      return _decodeUTF8(arr, this._fatal);
+    }
+    const le = this._encoding === "utf-16le";
+    let offset = 0;
+    if (arr.length >= 2 && !this._ignoreBOM) {
+      const bomLo = le ? arr[0] : arr[1];
+      const bomHi = le ? arr[1] : arr[0];
+      const bom = bomHi << 8 | bomLo;
+      if (bom === 65279 || bom === 65534) {
+        offset = 2;
+      }
+    }
+    return _decodeUTF16(arr.slice(offset), le, this._fatal);
+  }
+};
+var TextEncoderImpl = class {
+  _encoding;
+  constructor(label) {
+    this._encoding = _normalizeLabel(label);
+  }
+  get encoding() {
+    return this._encoding;
+  }
+  encode(input) {
+    if (!input)
+      return new Uint8Array(0);
+    if (this._encoding === "utf-8") {
+      const bytes = [];
+      for (let i = 0; i < input.length; i++) {
+        let c = input.charCodeAt(i);
+        if (c < 128) {
+          bytes.push(c);
+        } else if (c < 2048) {
+          bytes.push(192 | c >> 6, 128 | c & 63);
+        } else if (c < 55296 || c >= 57344) {
+          bytes.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+        } else {
+          i++;
+          const c2 = input.charCodeAt(i);
+          c = 65536 + ((c & 1023) << 10) | c2 & 1023;
+          bytes.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+        }
+      }
+      return new Uint8Array(bytes);
+    }
+    const le = this._encoding === "utf-16le";
+    const buf = new ArrayBuffer(input.length * 2);
+    const dv = new DataView(buf);
+    for (let i = 0; i < input.length; i++)
+      dv.setUint16(i * 2, input.charCodeAt(i), le);
+    return new Uint8Array(buf);
+  }
+};
+if (typeof globalThis.TextDecoder === "undefined") {
+  globalThis.TextDecoder = TextDecoderImpl;
 }
-var user32 = win.LoadLibrary("user32.dll");
-var gdi32 = win.LoadLibrary("gdi32.dll");
-if (!user32 || !gdi32)
-  throw new Error("Failed to load system DLLs");
-var DrawTextW = loadProc(user32, "DrawTextW");
-var GetDC = loadProc(user32, "GetDC");
-var ReleaseDC = loadProc(user32, "ReleaseDC");
-var SelectObject = loadProc(gdi32, "SelectObject");
-var FFI_TYPE_UINT642 = ffi.FFI_TYPE_UINT64;
-var FFI_S32 = ffi.FFI_TYPE_SINT32;
-var FFI_PTR = ffi.FFI_TYPE_POINTER;
+if (typeof globalThis.TextEncoder === "undefined") {
+  globalThis.TextEncoder = TextEncoderImpl;
+}
+
+// _build/lib/ffi-bind.js
+var KIND_TO_FFI = {
+  void: ffi.FFI_TYPE_VOID,
+  u8: ffi.FFI_TYPE_UINT8,
+  i8: ffi.FFI_TYPE_SINT8,
+  u16: ffi.FFI_TYPE_UINT16,
+  i16: ffi.FFI_TYPE_SINT16,
+  u32: ffi.FFI_TYPE_UINT32,
+  i32: ffi.FFI_TYPE_SINT32,
+  u64: ffi.FFI_TYPE_UINT64,
+  i64: ffi.FFI_TYPE_SINT64,
+  f32: ffi.FFI_TYPE_FLOAT,
+  f64: ffi.FFI_TYPE_DOUBLE,
+  ptr: ffi.FFI_TYPE_POINTER,
+  wstr: ffi.FFI_TYPE_POINTER
+};
+var C_ALIAS = {
+  int: "i32",
+  long: "i32",
+  short: "i16",
+  char: "i8",
+  float: "f32",
+  double: "f64",
+  DWORD: "u32",
+  UINT: "u32",
+  ULONG: "u32",
+  LONG: "i32",
+  BOOL: "i32",
+  HRESULT: "i32",
+  SHORT: "i16",
+  USHORT: "u16",
+  BYTE: "u8",
+  LONG_PTR: "ptr",
+  ULONG_PTR: "ptr",
+  INT_PTR: "ptr",
+  UINT_PTR: "ptr",
+  DWORD_PTR: "ptr",
+  SIZE_T: "ptr",
+  WPARAM: "ptr",
+  LPARAM: "ptr",
+  HANDLE: "ptr",
+  HWND: "ptr",
+  HDC: "ptr",
+  HMODULE: "ptr",
+  HFONT: "ptr",
+  HBRUSH: "ptr",
+  HICON: "ptr",
+  HBITMAP: "ptr",
+  LPVOID: "ptr",
+  LPCVOID: "ptr",
+  LPCWSTR: "ptr",
+  PCWSTR: "ptr",
+  LPWSTR: "ptr"
+};
+function normKind(t) {
+  const k = C_ALIAS[t] ?? t;
+  if (!(k in KIND_TO_FFI))
+    throw new Error(`ffi-bind: invalid kind "${t}"`);
+  return k;
+}
+var _dllCache = /* @__PURE__ */ new Map();
+function loadDll(dll) {
+  const cached = _dllCache.get(dll);
+  if (cached !== void 0)
+    return cached;
+  const loaded = win.LoadLibrary(dll);
+  if (!loaded)
+    throw new Error(`ffi-bind: LoadLibrary("${dll}") failed`);
+  _dllCache.set(dll, loaded);
+  return loaded;
+}
+function parseSig(sig) {
+  const parts = sig.split(" -> ");
+  const ret = parts[1];
+  if (ret === void 0 || parts.length > 2) {
+    throw new Error(`ffi-bind: invalid signature "${sig}" (expected "arg1 arg2 -> ret")`);
+  }
+  const retK = normKind(ret);
+  if (retK === "wstr")
+    throw new Error('ffi-bind: "wstr" cannot be a return type');
+  const tokens = (parts[0] ?? "") === "" ? [] : parts[0].split(" ");
+  const args = tokens.map((t) => normKind(t));
+  return { args, ret: retK };
+}
+function makeFn(proc, sig) {
+  const { args, ret } = parseSig(sig);
+  const argTypes = args.map((k) => KIND_TO_FFI[k]);
+  const retType = KIND_TO_FFI[ret];
+  return (...a) => {
+    const vals = args.map((k, i) => k === "wstr" ? new TextEncoder("utf-16le").encode(String(a[i]) + "\0").buffer : a[i]);
+    return ffi.ffiCall(proc, argTypes, vals, retType);
+  };
+}
+function bindLib(dll, map) {
+  const out = {};
+  const h = loadDll(dll);
+  for (const [name, sig] of Object.entries(map)) {
+    const proc = win.GetProcAddress(h, name);
+    if (!proc)
+      throw new Error(`ffi-bind: proc "${name}" not found in ${dll}`);
+    out[name] = makeFn(proc, sig);
+  }
+  return out;
+}
+
+// _build/lib/text-measure.js
+var user32 = bindLib("user32.dll", {
+  DrawTextW: "ptr wstr i32 ptr i32 -> i32",
+  GetDC: "ptr -> ptr",
+  ReleaseDC: "ptr ptr -> i32"
+});
+var gdi32 = bindLib("gdi32.dll", {
+  SelectObject: "ptr ptr -> ptr"
+});
 function measureText(hdc, text, maxWidth) {
-  const textBuf = new TextEncoder("utf-16le").encode(text + "\0").buffer;
   const rect = new ArrayBuffer(16);
   const dv = new DataView(rect);
   dv.setInt32(8, maxWidth, true);
-  ffi.ffiCall(DrawTextW, [FFI_TYPE_UINT642, FFI_PTR, FFI_S32, FFI_PTR, FFI_S32], [
+  user32.DrawTextW(
     hdc,
-    textBuf,
+    text,
     -1,
     rect,
     1024
     /* gui.DrawTextFlag.CALCRECT */
-  ], FFI_TYPE_UINT642);
+  );
   return { width: dv.getInt32(8, true), height: dv.getInt32(12, true) };
 }
 function getButtonIdealSize(hwnd) {
   const size = new ArrayBuffer(8);
-  gui2.SendMessage(hwnd, 5633, 0, ffi.bufferPtr(size));
+  gui2.SendMessage(hwnd, 5633, 0, ffi2.bufferPtr(size));
   const dv = new DataView(size);
   return { width: dv.getInt32(0, true), height: dv.getInt32(4, true) };
 }
 function measureTextForHwnd(hwnd, text) {
-  const hdc = ffi.ffiCall(GetDC, [FFI_TYPE_UINT642], [hwnd], FFI_TYPE_UINT642);
+  const hdc = user32.GetDC(hwnd);
   if (!hdc)
     return { width: 0, height: 0 };
   const hFont = gui2.SendMessage(hwnd, 49, 0, 0);
-  const oldFont = hFont ? ffi.ffiCall(SelectObject, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hdc, hFont], FFI_TYPE_UINT642) : 0;
+  const oldFont = hFont ? gdi32.SelectObject(hdc, hFont) : 0;
   const result = measureText(hdc, text, 0);
   if (hFont)
-    ffi.ffiCall(SelectObject, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hdc, oldFont], FFI_TYPE_UINT642);
-  ffi.ffiCall(ReleaseDC, [FFI_TYPE_UINT642, FFI_TYPE_UINT642], [hwnd, hdc], FFI_S32);
+    gdi32.SelectObject(hdc, oldFont);
+  user32.ReleaseDC(hwnd, hdc);
   const wr = gui2.GetWindowRect(hwnd);
   const cr = gui2.GetClientRect(hwnd);
   if (wr && cr) {
@@ -16019,15 +16332,285 @@ var ComboBox = (0, import_react4.forwardRef)(({ items, selectedIndex: controlled
 var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
 var import_react5 = __toESM(require_react(), 1);
 import * as gui6 from "gui";
-import * as ffi2 from "ffi";
-function readI16(ptr, offset) {
-  return ffi2.readByte(ptr + offset) | ffi2.readByte(ptr + offset + 1) << 8;
+import * as ffi4 from "ffi";
+
+// _build/lib/ffi-struct.js
+import * as os2 from "os";
+var PTR = os2.arch === "x64" ? 8 : 4;
+var AS = {
+  u8: [1, 1],
+  i8: [1, 1],
+  u16: [2, 2],
+  i16: [2, 2],
+  u32: [4, 4],
+  i32: [4, 4],
+  u64: [8, 8],
+  i64: [8, 8],
+  f32: [4, 4],
+  f64: [8, 8],
+  ptr: [PTR, PTR],
+  wstr: [2, 2]
+  // 仅定长数组元素用（wchar）
+};
+function alignUp(v, a) {
+  return v + a - 1 & ~(a - 1);
 }
-function readI32(ptr, offset) {
-  return ffi2.readByte(ptr + offset) | ffi2.readByte(ptr + offset + 1) << 8 | ffi2.readByte(ptr + offset + 2) << 16 | ffi2.readByte(ptr + offset + 3) << 24;
+function parseField(f) {
+  const arr = /^(.+)\[(\d+)\]$/.exec(f);
+  if (arr) {
+    const b2 = normKind(arr[1]);
+    if (b2 === "void")
+      throw new Error(`ffi-struct: "void" cannot be an array base`);
+    return { base: b2, count: Number(arr[2]) };
+  }
+  const b = normKind(f);
+  if (b === "void" || b === "wstr")
+    throw new Error(`ffi-struct: invalid scalar field type "${f}"`);
+  return { base: b, count: 1 };
+}
+function layout(def) {
+  const fields = [];
+  let cursor = 0;
+  let maxAlign = 1;
+  for (const key of Object.keys(def)) {
+    const v = def[key];
+    let a;
+    let w;
+    if (typeof v === "string") {
+      const { base, count } = parseField(v);
+      const [align, elem] = AS[base];
+      a = align;
+      w = count >= 1 ? elem * count : elem;
+      fields.push({ name: key, base, count, offset: 0 });
+    } else {
+      const child = v;
+      a = child.structAlign;
+      w = child.size;
+      fields.push({ name: key, base: "u8", count: 0, offset: 0, child });
+    }
+    const off = alignUp(cursor, a);
+    const f = fields[fields.length - 1];
+    f.offset = off;
+    cursor = off + w;
+    if (a > maxAlign)
+      maxAlign = a;
+  }
+  return { fields, size: alignUp(cursor, maxAlign), structAlign: maxAlign };
+}
+var _layoutCache = /* @__PURE__ */ new WeakMap();
+function buildLayout(def) {
+  let hit = _layoutCache.get(def);
+  if (hit)
+    return hit;
+  hit = layout(def);
+  _layoutCache.set(def, hit);
+  return hit;
+}
+function readScalar(dv, off, k) {
+  switch (k) {
+    case "u8":
+      return dv.getUint8(off);
+    case "i8":
+      return dv.getInt8(off);
+    case "u16":
+      return dv.getUint16(off, true);
+    case "i16":
+      return dv.getInt16(off, true);
+    case "u32":
+      return dv.getUint32(off, true);
+    case "i32":
+      return dv.getInt32(off, true);
+    case "u64":
+      return Number(dv.getBigUint64(off, true));
+    case "i64":
+      return Number(dv.getBigInt64(off, true));
+    case "f32":
+      return dv.getFloat32(off, true);
+    case "f64":
+      return dv.getFloat64(off, true);
+    case "ptr":
+      return readPtr(dv, off);
+    case "wstr":
+      return dv.getUint16(off, true);
+  }
 }
+function readPtr(dv, off) {
+  if (PTR === 8)
+    return Number(dv.getBigUint64(off, true));
+  return dv.getUint32(off, true);
+}
+function writeScalar(dv, off, k, val) {
+  switch (k) {
+    case "u8":
+      dv.setUint8(off, val);
+      break;
+    case "i8":
+      dv.setInt8(off, val);
+      break;
+    case "u16":
+      dv.setUint16(off, val, true);
+      break;
+    case "i16":
+      dv.setInt16(off, val, true);
+      break;
+    case "u32":
+      dv.setUint32(off, val >>> 0, true);
+      break;
+    case "i32":
+      dv.setInt32(off, val | 0, true);
+      break;
+    case "u64":
+      dv.setBigUint64(off, BigInt(Math.trunc(val)), true);
+      break;
+    case "i64":
+      dv.setBigInt64(off, BigInt(Math.trunc(val)), true);
+      break;
+    case "f32":
+      dv.setFloat32(off, val, true);
+      break;
+    case "f64":
+      dv.setFloat64(off, val, true);
+      break;
+    case "ptr":
+      writePtr(dv, off, val);
+      break;
+    case "wstr":
+      dv.setUint16(off, val, true);
+      break;
+  }
+}
+function writePtr(dv, off, val) {
+  if (PTR === 8)
+    dv.setBigUint64(off, BigInt(Math.trunc(val)), true);
+  else
+    dv.setUint32(off, val >>> 0, true);
+}
+function readField(dv, base, f) {
+  const off = base + f.offset;
+  if (f.child)
+    return readInto(f.child, dv.buffer, off);
+  if (f.count > 1) {
+    if (f.base === "wstr") {
+      const arr = new Uint16Array(dv.buffer, dv.byteOffset + off, f.count);
+      let end = 0;
+      while (end < arr.length && arr[end] !== 0)
+        end++;
+      let s = "";
+      for (let i = 0; i < end; i++)
+        s += String.fromCharCode(arr[i]);
+      return s;
+    }
+    const out = [];
+    const step = AS[f.base][1];
+    for (let i = 0; i < f.count; i++)
+      out.push(readScalar(dv, off + i * step, f.base));
+    return out;
+  }
+  return readScalar(dv, off, f.base);
+}
+function writeField(dv, base, f, v) {
+  const off = base + f.offset;
+  if (f.child) {
+    writeInto(f.child, v, dv.buffer, off);
+    return;
+  }
+  if (f.count > 1) {
+    if (f.base === "wstr") {
+      const s = String(v ?? "");
+      const arr = new Uint16Array(dv.buffer, dv.byteOffset + off, f.count);
+      for (let i = 0; i < arr.length; i++)
+        arr[i] = 0;
+      const n = Math.min(s.length, f.count - 1);
+      for (let i = 0; i < n; i++)
+        arr[i] = s.charCodeAt(i);
+      return;
+    }
+    const step = AS[f.base][1];
+    const list = v ?? [];
+    for (let i = 0; i < f.count; i++)
+      writeScalar(dv, off + i * step, f.base, list[i] ?? 0);
+    return;
+  }
+  writeScalar(dv, off, f.base, Number(v));
+}
+function doSize(def) {
+  return buildLayout(def).size;
+}
+function readInto(child, buf, offset) {
+  const r = child;
+  return r.read(buf, offset);
+}
+function doRead(_def, fields, buf, offset) {
+  const out = {};
+  const dv = new DataView(buf);
+  for (const f of fields)
+    out[f.name] = readField(dv, offset, f);
+  return out;
+}
+function doWrite(def, fields, v, buf, offset = 0) {
+  buf = buf ?? new ArrayBuffer(doSize(def));
+  const dv = new DataView(buf);
+  for (const f of fields)
+    writeField(dv, offset, f, v[f.name]);
+  return buf;
+}
+function writeInto(child, v, buf, offset) {
+  const w = child;
+  w.write(v, buf, offset);
+}
+function struct(def) {
+  const { fields, size, structAlign } = buildLayout(def);
+  return {
+    __fields: def,
+    size,
+    structAlign,
+    read: (buf, offset = 0) => doRead(def, fields, buf, offset),
+    write: (v, buf, offset = 0) => doWrite(def, fields, v, buf, offset),
+    offsetOf: (name) => {
+      for (const f of fields)
+        if (f.name === name)
+          return f.offset;
+      throw new Error(`ffi-struct: no field "${String(name)}"`);
+    }
+  };
+}
+
+// _build/lib/react-qw/nmhdr.js
+import * as os3 from "os";
+import * as ffi3 from "ffi";
+var IS64 = os3.arch === "x64";
+var PTR_SIZE = IS64 ? 8 : 4;
+var NMHDR = struct({ hwndFrom: "ptr", idFrom: "ptr", code: "i32" });
+var NMHDR_SIZE = NMHDR.size;
+var NMHDR_CODE = NMHDR.offsetOf("code");
+function readI32At(ptr, offset) {
+  return ffi3.readByte(ptr + offset) | ffi3.readByte(ptr + offset + 1) << 8 | ffi3.readByte(ptr + offset + 2) << 16 | ffi3.readByte(ptr + offset + 3) << 24;
+}
+function readU16At(ptr, offset) {
+  return ffi3.readByte(ptr + offset) | ffi3.readByte(ptr + offset + 1) << 8;
+}
+function nmCode(lParam) {
+  return readI32At(lParam, NMHDR_CODE);
+}
+
+// _build/lib/react-qw/components/DateTimePicker.js
+var SYSTEMTIME = struct({
+  wYear: "u16",
+  wMonth: "u16",
+  wDayOfWeek: "u16",
+  wDay: "u16",
+  wHour: "u16",
+  wMinute: "u16",
+  wSecond: "u16",
+  wMilliseconds: "u16"
+});
+var NMDATETIMECHANGE = struct({
+  hdr: NMHDR,
+  dwFlags: "u32",
+  st: SYSTEMTIME
+});
 function bufPtr(buf) {
-  return ffi2.bufferPtr(buf);
+  return ffi4.bufferPtr(buf);
 }
 function dateToSysTimeBuf(d) {
   const buf = new ArrayBuffer(16);
@@ -16084,20 +16667,21 @@ var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ va
   }, []);
   return (0, import_jsx_runtime4.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, ref, onEvent: (e) => {
     if (e.msg === 78) {
-      const code = readI32(e.lParam, 16);
+      const code = nmCode(e.lParam);
       if (code === -759) {
-        const dwFlags = readI32(e.lParam, 24);
+        const st = NMDATETIMECHANGE.offsetOf("st");
+        const dwFlags = readI32At(e.lParam, NMDATETIMECHANGE.offsetOf("dwFlags"));
         if (dwFlags === 1) {
           if (!isControlled)
             setInternalDate(null);
           onChangeRef.current?.(null);
         } else {
-          const year = readI16(e.lParam, 28);
-          const month = readI16(e.lParam, 30);
-          const day = readI16(e.lParam, 34);
-          const hour = readI16(e.lParam, 36);
-          const min = readI16(e.lParam, 38);
-          const sec = readI16(e.lParam, 40);
+          const year = readU16At(e.lParam, st + 0);
+          const month = readU16At(e.lParam, st + 2);
+          const day = readU16At(e.lParam, st + 6);
+          const hour = readU16At(e.lParam, st + 8);
+          const min = readU16At(e.lParam, st + 10);
+          const sec = readU16At(e.lParam, st + 12);
           const d = new Date(year, month - 1, day, hour, min, sec);
           if (!isControlled)
             setInternalDate(d);
@@ -16114,7 +16698,7 @@ var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ va
 var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
 var import_react6 = __toESM(require_react(), 1);
 import * as gui7 from "gui";
-import * as ffi3 from "ffi";
+import * as ffi5 from "ffi";
 function textToUtf16(s) {
   const buf = new ArrayBuffer((s.length + 1) * 2);
   const dv = new DataView(buf);
@@ -16141,7 +16725,7 @@ var Input = (0, import_react6.forwardRef)(({ value: controlledValue, defaultValu
     if (!h || !placeholder)
       return;
     const buf = textToUtf16(placeholder);
-    gui7.SendMessage(h, 5377, 1, ffi3.bufferPtr(buf));
+    gui7.SendMessage(h, 5377, 1, ffi5.bufferPtr(buf));
   }, [placeholder]);
   return (0, import_jsx_runtime5.jsx)("w", { type: "EDIT", text: displayValue, ws, style, disabled, ref: (h) => {
     inputRef.current = h;
@@ -16166,15 +16750,12 @@ var Input = (0, import_react6.forwardRef)(({ value: controlledValue, defaultValu
 var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
 var import_react7 = __toESM(require_react(), 1);
 import * as gui8 from "gui";
-import * as ffi4 from "ffi";
-function readI322(ptr, offset) {
-  return ffi4.readByte(ptr + offset) | ffi4.readByte(ptr + offset + 1) << 8 | ffi4.readByte(ptr + offset + 2) << 16 | ffi4.readByte(ptr + offset + 3) << 24;
-}
+import * as ffi6 from "ffi";
 function readUtf16(ptr, offset, maxWords) {
   const chars = [];
   for (let i = 0; i < maxWords; i++) {
-    const lo = ffi4.readByte(ptr + offset + i * 2);
-    const hi = ffi4.readByte(ptr + offset + i * 2 + 1);
+    const lo = ffi6.readByte(ptr + offset + i * 2);
+    const hi = ffi6.readByte(ptr + offset + i * 2 + 1);
     const code = hi << 8 | lo;
     if (code === 0)
       break;
@@ -16196,9 +16777,9 @@ var Link = (0, import_react7.forwardRef)(function Link2({ href, children, onClic
   }, [linkText]);
   return (0, import_jsx_runtime6.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, ref, onEvent: (e) => {
     if (e.msg === 78) {
-      const code = readI322(e.lParam, 16);
+      const code = nmCode(e.lParam);
       if (code === -2 || code === -4) {
-        const url = readUtf16(e.lParam, 136, 2048);
+        const url = readUtf16(e.lParam, NMHDR_SIZE + 112, 2048);
         onClickRef.current?.(url);
       }
     }
@@ -16259,7 +16840,7 @@ var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledI
 var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
 var import_react9 = __toESM(require_react(), 1);
 import * as gui10 from "gui";
-import * as ffi5 from "ffi";
+import * as ffi7 from "ffi";
 import * as win2 from "win";
 function textToUtf162(s) {
   const buf = new ArrayBuffer((s.length + 1) * 2);
@@ -16268,11 +16849,11 @@ function textToUtf162(s) {
     dv.setUint16(i * 2, s.charCodeAt(i), true);
   return buf;
 }
-function readI323(ptr, offset) {
-  return ffi5.readByte(ptr + offset) | ffi5.readByte(ptr + offset + 1) << 8 | ffi5.readByte(ptr + offset + 2) << 16 | ffi5.readByte(ptr + offset + 3) << 24;
+function readI32(ptr, offset) {
+  return ffi7.readByte(ptr + offset) | ffi7.readByte(ptr + offset + 1) << 8 | ffi7.readByte(ptr + offset + 2) << 16 | ffi7.readByte(ptr + offset + 3) << 24;
 }
 function readU32(ptr, offset) {
-  return ffi5.readByte(ptr + offset) | ffi5.readByte(ptr + offset + 1) << 8 | ffi5.readByte(ptr + offset + 2) << 16 | ffi5.readByte(ptr + offset + 3) << 24 >>> 0;
+  return ffi7.readByte(ptr + offset) | ffi7.readByte(ptr + offset + 1) << 8 | ffi7.readByte(ptr + offset + 2) << 16 | ffi7.readByte(ptr + offset + 3) << 24 >>> 0;
 }
 function readU64(ptr, offset) {
   const lo = readU32(ptr, offset);
@@ -16280,24 +16861,87 @@ function readU64(ptr, offset) {
   return lo + hi * 4294967296;
 }
 function writeU32(ptr, offset, v) {
-  ffi5.writeByte(ptr + offset, v & 255);
-  ffi5.writeByte(ptr + offset + 1, v >> 8 & 255);
-  ffi5.writeByte(ptr + offset + 2, v >> 16 & 255);
-  ffi5.writeByte(ptr + offset + 3, v >> 24 & 255);
+  ffi7.writeByte(ptr + offset, v & 255);
+  ffi7.writeByte(ptr + offset + 1, v >> 8 & 255);
+  ffi7.writeByte(ptr + offset + 2, v >> 16 & 255);
+  ffi7.writeByte(ptr + offset + 3, v >> 24 & 255);
 }
 function bufPtr2(buf) {
-  return ffi5.bufferPtr(buf);
+  return ffi7.bufferPtr(buf);
 }
 var LV_WS = 268435456 | 8388608 | 2097152 | 1048576 | 1 | 4;
-var CD_STAGE = 24;
-var CD_HDC = 32;
-var CD_ITEM = 56;
-var CD_CLRTEXT = 80;
-var CD_CLRTEXTBK = 84;
-var CD_SUBITEM = 88;
-var NMIA_ITEM = 24;
-var NMIA_SUBITEM = 28;
-var NM_CODE = 16;
+var NMCUSTOMDRAW = struct({
+  hdr: NMHDR,
+  dwDrawStage: "u32",
+  hdc: "ptr",
+  rc: "i32[4]",
+  dwItemSpec: "ptr",
+  uItemState: "u32",
+  lItemlParam: "ptr"
+});
+var NMLVCUSTOMDRAW = struct({
+  hdr: NMHDR,
+  dwDrawStage: "u32",
+  hdc: "ptr",
+  rc: "i32[4]",
+  dwItemSpec: "ptr",
+  uItemState: "u32",
+  lItemlParam: "ptr",
+  clrText: "u32",
+  clrTextBk: "u32",
+  iSubItem: "i32",
+  dwItemType: "u32"
+});
+var NMLISTVIEW = struct({
+  hdr: NMHDR,
+  iItem: "i32",
+  iSubItem: "i32",
+  uNewState: "u32",
+  uOldState: "u32",
+  uChanged: "u32",
+  ptAction: "i32[2]",
+  lParam: "ptr"
+});
+var CD_STAGE = NMCUSTOMDRAW.offsetOf("dwDrawStage");
+var CD_HDC = NMCUSTOMDRAW.offsetOf("hdc");
+var CD_ITEM = NMCUSTOMDRAW.offsetOf("dwItemSpec");
+var CD_CLRTEXT = NMLVCUSTOMDRAW.offsetOf("clrText");
+var CD_CLRTEXTBK = NMLVCUSTOMDRAW.offsetOf("clrTextBk");
+var CD_SUBITEM = NMLVCUSTOMDRAW.offsetOf("iSubItem");
+var NMIA_ITEM = NMLISTVIEW.offsetOf("iItem");
+var NMIA_SUBITEM = NMLISTVIEW.offsetOf("iSubItem");
+var NMLV_UNEW = NMLISTVIEW.offsetOf("uNewState");
+var NMLV_UOLD = NMLISTVIEW.offsetOf("uOldState");
+var LVITEMW = struct({
+  mask: "u32",
+  iItem: "i32",
+  iSubItem: "i32",
+  state: "u32",
+  stateMask: "u32",
+  pszText: "ptr",
+  cchTextMax: "i32",
+  iImage: "i32",
+  lParam: "ptr",
+  iIndent: "i32",
+  iGroupId: "i32",
+  cColumns: "u32",
+  puColumns: "ptr",
+  piColFmt: "ptr",
+  iGroup: "i32"
+});
+var LVCOLUMNW = struct({
+  mask: "u32",
+  fmt: "i32",
+  cx: "i32",
+  pszText: "ptr",
+  cchTextMax: "i32",
+  iSubItem: "i32",
+  iImage: "i32",
+  iOrder: "i32",
+  cxMin: "i32",
+  cxDefault: "i32",
+  cxIdeal: "i32"
+});
 var fontCache = /* @__PURE__ */ new Map();
 var gdi322 = null;
 var createFontIndirectW = null;
@@ -16341,7 +16985,7 @@ function getCellFont(hwnd, style) {
   const dv = new DataView(lf);
   const cur = gui10.SendMessage(hwnd, 49, 0, 0);
   if (cur) {
-    const got = ffi5.ffiCall(getObjectW, [ffi5.FFI_TYPE_UINT64, ffi5.FFI_TYPE_SINT32, ffi5.FFI_TYPE_POINTER], [cur, 92, lf], ffi5.FFI_TYPE_SINT32);
+    const got = ffi7.ffiCall(getObjectW, [ffi7.FFI_TYPE_POINTER, ffi7.FFI_TYPE_SINT32, ffi7.FFI_TYPE_POINTER], [cur, 92, lf], ffi7.FFI_TYPE_SINT32);
     if (!got)
       return null;
   } else {
@@ -16353,9 +16997,9 @@ function getCellFont(hwnd, style) {
     dv.setUint8(20, 1);
   if (style.underline)
     dv.setUint8(21, 1);
-  const h = ffi5.ffiCall(createFontIndirectW, [ffi5.FFI_TYPE_POINTER], [lf], ffi5.FFI_TYPE_UINT64);
-  fontCache.set(key, h === 0 ? 0 : h);
-  return h === 0 ? null : h;
+  const h = ffi7.ffiCall(createFontIndirectW, [ffi7.FFI_TYPE_POINTER], [lf], ffi7.FFI_TYPE_POINTER);
+  fontCache.set(key, h ? h : 0);
+  return h ? h : null;
 }
 function handleCustomDraw(lParam, columns, data, hwnd) {
   const stage = readU32(lParam, CD_STAGE);
@@ -16364,8 +17008,8 @@ function handleCustomDraw(lParam, columns, data, hwnd) {
   if (stage === 65537)
     return 32;
   if (stage === 196609) {
-    const colIndex = readI323(lParam, CD_SUBITEM);
-    const row = readI323(lParam, CD_ITEM);
+    const colIndex = readI32(lParam, CD_SUBITEM);
+    const row = readI32(lParam, CD_ITEM);
     const style = resolveCellStyle(columns, data, row, colIndex);
     if (!style)
       return 0;
@@ -16375,9 +17019,9 @@ function handleCustomDraw(lParam, columns, data, hwnd) {
       writeU32(lParam, CD_CLRTEXTBK, style.background);
     const hfont = getCellFont(hwnd, style);
     if (hfont && selectObjectFn) {
-      const hdc = readU64(lParam, CD_HDC);
+      const hdc = PTR_SIZE === 8 ? readU64(lParam, CD_HDC) : readU32(lParam, CD_HDC);
       if (hdc) {
-        ffi5.ffiCall(selectObjectFn, [ffi5.FFI_TYPE_UINT64, ffi5.FFI_TYPE_UINT64], [hdc, hfont], ffi5.FFI_TYPE_UINT64);
+        ffi7.ffiCall(selectObjectFn, [ffi7.FFI_TYPE_POINTER, ffi7.FFI_TYPE_POINTER], [hdc, hfont], ffi7.FFI_TYPE_POINTER);
         return 2;
       }
     }
@@ -16410,18 +17054,24 @@ function resolveCellStyle(columns, data, row, colIndex) {
   return style || void 0;
 }
 function makeLVItem(i, sub, text, image) {
-  const b = new ArrayBuffer(84);
-  const dv = new DataView(b);
-  dv.setInt32(4, i, true);
-  dv.setInt32(8, sub, true);
-  let mask = 1;
-  if (image !== void 0) {
-    mask |= 2;
-    dv.setInt32(36, image, true);
-  }
-  dv.setUint32(0, mask, true);
   const textBuf = textToUtf162(text);
-  dv.setBigUint64(24, BigInt(bufPtr2(textBuf)), true);
+  const b = LVITEMW.write({
+    mask: 1 | (image !== void 0 ? 2 : 0),
+    iItem: i,
+    iSubItem: sub,
+    state: 0,
+    stateMask: 0,
+    pszText: bufPtr2(textBuf),
+    cchTextMax: 0,
+    iImage: image ?? 0,
+    lParam: 0,
+    iIndent: 0,
+    iGroupId: 0,
+    cColumns: 0,
+    puColumns: 0,
+    piColFmt: 0,
+    iGroup: 0
+  });
   b.__textBuf = textBuf;
   return b;
 }
@@ -16474,13 +17124,19 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns, d
     const n = columns.length;
     for (let j = 0; j < n; j++) {
       const titleBuf = textToUtf162(columns[j].name);
-      const lvc = new ArrayBuffer(52);
-      const dv = new DataView(lvc);
-      dv.setUint32(0, 4 | 2 | 1, true);
-      dv.setInt32(4, alignToFmt(columns[j].align), true);
-      dv.setInt32(8, columns[j].width ?? 100, true);
-      dv.setBigUint64(16, BigInt(bufPtr2(titleBuf)), true);
-      dv.setInt32(28, j, true);
+      const lvc = LVCOLUMNW.write({
+        mask: 4 | 2 | 1,
+        fmt: alignToFmt(columns[j].align),
+        cx: columns[j].width ?? 100,
+        pszText: bufPtr2(titleBuf),
+        cchTextMax: 0,
+        iSubItem: j,
+        iImage: 0,
+        iOrder: 0,
+        cxMin: 0,
+        cxDefault: 0,
+        cxIdeal: 0
+      });
       lvc.__titleBuf = titleBuf;
       gui10.SendMessage(h, 4193, j, bufPtr2(lvc));
     }
@@ -16515,19 +17171,19 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns, d
   }, [data, columns, getIcon]);
   return (0, import_jsx_runtime8.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, ref, onEvent: (e) => {
     if (e.msg === 78) {
-      const code = readI323(e.lParam, NM_CODE);
+      const code = nmCode(e.lParam);
       if (code === -12) {
         return handleCustomDraw(e.lParam, columns, data, lvRef.current);
       }
       if (code === -100) {
-        const uNewState = readU32(e.lParam, 32);
-        const uOldState = readU32(e.lParam, 36);
+        const uNewState = readU32(e.lParam, NMLV_UNEW);
+        const uOldState = readU32(e.lParam, NMLV_UOLD);
         if ((uNewState & 2) !== (uOldState & 2))
           return 1;
       }
       if (code === -2) {
-        const iItem = readI323(e.lParam, NMIA_ITEM);
-        const iSubItem = readI323(e.lParam, NMIA_SUBITEM);
+        const iItem = readI32(e.lParam, NMIA_ITEM);
+        const iSubItem = readI32(e.lParam, NMIA_SUBITEM);
         const col = columns[iSubItem];
         const record = data[iItem];
         if (col?.onCellClick && record !== void 0)
@@ -16555,7 +17211,7 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns, d
     const sdv = new DataView(sbuf);
     sdv.setInt32(0, sp[0], true);
     sdv.setInt32(4, sp[1], true);
-    ffi5.ffiCall(screenToClient, [ffi5.FFI_TYPE_UINT64, ffi5.FFI_TYPE_POINTER], [h, sbuf], ffi5.FFI_TYPE_SINT32);
+    ffi7.ffiCall(screenToClient, [ffi7.FFI_TYPE_POINTER, ffi7.FFI_TYPE_POINTER], [h, sbuf], ffi7.FFI_TYPE_SINT32);
     const lvhi = new ArrayBuffer(24);
     const lvd = new DataView(lvhi);
     lvd.setInt32(0, sdv.getInt32(0, true), true);
@@ -16564,14 +17220,14 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns, d
     lvd.setInt32(16, -1, true);
     const lvhiPtr = bufPtr2(lvhi);
     gui10.SendMessage(h, 4153, 0, lvhiPtr);
-    const iItem = readI323(lvhiPtr, 12);
-    const iSubItem = readI323(lvhiPtr, 16);
+    const iItem = readI32(lvhiPtr, 12);
+    const iSubItem = readI32(lvhiPtr, 16);
     const style2 = resolveCellStyle(columns, data, iItem, iSubItem);
     if (!style2 || style2.cursor === void 0)
       return;
-    const hc = ffi5.ffiCall(loadCursorW, [ffi5.FFI_TYPE_UINT64, ffi5.FFI_TYPE_UINT64], [0, style2.cursor], ffi5.FFI_TYPE_UINT64);
+    const hc = ffi7.ffiCall(loadCursorW, [ffi7.FFI_TYPE_POINTER, ffi7.FFI_TYPE_POINTER], [0, style2.cursor], ffi7.FFI_TYPE_POINTER);
     if (hc) {
-      ffi5.ffiCall(setCursorFn, [ffi5.FFI_TYPE_UINT64], [hc], ffi5.FFI_TYPE_UINT64);
+      ffi7.ffiCall(setCursorFn, [ffi7.FFI_TYPE_POINTER], [hc], ffi7.FFI_TYPE_POINTER);
       return 1;
     }
     return;
@@ -16840,7 +17496,16 @@ var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 1
 var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
 var import_react14 = __toESM(require_react(), 1);
 import * as gui15 from "gui";
-import * as ffi6 from "ffi";
+import * as ffi8 from "ffi";
+var TCITEMW = struct({
+  mask: "u32",
+  dwState: "u32",
+  dwStateMask: "u32",
+  pszText: "ptr",
+  cchTextMax: "i32",
+  iImage: "i32",
+  lParam: "ptr"
+});
 function textToUtf163(s) {
   const buf = new ArrayBuffer((s.length + 1) * 2);
   const dv = new DataView(buf);
@@ -16848,9 +17513,6 @@ function textToUtf163(s) {
     dv.setUint16(i * 2, s.charCodeAt(i), true);
   return buf;
 }
-function readI324(ptr, offset) {
-  return ffi6.readByte(ptr + offset) | ffi6.readByte(ptr + offset + 1) << 8 | ffi6.readByte(ptr + offset + 2) << 16 | ffi6.readByte(ptr + offset + 3) << 24;
-}
 var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex, defaultSelectedIndex = 0, onChange, style }, ref) => {
   const [internalIndex, setInternalIndex] = (0, import_react14.useState)(defaultSelectedIndex);
   const isControlled = controlledIndex !== void 0;
@@ -16863,12 +17525,16 @@ var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex
     gui15.SendMessage(h, 4873, 0, 0);
     for (let i = 0; i < tabs.length; i++) {
       const titleBuf = textToUtf163(tabs[i].title);
-      const tci = new ArrayBuffer(40);
-      const dv = new DataView(tci);
-      dv.setUint32(0, 1, true);
-      dv.setBigUint64(16, BigInt(ffi6.bufferPtr(titleBuf)), true);
-      dv.setInt32(24, tabs[i].title.length + 1, true);
-      const tciPtr = ffi6.bufferPtr(tci);
+      const tci = TCITEMW.write({
+        mask: 1,
+        dwState: 0,
+        dwStateMask: 0,
+        pszText: ffi8.bufferPtr(titleBuf),
+        cchTextMax: tabs[i].title.length + 1,
+        iImage: 0,
+        lParam: 0
+      });
+      const tciPtr = ffi8.bufferPtr(tci);
       gui15.SendMessage(h, 4926, i, tciPtr);
     }
     gui15.SendMessage(h, 4876, sel, 0);
@@ -16883,7 +17549,7 @@ var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex
       const h = tabHwnd.current;
       if (!h)
         return;
-      const code = readI324(e.lParam, 16);
+      const code = nmCode(e.lParam);
       if (code === -552 || code === -2) {
         const newSel = gui15.SendMessage(h, 4875, 0, 0);
         if (newSel !== sel) {
@@ -16899,13 +17565,38 @@ var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex
 // _build/lib/react-qw/components/Tooltip.js
 var import_react15 = __toESM(require_react(), 1);
 import * as gui16 from "gui";
-import * as ffi7 from "ffi";
+import * as ffi9 from "ffi";
+var TTTOOLINFOW = struct({
+  cbSize: "u32",
+  uFlags: "u32",
+  hwnd: "ptr",
+  uId: "ptr",
+  rect: "i32[4]",
+  hinst: "ptr",
+  lpszText: "ptr",
+  lParam: "ptr",
+  lpReserved: "ptr"
+  // WinXP+ 追加字段（系统 sizeof 含之）
+});
 
 // _build/lib/react-qw/components/TreeView.js
 var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
 var import_react16 = __toESM(require_react(), 1);
 import * as gui17 from "gui";
-import * as ffi8 from "ffi";
+import * as ffi10 from "ffi";
+var TVITEM = struct({
+  mask: "u32",
+  hItem: "ptr",
+  state: "u32",
+  stateMask: "u32",
+  pszText: "ptr",
+  cchTextMax: "i32",
+  iImage: "i32",
+  iSelectedImage: "i32",
+  cChildren: "i32",
+  lParam: "ptr"
+});
+var TVINSERTSTRUCT = struct({ hParent: "ptr", hInsertAfter: "ptr", item: TVITEM });
 function textToUtf164(s) {
   const buf = new ArrayBuffer((s.length + 1) * 2);
   const dv = new DataView(buf);
@@ -16913,50 +17604,33 @@ function textToUtf164(s) {
     dv.setUint16(i * 2, s.charCodeAt(i), true);
   return buf;
 }
-function readI325(ptr, offset) {
-  return ffi8.readByte(ptr + offset) | ffi8.readByte(ptr + offset + 1) << 8 | ffi8.readByte(ptr + offset + 2) << 16 | ffi8.readByte(ptr + offset + 3) << 24;
-}
 function bufPtr3(buf) {
-  return ffi8.bufferPtr(buf);
-}
-function setPtr(dv, offset, ptr) {
-  dv.setUint32(offset, ptr & 4294967295, true);
-  dv.setUint32(offset + 4, Math.floor(ptr / 4294967296), true);
+  return ffi10.bufferPtr(buf);
 }
 function buildTvItem(textPtr, cChildren) {
   let mask = 1;
   if (cChildren > 0)
     mask |= 64;
-  const buf = new ArrayBuffer(56);
-  const dv = new DataView(buf);
-  dv.setUint32(0, mask, true);
-  setPtr(dv, 8, 0);
-  dv.setUint32(16, 0, true);
-  dv.setUint32(20, 0, true);
-  setPtr(dv, 24, textPtr);
-  dv.setInt32(32, 260, true);
-  dv.setInt32(36, 0, true);
-  dv.setInt32(40, 0, true);
-  dv.setInt32(44, cChildren, true);
-  setPtr(dv, 48, 0);
-  return buf;
-}
-function buildTvInsertStruct(hParent, hInsertAfter, itemBuf) {
-  const buf = new ArrayBuffer(72);
-  const dv = new DataView(buf);
-  setPtr(dv, 0, hParent);
-  setPtr(dv, 8, hInsertAfter);
-  const src = new DataView(itemBuf);
-  for (let i = 0; i < 56; i += 4)
-    dv.setUint32(16 + i, src.getUint32(i, true), true);
-  return buf;
+  return TVITEM.write({
+    mask,
+    hItem: 0,
+    state: 0,
+    stateMask: 0,
+    pszText: textPtr,
+    cchTextMax: 260,
+    iImage: 0,
+    iSelectedImage: 0,
+    cChildren,
+    lParam: 0
+  });
 }
 function insertItems(hTree, nodes, parentHandle, hItemMap, keyMap) {
   for (const node of nodes) {
     const cChildren = node.children && node.children.length > 0 ? 1 : 0;
     const textBuf = textToUtf164(node.label);
     const itemBuf = buildTvItem(bufPtr3(textBuf), cChildren);
-    const tvins = buildTvInsertStruct(parentHandle, -65536, itemBuf);
+    const item = TVITEM.read(itemBuf);
+    const tvins = TVINSERTSTRUCT.write({ hParent: parentHandle, hInsertAfter: -65536, item });
     const hItem = gui17.SendMessage(hTree, 4402, 0, bufPtr3(tvins));
     hItemMap.set(hItem, node);
     if (node.key)
@@ -17022,7 +17696,7 @@ var TreeView = (0, import_react16.forwardRef)(function TreeViewInner({ data, onS
   }, [selKey]);
   return (0, import_jsx_runtime14.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, ref, onEvent: (e) => {
     if (e.msg === 78) {
-      const code = readI325(e.lParam, 16);
+      const code = nmCode(e.lParam);
       if (code === -451) {
         const h = tvRef.current;
         if (!h)
@@ -17043,10 +17717,49 @@ var TreeView = (0, import_react16.forwardRef)(function TreeViewInner({ data, onS
 // _build/lib/react-qw/components/PathPicker.js
 var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
 var import_react17 = __toESM(require_react(), 1);
-import * as ffi9 from "ffi";
+import * as ffi11 from "ffi";
 import * as win3 from "win";
-var FFI_PTR2 = ffi9.FFI_TYPE_POINTER;
-var FFI_U32 = ffi9.FFI_TYPE_UINT32;
+
+// _build/lib/win-common-structs.js
+var OPENFILENAMEW = struct({
+  lStructSize: "u32",
+  hwndOwner: "ptr",
+  hInstance: "ptr",
+  lpstrFilter: "ptr",
+  lpstrCustomFilter: "ptr",
+  nMaxCustFilter: "u32",
+  nFilterIndex: "u32",
+  lpstrFile: "ptr",
+  nMaxFile: "u32",
+  lpstrFileTitle: "ptr",
+  nMaxFileTitle: "u32",
+  lpstrInitialDir: "ptr",
+  lpstrTitle: "ptr",
+  Flags: "u32",
+  nFileOffset: "u16",
+  nFileExtension: "u16",
+  lpstrDefExt: "ptr",
+  lCustData: "ptr",
+  lpfnHook: "ptr",
+  lpTemplateName: "ptr",
+  pvReserved: "ptr",
+  dwReserved: "u32",
+  FlagsEx: "u32"
+});
+var BROWSEINFOW = struct({
+  hwndOwner: "ptr",
+  pidlRoot: "ptr",
+  pszDisplayName: "ptr",
+  lpszTitle: "ptr",
+  ulFlags: "u32",
+  lpfn: "ptr",
+  lParam: "ptr",
+  iImage: "i32"
+});
+
+// _build/lib/react-qw/components/PathPicker.js
+var FFI_PTR = ffi11.FFI_TYPE_POINTER;
+var FFI_U32 = ffi11.FFI_TYPE_UINT32;
 var _GetOpenFileNameW = 0;
 var _SHBrowseForFolderW = 0;
 var _SHGetPathFromIDListW = 0;
@@ -17075,31 +17788,42 @@ function wideToStr(buf, offset = 0) {
   const nullIdx = str.indexOf("\0");
   return nullIdx >= 0 ? str.substring(0, nullIdx) : str;
 }
-function setPtr2(dv, off, ptr) {
-  dv.setUint32(off, ptr & 4294967295, true);
-  dv.setUint32(off + 4, Math.floor(ptr / 4294967296), true);
-}
 function openFileDialog(owner, filter, title, multiple) {
   if (!ensureDlls())
     return null;
-  const structBuf = new ArrayBuffer(152);
-  const sv = new DataView(structBuf);
   const fileBuf = new ArrayBuffer(260 * 2);
   const filterWide = strToWide(filter);
   const titleWide = title ? strToWide(title) : null;
-  sv.setUint32(0, 152, true);
-  setPtr2(sv, 8, owner);
-  setPtr2(sv, 24, ffi9.bufferPtr(filterWide));
-  setPtr2(sv, 48, ffi9.bufferPtr(fileBuf));
-  sv.setUint32(56, 260, true);
   let flags = 4096 | 2048 | 8;
   if (multiple)
     flags |= 512;
   flags |= 524288;
-  sv.setUint32(96, flags, true);
-  if (titleWide)
-    setPtr2(sv, 88, ffi9.bufferPtr(titleWide));
-  const ret = ffi9.ffiCall(_GetOpenFileNameW, [FFI_PTR2], [structBuf], FFI_U32);
+  const ofn = OPENFILENAMEW.write({
+    lStructSize: OPENFILENAMEW.size,
+    hwndOwner: owner,
+    hInstance: 0,
+    lpstrFilter: ffi11.bufferPtr(filterWide),
+    lpstrCustomFilter: 0,
+    nMaxCustFilter: 0,
+    nFilterIndex: 0,
+    lpstrFile: ffi11.bufferPtr(fileBuf),
+    nMaxFile: 260,
+    lpstrFileTitle: 0,
+    nMaxFileTitle: 0,
+    lpstrInitialDir: 0,
+    lpstrTitle: titleWide ? ffi11.bufferPtr(titleWide) : 0,
+    Flags: flags,
+    nFileOffset: 0,
+    nFileExtension: 0,
+    lpstrDefExt: 0,
+    lCustData: 0,
+    lpfnHook: 0,
+    lpTemplateName: 0,
+    pvReserved: 0,
+    dwReserved: 0,
+    FlagsEx: 0
+  });
+  const ret = ffi11.ffiCall(_GetOpenFileNameW, [FFI_PTR], [ofn], FFI_U32);
   if (!ret)
     return null;
   if (!multiple) {
@@ -17122,19 +17846,23 @@ function openFileDialog(owner, filter, title, multiple) {
 function openFolderDialog(owner, title) {
   if (!ensureDlls())
     return null;
-  const structBuf = new ArrayBuffer(64);
-  const sv = new DataView(structBuf);
   const titleWide = title ? strToWide(title) : null;
-  setPtr2(sv, 0, owner);
-  if (titleWide)
-    setPtr2(sv, 24, ffi9.bufferPtr(titleWide));
-  sv.setUint32(32, 65, true);
-  const pidl = ffi9.ffiCall(_SHBrowseForFolderW, [FFI_PTR2], [structBuf], FFI_PTR2);
+  const bi = BROWSEINFOW.write({
+    hwndOwner: owner,
+    pidlRoot: 0,
+    pszDisplayName: 0,
+    lpszTitle: titleWide ? ffi11.bufferPtr(titleWide) : 0,
+    ulFlags: 65,
+    lpfn: 0,
+    lParam: 0,
+    iImage: 0
+  });
+  const pidl = ffi11.ffiCall(_SHBrowseForFolderW, [FFI_PTR], [bi], FFI_PTR);
   if (!pidl)
     return null;
   const pathBuf = new ArrayBuffer(260 * 2);
-  const ok = ffi9.ffiCall(_SHGetPathFromIDListW, [ffi9.FFI_TYPE_UINT64, FFI_PTR2], [pidl, pathBuf], FFI_U32);
-  ffi9.ffiCall(_CoTaskMemFree, [ffi9.FFI_TYPE_UINT64], [pidl], ffi9.FFI_TYPE_VOID);
+  const ok = ffi11.ffiCall(_SHGetPathFromIDListW, [ffi11.FFI_TYPE_POINTER, FFI_PTR], [pidl, pathBuf], FFI_U32);
+  ffi11.ffiCall(_CoTaskMemFree, [ffi11.FFI_TYPE_POINTER], [pidl], ffi11.FFI_TYPE_VOID);
   return ok ? wideToStr(pathBuf) : null;
 }
 var PathPicker = (0, import_react17.forwardRef)((props, ref) => {