@gjsify/v8 0.1.13 → 0.2.0

package/lib/esm/heap.js

@@ -0,0 +1,37 @@
+import GLib from "@girs/glib-2.0";
+function readProcStatus() {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const [ok, contents] = GLib.file_get_contents("/proc/self/status");
+    if (!ok || !contents) return map;
+    const text = new TextDecoder().decode(contents);
+    for (const line of text.split("\n")) {
+      const m = /^(\w+):\s+(\d+)(\s+kB)?/.exec(line);
+      if (m) map.set(m[1], parseInt(m[2]) * (m[3] ? 1024 : 1));
+    }
+  } catch {
+  }
+  return map;
+}
+function getHeapStatistics() {
+  const proc = readProcStatus();
+  return {
+    total_heap_size: proc.get("VmSize") ?? 0,
+    total_heap_size_executable: 0,
+    total_physical_size: proc.get("VmRSS") ?? 0,
+    total_available_size: 0,
+    used_heap_size: proc.get("VmRSS") ?? 0,
+    heap_size_limit: 0,
+    malloced_memory: proc.get("VmData") ?? 0,
+    peak_malloced_memory: proc.get("VmPeak") ?? 0,
+    does_zap_garbage: 0,
+    number_of_native_contexts: 0,
+    number_of_detached_contexts: 0,
+    total_global_handles_size: 0,
+    used_global_handles_size: 0,
+    external_memory: 0
+  };
+}
+export {
+  getHeapStatistics
+};

package/lib/esm/index.js

