compact-encoding 3.3.1 → 3.4.0

package/README.md

@@ -123,6 +123,7 @@ to build others on top. Feel free to PR more that are missing.
 - `cenc.raw.float32array` - Encodes a float32array without a length prefixed.
 - `cenc.float64array` - Encodes a float64array with its element length uint prefixed.
 - `cenc.raw.float64array` - Encodes a float64array without a length prefixed.
+- `cenc.bitarray` - Encodes an array of bits or booleans with its length uint prefixed. Decoding returns array of booleans.
 - `cenc.bool` - Encodes a boolean as 1 or 0.
 - `cenc.string`, `cenc.utf8` - Encodes a utf-8 string, similar to buffer.
 - `cenc.raw.string`, `cenc.raw.utf8` - Encodes a utf-8 string without a length prefixed.

package/endian.d.ts

@@ -0,0 +1,2 @@
+export const LE: boolean
+export const BE: boolean

package/endian.js

@@ -1,4 +1,3 @@
-const LE = (exports.LE =
-  new Uint8Array(new Uint16Array([0xff]).buffer)[0] === 0xff)
+const LE = (exports.LE = new Uint8Array(new Uint16Array([0xff]).buffer)[0] === 0xff)
 
 exports.BE = !LE

package/index.d.ts

@@ -0,0 +1,202 @@
+interface State<T extends Uint8Array = Uint8Array> {
+  start: number
+  end: number
+  buffer: T | null
+}
+
+export function state<T extends Uint8Array = Uint8Array>(
+  start?: number,
+  end?: number,
+  buffer?: T | null
+): State<T>
+
+interface Encoder<Input = unknown, Output = Input> {
+  preencode(state: State, val: Input): void
+  encode(state: State, val: Input): void
+  decode(state: State): Output
+}
+
+interface Raw<T extends Uint8Array = Uint8Array> extends Encoder<T> {
+  buffer: Encoder<T>
+  binary: Encoder<string | T, T>
+  arraybuffer: Encoder<ArrayBuffer>
+
+  uint8array: Encoder<Uint8Array>
+  uint16array: Encoder<Uint16Array>
+  uint32array: Encoder<Uint32Array>
+
+  int8array: Encoder<Int8Array>
+  int16array: Encoder<Int16Array>
+  int32array: Encoder<Int32Array>
+
+  biguint64array: Encoder<BigUint64Array>
+  bigint64array: Encoder<BigInt64Array>
+
+  float32array: Encoder<Float32Array>
+  float64array: Encoder<Float64Array>
+
+  string: Encoder<string>
+  utf8: Encoder<string>
+  ascii: Encoder<string>
+  hex: Encoder<string>
+  base64: Encoder<string>
+  ucs2: Encoder<string>
+  utf16le: Encoder<string>
+
+  array: <I, O = I>(enc: Encoder<I, O>) => Encoder<I[], O[]>
+
+  json: Encoder<unknown>
+  ndjson: Encoder<unknown>
+}
+
+export const raw: Raw
+
+export const uint: Encoder<number>
+export const uint8: Encoder<number>
+export const uint16: Encoder<number>
+export const uint24: Encoder<number>
+export const uint32: Encoder<number>
+export const uint32be: Encoder<number>
+export const uint40: Encoder<number>
+export const uint48: Encoder<number>
+export const uint56: Encoder<number>
+export const uint64: Encoder<number>
+export const uint64be: Encoder<number>
+
+export const int: Encoder<number>
+export const int8: Encoder<number>
+export const int16: Encoder<number>
+export const int24: Encoder<number>
+export const int32: Encoder<number>
+export const int40: Encoder<number>
+export const int48: Encoder<number>
+export const int56: Encoder<number>
+export const int64: Encoder<number>
+
+export const biguint64: Encoder<bigint>
+export const bigint64: Encoder<bigint>
+export const biguint: Encoder<bigint>
+export const bigint: Encoder<bigint>
+
+export const lexint: Encoder<number>
+
+export const float32: Encoder<number>
+export const float64: Encoder<number>
+
+export const buffer: Encoder<Uint8Array>
+export const optionalBuffer: Encoder<Uint8Array | null>
+export const binary: Encoder<string | Uint8Array, Uint8Array>
+export const arraybuffer: Encoder<ArrayBuffer>
+export const bitarray: Encoder<Array<0 | 1 | boolean>, boolean[]>
+
+export const uint8array: Encoder<Uint8Array>
+export const uint16array: Encoder<Uint16Array>
+export const uint32array: Encoder<Uint32Array>
+
+export const int8array: Encoder<Int8Array>
+export const int16array: Encoder<Int16Array>
+export const int32array: Encoder<Int32Array>
+
+export const biguint64array: Encoder<BigUint64Array>
+export const bigint64array: Encoder<BigInt64Array>
+
+export const float32array: Encoder<Float32Array>
+export const float64array: Encoder<Float64Array>
+
+interface StringEncoder<T = unknown> extends Encoder<T> {
+  fixed(n: number): Encoder<T>
+}
+
+export const string: StringEncoder<string>
+export const utf8: StringEncoder<string>
+export const ascii: StringEncoder<string>
+export const hex: StringEncoder<string>
+export const base64: StringEncoder<string>
+export const ucs2: StringEncoder<string>
+export const utf16le: StringEncoder<string>
+
+export const bool: Encoder<boolean>
+
+export function fixed(n: number): Encoder<Uint8Array>
+export const fixed32: Encoder<Uint8Array>
+export const fixed64: Encoder<Uint8Array>
+
+export function array<I, O>(enc: Encoder<I, O>): Encoder<I[], O[]>
+
+export function frame<I, O>(enc: Encoder<I, O>): Encoder<I, O>
+
+export const date: Encoder<Date>
+
+export const json: Encoder<unknown>
+export const ndjson: Encoder<unknown>
+export const none: Encoder<unknown, null>
+export const any: Encoder<unknown>
+
+interface AddressInput {
+  host: string
+  port: number
+}
+
+interface Address<F extends 4 | 6 = 4 | 6> extends AddressInput {
+  family: F
+}
+
+export const port: Encoder<number>
+export const ipv4: Encoder<string>
+export const ipv4Address: Encoder<AddressInput, Address<4>>
+export const ipv6: Encoder<string>
+export const ipv6Address: Encoder<AddressInput, Address<6>>
+export const ip: Encoder<string>
+export const ipAddress: Encoder<AddressInput, Address>
+
+export function record<I, O = I>(
+  keyEncoding: Encoder<string>,
+  valueEncoder: Encoder<I, O>
+): Encoder<Record<string, I>, Record<string, O>>
+
+export const stringRecord: Encoder<Record<string, string>>
+
+interface CodecLike<Input, Output = Input> {
+  encode(value: Input): Uint8Array
+  decode(buffer: Uint8Array): Output
+}
+
+interface AbstractEncode<Input> {
+  (value: Input, buffer: Uint8Array, offset: number): unknown
+  bytes: number
+}
+
+interface AbstractDecode<Output> {
+  (buffer: Uint8Array, start: number, end: number): Output
+  bytes: number
+}
+
+interface AbstractEncodingLike<Input, Output = Input> {
+  encodingLength(value: Input): number
+  encode: AbstractEncode<Input>
+  decode: AbstractDecode<Output>
+}
+
+export function from(name: 'ascii'): Raw['ascii']
+export function from(name: 'utf-8' | 'utf8'): Raw['utf8']
+export function from(name: 'hex'): Raw['hex']
+export function from(name: 'base64'): Raw['base64']
+export function from(name: 'utf16-le' | 'utf16le' | 'ucs-2' | 'ucs2'): Raw['ucs2']
+export function from(name: 'ndjson'): Raw['ndjson']
+export function from(name: 'json'): Raw['json']
+export function from(name: 'binary' | string): Raw['binary']
+export function from<I, O>(enc: Encoder<I, O>): Encoder<I, O>
+export function from<I, O>(enc: CodecLike<I, O>): Encoder<I, O>
+export function from<I, O>(enc: AbstractEncodingLike<I, O>): Encoder<I, O>
+
+export function encode<Input = unknown, Output = Input>(
+  enc: Encoder<Input, Output>,
+  m: Input
+): Uint8Array
+
+export function decode<Input = unknown, Output = Input>(
+  enc: Encoder<Input, Output>,
+  buffer: Uint8Array
+): Output
+
+export type { State, Encoder, Raw, StringEncoder, AddressInput, Address }

