nolo-cli 0.143.0-alpha.1 → 0.145.0-alpha.1

package/node_modules/level-supports/test/index.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const shape = require('./shape')
+const cloneable = require('./cloneable')
+
+module.exports = function suite (test, testCommon) {
+  test('db has manifest', async function (t) {
+    const db = testCommon.factory()
+    const manifest = db.supports
+
+    shape(t, manifest)
+    cloneable(t, manifest)
+
+    const before = Object.assign({}, manifest, {
+      additionalMethods: Object.assign({}, manifest.additionalMethods)
+    })
+
+    await db.open()
+    t.same(db.supports, before, 'manifest did not change after open')
+
+    await db.close()
+    t.same(db.supports, before, 'manifest did not change after close')
+  })
+}

package/node_modules/level-supports/test/self.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const test = require('tape')
+const { supports } = require('..')
+const shape = require('./shape')
+const cloneable = require('./cloneable')
+
+test('no options', function (t) {
+  shape(t, supports())
+  cloneable(t, supports())
+  t.end()
+})
+
+test('falsy options', function (t) {
+  ;[null, false, undefined, 0, ''].forEach(function (value) {
+    const manifest = supports({
+      seek: value,
+      additionalMethods: {
+        foo: value
+      }
+    })
+
+    shape(t, manifest)
+    t.is(manifest.seek, false)
+  })
+
+  t.end()
+})
+
+test('truthy options', function (t) {
+  ;[true, {}, 'yes', 1, []].forEach(function (value) {
+    const manifest = supports({
+      streams: value,
+      additionalMethods: {
+        foo: value
+      }
+    })
+
+    shape(t, manifest)
+    t.same(manifest.streams, value)
+    t.same(manifest.additionalMethods.foo, value)
+  })
+
+  t.end()
+})
+
+test('merges input objects without mutating them', function (t) {
+  const input1 = { seek: null, streams: false }
+  const input2 = { streams: true, additionalMethods: {} }
+  const manifest = supports(input1, input2)
+
+  manifest.foobar = true
+  manifest.additionalMethods.baz = true
+
+  t.same(input1, { seek: null, streams: false })
+  t.same(input2, { streams: true, additionalMethods: {} })
+  t.is(manifest.seek, false)
+  t.is(manifest.streams, true)
+  shape(t, manifest)
+  t.end()
+})
+
+test('inherits additionalMethods', function (t) {
+  const manifest = supports({ additionalMethods: { foo: true } }, {})
+  t.same(manifest.additionalMethods, { foo: true })
+  t.end()
+})
+
+test('does not merge additionalMethods', function (t) {
+  const input1 = { additionalMethods: { foo: true } }
+  const input2 = { additionalMethods: { bar: true } }
+  const manifest = supports(input1, input2)
+  t.same(manifest.additionalMethods, { bar: true })
+  t.end()
+})
+
+test('adds snapshots alias', function (t) {
+  for (const value of [true, false]) {
+    t.is(supports({ implicitSnapshots: value }).implicitSnapshots, value)
+    t.is(supports({ implicitSnapshots: value }).snapshots, value)
+    t.is(supports({ snapshots: value }).implicitSnapshots, value)
+    t.is(supports({ snapshots: value }).snapshots, value)
+  }
+
+  t.end()
+})

package/node_modules/level-supports/test/shape.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const hasOwnProperty = Object.prototype.hasOwnProperty
+
+module.exports = function shape (t, manifest) {
+  t.ok(isObject(manifest), 'manifest is object')
+  t.ok(isObject(manifest.additionalMethods), 'additionalMethods is object')
+  t.ok(isObject(manifest.signals), 'signals is object')
+
+  for (const k in manifest) {
+    if (!hasOwnProperty.call(manifest, k)) continue
+
+    if (manifest[k]) {
+      t.ok(manifest[k], 'truthy: ' + k)
+    } else {
+      t.is(manifest[k], false, 'false: ' + k)
+    }
+  }
+}
+
+function isObject (o) {
+  return typeof o === 'object' && o !== null
+}