@@ -1,30 +1,24 @@
-function getHeapStatistics() {
-  return {
-    total_heap_size: 0,
-    total_heap_size_executable: 0,
-    total_physical_size: 0,
-    total_available_size: 0,
-    used_heap_size: 0,
-    heap_size_limit: 0,
-    malloced_memory: 0,
-    peak_malloced_memory: 0,
-    does_zap_garbage: 0,
-    number_of_native_contexts: 0,
-    number_of_detached_contexts: 0,
-    external_memory: 0
-  };
+import { getHeapStatistics } from "./heap.js";
+import {
+  Serializer,
+  Deserializer,
+  DefaultSerializer,
+  DefaultDeserializer
+} from "./serdes.js";
+function serialize(value) {
+  const ser = new DefaultSerializer();
+  ser.writeHeader();
+  ser.writeValue(value);
+  return ser.releaseBuffer();
+}
+function deserialize(buffer) {
+  const des = new DefaultDeserializer(buffer);
+  des.readHeader();
+  return des.readValue();
 }
 function getHeapSpaceStatistics() {
   return [];
 }
-function setFlagsFromString(_flags) {
-}
-function getHeapSnapshot() {
-  return null;
-}
-function writeHeapSnapshot(_filename) {
-  return "";
-}
 function getHeapCodeStatistics() {
   return {
     code_and_metadata_size: 0,
@@ -33,30 +27,86 @@ function getHeapCodeStatistics() {
     cpu_profiler_metadata_size: 0
   };
 }
-function serialize(value) {
-  return Buffer.from(JSON.stringify(value));
+function setFlagsFromString(_flags) {
 }
-function deserialize(buffer) {
-  return JSON.parse(buffer.toString());
+function getHeapSnapshot(_options) {
+  return null;
+}
+function writeHeapSnapshot(_filename) {
+  return "";
+}
+function isStringOneByteRepresentation(content) {
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) > 255) return false;
+  }
+  return true;
+}
+class GCProfiler {
+  #running = false;
+  #startTime = 0;
+  start() {
+    if (this.#running) return;
+    this.#running = true;
+    this.#startTime = Date.now();
+  }
+  stop() {
+    if (!this.#running) return void 0;
+    this.#running = false;
+    try {
+      const system = globalThis.imports?.system;
+      if (typeof system?.gc === "function") system.gc();
+    } catch {
+    }
+    return { version: 1, startTime: this.#startTime, endTime: Date.now(), stats: [] };
+  }
+  [Symbol.dispose]() {
+    this.stop();
+  }
+}
+class SyncCPUProfileHandle {
+  stop() {
+    return void 0;
+  }
+  [Symbol.dispose]() {
+    this.stop();
+  }
+}
+function startCpuProfile() {
+  return new SyncCPUProfileHandle();
 }
 var index_default = {
   getHeapStatistics,
   getHeapSpaceStatistics,
+  getHeapCodeStatistics,
   setFlagsFromString,
   getHeapSnapshot,
   writeHeapSnapshot,
-  getHeapCodeStatistics,
   serialize,
-  deserialize
+  deserialize,
+  isStringOneByteRepresentation,
+  Serializer,
+  Deserializer,
+  DefaultSerializer,
+  DefaultDeserializer,
+  GCProfiler,
+  startCpuProfile
 };
 export {
+  DefaultDeserializer,
+  DefaultSerializer,
+  Deserializer,
+  GCProfiler,
+  Serializer,
+  SyncCPUProfileHandle,
   index_default as default,
   deserialize,
   getHeapCodeStatistics,
   getHeapSnapshot,
   getHeapSpaceStatistics,
   getHeapStatistics,
+  isStringOneByteRepresentation,
   serialize,
   setFlagsFromString,
+  startCpuProfile,
   writeHeapSnapshot
 };

package/lib/esm/serdes.js

@@ -0,0 +1,536 @@
+import { Buffer } from "node:buffer";
+const WIRE_VERSION = 15;
+const kVersion = 255;
+const kUndefined = 95;
+const kNull = 48;
+const kTrue = 84;
+const kFalse = 70;
+const kInt32 = 73;
+const kUint32 = 85;
+const kDouble = 78;
+const kBigInt = 90;
+const kOneByteString = 34;
+const kUtf8String = 99;
+const kDate = 68;
+const kRegExp = 82;
+const kBeginJSObject = 111;
+const kEndJSObject = 123;
+const kBeginDenseArray = 65;
+const kEndDenseArray = 36;
+const kArrayBuffer = 66;
+const kObjectReference = 94;
+const kHostObject = 92;
+function writeVarint(buf, n) {
+  n = n >>> 0;
+  while (n >= 128) {
+    buf.push(n & 127 | 128);
+    n >>>= 7;
+  }
+  buf.push(n);
+}
+function readVarint(buf, pos) {
+  let result = 0, shift = 0, byte;
+  do {
+    if (pos >= buf.length) throw new Error("Unexpected end of buffer reading varint");
+    byte = buf[pos++];
+    result |= (byte & 127) << shift;
+    shift += 7;
+  } while (byte & 128);
+  return [result >>> 0, pos];
+}
+function zigZagEncode(n) {
+  return n >= 0 ? n * 2 : -n * 2 - 1;
+}
+function zigZagDecode(n) {
+  return n & 1 ? -(n >>> 1) - 1 : n >>> 1;
+}
+function writeFloat64(buf, d) {
+  const tmp = new DataView(new ArrayBuffer(8));
+  tmp.setFloat64(
+    0,
+    d,
+    true
+    /* LE */
+  );
+  for (let i = 0; i < 8; i++) buf.push(tmp.getUint8(i));
+}
+function readFloat64(buf, pos) {
+  if (pos + 8 > buf.length) throw new Error("ReadDouble() failed");
+  const view = new DataView(buf.buffer, buf.byteOffset + pos, 8);
+  return [view.getFloat64(0, true), pos + 8];
+}
+function isOneByte(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) > 255) return false;
+  }
+  return true;
+}
+function typedArrayToIndex(abView) {
+  const tag = Object.prototype.toString.call(abView);
+  if (tag === "[object Int8Array]") return 0;
+  if (tag === "[object Uint8Array]") return 1;
+  if (tag === "[object Uint8ClampedArray]") return 2;
+  if (tag === "[object Int16Array]") return 3;
+  if (tag === "[object Uint16Array]") return 4;
+  if (tag === "[object Int32Array]") return 5;
+  if (tag === "[object Uint32Array]") return 6;
+  if (tag === "[object Float32Array]") return 7;
+  if (tag === "[object Float64Array]") return 8;
+  if (tag === "[object DataView]") return 9;
+  if (tag === "[object BigInt64Array]") return 11;
+  if (tag === "[object BigUint64Array]") return 12;
+  return -1;
+}
+function indexToTypedArray(index) {
+  switch (index) {
+    case 0:
+      return Int8Array;
+    case 1:
+      return Uint8Array;
+    case 2:
+      return Uint8ClampedArray;
+    case 3:
+      return Int16Array;
+    case 4:
+      return Uint16Array;
+    case 5:
+      return Int32Array;
+    case 6:
+      return Uint32Array;
+    case 7:
+      return Float32Array;
+    case 8:
+      return Float64Array;
+    case 9:
+      return DataView;
+    case 10:
+      return Buffer;
+    case 11:
+      return BigInt64Array;
+    case 12:
+      return BigUint64Array;
+  }
+  return void 0;
+}
+class Serializer {
+  _bytes = [];
+  _seen = [];
+  _treatAbvAsHostObjects = false;
+  _getDataCloneError = Error;
+  writeHeader() {
+    this._bytes.push(kVersion);
+    writeVarint(this._bytes, WIRE_VERSION);
+  }
+  writeValue(value) {
+    if (value !== null && value !== void 0 && typeof value === "object") {
+      const idx = this._seen.indexOf(value);
+      if (idx !== -1) {
+        this._bytes.push(kObjectReference);
+        writeVarint(this._bytes, idx);
+        return;
+      }
+    }
+    if (value === void 0) {
+      this._bytes.push(kUndefined);
+    } else if (value === null) {
+      this._bytes.push(kNull);
+    } else if (value === true) {
+      this._bytes.push(kTrue);
+    } else if (value === false) {
+      this._bytes.push(kFalse);
+    } else if (typeof value === "number") {
+      if (Number.isInteger(value) && value >= -(2 ** 31) && value <= 2 ** 32 - 1) {
+        if (value >= 0) {
+          this._bytes.push(kUint32);
+          writeVarint(this._bytes, value);
+        } else {
+          this._bytes.push(kInt32);
+          writeVarint(this._bytes, zigZagEncode(value));
+        }
+      } else {
+        this._bytes.push(kDouble);
+        writeFloat64(this._bytes, value);
+      }
+    } else if (typeof value === "bigint") {
+      this._writeBigInt(value);
+    } else if (typeof value === "string") {
+      this._writeString(value);
+    } else if (typeof value === "object") {
+      const obj = value;
+      if (value instanceof Date) {
+        this._seen.push(obj);
+        this._bytes.push(kDate);
+        writeFloat64(this._bytes, value.getTime());
+      } else if (value instanceof RegExp) {
+        this._seen.push(obj);
+        this._bytes.push(kRegExp);
+        this._writeString(value.source);
+        writeVarint(this._bytes, regExpFlagsToInt(value));
+      } else if (value instanceof ArrayBuffer) {
+        this._seen.push(obj);
+        const bytes = new Uint8Array(value);
+        this._bytes.push(kArrayBuffer);
+        writeVarint(this._bytes, bytes.length);
+        for (let i = 0; i < bytes.length; i++) this._bytes.push(bytes[i]);
+      } else if (this._treatAbvAsHostObjects && (ArrayBuffer.isView(value) || Buffer.isBuffer(value))) {
+        this._seen.push(obj);
+        this._bytes.push(kHostObject);
+        this._writeHostObject(obj);
+      } else if (Array.isArray(value)) {
+        this._seen.push(obj);
+        const arr = value;
+        this._bytes.push(kBeginDenseArray);
+        writeVarint(this._bytes, arr.length);
+        for (let i = 0; i < arr.length; i++) this.writeValue(arr[i]);
+        this._bytes.push(kEndDenseArray);
+        writeVarint(this._bytes, 0);
+        writeVarint(this._bytes, arr.length);
+      } else {
+        this._seen.push(obj);
+        this._bytes.push(kBeginJSObject);
+        const keys = Object.keys(obj);
+        for (const key of keys) {
+          this._writeString(key);
+          this.writeValue(obj[key]);
+        }
+        this._bytes.push(kEndJSObject);
+        writeVarint(this._bytes, keys.length);
+      }
+    } else {
+      throw new this._getDataCloneError(
+        `${String(value)} could not be cloned.`
+      );
+    }
+  }
+  releaseBuffer() {
+    const result = Buffer.from(this._bytes);
+    this._bytes = [];
+    this._seen = [];
+    return result;
+  }
+  writeUint32(n) {
+    writeVarint(this._bytes, n >>> 0);
+  }
+  writeUint64(hi, lo) {
+    writeVarint(this._bytes, hi >>> 0);
+    writeVarint(this._bytes, lo >>> 0);
+  }
+  writeDouble(d) {
+    writeFloat64(this._bytes, d);
+  }
+  writeRawBytes(source) {
+    if (!ArrayBuffer.isView(source)) {
+      throw new TypeError("source must be a TypedArray or a DataView");
+    }
+    const bytes = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    for (let i = 0; i < bytes.length; i++) this._bytes.push(bytes[i]);
+  }
+  _writeHostObject(_obj) {
+    throw new this._getDataCloneError(
+      `Unserializable host object: ${Object.prototype.toString.call(_obj)}`
+    );
+  }
+  _setTreatArrayBufferViewsAsHostObjects(flag) {
+    this._treatAbvAsHostObjects = flag;
+  }
+  _writeString(s) {
+    if (isOneByte(s)) {
+      this._bytes.push(kOneByteString);
+      writeVarint(this._bytes, s.length);
+      for (let i = 0; i < s.length; i++) this._bytes.push(s.charCodeAt(i) & 255);
+    } else {
+      const encoded = new TextEncoder().encode(s);
+      this._bytes.push(kUtf8String);
+      writeVarint(this._bytes, encoded.length);
+      for (let i = 0; i < encoded.length; i++) this._bytes.push(encoded[i]);
+    }
+  }
+  _writeBigInt(n) {
+    this._bytes.push(kBigInt);
+    const negative = n < 0n;
+    const abs = negative ? -n : n;
+    const words = [];
+    let remaining = abs;
+    while (remaining > 0n) {
+      words.push(Number(remaining & 0xFFFFFFFFn));
+      words.push(Number(remaining >> 32n & 0xFFFFFFFFn));
+      remaining >>= 64n;
+    }
+    const wordCount = words.length;
+    const bitfield = wordCount << 1 | (negative ? 1 : 0);
+    writeVarint(this._bytes, bitfield);
+    for (const w of words) {
+      this._bytes.push(w & 255);
+      this._bytes.push(w >> 8 & 255);
+      this._bytes.push(w >> 16 & 255);
+      this._bytes.push(w >> 24 & 255);
+    }
+    if (words.length === 0) {
+    }
+  }
+}
+class Deserializer {
+  _pos = 0;
+  _wireVersion = 0;
+  _seen = [];
+  buffer;
+  constructor(buffer) {
+    if (!ArrayBuffer.isView(buffer) && !(buffer instanceof ArrayBuffer)) {
+      throw new TypeError("buffer must be a TypedArray or a DataView");
+    }
+    if (buffer instanceof ArrayBuffer) {
+      this.buffer = Buffer.from(buffer);
+    } else {
+      this.buffer = Buffer.from(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength
+      );
+    }
+  }
+  readHeader() {
+    if (this.buffer[this._pos] !== kVersion) {
+      throw new Error("ReadHeader() failed");
+    }
+    this._pos++;
+    const [ver, pos] = readVarint(this.buffer, this._pos);
+    this._wireVersion = ver;
+    this._pos = pos;
+    return true;
+  }
+  getWireFormatVersion() {
+    return this._wireVersion;
+  }
+  readValue() {
+    if (this._pos >= this.buffer.length) {
+      throw new Error("Unexpected end of buffer");
+    }
+    const tag = this.buffer[this._pos++];
+    switch (tag) {
+      case kUndefined:
+        return void 0;
+      case kNull:
+        return null;
+      case kTrue:
+        return true;
+      case kFalse:
+        return false;
+      case kInt32: {
+        const [n, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        return zigZagDecode(n);
+      }
+      case kUint32: {
+        const [n, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        return n >>> 0;
+      }
+      case kDouble: {
+        const [d, p] = readFloat64(this.buffer, this._pos);
+        this._pos = p;
+        return d;
+      }
+      case kBigInt: {
+        return this._readBigInt();
+      }
+      case kOneByteString: {
+        const [len, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        let s = "";
+        for (let i = 0; i < len; i++) s += String.fromCharCode(this.buffer[this._pos++]);
+        return s;
+      }
+      case kUtf8String: {
+        const [len, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        const bytes = this.buffer.slice(this._pos, this._pos + len);
+        this._pos += len;
+        return new TextDecoder().decode(bytes);
+      }
+      case kDate: {
+        const [ms, p] = readFloat64(this.buffer, this._pos);
+        this._pos = p;
+        const d = new Date(ms);
+        this._seen.push(d);
+        return d;
+      }
+      case kRegExp: {
+        const source = this.readValue();
+        const [flagBits, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        const flags = intToRegExpFlags(flagBits);
+        const re = new RegExp(source, flags);
+        this._seen.push(re);
+        return re;
+      }
+      case kArrayBuffer: {
+        const [byteLen, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        const ab = new ArrayBuffer(byteLen);
+        const view = new Uint8Array(ab);
+        for (let i = 0; i < byteLen; i++) view[i] = this.buffer[this._pos++];
+        this._seen.push(ab);
+        return ab;
+      }
+      case kObjectReference: {
+        const [idx, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        if (idx >= this._seen.length) throw new Error("Invalid object reference");
+        return this._seen[idx];
+      }
+      case kBeginDenseArray: {
+        const [len, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        const arr = new Array(len);
+        this._seen.push(arr);
+        for (let i = 0; i < len; i++) arr[i] = this.readValue();
+        if (this.buffer[this._pos] !== kEndDenseArray) throw new Error("Expected kEndDenseArray");
+        this._pos++;
+        const [, p2] = readVarint(this.buffer, this._pos);
+        this._pos = p2;
+        const [, p3] = readVarint(this.buffer, this._pos);
+        this._pos = p3;
+        return arr;
+      }
+      case kBeginJSObject: {
+        const obj = {};
+        this._seen.push(obj);
+        while (this.buffer[this._pos] !== kEndJSObject) {
+          const key = this.readValue();
+          obj[key] = this.readValue();
+        }
+        this._pos++;
+        const [, p] = readVarint(this.buffer, this._pos);
+        this._pos = p;
+        return obj;
+      }
+      case kHostObject: {
+        const obj = this._readHostObject();
+        if (obj !== null && obj !== void 0) this._seen.push(obj);
+        return obj;
+      }
+      default:
+        throw new Error(`Unknown tag 0x${tag.toString(16).padStart(2, "0")} at position ${this._pos - 1}`);
+    }
+  }
+  readUint32() {
+    const [n, p] = readVarint(this.buffer, this._pos);
+    this._pos = p;
+    return n >>> 0;
+  }
+  readUint64() {
+    const [hi, p1] = readVarint(this.buffer, this._pos);
+    const [lo, p2] = readVarint(this.buffer, p1);
+    this._pos = p2;
+    return [hi >>> 0, lo >>> 0];
+  }
+  readDouble() {
+    const [d, p] = readFloat64(this.buffer, this._pos);
+    this._pos = p;
+    return d;
+  }
+  // Returns the byte offset within this.buffer where the raw bytes start.
+  // Callers use: new FastBuffer(this.buffer.buffer, this.buffer.byteOffset + offset, length)
+  _readRawBytes(length) {
+    const offset = this._pos;
+    this._pos += length;
+    if (this._pos > this.buffer.length) throw new Error("Unexpected end of buffer reading raw bytes");
+    return offset;
+  }
+  // readRawBytes is patched on the prototype below (as in Node.js) to return a Buffer slice
+  readRawBytes(length) {
+    const offset = this._readRawBytes(length);
+    return Buffer.from(this.buffer.buffer, this.buffer.byteOffset + offset, length);
+  }
+  _readHostObject() {
+    throw new Error("No host object deserializer installed");
+  }
+  _readBigInt() {
+    const [bitfield, p] = readVarint(this.buffer, this._pos);
+    this._pos = p;
+    const negative = (bitfield & 1) === 1;
+    const u32Count = bitfield >> 1;
+    let result = 0n;
+    for (let i = 0; i < u32Count; i++) {
+      const lo = this.buffer[this._pos] | this.buffer[this._pos + 1] << 8 | this.buffer[this._pos + 2] << 16 | this.buffer[this._pos + 3] << 24;
+      this._pos += 4;
+      result |= BigInt(lo >>> 0) << BigInt(i * 32);
+    }
+    return negative ? -result : result;
+  }
+}
+function regExpFlagsToInt(re) {
+  let flags = 0;
+  if (re.global) flags |= 1 << 0;
+  if (re.ignoreCase) flags |= 1 << 1;
+  if (re.multiline) flags |= 1 << 2;
+  if (re.sticky) flags |= 1 << 3;
+  if (re.unicode) flags |= 1 << 4;
+  if (re.dotAll) flags |= 1 << 5;
+  if (re.hasIndices) flags |= 1 << 6;
+  if (re.unicodeSets) flags |= 1 << 7;
+  return flags;
+}
+function intToRegExpFlags(bits) {
+  let flags = "";
+  if (bits & 1 << 0) flags += "g";
+  if (bits & 1 << 1) flags += "i";
+  if (bits & 1 << 2) flags += "m";
+  if (bits & 1 << 3) flags += "y";
+  if (bits & 1 << 4) flags += "u";
+  if (bits & 1 << 5) flags += "s";
+  if (bits & 1 << 6) flags += "d";
+  if (bits & 1 << 7) flags += "v";
+  return flags;
+}
+class DefaultSerializer extends Serializer {
+  constructor() {
+    super();
+    this._setTreatArrayBufferViewsAsHostObjects(true);
+  }
+  _writeHostObject(abView) {
+    let typeIndex;
+    if (Buffer.isBuffer(abView)) {
+      typeIndex = 10;
+    } else {
+      typeIndex = typedArrayToIndex(abView);
+      if (typeIndex === -1) {
+        throw new this._getDataCloneError(
+          `Unserializable host object: ${Object.prototype.toString.call(abView)}`
+        );
+      }
+    }
+    this.writeUint32(typeIndex);
+    this.writeUint32(abView.byteLength);
+    this.writeRawBytes(new Uint8Array(abView.buffer, abView.byteOffset, abView.byteLength));
+  }
+}
+class DefaultDeserializer extends Deserializer {
+  _readHostObject() {
+    const typeIndex = this.readUint32();
+    const byteLength = this.readUint32();
+    const byteOffset = this._readRawBytes(byteLength);
+    if (typeIndex === 10) {
+      const b = Buffer.allocUnsafe(byteLength);
+      this.buffer.copy(b, 0, this.buffer.byteOffset + byteOffset, this.buffer.byteOffset + byteOffset + byteLength);
+      return b;
+    }
+    const Ctor = indexToTypedArray(typeIndex);
+    if (!Ctor) throw new Error(`Unknown TypedArray type index ${typeIndex}`);
+    const bytesPerElement = Ctor.BYTES_PER_ELEMENT ?? 1;
+    const elementCount = byteLength / bytesPerElement;
+    const absoluteOffset = this.buffer.byteOffset + byteOffset;
+    if (absoluteOffset % bytesPerElement === 0) {
+      return new Ctor(this.buffer.buffer, absoluteOffset, elementCount);
+    }
+    const copy = Buffer.allocUnsafe(byteLength);
+    this.buffer.copy(copy, 0, this.buffer.byteOffset + byteOffset, this.buffer.byteOffset + byteOffset + byteLength);
+    return new Ctor(copy.buffer, copy.byteOffset, elementCount);
+  }
+}
+export {
+  DefaultDeserializer,
+  DefaultSerializer,
+  Deserializer,
+  Serializer
+};