@scelar/nodepod 1.0.0

package/src/polyfills/buffer.ts

@@ -0,0 +1,628 @@
+// Buffer polyfill extending Uint8Array with Node.js Buffer API
+
+
+import { bytesToBase64, base64ToBytes, bytesToHex, bytesToLatin1 } from '../helpers/byte-encoding';
+
+const textEnc = new TextEncoder();
+const textDec = new TextDecoder('utf-8');
+
+// ---- The main BufferPolyfill class ----
+
+class BufferPolyfill extends Uint8Array {
+  static readonly BYTES_PER_ELEMENT = 1;
+
+  // Overloads matching Node.js Buffer.from
+  static from(source: ArrayLike<number>): BufferPolyfill;
+  static from<T>(source: ArrayLike<T>, mapper: (v: T, i: number) => number, ctx?: unknown): BufferPolyfill;
+  static from(source: string, enc?: string): BufferPolyfill;
+  static from(source: ArrayBuffer | Uint8Array): BufferPolyfill;
+  static from(source: Iterable<number>): BufferPolyfill;
+  static from(
+    source: string | ArrayBuffer | Uint8Array | number[] | ArrayLike<number> | Iterable<number>,
+    encOrMapper?: string | ((v: unknown, i: number) => number),
+    ctx?: unknown
+  ): BufferPolyfill {
+    // Handle typed-array style mapper
+    if (typeof encOrMapper === 'function') {
+      const items = Array.from(source as ArrayLike<number>, encOrMapper as (v: number, i: number) => number, ctx);
+      return new BufferPolyfill(items);
+    }
+
+    const encoding = encOrMapper as string | undefined;
+
+    if (Array.isArray(source)) {
+      return new BufferPolyfill(source);
+    }
+
+    if (typeof source === 'string') {
+      const enc = (encoding || 'utf8').toLowerCase();
+
+      if (enc === 'base64' || enc === 'base64url') {
+        let b64 = source;
+        if (enc === 'base64url') {
+          b64 = b64.replace(/-/g, '+').replace(/_/g, '/');
+          while (b64.length % 4 !== 0) b64 += '=';
+        }
+        return new BufferPolyfill(base64ToBytes(b64));
+      }
+
+      if (enc === 'hex') {
+        const octets = new Uint8Array(source.length >>> 1);
+        for (let i = 0; i < source.length; i += 2) {
+          octets[i >>> 1] = parseInt(source.substring(i, i + 2), 16);
+        }
+        return new BufferPolyfill(octets);
+      }
+
+      if (enc === 'latin1' || enc === 'binary') {
+        const octets = new Uint8Array(source.length);
+        for (let i = 0; i < source.length; i++) {
+          octets[i] = source.charCodeAt(i) & 0xff;
+        }
+        return new BufferPolyfill(octets);
+      }
+
+      // utf-8 default
+      return new BufferPolyfill(textEnc.encode(source));
+    }
+
+    if (source instanceof ArrayBuffer) {
+      return new BufferPolyfill(source);
+    }
+
+    return new BufferPolyfill(source as Uint8Array);
+  }
+
+  static alloc(len: number, fillValue?: number): BufferPolyfill {
+    const buf = new BufferPolyfill(len);
+    if (fillValue !== undefined) {
+      buf.fill(fillValue);
+    }
+    return buf;
+  }
+
+  static allocUnsafe(len: number): BufferPolyfill {
+    return new BufferPolyfill(len);
+  }
+
+  static allocUnsafeSlow(len: number): BufferPolyfill {
+    return new BufferPolyfill(len);
+  }
+
+  static concat(list: (Uint8Array | BufferPolyfill)[]): BufferPolyfill {
+    let totalLen = 0;
+    for (const chunk of list) totalLen += chunk.length;
+    const merged = new BufferPolyfill(totalLen);
+    let pos = 0;
+    for (const chunk of list) {
+      merged.set(chunk, pos);
+      pos += chunk.length;
+    }
+    return merged;
+  }
+
+  static isBuffer(candidate: unknown): candidate is BufferPolyfill {
+    return candidate instanceof BufferPolyfill || candidate instanceof Uint8Array;
+  }
+
+  static isEncoding(enc: string): boolean {
+    const lower = enc.toLowerCase();
+    return ['utf8', 'utf-8', 'ascii', 'latin1', 'binary', 'base64', 'base64url', 'hex'].includes(lower);
+  }
+
+  static byteLength(text: string, enc?: string): number {
+    const lower = (enc || 'utf8').toLowerCase();
+    if (lower === 'base64' || lower === 'base64url') {
+      const stripped = text.replace(/[=]/g, '');
+      return Math.floor(stripped.length * 3 / 4);
+    }
+    if (lower === 'hex') {
+      return text.length >>> 1;
+    }
+    return textEnc.encode(text).length;
+  }
+
+  // ---- Instance methods ----
+
+  toString(enc: BufferEncoding = 'utf8'): string {
+    const lower = (enc || 'utf8').toLowerCase();
+
+    if (lower === 'base64') return bytesToBase64(this);
+
+    if (lower === 'base64url') {
+      return bytesToBase64(this).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    }
+
+    if (lower === 'hex') return bytesToHex(this);
+
+    if (lower === 'latin1' || lower === 'binary') return bytesToLatin1(this);
+
+    return textDec.decode(this);
+  }
+
+  slice(begin?: number, end?: number): BufferPolyfill {
+    return new BufferPolyfill(super.slice(begin, end));
+  }
+
+  subarray(begin?: number, end?: number): BufferPolyfill {
+    return new BufferPolyfill(super.subarray(begin, end));
+  }
+
+  write(string: string, encoding?: BufferEncoding): number;
+  write(string: string, offset: number, encoding?: BufferEncoding): number;
+  write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
+  write(string: string, offsetOrEncoding?: number | BufferEncoding, lengthOrEncoding?: number | BufferEncoding, _encoding?: BufferEncoding): number {
+    const offset = typeof offsetOrEncoding === "number" ? offsetOrEncoding : 0;
+    const encoded = textEnc.encode(string);
+    const len = typeof lengthOrEncoding === "number" ? Math.min(lengthOrEncoding, encoded.length) : encoded.length;
+    this.set(encoded.subarray(0, len), offset);
+    return len;
+  }
+
+  copy(dest: BufferPolyfill, destStart?: number, srcStart?: number, srcEnd?: number): number {
+    const segment = this.subarray(srcStart || 0, srcEnd);
+    dest.set(segment, destStart || 0);
+    return segment.length;
+  }
+
+  compare(other: Uint8Array): number {
+    const bound = Math.min(this.length, other.length);
+    for (let i = 0; i < bound; i++) {
+      if (this[i] < other[i]) return -1;
+      if (this[i] > other[i]) return 1;
+    }
+    if (this.length < other.length) return -1;
+    if (this.length > other.length) return 1;
+    return 0;
+  }
+
+  equals(other: Uint8Array): boolean {
+    return this.compare(other) === 0;
+  }
+
+  toJSON(): { type: string; data: number[] } {
+    return { type: 'Buffer', data: Array.from(this) };
+  }
+
+  hasOwnProperty(key: PropertyKey): boolean {
+    return Object.prototype.hasOwnProperty.call(this, key);
+  }
+
+  indexOf(needle: number | Uint8Array | string, fromIndex?: number): number {
+    const start = fromIndex || 0;
+    if (typeof needle === 'number') {
+      for (let i = start; i < this.length; i++) {
+        if (this[i] === needle) return i;
+      }
+      return -1;
+    }
+    const search = typeof needle === 'string' ? BufferPolyfill.from(needle) : needle;
+    for (let i = start; i <= this.length - search.length; i++) {
+      let match = true;
+      for (let j = 0; j < search.length; j++) {
+        if (this[i + j] !== search[j]) { match = false; break; }
+      }
+      if (match) return i;
+    }
+    return -1;
+  }
+
+  includes(needle: number | Uint8Array | string, fromIndex?: number): boolean {
+    return this.indexOf(needle, fromIndex) !== -1;
+  }
+
+  // ---- Unsigned integer reads ----
+
+  readUInt8(pos: number): number {
+    return this[pos];
+  }
+
+  readUInt16BE(pos: number): number {
+    return (this[pos] << 8) | this[pos + 1];
+  }
+
+  readUInt16LE(pos: number): number {
+    return this[pos] | (this[pos + 1] << 8);
+  }
+
+  readUInt32BE(pos: number): number {
+    return ((this[pos] << 24) | (this[pos + 1] << 16) | (this[pos + 2] << 8) | this[pos + 3]) >>> 0;
+  }
+
+  readUInt32LE(pos: number): number {
+    return ((this[pos]) | (this[pos + 1] << 8) | (this[pos + 2] << 16) | (this[pos + 3] << 24)) >>> 0;
+  }
+
+  // ---- Unsigned integer writes ----
+
+  writeUInt8(val: number, pos: number): number {
+    this[pos] = val & 0xff;
+    return pos + 1;
+  }
+
+  writeUInt16BE(val: number, pos: number): number {
+    this[pos] = (val >>> 8) & 0xff;
+    this[pos + 1] = val & 0xff;
+    return pos + 2;
+  }
+
+  writeUInt16LE(val: number, pos: number): number {
+    this[pos] = val & 0xff;
+    this[pos + 1] = (val >>> 8) & 0xff;
+    return pos + 2;
+  }
+
+  writeUInt32BE(val: number, pos: number): number {
+    this[pos] = (val >>> 24) & 0xff;
+    this[pos + 1] = (val >>> 16) & 0xff;
+    this[pos + 2] = (val >>> 8) & 0xff;
+    this[pos + 3] = val & 0xff;
+    return pos + 4;
+  }
+
+  writeUInt32LE(val: number, pos: number): number {
+    this[pos] = val & 0xff;
+    this[pos + 1] = (val >>> 8) & 0xff;
+    this[pos + 2] = (val >>> 16) & 0xff;
+    this[pos + 3] = (val >>> 24) & 0xff;
+    return pos + 4;
+  }
+
+  // ---- Lowercase aliases ----
+  readUint8(pos: number): number { return this.readUInt8(pos); }
+  readUint16BE(pos: number): number { return this.readUInt16BE(pos); }
+  readUint16LE(pos: number): number { return this.readUInt16LE(pos); }
+  readUint32BE(pos: number): number { return this.readUInt32BE(pos); }
+  readUint32LE(pos: number): number { return this.readUInt32LE(pos); }
+  writeUint8(val: number, pos: number): number { return this.writeUInt8(val, pos); }
+  writeUint16BE(val: number, pos: number): number { return this.writeUInt16BE(val, pos); }
+  writeUint16LE(val: number, pos: number): number { return this.writeUInt16LE(val, pos); }
+  writeUint32BE(val: number, pos: number): number { return this.writeUInt32BE(val, pos); }
+  writeUint32LE(val: number, pos: number): number { return this.writeUInt32LE(val, pos); }
+
+  // ---- Signed integer reads ----
+
+  readInt8(pos: number): number {
+    const raw = this[pos];
+    return raw & 0x80 ? raw - 0x100 : raw;
+  }
+
+  readInt16BE(pos: number): number {
+    const raw = this.readUInt16BE(pos);
+    return raw & 0x8000 ? raw - 0x10000 : raw;
+  }
+
+  readInt16LE(pos: number): number {
+    const raw = this.readUInt16LE(pos);
+    return raw & 0x8000 ? raw - 0x10000 : raw;
+  }
+
+  readInt32BE(pos: number): number {
+    return this.readUInt32BE(pos) | 0;
+  }
+
+  readInt32LE(pos: number): number {
+    return this.readUInt32LE(pos) | 0;
+  }
+
+  // ---- Signed integer writes ----
+
+  writeInt8(val: number, pos: number): number {
+    this[pos] = val & 0xff;
+    return pos + 1;
+  }
+
+  writeInt16BE(val: number, pos: number): number {
+    return this.writeUInt16BE(val & 0xffff, pos);
+  }
+
+  writeInt16LE(val: number, pos: number): number {
+    return this.writeUInt16LE(val & 0xffff, pos);
+  }
+
+  writeInt32BE(val: number, pos: number): number {
+    return this.writeUInt32BE(val >>> 0, pos);
+  }
+
+  writeInt32LE(val: number, pos: number): number {
+    return this.writeUInt32LE(val >>> 0, pos);
+  }
+
+  // ---- BigInt 64-bit reads ----
+
+  readBigUInt64LE(pos: number): bigint {
+    const lo = BigInt(this[pos] | (this[pos + 1] << 8) | (this[pos + 2] << 16) | (this[pos + 3] << 24)) & 0xffffffffn;
+    const hi = BigInt(this[pos + 4] | (this[pos + 5] << 8) | (this[pos + 6] << 16) | (this[pos + 7] << 24)) & 0xffffffffn;
+    return lo | (hi << 32n);
+  }
+
+  readBigUInt64BE(pos: number): bigint {
+    const hi = BigInt(this[pos] << 24 | this[pos + 1] << 16 | this[pos + 2] << 8 | this[pos + 3]) & 0xffffffffn;
+    const lo = BigInt(this[pos + 4] << 24 | this[pos + 5] << 16 | this[pos + 6] << 8 | this[pos + 7]) & 0xffffffffn;
+    return lo | (hi << 32n);
+  }
+
+  readBigInt64LE(pos: number): bigint {
+    const unsigned = this.readBigUInt64LE(pos);
+    return unsigned >= 0x8000000000000000n ? unsigned - 0x10000000000000000n : unsigned;
+  }
+
+  readBigInt64BE(pos: number): bigint {
+    const unsigned = this.readBigUInt64BE(pos);
+    return unsigned >= 0x8000000000000000n ? unsigned - 0x10000000000000000n : unsigned;
+  }
+
+  // ---- BigInt 64-bit writes ----
+
+  writeBigUInt64LE(val: bigint, pos: number): number {
+    const lo = val & 0xffffffffn;
+    const hi = (val >> 32n) & 0xffffffffn;
+    this[pos] = Number(lo & 0xffn);
+    this[pos + 1] = Number((lo >> 8n) & 0xffn);
+    this[pos + 2] = Number((lo >> 16n) & 0xffn);
+    this[pos + 3] = Number((lo >> 24n) & 0xffn);
+    this[pos + 4] = Number(hi & 0xffn);
+    this[pos + 5] = Number((hi >> 8n) & 0xffn);
+    this[pos + 6] = Number((hi >> 16n) & 0xffn);
+    this[pos + 7] = Number((hi >> 24n) & 0xffn);
+    return pos + 8;
+  }
+
+  writeBigUInt64BE(val: bigint, pos: number): number {
+    const lo = val & 0xffffffffn;
+    const hi = (val >> 32n) & 0xffffffffn;
+    this[pos] = Number((hi >> 24n) & 0xffn);
+    this[pos + 1] = Number((hi >> 16n) & 0xffn);
+    this[pos + 2] = Number((hi >> 8n) & 0xffn);
+    this[pos + 3] = Number(hi & 0xffn);
+    this[pos + 4] = Number((lo >> 24n) & 0xffn);
+    this[pos + 5] = Number((lo >> 16n) & 0xffn);
+    this[pos + 6] = Number((lo >> 8n) & 0xffn);
+    this[pos + 7] = Number(lo & 0xffn);
+    return pos + 8;
+  }
+
+  writeBigInt64LE(val: bigint, pos: number): number {
+    const unsigned = val < 0n ? val + 0x10000000000000000n : val;
+    return this.writeBigUInt64LE(unsigned, pos);
+  }
+
+  writeBigInt64BE(val: bigint, pos: number): number {
+    const unsigned = val < 0n ? val + 0x10000000000000000n : val;
+    return this.writeBigUInt64BE(unsigned, pos);
+  }
+
+  // Lowercase BigInt aliases
+  readBigUint64LE(pos: number): bigint { return this.readBigUInt64LE(pos); }
+  readBigUint64BE(pos: number): bigint { return this.readBigUInt64BE(pos); }
+  writeBigUint64LE(val: bigint, pos: number): number { return this.writeBigUInt64LE(val, pos); }
+  writeBigUint64BE(val: bigint, pos: number): number { return this.writeBigUInt64BE(val, pos); }
+
+  // ---- Float / Double reads ----
+
+  readFloatLE(pos: number): number {
+    const dv = new DataView(this.buffer, this.byteOffset + pos, 4);
+    return dv.getFloat32(0, true);
+  }
+
+  readFloatBE(pos: number): number {
+    const dv = new DataView(this.buffer, this.byteOffset + pos, 4);
+    return dv.getFloat32(0, false);
+  }
+
+  readDoubleLE(pos: number): number {
+    const dv = new DataView(this.buffer, this.byteOffset + pos, 8);
+    return dv.getFloat64(0, true);
+  }
+
+  readDoubleBE(pos: number): number {
+    const dv = new DataView(this.buffer, this.byteOffset + pos, 8);
+    return dv.getFloat64(0, false);
+  }
+
+  // ---- Float / Double writes ----
+
+  writeFloatLE(val: number, pos: number): number {
+    const dv = new DataView(this.buffer, this.byteOffset + pos, 4);
+    dv.setFloat32(0, val, true);
+    return pos + 4;
+  }
+
+  writeFloatBE(val: number, pos: number): number {
+    const dv = new DataView(this.buffer, this.byteOffset + pos, 4);
+    dv.setFloat32(0, val, false);
+    return pos + 4;
+  }
+
+  writeDoubleLE(val: number, pos: number): number {
+    const dv = new DataView(this.buffer, this.byteOffset + pos, 8);
+    dv.setFloat64(0, val, true);
+    return pos + 8;
+  }
+
+  writeDoubleBE(val: number, pos: number): number {
+    const dv = new DataView(this.buffer, this.byteOffset + pos, 8);
+    dv.setFloat64(0, val, false);
+    return pos + 8;
+  }
+
+  // ---- Variable-length integer reads ----
+
+  readUIntLE(pos: number, width: number): number {
+    let result = 0;
+    let factor = 1;
+    for (let i = 0; i < width; i++) {
+      result += this[pos + i] * factor;
+      factor *= 0x100;
+    }
+    return result;
+  }
+
+  readUintLE(pos: number, width: number): number { return this.readUIntLE(pos, width); }
+
+  readUIntBE(pos: number, width: number): number {
+    let result = 0;
+    let factor = 1;
+    for (let i = width - 1; i >= 0; i--) {
+      result += this[pos + i] * factor;
+      factor *= 0x100;
+    }
+    return result;
+  }
+
+  readUintBE(pos: number, width: number): number { return this.readUIntBE(pos, width); }
+
+  readIntLE(pos: number, width: number): number {
+    let raw = this.readUIntLE(pos, width);
+    const threshold = Math.pow(2, (width * 8) - 1);
+    if (raw >= threshold) raw -= Math.pow(2, width * 8);
+    return raw;
+  }
+
+  readIntBE(pos: number, width: number): number {
+    let raw = this.readUIntBE(pos, width);
+    const threshold = Math.pow(2, (width * 8) - 1);
+    if (raw >= threshold) raw -= Math.pow(2, width * 8);
+    return raw;
+  }
+
+  // ---- Variable-length integer writes ----
+
+  writeUIntLE(val: number, pos: number, width: number): number {
+    let remaining = val;
+    for (let i = 0; i < width; i++) {
+      this[pos + i] = remaining & 0xff;
+      remaining = Math.floor(remaining / 0x100);
+    }
+    return pos + width;
+  }
+
+  writeUintLE(val: number, pos: number, width: number): number { return this.writeUIntLE(val, pos, width); }
+
+  writeUIntBE(val: number, pos: number, width: number): number {
+    let remaining = val;
+    for (let i = width - 1; i >= 0; i--) {
+      this[pos + i] = remaining & 0xff;
+      remaining = Math.floor(remaining / 0x100);
+    }
+    return pos + width;
+  }
+
+  writeUintBE(val: number, pos: number, width: number): number { return this.writeUIntBE(val, pos, width); }
+
+  writeIntLE(val: number, pos: number, width: number): number {
+    let adjusted = val;
+    if (adjusted < 0) adjusted += Math.pow(2, width * 8);
+    return this.writeUIntLE(adjusted, pos, width);
+  }
+
+  writeIntBE(val: number, pos: number, width: number): number {
+    let adjusted = val;
+    if (adjusted < 0) adjusted += Math.pow(2, width * 8);
+    return this.writeUIntBE(adjusted, pos, width);
+  }
+
+  // ---- Byte swap methods ----
+
+  swap16(): this {
+    if (this.length % 2 !== 0) throw new RangeError('Buffer size must be a multiple of 16-bits');
+    for (let i = 0; i < this.length; i += 2) {
+      const tmp = this[i];
+      this[i] = this[i + 1];
+      this[i + 1] = tmp;
+    }
+    return this;
+  }
+
+  swap32(): this {
+    if (this.length % 4 !== 0) throw new RangeError('Buffer size must be a multiple of 32-bits');
+    for (let i = 0; i < this.length; i += 4) {
+      const a = this[i], 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(): this {
+    if (this.length % 8 !== 0) throw new RangeError('Buffer size must be a multiple of 64-bits');
+    for (let i = 0; i < this.length; i += 8) {
+      const a = this[i], b = this[i + 1], c = this[i + 2], 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;
+  }
+}
+
+// Wrap BufferPolyfill so it can be called without `new` (like Node.js's deprecated Buffer())
+// Cast to BufferConstructor so downstream code sees Node.js-compatible Buffer types.
+const Buffer = new Proxy(BufferPolyfill, {
+  apply(_target, _thisArg, args) {
+    // Buffer(string, encoding) or Buffer(size) or Buffer(array) — deprecated but still works in Node
+    return (BufferPolyfill as any).from(...args);
+  },
+}) as unknown as BufferConstructor & typeof BufferPolyfill;
+
+// Install on globalThis if missing
+if (typeof globalThis.Buffer === 'undefined') {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (globalThis as any).Buffer = Buffer;
+}
+
+export { Buffer };
+
+// Secondary exports matching Node.js `buffer` module surface
+export const SlowBuffer = Buffer;
+export const kMaxLength = 2147483647;
+export const INSPECT_MAX_BYTES = 50;
+
+export const constants = {
+  MAX_LENGTH: kMaxLength,
+  MAX_STRING_LENGTH: 536870888,
+};
+
+export function transcode(
+  src: Uint8Array,
+  _fromEnc: string,
+  _toEnc: string
+): InstanceType<typeof BufferPolyfill> {
+  return BufferPolyfill.from(src);
+}
+
+export function resolveObjectURL(_id: string): undefined {
+  return undefined;
+}
+
+export function atob(data: string): string {
+  return globalThis.atob(data);
+}
+
+export function btoa(data: string): string {
+  return globalThis.btoa(data);
+}
+
+const bufferModule: Record<string, unknown> = {
+  Buffer: BufferPolyfill,
+  SlowBuffer,
+  kMaxLength,
+  INSPECT_MAX_BYTES,
+  constants,
+  transcode,
+  resolveObjectURL,
+  atob,
+  btoa,
+};
+
+Object.defineProperty(bufferModule, 'hasOwnProperty', {
+  value: Object.prototype.hasOwnProperty,
+  enumerable: false,
+  configurable: true,
+  writable: true,
+});
+
+export default bufferModule;