package/index.js

@@ -176,9 +176,7 @@ const uint56 = (exports.uint56 = {
   },
   decode(state) {
     if (state.end - state.start < 7) throw new Error('Out of bounds')
-    return validateSafeUint(
-      uint24.decode(state) + 0x1000000 * uint32.decode(state)
-    )
+    return validateSafeUint(uint24.decode(state) + 0x1000000 * uint32.decode(state))
   }
 })
 
@@ -194,9 +192,7 @@ const uint64 = (exports.uint64 = {
   },
   decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
-    return validateSafeUint(
-      uint32.decode(state) + 0x100000000 * uint32.decode(state)
-    )
+    return validateSafeUint(uint32.decode(state) + 0x100000000 * uint32.decode(state))
   }
 })
 
@@ -212,9 +208,7 @@ exports.uint64be = {
   },
   decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
-    return validateSafeUint(
-      0x100000000 * uint32be.decode(state) + uint32be.decode(state)
-    )
+    return validateSafeUint(0x100000000 * uint32be.decode(state) + uint32be.decode(state))
   }
 }
 
@@ -233,21 +227,13 @@ const biguint64 = (exports.biguint64 = {
     state.end += 8
   },
   encode(state, n) {
-    const view = new DataView(
-      state.buffer.buffer,
-      state.start + state.buffer.byteOffset,
-      8
-    )
+    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8)
     view.setBigUint64(0, n, true) // little endian
     state.start += 8
   },
   decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