package/node_modules/level-transcoder/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [1.0.1] - 2021-11-26
+
+### Fixed
+
+- Remove `codecs` from supported interfaces in `README` ([`3b6b003`](https://github.com/Level/transcoder/commit/3b6b003))
+
+## [1.0.0] - 2021-11-07
+
+_:seedling: Initial release._
+
+[1.0.1]: https://github.com/Level/transcoder/releases/tag/v1.0.1
+
+[1.0.0]: https://github.com/Level/transcoder/releases/tag/v1.0.0

package/node_modules/level-transcoder/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2012 The contributors to level-transcoder and level-codec.
+
+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.

package/node_modules/level-transcoder/README.md

@@ -0,0 +1,214 @@
+# level-transcoder
+
+**Encode data with built-in or custom encodings.** The successor to [`level-codec`][level-codec] that transcodes encodings from and to internal data formats supported by a database. This allows a database to store data in a format of its choice (Buffer, Uint8Array or String) with zero-effort support of known encodings. That includes other encoding interfaces in the ecosystem like [`abstract-encoding`][abstract-enc] and [`multiformats`][blockcodec].
+
+[![level badge][level-badge]](https://github.com/Level/awesome)
+[![npm](https://img.shields.io/npm/v/level-transcoder.svg)](https://www.npmjs.com/package/level-transcoder)
+[![Node version](https://img.shields.io/node/v/level-transcoder.svg)](https://www.npmjs.com/package/level-transcoder)
+[![Test](https://img.shields.io/github/workflow/status/Level/transcoder/Test?label=test)](https://github.com/Level/transcoder/actions/workflows/test.yml)
+[![Coverage](https://img.shields.io/codecov/c/github/Level/transcoder?label=\&logo=codecov\&logoColor=fff)](https://codecov.io/gh/Level/transcoder)
+[![Standard](https://img.shields.io/badge/standard-informational?logo=javascript\&logoColor=fff)](https://standardjs.com)
+[![Common Changelog](https://common-changelog.org/badge.svg)](https://common-changelog.org)
+[![Donate](https://img.shields.io/badge/donate-orange?logo=open-collective\&logoColor=fff)](https://opencollective.com/level)
+
+## Usage
+
+Create a transcoder, passing a desired format:
+
+```js
+const { Transcoder } = require('level-transcoder')
+
+const transcoder1 = new Transcoder(['view'])
+const transcoder2 = new Transcoder(['buffer'])
+const transcoder3 = new Transcoder(['utf8'])
+```
+
+Then select an encoding and encode some data:
+
+```js
+// Uint8Array(3) [ 49, 50, 51 ]
+console.log(transcoder1.encoding('json').encode(123))
+
+// <Buffer 31 32 33>
+console.log(transcoder2.encoding('json').encode(123))
+
+// '123'
+console.log(transcoder3.encoding('json').encode(123))
+```
+
+If the `Transcoder` constructor is given multiple formats then `Transcoder#encoding()` selects an encoding with the best fitting format. Consider a database like [`leveldown`][leveldown] which has the ability to return data as a Buffer or string. If an `encoding.decode(data)` function needs a string, we'll want to fetch that `data` from the database as a string. This avoids the cost of having to convert a Buffer to a string. So we'd use the following transcoder:
+
+```js
+const transcoder = new Transcoder(['buffer', 'utf8'])
+```
+
+Then, knowing for example that the return value of `JSON.stringify(data)` is a UTF-8 string which matches one of the given formats, the `'json'` encoding will return a string here:
+
+```js
+// '123'
+console.log(transcoder.encoding('json').encode(123))
+```
+
+In contrast, data encoded as a `'view'` (for now that just means Uint8Array) would get transcoded into the `'buffer'` encoding. Copying of data is avoided where possible, like how the underlying ArrayBuffer of a view can be passed to `Buffer.from(..)` without a copy.
+
+Lastly, encodings returned by `Transcoder#encoding()` have a `format` property to be used to forward information to an underlying store. For example: an input value of `{ x: 3 }` using the `'json'` encoding which has a `format` of `'utf8'`, can be forwarded as value `'{"x":3}'` with encoding `'utf8'`. Vice versa for output.
+
+## Encodings
+
+### Built-in Encodings
+
+These encodings can be used out of the box and are to be selected by name.
+
+In this table, the _input_ is what `encode()` accepts. The _format_ is what `encode()` returns as well as what `decode()` accepts. The _output_ is what `decode()` returns. The TypeScript typings of `level-transcoder` have generic type parameters with matching names: `TIn`, `TFormat` and `TOut`.
+
+| Name                    | Input                      | Format     | Output          |
+| :---------------------- | :------------------------- | :--------- | :-------------- |
+| `'buffer'` <sup>1</sup> | Buffer, Uint8Array, String | `'buffer'` | Buffer          |
+| `'view'`                | Uint8Array, Buffer, String | `'view'`   | Uint8Array      |
+| `'utf8'`                | String, Buffer, Uint8Array | `'utf8'`   | String          |
+| `'json'`                | Any JSON type              | `'utf8'`   | As input        |
+| `'hex'`                 | String (hex), Buffer       | `'buffer'` | String (hex)    |
+| `'base64'`              | String (base64), Buffer    | `'buffer'` | String (base64) |
+
+<sup>1</sup> Aliased as `'binary'`. Use of this alias does not affect the ability to transcode.
+
+### Transcoder Encodings
+
+It's not necessary to use or reference the below encodings directly. They're listed here for implementation notes and to show how input and output is the same; it's the format that differs.
+
+Custom encodings are transcoded in the same way and require no additional setup. For example: if a custom encoding has `{ name: 'example', format: 'utf8' }` then `level-transcoder` will create transcoder encodings on demand with names `'example+buffer'` and `'example+view'`.
+
+| Name                         | Input                      | Format     | Output          |
+| :--------------------------- | :------------------------- | :--------- | :-------------- |
+| `'buffer+view'`              | Buffer, Uint8Array, String | `'view'`   | Buffer          |
+| `'view+buffer'`              | Uint8Array, Buffer, String | `'buffer'` | Uint8Array      |
+| `'utf8+view'`                | String, Buffer, Uint8Array | `'view'`   | String          |
+| `'utf8+buffer'`              | String, Buffer, Uint8Array | `'buffer'` | String          |
+| `'json+view'`                | Any JSON type              | `'view'`   | As input        |
+| `'json+buffer'`              | Any JSON type              | `'buffer'` | As input        |
+| `'hex+view'` <sup>1</sup>    | String (hex), Buffer       | `'view'`   | String (hex)    |
+| `'base64+view'` <sup>1</sup> | String (base64), Buffer    | `'view'`   | String (base64) |
+
+<sup>1</sup> Unlike other encodings that transcode to `'view'`, these depend on Buffer at the moment and thus don't work in browsers if a [shim](https://github.com/feross/buffer) is not included by JavaScript bundlers like Webpack and Browserify.
+
+### Ecosystem Encodings
+
+Various modules in the ecosystem, in and outside of Level, can be used with `level-transcoder` although they follow different interfaces. Common between the interfaces is that they have `encode()` and `decode()` methods. The terms "codec" and "encoding" are used interchangeably in the ecosystem. Passing these encodings through `Transcoder#encoding()` (which is done implicitly when used in an `abstract-level` database) results in normalized encoding objects as described further below.
+
+| Module                                     | Format           | Interface                           | Named |
+| :----------------------------------------- | :--------------- | :---------------------------------- | :---- |
+| [`protocol-buffers`][protocol-buffers]     | `buffer`         | [`level-codec`][level-codec]        | ❌     |
+| [`charwise`][charwise]                     | `utf8`           | [`level-codec`][level-codec]        | ✅     |
+| [`bytewise`][bytewise]                     | `buffer`         | [`level-codec`][level-codec]        | ✅     |
+| [`lexicographic-integer-encoding`][lexint] | `buffer`, `utf8` | [`level-codec`][level-codec]        | ✅     |
+| [`abstract-encoding`][abstract-enc]        | `buffer`         | [`abstract-encoding`][abstract-enc] | ❌     |
+| [`multiformats`][js-multiformats]          | `view`           | [`multiformats`][blockcodec]        | ✅     |
+
+Those marked as not named are modules that export or generate encodings that don't have a `name` property (or `type` as an alias). We call these _anonymous encodings_. They can only be used as objects and not by name. Passing an anonymous encoding through `Transcoder#encoding()` does give it a `name` property for compatibility, but the value of `name` is not deterministic.
+
+## API
+
+### `Transcoder`
+
+#### `transcoder = new Transcoder(formats)`
+
+Create a new transcoder, providing the formats that are supported by a database (or other). The `formats` argument must be an array containing one or more of `'buffer'`, `'view'`, `'utf8'`. The returned `transcoder` instance is stateful, in that it contains a set of cached encoding objects.
+
+#### `encoding = transcoder.encoding(encoding)`
+
+Returns the given `encoding` argument as a normalized encoding object that follows the `level-transcoder` encoding interface. The `encoding` argument may be:
+
+- A string to select a known encoding by its name
+- An object that follows one of the following interfaces: [`level-transcoder`](#encoding-interface), [`level-codec`](https://github.com/Level/codec#encoding-format), [`abstract-encoding`][abstract-enc], [`multiformats`][blockcodec]
+- A previously normalized encoding, such that `encoding(x)` equals `encoding(encoding(x))`.
+
+Results are cached. If the `encoding` argument is an object and it has a name then subsequent calls can refer to that encoding by name.
+
+Depending on the `formats` provided to the `Transcoder` constructor, this method may return a _transcoder encoding_ that translates the desired encoding from / to a supported format. Its `encode()` and `decode()` methods will have respectively the same input and output types as a non-transcoded encoding, but its `name` property will differ.
+
+#### `encodings = transcoder.encodings()`
+
+Get an array of encoding objects. This includes:
+
+- Encodings for the `formats` that were passed to the `Transcoder` constructor
+- Custom encodings that were passed to `transcoder.encoding()`
+- Transcoder encodings for either.
+
+### `Encoding`
+
+#### `data = encoding.encode(data)`
+
+Encode data.
+
+#### `data = encoding.decode(data)`
+
+Decode data.
+
+#### `encoding.name`
+
+Unique name. A string.
+
+#### `encoding.commonName`
+
+Common name, computed from `name`. If this encoding is a transcoder encoding, `name` will be for example `'json+view'` and `commonName` will be just `'json'`. Else `name` will equal `commonName`.
+
+#### `encoding.format`
+
+Name of the (lower-level) encoding used by the return value of `encode()`. One of `'buffer'`, `'view'`, `'utf8'`. If `name` equals `format` then the encoding can be assumed to be idempotent, such that `encode(x)` equals `encode(encode(x))`.
+
+## Encoding Interface
+
+Custom encodings must follow the following interface:
+
+```ts
+interface IEncoding<TIn, TFormat, TOut> {
+  name: string
+  format: 'buffer' | 'view' | 'utf8'
+  encode: (data: TIn) => TFormat
+  decode: (data: TFormat) => TOut
+}
+```
+
+## Install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install level-transcoder
+```
+
+## Contributing
+
+[`Level/transcoder`](https://github.com/Level/transcoder) is an **OPEN Open Source Project**. This means that:
+
+> Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.
+
+See the [Contribution Guide](https://github.com/Level/community/blob/master/CONTRIBUTING.md) for more details.
+
+## Donate
+
+Support us with a monthly donation on [Open Collective](https://opencollective.com/level) and help us continue our work.
+
+## License
+
+[MIT](LICENSE)
+
+[level-badge]: https://leveljs.org/img/badge.svg
+
+[level-codec]: https://github.com/Level/codec
+
+[leveldown]: https://github.com/Level/leveldown
+
+[protocol-buffers]: https://github.com/mafintosh/protocol-buffers
+
+[charwise]: https://github.com/dominictarr/charwise
+
+[bytewise]: https://github.com/deanlandolt/bytewise
+
+[lexint]: https://github.com/vweevers/lexicographic-integer-encoding
+
+[abstract-enc]: https://github.com/mafintosh/abstract-encoding
+
+[js-multiformats]: https://github.com/multiformats/js-multiformats
+
+[blockcodec]: https://github.com/multiformats/js-multiformats/blob/master/src/codecs/interface.ts

package/node_modules/level-transcoder/UPGRADING.md

@@ -0,0 +1,13 @@
+# Upgrade Guide
+
+This document describes breaking changes and how to upgrade. For a complete list of changes including minor and patch releases, please refer to the [changelog](CHANGELOG.md).
+
+## 1.0.0
+
+This is the initial release of `level-transcoder`, which was forked from `level-codec`. Ultimately `level-transcoder` got a completely different API, so the two modules are not interchangeable. That said, here are the high-level differences from `level-codec` just for the record:
+
+- Throws if an encoding is not found, rather than falling back to `'id'` encoding
+- The `'binary'` encoding has been renamed to `'buffer'`, with `'binary'` as an alias
+- The `'utf8'` encoding of `level-codec` did not touch Buffers. In `level-transcoder` the same encoding will call `buffer.toString('utf8')` for consistency. Consumers can use the `'buffer'` encoding to avoid this conversion.
+- The `'id'` encoding (aliased as `'none'`) which wasn't supported by any active `abstract-leveldown` implementation, has been removed.
+- The `'ascii'`, `'ucs2'` and `'utf16le'` encodings are not supported.

package/node_modules/level-transcoder/index.d.ts

@@ -0,0 +1,27 @@
+import { Encoding, MixedEncoding, KnownEncoding, KnownEncodingName } from './lib/encoding'
+
+export class Transcoder<T = any> {
+  /**
+   * Create a Transcoder.
+   * @param formats Formats supported by consumer.
+   */
+  constructor (formats: Array<'buffer'|'view'|'utf8'>)
+
+  /**
+   * Get an array of supported encoding objects.
+   */
+  encodings (): Array<Encoding<any, T, any>>
+
+  /**
+   * Get the given encoding, creating a transcoder encoding if necessary.
+   * @param encoding Named encoding or encoding object.
+   */
+  encoding<TIn, TFormat, TOut> (
+    encoding: MixedEncoding<TIn, TFormat, TOut>
+  ): Encoding<TIn, T, TOut>
+
+  encoding<N extends KnownEncodingName> (encoding: N): KnownEncoding<N, T>
+  encoding (encoding: string): Encoding<any, T, any>
+}
+
+export * from './lib/encoding'

package/node_modules/level-transcoder/index.js

@@ -0,0 +1,158 @@
+'use strict'
+
+const ModuleError = require('module-error')
+const encodings = require('./lib/encodings')
+const { Encoding } = require('./lib/encoding')
+const { BufferFormat, ViewFormat, UTF8Format } = require('./lib/formats')
+
+const kFormats = Symbol('formats')
+const kEncodings = Symbol('encodings')
+const validFormats = new Set(['buffer', 'view', 'utf8'])
+
+/** @template T */
+class Transcoder {
+  /**
+   * @param {Array<'buffer'|'view'|'utf8'>} formats
+   */
+  constructor (formats) {
+    if (!Array.isArray(formats)) {
+      throw new TypeError("The first argument 'formats' must be an array")
+    } else if (!formats.every(f => validFormats.has(f))) {
+      // Note: we only only support aliases in key- and valueEncoding options (where we already did)
+      throw new TypeError("Format must be one of 'buffer', 'view', 'utf8'")
+    }
+
+    /** @type {Map<string|MixedEncoding<any, any, any>, Encoding<any, any, any>>} */
+    this[kEncodings] = new Map()
+    this[kFormats] = new Set(formats)
+
+    // Register encodings (done early in order to populate encodings())
+    for (const k in encodings) {
+      try {
+        this.encoding(k)
+      } catch (err) {
+        /* istanbul ignore if: assertion */
+        if (err.code !== 'LEVEL_ENCODING_NOT_SUPPORTED') throw err
+      }
+    }
+  }
+
+  /**
+   * @returns {Array<Encoding<any,T,any>>}
+   */
+  encodings () {
+    return Array.from(new Set(this[kEncodings].values()))
+  }
+
+  /**
+   * @param {string|MixedEncoding<any, any, any>} encoding
+   * @returns {Encoding<any, T, any>}
+   */
+  encoding (encoding) {
+    let resolved = this[kEncodings].get(encoding)
+
+    if (resolved === undefined) {
+      if (typeof encoding === 'string' && encoding !== '') {
+        resolved = lookup[encoding]
+
+        if (!resolved) {
+          throw new ModuleError(`Encoding '${encoding}' is not found`, {
+            code: 'LEVEL_ENCODING_NOT_FOUND'
+          })
+        }
+      } else if (typeof encoding !== 'object' || encoding === null) {
+        throw new TypeError("First argument 'encoding' must be a string or object")
+      } else {
+        resolved = from(encoding)
+      }
+
+      const { name, format } = resolved
+
+      if (!this[kFormats].has(format)) {
+        if (this[kFormats].has('view')) {
+          resolved = resolved.createViewTranscoder()
+        } else if (this[kFormats].has('buffer')) {
+          resolved = resolved.createBufferTranscoder()
+        } else if (this[kFormats].has('utf8')) {
+          resolved = resolved.createUTF8Transcoder()
+        } else {
+          throw new ModuleError(`Encoding '${name}' cannot be transcoded`, {
+            code: 'LEVEL_ENCODING_NOT_SUPPORTED'
+          })
+        }
+      }
+
+      for (const k of [encoding, name, resolved.name, resolved.commonName]) {
+        this[kEncodings].set(k, resolved)
+      }
+    }
+
+    return resolved
+  }
+}
+
+exports.Transcoder = Transcoder
+
+/**
+ * @param {MixedEncoding<any, any, any>} options
+ * @returns {Encoding<any, any, any>}
+ */
+function from (options) {
+  if (options instanceof Encoding) {
+    return options
+  }
+
+  // Loosely typed for ecosystem compatibility
+  const maybeType = 'type' in options && typeof options.type === 'string' ? options.type : undefined
+  const name = options.name || maybeType || `anonymous-${anonymousCount++}`
+
+  switch (detectFormat(options)) {
+    case 'view': return new ViewFormat({ ...options, name })
+    case 'utf8': return new UTF8Format({ ...options, name })
+    case 'buffer': return new BufferFormat({ ...options, name })
+    default: {
+      throw new TypeError("Format must be one of 'buffer', 'view', 'utf8'")
+    }
+  }
+}
+
+/**
+ * If format is not provided, fallback to detecting `level-codec`
+ * or `multiformats` encodings, else assume a format of buffer.
+ * @param {MixedEncoding<any, any, any>} options
+ * @returns {string}
+ */
+function detectFormat (options) {
+  if ('format' in options && options.format !== undefined) {
+    return options.format
+  } else if ('buffer' in options && typeof options.buffer === 'boolean') {
+    return options.buffer ? 'buffer' : 'utf8' // level-codec
+  } else if ('code' in options && Number.isInteger(options.code)) {
+    return 'view' // multiformats
+  } else {
+    return 'buffer'
+  }
+}
+
+/**
+ * @typedef {import('./lib/encoding').MixedEncoding<TIn,TFormat,TOut>} MixedEncoding
+ * @template TIn, TFormat, TOut
+ */
+
+/**
+ * @type {Object.<string, Encoding<any, any, any>>}
+ */
+const aliases = {
+  binary: encodings.buffer,
+  'utf-8': encodings.utf8
+}
+
+/**
+ * @type {Object.<string, Encoding<any, any, any>>}
+ */
+const lookup = {
+  ...encodings,
+  ...aliases
+}
+
+let anonymousCount = 0