bare-buffer 3.3.0 → 3.4.0

package/binding.c

@@ -7,22 +7,26 @@
 #include <string.h>
 #include <utf.h>
 
+static void
+bare_buffer__on_finalize_string(js_env_t *env, void *data, void *finalize_hint) {
+  free(data);
+}
+
 static inline int
-bare_buffer__memcmp(void *a, size_t a_len, void *b, size_t b_len) {
-  int r = memcmp(a, b, a_len < b_len ? a_len : b_len);
+bare_buffer__get_info(js_env_t *env, js_value_t *buffer, void **data, size_t *len) {
+  int err;
 
-  if (r == 0) {
-    if (a_len < b_len) return -1;
-    if (a_len > b_len) return 1;
-    return 0;
+  bool is_shared;
+  err = js_is_sharedarraybuffer(env, buffer, &is_shared);
+  if (err < 0) return err;
+
+  if (is_shared) {
+    err = js_get_sharedarraybuffer_info(env, buffer, data, len);
+  } else {
+    err = js_get_arraybuffer_info(env, buffer, data, len);
   }
 
-  return r < 0 ? -1 : 1;
-}
-
-static void
-bare_buffer__on_finalize_string(js_env_t *env, void *data, void *finalize_hint) {
-  free(data);
+  return err;
 }
 
 static js_value_t *
@@ -122,7 +126,7 @@ bare_buffer_to_string_utf8(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 3);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -156,7 +160,7 @@ bare_buffer_typed_write_utf8(
   assert(err == 0);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
   size_t str_len;
@@ -179,7 +183,7 @@ bare_buffer_write_utf8(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 4);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -214,7 +218,7 @@ bare_buffer_to_string_utf16le(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 3);
 
   utf16_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -251,7 +255,7 @@ bare_buffer_typed_write_utf16le(
   assert(err == 0);
 
   utf16_t *buf;
-  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
   offset /= sizeof(utf16_t);
@@ -279,7 +283,7 @@ bare_buffer_write_utf16le(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 4);
 
   utf16_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -319,7 +323,7 @@ bare_buffer_to_string_latin1(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 3);
 
   latin1_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -353,7 +357,7 @@ bare_buffer_typed_write_latin1(
   assert(err == 0);
 
   latin1_t *buf;
-  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
   size_t str_len;
@@ -376,7 +380,7 @@ bare_buffer_write_latin1(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 4);
 
   latin1_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -411,7 +415,7 @@ bare_buffer_to_string_base64(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 3);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -450,7 +454,7 @@ bare_buffer_to_string_base64url(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 3);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -492,7 +496,7 @@ bare_buffer_typed_write_base64(
   assert(err == 0);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
   js_string_encoding_t encoding;
@@ -540,7 +544,7 @@ bare_buffer_write_base64(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 4);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -600,7 +604,7 @@ bare_buffer_to_string_hex(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 3);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -642,7 +646,7 @@ bare_buffer_typed_write_hex(
   assert(err == 0);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
   js_string_encoding_t encoding;
@@ -690,7 +694,7 @@ bare_buffer_write_hex(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 4);
 
   utf8_t *buf;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &buf, NULL);
   assert(err == 0);
 
   int64_t offset;
@@ -737,6 +741,19 @@ bare_buffer_write_hex(js_env_t *env, js_callback_info_t *info) {
   return result;
 }
 
+static inline int
+bare_buffer__memcmp(void *a, size_t a_len, void *b, size_t b_len) {
+  int r = memcmp(a, b, a_len < b_len ? a_len : b_len);
+
+  if (r == 0) {
+    if (a_len < b_len) return -1;
+    if (a_len > b_len) return 1;
+    return 0;
+  }
+
+  return r < 0 ? -1 : 1;
+}
+
 static int32_t
 bare_buffer_typed_compare(
   js_value_t *receiver,
@@ -755,11 +772,11 @@ bare_buffer_typed_compare(
   assert(err == 0);
 
   uint8_t *a;
-  err = js_get_arraybuffer_info(env, a_handle, (void **) &a, NULL);
+  err = bare_buffer__get_info(env, a_handle, (void **) &a, NULL);
   assert(err == 0);
 
   uint8_t *b;
-  err = js_get_arraybuffer_info(env, b_handle, (void **) &b, NULL);
+  err = bare_buffer__get_info(env, b_handle, (void **) &b, NULL);
   assert(err == 0);
 
   return bare_buffer__memcmp(&a[a_offset], a_len, &b[b_offset], b_len);
@@ -778,7 +795,7 @@ bare_buffer_compare(js_env_t *env, js_callback_info_t *info) {
   assert(argc == 6);
 
   uint8_t *a;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &a, NULL);
+  err = bare_buffer__get_info(env, argv[0], (void **) &a, NULL);
   assert(err == 0);
 
   int64_t a_offset;
@@ -790,7 +807,7 @@ bare_buffer_compare(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   uint8_t *b;
-  err = js_get_arraybuffer_info(env, argv[3], (void **) &b, NULL);
+  err = bare_buffer__get_info(env, argv[3], (void **) &b, NULL);
   assert(err == 0);
 
   int64_t b_offset;

package/global.d.ts

@@ -6,4 +6,7 @@ declare global {
   type Buffer = buffer.Buffer
 
   const Buffer: BufferConstructor
+
+  const atob: typeof buffer.atob
+  const atob: typeof buffer.btoa
 }

package/global.js

@@ -1 +1,6 @@
-global.Buffer = require('.')
+const Buffer = require('.')
+
+global.Buffer = Buffer
+
+global.atob = Buffer.atob
+global.btoa = Buffer.btoa

package/index.d.ts

@@ -73,6 +73,9 @@ interface Buffer extends Uint8Array {
   readInt32BE(offset?: number): number
   readInt32LE(offset?: number): number
 
+  readIntBE(offset: number, byteLength: number): number
+  readIntLE(offset: number, byteLength: number): number
+
   readBigInt64BE(offset?: number): bigint
   readBigInt64LE(offset?: number): bigint
 
@@ -89,6 +92,11 @@ interface Buffer extends Uint8Array {
   readUInt32LE(offset?: number): number
   readUint32LE(offset?: number): number
 
+  readUIntBE(offset: number, byteLength: number): number
+  readUintBE(offset: number, byteLength: number): number
+  readUIntLE(offset: number, byteLength: number): number
+  readUintLE(offset: number, byteLength: number): number
+
   readBigUInt64BE(offset?: number): bigint
   readBigUint64BE(offset?: number): bigint
   readBigUInt64LE(offset?: number): bigint
@@ -117,6 +125,9 @@ interface Buffer extends Uint8Array {
   writeInt32BE(value: number, offset?: number): number
   writeInt32LE(value: number, offset?: number): number
 
+  writeIntBE(value: number, offset: number, byteLength: number): number
+  writeIntLE(value: number, offset: number, byteLength: number): number
+
   writeBigInt64BE(value: bigint, offset?: number): number
   writeBigInt64LE(value: bigint, offset?: number): number
 
@@ -133,6 +144,11 @@ interface Buffer extends Uint8Array {
   writeUInt32LE(value: number, offset?: number): number
   writeUint32LE(value: number, offset?: number): number
 
+  writeUIntBE(value: number, offset: number, byteLength: number): number
+  writeUintBE(value: number, offset: number, byteLength: number): number
+  writeUIntLE(value: number, offset: number, byteLength: number): number
+  writeUintLE(value: number, offset: number, byteLength: number): number
+
   writeBigUint64BE(value: bigint, offset?: number): number
   writeBigUInt64BE(value: bigint, offset?: number): number
   writeBigUint64LE(value: bigint, offset?: number): number
@@ -181,6 +197,9 @@ declare namespace Buffer {
     length?: number
   ): Buffer
 
+  export function atob(data: unknown): string
+  export function btoa(data: unknown): string
+
   export { Buffer, type BufferEncoding, constants }
 }
 

package/index.js

@@ -104,7 +104,6 @@ module.exports = exports = class Buffer extends Uint8Array {
     const source = this
 
     if (source === target) return true
-
     if (source.byteLength !== target.byteLength) return false
 
     return (
@@ -164,14 +163,13 @@ module.exports = exports = class Buffer extends Uint8Array {
 
   fill(value, offset = 0, end = this.byteLength, encoding = 'utf8') {
     if (typeof value === 'string') {
-      // fill(string, encoding)
       if (typeof offset === 'string') {
+        // fill(string, encoding)
         encoding = offset
         offset = 0
         end = this.byteLength
-
-        // fill(string, offset, encoding)
       } else if (typeof end === 'string') {
+        // fill(string, offset, encoding)
         encoding = end
         end = this.byteLength
       }
@@ -299,14 +297,13 @@ module.exports = exports = class Buffer extends Uint8Array {
     // write(string)
     if (arguments.length === 1) return utf8.write(this, string)
 
-    // write(string, encoding)
     if (typeof offset === 'string') {
+      // write(string, encoding)
       encoding = offset
       offset = 0
       length = this.byteLength
-
-      // write(string, offset, encoding)
     } else if (typeof length === 'string') {
+      // write(string, offset, encoding)
       encoding = length
       length = this.byteLength - offset
     }
@@ -376,6 +373,26 @@ module.exports = exports = class Buffer extends Uint8Array {
     return viewOf(this).getInt32(offset, true)
   }
 
+  readIntBE(offset, byteLength) {
+    if (byteLength === 6) return readInt48BE(viewOf(this), offset)
+    if (byteLength === 5) return readInt40BE(viewOf(this), offset)
+    if (byteLength === 3) return readInt24BE(viewOf(this), offset)
+    if (byteLength === 4) return this.readInt32BE(offset)
+    if (byteLength === 2) return this.readInt16BE(offset)
+    if (byteLength === 1) return this.readInt8(offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  readIntLE(offset, byteLength) {
+    if (byteLength === 6) return readInt48LE(viewOf(this), offset)
+    if (byteLength === 5) return readInt40LE(viewOf(this), offset)
+    if (byteLength === 3) return readInt24LE(viewOf(this), offset)
+    if (byteLength === 4) return this.readInt32LE(offset)
+    if (byteLength === 2) return this.readInt16LE(offset)
+    if (byteLength === 1) return this.readInt8(offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
   readUint8(offset = 0) {
     return viewOf(this).getUint8(offset)
   }
@@ -394,6 +411,26 @@ module.exports = exports = class Buffer extends Uint8Array {
     return viewOf(this).getUint32(offset, true)
   }
 
+  readUintBE(offset, byteLength) {
+    if (byteLength === 6) return readUint48BE(viewOf(this), offset)
+    if (byteLength === 5) return readUint40BE(viewOf(this), offset)
+    if (byteLength === 3) return readUint24BE(viewOf(this), offset)
+    if (byteLength === 4) return this.readUint32BE(offset)
+    if (byteLength === 2) return this.readUint16BE(offset)
+    if (byteLength === 1) return this.readUint8(offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  readUintLE(offset, byteLength) {
+    if (byteLength === 6) return readUint48LE(viewOf(this), offset)
+    if (byteLength === 5) return readUint40LE(viewOf(this), offset)
+    if (byteLength === 3) return readUint24LE(viewOf(this), offset)
+    if (byteLength === 4) return this.readUint32LE(offset)
+    if (byteLength === 2) return this.readUint16LE(offset)
+    if (byteLength === 1) return this.readUint8(offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
   readBigUInt64BE(...args) {
     return this.readBigUint64BE(...args)
   }
@@ -419,6 +456,13 @@ module.exports = exports = class Buffer extends Uint8Array {
     return this.readUint32LE(...args)
   }
 
+  readUIntBE(...args) {
+    return this.readUintBE(...args)
+  }
+  readUIntLE(...args) {
+    return this.readUintLE(...args)
+  }
+
   writeBigInt64BE(value, offset = 0) {
     viewOf(this).setBigInt64(offset, value, false)
     return offset + 8
@@ -478,6 +522,26 @@ module.exports = exports = class Buffer extends Uint8Array {
     return offset + 4
   }
 
+  writeIntBE(value, offset, byteLength) {
+    if (byteLength === 6) return writeInt48BE(value, viewOf(this), offset)
+    if (byteLength === 5) return writeInt40BE(value, viewOf(this), offset)
+    if (byteLength === 3) return writeInt24BE(value, viewOf(this), offset)
+    if (byteLength === 4) return this.writeInt32BE(value, offset)
+    if (byteLength === 2) return this.writeInt16BE(value, offset)
+    if (byteLength === 1) return this.writeInt8(value, offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  writeIntLE(value, offset, byteLength) {
+    if (byteLength === 6) return writeInt48LE(value, viewOf(this), offset)
+    if (byteLength === 5) return writeInt40LE(value, viewOf(this), offset)
+    if (byteLength === 3) return writeInt24LE(value, viewOf(this), offset)
+    if (byteLength === 4) return this.writeInt32LE(value, offset)
+    if (byteLength === 2) return this.writeInt16LE(value, offset)
+    if (byteLength === 1) return this.writeInt8(value, offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
   writeUint8(value, offset = 0) {
     viewOf(this).setUint8(offset, value, true)
     return offset + 1
@@ -501,6 +565,26 @@ module.exports = exports = class Buffer extends Uint8Array {
     return offset + 4
   }
 
+  writeUintBE(value, offset, byteLength) {
+    if (byteLength === 6) return writeUint48BE(value, viewOf(this), offset)
+    if (byteLength === 5) return writeUint40BE(value, viewOf(this), offset)
+    if (byteLength === 3) return writeUint24BE(value, viewOf(this), offset)
+    if (byteLength === 4) return this.writeUint32BE(value, offset)
+    if (byteLength === 2) return this.writeUint16BE(value, offset)
+    if (byteLength === 1) return this.writeUint8(value, offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  writeUintLE(value, offset, byteLength) {
+    if (byteLength === 6) return writeUint48LE(value, viewOf(this), offset)
+    if (byteLength === 5) return writeUint40LE(value, viewOf(this), offset)
+    if (byteLength === 3) return writeUint24LE(value, viewOf(this), offset)
+    if (byteLength === 4) return this.writeUint32LE(value, offset)
+    if (byteLength === 2) return this.writeUint16LE(value, offset)
+    if (byteLength === 1) return this.writeUint8(value, offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
   writeBigUInt64BE(...args) {
     return this.writeBigUint64BE(...args)
   }
@@ -525,6 +609,13 @@ module.exports = exports = class Buffer extends Uint8Array {
   writeUInt32LE(...args) {
     return this.writeUint32LE(...args)
   }
+
+  writeUIntBE(...args) {
+    return this.writeUintBE(...args)
+  }
+  writeUIntLE(...args) {
+    return this.writeUintLE(...args)
+  }
 }
 
 const Buffer = exports
@@ -630,7 +721,6 @@ exports.concat = function concat(buffers, length) {
     }
 
     result.set(buffer, offset)
-
     offset += buffer.byteLength
   }
 
@@ -742,3 +832,199 @@ function swap(buffer, n, m) {
   buffer[n] = buffer[m]
   buffer[m] = i
 }
+
+exports.atob = function atob(data) {
+  return Buffer.from(data, 'base64').toString('latin1')
+}
+
+exports.btoa = function btoa(data) {
+  if (typeof data !== 'string') data = String(data)
+
+  return Buffer.from(data, 'latin1').toString('base64')
+}
+
+function readInt48BE(view, offset) {
+  const hi = view.getUint16(offset, false)
+  const lo = view.getUint32(offset + 2, false)
+  let value = lo + hi * 0x100000000
+  if (hi & 0x8000) value -= 0x1000000000000
+  return value
+}
+
+function readInt48LE(view, offset) {
+  const lo = view.getUint32(offset, true)
+  const hi = view.getUint16(offset + 4, true)
+  let value = lo + hi * 0x100000000
+  if (hi & 0x8000) value -= 0x1000000000000
+  return value
+}
+
+function readInt40BE(view, offset) {
+  const hi = view.getUint8(offset)
+  const lo = view.getUint32(offset + 1, false)
+  let value = lo + hi * 0x100000000
+  if (hi & 0x80) value -= 0x10000000000
+  return value
+}
+
+function readInt40LE(view, offset) {
+  const lo = view.getUint32(offset, true)
+  const hi = view.getUint8(offset + 4)
+  let value = lo + hi * 0x100000000
+  if (hi & 0x80) value -= 0x10000000000
+  return value
+}
+
+function readInt24BE(view, offset) {
+  const value =
+    (view.getUint8(offset) << 16) |
+    (view.getUint8(offset + 1) << 8) |
+    view.getUint8(offset + 2)
+  return value & 0x800000 ? value - 0x1000000 : value
+}
+
+function readInt24LE(view, offset) {
+  const value =
+    view.getUint8(offset) |
+    (view.getUint8(offset + 1) << 8) |
+    (view.getUint8(offset + 2) << 16)
+  return value & 0x800000 ? value - 0x1000000 : value
+}
+
+function readUint48BE(view, offset) {
+  const hi = view.getUint16(offset, false)
+  const lo = view.getUint32(offset + 2, false)
+  return lo + hi * 0x100000000
+}
+
+function readUint48LE(view, offset) {
+  const lo = view.getUint32(offset, true)
+  const hi = view.getUint16(offset + 4, true)
+  return lo + hi * 0x100000000
+}
+
+function readUint40BE(view, offset) {
+  const hi = view.getUint8(offset)
+  const lo = view.getUint32(offset + 1, false)
+  return lo + hi * 0x100000000
+}
+
+function readUint40LE(view, offset) {
+  const lo = view.getUint32(offset, true)
+  const hi = view.getUint8(offset + 4)
+  return lo + hi * 0x100000000
+}
+
+function readUint24BE(view, offset) {
+  return (
+    (view.getUint8(offset) << 16) |
+    (view.getUint8(offset + 1) << 8) |
+    view.getUint8(offset + 2)
+  )
+}
+
+function readUint24LE(view, offset) {
+  return (
+    view.getUint8(offset) |
+    (view.getUint8(offset + 1) << 8) |
+    (view.getUint8(offset + 2) << 16)
+  )
+}
+
+function writeInt48BE(value, view, offset) {
+  if (value < 0) value += 0x1000000000000
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  view.setUint16(offset, hi, false)
+  view.setUint32(offset + 2, lo, false)
+  return offset + 6
+}
+
+function writeInt48LE(value, view, offset) {
+  if (value < 0) value += 0x1000000000000
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  view.setUint32(offset, lo, true)
+  view.setUint16(offset + 4, hi, true)
+  return offset + 6
+}
+
+function writeInt40BE(value, view, offset) {
+  if (value < 0) value += 0x10000000000
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  view.setUint8(offset, hi)
+  view.setUint32(offset + 1, lo, false)
+  return offset + 5
+}
+
+function writeInt40LE(value, view, offset) {
+  if (value < 0) value += 0x10000000000
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  view.setUint32(offset, lo, true)
+  view.setUint8(offset + 4, hi)
+  return offset + 5
+}
+
+function writeInt24BE(value, view, offset) {
+  if (value < 0) value += 0x1000000
+  view.setUint8(offset, (value >> 16) & 0xff)
+  view.setUint8(offset + 1, (value >> 8) & 0xff)
+  view.setUint8(offset + 2, value & 0xff)
+  return offset + 3
+}
+
+function writeInt24LE(value, view, offset) {
+  if (value < 0) value += 0x1000000
+  view.setUint8(offset, value & 0xff)
+  view.setUint8(offset + 1, (value >> 8) & 0xff)
+  view.setUint8(offset + 2, (value >> 16) & 0xff)
+  return offset + 3
+}
+
+function writeUint48BE(value, view, offset) {
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  view.setUint16(offset, hi, false)
+  view.setUint32(offset + 2, lo, false)
+  return offset + 6
+}
+
+function writeUint48LE(value, view, offset) {
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  view.setUint32(offset, lo, true)
+  view.setUint16(offset + 4, hi, true)
+  return offset + 6
+}
+
+function writeUint40BE(value, view, offset) {
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  view.setUint8(offset, hi)
+  view.setUint32(offset + 1, lo, false)
+  return offset + 5
+}
+
+function writeUint40LE(value, view, offset) {
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  view.setUint32(offset, lo, true)
+  view.setUint8(offset + 4, hi)
+  return offset + 5
+}
+
+function writeUint24BE(value, view, offset) {
+  view.setUint8(offset, (value >> 16) & 0xff)
+  view.setUint8(offset + 1, (value >> 8) & 0xff)
+  view.setUint8(offset + 2, value & 0xff)
+  return offset + 3
+}
+
+function writeUint24LE(value, view, offset) {
+  view.setUint8(offset, value & 0xff)
+  view.setUint8(offset + 1, (value >> 8) & 0xff)
+  view.setUint8(offset + 2, (value >> 16) & 0xff)
+  return offset + 3
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-buffer",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "Native buffers for JavaScript",
   "exports": {
     "./package": "./package.json",