-    const view = new DataView(
-      state.buffer.buffer,
-      state.start + state.buffer.byteOffset,
-      8
-    )
+    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8)
     const n = view.getBigUint64(0, true) // little endian
     state.start += 8
     return n
@@ -267,11 +253,7 @@ const biguint = (exports.biguint = {
     let len = 0
     for (let m = n; m; m = m >> 64n) len++
     uint.encode(state, len)
-    const view = new DataView(
-      state.buffer.buffer,
-      state.start + state.buffer.byteOffset,
-      8 * len
-    )
+    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len)
     for (let m = n, i = 0; m; m = m >> 64n, i += 8) {
       view.setBigUint64(i, BigInt.asUintN(64, m), true) // little endian
     }
@@ -280,14 +262,9 @@ const biguint = (exports.biguint = {
   decode(state) {
     const len = uint.decode(state)
     if (state.end - state.start < 8 * len) throw new Error('Out of bounds')
-    const view = new DataView(
-      state.buffer.buffer,
-      state.start + state.buffer.byteOffset,
-      8 * len
-    )
+    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len)
     let n = 0n
-    for (let i = len - 1; i >= 0; i--)
-      n = (n << 64n) + view.getBigUint64(i * 8, true) // little endian
+    for (let i = len - 1; i >= 0; i--) n = (n << 64n) + view.getBigUint64(i * 8, true) // little endian
     state.start += 8 * len
     return n
   }
@@ -302,21 +279,13 @@ exports.float32 = {
     state.end += 4
   },
   encode(state, n) {
-    const view = new DataView(
-      state.buffer.buffer,
-      state.start + state.buffer.byteOffset,
-      4
-    )
+    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 4)
     view.setFloat32(0, n, true) // little endian
     state.start += 4
   },
   decode(state) {
     if (state.end - state.start < 4) throw new Error('Out of bounds')
-    const view = new DataView(
-      state.buffer.buffer,
-      state.start + state.buffer.byteOffset,
-      4
-    )
+    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 4)
     const float = view.getFloat32(0, true) // little endian
     state.start += 4
     return float
@@ -328,21 +297,13 @@ exports.float64 = {
     state.end += 8
   },
   encode(state, n) {
-    const view = new DataView(
-      state.buffer.buffer,
-      state.start + state.buffer.byteOffset,
-      8
-    )
+    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8)
     view.setFloat64(0, n, true) // little endian
     state.start += 8
   },
   decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
