@gjsify/example-dom-canvas2d-fireworks 0.2.0 → 0.3.1

package/dist/gjs.js

@@ -1,3 +1,5 @@
+if(typeof globalThis.process==="undefined"){const _s=imports.system,_G=imports.gi.GLib;globalThis.process={platform:"linux",arch:"x64",version:"v20.0.0",env:new Proxy({},{get(_,p){return typeof p==="string"?(_G.getenv(p)??undefined):undefined},set(_,p,v){if(typeof p==="string")_G.setenv(p,String(v),true);return true},has(_,p){return typeof p==="string"&&_G.getenv(p)!==null},deleteProperty(_,p){if(typeof p==="string")_G.unsetenv(p);return true},ownKeys(){return _G.listenv()??[]},getOwnPropertyDescriptor(_,p){const v=_G.getenv(p);return v!==null?{value:v,writable:true,enumerable:true,configurable:true}:undefined}}),argv:_s?.programArgs?["gjs",_s.programInvocationName||"",..._s.programArgs]:["gjs"],versions:{},config:{},cwd(){return _G.get_current_dir()||"/"},exit(c){_s.exit(c??0)},stderr:{write(s){printerr(s)}},stdout:{write(s){print(s)}},stdin:null,exitCode:undefined,nextTick(fn,...a){Promise.resolve().then(()=>fn(...a))},hrtime(t){return t?[0,0]:[0,0]},};}
+
 // ../../../packages/infra/esbuild-plugin-gjsify/dist/shims/console-gjs.js
 var _isGJS = typeof print === "function" && typeof printerr === "function";
 function _formatArgs(...args) {
@@ -39,10 +41,10 @@ var Console = class {
   _groupIndentation;
   _timers = /* @__PURE__ */ new Map();
   _counters = /* @__PURE__ */ new Map();
-  constructor(stdoutOrOptions, stderr) {
+  constructor(stdoutOrOptions, stderr2) {
     if (stdoutOrOptions && typeof stdoutOrOptions.write === "function") {
       this._stdout = stdoutOrOptions;
-      this._stderr = stderr || this._stdout;
+      this._stderr = stderr2 || this._stdout;
     } else if (stdoutOrOptions && typeof stdoutOrOptions === "object") {
       const opts = stdoutOrOptions;
       this._stdout = opts.stdout;
@@ -218,10 +220,57 @@ var console = {
   timeStamp
 };
 
+// ../../../packages/gjs/utils/lib/esm/callable.js
+function makeCallable(Cls) {
+  return new Proxy(Cls, {
+    apply(target, thisArg, args) {
+      const tmp = Reflect.construct(target, args, target);
+      for (const key of Reflect.ownKeys(tmp)) {
+        const desc = Object.getOwnPropertyDescriptor(tmp, key);
+        if (desc) Object.defineProperty(thisArg, key, desc);
+      }
+      return thisArg;
+    }
+  });
+}
+
 // ../../../packages/gjs/utils/lib/esm/base64.js
 var B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var B64_LOOKUP = new Uint8Array(256);
 for (let i = 0; i < B64_CHARS.length; i++) B64_LOOKUP[B64_CHARS.charCodeAt(i)] = i;
+function btoaPolyfill(str) {
+  if (typeof globalThis.btoa === "function") return globalThis.btoa(str);
+  let result = "";
+  let i = 0;
+  for (; i + 2 < str.length; i += 3) {
+    const n = str.charCodeAt(i) << 16 | str.charCodeAt(i + 1) << 8 | str.charCodeAt(i + 2);
+    result += B64_CHARS[n >> 18 & 63] + B64_CHARS[n >> 12 & 63] + B64_CHARS[n >> 6 & 63] + B64_CHARS[n & 63];
+  }
+  if (i + 1 === str.length) {
+    const n = str.charCodeAt(i) << 16;
+    result += B64_CHARS[n >> 18 & 63] + B64_CHARS[n >> 12 & 63] + "==";
+  } else if (i + 2 === str.length) {
+    const n = str.charCodeAt(i) << 16 | str.charCodeAt(i + 1) << 8;
+    result += B64_CHARS[n >> 18 & 63] + B64_CHARS[n >> 12 & 63] + B64_CHARS[n >> 6 & 63] + "=";
+  }
+  return result;
+}
+function base64Decode(str) {
+  const cleaned = str.replace(/[=\s]/g, "");
+  const bytes = new Uint8Array(cleaned.length * 3 >> 2);
+  let bits = 0;
+  let collected = 0;
+  let pos = 0;
+  for (let i = 0; i < cleaned.length; i++) {
+    bits = bits << 6 | B64_LOOKUP[cleaned.charCodeAt(i)];
+    collected += 6;
+    if (collected >= 8) {
+      collected -= 8;
+      bytes[pos++] = bits >> collected & 255;
+    }
+  }
+  return bytes.subarray(0, pos);
+}
 
 // ../../../node_modules/@girs/glib-2.0/glib-2.0.js
 import GLib from "gi://GLib?version=2.0";
@@ -233,6 +282,39 @@ var glib_2_default = glib_2_0_default;
 // ../../../packages/gjs/utils/lib/esm/cli.js
 var byteArray = imports.byteArray;
 
+// ../../../packages/gjs/utils/lib/esm/encoding.js
+var VALID_ENCODINGS = ["utf8", "ascii", "latin1", "binary", "base64", "base64url", "hex", "ucs2", "utf16le"];
+function normalizeEncoding(enc) {
+  if (!enc || enc === "utf8" || enc === "utf-8") return "utf8";
+  const lower = ("" + enc).toLowerCase().replace(/-/g, "");
+  switch (lower) {
+    case "utf8":
+      return "utf8";
+    case "ascii":
+      return "ascii";
+    case "latin1":
+    case "binary":
+      return "latin1";
+    case "base64":
+      return "base64";
+    case "base64url":
+      return "base64url";
+    case "hex":
+      return "hex";
+    case "ucs2":
+    case "utf16le":
+      return "utf16le";
+    default:
+      return "utf8";
+  }
+}
+function checkEncoding(encoding) {
+  const lower = ("" + encoding).toLowerCase().replace(/-/g, "");
+  if (!VALID_ENCODINGS.includes(lower)) {
+    throw new TypeError(`Unknown encoding: ${encoding}`);
+  }
+}
+
 // ../../../packages/gjs/utils/lib/esm/globals.js
 function registerGlobal(name2, value2) {
   if (typeof globalThis[name2] === "undefined") {
@@ -240,6 +322,26 @@ function registerGlobal(name2, value2) {
   }
 }
 
+// ../../../packages/gjs/utils/lib/esm/error.js
+var initErrorV8Methods = (ErrorConstructor) => {
+  if (!Error.captureStackTrace) {
+    Error.captureStackTrace = function(targetObject, constructorOpt) {
+      const container = new Error();
+      const target = constructorOpt || targetObject;
+      Object.defineProperty(target, "stack", {
+        configurable: true,
+        get: function getStack() {
+          var stack = container.stack;
+          Object.defineProperty(this, "stack", {
+            value: stack
+          });
+          return stack;
+        }
+      });
+    };
+  }
+};
+
 // ../../../packages/gjs/utils/lib/esm/file.js
 var byteArray2 = imports.byteArray;
 
@@ -256,12 +358,43 @@ import GioUnix from "gi://GioUnix?version=2.0";
 // ../../../packages/gjs/utils/lib/esm/gio.js
 var byteArray3 = imports.byteArray;
 
+// ../../../packages/gjs/utils/lib/esm/microtask.js
+var queueMicrotask2 = (fn) => {
+  Promise.resolve().then(fn);
+};
+
 // ../../../packages/gjs/utils/lib/esm/path.js
 var { File } = gio_2_default;
 
 // ../../../packages/gjs/utils/lib/esm/structured-clone.js
 var { toString } = Object.prototype;
 
+// ../../../packages/gjs/utils/lib/esm/main-loop.js
+var _started = false;
+var _loop = null;
+function ensureMainLoop() {
+  const gjsImports = globalThis.imports;
+  if (!gjsImports) return void 0;
+  if (_started) return _loop;
+  const GLibModule = gjsImports.gi.GLib;
+  _loop = new GLibModule.MainLoop(null, false);
+  _started = true;
+  if (GLibModule.main_depth() === 0) {
+    try {
+      _loop.runAsync();
+    } catch {
+    }
+  }
+  return _loop;
+}
+function quitMainLoop() {
+  if (_loop) {
+    _loop.quit();
+    _started = false;
+    _loop = null;
+  }
+}
+
 // ../../../packages/node/buffer/lib/esm/blob.js
 var _encoder = new TextEncoder();
 var BlobPolyfill = class _BlobPolyfill {
@@ -485,7 +618,7 @@ var EventTarget = class {
   addEventListener(type, callback, options) {
     if (callback === null) return;
     const capture = typeof options === "boolean" ? options : options?.capture ?? false;
-    const once = typeof options === "object" ? options?.once ?? false : false;
+    const once2 = typeof options === "object" ? options?.once ?? false : false;
     const passive = typeof options === "object" ? options?.passive ?? false : false;
     let list = this._listeners.get(type);
     if (!list) {
@@ -495,7 +628,7 @@ var EventTarget = class {
     for (const entry2 of list) {
       if (entry2.listener === callback && entry2.capture === capture) return;
     }
-    const entry = { listener: callback, capture, once, passive, removed: false };
+    const entry = { listener: callback, capture, once: once2, passive, removed: false };
     list.push(entry);
     if (typeof options === "object" && options?.signal) {
       options.signal.addEventListener("abort", () => {
@@ -2864,10 +2997,672 @@ if (typeof globalThis.top === "undefined") {
   });
 }
 
+// ../../../packages/node/buffer/lib/esm/buffer.js
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+var hasSharedArrayBuffer = typeof SharedArrayBuffer !== "undefined";
+function encodeString(str, encoding) {
+  switch (encoding) {
+    case "utf8":
+      return textEncoder.encode(str);
+    case "ascii": {
+      const buf = new Uint8Array(str.length);
+      for (let i = 0; i < str.length; i++) {
+        buf[i] = str.charCodeAt(i) & 127;
+      }
+      return buf;
+    }
+    case "latin1": {
+      const buf = new Uint8Array(str.length);
+      for (let i = 0; i < str.length; i++) {
+        buf[i] = str.charCodeAt(i) & 255;
+      }
+      return buf;
+    }
+    case "base64": {
+      const standard = str.replace(/-/g, "+").replace(/_/g, "/");
+      return base64Decode(standard);
+    }
+    case "base64url": {
+      const base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+      return encodeString(base64, "base64");
+    }
+    case "hex": {
+      const bytes = str.length >>> 1;
+      const buf = new Uint8Array(bytes);
+      for (let i = 0; i < bytes; i++) {
+        const hi = parseInt(str[i * 2], 16);
+        const lo = parseInt(str[i * 2 + 1], 16);
+        if (Number.isNaN(hi) || Number.isNaN(lo)) break;
+        buf[i] = hi << 4 | lo;
+      }
+      return buf;
+    }
+    case "utf16le": {
+      const buf = new Uint8Array(str.length * 2);
+      for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        buf[i * 2] = code & 255;
+        buf[i * 2 + 1] = code >> 8 & 255;
+      }
+      return buf;
+    }
+    default:
+      return textEncoder.encode(str);
+  }
+}
+function decodeString(buf, encoding, start2, end) {
+  const slice = start2 !== void 0 || end !== void 0 ? buf.subarray(start2 ?? 0, end ?? buf.length) : buf;
+  switch (encoding) {
+    case "utf8":
+      return textDecoder.decode(slice);
+    case "ascii": {
+      let result = "";
+      for (let i = 0; i < slice.length; i++) {
+        result += String.fromCharCode(slice[i] & 127);
+      }
+      return result;
+    }
+    case "latin1": {
+      let result = "";
+      for (let i = 0; i < slice.length; i++) {
+        result += String.fromCharCode(slice[i]);
+      }
+      return result;
+    }
+    case "base64": {
+      let binary = "";
+      for (let i = 0; i < slice.length; i++) {
+        binary += String.fromCharCode(slice[i]);
+      }
+      return btoaPolyfill(binary);
+    }
+    case "base64url": {
+      const base64 = decodeString(slice, "base64");
+      return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    }
+    case "hex": {
+      let result = "";
+      for (let i = 0; i < slice.length; i++) {
+        result += slice[i].toString(16).padStart(2, "0");
+      }
+      return result;
+    }
+    case "utf16le": {
+      let result = "";
+      for (let i = 0; i + 1 < slice.length; i += 2) {
+        result += String.fromCharCode(slice[i] | slice[i + 1] << 8);
+      }
+      return result;
+    }
+    default:
+      return textDecoder.decode(slice);
+  }
+}
+function checkOffset(offset, ext, length) {
+  if (offset + ext > length) {
+    throw new RangeError("Attempt to access memory outside buffer bounds");
+  }
+}
+var Buffer2 = class _Buffer extends Uint8Array {
+  // Marker to identify Buffer instances
+  static _isBuffer = true;
+  // ---- Static constructors ----
+  static alloc(size, fill, encoding) {
+    if (typeof size !== "number") {
+      throw new TypeError(`The "size" argument must be of type number. Received type ${typeof size}`);
+    }
+    if (size < 0) {
+      throw new RangeError(`The value "${size}" is invalid for option "size"`);
+    }
+    const buf = new _Buffer(size);
+    if (fill !== void 0 && fill !== 0) {
+      buf.fill(fill, 0, size, encoding);
+    }
+    return buf;
+  }
+  static allocUnsafe(size) {
+    if (typeof size !== "number") {
+      throw new TypeError(`The "size" argument must be of type number. Received type ${typeof size}`);
+    }
+    return new _Buffer(size);
+  }
+  static allocUnsafeSlow(size) {
+    return _Buffer.allocUnsafe(size);
+  }
+  static from(value2, encodingOrOffset, length) {
+    if (typeof value2 === "string") {
+      const encoding = normalizeEncoding(encodingOrOffset);
+      if (encodingOrOffset && typeof encodingOrOffset === "string") {
+        const lower = ("" + encodingOrOffset).toLowerCase().replace(/-/g, "");
+        const valid = ["utf8", "ascii", "latin1", "binary", "base64", "base64url", "hex", "ucs2", "utf16le", ""];
+        if (!valid.includes(lower)) {
+          checkEncoding(encodingOrOffset);
+        }
+      }
+      const encoded = encodeString(value2, encoding);
+      const buf = new _Buffer(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+      return buf;
+    }
+    if (ArrayBuffer.isView(value2)) {
+      const buf = new _Buffer(value2.buffer, value2.byteOffset, value2.byteLength);
+      const copy = new _Buffer(buf.length);
+      copy.set(buf);
+      return copy;
+    }
+    if (value2 instanceof ArrayBuffer) {
+      const offset = encodingOrOffset || 0;
+      const len = length !== void 0 ? length : value2.byteLength - offset;
+      return new _Buffer(value2, offset, len);
+    }
+    if (hasSharedArrayBuffer && value2 instanceof SharedArrayBuffer) {
+      const offset = encodingOrOffset || 0;
+      const len = length !== void 0 ? length : value2.byteLength - offset;
+      return new _Buffer(new Uint8Array(value2, offset, len));
+    }
+    if (Array.isArray(value2)) {
+      const buf = new _Buffer(value2.length);
+      for (let i = 0; i < value2.length; i++) {
+        buf[i] = value2[i] & 255;
+      }
+      return buf;
+    }
+    throw new TypeError("The first argument must be of type string or an instance of Buffer, ArrayBuffer, or Array");
+  }
+  // ---- Static methods ----
+  static isBuffer(obj) {
+    return obj instanceof _Buffer;
+  }
+  static isEncoding(encoding) {
+    if (typeof encoding !== "string") return false;
+    const lower = encoding.toLowerCase().replace(/-/g, "");
+    return ["utf8", "ascii", "latin1", "binary", "base64", "base64url", "hex", "ucs2", "utf16le"].includes(lower);
+  }
+  static byteLength(string, encoding) {
+    if (typeof string !== "string") {
+      if (ArrayBuffer.isView(string)) return string.byteLength;
+      if (string instanceof ArrayBuffer) return string.byteLength;
+      if (hasSharedArrayBuffer && string instanceof SharedArrayBuffer) return string.byteLength;
+      throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer');
+    }
+    const enc = normalizeEncoding(encoding);
+    switch (enc) {
+      case "utf8":
+        return textEncoder.encode(string).byteLength;
+      case "ascii":
+      case "latin1":
+        return string.length;
+      case "base64":
+      case "base64url": {
+        let len = string.length;
+        while (len > 0 && (string[len - 1] === "=" || string[len - 1] === " ")) len--;
+        return len * 3 >>> 2;
+      }
+      case "hex":
+        return string.length >>> 1;
+      case "utf16le":
+        return string.length * 2;
+      default:
+        return textEncoder.encode(string).byteLength;
+    }
+  }
+  static compare(buf1, buf2) {
+    if (!(buf1 instanceof Uint8Array) || !(buf2 instanceof Uint8Array)) {
+      throw new TypeError("Arguments must be Buffers or Uint8Arrays");
+    }
+    const len = Math.min(buf1.length, buf2.length);
+    for (let i = 0; i < len; i++) {
+      if (buf1[i] < buf2[i]) return -1;
+      if (buf1[i] > buf2[i]) return 1;
+    }
+    if (buf1.length < buf2.length) return -1;
+    if (buf1.length > buf2.length) return 1;
+    return 0;
+  }
+  static concat(list, totalLength) {
+    if (list.length === 0) return _Buffer.alloc(0);
+    if (totalLength === void 0) {
+      totalLength = 0;
+      for (let i = 0; i < list.length; i++) {
+        totalLength += list[i].length;
+      }
+    }
+    const result = _Buffer.alloc(totalLength);
+    let offset = 0;
+    for (let i = 0; i < list.length; i++) {
+      const buf = list[i];
+      const toCopy = Math.min(buf.length, totalLength - offset);
+      if (toCopy <= 0) continue;
+      result.set(buf.subarray(0, toCopy), offset);
+      offset += toCopy;
+    }
+    return result;
+  }
+  static poolSize = 8192;
+  // ---- Instance methods ----
+  toString(encoding, start2, end) {
+    const enc = normalizeEncoding(encoding);
+    return decodeString(this, enc, start2, end);
+  }
+  toJSON() {
+    return {
+      type: "Buffer",
+      data: Array.from(this)
+    };
+  }
+  equals(otherBuffer) {
+    if (!(otherBuffer instanceof Uint8Array)) {
+      throw new TypeError("Argument must be a Buffer or Uint8Array");
+    }
+    if (this.length !== otherBuffer.length) return false;
+    for (let i = 0; i < this.length; i++) {
+      if (this[i] !== otherBuffer[i]) return false;
+    }
+    return true;
+  }
+  compare(target, targetStart, targetEnd, sourceStart, sourceEnd) {
+    if (!(target instanceof Uint8Array)) {
+      throw new TypeError("Argument must be a Buffer or Uint8Array");
+    }
+    const src = sourceStart !== void 0 || sourceEnd !== void 0 ? this.subarray(sourceStart ?? 0, sourceEnd ?? this.length) : this;
+    const tgt = targetStart !== void 0 || targetEnd !== void 0 ? target.subarray(targetStart ?? 0, targetEnd ?? target.length) : target;
+    return _Buffer.compare(src, tgt);
+  }
+  copy(target, targetStart = 0, sourceStart = 0, sourceEnd) {
+    const end = sourceEnd ?? this.length;
+    const toCopy = Math.min(end - sourceStart, target.length - targetStart);
+    if (toCopy <= 0) return 0;
+    target.set(this.subarray(sourceStart, sourceStart + toCopy), targetStart);
+    return toCopy;
+  }
+  // slice returns a Buffer (not Uint8Array) that shares memory
+  slice(start2, end) {
+    const s = start2 ?? 0;
+    const e = end ?? this.length;
+    const sub = super.subarray(s, e);
+    return new _Buffer(sub.buffer, sub.byteOffset, sub.byteLength);
+  }
+  // subarray also returns a Buffer
+  subarray(start2, end) {
+    const sub = super.subarray(start2, end);
+    return new _Buffer(sub.buffer, sub.byteOffset, sub.byteLength);
+  }
+  write(string, offset, length, encoding) {
+    offset = offset ?? 0;
+    const enc = normalizeEncoding(encoding || (typeof length === "string" ? length : void 0));
+    const encoded = encodeString(string, enc);
+    const maxLen = length !== void 0 && typeof length === "number" ? Math.min(length, this.length - offset) : this.length - offset;
+    const toCopy = Math.min(encoded.length, maxLen);
+    this.set(encoded.subarray(0, toCopy), offset);
+    return toCopy;
+  }
+  fill(value2, offset, end, encoding) {
+    const start2 = offset ?? 0;
+    const stop = end ?? this.length;
+    if (typeof value2 === "number") {
+      super.fill(value2 & 255, start2, stop);
+    } else if (typeof value2 === "string") {
+      const enc = normalizeEncoding(encoding);
+      const encoded = encodeString(value2, enc);
+      if (encoded.length === 0) {
+        super.fill(0, start2, stop);
+      } else if (encoded.length === 1) {
+        super.fill(encoded[0], start2, stop);
+      } else {
+        for (let i = start2; i < stop; i++) {
+          this[i] = encoded[(i - start2) % encoded.length];
+        }
+      }
+    } else if (value2 instanceof Uint8Array) {
+      if (value2.length === 0) {
+        super.fill(0, start2, stop);
+      } else {
+        for (let i = start2; i < stop; i++) {
+          this[i] = value2[(i - start2) % value2.length];
+        }
+      }
+    }
+    return this;
+  }
+  indexOf(value2, byteOffset, encoding) {
+    if (typeof value2 === "number") {
+      return super.indexOf(value2 & 255, byteOffset);
+    }
+    const needle = typeof value2 === "string" ? encodeString(value2, normalizeEncoding(encoding)) : value2;
+    const start2 = byteOffset ?? 0;
+    outer:
+      for (let i = start2; i <= this.length - needle.length; i++) {
+        for (let j = 0; j < needle.length; j++) {
+          if (this[i + j] !== needle[j]) continue outer;
+        }
+        return i;
+      }
+    return -1;
+  }
+  lastIndexOf(value2, byteOffset, encoding) {
+    if (typeof value2 === "number") {
+      return byteOffset !== void 0 ? super.lastIndexOf(value2 & 255, byteOffset) : super.lastIndexOf(value2 & 255);
+    }
+    const needle = typeof value2 === "string" ? encodeString(value2, normalizeEncoding(encoding)) : value2;
+    const start2 = byteOffset !== void 0 ? Math.min(byteOffset, this.length - needle.length) : this.length - needle.length;
+    outer:
+      for (let i = start2; i >= 0; i--) {
+        for (let j = 0; j < needle.length; j++) {
+          if (this[i + j] !== needle[j]) continue outer;
+        }
+        return i;
+      }
+    return -1;
+  }
+  includes(value2, byteOffset, encoding) {
+    return this.indexOf(value2, byteOffset, encoding) !== -1;
+  }
+  // ---- Read methods ----
+  readUInt8(offset = 0) {
+    checkOffset(offset, 1, this.length);
+    return this[offset];
+  }
+  readUInt16BE(offset = 0) {
+    checkOffset(offset, 2, this.length);
+    return this[offset] << 8 | this[offset + 1];
+  }
+  readUInt16LE(offset = 0) {
+    checkOffset(offset, 2, this.length);
+    return this[offset] | this[offset + 1] << 8;
+  }
+  readUInt32BE(offset = 0) {
+    checkOffset(offset, 4, this.length);
+    return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+  }
+  readUInt32LE(offset = 0) {
+    checkOffset(offset, 4, this.length);
+    return this[offset + 3] * 16777216 + (this[offset + 2] << 16 | this[offset + 1] << 8 | this[offset]) >>> 0;
+  }
+  readInt8(offset = 0) {
+    checkOffset(offset, 1, this.length);
+    return this[offset] | (this[offset] & 128 ? 4294967040 : 0);
+  }
+  readInt16BE(offset = 0) {
+    checkOffset(offset, 2, this.length);
+    const val = this[offset] << 8 | this[offset + 1];
+    return val & 32768 ? val | 4294901760 : val;
+  }
+  readInt16LE(offset = 0) {
+    checkOffset(offset, 2, this.length);
+    const val = this[offset] | this[offset + 1] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  }
+  readInt32BE(offset = 0) {
+    checkOffset(offset, 4, this.length);
+    return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+  }
+  readInt32LE(offset = 0) {
+    checkOffset(offset, 4, this.length);
+    return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+  }
+  readFloatBE(offset = 0) {
+    checkOffset(offset, 4, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    return view.getFloat32(0, false);
+  }
+  readFloatLE(offset = 0) {
+    checkOffset(offset, 4, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    return view.getFloat32(0, true);
+  }
+  readDoubleBE(offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    return view.getFloat64(0, false);
+  }
+  readDoubleLE(offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    return view.getFloat64(0, true);
+  }
+  readBigInt64BE(offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    return view.getBigInt64(0, false);
+  }
+  readBigInt64LE(offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    return view.getBigInt64(0, true);
+  }
+  readBigUInt64BE(offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    return view.getBigUint64(0, false);
+  }
+  readBigUInt64LE(offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    return view.getBigUint64(0, true);
+  }
+  readUIntBE(offset, byteLength) {
+    checkOffset(offset, byteLength, this.length);
+    let val = 0;
+    for (let i = 0; i < byteLength; i++) {
+      val = val * 256 + this[offset + i];
+    }
+    return val;
+  }
+  readUIntLE(offset, byteLength) {
+    checkOffset(offset, byteLength, this.length);
+    let val = 0;
+    let mul = 1;
+    for (let i = 0; i < byteLength; i++) {
+      val += this[offset + i] * mul;
+      mul *= 256;
+    }
+    return val;
+  }
+  readIntBE(offset, byteLength) {
+    checkOffset(offset, byteLength, this.length);
+    let val = 0;
+    for (let i = 0; i < byteLength; i++) {
+      val = val * 256 + this[offset + i];
+    }
+    if (val >= Math.pow(2, 8 * byteLength - 1)) {
+      val -= Math.pow(2, 8 * byteLength);
+    }
+    return val;
+  }
+  readIntLE(offset, byteLength) {
+    checkOffset(offset, byteLength, this.length);
+    let val = 0;
+    let mul = 1;
+    for (let i = 0; i < byteLength; i++) {
+      val += this[offset + i] * mul;
+      mul *= 256;
+    }
+    if (val >= Math.pow(2, 8 * byteLength - 1)) {
+      val -= Math.pow(2, 8 * byteLength);
+    }
+    return val;
+  }
+  // ---- Write methods ----
+  writeUInt8(value2, offset = 0) {
+    checkOffset(offset, 1, this.length);
+    this[offset] = value2 & 255;
+    return offset + 1;
+  }
+  writeUInt16BE(value2, offset = 0) {
+    checkOffset(offset, 2, this.length);
+    this[offset] = value2 >>> 8 & 255;
+    this[offset + 1] = value2 & 255;
+    return offset + 2;
+  }
+  writeUInt16LE(value2, offset = 0) {
+    checkOffset(offset, 2, this.length);
+    this[offset] = value2 & 255;
+    this[offset + 1] = value2 >>> 8 & 255;
+    return offset + 2;
+  }
+  writeUInt32BE(value2, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    this[offset] = value2 >>> 24 & 255;
+    this[offset + 1] = value2 >>> 16 & 255;
+    this[offset + 2] = value2 >>> 8 & 255;
+    this[offset + 3] = value2 & 255;
+    return offset + 4;
+  }
+  writeUInt32LE(value2, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    this[offset] = value2 & 255;
+    this[offset + 1] = value2 >>> 8 & 255;
+    this[offset + 2] = value2 >>> 16 & 255;
+    this[offset + 3] = value2 >>> 24 & 255;
+    return offset + 4;
+  }
+  writeInt8(value2, offset = 0) {
+    checkOffset(offset, 1, this.length);
+    if (value2 < 0) value2 = 255 + value2 + 1;
+    this[offset] = value2 & 255;
+    return offset + 1;
+  }
+  writeInt16BE(value2, offset = 0) {
+    checkOffset(offset, 2, this.length);
+    this[offset] = value2 >>> 8 & 255;
+    this[offset + 1] = value2 & 255;
+    return offset + 2;
+  }
+  writeInt16LE(value2, offset = 0) {
+    checkOffset(offset, 2, this.length);
+    this[offset] = value2 & 255;
+    this[offset + 1] = value2 >>> 8 & 255;
+    return offset + 2;
+  }
+  writeInt32BE(value2, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    this[offset] = value2 >>> 24 & 255;
+    this[offset + 1] = value2 >>> 16 & 255;
+    this[offset + 2] = value2 >>> 8 & 255;
+    this[offset + 3] = value2 & 255;
+    return offset + 4;
+  }
+  writeInt32LE(value2, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    this[offset] = value2 & 255;
+    this[offset + 1] = value2 >>> 8 & 255;
+    this[offset + 2] = value2 >>> 16 & 255;
+    this[offset + 3] = value2 >>> 24 & 255;
+    return offset + 4;
+  }
+  writeFloatBE(value2, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    view.setFloat32(0, value2, false);
+    return offset + 4;
+  }
+  writeFloatLE(value2, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    view.setFloat32(0, value2, true);
+    return offset + 4;
+  }
+  writeDoubleBE(value2, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setFloat64(0, value2, false);
+    return offset + 8;
+  }
+  writeDoubleLE(value2, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setFloat64(0, value2, true);
+    return offset + 8;
+  }
+  writeBigInt64BE(value2, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setBigInt64(0, value2, false);
+    return offset + 8;
+  }
+  writeBigInt64LE(value2, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setBigInt64(0, value2, true);
+    return offset + 8;
+  }
+  writeBigUInt64BE(value2, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setBigUint64(0, value2, false);
+    return offset + 8;
+  }
+  writeBigUInt64LE(value2, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setBigUint64(0, value2, true);
+    return offset + 8;
+  }
+  // ---- Swap methods ----
+  swap16() {
+    const len = this.length;
+    if (len % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
+    for (let i = 0; i < len; i += 2) {
+      const a = this[i];
+      this[i] = this[i + 1];
+      this[i + 1] = a;
+    }
+    return this;
+  }
+  swap32() {
+    const len = this.length;
+    if (len % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
+    for (let i = 0; i < len; i += 4) {
+      const a = this[i];
+      const b = this[i + 1];
+      this[i] = this[i + 3];
+      this[i + 1] = this[i + 2];
+      this[i + 2] = b;
+      this[i + 3] = a;
+    }
+    return this;
+  }
+  swap64() {
+    const len = this.length;
+    if (len % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
+    for (let i = 0; i < len; i += 8) {
+      const a = this[i];
+      const b = this[i + 1];
+      const c = this[i + 2];
+      const d = this[i + 3];
+      this[i] = this[i + 7];
+      this[i + 1] = this[i + 6];
+      this[i + 2] = this[i + 5];
+      this[i + 3] = this[i + 4];
+      this[i + 4] = d;
+      this[i + 5] = c;
+      this[i + 6] = b;
+      this[i + 7] = a;
+    }
+    return this;
+  }
+};
+var kMaxLength = 2 ** 31 - 1;
+var kStringMaxLength = 2 ** 28 - 16;
+
+// ../../../packages/node/buffer/lib/esm/index.js
+var atob2 = globalThis.atob;
+var btoa = globalThis.btoa;
+
+// ../../../packages/node/globals/lib/esm/register/buffer.js
+if (!("Buffer" in globalThis)) {
+  Object.defineProperty(globalThis, "Buffer", {
+    value: Buffer2,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+}
+
 // ../../../packages/node/globals/lib/esm/register/encoding.js
 if (typeof globalThis.btoa !== "function") {
   Object.defineProperty(globalThis, "btoa", {
-    value: function btoa(data) {
+    value: function btoa2(data) {
       const bytes = new Uint8Array(data.length);
       for (let i = 0; i < data.length; i++) {
         bytes[i] = data.charCodeAt(i) & 255;
@@ -2881,7 +3676,7 @@ if (typeof globalThis.btoa !== "function") {
 }
 if (typeof globalThis.atob !== "function") {
   Object.defineProperty(globalThis, "atob", {
-    value: function atob2(data) {
+    value: function atob3(data) {
       const bytes = glib_2_default.base64_decode(data);
       let result = "";
       for (let i = 0; i < bytes.length; i++) {
@@ -2895,6 +3690,1359 @@ if (typeof globalThis.atob !== "function") {
   });
 }
 
+// ../../../packages/node/globals/lib/esm/register/microtask.js
+if (typeof queueMicrotask !== "function") {
+  Object.defineProperty(globalThis, "queueMicrotask", {
+    value: queueMicrotask2,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+}
+
+// ../../../packages/node/events/lib/esm/event-emitter.js
+var kCapture = /* @__PURE__ */ Symbol("kCapture");
+var kRejection = /* @__PURE__ */ Symbol.for("nodejs.rejection");
+function onceWrapper() {
+  const { target, type, listener } = this;
+  if (this.wrapperFn) target.removeListener(type, this.wrapperFn);
+  const result = listener.apply(target, arguments);
+  return result;
+}
+function _onceWrap(target, type, listener) {
+  const state = { target, type, listener, wrapperFn: void 0 };
+  const wrapped = onceWrapper.bind(state);
+  state.wrapperFn = wrapped;
+  wrapped.listener = listener;
+  return wrapped;
+}
+function arrayClone(arr) {
+  switch (arr.length) {
+    case 0:
+      return [];
+    case 1:
+      return [arr[0]];
+    case 2:
+      return [arr[0], arr[1]];
+    case 3:
+      return [arr[0], arr[1], arr[2]];
+    default:
+      return arr.slice();
+  }
+}
+function checkListener(listener) {
+  if (typeof listener !== "function") {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+function validateNumber(value2, name2) {
+  if (typeof value2 !== "number" || value2 !== value2) {
+    throw new TypeError(`The "${name2}" argument must be of type number. Received type ${typeof value2}`);
+  }
+}
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++) {
+    list[index] = list[index + 1];
+  }
+  list.pop();
+}
+var EventEmitter = class _EventEmitter {
+  static defaultMaxListeners = 10;
+  static errorMonitor = /* @__PURE__ */ Symbol("events.errorMonitor");
+  static captureRejectionSymbol = kRejection;
+  static _captureRejections = false;
+  static get captureRejections() {
+    return _EventEmitter._captureRejections;
+  }
+  static set captureRejections(value2) {
+    if (typeof value2 !== "boolean") {
+      throw new TypeError('The "captureRejections" argument must be of type boolean.');
+    }
+    _EventEmitter._captureRejections = value2;
+  }
+  _events;
+  _eventsCount;
+  _maxListeners;
+  [kCapture];
+  constructor(opts) {
+    this._events = /* @__PURE__ */ Object.create(null);
+    this._eventsCount = 0;
+    this._maxListeners = void 0;
+    this[kCapture] = opts?.captureRejections ?? _EventEmitter._captureRejections;
+  }
+  setMaxListeners(n) {
+    validateNumber(n, "n");
+    if (n < 0) {
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n);
+    }
+    this._maxListeners = n;
+    return this;
+  }
+  getMaxListeners() {
+    return this._maxListeners ?? _EventEmitter.defaultMaxListeners;
+  }
+  emit(type, ...args) {
+    const events = this._events;
+    let doError = type === "error";
+    if (events !== void 0) {
+      if (doError && events[_EventEmitter.errorMonitor] !== void 0) {
+        this.emit(_EventEmitter.errorMonitor, ...args);
+      }
+      doError = doError && events.error === void 0;
+    } else if (!doError) {
+      return false;
+    }
+    if (doError) {
+      let er;
+      if (args.length > 0) {
+        er = args[0];
+      } else {
+        er = new Error("Unhandled error.");
+      }
+      if (er instanceof Error) {
+        throw er;
+      }
+      const err = new Error("Unhandled error. (" + er + ")");
+      err.context = er;
+      throw err;
+    }
+    const handler = events[type];
+    if (handler === void 0) {
+      return false;
+    }
+    if (typeof handler === "function") {
+      const result = handler.apply(this, args);
+      if (result !== void 0 && result !== null && this[kCapture]) {
+        this._addCatch(result, type, args);
+      }
+    } else {
+      const listeners = arrayClone(handler);
+      const len = listeners.length;
+      for (let i = 0; i < len; ++i) {
+        const result = listeners[i].apply(this, args);
+        if (result !== void 0 && result !== null && this[kCapture]) {
+          this._addCatch(result, type, args);
+        }
+      }
+    }
+    return true;
+  }
+  _addCatch(result, type, args) {
+    if (typeof result?.then === "function") {
+      result.then(void 0, (err) => {
+        const handler = this[kRejection];
+        if (typeof handler === "function") {
+          handler.call(this, err, type, ...args);
+        } else {
+          const prev = this[kCapture];
+          try {
+            this[kCapture] = false;
+            this.emit("error", err);
+          } finally {
+            this[kCapture] = prev;
+          }
+        }
+      });
+    }
+  }
+  addListener(type, listener) {
+    return this._addListener(type, listener, false);
+  }
+  on(type, listener) {
+    return this._addListener(type, listener, false);
+  }
+  prependListener(type, listener) {
+    return this._addListener(type, listener, true);
+  }
+  _addListener(type, listener, prepend) {
+    checkListener(listener);
+    let events = this._events;
+    if (events === void 0) {
+      events = this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    } else if (events.newListener !== void 0) {
+      this.emit("newListener", type, listener.listener ?? listener);
+      events = this._events;
+    }
+    let existing = events[type];
+    if (existing === void 0) {
+      events[type] = listener;
+      ++this._eventsCount;
+    } else if (typeof existing === "function") {
+      events[type] = prepend ? [listener, existing] : [existing, listener];
+    } else {
+      if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+    }
+    const m = this.getMaxListeners();
+    if (m > 0) {
+      const count2 = typeof events[type] === "function" ? 1 : events[type].length;
+      if (count2 > m && !events[type].warned) {
+        if (typeof events[type] !== "function") {
+          events[type].warned = true;
+        }
+        const w = new Error(
+          `Possible EventEmitter memory leak detected. ${count2} ${String(type)} listeners added to [${this.constructor.name}]. Use emitter.setMaxListeners() to increase limit`
+        );
+        w.name = "MaxListenersExceededWarning";
+        console.warn(w.message);
+      }
+    }
+    return this;
+  }
+  once(type, listener) {
+    checkListener(listener);
+    this.on(type, _onceWrap(this, type, listener));
+    return this;
+  }
+  prependOnceListener(type, listener) {
+    checkListener(listener);
+    this.prependListener(type, _onceWrap(this, type, listener));
+    return this;
+  }
+  removeListener(type, listener) {
+    checkListener(listener);
+    const events = this._events;
+    if (events === void 0) {
+      return this;
+    }
+    const list = events[type];
+    if (list === void 0) {
+      return this;
+    }
+    if (list === listener || list.listener === listener) {
+      if (--this._eventsCount === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+      } else {
+        delete events[type];
+        if (events.removeListener) {
+          this.emit("removeListener", type, list.listener ?? listener);
+        }
+      }
+    } else if (typeof list !== "function") {
+      let position = -1;
+      for (let i = list.length - 1; i >= 0; i--) {
+        if (list[i] === listener || list[i].listener === listener) {
+          position = i;
+          break;
+        }
+      }
+      if (position < 0) {
+        return this;
+      }
+      if (position === 0) {
+        list.shift();
+      } else {
+        spliceOne(list, position);
+      }
+      if (list.length === 1) {
+        events[type] = list[0];
+      }
+      if (events.removeListener !== void 0) {
+        this.emit("removeListener", type, listener.listener ?? listener);
+      }
+    }
+    return this;
+  }
+  off(type, listener) {
+    return this.removeListener(type, listener);
+  }
+  removeAllListeners(type) {
+    const events = this._events;
+    if (events === void 0) {
+      return this;
+    }
+    if (events.removeListener === void 0) {
+      if (arguments.length === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      } else if (events[type] !== void 0) {
+        if (--this._eventsCount === 0) {
+          this._events = /* @__PURE__ */ Object.create(null);
+        } else {
+          delete events[type];
+        }
+      }
+      return this;
+    }
+    if (arguments.length === 0) {
+      const keys = Object.keys(events);
+      for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        if (key === "removeListener") continue;
+        this.removeAllListeners(key);
+      }
+      this.removeAllListeners("removeListener");
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+      return this;
+    }
+    const listeners = events[type];
+    if (typeof listeners === "function") {
+      this.removeListener(type, listeners);
+    } else if (listeners !== void 0) {
+      for (let i = listeners.length - 1; i >= 0; i--) {
+        this.removeListener(type, listeners[i]);
+      }
+    }
+    return this;
+  }
+  listeners(type) {
+    const events = this._events;
+    if (events === void 0) {
+      return [];
+    }
+    const evlistener = events[type];
+    if (evlistener === void 0) {
+      return [];
+    }
+    if (typeof evlistener === "function") {
+      return [evlistener.listener ?? evlistener];
+    }
+    return unwrapListeners(evlistener);
+  }
+  rawListeners(type) {
+    const events = this._events;
+    if (events === void 0) {
+      return [];
+    }
+    const evlistener = events[type];
+    if (evlistener === void 0) {
+      return [];
+    }
+    if (typeof evlistener === "function") {
+      return [evlistener];
+    }
+    return arrayClone(evlistener);
+  }
+  listenerCount(type) {
+    const events = this._events;
+    if (events === void 0) {
+      return 0;
+    }
+    const evlistener = events[type];
+    if (evlistener === void 0) {
+      return 0;
+    }
+    if (typeof evlistener === "function") {
+      return 1;
+    }
+    return evlistener.length;
+  }
+  eventNames() {
+    return (this._eventsCount ?? 0) > 0 ? Reflect.ownKeys(this._events) : [];
+  }
+  // -- Static methods --
+  /**
+   * Returns a promise that resolves when the emitter emits the given event,
+   * or rejects if the emitter emits 'error' while waiting.
+   */
+  static once(emitter, name2, options) {
+    return new Promise((resolve, reject) => {
+      const signal = options?.signal;
+      if (signal?.aborted) {
+        reject(createAbortError(signal));
+        return;
+      }
+      if (typeof emitter.addEventListener === "function") {
+        const eventTarget = emitter;
+        const handler = (...args) => {
+          if (signal) {
+            signal.removeEventListener("abort", abortHandler2);
+          }
+          resolve(args);
+        };
+        const errorHandler2 = (err) => {
+          if (signal) {
+            signal.removeEventListener("abort", abortHandler2);
+          }
+          eventTarget.removeEventListener("error", errorHandler2);
+          reject(err);
+        };
+        const abortHandler2 = () => {
+          eventTarget.removeEventListener(name2, handler);
+          eventTarget.removeEventListener("error", errorHandler2);
+          reject(createAbortError(signal));
+        };
+        eventTarget.addEventListener(name2, handler, { once: true });
+        if (name2 !== "error") {
+          eventTarget.addEventListener("error", errorHandler2, { once: true });
+        }
+        if (signal) {
+          signal.addEventListener("abort", abortHandler2, { once: true });
+        }
+        return;
+      }
+      const ee = emitter;
+      const eventHandler = (...args) => {
+        if (signal) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+        if (errorHandler !== void 0) {
+          ee.removeListener("error", errorHandler);
+        }
+        resolve(args);
+      };
+      let errorHandler;
+      if (name2 !== "error") {
+        errorHandler = (err) => {
+          ee.removeListener(name2, eventHandler);
+          if (signal) {
+            signal.removeEventListener("abort", abortHandler);
+          }
+          reject(err);
+        };
+        ee.once("error", errorHandler);
+      }
+      ee.once(name2, eventHandler);
+      const abortHandler = () => {
+        ee.removeListener(name2, eventHandler);
+        if (errorHandler) {
+          ee.removeListener("error", errorHandler);
+        }
+        reject(createAbortError(signal));
+      };
+      if (signal) {
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+    });
+  }
+  /**
+   * Returns an async iterator that yields event arguments each time the emitter emits.
+   */
+  static on(emitter, event, options) {
+    const signal = options?.signal;
+    if (signal?.aborted) {
+      throw createAbortError(signal);
+    }
+    const highWaterMark = options?.highWaterMark ?? Number.MAX_SAFE_INTEGER;
+    const lowWaterMark = options?.lowWaterMark ?? 1;
+    validateNumber(highWaterMark, "highWaterMark");
+    validateNumber(lowWaterMark, "lowWaterMark");
+    const unconsumedEvents = [];
+    const unconsumedPromises = [];
+    let error2 = null;
+    let finished = false;
+    let paused = false;
+    const eventHandler = (...args) => {
+      if (unconsumedPromises.length > 0) {
+        const { resolve } = unconsumedPromises.shift();
+        resolve({ value: args, done: false });
+      } else {
+        unconsumedEvents.push(args);
+        if (unconsumedEvents.length >= highWaterMark && !paused) {
+          paused = true;
+          if (typeof emitter.pause === "function") {
+            emitter.pause();
+          }
+        }
+      }
+    };
+    const errorHandler = (err) => {
+      error2 = err;
+      if (unconsumedPromises.length > 0) {
+        const { reject } = unconsumedPromises.shift();
+        reject(err);
+      }
+      iterator.return();
+    };
+    const abortHandler = () => {
+      errorHandler(createAbortError(signal));
+    };
+    emitter.on(event, eventHandler);
+    if (event !== "error") {
+      emitter.on("error", errorHandler);
+    }
+    if (signal) {
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    const cleanup = () => {
+      emitter.removeListener(event, eventHandler);
+      emitter.removeListener("error", errorHandler);
+      if (signal) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+      finished = true;
+      for (const { resolve } of unconsumedPromises) {
+        resolve({ value: void 0, done: true });
+      }
+      unconsumedPromises.length = 0;
+      unconsumedEvents.length = 0;
+    };
+    const iterator = {
+      next() {
+        if (unconsumedEvents.length > 0) {
+          const value2 = unconsumedEvents.shift();
+          if (paused && unconsumedEvents.length < lowWaterMark) {
+            paused = false;
+            if (typeof emitter.resume === "function") {
+              emitter.resume();
+            }
+          }
+          return Promise.resolve({ value: value2, done: false });
+        }
+        if (error2) {
+          const p = Promise.reject(error2);
+          error2 = null;
+          return p;
+        }
+        if (finished) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve, reject) => {
+          unconsumedPromises.push({ resolve, reject });
+        });
+      },
+      return() {
+        cleanup();
+        return Promise.resolve({ value: void 0, done: true });
+      },
+      throw(err) {
+        if (!finished) {
+          error2 = err;
+          cleanup();
+        }
+        return Promise.reject(err);
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+    return iterator;
+  }
+  /**
+   * Returns the number of listeners listening to the event name.
+   * @deprecated Use emitter.listenerCount() instead.
+   */
+  static listenerCount(emitter, type) {
+    return emitter.listenerCount(type);
+  }
+  /**
+   * Returns a copy of the array of listeners for the event named eventName.
+   */
+  static getEventListeners(emitter, name2) {
+    if (typeof emitter.listeners === "function") {
+      return emitter.listeners(name2);
+    }
+    return [];
+  }
+  /**
+   * Set max listeners on one or more emitters.
+   */
+  static setMaxListeners(n, ...emitters) {
+    validateNumber(n, "n");
+    if (n < 0) {
+      throw new RangeError('The value of "n" is out of range.');
+    }
+    if (emitters.length === 0) {
+      _EventEmitter.defaultMaxListeners = n;
+    } else {
+      for (const emitter of emitters) {
+        if (typeof emitter.setMaxListeners === "function") {
+          emitter.setMaxListeners(n);
+        }
+      }
+    }
+  }
+  /**
+   * Returns the currently set max listeners on the emitter.
+   */
+  static getMaxListeners(emitter) {
+    if (typeof emitter.getMaxListeners === "function") {
+      return emitter.getMaxListeners();
+    }
+    return _EventEmitter.defaultMaxListeners;
+  }
+  /**
+   * Listens once to an abort event on the provided signal and returns a disposable.
+   */
+  static addAbortListener(signal, listener) {
+    if (signal.aborted) {
+      Promise.resolve().then(() => listener());
+    }
+    const handler = () => listener();
+    signal.addEventListener("abort", handler, { once: true });
+    return {
+      [Symbol.dispose]() {
+        signal.removeEventListener("abort", handler);
+      }
+    };
+  }
+};
+EventEmitter.EventEmitter = EventEmitter;
+{
+  const methods = [
+    "setMaxListeners",
+    "getMaxListeners",
+    "emit",
+    "addListener",
+    "on",
+    "prependListener",
+    "once",
+    "prependOnceListener",
+    "removeListener",
+    "off",
+    "removeAllListeners",
+    "listeners",
+    "rawListeners",
+    "listenerCount",
+    "eventNames"
+  ];
+  for (const m of methods) {
+    const fn = EventEmitter.prototype[m];
+    if (typeof fn === "function") {
+      Object.defineProperty(EventEmitter.prototype, m, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: fn
+      });
+    }
+  }
+  Object.defineProperty(EventEmitter.prototype, "_events", { enumerable: true, configurable: true, writable: true, value: void 0 });
+  Object.defineProperty(EventEmitter.prototype, "_eventsCount", { enumerable: true, configurable: true, writable: true, value: 0 });
+  Object.defineProperty(EventEmitter.prototype, "_maxListeners", { enumerable: true, configurable: true, writable: true, value: void 0 });
+}
+function unwrapListeners(arr) {
+  const ret = new Array(arr.length);
+  for (let i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener ?? arr[i];
+  }
+  return ret;
+}
+function createAbortError(signal) {
+  const err = new Error("The operation was aborted");
+  err.name = "AbortError";
+  err.code = "ABORT_ERR";
+  if (signal?.reason) {
+    err.cause = signal.reason;
+  }
+  return err;
+}
+
+// ../../../packages/node/events/lib/esm/index.js
+var EventEmitter2 = makeCallable(EventEmitter);
+EventEmitter2.EventEmitter = EventEmitter2;
+var captureRejectionSymbol = EventEmitter2.captureRejectionSymbol;
+var errorMonitor = EventEmitter2.errorMonitor;
+var defaultMaxListeners = EventEmitter2.defaultMaxListeners;
+var setMaxListeners = EventEmitter2.setMaxListeners;
+var getMaxListeners = EventEmitter2.getMaxListeners;
+var once = EventEmitter2.once;
+var on = EventEmitter2.on;
+var getEventListeners = EventEmitter2.getEventListeners;
+var listenerCount = EventEmitter2.listenerCount;
+var addAbortListener = EventEmitter2.addAbortListener;
+
+// ../../../packages/node/terminal-native/lib/esm/index.js
+var _mod = null;
+var _gi = globalThis.imports?.gi;
+if (_gi) {
+  try {
+    _mod = _gi["GjsifyTerminal"];
+  } catch {
+  }
+}
+var nativeTerminal = _mod;
+
+// ../../../packages/node/process/lib/esm/index.js
+var _encoder2 = new TextEncoder();
+function getGjsGlobal() {
+  return globalThis;
+}
+function detectGjsVersion() {
+  try {
+    const system = getGjsGlobal().imports?.system;
+    if (system?.version !== void 0) {
+      const v = Number(system.version);
+      const major = Math.floor(v / 1e4);
+      const minor = Math.floor(v % 1e4 / 100);
+      const patch = v % 100;
+      return `${major}.${minor}.${patch}`;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function detectNodeVersion() {
+  if (typeof globalThis.process?.versions?.node === "string") {
+    return globalThis.process.versions.node;
+  }
+  return void 0;
+}
+function detectVersionInfo() {
+  const nodeVersion = detectNodeVersion();
+  if (nodeVersion) {
+    return {
+      version: globalThis.process.version,
+      versions: { ...globalThis.process.versions },
+      title: globalThis.process?.title || "node"
+    };
+  }
+  const gjsVersion = detectGjsVersion();
+  const versions2 = {
+    node: "20.0.0"
+    // Compatibility version — many npm packages check process.versions.node
+  };
+  if (gjsVersion) versions2.gjs = gjsVersion;
+  return {
+    version: "v20.0.0",
+    // Compatibility version for Node.js API level checks
+    versions: versions2,
+    title: "gjs"
+  };
+}
+function detectPpid() {
+  if (typeof globalThis.process?.ppid === "number") {
+    return globalThis.process.ppid;
+  }
+  try {
+    const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib3) {
+      const [, contents] = GLib3.file_get_contents("/proc/self/status");
+      if (contents) {
+        const str = new TextDecoder().decode(contents);
+        const match = str.match(/PPid:\s+(\d+)/);
+        if (match) return parseInt(match[1], 10);
+      }
+    }
+  } catch {
+  }
+  return 0;
+}
+function detectPlatform() {
+  try {
+    const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib3) {
+      const osInfo = GLib3.get_os_info("ID");
+      if (osInfo) return "linux";
+    }
+  } catch {
+  }
+  if (typeof getGjsGlobal().imports?.system !== "undefined") {
+    return "linux";
+  }
+  if (typeof globalThis.process?.platform === "string") {
+    return globalThis.process.platform;
+  }
+  return "linux";
+}
+function detectArch() {
+  if (typeof globalThis.process?.arch === "string") {
+    return globalThis.process.arch;
+  }
+  return "x64";
+}
+function getCwd() {
+  try {
+    const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib3?.get_current_dir) return GLib3.get_current_dir();
+  } catch {
+  }
+  return "/";
+}
+function getEnvProxy() {
+  if (typeof globalThis.process?.env === "object") {
+    return globalThis.process.env;
+  }
+  try {
+    const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib3) {
+      return new Proxy({}, {
+        get(_target, prop) {
+          if (typeof prop !== "string") return void 0;
+          return GLib3.getenv(prop) ?? void 0;
+        },
+        set(_target, prop, value2) {
+          if (typeof prop !== "string") return false;
+          GLib3.setenv(prop, String(value2), true);
+          return true;
+        },
+        deleteProperty(_target, prop) {
+          if (typeof prop !== "string") return false;
+          GLib3.unsetenv(prop);
+          return true;
+        },
+        has(_target, prop) {
+          if (typeof prop !== "string") return false;
+          return GLib3.getenv(prop) !== null;
+        },
+        ownKeys(_target) {
+          const envp = GLib3.listenv();
+          return envp;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+          if (typeof prop !== "string") return void 0;
+          const val = GLib3.getenv(prop);
+          if (val === null) return void 0;
+          return { configurable: true, enumerable: true, writable: true, value: val };
+        }
+      });
+    }
+  } catch {
+  }
+  return {};
+}
+function getArgv() {
+  if (typeof globalThis.process?.argv !== "undefined") {
+    return globalThis.process.argv;
+  }
+  try {
+    const system = getGjsGlobal().imports?.system;
+    if (system?.programArgs) {
+      return ["gjs", system.programInvocationName || "", ...system.programArgs];
+    }
+  } catch {
+  }
+  return ["gjs"];
+}
+function getExecPath() {
+  if (typeof globalThis.process?.execPath === "string") {
+    return globalThis.process.execPath;
+  }
+  try {
+    const system = getGjsGlobal().imports?.system;
+    if (system?.programInvocationName) return system.programInvocationName;
+  } catch {
+  }
+  return "/usr/bin/gjs";
+}
+function getPid() {
+  if (typeof globalThis.process?.pid === "number") {
+    return globalThis.process.pid;
+  }
+  try {
+    const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib3) {
+      const [, contents] = GLib3.file_get_contents("/proc/self/stat");
+      if (contents) {
+        const str = new TextDecoder().decode(contents);
+        const pid2 = parseInt(str, 10);
+        if (!isNaN(pid2)) return pid2;
+      }
+    }
+  } catch {
+  }
+  return 0;
+}
+var startTime = Date.now();
+function getGioNamespace() {
+  const _gi2 = globalThis.imports?.gi;
+  if (!_gi2) return null;
+  let gio = null;
+  try {
+    gio = _gi2["GioUnix"];
+  } catch {
+  }
+  if (!gio) {
+    try {
+      gio = _gi2["Gio"];
+    } catch {
+    }
+  }
+  return gio;
+}
+var ProcessWriteStream = class extends EventEmitter2 {
+  fd;
+  // Required by Stream.pipe(): without this, pipe skips dest.write() entirely.
+  writable = true;
+  _outGio = null;
+  constructor(fd) {
+    super();
+    this.fd = fd;
+    const gio = getGioNamespace();
+    if (gio) {
+      const Cls = gio.UnixOutputStream ?? gio.OutputStream;
+      if (Cls) {
+        try {
+          this._outGio = Cls.new(this.fd, false);
+        } catch {
+        }
+      }
+    }
+  }
+  write(data) {
+    if (this._outGio) {
+      try {
+        const bytes = typeof data === "string" ? _encoder2.encode(data) : data;
+        this._outGio.write_all(bytes, null);
+        return true;
+      } catch {
+      }
+    }
+    if (this.fd === 2) {
+      console.error(data);
+    } else {
+      console.log(data);
+    }
+    return true;
+  }
+  get isTTY() {
+    if (nativeTerminal) return nativeTerminal.Terminal.is_tty(this.fd);
+    try {
+      const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib3) return !!GLib3.log_writer_supports_color(this.fd);
+    } catch {
+    }
+    return false;
+  }
+  get columns() {
+    if (nativeTerminal) {
+      const [ok, , cols] = nativeTerminal.Terminal.get_size(this.fd);
+      if (ok && cols > 0) return cols;
+    }
+    try {
+      const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib3) {
+        const c = parseInt(GLib3.getenv("COLUMNS") ?? "0", 10);
+        if (c > 0) return c;
+      }
+    } catch {
+    }
+    return 80;
+  }
+  // stdout/stderr must never be closed — the process owns the fds.
+  // pipe() calls end() when its source emits 'end' (e.g. MuteStream); no-op here.
+  end() {
+  }
+  destroy() {
+  }
+  get rows() {
+    if (nativeTerminal) {
+      const [ok, rows] = nativeTerminal.Terminal.get_size(this.fd);
+      if (ok && rows > 0) return rows;
+    }
+    try {
+      const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib3) {
+        const r = parseInt(GLib3.getenv("LINES") ?? "0", 10);
+        if (r > 0) return r;
+      }
+    } catch {
+    }
+    return 24;
+  }
+};
+var ProcessReadStream = class extends EventEmitter2 {
+  fd;
+  isRaw = false;
+  // Do NOT expose `readableFlowing` as an instance property: @inquirer/core uses
+  // `'readableFlowing' in input` to defer startCycle() via setImmediate. In GJS,
+  // setImmediate fires as a microtask — the property must stay absent so
+  // @inquirer/core calls startCycle() synchronously on its own schedule.
+  _gio = null;
+  _stdinGio = null;
+  _reading = false;
+  _flowing = false;
+  _sttyCleanupRegistered = false;
+  _mainLoopHeld = false;
+  // True while a read_bytes_async is in-flight. Prevents a second concurrent
+  // read from starting when pause()+resume() fires between GLib iterations.
+  _pendingRead = false;
+  constructor(fd) {
+    super();
+    this.fd = fd;
+    this._gio = getGioNamespace();
+  }
+  get isTTY() {
+    if (nativeTerminal) return nativeTerminal.Terminal.is_tty(this.fd);
+    return false;
+  }
+  setRawMode(mode) {
+    if (nativeTerminal) {
+      const ok = nativeTerminal.Terminal.set_raw_mode(this.fd, mode);
+      if (ok) {
+        this.isRaw = mode;
+        return this;
+      }
+    }
+    this._setRawModeViaStty(mode);
+    this.isRaw = mode;
+    return this;
+  }
+  _setRawModeViaStty(mode) {
+    try {
+      const _gi2 = globalThis.imports?.gi;
+      const Gio3 = _gi2?.Gio ?? _gi2?.["Gio"];
+      if (!Gio3) return;
+      const STDIN_INHERIT = Gio3.SubprocessFlags?.STDIN_INHERIT ?? 2;
+      const argv2 = mode ? ["stty", "-icanon", "-echo", "-icrnl", "min", "1", "time", "0"] : ["stty", "icanon", "echo", "icrnl"];
+      const launcher = new Gio3.SubprocessLauncher({ flags: STDIN_INHERIT });
+      const proc = launcher.spawnv(argv2);
+      proc.wait(null);
+      if (mode && !this._sttyCleanupRegistered) {
+        this._sttyCleanupRegistered = true;
+        const proc_ = globalThis.process;
+        if (proc_?.once && typeof proc_.once === "function") {
+          proc_.once("exit", () => this._setRawModeViaStty(false));
+        }
+      }
+    } catch {
+    }
+  }
+  setEncoding(_enc) {
+    return this;
+  }
+  resume() {
+    this._flowing = true;
+    if (this._gio && this.fd === 0 && !this._reading) {
+      this._startReading();
+    }
+    return this;
+  }
+  pause() {
+    this._flowing = false;
+    this._reading = false;
+    if (this._mainLoopHeld) {
+      this._mainLoopHeld = false;
+      const _gi2 = globalThis.imports?.gi;
+      const GLib3 = _gi2?.GLib ?? _gi2?.["GLib"];
+      if (GLib3?.idle_add) {
+        GLib3.idle_add(300, () => {
+          if (!this._mainLoopHeld) quitMainLoop();
+          return false;
+        });
+      } else {
+        quitMainLoop();
+      }
+    }
+    return this;
+  }
+  read() {
+    return null;
+  }
+  _startReading() {
+    if (!this._gio || this._reading) return;
+    if (this._pendingRead) {
+      this._reading = true;
+      if (!this._mainLoopHeld) {
+        this._mainLoopHeld = true;
+        ensureMainLoop();
+      }
+      return;
+    }
+    this._reading = true;
+    if (!this._mainLoopHeld) {
+      this._mainLoopHeld = true;
+      ensureMainLoop();
+    }
+    if (!this._stdinGio) {
+      const Cls = this._gio.UnixInputStream ?? this._gio.InputStream;
+      if (!Cls) {
+        this._reading = false;
+        return;
+      }
+      try {
+        this._stdinGio = Cls.new(this.fd, false);
+      } catch {
+        this._reading = false;
+        return;
+      }
+    }
+    const loop = () => {
+      if (!this._reading) {
+        this._pendingRead = false;
+        return;
+      }
+      this._pendingRead = true;
+      this._stdinGio.read_bytes_async(
+        4096,
+        0,
+        null,
+        (src, res) => {
+          this._pendingRead = false;
+          try {
+            const bytes = src.read_bytes_finish(res);
+            const data = bytes?.get_data?.() ?? null;
+            if (data && data.byteLength > 0) {
+              this.emit("data", Buffer.from(data));
+            } else if (data !== null && data.byteLength === 0) {
+              this._reading = false;
+              this.emit("end");
+              return;
+            }
+          } catch {
+            this._reading = false;
+            return;
+          }
+          if (this._reading) loop();
+        }
+      );
+    };
+    loop();
+  }
+};
+function getMonotonicTime() {
+  try {
+    const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib3?.get_monotonic_time) {
+      return BigInt(GLib3.get_monotonic_time()) * 1000n;
+    }
+  } catch {
+  }
+  if (typeof performance?.now === "function") {
+    return BigInt(Math.round(performance.now() * 1e6));
+  }
+  return BigInt(Date.now()) * 1000000n;
+}
+var hrtimeBase = getMonotonicTime();
+var Process = class extends EventEmitter2 {
+  platform;
+  arch;
+  env;
+  argv;
+  argv0;
+  execPath;
+  pid;
+  ppid;
+  version;
+  versions;
+  title;
+  execArgv;
+  config;
+  exitCode;
+  constructor() {
+    super();
+    this.platform = detectPlatform();
+    this.arch = detectArch();
+    this.env = getEnvProxy();
+    this.argv = getArgv();
+    this.argv0 = this.argv[0] || "gjs";
+    this.execPath = getExecPath();
+    this.execArgv = globalThis.process?.execArgv ?? [];
+    this.config = globalThis.process?.config ?? { target_defaults: {}, variables: {} };
+    this.pid = getPid();
+    this.ppid = detectPpid();
+    const versionInfo = detectVersionInfo();
+    this.version = versionInfo.version;
+    this.versions = versionInfo.versions;
+    this.title = versionInfo.title;
+  }
+  cwd() {
+    return getCwd();
+  }
+  chdir(directory) {
+    try {
+      const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib3?.chdir) {
+        if (!GLib3.file_test(
+          directory,
+          16
+          /* G_FILE_TEST_EXISTS */
+        )) {
+          const err = new Error(`ENOENT: no such file or directory, chdir '${directory}'`);
+          err.code = "ENOENT";
+          err.syscall = "chdir";
+          err.path = directory;
+          throw err;
+        }
+        GLib3.chdir(directory);
+        return;
+      }
+    } catch (e) {
+      if (e && typeof e === "object" && e.code === "ENOENT") throw e;
+    }
+    const nativeProcess = globalThis.process;
+    if (nativeProcess && nativeProcess !== this && typeof nativeProcess.chdir === "function") {
+      nativeProcess.chdir(directory);
+      return;
+    }
+    throw new Error("process.chdir() is not supported in this environment");
+  }
+  kill(pid2, signal) {
+    const nativeProcess = globalThis.process;
+    if (nativeProcess && nativeProcess !== this && typeof nativeProcess.kill === "function") {
+      return nativeProcess.kill(pid2, signal);
+    }
+    try {
+      const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib3) {
+        const sig = typeof signal === "number" ? String(signal) : signal || "SIGTERM";
+        const sigArg = sig.startsWith("SIG") ? `-${sig.slice(3)}` : `-${sig}`;
+        GLib3.spawn_command_line_sync(`kill ${sigArg} ${pid2}`);
+        return true;
+      }
+    } catch {
+    }
+    throw new Error("process.kill() is not supported in this environment");
+  }
+  exit(code) {
+    this.exitCode = code ?? this.exitCode ?? 0;
+    this.emit("exit", this.exitCode);
+    const gjsImports = getGjsGlobal().imports;
+    const GLib3 = gjsImports?.gi?.GLib;
+    const system = gjsImports?.system;
+    const idleAdd = GLib3?.idle_add;
+    const sourceRemove = GLib3?.SOURCE_REMOVE;
+    const priorityDefault = GLib3?.PRIORITY_DEFAULT;
+    if (system?.exit && idleAdd && typeof priorityDefault === "number" && typeof sourceRemove === "boolean") {
+      const exitCodeNow = this.exitCode;
+      ensureMainLoop();
+      idleAdd(priorityDefault, () => {
+        quitMainLoop();
+        system.exit(exitCodeNow);
+        return sourceRemove;
+      });
+      return new Promise(() => {
+      });
+    }
+    try {
+      if (system?.exit) system.exit(this.exitCode);
+    } catch {
+    }
+    const nativeProcess = globalThis.process;
+    if (nativeProcess && nativeProcess !== this && typeof nativeProcess.exit === "function") {
+      nativeProcess.exit(this.exitCode);
+    }
+    throw new Error(`process.exit(${this.exitCode})`);
+  }
+  nextTick(callback, ...args) {
+    if (typeof queueMicrotask === "function") {
+      queueMicrotask(() => callback(...args));
+    } else {
+      Promise.resolve().then(() => callback(...args));
+    }
+  }
+  hrtime(time2) {
+    const now = getMonotonicTime() - hrtimeBase;
+    const seconds = Number(now / 1000000000n);
+    const nanoseconds = Number(now % 1000000000n);
+    if (time2) {
+      let diffSec = seconds - time2[0];
+      let diffNano = nanoseconds - time2[1];
+      if (diffNano < 0) {
+        diffSec--;
+        diffNano += 1e9;
+      }
+      return [diffSec, diffNano];
+    }
+    return [seconds, nanoseconds];
+  }
+  uptime() {
+    return (Date.now() - startTime) / 1e3;
+  }
+  memoryUsage() {
+    try {
+      const GLib3 = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib3) {
+        const [, contents] = GLib3.file_get_contents("/proc/self/status");
+        if (contents) {
+          const str = new TextDecoder().decode(contents);
+          const vmRSS = str.match(/VmRSS:\s+(\d+)/);
+          const rss = vmRSS ? parseInt(vmRSS[1], 10) * 1024 : 0;
+          return { rss, heapTotal: rss, heapUsed: rss, external: 0, arrayBuffers: 0 };
+        }
+      }
+    } catch {
+    }
+    const nativeProcess = globalThis.process;
+    if (nativeProcess && nativeProcess !== this && typeof nativeProcess.memoryUsage === "function") {
+      return nativeProcess.memoryUsage();
+    }
+    return { rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 };
+  }
+  cpuUsage(previousValue) {
+    const nativeProcess = globalThis.process;
+    if (nativeProcess && nativeProcess !== this && typeof nativeProcess.cpuUsage === "function") {
+      return nativeProcess.cpuUsage(previousValue);
+    }
+    return { user: 0, system: 0 };
+  }
+  // Note: Cannot check globalThis.process.stdout here — on GJS globalThis.process
+  // IS this instance, so that would cause infinite recursion.
+  stdout = new ProcessWriteStream(1);
+  stderr = new ProcessWriteStream(2);
+  stdin = new ProcessReadStream(0);
+  abort() {
+    this.exit(1);
+  }
+  // no-op stubs for compatibility
+  umask(mask) {
+    return 18;
+  }
+  emitWarning(warning, name2) {
+    if (typeof warning === "string") {
+      console.warn(`(${name2 || "Warning"}): ${warning}`);
+    } else {
+      console.warn(warning.message);
+    }
+  }
+};
+Process.prototype.hrtime.bigint = function() {
+  return getMonotonicTime() - hrtimeBase;
+};
+var process = new Process();
+if (nativeTerminal) {
+  try {
+    const watcher = new nativeTerminal.ResizeWatcher();
+    watcher.connect("resized", (_obj, _rows, _cols) => {
+      process.stdout.emit("resize");
+      process.stderr.emit("resize");
+    });
+    watcher.start();
+  } catch {
+  }
+}
+var platform = process.platform;
+var arch = process.arch;
+var env = process.env;
+var argv = process.argv;
+var argv0 = process.argv0;
+var execPath = process.execPath;
+var pid = process.pid;
+var ppid = process.ppid;
+var version = process.version;
+var versions = process.versions;
+var cwd = process.cwd.bind(process);
+var chdir = process.chdir.bind(process);
+var exit = process.exit.bind(process);
+var nextTick = process.nextTick.bind(process);
+var hrtime = process.hrtime.bind(process);
+var uptime = process.uptime.bind(process);
+var memoryUsage = process.memoryUsage.bind(process);
+var cpuUsage = process.cpuUsage.bind(process);
+var kill = process.kill.bind(process);
+var abort = process.abort.bind(process);
+var umask = process.umask.bind(process);
+var emitWarning = process.emitWarning.bind(process);
+var execArgv = process.execArgv;
+var config = process.config;
+var stdout = process.stdout;
+var stderr = process.stderr;
+var stdin = process.stdin;
+var index_default = process;
+
+// ../../../packages/node/globals/lib/esm/register/process.js
+if (typeof Promise.withResolvers !== "function") {
+  Promise.withResolvers = function() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  };
+}
+initErrorV8Methods(Error);
+if (!("global" in globalThis)) {
+  Object.defineProperty(globalThis, "global", {
+    value: globalThis,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+}
+Object.defineProperty(globalThis, "process", {
+  value: index_default,
+  enumerable: false,
+  writable: true,
+  configurable: true
+});
+
 // ../../../packages/node/perf_hooks/lib/esm/index.js
 var performance2;
 if (globalThis.performance) {
@@ -2922,17 +5070,17 @@ if (globalThis.performance) {
       return entry;
     },
     measure(name2, startMark, endMark) {
-      let startTime = 0;
+      let startTime2 = 0;
       let endTime = _now();
       if (startMark) {
         const s = _entries.find((e) => e.entryType === "mark" && e.name === startMark);
-        if (s) startTime = s.startTime;
+        if (s) startTime2 = s.startTime;
       }
       if (endMark) {
         const e = _entries.find((e2) => e2.entryType === "mark" && e2.name === endMark);
         if (e) endTime = e.startTime;
       }
-      const entry = { name: name2, entryType: "measure", startTime, duration: endTime - startTime };
+      const entry = { name: name2, entryType: "measure", startTime: startTime2, duration: endTime - startTime2 };
       _entries.push(entry);
       return entry;
     },