compact-encoding 2.10.0 → 2.12.0

package/.github/workflows/test-node.yml

@@ -2,10 +2,10 @@ name: Build Status
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
     branches:
-      - master
+      - main
 jobs:
   build:
     strategy:

package/LICENSE

@@ -1,21 +1,201 @@
-The MIT License (MIT)
-
-Copyright (c) 2021 Mathias Buus
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,13 @@
+Copyright 2023 Holepunch Inc
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -75,6 +75,7 @@ const bool = cenc.decode(cenc.bool, buf)
 The following encodings are bundled as they are primitives that can be used
 to build others on top. Feel free to PR more that are missing.
 
+* `cenc.raw` - Pass through encodes a buffer, i.e. a basic copy.
 * `cenc.uint` - Encodes a uint using [compact-uint](https://github.com/mafintosh/compact-uint).
 * `cenc.uint8` - Encodes a fixed size uint8.
 * `cenc.uint16` - Encodes a fixed size uint16. Useful for things like ports.
@@ -97,34 +98,51 @@ to build others on top. Feel free to PR more that are missing.
 * `cenc.float32` - Encodes a fixed size float32.
 * `cenc.float64` - Encodes a fixed size float64.
 * `cenc.buffer` - Encodes a buffer with its length uint prefixed. When decoding an empty buffer, `null` is returned.
-* `cenc.raw` - Pass through encodes a buffer, i.e. a basic copy.
+* `cenc.raw.buffer` - Encodes a buffer without a length prefixed.
 * `cenc.uint8array` - Encodes a uint8array with its element length uint prefixed.
+* `cenc.raw.uint8array` - Encodes a uint8array without a length prefixed.
 * `cenc.uint16array` - Encodes a uint16array with its element length uint prefixed.
+* `cenc.raw.uint16array` - Encodes a uint16array without a length prefixed.
 * `cenc.uint32array` - Encodes a uint32array with its element length uint prefixed.
+* `cenc.raw.uint32array` - Encodes a uint32array without a length prefixed.
 * `cenc.int8array` - Encodes a int8array with its element length uint prefixed.
+* `cenc.raw.int8array` - Encodes a int8array without a length prefixed.
 * `cenc.int16array` - Encodes a int16array with its element length uint prefixed.
+* `cenc.raw.int16array` - Encodes a int16array without a length prefixed.
 * `cenc.int32array` - Encodes a int32array with its element length uint prefixed.
+* `cenc.raw.int32array` - Encodes a int32array without a length prefixed.
 * `cenc.float32array` - Encodes a float32array with its element length uint prefixed.
+* `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.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.
 * `cenc.string.fixed(n)`, `cenc.utf8.fixed(n)` - Encodes a fixed sized utf-8 string.
 * `cenc.ascii` - Encodes an ascii string.
+* `cenc.raw.ascii` - Encodes an ascii string without a length prefixed.
 * `cenc.ascii.fixed(n)` - Encodes a fixed size ascii string.
 * `cenc.hex` - Encodes a hex string.
+* `cenc.raw.hex` - Encodes a hex string without a length prefixed.
 * `cenc.hex.fixed(n)` - Encodes a fixed size hex string.
 * `cenc.base64` - Encodes a base64 string.
+* `cenc.raw.base64` - Encodes a base64 string without a length prefixed.
 * `cenc.base64.fixed(n)` - Encodes a fixed size base64 string.
 * `cenc.utf16le`, `cenc.ucs2` - Encodes a utf16le string.
+* `cenc.raw.utf16le`, `cenc.raw.ucs2` - Encodes a utf16le string without a length prefixed.
 * `cenc.utf16le.fixed(n)`, `cenc.ucs2.fixed(n)` - Encodes a fixed size utf16le string.
 * `cenc.fixed32` - Encodes a fixed 32 byte buffer.
 * `cenc.fixed64` - Encodes a fixed 64 byte buffer.
 * `cenc.fixed(n)` - Makes a fixed sized encoder.
 * `cenc.array(enc)` - Makes an array encoder from another encoder. Arrays are uint prefixed with their length.
+* `cenc.raw.array(enc)` - Makes an array encoder from another encoder, without a length prefixed.
 * `cenc.json` - Encodes a JSON value as utf-8.
+* `cenc.raw.json` - Encodes a JSON value as utf-8 without a length prefixed.
 * `cenc.ndjson` - Encodes a JSON value as newline delimited utf-8.
+* `cenc.raw.ndjson` - Encodes a JSON value as newline delimited utf-8 without a length prefixed.
+* `cenc.any` - Encodes any JSON representable value into a self described buffer. Like JSON + buffer, but using compact types. Useful for schemaless codecs.
 * `cenc.from(enc)` - Makes a compact encoder from a [codec](https://github.com/mafintosh/codecs) or [abstract-encoding](https://github.com/mafintosh/abstract-encoding).
 
 ## License
 
-MIT
+Apache 2.0

package/endian.js

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

package/index.js

@@ -1,12 +1,13 @@
 const b4a = require('b4a')
 
-const LE = (new Uint8Array(new Uint16Array([0xff]).buffer))[0] === 0xff
-const BE = !LE
+const { BE } = require('./endian')
 
 exports.state = function (start = 0, end = 0, buffer = null) {
   return { start, end, buffer, cache: null }
 }
 
+const raw = exports.raw = require('./raw')
+
 const uint = exports.uint = {
   preencode (state, n) {
     state.end += n <= 0xfc ? 1 : n <= 0xffff ? 3 : n <= 0xffffffff ? 5 : 9
@@ -211,7 +212,7 @@ exports.float64 = {
   }
 }
 
-exports.buffer = {
+const buffer = exports.buffer = {
   preencode (state, b) {
     if (b) uint8array.preencode(state, b)
     else state.end++
@@ -228,18 +229,15 @@ exports.buffer = {
   }
 }
 
-const raw = exports.raw = {
+exports.binary = {
+  ...buffer,
   preencode (state, b) {
-    state.end += b.byteLength
+    if (typeof b === 'string') utf8.preencode(state, b)
+    else buffer.preencode(state, b)
   },
   encode (state, b) {
-    state.buffer.set(b, state.start)
-    state.start += b.byteLength
-  },
-  decode (state) {
-    const b = state.buffer.subarray(state.start, state.end)
-    state.start = state.end
-    return b
+    if (typeof b === 'string') utf8.encode(state, b)
+    else buffer.encode(state, b)
   }
 }
 
@@ -360,18 +358,6 @@ const fixed = exports.fixed = function fixed (n) {
 exports.fixed32 = fixed(32)
 exports.fixed64 = fixed(64)
 
-exports.none = {
-  preencode (state, m) {
-    // do nothing
-  },
-  encode (state, m) {
-    // do nothing
-  },
-  decode (state) {
-    return null
-  }
-}
-
 exports.array = function array (enc) {
   return {
     preencode (state, list) {
@@ -416,12 +402,142 @@ exports.ndjson = {
   }
 }
 
+// simple helper for when you want to just express nothing
+exports.none = {
+  preencode (state, n) {
+    // do nothing
+  },
+  encode (state, n) {
+    // do nothing
+  },
+  decode (state) {
+    return null
+  }
+}
+
+// "any" encoders here for helping just structure any object without schematising it
+
+const anyArray = {
+  preencode (state, arr) {
+    uint.preencode(state, arr.length)
+    for (let i = 0; i < arr.length; i++) {
+      any.preencode(state, arr[i])
+    }
+  },
+  encode (state, arr) {
+    uint.encode(state, arr.length)
+    for (let i = 0; i < arr.length; i++) {
+      any.encode(state, arr[i])
+    }
+  },
+  decode (state) {
+    const arr = []
+    let len = uint.decode(state)
+    while (len-- > 0) {
+      arr.push(any.decode(state))
+    }
+    return arr
+  }
+}
+
+const anyObject = {
+  preencode (state, o) {
+    const keys = Object.keys(o)
+    uint.preencode(state, keys.length)
+    for (const key of keys) {
+      utf8.preencode(state, key)
+      any.preencode(state, o[key])
+    }
+  },
+  encode (state, o) {
+    const keys = Object.keys(o)
+    uint.encode(state, keys.length)
+    for (const key of keys) {
+      utf8.encode(state, key)
+      any.encode(state, o[key])
+    }
+  },
+  decode (state) {
+    let len = uint.decode(state)
+    const o = {}
+    while (len-- > 0) {
+      const key = utf8.decode(state)
+      o[key] = any.decode(state)
+    }
+    return o
+  }
+}
+
+const anyTypes = [
+  exports.none,
+  exports.bool,
+  exports.string,
+  exports.buffer,
+  exports.uint,
+  exports.int,
+  exports.float64,
+  anyArray,
+  anyObject
+]
+
+const any = exports.any = {
+  preencode (state, o) {
+    const t = getType(o)
+    uint.preencode(state, t)
+    anyTypes[t].preencode(state, o)
+  },
+  encode (state, o) {
+    const t = getType(o)
+    uint.encode(state, t)
+    anyTypes[t].encode(state, o)
+  },
+  decode (state) {
+    const t = uint.decode(state)
+    if (t >= anyTypes.length) throw new Error('Unknown type: ' + t)
+    return anyTypes[t].decode(state)
+  }
+}
+
+function getType (o) {
+  if (o === null || o === undefined) return 0
+  if (typeof o === 'boolean') return 1
+  if (typeof o === 'string') return 2
+  if (b4a.isBuffer(o)) return 3
+  if (typeof o === 'number') {
+    if (Number.isInteger(o)) return o >= 0 ? 4 : 5
+    return 6
+  }
+  if (Array.isArray(o)) return 7
+  if (typeof o === 'object') return 8
+
+  throw new Error('Unsupported type for ' + o)
+}
+
 exports.from = function from (enc) {
+  if (typeof enc === 'string') return fromNamed(enc)
   if (enc.preencode) return enc
   if (enc.encodingLength) return fromAbstractEncoder(enc)
   return fromCodec(enc)
 }
 
+function fromNamed (enc) {
+  switch (enc) {
+    case 'ascii': return raw.ascii
+    case 'utf-8':
+    case 'utf8': return raw.utf8
+    case 'hex': return raw.hex
+    case 'base64': return raw.base64
+    case 'utf16-le':
+    case 'utf16le':
+    case 'ucs-2':
+    case 'ucs2': return raw.ucs2
+    case 'ndjson': return raw.ndjson
+    case 'json': return raw.json
+    case 'binary':
+    default: return raw.binary
+  }
+}
+
 function fromCodec (enc) {
   let tmpM = null
   let tmpBuf = null

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "compact-encoding",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "description": "A series of compact encoding schemes for building small and fast parsers and serializers",
   "main": "index.js",
   "dependencies": {
     "b4a": "^1.3.0"
   },
   "devDependencies": {
-    "brittle": "^1.5.1",
+    "brittle": "^3.0.0",
     "standard": "^16.0.3"
   },
   "scripts": {
@@ -18,7 +18,7 @@
     "url": "https://github.com/compact-encoding/compact-encoding.git"
   },
   "author": "Mathias Buus (@mafintosh)",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/compact-encoding/compact-encoding/issues"
   },

package/raw.js

@@ -0,0 +1,148 @@
+const b4a = require('b4a')
+
+const { BE } = require('./endian')
+
+exports = module.exports = {
+  preencode (state, b) {
+    state.end += b.byteLength
+  },
+  encode (state, b) {
+    state.buffer.set(b, state.start)
+    state.start += b.byteLength
+  },
+  decode (state) {
+    const b = state.buffer.subarray(state.start, state.end)
+    state.start = state.end
+    return b
+  }
+}
+
+const buffer = exports.buffer = {
+  preencode (state, b) {
+    if (b) uint8array.preencode(state, b)
+    else state.end++
+  },
+  encode (state, b) {
+    if (b) uint8array.encode(state, b)
+    else state.buffer[state.start++] = 0
+  },
+  decode (state) {
+    const b = state.buffer.subarray(state.start)
+    if (b.byteLength === 0) return null
+    state.start = state.end
+    return b
+  }
+}
+
+exports.binary = {
+  ...buffer,
+  preencode (state, b) {
+    if (typeof b === 'string') utf8.preencode(state, b)
+    else buffer.preencode(state, b)
+  },
+  encode (state, b) {
+    if (typeof b === 'string') utf8.encode(state, b)
+    else buffer.encode(state, b)
+  }
+}
+
+function typedarray (TypedArray, swap) {
+  const n = TypedArray.BYTES_PER_ELEMENT
+
+  return {
+    preencode (state, b) {
+      state.end += b.byteLength
+    },
+    encode (state, b) {
+      const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
+
+      if (BE && swap) swap(view)
+
+      state.buffer.set(view, state.start)
+      state.start += b.byteLength
+    },
+    decode (state) {
+      let b = state.buffer.subarray(state.start)
+      if ((b.byteOffset % n) !== 0) b = new Uint8Array(b)
+
+      if (BE && swap) swap(b)
+
+      state.start = state.end
+
+      return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n)
+    }
+  }
+}
+
+const uint8array = exports.uint8array = typedarray(Uint8Array)
+exports.uint16array = typedarray(Uint16Array, b4a.swap16)
+exports.uint32array = typedarray(Uint32Array, b4a.swap32)
+
+exports.int8array = typedarray(Int8Array)
+exports.int16array = typedarray(Int16Array, b4a.swap16)
+exports.int32array = typedarray(Int32Array, b4a.swap32)
+
+exports.float32array = typedarray(Float32Array, b4a.swap32)
+exports.float64array = typedarray(Float64Array, b4a.swap64)
+
+function string (encoding) {
+  return {
+    preencode (state, s) {
+      state.end += b4a.byteLength(s, encoding)
+    },
+    encode (state, s) {
+      state.start += b4a.write(state.buffer, s, state.start, encoding)
+    },
+    decode (state) {
+      const s = b4a.toString(state.buffer, encoding, state.start)
+      state.start = state.end
+      return s
+    }
+  }
+}
+
+const utf8 = exports.string = exports.utf8 = string('utf-8')
+exports.ascii = string('ascii')
+exports.hex = string('hex')
+exports.base64 = string('base64')
+exports.ucs2 = exports.utf16le = string('utf16le')
+
+exports.array = function array (enc) {
+  return {
+    preencode (state, list) {
+      for (const value of list) enc.preencode(state, value)
+    },
+    encode (state, list) {
+      for (const value of list) enc.encode(state, value)
+    },
+    decode (state) {
+      const arr = []
+      while (state.start < state.end) arr.push(enc.decode(state))
+      return arr
+    }
+  }
+}
+
+exports.json = {
+  preencode (state, v) {
+    utf8.preencode(state, JSON.stringify(v))
+  },
+  encode (state, v) {
+    utf8.encode(state, JSON.stringify(v))
+  },
+  decode (state) {
+    return JSON.parse(utf8.decode(state))
+  }
+}
+
+exports.ndjson = {
+  preencode (state, v) {
+    utf8.preencode(state, JSON.stringify(v) + '\n')
+  },
+  encode (state, v) {
+    utf8.encode(state, JSON.stringify(v) + '\n')
+  },
+  decode (state) {
+    return JSON.parse(utf8.decode(state))
+  }
+}

package/test.js

@@ -1,8 +1,8 @@
 const enc = require('./')
-const tape = require('brittle')
+const test = require('brittle')
 const b4a = require('b4a')
 
-tape('uint', function (t) {
+test('uint', function (t) {
   const state = enc.state()
 
   enc.uint.preencode(state, 42)
@@ -29,7 +29,7 @@ tape('uint', function (t) {
   t.exception(() => enc.uint.decode(state))
 })
 
-tape('int', function (t) {
+test('int', function (t) {
   const state = enc.state()
 
   enc.int.preencode(state, 42)
@@ -51,7 +51,7 @@ tape('int', function (t) {
   t.exception(() => enc.int.decode(state))
 })
 
-tape('float64', function (t) {
+test('float64', function (t) {
   const state = enc.state()
 
   enc.float64.preencode(state, 162.2377294)
@@ -146,7 +146,7 @@ tape('float64', function (t) {
   t.is(state.start, state.end)
 })
 
-tape('buffer', function (t) {
+test('buffer', function (t) {
   const state = enc.state()
 
   enc.buffer.preencode(state, b4a.from('hi'))
@@ -173,7 +173,7 @@ tape('buffer', function (t) {
   t.exception(() => enc.buffer.decode(state))
 })
 
-tape('raw', function (t) {
+test('raw', function (t) {
   const state = enc.state()
 
   enc.raw.preencode(state, b4a.from('hi'))
@@ -188,7 +188,26 @@ tape('raw', function (t) {
   t.is(state.start, state.end)
 })
 
-tape('uint16array', function (t) {
+test('raw uint8array', function (t) {
+  const state = enc.state()
+
+  enc.raw.uint8array.preencode(state, Uint8Array.of(1, 2))
+  t.alike(state, enc.state(0, 2))
+  enc.raw.uint8array.preencode(state, Uint8Array.of(3, 4))
+  t.alike(state, enc.state(0, 4))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.raw.uint8array.encode(state, Uint8Array.of(1, 2))
+  t.alike(state, enc.state(2, 4, b4a.from([1, 2, 0, 0])))
+  enc.raw.uint8array.encode(state, Uint8Array.of(3, 4))
+  t.alike(state, enc.state(4, 4, b4a.from([1, 2, 3, 4])))
+
+  state.start = 0
+  t.alike(enc.raw.uint8array.decode(state), Uint8Array.of(1, 2, 3, 4))
+  t.alike(enc.raw.uint8array.decode(state), Uint8Array.of())
+})
+
+test('uint16array', function (t) {
   const state = enc.state()
 
   enc.uint16array.preencode(state, new Uint16Array([1, 2, 3]))
@@ -205,7 +224,7 @@ tape('uint16array', function (t) {
   t.exception(() => enc.uint16array.decode(state))
 })
 
-tape('uint32array', function (t) {
+test('uint32array', function (t) {
   const state = enc.state()
 
   enc.uint32array.preencode(state, new Uint32Array([1]))
@@ -227,7 +246,7 @@ tape('uint32array', function (t) {
   t.exception(() => enc.uint32array.decode(state))
 })
 
-tape('int16array', function (t) {
+test('int16array', function (t) {
   const state = enc.state()
 
   enc.int16array.preencode(state, new Int16Array([1, -2, 3]))
@@ -244,7 +263,7 @@ tape('int16array', function (t) {
   t.exception(() => enc.int16array.decode(state))
 })
 
-tape('int32array', function (t) {
+test('int32array', function (t) {
   const state = enc.state()
 
   enc.int32array.preencode(state, new Int32Array([1, -2, 3]))
@@ -261,7 +280,7 @@ tape('int32array', function (t) {
   t.exception(() => enc.int32array.decode(state))
 })
 
-tape('float32array', function (t) {
+test('float32array', function (t) {
   const state = enc.state()
 
   enc.float32array.preencode(state, new Float32Array([1.1, -2.2, 3.3]))
@@ -278,7 +297,7 @@ tape('float32array', function (t) {
   t.exception(() => enc.float32array.decode(state))
 })
 
-tape('float64array', function (t) {
+test('float64array', function (t) {
   const state = enc.state()
 
   enc.float64array.preencode(state, new Float64Array([1.1, -2.2, 3.3]))
@@ -295,7 +314,7 @@ tape('float64array', function (t) {
   t.exception(() => enc.float64array.decode(state))
 })
 
-tape('string', function (t) {
+test('string', function (t) {
   const state = enc.state()
 
   enc.string.preencode(state, '🌾')
@@ -317,7 +336,25 @@ tape('string', function (t) {
   t.exception(() => enc.string.decode(state))
 })
 
-tape('fixed32', function (t) {
+test('raw string', function (t) {
+  const state = enc.state()
+
+  enc.raw.string.preencode(state, 'hello')
+  t.alike(state, enc.state(0, 5))
+  enc.raw.string.preencode(state, ' world')
+  t.alike(state, enc.state(0, 11))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.raw.string.encode(state, 'hello')
+  enc.raw.string.encode(state, ' world')
+  t.alike(state, enc.state(11, 11, b4a.from('hello world')))
+
+  state.start = 0
+  t.is(enc.raw.string.decode(state), 'hello world')
+  t.is(enc.raw.string.decode(state), '')
+})
+
+test('fixed32', function (t) {
   const state = enc.state()
 
   enc.fixed32.preencode(state, b4a.alloc(32).fill('a'))
@@ -339,7 +376,7 @@ tape('fixed32', function (t) {
   t.exception(() => enc.fixed32.decode(state))
 })
 
-tape('fixed64', function (t) {
+test('fixed64', function (t) {
   const state = enc.state()
 
   enc.fixed64.preencode(state, b4a.alloc(64).fill('a'))
@@ -361,7 +398,7 @@ tape('fixed64', function (t) {
   t.exception(() => enc.fixed64.decode(state))
 })
 
-tape('fixed n', function (t) {
+test('fixed n', function (t) {
   const state = enc.state()
   const fixed = enc.fixed(3)
 
@@ -386,7 +423,7 @@ tape('fixed n', function (t) {
   t.exception(() => fixed.decode(state))
 })
 
-tape('array', function (t) {
+test('array', function (t) {
   const state = enc.state()
   const arr = enc.array(enc.bool)
 
@@ -409,7 +446,27 @@ tape('array', function (t) {
   t.exception(() => arr.decode(state))
 })
 
-tape('json', function (t) {
+test('raw array', function (t) {
+  const state = enc.state()
+  const arr = enc.raw.array(enc.bool)
+
+  arr.preencode(state, [true])
+  t.alike(state, enc.state(0, 1))
+  arr.preencode(state, [true])
+  t.alike(state, enc.state(0, 2))
+
+  state.buffer = b4a.alloc(state.end)
+  arr.encode(state, [true])
+  t.alike(state, enc.state(1, 2, b4a.from([1, 0])))
+  arr.encode(state, [true])
+  t.alike(state, enc.state(2, 2, b4a.from([1, 1])))
+
+  state.start = 0
+  t.alike(arr.decode(state), [true, true])
+  t.alike(arr.decode(state), [])
+})
+
+test('json', function (t) {
   const state = enc.state()
 
   enc.json.preencode(state, { a: 1, b: 2 })
@@ -428,7 +485,23 @@ tape('json', function (t) {
   t.exception(() => enc.json.decode(state))
 })
 
-tape('lexint: big numbers', function (t) {
+test('raw json', function (t) {
+  const state = enc.state()
+
+  enc.raw.json.preencode(state, { a: 1, b: 2 })
+  t.alike(state, enc.state(0, 13))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.raw.json.encode(state, { a: 1, b: 2 })
+  t.alike(state, enc.state(13, 13, b4a.from('{"a":1,"b":2}')))
+
+  state.start = 0
+  t.alike(enc.raw.json.decode(state), { a: 1, b: 2 })
+
+  t.exception(() => enc.json.decode(state))
+})
+
+test('lexint: big numbers', function (t) {
   t.plan(1)
 
   let prev = enc.encode(enc.lexint, 0)
@@ -445,7 +518,7 @@ tape('lexint: big numbers', function (t) {
   t.is(n, Infinity)
 })
 
-tape('lexint: range precision', function (t) {
+test('lexint: range precision', function (t) {
   t.plan(2)
   const a = 1e55
   const b = 1.0000000000001e55
@@ -455,7 +528,7 @@ tape('lexint: range precision', function (t) {
   t.not(ha, hb)
 })
 
-tape('lexint: range precision', function (t) {
+test('lexint: range precision', function (t) {
   let prev = enc.encode(enc.lexint, 0)
   const skip = 0.000000001e55
   for (let i = 0, n = 1e55; i < 1000; n = 1e55 + skip * ++i) {
@@ -467,7 +540,7 @@ tape('lexint: range precision', function (t) {
   t.end()
 })
 
-tape('lexint: small numbers', function (t) {
+test('lexint: small numbers', function (t) {
   let prev = enc.encode(enc.lexint, 0)
   for (let n = 1; n < 256 * 256 * 16; n++) {
     const cur = enc.encode(enc.lexint, n)
@@ -478,7 +551,7 @@ tape('lexint: small numbers', function (t) {
   t.end()
 })
 
-tape('lexint: throws', function (t) {
+test('lexint: throws', function (t) {
   t.exception(() => {
     enc.decode(enc.lexint, b4a.alloc(1, 251))
   })
@@ -554,7 +627,7 @@ tape('lexint: throws', function (t) {
   t.end()
 })
 
-tape('lexint: unpack', function (t) {
+test('lexint: unpack', function (t) {
   let n
   let skip = 1
 
@@ -581,3 +654,20 @@ tape('lexint: unpack', function (t) {
     }
   }
 })
+
+test('any', function (t) {
+  const o = {
+    hello: 'world',
+    num: 42,
+    neg: -42,
+    arr: [{ yes: 1 }, { no: false }],
+    nest: {},
+    float: 0.54
+  }
+
+  t.alike(enc.decode(enc.any, enc.encode(enc.any, o)), o)
+
+  const arr = new Array(3)
+
+  t.alike(enc.decode(enc.any, enc.encode(enc.any, arr)), [null, null, null])
+})