-    const view = new DataView(
-      state.buffer.buffer,
-      state.start + state.buffer.byteOffset,
-      8
-    )
+    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8)
     const float = view.getFloat64(0, true) // little endian
     state.start += 8
     return float
@@ -417,6 +378,35 @@ exports.arraybuffer = {
   }
 }
 
+exports.bitarray = {
+  preencode(state, m) {
+    uint.preencode(state, m.length)
+    state.end += Math.ceil(m.length / 8)
+  },
+  encode(state, m) {
+    uint.encode(state, m.length)
+    for (let i = 0; i < m.length; i += 8) {
+      let byte = 0
+      for (let j = 0; j < 8 && i + j < m.length; j++) {
+        if (m[i + j]) byte |= 1 << j
+      }
+      state.buffer[state.start++] = byte
+    }
+  },
+  decode(state) {
+    const n = uint.decode(state)
+    if (state.end - state.start < Math.ceil(n / 8)) throw new Error('Out of bounds')
+    const m = new Array(n)
+    for (let i = 0; i < n; i += 8) {
+      const byte = state.buffer[state.start++]
+      for (let j = 0; j < 8 && i + j < n; j++) {
+        m[i + j] = (byte & (1 << j)) !== 0
+      }
+    }
+    return m
+  }
+}
+
 function typedarray(TypedArray, swap) {
   const n = TypedArray.BYTES_PER_ELEMENT
 
@@ -479,12 +469,7 @@ function string(encoding) {
     decode(state) {
       const len = uint.decode(state)
       if (state.end - state.start < len) throw new Error('Out of bounds')
-      return b4a.toString(
-        state.buffer,
-        encoding,
-        state.start,
-        (state.start += len)
-      )
+      return b4a.toString(state.buffer, encoding, state.start, (state.start += len))
     },
     fixed(n) {
       return {
@@ -497,12 +482,7 @@ function string(encoding) {
         },
         decode(state) {
           if (state.end - state.start < n) throw new Error('Out of bounds')
-          return b4a.toString(
-            state.buffer,
-            encoding,
-            state.start,
-            (state.start += n)
-          )
+          return b4a.toString(state.buffer, encoding, state.start, (state.start += n))
         }
       }
     }
@@ -764,10 +744,7 @@ const ipv4 = (exports.ipv4 = {
       let n = 0
       let c
 
-      while (
-        i < string.length &&
-        (c = string.charCodeAt(i++)) !== /* . */ 0x2e
-      ) {
+      while (i < string.length && (c = string.charCodeAt(i++)) !== /* . */ 0x2e) {
         n = n * 10 + (c - /* 0 */ 0x30)
       }
 
@@ -807,10 +784,7 @@ const ipv6 = (exports.ipv6 = {
       let n = 0
       let c
 
-      while (
-        i < string.length &&
-        (c = string.charCodeAt(i++)) !== /* : */ 0x3a
-      ) {
+      while (i < string.length && (c = string.charCodeAt(i++)) !== /* : */ 0x3a) {
         if (c >= 0x30 && c <= 0x39) n = n * 0x10 + (c - /* 0 */ 0x30)
         else if (c >= 0x41 && c <= 0x46) n = n * 0x10 + (c - /* A */ 0x41 + 10)
         else if (c >= 0x61 && c <= 0x66) n = n * 0x10 + (c - /* a */ 0x61 + 10)
@@ -827,9 +801,7 @@ const ipv6 = (exports.ipv6 = {
 
     if (split !== null) {
       const offset = end - state.start
-      state.buffer
-        .copyWithin(split + offset, split)
-        .fill(0, split, split + offset)
+      state.buffer.copyWithin(split + offset, split).fill(0, split, split + offset)
     }
 
     state.start = end
@@ -837,45 +809,21 @@ const ipv6 = (exports.ipv6 = {
   decode(state) {
     if (state.end - state.start < 16) throw new Error('Out of bounds')
     return (
-      (
-        state.buffer[state.start++] * 256 +
-        state.buffer[state.start++]
-      ).toString(16) +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) +
       ':' +
-      (
-        state.buffer[state.start++] * 256 +
-        state.buffer[state.start++]
-      ).toString(16) +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) +
       ':' +
-      (
-        state.buffer[state.start++] * 256 +
-        state.buffer[state.start++]
-      ).toString(16) +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) +
       ':' +
-      (
-        state.buffer[state.start++] * 256 +
-        state.buffer[state.start++]
-      ).toString(16) +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) +
       ':' +
-      (
-        state.buffer[state.start++] * 256 +
-        state.buffer[state.start++]
-      ).toString(16) +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) +
       ':' +
-      (
-        state.buffer[state.start++] * 256 +
-        state.buffer[state.start++]
-      ).toString(16) +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) +
       ':' +
-      (
-        state.buffer[state.start++] * 256 +
-        state.buffer[state.start++]
-      ).toString(16) +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) +
       ':' +
-      (
-        state.buffer[state.start++] * 256 +
-        state.buffer[state.start++]
-      ).toString(16)
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16)
     )
   }
 })
@@ -1120,13 +1068,9 @@ function validateInt(n) {
 // Kept out here, the message costs nothing until it is actually thrown.
 
 function outsideUintRange() {
-  return new Error(
-    `uint must be between 0 and ${Number.MAX_SAFE_INTEGER}, use biguint`
-  )
+  return new Error(`uint must be between 0 and ${Number.MAX_SAFE_INTEGER}, use biguint`)
 }
 
 function outsideIntRange() {
-  return new Error(
-    `int must be between ${MIN_SAFE_INT} and ${MAX_SAFE_INT}, use bigint`
-  )
+  return new Error(`int must be between ${MIN_SAFE_INT} and ${MAX_SAFE_INT}, use bigint`)
 }

package/lexint.d.ts

@@ -0,0 +1,3 @@
+import { lexint } from './index'
+
+export = lexint

package/lexint.js

@@ -79,9 +79,7 @@ function decode(state) {
   }
 
   if (flag < 253) {
-    return (
-      (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max
-    )
+    return (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max
   }
 
   if (flag < 254) {

package/package.json

@@ -1,25 +1,30 @@
 {
   "name": "compact-encoding",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "description": "A series of compact encoding schemes for building small and fast parsers and serializers",
   "main": "index.js",
+  "types": "index.d.ts",
   "files": [
     "endian.js",
+    "endian.d.ts",
     "index.js",
+    "index.d.ts",
     "lexint.js",
-    "raw.js"
+    "lexint.d.ts",
+    "raw.js",
+    "raw.d.ts"
   ],
   "dependencies": {
     "b4a": "^1.3.0"
   },
   "devDependencies": {
-    "brittle": "^3.0.0",
+    "brittle": "^4.0.0",
     "prettier": "^3.6.2",
-    "prettier-config-holepunch": "^1.0.0"
+    "prettier-config-holepunch": "^2.0.0"
   },
   "scripts": {
     "format": "prettier . --write",
-    "test": "prettier . --check && brittle test.js"
+    "test": "prettier . --check && brittle-node test.js"
   },
   "repository": {
     "type": "git",

package/raw.d.ts

@@ -0,0 +1,4 @@
+import type { Raw } from './index'
+
+declare const raw: Raw
+export = raw