@gjsify/buffer 0.0.4 → 0.1.1

package/lib/esm/buffer.js

@@ -0,0 +1,661 @@
+import { normalizeEncoding, checkEncoding, btoaPolyfill as _btoa, base64Decode } from "@gjsify/utils";
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const 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, start, end) {
+  const slice = start !== void 0 || end !== void 0 ? buf.subarray(start ?? 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 _btoa(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");
+  }
+}
+const INSPECT_MAX_BYTES = 50;
+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(value, encodingOrOffset, length) {
+    if (typeof value === "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(value, encoding);
+      const buf = new Buffer(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+      return buf;
+    }
+    if (ArrayBuffer.isView(value)) {
+      const buf = new Buffer(value.buffer, value.byteOffset, value.byteLength);
+      const copy = new Buffer(buf.length);
+      copy.set(buf);
+      return copy;
+    }
+    if (value instanceof ArrayBuffer) {
+      const offset = encodingOrOffset || 0;
+      const len = length !== void 0 ? length : value.byteLength - offset;
+      return new Buffer(value, offset, len);
+    }
+    if (hasSharedArrayBuffer && value instanceof SharedArrayBuffer) {
+      const offset = encodingOrOffset || 0;
+      const len = length !== void 0 ? length : value.byteLength - offset;
+      return new Buffer(new Uint8Array(value, offset, len));
+    }
+    if (Array.isArray(value)) {
+      const buf = new Buffer(value.length);
+      for (let i = 0; i < value.length; i++) {
+        buf[i] = value[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, start, end) {
+    const enc = normalizeEncoding(encoding);
+    return decodeString(this, enc, start, 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(start, end) {
+    const s = start ?? 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(start, end) {
+    const sub = super.subarray(start, 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(value, offset, end, encoding) {
+    const start = offset ?? 0;
+    const stop = end ?? this.length;
+    if (typeof value === "number") {
+      super.fill(value & 255, start, stop);
+    } else if (typeof value === "string") {
+      const enc = normalizeEncoding(encoding);
+      const encoded = encodeString(value, enc);
+      if (encoded.length === 0) {
+        super.fill(0, start, stop);
+      } else if (encoded.length === 1) {
+        super.fill(encoded[0], start, stop);
+      } else {
+        for (let i = start; i < stop; i++) {
+          this[i] = encoded[(i - start) % encoded.length];
+        }
+      }
+    } else if (value instanceof Uint8Array) {
+      if (value.length === 0) {
+        super.fill(0, start, stop);
+      } else {
+        for (let i = start; i < stop; i++) {
+          this[i] = value[(i - start) % value.length];
+        }
+      }
+    }
+    return this;
+  }
+  indexOf(value, byteOffset, encoding) {
+    if (typeof value === "number") {
+      return super.indexOf(value & 255, byteOffset);
+    }
+    const needle = typeof value === "string" ? encodeString(value, normalizeEncoding(encoding)) : value;
+    const start = byteOffset ?? 0;
+    outer:
+      for (let i = start; 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(value, byteOffset, encoding) {
+    if (typeof value === "number") {
+      return byteOffset !== void 0 ? super.lastIndexOf(value & 255, byteOffset) : super.lastIndexOf(value & 255);
+    }
+    const needle = typeof value === "string" ? encodeString(value, normalizeEncoding(encoding)) : value;
+    const start = byteOffset !== void 0 ? Math.min(byteOffset, this.length - needle.length) : this.length - needle.length;
+    outer:
+      for (let i = start; i >= 0; i--) {
+        for (let j = 0; j < needle.length; j++) {
+          if (this[i + j] !== needle[j]) continue outer;
+        }
+        return i;
+      }
+    return -1;
+  }
+  includes(value, byteOffset, encoding) {
+    return this.indexOf(value, 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(value, offset = 0) {
+    checkOffset(offset, 1, this.length);
+    this[offset] = value & 255;
+    return offset + 1;
+  }
+  writeUInt16BE(value, offset = 0) {
+    checkOffset(offset, 2, this.length);
+    this[offset] = value >>> 8 & 255;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  }
+  writeUInt16LE(value, offset = 0) {
+    checkOffset(offset, 2, this.length);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8 & 255;
+    return offset + 2;
+  }
+  writeUInt32BE(value, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    this[offset] = value >>> 24 & 255;
+    this[offset + 1] = value >>> 16 & 255;
+    this[offset + 2] = value >>> 8 & 255;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  }
+  writeUInt32LE(value, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8 & 255;
+    this[offset + 2] = value >>> 16 & 255;
+    this[offset + 3] = value >>> 24 & 255;
+    return offset + 4;
+  }
+  writeInt8(value, offset = 0) {
+    checkOffset(offset, 1, this.length);
+    if (value < 0) value = 255 + value + 1;
+    this[offset] = value & 255;
+    return offset + 1;
+  }
+  writeInt16BE(value, offset = 0) {
+    checkOffset(offset, 2, this.length);
+    this[offset] = value >>> 8 & 255;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  }
+  writeInt16LE(value, offset = 0) {
+    checkOffset(offset, 2, this.length);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8 & 255;
+    return offset + 2;
+  }
+  writeInt32BE(value, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    this[offset] = value >>> 24 & 255;
+    this[offset + 1] = value >>> 16 & 255;
+    this[offset + 2] = value >>> 8 & 255;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  }
+  writeInt32LE(value, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8 & 255;
+    this[offset + 2] = value >>> 16 & 255;
+    this[offset + 3] = value >>> 24 & 255;
+    return offset + 4;
+  }
+  writeFloatBE(value, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    view.setFloat32(0, value, false);
+    return offset + 4;
+  }
+  writeFloatLE(value, offset = 0) {
+    checkOffset(offset, 4, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    view.setFloat32(0, value, true);
+    return offset + 4;
+  }
+  writeDoubleBE(value, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setFloat64(0, value, false);
+    return offset + 8;
+  }
+  writeDoubleLE(value, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setFloat64(0, value, true);
+    return offset + 8;
+  }
+  writeBigInt64BE(value, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setBigInt64(0, value, false);
+    return offset + 8;
+  }
+  writeBigInt64LE(value, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setBigInt64(0, value, true);
+    return offset + 8;
+  }
+  writeBigUInt64BE(value, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setBigUint64(0, value, false);
+    return offset + 8;
+  }
+  writeBigUInt64LE(value, offset = 0) {
+    checkOffset(offset, 8, this.length);
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setBigUint64(0, value, 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;
+  }
+}
+const kMaxLength = 2 ** 31 - 1;
+const kStringMaxLength = 2 ** 28 - 16;
+const constants = { MAX_LENGTH: kMaxLength, MAX_STRING_LENGTH: kStringMaxLength };
+class SlowBuffer extends Buffer {
+  constructor(size) {
+    super(size);
+  }
+}
+export {
+  Buffer,
+  SlowBuffer,
+  constants,
+  kMaxLength,
+  kStringMaxLength
+};

package/lib/esm/index.js

@@ -1,6 +1,33 @@
-export * from "@gjsify/deno_std/node/buffer";
-import buffer from "@gjsify/deno_std/node/buffer";
-var src_default = buffer;
+import { Buffer, SlowBuffer, kMaxLength, kStringMaxLength, constants } from "./buffer.js";
+import { Blob as BlobImpl, File as FileImpl } from "./blob.js";
+import { registerGlobal } from "@gjsify/utils";
+registerGlobal("Blob", BlobImpl);
+registerGlobal("File", FileImpl);
+const atob = globalThis.atob;
+const btoa = globalThis.btoa;
+const INSPECT_MAX_BYTES = 50;
+var index_default = {
+  Buffer,
+  SlowBuffer,
+  Blob: BlobImpl,
+  File: FileImpl,
+  atob,
+  btoa,
+  kMaxLength,
+  kStringMaxLength,
+  constants,
+  INSPECT_MAX_BYTES
+};
 export {
-  src_default as default
+  BlobImpl as Blob,
+  Buffer,
+  FileImpl as File,
+  INSPECT_MAX_BYTES,
+  SlowBuffer,
+  atob,
+  btoa,
+  constants,
+  index_default as default,
+  kMaxLength,
+  kStringMaxLength
 };