feat(ext/node): embed std/node into the snapshot (#17724)

This commit moves "deno_std/node" in "ext/node" crate. The code is
transpiled and snapshotted during the build process.

During the first pass a minimal amount of work was done to create the
snapshot, a lot of code in "ext/node" depends on presence of "Deno"
global. This code will be gradually fixed in the follow up PRs to migrate
it to import relevant APIs from "internal:" modules.

Currently the code from snapshot is not used in any way, and all
Node/npm compatibility still uses code from 
"https://deno.land/std/node" (or from the location specified by 
"DENO_NODE_COMPAT_URL"). This will also be handled in a follow 
up PRs.

---------

Co-authored-by: crowlkats <crowlkats@toaxl.com>
Co-authored-by: Divy Srivastava <dj.srivastava23@gmail.com>
Co-authored-by: Yoshiya Hinosawa <stibium121@gmail.com>

1 files changed, 2607 insertions, 0 deletions

diff --git a/ext/node/polyfills/internal/buffer.mjs b/ext/node/polyfills/internal/buffer.mjs
new file mode 100644
index 000000000..506f90507
--- /dev/null
+++ b/ext/node/polyfills/internal/buffer.mjs
@@ -0,0 +1,2607 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+// Copyright Feross Aboukhadijeh, and other contributors. All rights reserved. MIT license.
+
+import { TextDecoder, TextEncoder } from "internal:deno_web/08_text_encoding.js";
+import { codes } from "internal:deno_node/polyfills/internal/error_codes.ts";
+import { encodings } from "internal:deno_node/polyfills/internal_binding/string_decoder.ts";
+import { indexOfBuffer, indexOfNumber } from "internal:deno_node/polyfills/internal_binding/buffer.ts";
+import {
+  asciiToBytes,
+  base64ToBytes,
+  base64UrlToBytes,
+  bytesToAscii,
+  bytesToUtf16le,
+  hexToBytes,
+  utf16leToBytes,
+} from "internal:deno_node/polyfills/internal_binding/_utils.ts";
+import { isAnyArrayBuffer, isArrayBufferView } from "internal:deno_node/polyfills/internal/util/types.ts";
+import { normalizeEncoding } from "internal:deno_node/polyfills/internal/util.mjs";
+import { validateBuffer } from "internal:deno_node/polyfills/internal/validators.mjs";
+import { isUint8Array } from "internal:deno_node/polyfills/internal/util/types.ts";
+import { forgivingBase64Encode, forgivingBase64UrlEncode } from "internal:deno_web/00_infra.js";
+
+const utf8Encoder = new TextEncoder();
+
+// Temporary buffers to convert numbers.
+const float32Array = new Float32Array(1);
+const uInt8Float32Array = new Uint8Array(float32Array.buffer);
+const float64Array = new Float64Array(1);
+const uInt8Float64Array = new Uint8Array(float64Array.buffer);
+
+// Check endianness.
+float32Array[0] = -1; // 0xBF800000
+// Either it is [0, 0, 128, 191] or [191, 128, 0, 0]. It is not possible to
+// check this with `os.endianness()` because that is determined at compile time.
+export const bigEndian = uInt8Float32Array[3] === 0;
+
+export const kMaxLength = 2147483647;
+export const kStringMaxLength = 536870888;
+const MAX_UINT32 = 2 ** 32;
+
+const customInspectSymbol =
+  typeof Symbol === "function" && typeof Symbol["for"] === "function"
+    ? Symbol["for"]("nodejs.util.inspect.custom")
+    : null;
+
+const INSPECT_MAX_BYTES = 50;
+
+export const constants = {
+  MAX_LENGTH: kMaxLength,
+  MAX_STRING_LENGTH: kStringMaxLength,
+};
+
+Object.defineProperty(Buffer.prototype, "parent", {
+  enumerable: true,
+  get: function () {
+    if (!Buffer.isBuffer(this)) {
+      return void 0;
+    }
+    return this.buffer;
+  },
+});
+
+Object.defineProperty(Buffer.prototype, "offset", {
+  enumerable: true,
+  get: function () {
+    if (!Buffer.isBuffer(this)) {
+      return void 0;
+    }
+    return this.byteOffset;
+  },
+});
+
+function createBuffer(length) {
+  if (length > kMaxLength) {
+    throw new RangeError(
+      'The value "' + length + '" is invalid for option "size"',
+    );
+  }
+  const buf = new Uint8Array(length);
+  Object.setPrototypeOf(buf, Buffer.prototype);
+  return buf;
+}
+
+export function Buffer(arg, encodingOrOffset, length) {
+  if (typeof arg === "number") {
+    if (typeof encodingOrOffset === "string") {
+      throw new codes.ERR_INVALID_ARG_TYPE(
+        "string",
+        "string",
+        arg,
+      );
+    }
+    return _allocUnsafe(arg);
+  }
+  return _from(arg, encodingOrOffset, length);
+}
+
+Buffer.poolSize = 8192;
+
+function _from(value, encodingOrOffset, length) {
+  if (typeof value === "string") {
+    return fromString(value, encodingOrOffset);
+  }
+
+  if (typeof value === "object" && value !== null) {
+    if (isAnyArrayBuffer(value)) {
+      return fromArrayBuffer(value, encodingOrOffset, length);
+    }
+
+    const valueOf = value.valueOf && value.valueOf();
+    if (
+      valueOf != null &&
+      valueOf !== value &&
+      (typeof valueOf === "string" || typeof valueOf === "object")
+    ) {
+      return _from(valueOf, encodingOrOffset, length);
+    }
+
+    const b = fromObject(value);
+    if (b) {
+      return b;
+    }
+
+    if (typeof value[Symbol.toPrimitive] === "function") {
+      const primitive = value[Symbol.toPrimitive]("string");
+      if (typeof primitive === "string") {
+        return fromString(primitive, encodingOrOffset);
+      }
+    }
+  }
+
+  throw new codes.ERR_INVALID_ARG_TYPE(
+    "first argument",
+    ["string", "Buffer", "ArrayBuffer", "Array", "Array-like Object"],
+    value,
+  );
+}
+
+Buffer.from = function from(value, encodingOrOffset, length) {
+  return _from(value, encodingOrOffset, length);
+};
+
+Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
+
+Object.setPrototypeOf(Buffer, Uint8Array);
+
+function assertSize(size) {
+  validateNumber(size, "size");
+  if (!(size >= 0 && size <= kMaxLength)) {
+    throw new codes.ERR_INVALID_ARG_VALUE.RangeError("size", size);
+  }
+}
+
+function _alloc(size, fill, encoding) {
+  assertSize(size);
+
+  const buffer = createBuffer(size);
+  if (fill !== undefined) {
+    if (encoding !== undefined && typeof encoding !== "string") {
+      throw new codes.ERR_INVALID_ARG_TYPE(
+        "encoding",
+        "string",
+        encoding,
+      );
+    }
+    return buffer.fill(fill, encoding);
+  }
+  return buffer;
+}
+
+Buffer.alloc = function alloc(size, fill, encoding) {
+  return _alloc(size, fill, encoding);
+};
+
+function _allocUnsafe(size) {
+  assertSize(size);
+  return createBuffer(size < 0 ? 0 : checked(size) | 0);
+}
+
+Buffer.allocUnsafe = function allocUnsafe(size) {
+  return _allocUnsafe(size);
+};
+
+Buffer.allocUnsafeSlow = function allocUnsafeSlow(size) {
+  return _allocUnsafe(size);
+};
+
+function fromString(string, encoding) {
+  if (typeof encoding !== "string" || encoding === "") {
+    encoding = "utf8";
+  }
+  if (!Buffer.isEncoding(encoding)) {
+    throw new codes.ERR_UNKNOWN_ENCODING(encoding);
+  }
+  const length = byteLength(string, encoding) | 0;
+  let buf = createBuffer(length);
+  const actual = buf.write(string, encoding);
+  if (actual !== length) {
+    buf = buf.slice(0, actual);
+  }
+  return buf;
+}
+
+function fromArrayLike(array) {
+  const length = array.length < 0 ? 0 : checked(array.length) | 0;
+  const buf = createBuffer(length);
+  for (let i = 0; i < length; i += 1) {
+    buf[i] = array[i] & 255;
+  }
+  return buf;
+}
+
+function fromObject(obj) {
+  if (obj.length !== undefined || isAnyArrayBuffer(obj.buffer)) {
+    if (typeof obj.length !== "number") {
+      return createBuffer(0);
+    }
+    return fromArrayLike(obj);
+  }
+
+  if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+    return fromArrayLike(obj.data);
+  }
+}
+
+function checked(length) {
+  if (length >= kMaxLength) {
+    throw new RangeError(
+      "Attempt to allocate Buffer larger than maximum size: 0x" +
+        kMaxLength.toString(16) + " bytes",
+    );
+  }
+  return length | 0;
+}
+
+export function SlowBuffer(length) {
+  assertSize(length);
+  return Buffer.alloc(+length);
+}
+
+Object.setPrototypeOf(SlowBuffer.prototype, Uint8Array.prototype);
+
+Object.setPrototypeOf(SlowBuffer, Uint8Array);
+
+Buffer.isBuffer = function isBuffer(b) {
+  return b != null && b._isBuffer === true && b !== Buffer.prototype;
+};
+
+Buffer.compare = function compare(a, b) {
+  if (isInstance(a, Uint8Array)) {
+    a = Buffer.from(a, a.offset, a.byteLength);
+  }
+  if (isInstance(b, Uint8Array)) {
+    b = Buffer.from(b, b.offset, b.byteLength);
+  }
+  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+    throw new TypeError(
+      'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array',
+    );
+  }
+  if (a === b) {
+    return 0;
+  }
+  let x = a.length;
+  let y = b.length;
+  for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+    if (a[i] !== b[i]) {
+      x = a[i];
+      y = b[i];
+      break;
+    }
+  }
+  if (x < y) {
+    return -1;
+  }
+  if (y < x) {
+    return 1;
+  }
+  return 0;
+};
+
+Buffer.isEncoding = function isEncoding(encoding) {
+  return typeof encoding === "string" && encoding.length !== 0 &&
+    normalizeEncoding(encoding) !== undefined;
+};
+
+Buffer.concat = function concat(list, length) {
+  if (!Array.isArray(list)) {
+    throw new codes.ERR_INVALID_ARG_TYPE("list", "Array", list);
+  }
+
+  if (list.length === 0) {
+    return Buffer.alloc(0);
+  }
+
+  if (length === undefined) {
+    length = 0;
+    for (let i = 0; i < list.length; i++) {
+      if (list[i].length) {
+        length += list[i].length;
+      }
+    }
+  } else {
+    validateOffset(length, "length");
+  }
+
+  const buffer = Buffer.allocUnsafe(length);
+  let pos = 0;
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    if (!isUint8Array(buf)) {
+      // TODO(BridgeAR): This should not be of type ERR_INVALID_ARG_TYPE.
+      // Instead, find the proper error code for this.
+      throw new codes.ERR_INVALID_ARG_TYPE(
+        `list[${i}]`,
+        ["Buffer", "Uint8Array"],
+        list[i],
+      );
+    }
+    pos += _copyActual(buf, buffer, pos, 0, buf.length);
+  }
+
+  // Note: `length` is always equal to `buffer.length` at this point
+  if (pos < length) {
+    // Zero-fill the remaining bytes if the specified `length` was more than
+    // the actual total length, i.e. if we have some remaining allocated bytes
+    // there were not initialized.
+    buffer.fill(0, pos, length);
+  }
+
+  return buffer;
+};
+
+function byteLength(string, encoding) {
+  if (typeof string !== "string") {
+    if (isArrayBufferView(string) || isAnyArrayBuffer(string)) {
+      return string.byteLength;
+    }
+
+    throw new codes.ERR_INVALID_ARG_TYPE(
+      "string",
+      ["string", "Buffer", "ArrayBuffer"],
+      string,
+    );
+  }
+
+  const len = string.length;
+  const mustMatch = arguments.length > 2 && arguments[2] === true;
+  if (!mustMatch && len === 0) {
+    return 0;
+  }
+
+  if (!encoding) {
+    return (mustMatch ? -1 : byteLengthUtf8(string));
+  }
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined) {
+    return (mustMatch ? -1 : byteLengthUtf8(string));
+  }
+  return ops.byteLength(string);
+}
+
+Buffer.byteLength = byteLength;
+
+Buffer.prototype._isBuffer = true;
+
+function swap(b, n, m) {
+  const i = b[n];
+  b[n] = b[m];
+  b[m] = i;
+}
+
+Buffer.prototype.swap16 = function 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) {
+    swap(this, i, i + 1);
+  }
+  return this;
+};
+
+Buffer.prototype.swap32 = function 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) {
+    swap(this, i, i + 3);
+    swap(this, i + 1, i + 2);
+  }
+  return this;
+};
+
+Buffer.prototype.swap64 = function 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) {
+    swap(this, i, i + 7);
+    swap(this, i + 1, i + 6);
+    swap(this, i + 2, i + 5);
+    swap(this, i + 3, i + 4);
+  }
+  return this;
+};
+
+Buffer.prototype.toString = function toString(encoding, start, end) {
+  if (arguments.length === 0) {
+    return this.utf8Slice(0, this.length);
+  }
+
+  const len = this.length;
+
+  if (start <= 0) {
+    start = 0;
+  } else if (start >= len) {
+    return "";
+  } else {
+    start |= 0;
+  }
+
+  if (end === undefined || end > len) {
+    end = len;
+  } else {
+    end |= 0;
+  }
+
+  if (end <= start) {
+    return "";
+  }
+
+  if (encoding === undefined) {
+    return this.utf8Slice(start, end);
+  }
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined) {
+    throw new codes.ERR_UNKNOWN_ENCODING(encoding);
+  }
+
+  return ops.slice(this, start, end);
+};
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString;
+
+Buffer.prototype.equals = function equals(b) {
+  if (!isUint8Array(b)) {
+    throw new codes.ERR_INVALID_ARG_TYPE(
+      "otherBuffer",
+      ["Buffer", "Uint8Array"],
+      b,
+    );
+  }
+  if (this === b) {
+    return true;
+  }
+  return Buffer.compare(this, b) === 0;
+};
+
+Buffer.prototype.inspect = function inspect() {
+  let str = "";
+  const max = INSPECT_MAX_BYTES;
+  str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+  if (this.length > max) {
+    str += " ... ";
+  }
+  return "<Buffer " + str + ">";
+};
+
+if (customInspectSymbol) {
+  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
+}
+
+Buffer.prototype.compare = function compare(
+  target,
+  start,
+  end,
+  thisStart,
+  thisEnd,
+) {
+  if (isInstance(target, Uint8Array)) {
+    target = Buffer.from(target, target.offset, target.byteLength);
+  }
+  if (!Buffer.isBuffer(target)) {
+    throw new codes.ERR_INVALID_ARG_TYPE(
+      "target",
+      ["Buffer", "Uint8Array"],
+      target,
+    );
+  }
+
+  if (start === undefined) {
+    start = 0;
+  } else {
+    validateOffset(start, "targetStart", 0, kMaxLength);
+  }
+
+  if (end === undefined) {
+    end = target.length;
+  } else {
+    validateOffset(end, "targetEnd", 0, target.length);
+  }
+
+  if (thisStart === undefined) {
+    thisStart = 0;
+  } else {
+    validateOffset(start, "sourceStart", 0, kMaxLength);
+  }
+
+  if (thisEnd === undefined) {
+    thisEnd = this.length;
+  } else {
+    validateOffset(end, "sourceEnd", 0, this.length);
+  }
+
+  if (
+    start < 0 || end > target.length || thisStart < 0 ||
+    thisEnd > this.length
+  ) {
+    throw new codes.ERR_OUT_OF_RANGE("out of range index", "range");
+  }
+
+  if (thisStart >= thisEnd && start >= end) {
+    return 0;
+  }
+  if (thisStart >= thisEnd) {
+    return -1;
+  }
+  if (start >= end) {
+    return 1;
+  }
+  start >>>= 0;
+  end >>>= 0;
+  thisStart >>>= 0;
+  thisEnd >>>= 0;
+  if (this === target) {
+    return 0;
+  }
+  let x = thisEnd - thisStart;
+  let y = end - start;
+  const len = Math.min(x, y);
+  const thisCopy = this.slice(thisStart, thisEnd);
+  const targetCopy = target.slice(start, end);
+  for (let i = 0; i < len; ++i) {
+    if (thisCopy[i] !== targetCopy[i]) {
+      x = thisCopy[i];
+      y = targetCopy[i];
+      break;
+    }
+  }
+  if (x < y) {
+    return -1;
+  }
+  if (y < x) {
+    return 1;
+  }
+  return 0;
+};
+
+function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+  validateBuffer(buffer);
+
+  if (typeof byteOffset === "string") {
+    encoding = byteOffset;
+    byteOffset = undefined;
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff;
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000;
+  }
+  byteOffset = +byteOffset;
+  if (Number.isNaN(byteOffset)) {
+    byteOffset = dir ? 0 : (buffer.length || buffer.byteLength);
+  }
+  dir = !!dir;
+
+  if (typeof val === "number") {
+    return indexOfNumber(buffer, val >>> 0, byteOffset, dir);
+  }
+
+  let ops;
+  if (encoding === undefined) {
+    ops = encodingOps.utf8;
+  } else {
+    ops = getEncodingOps(encoding);
+  }
+
+  if (typeof val === "string") {
+    if (ops === undefined) {
+      throw new codes.ERR_UNKNOWN_ENCODING(encoding);
+    }
+    return ops.indexOf(buffer, val, byteOffset, dir);
+  }
+
+  if (isUint8Array(val)) {
+    const encodingVal = ops === undefined ? encodingsMap.utf8 : ops.encodingVal;
+    return indexOfBuffer(buffer, val, byteOffset, encodingVal, dir);
+  }
+
+  throw new codes.ERR_INVALID_ARG_TYPE(
+    "value",
+    ["number", "string", "Buffer", "Uint8Array"],
+    val,
+  );
+}
+
+Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1;
+};
+
+Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+};
+
+Buffer.prototype.lastIndexOf = function lastIndexOf(
+  val,
+  byteOffset,
+  encoding,
+) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+};
+
+Buffer.prototype.asciiSlice = function asciiSlice(offset, length) {
+  if (offset === 0 && length === this.length) {
+    return bytesToAscii(this);
+  } else {
+    return bytesToAscii(this.slice(offset, length));
+  }
+};
+
+Buffer.prototype.asciiWrite = function asciiWrite(string, offset, length) {
+  return blitBuffer(asciiToBytes(string), this, offset, length);
+};
+
+Buffer.prototype.base64Slice = function base64Slice(
+  offset,
+  length,
+) {
+  if (offset === 0 && length === this.length) {
+    return forgivingBase64Encode(this);
+  } else {
+    return forgivingBase64Encode(this.slice(offset, length));
+  }
+};
+
+Buffer.prototype.base64Write = function base64Write(
+  string,
+  offset,
+  length,
+) {
+  return blitBuffer(base64ToBytes(string), this, offset, length);
+};
+
+Buffer.prototype.base64urlSlice = function base64urlSlice(
+  offset,
+  length,
+) {
+  if (offset === 0 && length === this.length) {
+    return forgivingBase64UrlEncode(this);
+  } else {
+    return forgivingBase64UrlEncode(this.slice(offset, length));
+  }
+};
+
+Buffer.prototype.base64urlWrite = function base64urlWrite(
+  string,
+  offset,
+  length,
+) {
+  return blitBuffer(base64UrlToBytes(string), this, offset, length);
+};
+
+Buffer.prototype.hexWrite = function hexWrite(string, offset, length) {
+  return blitBuffer(
+    hexToBytes(string, this.length - offset),
+    this,
+    offset,
+    length,
+  );
+};
+
+Buffer.prototype.hexSlice = function hexSlice(string, offset, length) {
+  return _hexSlice(this, string, offset, length);
+};
+
+Buffer.prototype.latin1Slice = function latin1Slice(
+  string,
+  offset,
+  length,
+) {
+  return _latin1Slice(this, string, offset, length);
+};
+
+Buffer.prototype.latin1Write = function latin1Write(
+  string,
+  offset,
+  length,
+) {
+  return blitBuffer(asciiToBytes(string), this, offset, length);
+};
+
+Buffer.prototype.ucs2Slice = function ucs2Slice(offset, length) {
+  if (offset === 0 && length === this.length) {
+    return bytesToUtf16le(this);
+  } else {
+    return bytesToUtf16le(this.slice(offset, length));
+  }
+};
+
+Buffer.prototype.ucs2Write = function ucs2Write(string, offset, length) {
+  return blitBuffer(
+    utf16leToBytes(string, this.length - offset),
+    this,
+    offset,
+    length,
+  );
+};
+
+Buffer.prototype.utf8Slice = function utf8Slice(string, offset, length) {
+  return _utf8Slice(this, string, offset, length);
+};
+
+Buffer.prototype.utf8Write = function utf8Write(string, offset, length) {
+  return blitBuffer(
+    utf8ToBytes(string, this.length - offset),
+    this,
+    offset,
+    length,
+  );
+};
+
+Buffer.prototype.write = function write(string, offset, length, encoding) {
+  // Buffer#write(string);
+  if (offset === undefined) {
+    return this.utf8Write(string, 0, this.length);
+  }
+  // Buffer#write(string, encoding)
+  if (length === undefined && typeof offset === "string") {
+    encoding = offset;
+    length = this.length;
+    offset = 0;
+
+    // Buffer#write(string, offset[, length][, encoding])
+  } else {
+    validateOffset(offset, "offset", 0, this.length);
+
+    const remaining = this.length - offset;
+
+    if (length === undefined) {
+      length = remaining;
+    } else if (typeof length === "string") {
+      encoding = length;
+      length = remaining;
+    } else {
+      validateOffset(length, "length", 0, this.length);
+      if (length > remaining) {
+        length = remaining;
+      }
+    }
+  }
+
+  if (!encoding) {
+    return this.utf8Write(string, offset, length);
+  }
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined) {
+    throw new codes.ERR_UNKNOWN_ENCODING(encoding);
+  }
+  return ops.write(this, string, offset, length);
+};
+
+Buffer.prototype.toJSON = function toJSON() {
+  return {
+    type: "Buffer",
+    data: Array.prototype.slice.call(this._arr || this, 0),
+  };
+};
+function fromArrayBuffer(obj, byteOffset, length) {
+  // Convert byteOffset to integer
+  if (byteOffset === undefined) {
+    byteOffset = 0;
+  } else {
+    byteOffset = +byteOffset;
+    if (Number.isNaN(byteOffset)) {
+      byteOffset = 0;
+    }
+  }
+
+  const maxLength = obj.byteLength - byteOffset;
+
+  if (maxLength < 0) {
+    throw new codes.ERR_BUFFER_OUT_OF_BOUNDS("offset");
+  }
+
+  if (length === undefined) {
+    length = maxLength;
+  } else {
+    // Convert length to non-negative integer.
+    length = +length;
+    if (length > 0) {
+      if (length > maxLength) {
+        throw new codes.ERR_BUFFER_OUT_OF_BOUNDS("length");
+      }
+    } else {
+      length = 0;
+    }
+  }
+
+  const buffer = new Uint8Array(obj, byteOffset, length);
+  Object.setPrototypeOf(buffer, Buffer.prototype);
+  return buffer;
+}
+
+function _base64Slice(buf, start, end) {
+  if (start === 0 && end === buf.length) {
+    return forgivingBase64Encode(buf);
+  } else {
+    return forgivingBase64Encode(buf.slice(start, end));
+  }
+}
+
+const decoder = new TextDecoder();
+
+function _utf8Slice(buf, start, end) {
+  return decoder.decode(buf.slice(start, end));
+}
+
+function _latin1Slice(buf, start, end) {
+  let ret = "";
+  end = Math.min(buf.length, end);
+  for (let i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i]);
+  }
+  return ret;
+}
+
+function _hexSlice(buf, start, end) {
+  const len = buf.length;
+  if (!start || start < 0) {
+    start = 0;
+  }
+  if (!end || end < 0 || end > len) {
+    end = len;
+  }
+  let out = "";
+  for (let i = start; i < end; ++i) {
+    out += hexSliceLookupTable[buf[i]];
+  }
+  return out;
+}
+
+Buffer.prototype.slice = function slice(start, end) {
+  const len = this.length;
+  start = ~~start;
+  end = end === void 0 ? len : ~~end;
+  if (start < 0) {
+    start += len;
+    if (start < 0) {
+      start = 0;
+    }
+  } else if (start > len) {
+    start = len;
+  }
+  if (end < 0) {
+    end += len;
+    if (end < 0) {
+      end = 0;
+    }
+  } else if (end > len) {
+    end = len;
+  }
+  if (end < start) {
+    end = start;
+  }
+  const newBuf = this.subarray(start, end);
+  Object.setPrototypeOf(newBuf, Buffer.prototype);
+  return newBuf;
+};
+
+Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function readUIntLE(
+  offset,
+  byteLength,
+) {
+  if (offset === undefined) {
+    throw new codes.ERR_INVALID_ARG_TYPE("offset", "number", offset);
+  }
+  if (byteLength === 6) {
+    return readUInt48LE(this, offset);
+  }
+  if (byteLength === 5) {
+    return readUInt40LE(this, offset);
+  }
+  if (byteLength === 3) {
+    return readUInt24LE(this, offset);
+  }
+  if (byteLength === 4) {
+    return this.readUInt32LE(offset);
+  }
+  if (byteLength === 2) {
+    return this.readUInt16LE(offset);
+  }
+  if (byteLength === 1) {
+    return this.readUInt8(offset);
+  }
+
+  boundsError(byteLength, 6, "byteLength");
+};
+
+Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function readUIntBE(
+  offset,
+  byteLength,
+) {
+  if (offset === undefined) {
+    throw new codes.ERR_INVALID_ARG_TYPE("offset", "number", offset);
+  }
+  if (byteLength === 6) {
+    return readUInt48BE(this, offset);
+  }
+  if (byteLength === 5) {
+    return readUInt40BE(this, offset);
+  }
+  if (byteLength === 3) {
+    return readUInt24BE(this, offset);
+  }
+  if (byteLength === 4) {
+    return this.readUInt32BE(offset);
+  }
+  if (byteLength === 2) {
+    return this.readUInt16BE(offset);
+  }
+  if (byteLength === 1) {
+    return this.readUInt8(offset);
+  }
+
+  boundsError(byteLength, 6, "byteLength");
+};
+
+Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(
+  offset = 0,
+) {
+  validateNumber(offset, "offset");
+  const val = this[offset];
+  if (val === undefined) {
+    boundsError(offset, this.length - 1);
+  }
+
+  return val;
+};
+
+Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = readUInt16BE;
+
+Buffer.prototype.readUint16LE =
+  Buffer.prototype.readUInt16LE =
+    function readUInt16LE(offset = 0) {
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 1];
+      if (first === undefined || last === undefined) {
+        boundsError(offset, this.length - 2);
+      }
+
+      return first + last * 2 ** 8;
+    };
+
+Buffer.prototype.readUint32LE =
+  Buffer.prototype.readUInt32LE =
+    function readUInt32LE(offset = 0) {
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 3];
+      if (first === undefined || last === undefined) {
+        boundsError(offset, this.length - 4);
+      }
+
+      return first +
+        this[++offset] * 2 ** 8 +
+        this[++offset] * 2 ** 16 +
+        last * 2 ** 24;
+    };
+
+Buffer.prototype.readUint32BE = Buffer.prototype.readUInt32BE = readUInt32BE;
+
+Buffer.prototype.readBigUint64LE =
+  Buffer.prototype.readBigUInt64LE =
+    defineBigIntMethod(
+      function readBigUInt64LE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const lo = first + this[++offset] * 2 ** 8 +
+          this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 24;
+        const hi = this[++offset] + this[++offset] * 2 ** 8 +
+          this[++offset] * 2 ** 16 + last * 2 ** 24;
+        return BigInt(lo) + (BigInt(hi) << BigInt(32));
+      },
+    );
+
+Buffer.prototype.readBigUint64BE =
+  Buffer.prototype.readBigUInt64BE =
+    defineBigIntMethod(
+      function readBigUInt64BE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 8 + this[++offset];
+        const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 8 + last;
+        return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+      },
+    );
+
+Buffer.prototype.readIntLE = function readIntLE(
+  offset,
+  byteLength,
+) {
+  if (offset === undefined) {
+    throw new codes.ERR_INVALID_ARG_TYPE("offset", "number", offset);
+  }
+  if (byteLength === 6) {
+    return readInt48LE(this, offset);
+  }
+  if (byteLength === 5) {
+    return readInt40LE(this, offset);
+  }
+  if (byteLength === 3) {
+    return readInt24LE(this, offset);
+  }
+  if (byteLength === 4) {
+    return this.readInt32LE(offset);
+  }
+  if (byteLength === 2) {
+    return this.readInt16LE(offset);
+  }
+  if (byteLength === 1) {
+    return this.readInt8(offset);
+  }
+
+  boundsError(byteLength, 6, "byteLength");
+};
+
+Buffer.prototype.readIntBE = function readIntBE(offset, byteLength) {
+  if (offset === undefined) {
+    throw new codes.ERR_INVALID_ARG_TYPE("offset", "number", offset);
+  }
+  if (byteLength === 6) {
+    return readInt48BE(this, offset);
+  }
+  if (byteLength === 5) {
+    return readInt40BE(this, offset);
+  }
+  if (byteLength === 3) {
+    return readInt24BE(this, offset);
+  }
+  if (byteLength === 4) {
+    return this.readInt32BE(offset);
+  }
+  if (byteLength === 2) {
+    return this.readInt16BE(offset);
+  }
+  if (byteLength === 1) {
+    return this.readInt8(offset);
+  }
+
+  boundsError(byteLength, 6, "byteLength");
+};
+
+Buffer.prototype.readInt8 = function readInt8(offset = 0) {
+  validateNumber(offset, "offset");
+  const val = this[offset];
+  if (val === undefined) {
+    boundsError(offset, this.length - 1);
+  }
+
+  return val | (val & 2 ** 7) * 0x1fffffe;
+};
+
+Buffer.prototype.readInt16LE = function readInt16LE(offset = 0) {
+  validateNumber(offset, "offset");
+  const first = this[offset];
+  const last = this[offset + 1];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, this.length - 2);
+  }
+
+  const val = first + last * 2 ** 8;
+  return val | (val & 2 ** 15) * 0x1fffe;
+};
+
+Buffer.prototype.readInt16BE = function readInt16BE(offset = 0) {
+  validateNumber(offset, "offset");
+  const first = this[offset];
+  const last = this[offset + 1];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, this.length - 2);
+  }
+
+  const val = first * 2 ** 8 + last;
+  return val | (val & 2 ** 15) * 0x1fffe;
+};
+
+Buffer.prototype.readInt32LE = function readInt32LE(offset = 0) {
+  validateNumber(offset, "offset");
+  const first = this[offset];
+  const last = this[offset + 3];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, this.length - 4);
+  }
+
+  return first +
+    this[++offset] * 2 ** 8 +
+    this[++offset] * 2 ** 16 +
+    (last << 24); // Overflow
+};
+
+Buffer.prototype.readInt32BE = function readInt32BE(offset = 0) {
+  validateNumber(offset, "offset");
+  const first = this[offset];
+  const last = this[offset + 3];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, this.length - 4);
+  }
+
+  return (first << 24) + // Overflow
+    this[++offset] * 2 ** 16 +
+    this[++offset] * 2 ** 8 +
+    last;
+};
+
+Buffer.prototype.readBigInt64LE = defineBigIntMethod(
+  function readBigInt64LE(offset) {
+    offset = offset >>> 0;
+    validateNumber(offset, "offset");
+    const first = this[offset];
+    const last = this[offset + 7];
+    if (first === void 0 || last === void 0) {
+      boundsError(offset, this.length - 8);
+    }
+    const val = this[offset + 4] + this[offset + 5] * 2 ** 8 +
+      this[offset + 6] * 2 ** 16 + (last << 24);
+    return (BigInt(val) << BigInt(32)) +
+      BigInt(
+        first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 24,
+      );
+  },
+);
+
+Buffer.prototype.readBigInt64BE = defineBigIntMethod(
+  function readBigInt64BE(offset) {
+    offset = offset >>> 0;
+    validateNumber(offset, "offset");
+    const first = this[offset];
+    const last = this[offset + 7];
+    if (first === void 0 || last === void 0) {
+      boundsError(offset, this.length - 8);
+    }
+    const val = (first << 24) + this[++offset] * 2 ** 16 +
+      this[++offset] * 2 ** 8 + this[++offset];
+    return (BigInt(val) << BigInt(32)) +
+      BigInt(
+        this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 8 + last,
+      );
+  },
+);
+
+Buffer.prototype.readFloatLE = function readFloatLE(offset) {
+  return bigEndian
+    ? readFloatBackwards(this, offset)
+    : readFloatForwards(this, offset);
+};
+
+Buffer.prototype.readFloatBE = function readFloatBE(offset) {
+  return bigEndian
+    ? readFloatForwards(this, offset)
+    : readFloatBackwards(this, offset);
+};
+
+Buffer.prototype.readDoubleLE = function readDoubleLE(offset) {
+  return bigEndian
+    ? readDoubleBackwards(this, offset)
+    : readDoubleForwards(this, offset);
+};
+
+Buffer.prototype.readDoubleBE = function readDoubleBE(offset) {
+  return bigEndian
+    ? readDoubleForwards(this, offset)
+    : readDoubleBackwards(this, offset);
+};
+
+Buffer.prototype.writeUintLE =
+  Buffer.prototype.writeUIntLE =
+    function writeUIntLE(value, offset, byteLength) {
+      if (byteLength === 6) {
+        return writeU_Int48LE(this, value, offset, 0, 0xffffffffffff);
+      }
+      if (byteLength === 5) {
+        return writeU_Int40LE(this, value, offset, 0, 0xffffffffff);
+      }
+      if (byteLength === 3) {
+        return writeU_Int24LE(this, value, offset, 0, 0xffffff);
+      }
+      if (byteLength === 4) {
+        return writeU_Int32LE(this, value, offset, 0, 0xffffffff);
+      }
+      if (byteLength === 2) {
+        return writeU_Int16LE(this, value, offset, 0, 0xffff);
+      }
+      if (byteLength === 1) {
+        return writeU_Int8(this, value, offset, 0, 0xff);
+      }
+
+      boundsError(byteLength, 6, "byteLength");
+    };
+
+Buffer.prototype.writeUintBE =
+  Buffer.prototype.writeUIntBE =
+    function writeUIntBE(value, offset, byteLength) {
+      if (byteLength === 6) {
+        return writeU_Int48BE(this, value, offset, 0, 0xffffffffffff);
+      }
+      if (byteLength === 5) {
+        return writeU_Int40BE(this, value, offset, 0, 0xffffffffff);
+      }
+      if (byteLength === 3) {
+        return writeU_Int24BE(this, value, offset, 0, 0xffffff);
+      }
+      if (byteLength === 4) {
+        return writeU_Int32BE(this, value, offset, 0, 0xffffffff);
+      }
+      if (byteLength === 2) {
+        return writeU_Int16BE(this, value, offset, 0, 0xffff);
+      }
+      if (byteLength === 1) {
+        return writeU_Int8(this, value, offset, 0, 0xff);
+      }
+
+      boundsError(byteLength, 6, "byteLength");
+    };
+
+Buffer.prototype.writeUint8 = Buffer.prototype.writeUInt8 = function writeUInt8(
+  value,
+  offset = 0,
+) {
+  return writeU_Int8(this, value, offset, 0, 0xff);
+};
+
+Buffer.prototype.writeUint16LE =
+  Buffer.prototype.writeUInt16LE =
+    function writeUInt16LE(value, offset = 0) {
+      return writeU_Int16LE(this, value, offset, 0, 0xffff);
+    };
+
+Buffer.prototype.writeUint16BE =
+  Buffer.prototype.writeUInt16BE =
+    function writeUInt16BE(value, offset = 0) {
+      return writeU_Int16BE(this, value, offset, 0, 0xffff);
+    };
+
+Buffer.prototype.writeUint32LE =
+  Buffer.prototype.writeUInt32LE =
+    function writeUInt32LE(value, offset = 0) {
+      return _writeUInt32LE(this, value, offset, 0, 0xffffffff);
+    };
+
+Buffer.prototype.writeUint32BE =
+  Buffer.prototype.writeUInt32BE =
+    function writeUInt32BE(value, offset = 0) {
+      return _writeUInt32BE(this, value, offset, 0, 0xffffffff);
+    };
+
+function wrtBigUInt64LE(buf, value, offset, min, max) {
+  checkIntBI(value, min, max, buf, offset, 7);
+  let lo = Number(value & BigInt(4294967295));
+  buf[offset++] = lo;
+  lo = lo >> 8;
+  buf[offset++] = lo;
+  lo = lo >> 8;
+  buf[offset++] = lo;
+  lo = lo >> 8;
+  buf[offset++] = lo;
+  let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+  buf[offset++] = hi;
+  hi = hi >> 8;
+  buf[offset++] = hi;
+  hi = hi >> 8;
+  buf[offset++] = hi;
+  hi = hi >> 8;
+  buf[offset++] = hi;
+  return offset;
+}
+
+function wrtBigUInt64BE(buf, value, offset, min, max) {
+  checkIntBI(value, min, max, buf, offset, 7);
+  let lo = Number(value & BigInt(4294967295));
+  buf[offset + 7] = lo;
+  lo = lo >> 8;
+  buf[offset + 6] = lo;
+  lo = lo >> 8;
+  buf[offset + 5] = lo;
+  lo = lo >> 8;
+  buf[offset + 4] = lo;
+  let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+  buf[offset + 3] = hi;
+  hi = hi >> 8;
+  buf[offset + 2] = hi;
+  hi = hi >> 8;
+  buf[offset + 1] = hi;
+  hi = hi >> 8;
+  buf[offset] = hi;
+  return offset + 8;
+}
+
+Buffer.prototype.writeBigUint64LE =
+  Buffer.prototype.writeBigUInt64LE =
+    defineBigIntMethod(
+      function writeBigUInt64LE(value, offset = 0) {
+        return wrtBigUInt64LE(
+          this,
+          value,
+          offset,
+          BigInt(0),
+          BigInt("0xffffffffffffffff"),
+        );
+      },
+    );
+
+Buffer.prototype.writeBigUint64BE =
+  Buffer.prototype.writeBigUInt64BE =
+    defineBigIntMethod(
+      function writeBigUInt64BE(value, offset = 0) {
+        return wrtBigUInt64BE(
+          this,
+          value,
+          offset,
+          BigInt(0),
+          BigInt("0xffffffffffffffff"),
+        );
+      },
+    );
+
+Buffer.prototype.writeIntLE = function writeIntLE(
+  value,
+  offset,
+  byteLength,
+) {
+  if (byteLength === 6) {
+    return writeU_Int48LE(
+      this,
+      value,
+      offset,
+      -0x800000000000,
+      0x7fffffffffff,
+    );
+  }
+  if (byteLength === 5) {
+    return writeU_Int40LE(this, value, offset, -0x8000000000, 0x7fffffffff);
+  }
+  if (byteLength === 3) {
+    return writeU_Int24LE(this, value, offset, -0x800000, 0x7fffff);
+  }
+  if (byteLength === 4) {
+    return writeU_Int32LE(this, value, offset, -0x80000000, 0x7fffffff);
+  }
+  if (byteLength === 2) {
+    return writeU_Int16LE(this, value, offset, -0x8000, 0x7fff);
+  }
+  if (byteLength === 1) {
+    return writeU_Int8(this, value, offset, -0x80, 0x7f);
+  }
+
+  boundsError(byteLength, 6, "byteLength");
+};
+
+Buffer.prototype.writeIntBE = function writeIntBE(
+  value,
+  offset,
+  byteLength,
+) {
+  if (byteLength === 6) {
+    return writeU_Int48BE(
+      this,
+      value,
+      offset,
+      -0x800000000000,
+      0x7fffffffffff,
+    );
+  }
+  if (byteLength === 5) {
+    return writeU_Int40BE(this, value, offset, -0x8000000000, 0x7fffffffff);
+  }
+  if (byteLength === 3) {
+    return writeU_Int24BE(this, value, offset, -0x800000, 0x7fffff);
+  }
+  if (byteLength === 4) {
+    return writeU_Int32BE(this, value, offset, -0x80000000, 0x7fffffff);
+  }
+  if (byteLength === 2) {
+    return writeU_Int16BE(this, value, offset, -0x8000, 0x7fff);
+  }
+  if (byteLength === 1) {
+    return writeU_Int8(this, value, offset, -0x80, 0x7f);
+  }
+
+  boundsError(byteLength, 6, "byteLength");
+};
+
+Buffer.prototype.writeInt8 = function writeInt8(value, offset = 0) {
+  return writeU_Int8(this, value, offset, -0x80, 0x7f);
+};
+
+Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset = 0) {
+  return writeU_Int16LE(this, value, offset, -0x8000, 0x7fff);
+};
+
+Buffer.prototype.writeInt16BE = function writeInt16BE(
+  value,
+  offset = 0,
+) {
+  return writeU_Int16BE(this, value, offset, -0x8000, 0x7fff);
+};
+
+Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset = 0) {
+  return writeU_Int32LE(this, value, offset, -0x80000000, 0x7fffffff);
+};
+
+Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset = 0) {
+  return writeU_Int32BE(this, value, offset, -0x80000000, 0x7fffffff);
+};
+
+Buffer.prototype.writeBigInt64LE = defineBigIntMethod(
+  function writeBigInt64LE(value, offset = 0) {
+    return wrtBigUInt64LE(
+      this,
+      value,
+      offset,
+      -BigInt("0x8000000000000000"),
+      BigInt("0x7fffffffffffffff"),
+    );
+  },
+);
+
+Buffer.prototype.writeBigInt64BE = defineBigIntMethod(
+  function writeBigInt64BE(value, offset = 0) {
+    return wrtBigUInt64BE(
+      this,
+      value,
+      offset,
+      -BigInt("0x8000000000000000"),
+      BigInt("0x7fffffffffffffff"),
+    );
+  },
+);
+
+Buffer.prototype.writeFloatLE = function writeFloatLE(
+  value,
+  offset,
+) {
+  return bigEndian
+    ? writeFloatBackwards(this, value, offset)
+    : writeFloatForwards(this, value, offset);
+};
+
+Buffer.prototype.writeFloatBE = function writeFloatBE(
+  value,
+  offset,
+) {
+  return bigEndian
+    ? writeFloatForwards(this, value, offset)
+    : writeFloatBackwards(this, value, offset);
+};
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE(
+  value,
+  offset,
+) {
+  return bigEndian
+    ? writeDoubleBackwards(this, value, offset)
+    : writeDoubleForwards(this, value, offset);
+};
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE(
+  value,
+  offset,
+) {
+  return bigEndian
+    ? writeDoubleForwards(this, value, offset)
+    : writeDoubleBackwards(this, value, offset);
+};
+
+Buffer.prototype.copy = function copy(
+  target,
+  targetStart,
+  sourceStart,
+  sourceEnd,
+) {
+  if (!isUint8Array(this)) {
+    throw new codes.ERR_INVALID_ARG_TYPE(
+      "source",
+      ["Buffer", "Uint8Array"],
+      this,
+    );
+  }
+
+  if (!isUint8Array(target)) {
+    throw new codes.ERR_INVALID_ARG_TYPE(
+      "target",
+      ["Buffer", "Uint8Array"],
+      target,
+    );
+  }
+
+  if (targetStart === undefined) {
+    targetStart = 0;
+  } else {
+    targetStart = toInteger(targetStart, 0);
+    if (targetStart < 0) {
+      throw new codes.ERR_OUT_OF_RANGE("targetStart", ">= 0", targetStart);
+    }
+  }
+
+  if (sourceStart === undefined) {
+    sourceStart = 0;
+  } else {
+    sourceStart = toInteger(sourceStart, 0);
+    if (sourceStart < 0) {
+      throw new codes.ERR_OUT_OF_RANGE("sourceStart", ">= 0", sourceStart);
+    }
+    if (sourceStart >= MAX_UINT32) {
+      throw new codes.ERR_OUT_OF_RANGE(
+        "sourceStart",
+        `< ${MAX_UINT32}`,
+        sourceStart,
+      );
+    }
+  }
+
+  if (sourceEnd === undefined) {
+    sourceEnd = this.length;
+  } else {
+    sourceEnd = toInteger(sourceEnd, 0);
+    if (sourceEnd < 0) {
+      throw new codes.ERR_OUT_OF_RANGE("sourceEnd", ">= 0", sourceEnd);
+    }
+    if (sourceEnd >= MAX_UINT32) {
+      throw new codes.ERR_OUT_OF_RANGE(
+        "sourceEnd",
+        `< ${MAX_UINT32}`,
+        sourceEnd,
+      );
+    }
+  }
+
+  if (targetStart >= target.length) {
+    return 0;
+  }
+
+  if (sourceEnd > 0 && sourceEnd < sourceStart) {
+    sourceEnd = sourceStart;
+  }
+  if (sourceEnd === sourceStart) {
+    return 0;
+  }
+  if (target.length === 0 || this.length === 0) {
+    return 0;
+  }
+
+  if (sourceEnd > this.length) {
+    sourceEnd = this.length;
+  }
+
+  if (target.length - targetStart < sourceEnd - sourceStart) {
+    sourceEnd = target.length - targetStart + sourceStart;
+  }
+
+  const len = sourceEnd - sourceStart;
+  if (
+    this === target && typeof Uint8Array.prototype.copyWithin === "function"
+  ) {
+    this.copyWithin(targetStart, sourceStart, sourceEnd);
+  } else {
+    Uint8Array.prototype.set.call(
+      target,
+      this.subarray(sourceStart, sourceEnd),
+      targetStart,
+    );
+  }
+  return len;
+};
+
+Buffer.prototype.fill = function fill(val, start, end, encoding) {
+  if (typeof val === "string") {
+    if (typeof start === "string") {
+      encoding = start;
+      start = 0;
+      end = this.length;
+    } else if (typeof end === "string") {
+      encoding = end;
+      end = this.length;
+    }
+    if (encoding !== void 0 && typeof encoding !== "string") {
+      throw new TypeError("encoding must be a string");
+    }
+    if (typeof encoding === "string" && !Buffer.isEncoding(encoding)) {
+      throw new TypeError("Unknown encoding: " + encoding);
+    }
+    if (val.length === 1) {
+      const code = val.charCodeAt(0);
+      if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+        val = code;
+      }
+    }
+  } else if (typeof val === "number") {
+    val = val & 255;
+  } else if (typeof val === "boolean") {
+    val = Number(val);
+  }
+  if (start < 0 || this.length < start || this.length < end) {
+    throw new RangeError("Out of range index");
+  }
+  if (end <= start) {
+    return this;
+  }
+  start = start >>> 0;
+  end = end === void 0 ? this.length : end >>> 0;
+  if (!val) {
+    val = 0;
+  }
+  let i;
+  if (typeof val === "number") {
+    for (i = start; i < end; ++i) {
+      this[i] = val;
+    }
+  } else {
+    const bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding);
+    const len = bytes.length;
+    if (len === 0) {
+      throw new codes.ERR_INVALID_ARG_VALUE(
+        "value",
+        val,
+      );
+    }
+    for (i = 0; i < end - start; ++i) {
+      this[i + start] = bytes[i % len];
+    }
+  }
+  return this;
+};
+
+function checkBounds(buf, offset, byteLength2) {
+  validateNumber(offset, "offset");
+  if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+    boundsError(offset, buf.length - (byteLength2 + 1));
+  }
+}
+
+function checkIntBI(value, min, max, buf, offset, byteLength2) {
+  if (value > max || value < min) {
+    const n = typeof min === "bigint" ? "n" : "";
+    let range;
+    if (byteLength2 > 3) {
+      if (min === 0 || min === BigInt(0)) {
+        range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+      } else {
+        range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${
+          (byteLength2 + 1) * 8 - 1
+        }${n}`;
+      }
+    } else {
+      range = `>= ${min}${n} and <= ${max}${n}`;
+    }
+    throw new codes.ERR_OUT_OF_RANGE("value", range, value);
+  }
+  checkBounds(buf, offset, byteLength2);
+}
+
+function utf8ToBytes(string, units) {
+  units = units || Infinity;
+  let codePoint;
+  const length = string.length;
+  let leadSurrogate = null;
+  const bytes = [];
+  for (let i = 0; i < length; ++i) {
+    codePoint = string.charCodeAt(i);
+    if (codePoint > 55295 && codePoint < 57344) {
+      if (!leadSurrogate) {
+        if (codePoint > 56319) {
+          if ((units -= 3) > -1) {
+            bytes.push(239, 191, 189);
+          }
+          continue;
+        } else if (i + 1 === length) {
+          if ((units -= 3) > -1) {
+            bytes.push(239, 191, 189);
+          }
+          continue;
+        }
+        leadSurrogate = codePoint;
+        continue;
+      }
+      if (codePoint < 56320) {
+        if ((units -= 3) > -1) {
+          bytes.push(239, 191, 189);
+        }
+        leadSurrogate = codePoint;
+        continue;
+      }
+      codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+    } else if (leadSurrogate) {
+      if ((units -= 3) > -1) {
+        bytes.push(239, 191, 189);
+      }
+    }
+    leadSurrogate = null;
+    if (codePoint < 128) {
+      if ((units -= 1) < 0) {
+        break;
+      }
+      bytes.push(codePoint);
+    } else if (codePoint < 2048) {
+      if ((units -= 2) < 0) {
+        break;
+      }
+      bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+    } else if (codePoint < 65536) {
+      if ((units -= 3) < 0) {
+        break;
+      }
+      bytes.push(
+        codePoint >> 12 | 224,
+        codePoint >> 6 & 63 | 128,
+        codePoint & 63 | 128,
+      );
+    } else if (codePoint < 1114112) {
+      if ((units -= 4) < 0) {
+        break;
+      }
+      bytes.push(
+        codePoint >> 18 | 240,
+        codePoint >> 12 & 63 | 128,
+        codePoint >> 6 & 63 | 128,
+        codePoint & 63 | 128,
+      );
+    } else {
+      throw new Error("Invalid code point");
+    }
+  }
+  return bytes;
+}
+
+function blitBuffer(src, dst, offset, byteLength) {
+  let i;
+  const length = byteLength === undefined ? src.length : byteLength;
+  for (i = 0; i < length; ++i) {
+    if (i + offset >= dst.length || i >= src.length) {
+      break;
+    }
+    dst[i + offset] = src[i];
+  }
+  return i;
+}
+
+function isInstance(obj, type) {
+  return obj instanceof type ||
+    obj != null && obj.constructor != null &&
+      obj.constructor.name != null && obj.constructor.name === type.name;
+}
+
+const hexSliceLookupTable = function () {
+  const alphabet = "0123456789abcdef";
+  const table = new Array(256);
+  for (let i = 0; i < 16; ++i) {
+    const i16 = i * 16;
+    for (let j = 0; j < 16; ++j) {
+      table[i16 + j] = alphabet[i] + alphabet[j];
+    }
+  }
+  return table;
+}();
+
+function defineBigIntMethod(fn) {
+  return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+}
+
+function BufferBigIntNotDefined() {
+  throw new Error("BigInt not supported");
+}
+
+export const atob = globalThis.atob;
+export const Blob = globalThis.Blob;
+export const btoa = globalThis.btoa;
+
+export function readUInt48LE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 5];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 6);
+  }
+
+  return first +
+    buf[++offset] * 2 ** 8 +
+    buf[++offset] * 2 ** 16 +
+    buf[++offset] * 2 ** 24 +
+    (buf[++offset] + last * 2 ** 8) * 2 ** 32;
+}
+
+export function readUInt40LE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 4];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 5);
+  }
+
+  return first +
+    buf[++offset] * 2 ** 8 +
+    buf[++offset] * 2 ** 16 +
+    buf[++offset] * 2 ** 24 +
+    last * 2 ** 32;
+}
+
+export function readUInt24LE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 2];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 3);
+  }
+
+  return first + buf[++offset] * 2 ** 8 + last * 2 ** 16;
+}
+
+export function readUInt48BE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 5];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 6);
+  }
+
+  return (first * 2 ** 8 + buf[++offset]) * 2 ** 32 +
+    buf[++offset] * 2 ** 24 +
+    buf[++offset] * 2 ** 16 +
+    buf[++offset] * 2 ** 8 +
+    last;
+}
+
+export function readUInt40BE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 4];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 5);
+  }
+
+  return first * 2 ** 32 +
+    buf[++offset] * 2 ** 24 +
+    buf[++offset] * 2 ** 16 +
+    buf[++offset] * 2 ** 8 +
+    last;
+}
+
+export function readUInt24BE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 2];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 3);
+  }
+
+  return first * 2 ** 16 + buf[++offset] * 2 ** 8 + last;
+}
+
+export function readUInt16BE(offset = 0) {
+  validateNumber(offset, "offset");
+  const first = this[offset];
+  const last = this[offset + 1];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, this.length - 2);
+  }
+
+  return first * 2 ** 8 + last;
+}
+
+export function readUInt32BE(offset = 0) {
+  validateNumber(offset, "offset");
+  const first = this[offset];
+  const last = this[offset + 3];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, this.length - 4);
+  }
+
+  return first * 2 ** 24 +
+    this[++offset] * 2 ** 16 +
+    this[++offset] * 2 ** 8 +
+    last;
+}
+
+export function readDoubleBackwards(buffer, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buffer[offset];
+  const last = buffer[offset + 7];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buffer.length - 8);
+  }
+
+  uInt8Float64Array[7] = first;
+  uInt8Float64Array[6] = buffer[++offset];
+  uInt8Float64Array[5] = buffer[++offset];
+  uInt8Float64Array[4] = buffer[++offset];
+  uInt8Float64Array[3] = buffer[++offset];
+  uInt8Float64Array[2] = buffer[++offset];
+  uInt8Float64Array[1] = buffer[++offset];
+  uInt8Float64Array[0] = last;
+  return float64Array[0];
+}
+
+export function readDoubleForwards(buffer, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buffer[offset];
+  const last = buffer[offset + 7];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buffer.length - 8);
+  }
+
+  uInt8Float64Array[0] = first;
+  uInt8Float64Array[1] = buffer[++offset];
+  uInt8Float64Array[2] = buffer[++offset];
+  uInt8Float64Array[3] = buffer[++offset];
+  uInt8Float64Array[4] = buffer[++offset];
+  uInt8Float64Array[5] = buffer[++offset];
+  uInt8Float64Array[6] = buffer[++offset];
+  uInt8Float64Array[7] = last;
+  return float64Array[0];
+}
+
+export function writeDoubleForwards(buffer, val, offset = 0) {
+  val = +val;
+  checkBounds(buffer, offset, 7);
+
+  float64Array[0] = val;
+  buffer[offset++] = uInt8Float64Array[0];
+  buffer[offset++] = uInt8Float64Array[1];
+  buffer[offset++] = uInt8Float64Array[2];
+  buffer[offset++] = uInt8Float64Array[3];
+  buffer[offset++] = uInt8Float64Array[4];
+  buffer[offset++] = uInt8Float64Array[5];
+  buffer[offset++] = uInt8Float64Array[6];
+  buffer[offset++] = uInt8Float64Array[7];
+  return offset;
+}
+
+export function writeDoubleBackwards(buffer, val, offset = 0) {
+  val = +val;
+  checkBounds(buffer, offset, 7);
+
+  float64Array[0] = val;
+  buffer[offset++] = uInt8Float64Array[7];
+  buffer[offset++] = uInt8Float64Array[6];
+  buffer[offset++] = uInt8Float64Array[5];
+  buffer[offset++] = uInt8Float64Array[4];
+  buffer[offset++] = uInt8Float64Array[3];
+  buffer[offset++] = uInt8Float64Array[2];
+  buffer[offset++] = uInt8Float64Array[1];
+  buffer[offset++] = uInt8Float64Array[0];
+  return offset;
+}
+
+export function readFloatBackwards(buffer, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buffer[offset];
+  const last = buffer[offset + 3];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buffer.length - 4);
+  }
+
+  uInt8Float32Array[3] = first;
+  uInt8Float32Array[2] = buffer[++offset];
+  uInt8Float32Array[1] = buffer[++offset];
+  uInt8Float32Array[0] = last;
+  return float32Array[0];
+}
+
+export function readFloatForwards(buffer, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buffer[offset];
+  const last = buffer[offset + 3];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buffer.length - 4);
+  }
+
+  uInt8Float32Array[0] = first;
+  uInt8Float32Array[1] = buffer[++offset];
+  uInt8Float32Array[2] = buffer[++offset];
+  uInt8Float32Array[3] = last;
+  return float32Array[0];
+}
+
+export function writeFloatForwards(buffer, val, offset = 0) {
+  val = +val;
+  checkBounds(buffer, offset, 3);
+
+  float32Array[0] = val;
+  buffer[offset++] = uInt8Float32Array[0];
+  buffer[offset++] = uInt8Float32Array[1];
+  buffer[offset++] = uInt8Float32Array[2];
+  buffer[offset++] = uInt8Float32Array[3];
+  return offset;
+}
+
+export function writeFloatBackwards(buffer, val, offset = 0) {
+  val = +val;
+  checkBounds(buffer, offset, 3);
+
+  float32Array[0] = val;
+  buffer[offset++] = uInt8Float32Array[3];
+  buffer[offset++] = uInt8Float32Array[2];
+  buffer[offset++] = uInt8Float32Array[1];
+  buffer[offset++] = uInt8Float32Array[0];
+  return offset;
+}
+
+export function readInt24LE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 2];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 3);
+  }
+
+  const val = first + buf[++offset] * 2 ** 8 + last * 2 ** 16;
+  return val | (val & 2 ** 23) * 0x1fe;
+}
+
+export function readInt40LE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 4];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 5);
+  }
+
+  return (last | (last & 2 ** 7) * 0x1fffffe) * 2 ** 32 +
+    first +
+    buf[++offset] * 2 ** 8 +
+    buf[++offset] * 2 ** 16 +
+    buf[++offset] * 2 ** 24;
+}
+
+export function readInt48LE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 5];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 6);
+  }
+
+  const val = buf[offset + 4] + last * 2 ** 8;
+  return (val | (val & 2 ** 15) * 0x1fffe) * 2 ** 32 +
+    first +
+    buf[++offset] * 2 ** 8 +
+    buf[++offset] * 2 ** 16 +
+    buf[++offset] * 2 ** 24;
+}
+
+export function readInt24BE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 2];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 3);
+  }
+
+  const val = first * 2 ** 16 + buf[++offset] * 2 ** 8 + last;
+  return val | (val & 2 ** 23) * 0x1fe;
+}
+
+export function readInt48BE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 5];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 6);
+  }
+
+  const val = buf[++offset] + first * 2 ** 8;
+  return (val | (val & 2 ** 15) * 0x1fffe) * 2 ** 32 +
+    buf[++offset] * 2 ** 24 +
+    buf[++offset] * 2 ** 16 +
+    buf[++offset] * 2 ** 8 +
+    last;
+}
+
+export function readInt40BE(buf, offset = 0) {
+  validateNumber(offset, "offset");
+  const first = buf[offset];
+  const last = buf[offset + 4];
+  if (first === undefined || last === undefined) {
+    boundsError(offset, buf.length - 5);
+  }
+
+  return (first | (first & 2 ** 7) * 0x1fffffe) * 2 ** 32 +
+    buf[++offset] * 2 ** 24 +
+    buf[++offset] * 2 ** 16 +
+    buf[++offset] * 2 ** 8 +
+    last;
+}
+
+export function byteLengthUtf8(str) {
+  return utf8Encoder.encode(str).length;
+}
+
+function base64ByteLength(str, bytes) {
+  // Handle padding
+  if (str.charCodeAt(bytes - 1) === 0x3D) {
+    bytes--;
+  }
+  if (bytes > 1 && str.charCodeAt(bytes - 1) === 0x3D) {
+    bytes--;
+  }
+
+  // Base64 ratio: 3/4
+  return (bytes * 3) >>> 2;
+}
+
+export const encodingsMap = Object.create(null);
+for (let i = 0; i < encodings.length; ++i) {
+  encodingsMap[encodings[i]] = i;
+}
+
+export const encodingOps = {
+  ascii: {
+    byteLength: (string) => string.length,
+    encoding: "ascii",
+    encodingVal: encodingsMap.ascii,
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(
+        buf,
+        asciiToBytes(val),
+        byteOffset,
+        encodingsMap.ascii,
+        dir,
+      ),
+    slice: (buf, start, end) => buf.asciiSlice(start, end),
+    write: (buf, string, offset, len) => buf.asciiWrite(string, offset, len),
+  },
+  base64: {
+    byteLength: (string) => base64ByteLength(string, string.length),
+    encoding: "base64",
+    encodingVal: encodingsMap.base64,
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(
+        buf,
+        base64ToBytes(val),
+        byteOffset,
+        encodingsMap.base64,
+        dir,
+      ),
+    slice: (buf, start, end) => buf.base64Slice(start, end),
+    write: (buf, string, offset, len) => buf.base64Write(string, offset, len),
+  },
+  base64url: {
+    byteLength: (string) => base64ByteLength(string, string.length),
+    encoding: "base64url",
+    encodingVal: encodingsMap.base64url,
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(
+        buf,
+        base64UrlToBytes(val),
+        byteOffset,
+        encodingsMap.base64url,
+        dir,
+      ),
+    slice: (buf, start, end) => buf.base64urlSlice(start, end),
+    write: (buf, string, offset, len) =>
+      buf.base64urlWrite(string, offset, len),
+  },
+  hex: {
+    byteLength: (string) => string.length >>> 1,
+    encoding: "hex",
+    encodingVal: encodingsMap.hex,
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(
+        buf,
+        hexToBytes(val),
+        byteOffset,
+        encodingsMap.hex,
+        dir,
+      ),
+    slice: (buf, start, end) => buf.hexSlice(start, end),
+    write: (buf, string, offset, len) => buf.hexWrite(string, offset, len),
+  },
+  latin1: {
+    byteLength: (string) => string.length,
+    encoding: "latin1",
+    encodingVal: encodingsMap.latin1,
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(
+        buf,
+        asciiToBytes(val),
+        byteOffset,
+        encodingsMap.latin1,
+        dir,
+      ),
+    slice: (buf, start, end) => buf.latin1Slice(start, end),
+    write: (buf, string, offset, len) => buf.latin1Write(string, offset, len),
+  },
+  ucs2: {
+    byteLength: (string) => string.length * 2,
+    encoding: "ucs2",
+    encodingVal: encodingsMap.utf16le,
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(
+        buf,
+        utf16leToBytes(val),
+        byteOffset,
+        encodingsMap.utf16le,
+        dir,
+      ),
+    slice: (buf, start, end) => buf.ucs2Slice(start, end),
+    write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+  },
+  utf8: {
+    byteLength: byteLengthUtf8,
+    encoding: "utf8",
+    encodingVal: encodingsMap.utf8,
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(
+        buf,
+        utf8Encoder.encode(val),
+        byteOffset,
+        encodingsMap.utf8,
+        dir,
+      ),
+    slice: (buf, start, end) => buf.utf8Slice(start, end),
+    write: (buf, string, offset, len) => buf.utf8Write(string, offset, len),
+  },
+  utf16le: {
+    byteLength: (string) => string.length * 2,
+    encoding: "utf16le",
+    encodingVal: encodingsMap.utf16le,
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(
+        buf,
+        utf16leToBytes(val),
+        byteOffset,
+        encodingsMap.utf16le,
+        dir,
+      ),
+    slice: (buf, start, end) => buf.ucs2Slice(start, end),
+    write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+  },
+};
+
+export function getEncodingOps(encoding) {
+  encoding = String(encoding).toLowerCase();
+  switch (encoding.length) {
+    case 4:
+      if (encoding === "utf8") return encodingOps.utf8;
+      if (encoding === "ucs2") return encodingOps.ucs2;
+      break;
+    case 5:
+      if (encoding === "utf-8") return encodingOps.utf8;
+      if (encoding === "ascii") return encodingOps.ascii;
+      if (encoding === "ucs-2") return encodingOps.ucs2;
+      break;
+    case 7:
+      if (encoding === "utf16le") {
+        return encodingOps.utf16le;
+      }
+      break;
+    case 8:
+      if (encoding === "utf-16le") {
+        return encodingOps.utf16le;
+      }
+      break;
+    // deno-lint-ignore no-fallthrough
+    case 6:
+      if (encoding === "latin1" || encoding === "binary") {
+        return encodingOps.latin1;
+      }
+      if (encoding === "base64") return encodingOps.base64;
+    case 3:
+      if (encoding === "hex") {
+        return encodingOps.hex;
+      }
+      break;
+    case 9:
+      if (encoding === "base64url") {
+        return encodingOps.base64url;
+      }
+      break;
+  }
+}
+
+export function _copyActual(
+  source,
+  target,
+  targetStart,
+  sourceStart,
+  sourceEnd,
+) {
+  if (sourceEnd - sourceStart > target.length - targetStart) {
+    sourceEnd = sourceStart + target.length - targetStart;
+  }
+
+  let nb = sourceEnd - sourceStart;
+  const sourceLen = source.length - sourceStart;
+  if (nb > sourceLen) {
+    nb = sourceLen;
+  }
+
+  if (sourceStart !== 0 || sourceEnd < source.length) {
+    source = new Uint8Array(source.buffer, source.byteOffset + sourceStart, nb);
+  }
+
+  target.set(source, targetStart);
+
+  return nb;
+}
+
+export function boundsError(value, length, type) {
+  if (Math.floor(value) !== value) {
+    validateNumber(value, type);
+    throw new codes.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
+  }
+
+  if (length < 0) {
+    throw new codes.ERR_BUFFER_OUT_OF_BOUNDS();
+  }
+
+  throw new codes.ERR_OUT_OF_RANGE(
+    type || "offset",
+    `>= ${type ? 1 : 0} and <= ${length}`,
+    value,
+  );
+}
+
+export function validateNumber(value, name) {
+  if (typeof value !== "number") {
+    throw new codes.ERR_INVALID_ARG_TYPE(name, "number", value);
+  }
+}
+
+function checkInt(value, min, max, buf, offset, byteLength) {
+  if (value > max || value < min) {
+    const n = typeof min === "bigint" ? "n" : "";
+    let range;
+    if (byteLength > 3) {
+      if (min === 0 || min === 0n) {
+        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
+      } else {
+        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and ` +
+          `< 2${n} ** ${(byteLength + 1) * 8 - 1}${n}`;
+      }
+    } else {
+      range = `>= ${min}${n} and <= ${max}${n}`;
+    }
+    throw new codes.ERR_OUT_OF_RANGE("value", range, value);
+  }
+  checkBounds(buf, offset, byteLength);
+}
+
+export function toInteger(n, defaultVal) {
+  n = +n;
+  if (
+    !Number.isNaN(n) &&
+    n >= Number.MIN_SAFE_INTEGER &&
+    n <= Number.MAX_SAFE_INTEGER
+  ) {
+    return ((n % 1) === 0 ? n : Math.floor(n));
+  }
+  return defaultVal;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int8(buf, value, offset, min, max) {
+  value = +value;
+  validateNumber(offset, "offset");
+  if (value > max || value < min) {
+    throw new codes.ERR_OUT_OF_RANGE("value", `>= ${min} and <= ${max}`, value);
+  }
+  if (buf[offset] === undefined) {
+    boundsError(offset, buf.length - 1);
+  }
+
+  buf[offset] = value;
+  return offset + 1;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int16BE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 1);
+
+  buf[offset++] = value >>> 8;
+  buf[offset++] = value;
+  return offset;
+}
+
+export function _writeUInt32LE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 3);
+
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  return offset;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int16LE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 1);
+
+  buf[offset++] = value;
+  buf[offset++] = value >>> 8;
+  return offset;
+}
+
+export function _writeUInt32BE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 3);
+
+  buf[offset + 3] = value;
+  value = value >>> 8;
+  buf[offset + 2] = value;
+  value = value >>> 8;
+  buf[offset + 1] = value;
+  value = value >>> 8;
+  buf[offset] = value;
+  return offset + 4;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int48BE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 5);
+
+  const newVal = Math.floor(value * 2 ** -32);
+  buf[offset++] = newVal >>> 8;
+  buf[offset++] = newVal;
+  buf[offset + 3] = value;
+  value = value >>> 8;
+  buf[offset + 2] = value;
+  value = value >>> 8;
+  buf[offset + 1] = value;
+  value = value >>> 8;
+  buf[offset] = value;
+  return offset + 4;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int40BE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 4);
+
+  buf[offset++] = Math.floor(value * 2 ** -32);
+  buf[offset + 3] = value;
+  value = value >>> 8;
+  buf[offset + 2] = value;
+  value = value >>> 8;
+  buf[offset + 1] = value;
+  value = value >>> 8;
+  buf[offset] = value;
+  return offset + 4;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int32BE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 3);
+
+  buf[offset + 3] = value;
+  value = value >>> 8;
+  buf[offset + 2] = value;
+  value = value >>> 8;
+  buf[offset + 1] = value;
+  value = value >>> 8;
+  buf[offset] = value;
+  return offset + 4;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int24BE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 2);
+
+  buf[offset + 2] = value;
+  value = value >>> 8;
+  buf[offset + 1] = value;
+  value = value >>> 8;
+  buf[offset] = value;
+  return offset + 3;
+}
+
+export function validateOffset(
+  value,
+  name,
+  min = 0,
+  max = Number.MAX_SAFE_INTEGER,
+) {
+  if (typeof value !== "number") {
+    throw new codes.ERR_INVALID_ARG_TYPE(name, "number", value);
+  }
+  if (!Number.isInteger(value)) {
+    throw new codes.ERR_OUT_OF_RANGE(name, "an integer", value);
+  }
+  if (value < min || value > max) {
+    throw new codes.ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
+  }
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int48LE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 5);
+
+  const newVal = Math.floor(value * 2 ** -32);
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  buf[offset++] = newVal;
+  buf[offset++] = newVal >>> 8;
+  return offset;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int40LE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 4);
+
+  const newVal = value;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  buf[offset++] = Math.floor(newVal * 2 ** -32);
+  return offset;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int32LE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 3);
+
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  return offset;
+}
+
+// deno-lint-ignore camelcase
+export function writeU_Int24LE(buf, value, offset, min, max) {
+  value = +value;
+  checkInt(value, min, max, buf, offset, 2);
+
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  value = value >>> 8;
+  buf[offset++] = value;
+  return offset;
+}
+
+export default {
+  atob,
+  btoa,
+  Blob,
+  Buffer,
+  constants,
+  kMaxLength,
+  kStringMaxLength,
+  SlowBuffer,
+};