quickwin 1.2.1 → 2.0.0

package/examples/pdf_viewer.js

@@ -1367,9 +1367,9 @@ var require_scheduler_development = __commonJS({
         }
         return first;
       }
-      function compare(a, b) {
-        var diff = a.sortIndex - b.sortIndex;
-        return 0 !== diff ? diff : a.id - b.id;
+      function compare(a, b6) {
+        var diff = a.sortIndex - b6.sortIndex;
+        return 0 !== diff ? diff : a.id - b6.id;
       }
       function advanceTimers(currentTime) {
         for (var timer = peek(timerQueue); null !== timer; ) {
@@ -1667,14 +1667,14 @@ var require_react_reconciler_development = __commonJS({
             throw Error("Unable to find node on an unmounted component.");
           return alternate !== fiber ? null : fiber;
         }
-        for (var a = fiber, b = alternate; ; ) {
+        for (var a = fiber, b6 = alternate; ; ) {
           var parentA = a.return;
           if (null === parentA) break;
           var parentB = parentA.alternate;
           if (null === parentB) {
-            b = parentA.return;
-            if (null !== b) {
-              a = b;
+            b6 = parentA.return;
+            if (null !== b6) {
+              a = b6;
               continue;
             }
             break;
@@ -1682,23 +1682,23 @@ var require_react_reconciler_development = __commonJS({
           if (parentA.child === parentB.child) {
             for (parentB = parentA.child; parentB; ) {
               if (parentB === a) return assertIsMounted(parentA), fiber;
-              if (parentB === b) return assertIsMounted(parentA), alternate;
+              if (parentB === b6) return assertIsMounted(parentA), alternate;
               parentB = parentB.sibling;
             }
             throw Error("Unable to find node on an unmounted component.");
           }
-          if (a.return !== b.return) a = parentA, b = parentB;
+          if (a.return !== b6.return) a = parentA, b6 = parentB;
           else {
             for (var didFindChild = false, _child = parentA.child; _child; ) {
               if (_child === a) {
                 didFindChild = true;
                 a = parentA;
-                b = parentB;
+                b6 = parentB;
                 break;
               }
-              if (_child === b) {
+              if (_child === b6) {
                 didFindChild = true;
-                b = parentA;
+                b6 = parentA;
                 a = parentB;
                 break;
               }
@@ -1709,12 +1709,12 @@ var require_react_reconciler_development = __commonJS({
                 if (_child === a) {
                   didFindChild = true;
                   a = parentB;
-                  b = parentA;
+                  b6 = parentA;
                   break;
                 }
-                if (_child === b) {
+                if (_child === b6) {
                   didFindChild = true;
-                  b = parentB;
+                  b6 = parentB;
                   a = parentA;
                   break;
                 }
@@ -1726,7 +1726,7 @@ var require_react_reconciler_development = __commonJS({
                 );
             }
           }
-          if (a.alternate !== b)
+          if (a.alternate !== b6)
             throw Error(
               "Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."
             );
@@ -15071,10 +15071,10 @@ var require_react_reconciler_development = __commonJS({
           setCurrentUpdatePriority(previousPriority), ReactSharedInternals.T = prevTransition;
         }
       };
-      exports2.discreteUpdates = function(fn, a, b, c, d) {
+      exports2.discreteUpdates = function(fn, a, b6, c, d) {
         var prevTransition = ReactSharedInternals.T, previousPriority = getCurrentUpdatePriority();
         try {
-          return setCurrentUpdatePriority(2), ReactSharedInternals.T = null, fn(a, b, c, d);
+          return setCurrentUpdatePriority(2), ReactSharedInternals.T = null, fn(a, b6, c, d);
         } finally {
           setCurrentUpdatePriority(previousPriority), ReactSharedInternals.T = prevTransition, executionContext === NoContext && (workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS);
         }
@@ -15355,28 +15355,1184 @@ var require_constants = __commonJS({
 
 // _build/examples/pdf_viewer.js
 var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
+
+// _build/lib/ffi/ctype.js
+import { bufferPtr } from "ffi";
+import * as os from "os";
+var C_BASIC_TYPE = [
+  "void",
+  "u8",
+  "i8",
+  "u16",
+  "i16",
+  "u32",
+  "i32",
+  "u64",
+  "i64",
+  "f32",
+  "f64",
+  "ptr"
+];
+var PTR_TOKEN_RE = /^<([^<>\s]*)>ptr(!|@[A-Za-z_]\w*)?$/;
+function isCPtrToken(t) {
+  return PTR_TOKEN_RE.test(t);
+}
+function ptrName(t) {
+  const m = PTR_TOKEN_RE.exec(t);
+  return m?.[1] || "";
+}
+var cTokenToType = (t) => {
+  if (isCPtrToken(t))
+    return "ptr";
+  else
+    return t;
+};
+var PTR_SIZE = os.arch === "x64" ? 8 : 4;
+var SizeAlign = {
+  u8: 1,
+  i8: 1,
+  u16: 2,
+  i16: 2,
+  u32: 4,
+  i32: 4,
+  u64: 8,
+  i64: 8,
+  f32: 4,
+  f64: 8
+};
+var NULL = 0;
+function normToken(t) {
+  if (isCPtrToken(t)) {
+    const m = PTR_TOKEN_RE.exec(t);
+    return m?.[2]?.startsWith("@") ? `<${m[1]}>ptr` : t;
+  }
+  const at = t.indexOf("@");
+  const base = at >= 0 ? t.slice(0, at) : t;
+  const suffixOk = at < 0 || /^[A-Za-z_]\w*$/.test(t.slice(at + 1));
+  if (suffixOk && base !== "ptr" && C_BASIC_TYPE.includes(base))
+    return base;
+  throw new Error("Unknown token: " + t);
+}
+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 dv.getBigUint64(off, true);
+    case "i64":
+      return dv.getBigInt64(off, true);
+    case "f32":
+      return dv.getFloat32(off, true);
+    case "f64":
+      return dv.getFloat64(off, true);
+    case "ptr": {
+      return PTR_SIZE === 8 ? Number(dv.getBigInt64(off, true)) : dv.getInt32(off, true);
+    }
+  }
+}
+function writeScalar(dv, off, { k, v }) {
+  switch (k) {
+    case "u8":
+      dv.setUint8(off, Number(v));
+      break;
+    case "i8":
+      dv.setInt8(off, Number(v));
+      break;
+    case "u16":
+      dv.setUint16(off, Number(v), true);
+      break;
+    case "i16":
+      dv.setInt16(off, Number(v), true);
+      break;
+    case "u32":
+      dv.setUint32(off, v >>> 0, true);
+      break;
+    case "i32":
+      dv.setUint32(off, v >>> 0, true);
+      break;
+    case "u64":
+      dv.setBigUint64(off, v, true);
+      break;
+    case "i64":
+      dv.setBigInt64(off, v, true);
+      break;
+    case "f32":
+      dv.setFloat32(off, v, true);
+      break;
+    case "f64":
+      dv.setFloat64(off, v, true);
+      break;
+    case "ptr": {
+      if (v == null) {
+        throw new Error("ffi: got null/undefined for a ptr slot; pass the imported NULL constant for empty");
+      }
+      if (PTR_SIZE === 8)
+        dv.setBigUint64(off, BigInt.asUintN(64, BigInt(v)), true);
+      else
+        dv.setUint32(off, v >>> 0, true);
+      break;
+    }
+  }
+}
+function writeSlot(dv, off, e) {
+  const { k, v } = e;
+  if (k === "u8" || k === "i8" || k === "u16" || k === "i16") {
+    dv.setUint32(off, Number(v) >>> 0, true);
+    return;
+  }
+  writeScalar(dv, off, e);
+}
+var PtrArrayBuffer = class extends ArrayBuffer {
+  ptr;
+  constructor(byteLength) {
+    super(byteLength);
+    this.ptr = bufferPtr(this);
+  }
+};
+
+// _build/examples/pdf_viewer.js
 var import_react19 = __toESM(require_react(), 1);
 import "../lib/polyfill.js";
-import * as std from "std";
-import * as gui19 from "gui";
-import * as win5 from "win";
-import * as ffi11 from "ffi";
+import * as std2 from "std";
+import * as gui18 from "gui";
 
 // _build/lib/react-qw/index.js
-import * as gui18 from "gui";
+import * as gui17 from "gui";
+
+// _build/lib/windows/user32.js
+import * as os3 from "os";
+
+// _build/lib/ffi/bind.js
+import * as ffi from "ffi";
+import * as os2 from "os";
+import * as std from "std";
+import * as win from "win";
+
+// _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 b6 = buf[i++];
+    if (b6 < 128) {
+      out += String.fromCharCode(b6);
+      continue;
+    }
+    if (b6 < 192) {
+      out += fatal ? (() => {
+        throw new TypeError("unexpected continuation byte");
+      })() : "\uFFFD";
+      continue;
+    }
+    let c, min;
+    if (b6 < 224) {
+      if (i >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b22 = buf[i++];
+      if ((b22 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c = (b6 & 31) << 6 | b22 & 63;
+      min = 128;
+    } else if (b6 < 240) {
+      if (i + 1 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b22 = buf[i++];
+      const b32 = buf[i++];
+      if ((b22 & 192) !== 128 || (b32 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c = (b6 & 15) << 12 | (b22 & 63) << 6 | b32 & 63;
+      min = 2048;
+    } else if (b6 < 248) {
+      if (i + 2 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b22 = buf[i++];
+      const b32 = buf[i++];
+      const b42 = buf[i++];
+      if ((b22 & 192) !== 128 || (b32 & 192) !== 128 || (b42 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c = (b6 & 7) << 18 | (b22 & 63) << 12 | (b32 & 63) << 6 | b42 & 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;
+}
+if (typeof globalThis.TextEncoder === "undefined") {
+  globalThis.TextEncoder = TextEncoderImpl;
+}
+
+// _build/lib/ffi/bind.js
+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(" -> ");
+  if (parts.length !== 2) {
+    throw new Error(`ffi-bind: invalid signature "${sig}" (expected "arg1 arg2 -> ret")`);
+  }
+  const rawArgs = parts[0].split(" ").filter((t) => t !== "");
+  const argTokens = [];
+  for (const raw of rawArgs) {
+    const tok = normToken(raw);
+    if (tok === "void") {
+      throw new Error("Void can not in args");
+    }
+    argTokens.push(tok);
+  }
+  return {
+    argTokens,
+    retToken: normToken(parts[1]),
+    sig
+  };
+}
+function makeFn(proc, sig, encoders, decoders) {
+  const ps = parseSig(sig);
+  return (...a) => callPacked(proc, ps, a, encoders, decoders);
+}
+var IA32_ARG_SIZE = {
+  u8: 4,
+  i8: 4,
+  u16: 4,
+  i16: 4,
+  u32: 4,
+  i32: 4,
+  u64: 8,
+  i64: 8,
+  f32: 4,
+  f64: 8,
+  ptr: PTR_SIZE
+};
+var X64_MIN_SLOTS = 4;
+function callPacked(proc, { argTokens, retToken, sig }, args, encoders, decoders) {
+  const is64 = os2.arch === "x64";
+  const getWidth = (t, is642) => {
+    if (is642)
+      return 8;
+    if (isCPtrToken(t))
+      return PTR_SIZE;
+    return IA32_ARG_SIZE[t];
+  };
+  let total = 0;
+  for (const t of argTokens)
+    total += getWidth(t, is64);
+  if (is64 && argTokens.length < X64_MIN_SLOTS)
+    total = X64_MIN_SLOTS * 8;
+  const argFrame = new ArrayBuffer(total);
+  const dv = new DataView(argFrame);
+  const held = [];
+  let off = 0;
+  for (let i = 0; i < argTokens.length; i++) {
+    const argToken = argTokens[i];
+    const nonnull = argToken.endsWith("!");
+    const arg = args[i];
+    if (isCPtrToken(argToken)) {
+      const name = ptrName(argToken);
+      if (typeof arg === "number") {
+        if (nonnull && arg === 0)
+          throw new Error(`ffi-bind: ${sig}: arg#${i + 1} <${name}>ptr! got 0 (null pointer forbidden here; the token marks this position non-null)`);
+        writeSlot(dv, off, { k: "ptr", v: arg });
+      } else {
+        if (arg === null || arg === void 0) {
+          throw new Error(`ffi-bind: <${name}>ptr got ${String(arg)}; pass the imported NULL constant for an empty pointer`);
+        }
+        const codec = encoders[name];
+        if (!codec) {
+          throw new Error(name === "" ? `ffi-bind: <>ptr expects number (NULL | Ptr), got ${typeof arg}; use <BYTE>ptr with a PtrArrayBuffer (new PtrArrayBuffer(n)), or ffi.bufferPtr(buf) for an address` : `ffi-bind: unknown layout "<${name}>ptr" (available: ${Object.keys(encoders).join(", ") || "none"})`);
+        }
+        if (!codec.encode) {
+          throw new Error(`ffi-bind: <${name}>ptr has no encoder (out-only codec)`);
+        }
+        const buf = codec.encode(arg);
+        held.push(buf);
+        const p = buf.ptr;
+        if (typeof p !== "number")
+          throw new Error("ffi-bind: codec.encode must return a PtrArrayBuffer, got plain ArrayBuffer");
+        if (nonnull && p === 0)
+          throw new Error(`ffi-bind: ${sig}: arg#${i + 1} <${name}>ptr! encode produced 0 (null pointer forbidden here)`);
+        writeSlot(dv, off, { k: "ptr", v: p });
+      }
+    } else {
+      writeSlot(dv, off, { k: argToken, v: arg });
+    }
+    off += getWidth(argToken, is64);
+  }
+  const retBuf = new ArrayBuffer(8);
+  const retIsFp = retToken === "f32" || retToken === "f64";
+  ffi.ffiCall(proc, argFrame, retBuf, retIsFp ? 1 : 0);
+  const raw = readRet(cTokenToType(retToken), retBuf);
+  if (retToken.endsWith("!") && raw === 0)
+    throw new Error(`ffi-bind: ${sig}: return ${retToken} got 0 (the token promises C never returns null here)`);
+  if (isCPtrToken(retToken) && raw !== 0) {
+    const name = ptrName(retToken);
+    if (name !== "") {
+      const codec = decoders[name];
+      if (codec?.decode)
+        return codec.decode(raw);
+    }
+  }
+  return raw;
+}
+function readRet(ret, retBuf) {
+  if (ret === "void")
+    return void 0;
+  return readScalar(new DataView(retBuf), 0, ret);
+}
+var WCHAR = {
+  encode: (v) => {
+    const u8 = new TextEncoder("utf-16le").encode(v + "\0");
+    const out = new PtrArrayBuffer(u8.byteLength);
+    new Uint8Array(out).set(u8);
+    return out;
+  },
+  decode: (p) => {
+    if (typeof p === "number") {
+      let s2 = "";
+      let addr = p;
+      const start = addr;
+      for (; ; ) {
+        const lo = ffi.readByte(addr);
+        const hi = ffi.readByte(addr + 1);
+        if (lo === 0 && hi === 0)
+          return s2;
+        s2 += String.fromCharCode(lo | hi << 8);
+        addr += 2;
+        if (addr - start > 1 << 21) {
+          throw new Error("ffi-bind: WCHAR decode exceeded 4MiB without NUL");
+        }
+      }
+    }
+    const u8 = new Uint8Array(p);
+    const limit = u8.length & ~1;
+    let s = "";
+    for (let i = 0; i < limit; i += 2) {
+      const c = u8[i] | u8[i + 1] << 8;
+      if (c === 0)
+        return s;
+      s += String.fromCharCode(c);
+    }
+    return s;
+  },
+  alloc: (size = 256) => new PtrArrayBuffer(size * 2)
+};
+var BYTE = {
+  encode: (v) => {
+    if (!(v instanceof PtrArrayBuffer))
+      throw new Error("ffi-bind: <BYTE>ptr wants a PtrArrayBuffer (new PtrArrayBuffer(n) / BYTE.alloc / struct.encode), not a plain ArrayBuffer");
+    return v;
+  },
+  alloc: (byteLen) => new PtrArrayBuffer(byteLen)
+};
+var builtinCodecs = { WCHAR, BYTE };
+function bind(dll, name, sig, encoders, decoders) {
+  const proc = win.GetProcAddress(loadDll(dll), name);
+  if (!proc)
+    throw new Error(`ffi-bind: proc "${name}" not found in ${dll}`);
+  const effDec = decoders ?? encoders;
+  return makeFn(proc, sig, { ...builtinCodecs, ...encoders }, { ...builtinCodecs, ...effDec ?? {} });
+}
+var leakRegistry = new FinalizationRegistry((held) => {
+  std.printf('[ffi] closure leaked (GCed without dispose): sig="%s" ptr=0x%x\n', held.sig, held.ptr);
+});
+
+// _build/lib/ffi/struct.js
+import * as ffi2 from "ffi";
+function alignUp(v, a) {
+  return v + a - 1 & ~(a - 1);
+}
+var isCNumberToken = (t) => SizeAlign[t] !== void 0;
+function lower(v) {
+  if (typeof v === "string") {
+    const st = /^(u8|u16)\[(\d+)\]@(utf-8|utf-16le)$/.exec(v);
+    if (st) {
+      const length = Number(st[2]);
+      if (!Number.isInteger(length) || length < 1)
+        throw new Error(`ffi-struct: string length must be an integer >= 1, got ${length}`);
+      const s2 = st[1] === "u8" ? 1 : 2;
+      return { size: s2 * length, align: s2, type: { tag: "string", encoding: st[3] } };
+    }
+    const a = /^([^\[\]]+)\[(\d+)\]$/.exec(v);
+    if (a) {
+      const length = Number(a[2]);
+      if (!Number.isInteger(length) || length < 1)
+        throw new Error(`ffi-struct: array length must be an integer >= 1, got ${length}`);
+      const el = lower(a[1]);
+      if (el.type.tag === "bitfield")
+        throw new Error("ffi-struct: bitfields cannot be array elements");
+      return {
+        size: el.size * length,
+        align: el.align,
+        type: { tag: "array", elementType: el.type, elementSize: el.size }
+      };
+    }
+    const b6 = /^([A-Za-z_]\w*):(\d+)$/.exec(v);
+    if (b6) {
+      const rawUnit = b6[1];
+      const unit = normToken(rawUnit);
+      if (!isCNumberToken(unit) || unit === "f32" || unit === "f64")
+        throw new Error(`ffi-struct: bitfield unit must be an integer type, got "${rawUnit}"`);
+      const width = Number(b6[2]);
+      const s2 = SizeAlign[unit];
+      const cap = s2 * 8;
+      if (!Number.isInteger(width) || width < 1)
+        throw new Error(`ffi-struct: bitfield width must be an integer >= 1, got ${width}`);
+      if (width > cap)
+        throw new Error(`ffi-struct: bitfield width ${width} exceeds unit width ${cap}`);
+      return { size: s2, align: s2, type: { tag: "bitfield", unit, bit: 0, width } };
+    }
+    const k = normToken(v);
+    if (isCPtrToken(k))
+      return { size: PTR_SIZE, align: PTR_SIZE, type: { tag: "basic", kind: "ptr" } };
+    if (!isCNumberToken(k))
+      throw new Error(`ffi-struct: unknown kind "${v}"`);
+    const s = SizeAlign[k];
+    return { size: s, align: s, type: { tag: "basic", kind: k } };
+  }
+  if (v && typeof v === "object") {
+    const o = v;
+    const tag = o["#"];
+    if (tag === void 0)
+      throw new Error(`ffi-struct: nested object value requires a '#' key ('struct' | 'union' | 'array')`);
+    if (tag === "array" && "#pack" in o)
+      throw new Error(`ffi-struct: '#pack' is only allowed on struct/union, got '${tag}'`);
+    if (tag === "array") {
+      const length = o["length"];
+      if (!Number.isInteger(length) || length < 1)
+        throw new Error(`ffi-struct: array length must be an integer >= 1, got ${String(length)}`);
+      const el = lower(o["element"]);
+      if (el.type.tag === "bitfield")
+        throw new Error("ffi-struct: bitfields cannot be array elements");
+      return {
+        size: el.size * length,
+        align: el.align,
+        type: { tag: "array", elementType: el.type, elementSize: el.size }
+      };
+    }
+    if (tag === "struct" || tag === "union") {
+      const l = computeStructLayout(v);
+      return { size: l.size, align: l.maxEffectiveAlign, type: { tag, fields: l.fields } };
+    }
+    throw new Error(`ffi-struct: unknown '#' declaration ${JSON.stringify(String(tag))}`);
+  }
+  throw new Error(`ffi-struct: invalid member value: ${String(v)}`);
+}
+function computeStructLayout(t) {
+  const isStruct = t["#"] === "struct";
+  const pack = t["#pack"] ?? 8;
+  let maxEffectiveAlign = 1;
+  let maxMemberSize = 0;
+  const fields = [];
+  let cursor = 0;
+  let unitBase = -1;
+  let unitBits = 0;
+  let unitSize = 0;
+  const flushUnit = () => {
+    if (unitBase < 0)
+      return;
+    cursor = alignUp(unitBase + Math.ceil(unitBits / 8), unitSize);
+    unitBase = -1;
+  };
+  for (const [rawName, v] of Object.entries(t)) {
+    if (rawName.startsWith("#"))
+      continue;
+    const m = /^([^@]+)@(\d+)$/.exec(rawName);
+    const name = m ? m[1] : rawName;
+    const alignas = m ? Number(m[2]) : 0;
+    const { size, align: natural, type } = lower(v);
+    const nonnull = typeof v === "string" && v.endsWith("!");
+    let align = natural;
+    if (pack > 0)
+      align = Math.min(pack, align);
+    if (alignas)
+      align = Math.max(align, alignas);
+    if (type.tag === "bitfield") {
+      if (name.startsWith("$"))
+        throw new Error("ffi-struct: bitfield members must be named");
+      if (!isStruct) {
+        fields.push({ name, offset: 0, size, type: { ...type, bit: 0 } });
+        maxEffectiveAlign = Math.max(maxEffectiveAlign, align);
+        maxMemberSize = Math.max(maxMemberSize, size);
+        continue;
+      }
+      const width = type.width;
+      if (unitBase < 0 || size !== unitSize || unitBits + width > unitSize * 8) {
+        if (unitBase >= 0)
+          flushUnit();
+        const offset2 = alignUp(cursor, align);
+        unitBase = offset2;
+        unitBits = 0;
+        unitSize = size;
+      }
+      fields.push({
+        name,
+        offset: unitBase,
+        // 单元基址（不是位域自己的地址）
+        size,
+        type: { ...type, bit: unitBits }
+      });
+      unitBits += width;
+      maxEffectiveAlign = Math.max(maxEffectiveAlign, align);
+      maxMemberSize = Math.max(maxMemberSize, size);
+      continue;
+    }
+    flushUnit();
+    const offset = alignUp(cursor, align);
+    if (!name.startsWith("$")) {
+      fields.push({ name, offset, size, type, ...nonnull ? { nonnull: true } : {} });
+    } else {
+      if (type.tag !== "struct" && type.tag !== "union")
+        throw new Error(`ffi-struct: anonymous member "${name}" must be a struct/union`);
+      for (const cf of type.fields)
+        fields.push({ ...cf, offset: cf.offset + offset });
+    }
+    if (isStruct)
+      cursor = offset + size;
+    maxEffectiveAlign = Math.max(maxEffectiveAlign, align);
+    maxMemberSize = Math.max(maxMemberSize, size);
+  }
+  flushUnit();
+  return {
+    size: isStruct ? alignUp(cursor, maxEffectiveAlign) : alignUp(maxMemberSize, maxEffectiveAlign),
+    maxEffectiveAlign,
+    fields
+  };
+}
+function readUnitRaw(dv, off, unit) {
+  const s = SizeAlign[unit];
+  if (s === 1)
+    return BigInt(dv.getUint8(off));
+  if (s === 2)
+    return BigInt(dv.getUint16(off, true));
+  if (s === 4)
+    return BigInt(dv.getUint32(off, true));
+  return dv.getBigUint64(off, true);
+}
+function writeUnitRaw(dv, off, unit, v) {
+  const s = SizeAlign[unit];
+  if (s === 1) {
+    dv.setUint8(off, Number(v & 0xffn));
+    return;
+  }
+  if (s === 2) {
+    dv.setUint16(off, Number(v & 0xffffn), true);
+    return;
+  }
+  if (s === 4) {
+    dv.setUint32(off, Number(v & 0xffffffffn), true);
+    return;
+  }
+  dv.setBigUint64(off, v & 0xffffffffffffffffn, true);
+}
+function readBitfield(dv, off, t) {
+  const w = BigInt(t.width);
+  let v = readUnitRaw(dv, off, t.unit) >> BigInt(t.bit) & (1n << w) - 1n;
+  if (t.unit[0] === "i" && v & 1n << w - 1n)
+    v -= 1n << w;
+  if (t.width > 53)
+    return v;
+  return Number(v);
+}
+function writeBitfield(dv, off, t, val) {
+  const w = BigInt(t.width);
+  const bit = BigInt(t.bit);
+  const widthMask = (1n << w) - 1n;
+  const posMask = widthMask << bit;
+  const raw = readUnitRaw(dv, off, t.unit);
+  const bits = (typeof val === "bigint" ? val : BigInt(Math.trunc(val))) & widthMask;
+  writeUnitRaw(dv, off, t.unit, raw & ~posMask | bits << bit);
+}
+var stringEncoders = {
+  "utf-8": new TextEncoder("utf-8"),
+  "utf-16le": new TextEncoder("utf-16le")
+};
+var stringDecoders = {
+  "utf-8": new TextDecoder("utf-8", { ignoreBOM: true }),
+  "utf-16le": new TextDecoder("utf-16le", { ignoreBOM: true })
+};
+function readString(dv, off, size, enc) {
+  const bytes = new Uint8Array(dv.buffer, dv.byteOffset + off, size);
+  const unit = enc === "utf-16le" ? 2 : 1;
+  let end = size;
+  for (let i = 0; i + unit <= size; i += unit) {
+    if (bytes[i] === 0 && (unit === 1 || bytes[i + 1] === 0)) {
+      end = i;
+      break;
+    }
+  }
+  return stringDecoders[enc].decode(bytes.subarray(0, end));
+}
+function writeString(dv, off, size, enc, v) {
+  const bytes = new Uint8Array(dv.buffer, dv.byteOffset + off, size);
+  bytes.fill(0);
+  const unit = enc === "utf-16le" ? 2 : 1;
+  const cap = size - unit;
+  if (cap <= 0)
+    return;
+  const src = stringEncoders[enc].encode(String(v ?? ""));
+  bytes.set(src.subarray(0, Math.min(src.length, cap)));
+}
+function readArray(dv, off, size, t) {
+  const count = t.elementSize > 0 ? size / t.elementSize : 0;
+  const out = [];
+  for (let i = 0; i < count; i++)
+    out.push(readElement(dv, off + i * t.elementSize, t.elementType, t.elementSize));
+  return out;
+}
+function writeArray(dv, off, size, t, v) {
+  const count = t.elementSize > 0 ? size / t.elementSize : 0;
+  const list = v ?? [];
+  for (let i = 0; i < count; i++)
+    writeElement(dv, off + i * t.elementSize, t.elementType, t.elementSize, list[i]);
+}
+function readElement(dv, off, t, size) {
+  switch (t.tag) {
+    case "basic":
+      return readScalar(dv, off, t.kind);
+    case "bitfield":
+      return readBitfield(dv, off, t);
+    case "string":
+      return readString(dv, off, size, t.encoding);
+    case "struct":
+    case "union":
+      return doDecode(dv, off, t.fields);
+    case "array":
+      return readArray(dv, off, size, t);
+  }
+}
+function writeElement(dv, off, t, size, val) {
+  switch (t.tag) {
+    // TODO: remove this any
+    case "basic":
+      writeScalar(dv, off, { k: t.kind, v: val });
+      break;
+    // 直传（不 Number()）：writeBitfield 的 val 是 number | bigint，
+    // 64 位单元走 bigint，先 Number() 会把 >2^53 的位域值截断。
+    case "bitfield":
+      writeBitfield(dv, off, t, val ?? 0);
+      break;
+    case "string":
+      writeString(dv, off, size, t.encoding, val);
+      break;
+    case "struct":
+    case "union":
+      doEncode(dv, off, t.fields, val ?? {});
+      break;
+    case "array":
+      writeArray(dv, off, size, t, val);
+      break;
+  }
+}
+function doDecode(dv, base, fields) {
+  const out = {};
+  for (const f of fields) {
+    const v = readElement(dv, base + f.offset, f.type, f.size);
+    if (f.nonnull && v === 0)
+      throw new Error(`ffi-struct: decode: '!' field "${f.name}" got 0 (C did not fill it, or decode was called on an unfilled slot)`);
+    out[f.name] = v;
+  }
+  return out;
+}
+function doEncode(dv, base, fields, v) {
+  for (const f of fields) {
+    if (v[f.name] === void 0)
+      continue;
+    writeElement(dv, base + f.offset, f.type, f.size, v[f.name]);
+  }
+}
+function createStruct(t) {
+  const { fields, size, maxEffectiveAlign } = computeStructLayout(t);
+  return {
+    __struct: t,
+    size,
+    structAlign: maxEffectiveAlign,
+    decode: (p) => {
+      if (typeof p === "number") {
+        const buf = new ArrayBuffer(size);
+        const u8 = new Uint8Array(buf);
+        for (let i = 0; i < size; i++)
+          u8[i] = ffi2.readByte(p + i);
+        return doDecode(new DataView(buf), 0, fields);
+      }
+      return doDecode(new DataView(p), 0, fields);
+    },
+    alloc: (() => new PtrArrayBuffer(size)),
+    encode: ((v, buf) => {
+      if (v === void 0 || v === null)
+        throw new Error(`ffi-struct: encode(v) requires an argument; use alloc() for a zeroed out-param slot`);
+      const out = buf ?? new PtrArrayBuffer(size);
+      doEncode(new DataView(out), 0, fields, v);
+      return out;
+    }),
+    offsetOf: (name) => {
+      for (const f of fields)
+        if (f.name === name)
+          return f.offset;
+      throw new Error(`ffi-struct: no field "${name}"`);
+    }
+  };
+}
+function buildDecl(kind, member, pack) {
+  const decl = { "#": kind };
+  if (pack !== void 0)
+    decl["#pack"] = pack;
+  for (const [k, v] of Object.entries(member))
+    if (!k.startsWith("#"))
+      decl[k] = v;
+  return decl;
+}
+function struct(a, b6, c) {
+  const isNamed = typeof a === "string";
+  const raw = isNamed ? b6 : a;
+  const opts = isNamed ? c : b6;
+  return createStruct(buildDecl("struct", raw, opts?.pack));
+}
+
+// _build/lib/windows/structs.js
+var RECT = /* @__PURE__ */ struct("RECT", {
+  left: "i32",
+  top: "i32",
+  right: "i32",
+  bottom: "i32"
+});
+var POINT = /* @__PURE__ */ struct("POINT", {
+  x: "i32",
+  y: "i32"
+});
+var SIZE = /* @__PURE__ */ struct("SIZE", {
+  cx: "i32",
+  cy: "i32"
+});
+var LOGFONTW = /* @__PURE__ */ struct("LOGFONTW", {
+  lfHeight: "i32",
+  lfWidth: "i32",
+  lfEscapement: "i32",
+  lfOrientation: "i32",
+  lfWeight: "i32",
+  lfItalic: "u8",
+  lfUnderline: "u8",
+  lfStrikeOut: "u8",
+  lfCharSet: "u8",
+  lfOutPrecision: "u8",
+  lfClipPrecision: "u8",
+  lfQuality: "u8",
+  lfPitchAndFamily: "u8",
+  lfFaceName: "u16[32]@utf-16le"
+});
+var BITMAPINFOHEADER = /* @__PURE__ */ struct("BITMAPINFOHEADER", {
+  biSize: "u32",
+  biWidth: "i32",
+  biHeight: "i32",
+  biPlanes: "u16",
+  biBitCount: "u16",
+  biCompression: "u32",
+  biSizeImage: "u32",
+  biXPelsPerMeter: "i32",
+  biYPelsPerMeter: "i32",
+  biClrUsed: "u32",
+  biClrImportant: "u32"
+});
+var OPENFILENAMEW = /* @__PURE__ */ struct("OPENFILENAMEW", {
+  lStructSize: "u32",
+  hwndOwner: "<HWND>ptr",
+  hInstance: "<HMODULE>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 = /* @__PURE__ */ struct("BROWSEINFOW", {
+  hwndOwner: "<HWND>ptr",
+  pidlRoot: "<>ptr",
+  pszDisplayName: "<>ptr",
+  lpszTitle: "<>ptr",
+  ulFlags: "u32",
+  lpfn: "<>ptr",
+  lParam: "<>ptr",
+  iImage: "i32"
+});
+var NMHDR = /* @__PURE__ */ struct("NMHDR", {
+  hwndFrom: "<HWND>ptr",
+  idFrom: "<>ptr",
+  code: "i32"
+});
+var SYSTEMTIME = /* @__PURE__ */ struct("SYSTEMTIME", {
+  wYear: "u16",
+  wMonth: "u16",
+  wDayOfWeek: "u16",
+  wDay: "u16",
+  wHour: "u16",
+  wMinute: "u16",
+  wSecond: "u16",
+  wMilliseconds: "u16"
+});
+var NMDATETIMECHANGE = /* @__PURE__ */ struct("NMDATETIMECHANGE", {
+  hdr: NMHDR.__struct,
+  dwFlags: "u32",
+  st: SYSTEMTIME.__struct
+});
+var LITEM = /* @__PURE__ */ struct("LITEM", {
+  mask: "u32",
+  iLink: "i32",
+  state: "u32",
+  stateMask: "u32",
+  szID: "u16[48]@utf-16le",
+  szUrl: "u16[2084]@utf-16le"
+});
+var NMLINK = /* @__PURE__ */ struct("NMLINK", {
+  hdr: NMHDR.__struct,
+  item: LITEM.__struct
+});
+var NMCUSTOMDRAW = /* @__PURE__ */ struct("NMCUSTOMDRAW", {
+  hdr: NMHDR.__struct,
+  dwDrawStage: "u32",
+  hdc: "<HDC>ptr",
+  rc: "i32[4]",
+  dwItemSpec: "<>ptr",
+  uItemState: "u32",
+  lItemlParam: "<>ptr"
+});
+var NMLVCUSTOMDRAW = /* @__PURE__ */ struct("NMLVCUSTOMDRAW", {
+  hdr: NMHDR.__struct,
+  dwDrawStage: "u32",
+  hdc: "<HDC>ptr",
+  rc: "i32[4]",
+  dwItemSpec: "<>ptr",
+  uItemState: "u32",
+  lItemlParam: "<>ptr",
+  clrText: "u32",
+  clrTextBk: "u32",
+  iSubItem: "i32",
+  dwItemType: "u32"
+});
+var NMLISTVIEW = /* @__PURE__ */ struct("NMLISTVIEW", {
+  hdr: NMHDR.__struct,
+  iItem: "i32",
+  iSubItem: "i32",
+  uNewState: "u32",
+  uOldState: "u32",
+  uChanged: "u32",
+  ptAction: "i32[2]",
+  lParam: "<>ptr"
+});
+var TCITEMW = /* @__PURE__ */ struct("TCITEMW", {
+  mask: "u32",
+  dwState: "u32",
+  dwStateMask: "u32",
+  pszText: "<>ptr",
+  cchTextMax: "i32",
+  iImage: "i32",
+  lParam: "<>ptr"
+});
+var TVITEM = /* @__PURE__ */ struct("TVITEM", {
+  mask: "u32",
+  hItem: "<>ptr",
+  state: "u32",
+  stateMask: "u32",
+  pszText: "<>ptr",
+  cchTextMax: "i32",
+  iImage: "i32",
+  iSelectedImage: "i32",
+  cChildren: "i32",
+  lParam: "<>ptr"
+});
+var TVINSERTSTRUCT = /* @__PURE__ */ struct("TVINSERTSTRUCT", {
+  hParent: "<>ptr",
+  hInsertAfter: "<>ptr",
+  item: TVITEM.__struct
+});
+var LVHITTESTINFO = /* @__PURE__ */ struct("LVHITTESTINFO", {
+  pt: "i32[2]",
+  flags: "u32",
+  iItem: "i32",
+  iSubItem: "i32",
+  iGroup: "i32"
+});
+var LVITEMW = /* @__PURE__ */ struct("LVITEMW", {
+  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 = /* @__PURE__ */ struct("LVCOLUMNW", {
+  mask: "u32",
+  fmt: "i32",
+  cx: "i32",
+  pszText: "<>ptr",
+  cchTextMax: "i32",
+  iSubItem: "i32",
+  iImage: "i32",
+  iOrder: "i32",
+  cxMin: "i32",
+  cxDefault: "i32",
+  cxIdeal: "i32"
+});
+var MSG = /* @__PURE__ */ struct("MSG", {
+  hwnd: "<HWND>ptr",
+  message: "u32",
+  wParam: "<>ptr",
+  lParam: "<>ptr",
+  time: "u32",
+  pt: POINT.__struct
+});
+var PAINTSTRUCT = /* @__PURE__ */ struct("PAINTSTRUCT", {
+  hdc: "<HDC>ptr",
+  fErase: "i32",
+  rcPaint: RECT.__struct,
+  fRestore: "i32",
+  fIncUpdate: "i32",
+  rgbReserved: "u8[32]"
+});
+
+// _build/lib/windows/user32.js
+var b = (name, sig, encoders) => bind("user32.dll", name, sig, encoders);
+var _bProbe = b("GetDesktopWindow", " -> <HWND>ptr");
+var LONG_PTR_SYM = os3.arch === "x64" ? "PtrW" : "W";
+var SetWindowPos = /* @__PURE__ */ b("SetWindowPos", "<HWND>ptr <>ptr@SetWindowPosHwnd i32 i32 i32 i32 u32 -> i32");
+var SetWindowText = /* @__PURE__ */ b("SetWindowTextW", "<HWND>ptr <WCHAR>ptr -> i32");
+var GetWindowLongPtr = /* @__PURE__ */ b("GetWindowLong" + LONG_PTR_SYM, "<HWND>ptr i32@Gwlp -> <>ptr");
+var SetWindowLongPtr = /* @__PURE__ */ b("SetWindowLong" + LONG_PTR_SYM, "<HWND>ptr i32@Gwlp <>ptr -> <>ptr");
+var EnableWindow = /* @__PURE__ */ b("EnableWindow", "<HWND>ptr i32 -> i32");
+var SetParent = /* @__PURE__ */ b("SetParent", "<HWND>ptr <HWND>ptr -> <HWND>ptr");
+var DefWindowProc = /* @__PURE__ */ b("DefWindowProcW", "<HWND>ptr u32@AnyMsg <>ptr <>ptr -> <>ptr");
+var CallWindowProc = /* @__PURE__ */ b("CallWindowProcW", "<>ptr <HWND>ptr u32@AnyMsg <>ptr <>ptr -> <>ptr");
+var GetDC = /* @__PURE__ */ b("GetDC", "<HWND>ptr -> <HDC>ptr");
+var ReleaseDC = /* @__PURE__ */ b("ReleaseDC", "<HWND>ptr <HDC>ptr! -> i32");
+var DrawText = /* @__PURE__ */ b("DrawTextW", "<HDC>ptr! <WCHAR>ptr i32 <RECT>ptr i32 -> i32");
+var InvalidateRect = /* @__PURE__ */ b("InvalidateRect", "<HWND>ptr <RECT>ptr i32 -> i32", { RECT });
+var SetCursor = /* @__PURE__ */ b("SetCursor", "<HCURSOR>ptr -> <HCURSOR>ptr");
+var LoadCursor = /* @__PURE__ */ b("LoadCursorW", "<HMODULE>ptr <>ptr -> <HCURSOR>ptr");
+var GetCursorPos = /* @__PURE__ */ b("GetCursorPos", "<POINT>ptr -> i32");
+var ScreenToClient = /* @__PURE__ */ b("ScreenToClient", "<HWND>ptr <POINT>ptr -> i32");
+var ShowScrollBar = /* @__PURE__ */ b("ShowScrollBar", "<HWND>ptr u32 i32 -> i32");
+var GetSystemMetrics = /* @__PURE__ */ b("GetSystemMetrics", "i32 -> i32");
 
 // _build/lib/react-qw/reconciler.js
 var import_react_reconciler = __toESM(require_react_reconciler(), 1);
 var import_react = __toESM(require_react(), 1);
 var import_constants = __toESM(require_constants(), 1);
 import * as gui3 from "gui";
-import * as os2 from "os";
+import * as os4 from "os";
+
+// _build/lib/windows/gdi32.js
+var b2 = (name, sig, encoders) => bind("gdi32.dll", name, sig, encoders);
+var DeleteObject = /* @__PURE__ */ b2("DeleteObject", "<>ptr -> i32");
+var GetDeviceCaps = /* @__PURE__ */ b2("GetDeviceCaps", "<HDC>ptr! i32@DeviceCap -> i32");
+var CreateFontIndirect = /* @__PURE__ */ b2("CreateFontIndirectW", "<LOGFONTW>ptr -> <>ptr", { LOGFONTW });
+var SelectObject = /* @__PURE__ */ b2("SelectObject", "<HDC>ptr! <>ptr -> <>ptr");
+var GetObject = /* @__PURE__ */ b2("GetObjectW", "<>ptr i32 <BYTE>ptr -> i32");
+var SetDIBitsToDevice = /* @__PURE__ */ b2("SetDIBitsToDevice", "<HDC>ptr! i32 i32 u32 u32 i32 i32 u32 u32 <BYTE>ptr <BYTE>ptr u32 -> i32");
 
 // _build/lib/react-qw/props.js
 import * as gui from "gui";
 function applyProps(instance, newProps, _oldProps) {
   const hwnd = instance.hwnd;
   instance.props = newProps;
+  if (hwnd === null)
+    return;
   const textVal = "text" in newProps ? newProps.text : typeof newProps.children === "string" ? newProps.children : typeof newProps.children === "number" ? String(newProps.children) : void 0;
   if (textVal !== void 0) {
     let cursor = -1;
@@ -15384,13 +16540,13 @@ function applyProps(instance, newProps, _oldProps) {
       const sel = gui.SendMessage(hwnd, 176, 0, 0);
       cursor = sel >>> 16;
     }
-    gui.SetWindowText(hwnd, textVal);
+    SetWindowText(hwnd, textVal);
     if (instance.type === "EDIT" && cursor >= 0) {
       gui.SendMessage(hwnd, 177, cursor, cursor);
     }
   }
   if ("disabled" in newProps) {
-    gui.EnableWindow(hwnd, !newProps.disabled);
+    EnableWindow(hwnd, !newProps.disabled ? 1 : 0);
   }
   if ("hidden" in newProps) {
     gui.ShowWindow(
@@ -15490,58 +16646,36 @@ function calculateFlexLayout(flex, parentW, parentH, children) {
 }
 
 // _build/lib/text-measure.js
-import * as ffi from "ffi";
-import * as os from "os";
-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;
-}
-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_HND = os.arch === "ia32" ? ffi.FFI_TYPE_UINT32 : ffi.FFI_TYPE_UINT64;
-var FFI_S32 = ffi.FFI_TYPE_SINT32;
-var FFI_PTR = ffi.FFI_TYPE_POINTER;
 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_HND, FFI_PTR, FFI_S32, FFI_PTR, FFI_S32], [
+  const r = RECT.encode({ right: maxWidth });
+  DrawText(
     hdc,
-    textBuf,
+    text,
     -1,
-    rect,
+    r.ptr,
     1024
     /* gui.DrawTextFlag.CALCRECT */
-  ], FFI_S32);
-  return { width: dv.getInt32(8, true), height: dv.getInt32(12, true) };
+  );
+  const { right, bottom } = RECT.decode(r);
+  return { width: right, height: bottom };
 }
 function getButtonIdealSize(hwnd) {
-  const size = new ArrayBuffer(8);
-  gui2.SendMessage(hwnd, 5633, 0, ffi.bufferPtr(size));
-  const dv = new DataView(size);
-  return { width: dv.getInt32(0, true), height: dv.getInt32(4, true) };
+  const size = SIZE.alloc();
+  gui2.SendMessage(hwnd, 5633, 0, size.ptr);
+  const { cx, cy } = SIZE.decode(size);
+  return { width: cx, height: cy };
 }
 function measureTextForHwnd(hwnd, text) {
-  const hdc = ffi.ffiCall(GetDC, [FFI_HND], [hwnd], FFI_HND);
+  const hdc = GetDC(hwnd);
   if (!hdc)
     return { width: 0, height: 0 };
   const hFont = gui2.SendMessage(hwnd, 49, 0, 0);
-  const oldFont = hFont ? ffi.ffiCall(SelectObject, [FFI_HND, FFI_HND], [hdc, hFont], FFI_HND) : 0;
+  const oldFont = hFont ? SelectObject(hdc, hFont) : 0;
   const result = measureText(hdc, text, 0);
   if (hFont)
-    ffi.ffiCall(SelectObject, [FFI_HND, FFI_HND], [hdc, oldFont], FFI_HND);
-  ffi.ffiCall(ReleaseDC, [FFI_HND, FFI_HND], [hwnd, hdc], FFI_S32);
+    SelectObject(hdc, oldFont);
+  ReleaseDC(hwnd, hdc);
   const wr = gui2.GetWindowRect(hwnd);
   const cr = gui2.GetClientRect(hwnd);
   if (wr && cr) {
@@ -15553,14 +16687,20 @@ function measureTextForHwnd(hwnd, text) {
 
 // _build/lib/react-qw/reconciler.js
 var dpiFont = gui3.CreateSystemDpiFont();
-var scaleFactor = gui3.GetScaleFactor();
+var scaleFactor = (() => {
+  const hdc = GetDC(NULL);
+  const dpi = hdc ? GetDeviceCaps(hdc, 88) : 96;
+  if (hdc)
+    ReleaseDC(NULL, hdc);
+  return dpi / 96;
+})();
 var DELAYED_CONTROLS = /* @__PURE__ */ new Set(["SysListView32", "SysTreeView32", "LISTBOX", "COMBOBOX", "msctls_trackbar32", "SysDateTimePick32", "SysLink"]);
 function isDelayedControl(winClass) {
   return DELAYED_CONTROLS.has(winClass);
 }
 function setupWindowProc(instance, hwnd) {
   instance.hwnd = hwnd;
-  const oldProc = gui3.GetWindowLongPtr(
+  const oldProc = GetWindowLongPtr(
     hwnd,
     -4
     /* gui.Gwlp.WNDPROC */
@@ -15569,11 +16709,11 @@ function setupWindowProc(instance, hwnd) {
   gui3.SetWindowProc(hwnd, (hwnd2, msg, wParam, lParam) => {
     const ev = instance.props.onEvent;
     if (!ev)
-      return gui3.CallWindowProc(oldProc, hwnd2, msg, wParam, lParam);
+      return CallWindowProc(oldProc, hwnd2, msg, wParam, lParam);
     if (typeof ev === "object") {
-      return ev.fn({ hwnd: hwnd2, msg, wParam, lParam, callOldWndProc: () => gui3.CallWindowProc(oldProc, hwnd2, msg, wParam, lParam) });
+      return ev.fn({ hwnd: hwnd2, msg, wParam, lParam, callOldWndProc: () => CallWindowProc(oldProc, hwnd2, msg, wParam, lParam) });
     }
-    const result = gui3.CallWindowProc(oldProc, hwnd2, msg, wParam, lParam);
+    const result = CallWindowProc(oldProc, hwnd2, msg, wParam, lParam);
     const override = ev({ hwnd: hwnd2, msg, wParam, lParam });
     return typeof override === "number" && Number.isInteger(override) ? override : result;
   });
@@ -15643,7 +16783,7 @@ function runFlexLayout(inst) {
     if (lr && lr.x === r.x && lr.y === r.y && lr.w === r.width && lr.h === r.height)
       continue;
     console.log("flex: set", child.type, child.hwnd, "to", r.x, r.y, r.width, r.height);
-    gui3.SetWindowPos(
+    SetWindowPos(
       child.hwnd,
       0,
       (r.x + pl) * scaleFactor,
@@ -15653,7 +16793,7 @@ function runFlexLayout(inst) {
       64
       /* gui.SetWindowPosFlag.SWP_SHOWWINDOW */
     );
-    gui3.InvalidateRect(child.hwnd, null, true);
+    InvalidateRect(child.hwnd, NULL, 1);
     child.lastRect = { x: r.x, y: r.y, w: r.width, h: r.height };
   }
   for (const c of children)
@@ -15699,7 +16839,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, parent.hwnd);
     } else {
-      gui3.SetParent(child.hwnd, parent.hwnd);
+      SetParent(child.hwnd, parent.hwnd ?? NULL);
     }
     if (false)
       console.log("[reconciler] appendInitialChild parent:", parent.hwnd, "child:", child.hwnd);
@@ -15709,7 +16849,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, parent.hwnd);
     } else {
-      gui3.SetParent(child.hwnd, parent.hwnd);
+      SetParent(child.hwnd, parent.hwnd ?? NULL);
     }
     if (false)
       console.log("[reconciler] appendChild parent:", parent.hwnd, "child:", child.hwnd);
@@ -15719,7 +16859,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, container);
     } else {
-      gui3.SetParent(child.hwnd, container);
+      SetParent(child.hwnd, container);
     }
     const rootInst = instancesByHwnd.get(container);
     if (rootInst)
@@ -15731,7 +16871,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, parent.hwnd);
     } else {
-      gui3.SetParent(child.hwnd, parent.hwnd);
+      SetParent(child.hwnd, parent.hwnd ?? NULL);
     }
     if (false)
       console.log("[reconciler] insertBefore parent:", parent.hwnd, "child:", child.hwnd, "before:", beforeChild.hwnd);
@@ -15743,7 +16883,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, container);
     } else {
-      gui3.SetParent(child.hwnd, container);
+      SetParent(child.hwnd, container);
     }
     const rootInst = instancesByHwnd.get(container);
     if (!rootInst)
@@ -15800,7 +16940,7 @@ var hostConfig = {
   resetTextContent(_instance) {
   },
   commitTextUpdate(instance, _oldText, newText) {
-    gui3.SetWindowText(instance.hwnd, newText);
+    SetWindowText(instance.hwnd, newText);
   },
   hideInstance(instance) {
     if (instance.hwnd !== null)
@@ -15854,10 +16994,10 @@ var hostConfig = {
   clearContainer(_container) {
   },
   scheduleTimeout(fn, delay) {
-    return os2.setTimeout(fn, delay);
+    return os4.setTimeout(fn, delay);
   },
   cancelTimeout(id) {
-    os2.clearTimeout?.(id);
+    os4.clearTimeout?.(id);
   },
   noTimeout: -1,
   supportsMutation: true,
@@ -16024,28 +17164,23 @@ 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;
-}
-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 bufPtr(buf) {
-  return ffi2.bufferPtr(buf);
+
+// _build/lib/react-qw/nmhdr.js
+function nmCode(lParam) {
+  return NMHDR.decode(lParam).code;
 }
+
+// _build/lib/react-qw/components/DateTimePicker.js
 function dateToSysTimeBuf(d) {
-  const buf = new ArrayBuffer(16);
-  const dv = new DataView(buf);
-  dv.setUint16(0, d.getFullYear(), true);
-  dv.setUint16(2, d.getMonth() + 1, true);
-  dv.setUint16(4, 0, true);
-  dv.setUint16(6, d.getDate(), true);
-  dv.setUint16(8, d.getHours(), true);
-  dv.setUint16(10, d.getMinutes(), true);
-  dv.setUint16(12, d.getSeconds(), true);
-  dv.setUint16(14, d.getMilliseconds(), true);
-  return buf;
+  return SYSTEMTIME.encode({
+    wYear: d.getFullYear(),
+    wMonth: d.getMonth() + 1,
+    wDay: d.getDate(),
+    wHour: d.getHours(),
+    wMinute: d.getMinutes(),
+    wSecond: d.getSeconds(),
+    wMilliseconds: d.getMilliseconds()
+  });
 }
 var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ value, onChange, defaultValue, format = "short", allowNone, updown, style }, ref) {
   const [internalDate, setInternalDate] = (0, import_react5.useState)(defaultValue ?? null);
@@ -16070,7 +17205,7 @@ var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ va
     const d = effectiveDate;
     if (d) {
       const buf = dateToSysTimeBuf(d);
-      gui6.SendMessage(h, 4098, 0, bufPtr(buf));
+      gui6.SendMessage(h, 4098, 0, buf.ptr);
     } else {
       gui6.SendMessage(h, 4098, 1, 0);
     }
@@ -16079,7 +17214,7 @@ var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ va
     const h = dpRef.current;
     if (!h)
       return;
-    gui6.InvalidateRect(h, null, true);
+    InvalidateRect(h, NULL, 1);
     const cr = gui6.GetClientRect(h);
     if (cr) {
       const w = cr.right - cr.left;
@@ -16089,21 +17224,15 @@ 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 { dwFlags, st } = NMDATETIMECHANGE.decode(e.lParam);
         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 d = new Date(year, month - 1, day, hour, min, sec);
+          const d = new Date(st.wYear, st.wMonth - 1, st.wDay, st.wHour, st.wMinute, st.wSecond);
           if (!isControlled)
             setInternalDate(d);
           onChangeRef.current?.(d);
@@ -16119,14 +17248,6 @@ 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";
-function textToUtf16(s) {
-  const buf = new ArrayBuffer((s.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < s.length; i++)
-    dv.setUint16(i * 2, s.charCodeAt(i), true);
-  return buf;
-}
 var Input = (0, import_react6.forwardRef)(({ value: controlledValue, defaultValue = "", onChange, placeholder, password, multiline, readonly, number, disabled, style }, ref) => {
   const [internalValue, setInternalValue] = (0, import_react6.useState)(defaultValue);
   const isControlled = controlledValue !== void 0;
@@ -16145,8 +17266,8 @@ var Input = (0, import_react6.forwardRef)(({ value: controlledValue, defaultValu
     const h = inputRef.current;
     if (!h || !placeholder)
       return;
-    const buf = textToUtf16(placeholder);
-    gui7.SendMessage(h, 5377, 1, ffi3.bufferPtr(buf));
+    const buf = WCHAR.encode(placeholder);
+    gui7.SendMessage(h, 5377, 1, buf.ptr);
   }, [placeholder]);
   return (0, import_jsx_runtime5.jsx)("w", { type: "EDIT", text: displayValue, ws, style, disabled, ref: (h) => {
     inputRef.current = h;
@@ -16170,23 +17291,6 @@ var Input = (0, import_react6.forwardRef)(({ value: controlledValue, defaultValu
 // _build/lib/react-qw/components/Link.js
 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;
-}
-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 code = hi << 8 | lo;
-    if (code === 0)
-      break;
-    chars.push(String.fromCharCode(code));
-  }
-  return chars.join("");
-}
 var Link = (0, import_react7.forwardRef)(function Link2({ href, children, onClick, style }, ref) {
   const displayText = children != null ? String(children) : href ?? "";
   const linkText = href ? `<A HREF="${href}">${displayText}</A>` : displayText;
@@ -16197,14 +17301,13 @@ var Link = (0, import_react7.forwardRef)(function Link2({ href, children, onClic
     const h = linkRef.current;
     if (!h)
       return;
-    gui8.InvalidateRect(h, null, true);
+    InvalidateRect(h, NULL, 1);
   }, [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);
-        onClickRef.current?.(url);
+        onClickRef.current?.(NMLINK.decode(e.lParam).item.szUrl);
       }
     }
   }, children: (0, import_jsx_runtime6.jsx)("w", { type: "SysLink", ws: 268435456 | 65536, text: linkText, style: { flexGrow: 1 }, ref: (h) => {
@@ -16215,7 +17318,7 @@ var Link = (0, import_react7.forwardRef)(function Link2({ href, children, onClic
 // _build/lib/react-qw/components/ListBox.js
 var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
 var import_react8 = __toESM(require_react(), 1);
-import * as gui9 from "gui";
+import * as gui8 from "gui";
 var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledIndex, defaultSelectedIndex = -1, onChange, style, sort, scrollToBottom }, ref) => {
   const [internalIndex, setInternalIndex] = (0, import_react8.useState)(defaultSelectedIndex);
   const isControlled = controlledIndex !== void 0;
@@ -16227,18 +17330,18 @@ var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledI
     const h = lbRef.current;
     if (!h)
       return;
-    gui9.SendMessage(h, 388, 0, 0);
+    gui8.SendMessage(h, 388, 0, 0);
     for (const item of items)
-      gui9.SendMessage(h, 384, 0, item);
+      gui8.SendMessage(h, 384, 0, item);
     if (sel >= 0 && sel < items.length)
-      gui9.SendMessage(h, 390, sel, 0);
+      gui8.SendMessage(h, 390, sel, 0);
     if (scrollToBottom && items.length > 0)
-      gui9.SendMessage(h, 407, items.length - 1, 0);
+      gui8.SendMessage(h, 407, items.length - 1, 0);
   }, [items]);
   (0, import_react8.useEffect)(() => {
     const h = lbRef.current;
     if (h)
-      gui9.SendMessage(h, 390, sel, 0);
+      gui8.SendMessage(h, 390, sel, 0);
   }, [sel]);
   return (0, import_jsx_runtime7.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, onEvent: (e) => {
     if (e.msg !== 273)
@@ -16248,7 +17351,7 @@ var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledI
       const h = lbRef.current;
       if (!h)
         return;
-      const newSel = gui9.SendMessage(h, 392, 0, 0);
+      const newSel = gui8.SendMessage(h, 392, 0, 0);
       if (newSel !== sel && newSel >= 0) {
         if (!isControlled)
           setInternalIndex(newSel);
@@ -16263,75 +17366,18 @@ var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledI
 // _build/lib/react-qw/components/ListView.js
 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 win2 from "win";
-function textToUtf162(s) {
-  const buf = new ArrayBuffer((s.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < s.length; i++)
-    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 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;
-}
-function readU64(ptr, offset) {
-  const lo = readU32(ptr, offset);
-  const hi = readU32(ptr, offset + 4);
-  return lo + hi * 4294967296;
-}
+import * as gui9 from "gui";
+import * as ffi3 from "ffi";
 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);
-}
-function bufPtr2(buf) {
-  return ffi5.bufferPtr(buf);
+  ffi3.writeByte(ptr + offset, v & 255);
+  ffi3.writeByte(ptr + offset + 1, v >> 8 & 255);
+  ffi3.writeByte(ptr + offset + 2, v >> 16 & 255);
+  ffi3.writeByte(ptr + offset + 3, v >> 24 & 255);
 }
 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 CD_CLRTEXT = NMLVCUSTOMDRAW.offsetOf("clrText");
+var CD_CLRTEXTBK = NMLVCUSTOMDRAW.offsetOf("clrTextBk");
 var fontCache = /* @__PURE__ */ new Map();
-var gdi322 = null;
-var createFontIndirectW = null;
-var selectObjectFn = null;
-var getObjectW = null;
-function ensureGdi() {
-  if (gdi322 !== null)
-    return;
-  gdi322 = win2.LoadLibrary("gdi32.dll");
-  if (!gdi322)
-    return;
-  createFontIndirectW = win2.GetProcAddress(gdi322, "CreateFontIndirectW");
-  selectObjectFn = win2.GetProcAddress(gdi322, "SelectObject");
-  getObjectW = win2.GetProcAddress(gdi322, "GetObjectW");
-}
-var user322 = null;
-var loadCursorW = null;
-var setCursorFn = null;
-var screenToClient = null;
-function ensureUser32() {
-  if (user322 !== null)
-    return;
-  user322 = win2.LoadLibrary("user32.dll");
-  if (!user322)
-    return;
-  loadCursorW = win2.GetProcAddress(user322, "LoadCursorW");
-  setCursorFn = win2.GetProcAddress(user322, "SetCursor");
-  screenToClient = win2.GetProcAddress(user322, "ScreenToClient");
-}
 function getCellFont(hwnd, style) {
   const key = (style.bold ? "b" : "") + (style.italic ? "i" : "") + (style.underline ? "u" : "");
   if (key === "")
@@ -16339,39 +17385,37 @@ function getCellFont(hwnd, style) {
   const cached = fontCache.get(key);
   if (cached !== void 0)
     return cached === 0 ? null : cached;
-  ensureGdi();
-  if (!createFontIndirectW || !getObjectW || !hwnd)
+  if (!hwnd)
     return null;
-  const lf = new ArrayBuffer(92);
-  const dv = new DataView(lf);
-  const cur = gui10.SendMessage(hwnd, 49, 0, 0);
+  let base = { lfHeight: -13 };
+  const cur = gui9.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);
-    if (!got)
+    const lf = LOGFONTW.alloc();
+    if (!GetObject(cur, LOGFONTW.size, lf))
       return null;
-  } else {
-    dv.setInt32(0, -13, true);
+    base = LOGFONTW.decode(lf);
   }
-  if (style.bold)
-    dv.setInt32(16, 700, true);
-  if (style.italic)
-    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 = CreateFontIndirect({
+    ...base,
+    ...style.bold ? {
+      lfWeight: 700
+      /* gui.FontWeight.BOLD */
+    } : {},
+    ...style.italic ? { lfItalic: 1 } : {},
+    ...style.underline ? { lfUnderline: 1 } : {}
+  });
+  fontCache.set(key, h ? h : 0);
+  return h ? h : null;
 }
 function handleCustomDraw(lParam, columns, data, hwnd) {
-  const stage = readU32(lParam, CD_STAGE);
+  const { dwDrawStage: stage } = NMCUSTOMDRAW.decode(lParam);
   if (stage === 1)
     return 32;
   if (stage === 65537)
     return 32;
   if (stage === 196609) {
-    const colIndex = readI323(lParam, CD_SUBITEM);
-    const row = readI323(lParam, CD_ITEM);
-    const style = resolveCellStyle(columns, data, row, colIndex);
+    const cd = NMLVCUSTOMDRAW.decode(lParam);
+    const style = resolveCellStyle(columns, data, cd.dwItemSpec, cd.iSubItem);
     if (!style)
       return 0;
     if (style.color !== void 0)
@@ -16379,12 +17423,9 @@ function handleCustomDraw(lParam, columns, data, hwnd) {
     if (style.background !== void 0)
       writeU32(lParam, CD_CLRTEXTBK, style.background);
     const hfont = getCellFont(hwnd, style);
-    if (hfont && selectObjectFn) {
-      const hdc = readU64(lParam, CD_HDC);
-      if (hdc) {
-        ffi5.ffiCall(selectObjectFn, [ffi5.FFI_TYPE_UINT64, ffi5.FFI_TYPE_UINT64], [hdc, hfont], ffi5.FFI_TYPE_UINT64);
-        return 2;
-      }
+    if (hfont && cd.hdc) {
+      SelectObject(cd.hdc, hfont);
+      return 2;
     }
   }
   return 0;
@@ -16415,20 +17456,26 @@ 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);
-  b.__textBuf = textBuf;
-  return b;
+  const textBuf = WCHAR.encode(text);
+  const b6 = LVITEMW.encode({
+    mask: 1 | (image !== void 0 ? 2 : 0),
+    iItem: i,
+    iSubItem: sub,
+    state: 0,
+    stateMask: 0,
+    pszText: textBuf.ptr,
+    cchTextMax: 0,
+    iImage: image ?? 0,
+    lParam: 0,
+    iIndent: 0,
+    iGroupId: 0,
+    cColumns: 0,
+    puColumns: 0,
+    piColFmt: 0,
+    iGroup: 0
+  });
+  b6.__textBuf = textBuf;
+  return b6;
 }
 var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns, data, style, icons, iconSize, getIcon }, ref) {
   const lvRef = (0, import_react9.useRef)(null);
@@ -16440,36 +17487,36 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns, d
     const il = iconListRef.current;
     iconListRef.current = 0;
     if (il) {
-      gui10.SendMessage(h, 4099, 1, 0);
-      gui10.ImageListDestroy(il);
+      gui9.SendMessage(h, 4099, 1, 0);
+      gui9.ImageListDestroy(il);
     }
     if (!icons || icons.length === 0)
       return;
     const size = iconSize ?? 32;
-    const img = gui10.ImageListCreate(size, size, 32, icons.length, 1);
+    const img = gui9.ImageListCreate(size, size, 32, icons.length, 1);
     if (!img)
       return;
     for (const p of icons) {
-      const hbm = gui10.CreateBitmapFromPixels(size, size, p);
+      const hbm = gui9.CreateBitmapFromPixels(size, size, p);
       if (hbm) {
-        gui10.ImageListAdd(img, hbm);
-        gui10.DeleteObject(hbm);
+        gui9.ImageListAdd(img, hbm);
+        DeleteObject(hbm);
       }
     }
-    gui10.SendMessage(h, 4099, 1, img);
+    gui9.SendMessage(h, 4099, 1, img);
     iconListRef.current = img;
   }, [icons, iconSize]);
   (0, import_react9.useEffect)(() => {
     const h = lvRef.current;
     if (!h)
       return;
-    const hdr = gui10.SendMessage(h, 4127, 0, 0);
+    const hdr = gui9.SendMessage(h, 4127, 0, 0);
     if (hdr) {
-      let n2 = gui10.SendMessage(hdr, 4608, 0, 0);
+      let n2 = gui9.SendMessage(hdr, 4608, 0, 0);
       for (let k = n2 - 1; k >= 0; k--)
-        gui10.SendMessage(h, 4124, k, 0);
+        gui9.SendMessage(h, 4124, k, 0);
     }
-    gui10.SendMessage(
+    gui9.SendMessage(
       h,
       4150,
       0,
@@ -16478,37 +17525,43 @@ 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 titleBuf = WCHAR.encode(columns[j].name);
+      const lvc = LVCOLUMNW.encode({
+        mask: 4 | 2 | 1,
+        fmt: alignToFmt(columns[j].align),
+        cx: columns[j].width ?? 100,
+        pszText: titleBuf.ptr,
+        cchTextMax: 0,
+        iSubItem: j,
+        iImage: 0,
+        iOrder: 0,
+        cxMin: 0,
+        cxDefault: 0,
+        cxIdeal: 0
+      });
       lvc.__titleBuf = titleBuf;
-      gui10.SendMessage(h, 4193, j, bufPtr2(lvc));
+      gui9.SendMessage(h, 4193, j, lvc.ptr);
     }
   }, [columns]);
   (0, import_react9.useEffect)(() => {
     const h = lvRef.current;
     if (!h)
       return;
-    gui10.SendMessage(h, 4105, 0, 0);
+    gui9.SendMessage(h, 4105, 0, 0);
     const nCols = columns.length;
     for (let i = 0; i < data.length; i++) {
       const record = data[i];
       const img = getIcon ? getIcon(record, i) : void 0;
       const itemBuf = makeLVItem(i, 0, cellText(record, columns[0], i), img);
-      gui10.SendMessage(h, 4173, 0, bufPtr2(itemBuf));
+      gui9.SendMessage(h, 4173, 0, itemBuf.ptr);
       for (let j = 1; j < nCols; j++) {
         const subBuf = makeLVItem(i, j, cellText(record, columns[j], i));
-        gui10.SendMessage(h, 4172, 0, bufPtr2(subBuf));
+        gui9.SendMessage(h, 4172, 0, subBuf.ptr);
       }
     }
     for (let j = 0; j < columns.length; j++) {
       if (columns[j].width == null) {
-        gui10.SendMessage(
+        gui9.SendMessage(
           h,
           4126,
           j,
@@ -16520,19 +17573,17 @@ 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, uOldState } = NMLISTVIEW.decode(e.lParam);
         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, iSubItem } = NMLISTVIEW.decode(e.lParam);
         const col = columns[iSubItem];
         const record = data[iItem];
         if (col?.onCellClick && record !== void 0)
@@ -16550,33 +17601,20 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns, d
     const h = lvRef.current;
     if (!h)
       return;
-    ensureUser32();
-    if (!loadCursorW || !setCursorFn || !screenToClient)
-      return;
-    const sp = gui10.GetCursorPos();
-    if (!sp)
+    const pt = POINT.alloc();
+    if (!GetCursorPos(pt.ptr))
       return;
-    const sbuf = new ArrayBuffer(8);
-    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);
-    const lvhi = new ArrayBuffer(24);
-    const lvd = new DataView(lvhi);
-    lvd.setInt32(0, sdv.getInt32(0, true), true);
-    lvd.setInt32(4, sdv.getInt32(4, true), true);
-    lvd.setInt32(12, -1, true);
-    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);
+    ScreenToClient(h, pt.ptr);
+    const { x: sx, y: sy } = POINT.decode(pt);
+    const hit = LVHITTESTINFO.encode({ pt: [sx, sy], iItem: -1, iSubItem: -1 });
+    gui9.SendMessage(h, 4153, 0, hit.ptr);
+    const { iItem, iSubItem } = LVHITTESTINFO.decode(hit);
     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 = LoadCursor(NULL, style2.cursor);
     if (hc) {
-      ffi5.ffiCall(setCursorFn, [ffi5.FFI_TYPE_UINT64], [hc], ffi5.FFI_TYPE_UINT64);
+      SetCursor(hc);
       return 1;
     }
     return;
@@ -16586,7 +17624,7 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns, d
 // _build/lib/react-qw/components/ProgressBar.js
 var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
 var import_react10 = __toESM(require_react(), 1);
-import * as gui11 from "gui";
+import * as gui10 from "gui";
 var ProgressBar = (0, import_react10.forwardRef)(({ value = 0, max = 100, style, smooth }, ref) => {
   const pbRef = (0, import_react10.useRef)(null);
   const ws = 268435456 | 8388608 | (smooth ? 1 : 0);
@@ -16594,8 +17632,8 @@ var ProgressBar = (0, import_react10.forwardRef)(({ value = 0, max = 100, style,
     const h = pbRef.current;
     if (!h)
       return;
-    gui11.SendMessage(h, 1030, 0, max);
-    gui11.SendMessage(h, 1026, Math.min(value, max), 0);
+    gui10.SendMessage(h, 1030, 0, max);
+    gui10.SendMessage(h, 1026, Math.min(value, max), 0);
   }, [value, max]);
   return (0, import_jsx_runtime9.jsx)("w", { type: "msctls_progress32", ws, style, ref: (h) => {
     pbRef.current = h;
@@ -16609,7 +17647,7 @@ var ProgressBar = (0, import_react10.forwardRef)(({ value = 0, max = 100, style,
 // _build/lib/react-qw/components/RadioButton.js
 var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
 var import_react11 = __toESM(require_react(), 1);
-import * as gui12 from "gui";
+import * as gui11 from "gui";
 var RadioButton = (0, import_react11.forwardRef)(({ checked: controlledChecked, defaultChecked = false, onChange, label, style, disabled }, ref) => {
   const [internalChecked, setInternalChecked] = (0, import_react11.useState)(defaultChecked);
   const isControlled = controlledChecked !== void 0;
@@ -16619,7 +17657,7 @@ var RadioButton = (0, import_react11.forwardRef)(({ checked: controlledChecked,
     const h = rbRef.current;
     if (!h)
       return;
-    gui12.SendMessage(h, 241, displayChecked ? 1 : 0, 0);
+    gui11.SendMessage(h, 241, displayChecked ? 1 : 0, 0);
   }, [displayChecked]);
   return (0, import_jsx_runtime10.jsx)("w", { type: "BUTTON", text: label ?? "", ws: 268435456 | 9, style, disabled, ref: (h) => {
     rbRef.current = h;
@@ -16629,7 +17667,7 @@ var RadioButton = (0, import_react11.forwardRef)(({ checked: controlledChecked,
       ref.current = h;
   }, onEvent: (e) => {
     if (e.msg === 514) {
-      const newChecked = gui12.SendMessage(e.hwnd, 240, 0, 0) !== 0;
+      const newChecked = gui11.SendMessage(e.hwnd, 240, 0, 0) !== 0;
       if (newChecked !== displayChecked) {
         if (!isControlled)
           setInternalChecked(newChecked);
@@ -16642,24 +17680,27 @@ var RadioButton = (0, import_react11.forwardRef)(({ checked: controlledChecked,
 // _build/lib/react-qw/components/ScrollView.js
 var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
 var import_react12 = __toESM(require_react(), 1);
-import * as gui13 from "gui";
+import * as gui12 from "gui";
 var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth, contentHeight }, ref) => {
   const svRef = (0, import_react12.useRef)(null);
   const contentRef = (0, import_react12.useRef)(null);
   const scrollXRef = (0, import_react12.useRef)(0);
   const scrollYRef = (0, import_react12.useRef)(0);
   function updateScroll(sv, content) {
-    const svRect = gui13.GetClientRect(sv);
+    const svRect = gui12.GetClientRect(sv);
     if (!svRect)
       return;
     const svW = svRect.right - svRect.left;
     const svH = svRect.bottom - svRect.top;
-    const scale = gui13.GetScaleFactor();
+    const hdc = GetDC(NULL);
+    const scale = hdc ? GetDeviceCaps(hdc, 88) / 96 : 1;
+    if (hdc)
+      ReleaseDC(NULL, hdc);
     const natW = Math.round((contentWidth ?? svW / scale) * scale);
     const natH = Math.round((contentHeight ?? svH / scale) * scale);
     scrollXRef.current = Math.max(0, Math.min(scrollXRef.current, natW - svW));
     scrollYRef.current = Math.max(0, Math.min(scrollYRef.current, natH - svH));
-    gui13.SetWindowPos(
+    SetWindowPos(
       content,
       0,
       -scrollXRef.current,
@@ -16671,18 +17712,18 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
     );
     forceFlexLayout(content);
     if (natW > svW) {
-      gui13.SetScrollInfo(sv, 0, { min: 0, max: natW - 1, page: svW, pos: scrollXRef.current }, true);
-      gui13.ShowScrollBar(sv, 0, true);
+      gui12.SetScrollInfo(sv, 0, { min: 0, max: natW - 1, page: svW, pos: scrollXRef.current }, true);
+      ShowScrollBar(sv, 0, 1);
     } else {
       scrollXRef.current = 0;
-      gui13.ShowScrollBar(sv, 0, false);
+      ShowScrollBar(sv, 0, 0);
     }
     if (natH > svH) {
-      gui13.SetScrollInfo(sv, 1, { min: 0, max: natH - 1, page: svH, pos: scrollYRef.current }, true);
-      gui13.ShowScrollBar(sv, 1, true);
+      gui12.SetScrollInfo(sv, 1, { min: 0, max: natH - 1, page: svH, pos: scrollYRef.current }, true);
+      ShowScrollBar(sv, 1, 1);
     } else {
       scrollYRef.current = 0;
-      gui13.ShowScrollBar(sv, 1, false);
+      ShowScrollBar(sv, 1, 0);
     }
   }
   (0, import_react12.useLayoutEffect)(() => {
@@ -16698,7 +17739,7 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
     } else {
       scrollXRef.current = newPos;
     }
-    gui13.SetWindowPos(
+    SetWindowPos(
       content,
       0,
       -scrollXRef.current,
@@ -16708,14 +17749,14 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
       1 | 4
       /* gui.SetWindowPosFlag.SWP_NOZORDER */
     );
-    gui13.SetScrollInfo(sv, bar, { pos: newPos }, true);
+    gui12.SetScrollInfo(sv, bar, { pos: newPos }, true);
   }
   function handleScroll(e, bar) {
     const sv = svRef.current;
     const content = contentRef.current;
     if (!sv || !content)
       return;
-    const info = gui13.GetScrollInfo(sv, bar);
+    const info = gui12.GetScrollInfo(sv, bar);
     const maxPos = info.max - info.page + 1;
     const code = e.wParam & 65535;
     const ref_ = bar === 1 ? scrollYRef : scrollXRef;
@@ -16749,7 +17790,7 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
     if (!isHorz && contentHeight === void 0)
       return;
     const bar = isHorz ? 0 : 1;
-    const info = gui13.GetScrollInfo(sv, bar);
+    const info = gui12.GetScrollInfo(sv, bar);
     const maxPos = info.max - info.page + 1;
     const ref_ = isHorz ? scrollXRef : scrollYRef;
     let newPos = ref_.current + dy;
@@ -16766,7 +17807,7 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
   }, onEvent: {
     fn: (e) => {
       if (e.msg === 132 || e.msg === 161) {
-        return gui13.DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
+        return DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
       }
       if (e.msg === 277) {
         handleScroll(
@@ -16798,7 +17839,7 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
 // _build/lib/react-qw/components/Slider.js
 var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
 var import_react13 = __toESM(require_react(), 1);
-import * as gui14 from "gui";
+import * as gui13 from "gui";
 var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 100, vertical = false, disabled, style }, ref) => {
   const wrapperRef = (0, import_react13.useRef)(null);
   const sliderRef = (0, import_react13.useRef)(null);
@@ -16807,14 +17848,14 @@ var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 1
     if (!h)
       return;
     const lParam = min & 65535 | (max & 65535) << 16;
-    gui14.SendMessage(h, 1030, 0, lParam);
-    gui14.SendMessage(h, 1029, 1, value);
+    gui13.SendMessage(h, 1030, 0, lParam);
+    gui13.SendMessage(h, 1029, 1, value);
   }, [min, max]);
   (0, import_react13.useEffect)(() => {
     const h = sliderRef.current;
     if (!h)
       return;
-    gui14.SendMessage(h, 1029, 1, value);
+    gui13.SendMessage(h, 1029, 1, value);
   }, [value]);
   const tbStyle = 268435456 | 65536 | 1 | (vertical ? 2 : 0);
   return (0, import_jsx_runtime12.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style, ref: (h) => {
@@ -16825,13 +17866,13 @@ var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 1
       ref.current = h;
   }, onEvent: (e) => {
     if (e.msg === 132 || e.msg === 161) {
-      return gui14.DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
+      return DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
     }
     if (e.msg === 276 || e.msg === 277) {
       const h = sliderRef.current;
       if (!h)
         return 0;
-      const pos = gui14.SendMessage(h, 1024, 0, 0);
+      const pos = gui13.SendMessage(h, 1024, 0, 0);
       onChange?.(pos);
       return 0;
     }
@@ -16844,18 +17885,7 @@ var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 1
 // _build/lib/react-qw/components/Tab.js
 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";
-function textToUtf163(s) {
-  const buf = new ArrayBuffer((s.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < s.length; i++)
-    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;
-}
+import * as gui14 from "gui";
 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;
@@ -16865,32 +17895,36 @@ var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex
     const h = tabHwnd.current;
     if (!h)
       return;
-    gui15.SendMessage(h, 4873, 0, 0);
+    gui14.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);
-      gui15.SendMessage(h, 4926, i, tciPtr);
+      const titleBuf = WCHAR.encode(tabs[i].title);
+      const tci = TCITEMW.encode({
+        mask: 1,
+        dwState: 0,
+        dwStateMask: 0,
+        pszText: titleBuf.ptr,
+        cchTextMax: tabs[i].title.length + 1,
+        iImage: 0,
+        lParam: 0
+      });
+      const tciPtr = tci.ptr;
+      gui14.SendMessage(h, 4926, i, tciPtr);
     }
-    gui15.SendMessage(h, 4876, sel, 0);
+    gui14.SendMessage(h, 4876, sel, 0);
   }, [tabs]);
   (0, import_react14.useEffect)(() => {
     const h = tabHwnd.current;
     if (h)
-      gui15.SendMessage(h, 4876, sel, 0);
+      gui14.SendMessage(h, 4876, sel, 0);
   }, [sel]);
   return (0, import_jsx_runtime13.jsxs)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, ref, onEvent: (e) => {
     if (e.msg === 78) {
       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);
+        const newSel = gui14.SendMessage(h, 4875, 0, 0);
         if (newSel !== sel) {
           if (!isControlled)
             setInternalIndex(newSel);
@@ -16903,79 +17937,50 @@ 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 gui15 from "gui";
 
 // _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";
-function textToUtf164(s) {
-  const buf = new ArrayBuffer((s.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < s.length; i++)
-    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);
-}
+import * as gui16 from "gui";
 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.encode({
+    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 hItem = gui17.SendMessage(hTree, 4402, 0, bufPtr3(tvins));
+    const textBuf = WCHAR.encode(node.label);
+    const itemBuf = buildTvItem(textBuf.ptr, cChildren);
+    const item = TVITEM.decode(itemBuf);
+    const tvins = TVINSERTSTRUCT.encode({ hParent: parentHandle, hInsertAfter: -65536, item });
+    const hItem = gui16.SendMessage(hTree, 4402, 0, tvins.ptr);
     hItemMap.set(hItem, node);
     if (node.key)
       keyMap.set(node.key, hItem);
     if (node.children && node.children.length > 0) {
       insertItems(hTree, node.children, hItem, hItemMap, keyMap);
-      gui17.SendMessage(hTree, 4354, 2, hItem);
+      gui16.SendMessage(hTree, 4354, 2, hItem);
     }
   }
 }
 function deleteAllItems(hTree) {
-  const n = gui17.SendMessage(hTree, 4357, 0, 0);
+  const n = gui16.SendMessage(hTree, 4357, 0, 0);
   if (n > 0)
-    gui17.SendMessage(
+    gui16.SendMessage(
       hTree,
       4353,
       1,
@@ -17007,7 +18012,7 @@ var TreeView = (0, import_react16.forwardRef)(function TreeViewInner({ data, onS
     const h = tvRef.current;
     if (!h)
       return;
-    gui17.SendMessage(
+    gui16.SendMessage(
       h,
       4396,
       0,
@@ -17023,16 +18028,16 @@ var TreeView = (0, import_react16.forwardRef)(function TreeViewInner({ data, onS
       return;
     const hItem = keyMapRef.current.get(selKey);
     if (hItem !== void 0)
-      gui17.SendMessage(h, 4363, 9, hItem);
+      gui16.SendMessage(h, 4363, 9, hItem);
   }, [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)
           return;
-        const hCaret = gui17.SendMessage(h, 4362, 9, 0);
+        const hCaret = gui16.SendMessage(h, 4362, 9, 0);
         const node = hItemMapRef.current.get(hCaret) ?? null;
         const key = node?.key ?? null;
         if (!isControlled)
@@ -17048,99 +18053,63 @@ 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 win3 from "win";
-var FFI_PTR2 = ffi9.FFI_TYPE_POINTER;
-var FFI_U32 = ffi9.FFI_TYPE_UINT32;
-var _GetOpenFileNameW = 0;
-var _SHBrowseForFolderW = 0;
-var _SHGetPathFromIDListW = 0;
-var _CoTaskMemFree = 0;
-function ensureDlls() {
-  if (_GetOpenFileNameW)
-    return true;
-  const comdlg32 = win3.LoadLibrary("comdlg32.dll");
-  const shell32 = win3.LoadLibrary("shell32.dll");
-  const ole32 = win3.LoadLibrary("ole32.dll");
-  if (!comdlg32 || !shell32 || !ole32)
-    return false;
-  const load = (lib, name) => win3.GetProcAddress(lib, name) || 0;
-  _GetOpenFileNameW = load(comdlg32, "GetOpenFileNameW");
-  _SHBrowseForFolderW = load(shell32, "SHBrowseForFolderW");
-  _SHGetPathFromIDListW = load(shell32, "SHGetPathFromIDListW");
-  _CoTaskMemFree = load(ole32, "CoTaskMemFree");
-  return !!_GetOpenFileNameW && !!_SHBrowseForFolderW && !!_SHGetPathFromIDListW && !!_CoTaskMemFree;
-}
-function strToWide(s) {
-  return new TextEncoder("utf-16le").encode(s + "\0").buffer;
-}
-var _decoder = new TextDecoder("utf-16le");
-function wideToStr(buf, offset = 0) {
-  const str = _decoder.decode(new Uint8Array(buf, offset));
-  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);
-}
+
+// _build/lib/windows/comdlg32.js
+var b3 = (name, sig) => bind("comdlg32.dll", name, sig);
+var GetOpenFileName = /* @__PURE__ */ b3("GetOpenFileNameW", "<BYTE>ptr -> u32");
+
+// _build/lib/windows/shell32.js
+var b4 = (name, sig) => bind("shell32.dll", name, sig);
+var SHBrowseForFolder = /* @__PURE__ */ b4("SHBrowseForFolderW", "<BYTE>ptr -> <>ptr");
+var SHGetPathFromIDList = /* @__PURE__ */ b4("SHGetPathFromIDListW", "<>ptr <BYTE>ptr -> u32");
+
+// _build/lib/windows/ole32.js
+var b5 = (name, sig) => bind("ole32.dll", name, sig);
+var CoTaskMemFree = /* @__PURE__ */ b5("CoTaskMemFree", "<>ptr -> void");
+
+// _build/lib/react-qw/components/PathPicker.js
 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);
+  const fileBuf = WCHAR.alloc(260);
+  const filterWide = WCHAR.encode(filter);
+  const titleWide = title ? WCHAR.encode(title) : null;
   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.encode({
+    lStructSize: OPENFILENAMEW.size,
+    hwndOwner: owner,
+    lpstrFilter: filterWide.ptr,
+    lpstrFile: fileBuf.ptr,
+    nMaxFile: 260,
+    lpstrTitle: titleWide?.ptr ?? 0,
+    Flags: flags
+  });
+  const ret = GetOpenFileName(ofn);
   if (!ret)
     return null;
   if (!multiple) {
-    return wideToStr(fileBuf);
+    return WCHAR.decode(fileBuf);
   }
-  const dir = wideToStr(fileBuf);
-  let pos = (dir.length + 1) * 2;
-  const files = [];
-  while (pos < fileBuf.byteLength) {
-    const f = wideToStr(fileBuf, pos);
-    if (f.length === 0)
-      break;
-    files.push(dir + "\\" + f);
-    pos += (f.length + 1) * 2;
-  }
-  if (files.length === 0)
-    return [dir];
-  return files;
+  const strs = new TextDecoder("utf-16le").decode(new Uint8Array(fileBuf)).split("\0");
+  const dir = strs[0] ?? "";
+  const files = strs.slice(1).filter((f) => f.length > 0).map((f) => dir + "\\" + f);
+  return files.length > 0 ? files : [dir];
 }
 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 titleWide = title ? WCHAR.encode(title) : null;
+  const bi = BROWSEINFOW.encode({
+    hwndOwner: owner,
+    lpszTitle: titleWide?.ptr ?? 0,
+    ulFlags: 65
+  });
+  const pidl = SHBrowseForFolder(bi);
   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);
-  return ok ? wideToStr(pathBuf) : null;
+  const pathBuf = WCHAR.alloc(260);
+  const ok = SHGetPathFromIDList(pidl, pathBuf);
+  CoTaskMemFree(pidl);
+  return ok ? WCHAR.decode(pathBuf) : null;
 }
 var PathPicker = (0, import_react17.forwardRef)((props, ref) => {
   const { type = "file", filter = "All Files\0*.*\0\0", title, disabled, style } = props;
@@ -17191,7 +18160,7 @@ var rootMap = /* @__PURE__ */ new Map();
 function ensureDefaultClass() {
   if (defaultClassRegistered)
     return DEFAULT_CLASS;
-  gui18.RegisterClass(DEFAULT_CLASS, (hwnd, msg, wParam, lParam) => {
+  gui17.RegisterClass(DEFAULT_CLASS, (hwnd, msg, wParam, lParam) => {
     const entry = rootMap.get(hwnd);
     if (msg === 2 && entry) {
       rootMap.delete(hwnd);
@@ -17204,7 +18173,7 @@ function ensureDefaultClass() {
       return result;
     if (msg === 5)
       forceFlexLayout(hwnd);
-    return gui18.DefWindowProc(hwnd, msg, wParam, lParam);
+    return DefWindowProc(hwnd, msg, wParam, lParam);
   });
   defaultClassRegistered = true;
   return DEFAULT_CLASS;
@@ -17217,15 +18186,15 @@ function createRoot(container) {
     const ws = (cfg.ws ?? 0) | 13565952;
     const w = (cfg.width ?? 800) * scaleFactor;
     const h = (cfg.height ?? 600) * scaleFactor;
-    const [sw, sh] = gui18.GetScreenSize();
+    const [sw, sh] = [GetSystemMetrics(0), GetSystemMetrics(1)];
     const x = cfg.x === void 0 ? (sw - w) / 2 | 0 : cfg.x === -2147483648 ? -2147483648 : cfg.x * scaleFactor;
     const y = cfg.y === void 0 ? (sh - h) / 2 | 0 : cfg.y === -2147483648 ? -2147483648 : cfg.y * scaleFactor;
-    const hwin = gui18.CreateWindow(className, cfg.text || "", ws, x, y, w, h, null, null);
+    const hwin = gui17.CreateWindow(className, cfg.text || "", ws, x, y, w, h, null, null);
     if (!hwin)
       throw new Error("CreateWindow failed");
     hwnd = hwin;
     if (!cfg.noShowWindow)
-      gui18.ShowWindow(hwnd);
+      gui17.ShowWindow(hwnd);
   } else {
     hwnd = container;
   }
@@ -17255,33 +18224,8 @@ function render(element, containerOrConfig, _callback) {
 // _build/examples/PdfCanvas.js
 var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
 var import_react18 = __toESM(require_react(), 1);
-import * as win4 from "win";
-import * as ffi10 from "ffi";
-var _user32 = win4.LoadLibrary("user32.dll");
-var _gdi32 = win4.LoadLibrary("gdi32.dll");
-if (!_user32 || !_gdi32)
-  throw new Error("Failed to load user32/gdi32");
-function loadProc2(lib, name) {
-  const ptr = win4.GetProcAddress(lib, name);
-  if (!ptr)
-    throw new Error("Failed to load " + name);
-  return ptr;
-}
-var GetDC_ = loadProc2(_user32, "GetDC");
-var ReleaseDC_ = loadProc2(_user32, "ReleaseDC");
-var SetDIBitsToDevice_ = loadProc2(_gdi32, "SetDIBitsToDevice");
-var FFI_PTR3 = ffi10.FFI_TYPE_POINTER;
-var FFI_U322 = ffi10.FFI_TYPE_UINT32;
-var FFI_S322 = ffi10.FFI_TYPE_SINT32;
 function makeBitmapInfo(w, h) {
-  const bmi = new ArrayBuffer(40);
-  const bv = new DataView(bmi);
-  bv.setUint32(0, 40, true);
-  bv.setInt32(4, w, true);
-  bv.setInt32(8, -h, true);
-  bv.setUint16(12, 1, true);
-  bv.setUint16(14, 24, true);
-  return bmi;
+  return BITMAPINFOHEADER.encode({ biSize: BITMAPINFOHEADER.size, biWidth: w, biHeight: -h, biPlanes: 1, biBitCount: 24 });
 }
 var PdfCanvas = (0, import_react18.forwardRef)(({ pixmap, style }, ref) => {
   const canvasRef = (0, import_react18.useRef)(null);
@@ -17301,37 +18245,11 @@ var PdfCanvas = (0, import_react18.forwardRef)(({ pixmap, style }, ref) => {
       const pm = pixmapRef.current;
       if (!pm)
         return 0;
-      const hdc = ffi10.ffiCall(GetDC_, [ffi10.FFI_TYPE_UINT64], [hwnd], ffi10.FFI_TYPE_UINT64);
+      const hdc = GetDC(hwnd);
       if (hdc) {
         const bmi = makeBitmapInfo(pm.w, pm.h);
-        ffi10.ffiCall(SetDIBitsToDevice_, [
-          ffi10.FFI_TYPE_UINT64,
-          FFI_S322,
-          FFI_S322,
-          FFI_U322,
-          FFI_U322,
-          FFI_S322,
-          FFI_S322,
-          FFI_U322,
-          FFI_U322,
-          FFI_PTR3,
-          FFI_PTR3,
-          FFI_U322
-        ], [
-          hdc,
-          0,
-          0,
-          pm.w,
-          pm.h,
-          0,
-          0,
-          0,
-          pm.h,
-          pm.data,
-          bmi,
-          0
-        ], FFI_S322);
-        ffi10.ffiCall(ReleaseDC_, [ffi10.FFI_TYPE_UINT64, ffi10.FFI_TYPE_UINT64], [hwnd, hdc], FFI_S322);
+        SetDIBitsToDevice(hdc, 0, 0, pm.w, pm.h, 0, 0, 0, pm.h, pm.data, bmi, 0);
+        ReleaseDC(hwnd, hdc);
       }
       return 0;
     }
@@ -17340,67 +18258,29 @@ var PdfCanvas = (0, import_react18.forwardRef)(({ pixmap, style }, ref) => {
 });
 
 // _build/examples/pdf_viewer.js
-var _user322 = win5.LoadLibrary("user32.dll");
-var _gdi322 = win5.LoadLibrary("gdi32.dll");
-var _comdlg32 = win5.LoadLibrary("comdlg32.dll");
-if (!_user322 || !_gdi322 || !_comdlg32) {
-  gui19.MessageBox("Failed to load system libraries");
-  std.exit(0);
-}
-function loadProc3(lib, name) {
-  const ptr = win5.GetProcAddress(lib, name);
-  if (!ptr)
-    throw new Error("Failed to load " + name);
-  return ptr;
-}
-var GetOpenFileNameW_ = loadProc3(_comdlg32, "GetOpenFileNameW");
-var FFI_PTR4 = ffi11.FFI_TYPE_POINTER;
-var FFI_U323 = ffi11.FFI_TYPE_UINT32;
-function strToWide2(str) {
-  const buf = new ArrayBuffer((str.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < str.length; i++)
-    dv.setUint16(i * 2, str.charCodeAt(i), true);
-  return buf;
-}
-function wideToStr2(buf) {
-  const dv = new DataView(buf);
-  const chars = [];
-  for (let i = 0; i < buf.byteLength; i += 2) {
-    const c = dv.getUint16(i, true);
-    if (c === 0)
-      break;
-    chars.push(c);
-  }
-  return String.fromCharCode(...chars);
-}
-function setPtr3(dv, off, ptr) {
-  dv.setUint32(off, ptr & 4294967295, true);
-  dv.setUint32(off + 4, Math.floor(ptr / 4294967296), true);
-}
 function openPdfFileDialog(owner) {
-  const structBuf = new ArrayBuffer(152);
-  const sv = new DataView(structBuf);
-  const fileBuf = new ArrayBuffer(260 * 2);
-  const filterWide = strToWide2("PDF Files\0*.pdf\0All Files\0*.*\0\0");
-  sv.setUint32(0, 152, true);
-  sv.setUint32(8, owner & 4294967295, true);
-  sv.setUint32(12, Math.floor(owner / 4294967296), true);
-  setPtr3(sv, 24, ffi11.bufferPtr(filterWide));
-  setPtr3(sv, 48, ffi11.bufferPtr(fileBuf));
-  sv.setUint32(56, 260, true);
-  sv.setUint32(96, 4096 | 2048 | 4, true);
-  const ret = ffi11.ffiCall(GetOpenFileNameW_, [FFI_PTR4], [structBuf], FFI_U323);
+  const fileBuf = WCHAR.alloc(260);
+  const filterWide = WCHAR.encode("PDF Files\0*.pdf\0All Files\0*.*\0\0");
+  const ofn = OPENFILENAMEW.encode({
+    lStructSize: OPENFILENAMEW.size,
+    hwndOwner: owner,
+    lpstrFilter: filterWide.ptr,
+    lpstrFile: fileBuf.ptr,
+    nMaxFile: 260,
+    Flags: 4096 | 2048 | 4
+  });
+  ofn.__keep = [fileBuf, filterWide];
+  const ret = GetOpenFileName(ofn);
   if (!ret)
     return null;
-  const path = wideToStr2(fileBuf);
+  const path = WCHAR.decode(fileBuf);
   return path.length > 0 ? path : null;
 }
 async function loadMupdf() {
   const wasmPath = "./vendor/mupdf-wasm/mupdf-wasm.wasm";
-  const fp = std.open(wasmPath, "rb");
+  const fp = std2.open(wasmPath, "rb");
   if (!fp) {
-    std.printf("Error: cannot open %s\n", wasmPath);
+    std2.printf("Error: cannot open %s\n", wasmPath);
     return null;
   }
   fp.seek(0, 2);
@@ -17416,7 +18296,7 @@ async function loadMupdf() {
   try {
     return await import("../vendor/mupdf-wasm/mupdf.js");
   } catch (e) {
-    std.printf("Error: mupdf load failed: %s\n", String(e));
+    std2.printf("Error: mupdf load failed: %s\n", String(e));
     return null;
   }
 }
@@ -17434,9 +18314,9 @@ function renderPdfPage(mupdf, filePath, pageIndex) {
     cachedDoc = null;
     cachedPath = "";
     cachedTotalPages = 0;
-    const fp = std.open(filePath, "rb");
+    const fp = std2.open(filePath, "rb");
     if (!fp) {
-      std.printf("Error: cannot open %s\n", filePath);
+      std2.printf("Error: cannot open %s\n", filePath);
       return null;
     }
     let buf = null;
@@ -17456,7 +18336,7 @@ function renderPdfPage(mupdf, filePath, pageIndex) {
       cachedTotalPages = cachedDoc.countPages();
       cachedPath = filePath;
     } catch (e) {
-      std.printf("Error opening document: %s\n", String(e));
+      std2.printf("Error opening document: %s\n", String(e));
       return null;
     }
   }
@@ -17478,7 +18358,7 @@ function renderPdfPage(mupdf, filePath, pageIndex) {
     const h = pixmap.getHeight();
     const dibStride = Math.floor((w * 3 + 3) / 4) * 4;
     const dibSize = h * dibStride;
-    const dibBuffer = new ArrayBuffer(dibSize);
+    const dibBuffer = new PtrArrayBuffer(dibSize);
     const dib = new Uint8Array(dibBuffer);
     for (let y = 0; y < h; y++) {
       const srcOff = y * srcStride;
@@ -17493,7 +18373,7 @@ function renderPdfPage(mupdf, filePath, pageIndex) {
     }
     return { data: dibBuffer, w, h, totalPages: cachedTotalPages };
   } catch (e) {
-    std.printf("Error rendering: %s\n", String(e));
+    std2.printf("Error rendering: %s\n", String(e));
     if (cachedDoc) {
       try {
         cachedDoc.destroy();
@@ -17531,7 +18411,7 @@ function App({ mupdf, mainHwnd: hwnd }) {
       setCurrentPage(page);
       setTotalPages(result.totalPages);
     } else {
-      gui19.MessageBox("Failed to render PDF page");
+      gui18.MessageBox("Failed to render PDF page");
     }
   }
   function handleOpen() {
@@ -17554,14 +18434,14 @@ function App({ mupdf, mainHwnd: hwnd }) {
 async function main() {
   const mupdf = await loadMupdf();
   if (!mupdf) {
-    gui19.MessageBox("Loading mupdf WASM failed.\nEnsure vendor/mupdf-wasm/ is present.");
+    gui18.MessageBox("Loading mupdf WASM failed.\nEnsure vendor/mupdf-wasm/ is present.");
     return;
   }
-  gui19.RegisterClass("PdfViewerWin");
-  const hwnd = gui19.CreateWindow("PdfViewerWin", "PDF Viewer", 13565952, 100, 100, 1200, 800, null, null);
+  gui18.RegisterClass("PdfViewerWin");
+  const hwnd = gui18.CreateWindow("PdfViewerWin", "PDF Viewer", 13565952, 100, 100, 1200, 800, null, null);
   if (hwnd) {
     render((0, import_jsx_runtime17.jsx)(App, { mupdf, mainHwnd: hwnd }), hwnd);
-    setTimeout(() => gui19.ShowWindow(hwnd), 0);
+    setTimeout(() => gui18.ShowWindow(hwnd), 0);
   }
 }
 main();