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

package/node_modules/buffer/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "buffer",
+  "description": "Node.js Buffer API, for the browser",
+  "version": "6.0.3",
+  "author": {
+    "name": "Feross Aboukhadijeh",
+    "email": "feross@feross.org",
+    "url": "https://feross.org"
+  },
+  "bugs": {
+    "url": "https://github.com/feross/buffer/issues"
+  },
+  "contributors": [
+    "Romain Beauxis <toots@rastageeks.org>",
+    "James Halliday <mail@substack.net>"
+  ],
+  "dependencies": {
+    "base64-js": "^1.3.1",
+    "ieee754": "^1.2.1"
+  },
+  "devDependencies": {
+    "airtap": "^3.0.0",
+    "benchmark": "^2.1.4",
+    "browserify": "^17.0.0",
+    "concat-stream": "^2.0.0",
+    "hyperquest": "^2.1.3",
+    "is-buffer": "^2.0.5",
+    "is-nan": "^1.3.0",
+    "split": "^1.0.1",
+    "standard": "*",
+    "tape": "^5.0.1",
+    "through2": "^4.0.2",
+    "uglify-js": "^3.11.5"
+  },
+  "homepage": "https://github.com/feross/buffer",
+  "jspm": {
+    "map": {
+      "./index.js": {
+        "node": "@node/buffer"
+      }
+    }
+  },
+  "keywords": [
+    "arraybuffer",
+    "browser",
+    "browserify",
+    "buffer",
+    "compatible",
+    "dataview",
+    "uint8array"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/feross/buffer.git"
+  },
+  "scripts": {
+    "perf": "browserify --debug perf/bracket-notation.js > perf/bundle.js && open perf/index.html",
+    "perf-node": "node perf/bracket-notation.js && node perf/concat.js && node perf/copy-big.js && node perf/copy.js && node perf/new-big.js && node perf/new.js && node perf/readDoubleBE.js && node perf/readFloatBE.js && node perf/readUInt32LE.js && node perf/slice.js && node perf/writeFloatBE.js",
+    "size": "browserify -r ./ | uglifyjs -c -m | gzip | wc -c",
+    "test": "standard && node ./bin/test.js",
+    "test-browser-old": "airtap -- test/*.js",
+    "test-browser-old-local": "airtap --local -- test/*.js",
+    "test-browser-new": "airtap -- test/*.js test/node/*.js",
+    "test-browser-new-local": "airtap --local -- test/*.js test/node/*.js",
+    "test-node": "tape test/*.js test/node/*.js",
+    "update-authors": "./bin/update-authors.sh"
+  },
+  "standard": {
+    "ignore": [
+      "test/node/**/*.js",
+      "test/common.js",
+      "test/_polyfill.js",
+      "perf/**/*.js"
+    ]
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/feross"
+    },
+    {
+      "type": "patreon",
+      "url": "https://www.patreon.com/feross"
+    },
+    {
+      "type": "consulting",
+      "url": "https://feross.org/support"
+    }
+  ]
+}

package/node_modules/classic-level/CHANGELOG.md

@@ -0,0 +1,115 @@
+# Changelog
+
+## [3.0.0] - 2025-04-20
+
+_If you are upgrading: please see [`UPGRADING.md`](UPGRADING.md)._
+
+### Changed
+
+- **Breaking:** upgrade to `abstract-level` 3 ([#112](https://github.com/Level/classic-level/issues/112)) ([`812fe88`](https://github.com/Level/classic-level/commit/812fe88)) (Vincent Weevers)
+
+### Added
+
+- Add `db.getSync()` method ([#120](https://github.com/Level/classic-level/issues/120)) ([`7a2bd2c`](https://github.com/Level/classic-level/commit/7a2bd2c)) (Vincent Weevers)
+- Implement `has()` and `hasMany()` ([#111](https://github.com/Level/classic-level/issues/111)) ([`6aeb739`](https://github.com/Level/classic-level/commit/6aeb739)) (Vincent Weevers)
+- Implement explicit snapshots ([#110](https://github.com/Level/classic-level/issues/110)) ([`15eb289`](https://github.com/Level/classic-level/commit/15eb289)) (Vincent Weevers)
+
+### Fixed
+
+- Fix TypeScript return type of `get` and `getMany` ([#117](https://github.com/Level/classic-level/issues/117)) ([`e310ffd`](https://github.com/Level/classic-level/commit/e310ffd)) (David Daester)
+
+## [2.0.0] - 2024-10-21
+
+_If you are upgrading: please see [`UPGRADING.md`](UPGRADING.md)._
+
+### Changed
+
+- **Breaking:** bump `abstract-level` to 2.0.0 ([`dff7a67`](https://github.com/Level/classic-level/commit/dff7a67)) (Vincent Weevers)
+- **Breaking:** remove callbacks and `LEVEL_NOT_FOUND` ([`d5bad80`](https://github.com/Level/classic-level/commit/d5bad80)) (Vincent Weevers)
+- Update README for v2, with a new approach ([`a078b45`](https://github.com/Level/classic-level/commit/a078b45)) (Vincent Weevers)
+- Refactor to put more trust in abstract-level state ([`c2426bb`](https://github.com/Level/classic-level/commit/c2426bb)) (Vincent Weevers)
+- Use headers of 18.20.4 for prebuilds ([`13bcc68`](https://github.com/Level/classic-level/commit/13bcc68)) (Vincent Weevers)
+- Swap CentOS image with AlmaLinux (for linux prebuilds) ([`a3be44d`](https://github.com/Level/classic-level/commit/a3be44d)) (Vincent Weevers)
+
+### Added
+
+- Support `signal` option on iterators ([`6e196dc`](https://github.com/Level/classic-level/commit/6e196dc)) (Vincent Weevers)
+
+### Removed
+
+- **Breaking:** drop Node.js < 18 and Electron < 30 ([`c177f3c`](https://github.com/Level/classic-level/commit/c177f3c), [`e18d5c7`](https://github.com/Level/classic-level/commit/e18d5c7)) (Vincent Weevers)
+- Stop testing on FreeBSD ([`ce99a79`](https://github.com/Level/classic-level/commit/ce99a79)) (Vincent Weevers)
+- Remove `levelup` compatibility check ([`b086bc8`](https://github.com/Level/classic-level/commit/b086bc8)) (Vincent Weevers)
+
+### Fixed
+
+- Fix cache bug in `iterator.nextv()` ([`1063558`](https://github.com/Level/classic-level/commit/1063558)) (Vincent Weevers)
+- Create snapshot for `get()` synchronously ([`50e03dc`](https://github.com/Level/classic-level/commit/50e03dc)) (Vincent Weevers)
+
+## [1.4.1] - 2024-01-20
+
+### Fixed
+
+- Fix race condition in tests ([#90](https://github.com/Level/classic-level/issues/90)) ([`9ff2e82`](https://github.com/Level/classic-level/commit/9ff2e82)) (Matthew Keil).
+
+## [1.4.0] - 2023-11-26
+
+_Not released to npm because of a race issue, which was fixed in 1.4.1._
+
+### Added
+
+- Add opt-in multithreading ([#85](https://github.com/Level/classic-level/issues/85)) ([`7d497a5`](https://github.com/Level/classic-level/commit/7d497a5)) (Matthew Keil).
+
+## [1.3.0] - 2023-04-07
+
+### Changed
+
+- Refactor some pointer usage ([#25](https://github.com/Level/classic-level/issues/25)) ([`d6437b4`](https://github.com/Level/classic-level/commit/d6437b4)) (Robert Nagy)
+- Refactor: handle view encoding (Uint8Array) natively ([#43](https://github.com/Level/classic-level/issues/43)) ([`b9fd5e9`](https://github.com/Level/classic-level/commit/b9fd5e9)) (Vincent Weevers)
+- Bump and unlock `napi-macros` from 2.0.0 to 2.2.2 ([#58](https://github.com/Level/classic-level/issues/58)) ([`8a4717b`](https://github.com/Level/classic-level/commit/8a4717b)) (Vincent Weevers).
+
+### Fixed
+
+- Swap linux-arm build to use `linux-arm64-lts` ([#71](https://github.com/Level/classic-level/issues/71)) ([`5ea74ab`](https://github.com/Level/classic-level/commit/5ea74ab)) (Cody Swendrowski)
+- Add `openssl_fips` variable to gyp bindings ([#72](https://github.com/Level/classic-level/issues/72)) ([`b3f8517`](https://github.com/Level/classic-level/commit/b3f8517)) (Cody Swendrowski).
+
+## [1.2.0] - 2022-03-25
+
+### Added
+
+- Yield `LEVEL_LOCKED` error when lock is held ([#8](https://github.com/Level/classic-level/issues/8)) ([`aa975de`](https://github.com/Level/classic-level/commit/aa975de)) (Vincent Weevers)
+
+### Fixed
+
+- Fix `getMany()` memory leak ([#9](https://github.com/Level/classic-level/issues/9)) ([`00364c7`](https://github.com/Level/classic-level/commit/00364c7)) (Vincent Weevers).
+
+## [1.1.0] - 2022-03-06
+
+### Added
+
+- Create location directory recursively ([#6](https://github.com/Level/classic-level/issues/6)) ([`1ba0b69`](https://github.com/Level/classic-level/commit/1ba0b69)) (Vincent Weevers)
+
+### Fixed
+
+- Fix TypeScript type declarations ([`a79fe82`](https://github.com/Level/classic-level/commit/a79fe82)) (Vincent Weevers)
+- Document the return type of `db.batch()` and add example ([`a909ea6`](https://github.com/Level/classic-level/commit/a909ea6)) (Vincent Weevers).
+
+## [1.0.0] - 2022-03-04
+
+_:seedling: Initial release. If you are upgrading from `leveldown` please see [`UPGRADING.md`](UPGRADING.md)._
+
+[3.0.0]: https://github.com/Level/classic-level/releases/tag/v3.0.0
+
+[2.0.0]: https://github.com/Level/classic-level/releases/tag/v2.0.0
+
+[1.4.1]: https://github.com/Level/classic-level/releases/tag/v1.4.1
+
+[1.4.0]: https://github.com/Level/classic-level/releases/tag/v1.4.0
+
+[1.3.0]: https://github.com/Level/classic-level/releases/tag/v1.3.0
+
+[1.2.0]: https://github.com/Level/classic-level/releases/tag/v1.2.0
+
+[1.1.0]: https://github.com/Level/classic-level/releases/tag/v1.1.0
+
+[1.0.0]: https://github.com/Level/classic-level/releases/tag/v1.0.0

package/node_modules/classic-level/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012 Rod Vagg and the contributors to classic-level and leveldown.
+
+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/classic-level/README.md

@@ -0,0 +1,274 @@
+# classic-level
+
+**An [`abstract-level`](https://github.com/Level/abstract-level) database backed by [LevelDB](https://github.com/google/leveldb).** The successor to [`leveldown`](https://github.com/Level/leveldown) with builtin encodings, sublevels, events, hooks and support of Uint8Array. If you are upgrading, please see [`UPGRADING.md`](UPGRADING.md).
+
+> :pushpin: What is `abstract-level`? Head on over to [Frequently Asked Questions](https://github.com/Level/community#faq).
+
+[![level badge][level-badge]](https://github.com/Level/awesome)
+[![npm](https://img.shields.io/npm/v/classic-level.svg)](https://www.npmjs.com/package/classic-level)
+[![Node version](https://img.shields.io/node/v/classic-level.svg)](https://www.npmjs.com/package/classic-level)
+[![Test](https://img.shields.io/github/actions/workflow/status/Level/classic-level/test.yml?branch=main\&label=test)](https://github.com/Level/classic-level/actions/workflows/test.yml)
+[![Coverage](https://img.shields.io/codecov/c/github/Level/classic-level?label=\&logo=codecov\&logoColor=fff)](https://codecov.io/gh/Level/classic-level)
+[![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
+
+```js
+const { ClassicLevel } = require('classic-level')
+
+// Create a database
+const db = new ClassicLevel('./db', { valueEncoding: 'json' })
+
+// Add an entry with key 'a' and value 1
+await db.put('a', 1)
+
+// Add multiple entries
+await db.batch([{ type: 'put', key: 'b', value: 2 }])
+
+// Get value of key 'a': 1
+const value = await db.get('a')
+
+// Iterate entries with keys that are greater than 'a'
+for await (const [key, value] of db.iterator({ gt: 'a' })) {
+  console.log(value) // 2
+}
+```
+
+Usage from TypeScript requires generic type parameters.
+
+<details><summary>TypeScript example</summary>
+
+```ts
+// Specify types of keys and values (any, in the case of json).
+// The generic type parameters default to ClassicLevel<string, string>.
+const db = new ClassicLevel<string, any>('./db', { valueEncoding: 'json' })
+
+// All relevant methods then use those types
+await db.put('a', { x: 123 })
+
+// Specify different types when overriding encoding per operation
+await db.get<string, string>('a', { valueEncoding: 'utf8' })
+
+// Though in some cases TypeScript can infer them
+await db.get('a', { valueEncoding: db.valueEncoding('utf8') })
+
+// It works the same for sublevels
+const abc = db.sublevel('abc')
+const xyz = db.sublevel<string, any>('xyz', { valueEncoding: 'json' })
+```
+
+</details>
+
+## Supported Platforms
+
+We aim to support Active LTS and Current Node.js releases, Electron >= 30, as well as any future Node.js and Electron releases thanks to [Node-API](https://nodejs.org/api/n-api.html).
+
+The `classic-level` npm package ships with prebuilt binaries for popular 64-bit platforms as well as ARM, M1, Android, Alpine (musl), Windows 32-bit, Linux flavors with an old glibc (2.28) and is known to work on:
+
+- **Linux**, including ARM platforms such as Raspberry Pi and Kindle
+- **Mac OS** (10.7 and later)
+- **Windows**.
+
+When installing `classic-level`, [`node-gyp-build`](https://github.com/prebuild/node-gyp-build) will check if a compatible binary exists and fallback to compiling from source if it doesn't. In that case you'll need a [valid `node-gyp` installation](https://github.com/nodejs/node-gyp#installation).
+
+If you don't want to use the prebuilt binary for the platform you are installing on, specify the `--build-from-source` flag when you install:
+
+```
+npm install classic-level --build-from-source
+```
+
+If you are working on `classic-level` itself and want to recompile the C++ code, run `npm run rebuild`.
+
+## API
+
+The API of `classic-level` follows that of [`abstract-level`](https://github.com/Level/abstract-level#public-api-for-consumers) with a few additional methods and options that are specific to LevelDB. The documentation below only covers the differences.
+
+### `db = new ClassicLevel(location[, options])`
+
+Create a database or open an existing database. The `location` argument must be a directory path (relative or absolute) where LevelDB will store its files. If the directory does not yet exist (and `options.createIfMissing` is true) it will be created recursively. Options are the same as in `abstract-level` except for the additional options accepted by `db.open()` and thus by this constructor.
+
+A `classic-level` database obtains an exclusive lock. If another process or instance has already opened the underlying LevelDB store at the same `location` then opening will fail with error code [`LEVEL_LOCKED`](https://github.com/Level/abstract-level#errors).
+
+### Opening
+
+The [`db.open([options])`](https://github.com/Level/abstract-level#dbopenoptions) method has additional options:
+
+- `multithreading` (boolean, default: `false`): allow multiple threads to access the database. This is only relevant when using [worker threads](https://nodejs.org/api/worker_threads.html).
+
+It also has the following options for advanced performance tuning, only to be modified if you can prove actual benefit for your particular application.
+
+<details>
+<summary>Click to expand</summary>
+
+- `compression` (boolean, default: `true`): Unless set to `false`, all _compressible_ data will be run through the Snappy compression algorithm before being stored. Snappy is very fast so leave this on unless you have good reason to turn it off.
+
+- `cacheSize` (number, default: `8 * 1024 * 1024`): The size (in bytes) of the in-memory [LRU](http://en.wikipedia.org/wiki/Least_Recently_Used) cache with frequently used uncompressed block contents.
+
+- `writeBufferSize` (number, default: `4 * 1024 * 1024`): The maximum size (in bytes) of the log (in memory and stored in the `.log` file on disk). Beyond this size, LevelDB will convert the log data to the first level of sorted table files. From LevelDB documentation:
+
+  > Larger values increase performance, especially during bulk loads. Up to two write buffers may be held in memory at the same time, so you may wish to adjust this parameter to control memory usage. Also, a larger write buffer will result in a longer recovery time the next time the database is opened.
+
+- `blockSize` (number, default: `4096`): The _approximate_ size of the blocks that make up the table files. The size relates to uncompressed data (hence "approximate"). Blocks are indexed in the table file and entry-lookups involve reading an entire block and parsing to discover the required entry.
+
+- `maxOpenFiles` (number, default: `1000`): The maximum number of files that LevelDB is allowed to have open at a time. If your database is likely to have a large working set, you may increase this value to prevent file descriptor churn. To calculate the number of files required for your working set, divide your total data size by `maxFileSize`.
+
+- `blockRestartInterval` (number, default: `16`): The number of entries before restarting the "delta encoding" of keys within blocks. Each "restart" point stores the full key for the entry, between restarts, the common prefix of the keys for those entries is omitted. Restarts are similar to the concept of keyframes in video encoding and are used to minimise the amount of space required to store keys. This is particularly helpful when using deep namespacing / prefixing in your keys.
+
+- `maxFileSize` (number, default: `2 * 1024 * 1024`): The maximum amount of bytes to write to a file before switching to a new one. From LevelDB documentation:
+
+  > If your filesystem is more efficient with larger files, you could consider increasing the value. The downside will be longer compactions and hence longer latency / performance hiccups. Another reason to increase this parameter might be when you are initially populating a large database.
+
+</details>
+
+### Closing
+
+The [`db.close()`](https://github.com/Level/abstract-level#dbclose) method has an additional behavior: it waits for any pending operations to finish before closing. For example:
+
+```js
+// close() will wait for the put() to finish.
+const promise1 = db.put('key', 'value')
+const promise2 = db.close()
+```
+
+### Reading
+
+The [`db.get(key[, options])`](https://github.com/Level/abstract-level#dbgetkey-options), [`db.getMany(keys[, options])`](https://github.com/Level/abstract-level#dbgetmanykeys-options) and [`db.iterator([options])`](https://github.com/Level/abstract-level#iterator--dbiteratoroptions) methods have an additional option:
+
+- `fillCache` (boolean, default: `true`): unless set to `false`, LevelDB will fill its in-memory [LRU](http://en.wikipedia.org/wiki/Least_Recently_Used) cache with data that was read.
+
+A `classic-level` database supports snapshots (as indicated by [`db.supports.snapshots`](https://github.com/Level/supports#snapshots-boolean)) which means `db.get()`, `db.getMany()` and `db.iterator()` read from a snapshot of the database, created synchronously at the time that `db.get()`, `db.getMany()` or `db.iterator()` was called. This means they will not see the data of simultaneous write operations, commonly referred to as having _snapshot guarantees_.
+
+The [`db.iterator([options])`](https://github.com/Level/abstract-level#iterator--dbiteratoroptions) method also accepts:
+
+- `highWaterMarkBytes` (number, default: `16 * 1024`): limit the amount of data that the iterator will hold in memory.
+
+While [`iterator.nextv(size)`](https://github.com/Level/abstract-level#iteratornextvsize-options) is reading entries from LevelDB into memory, it sums up the byte length of those entries. If and when that sum has exceeded `highWaterMarkBytes`, reading will stop. If `nextv(2)` would normally yield two entries but the first entry is too large, then only one entry will be yielded. More `nextv(size)` calls must then be made to get the remaining entries.
+
+If memory usage is less of a concern, increasing `highWaterMarkBytes` can increase the throughput of `nextv(size)`. If set to `0` then `nextv(size)` will never yield more than one entry, as `highWaterMarkBytes` will be exceeded on each call. It can not be set to `Infinity`. On key- and value iterators (see below) it applies to the byte length of keys or values respectively, rather than the combined byte length of keys _and_ values.
+
+Optimal performance can be achieved by setting `highWaterMarkBytes` to at least `size` multiplied by the expected byte length of an entry, ensuring that `size` is always met. In other words, that `nextv(size)` will not stop reading before `size` amount of entries have been read into memory. If the iterator is wrapped in a [Node.js stream](https://github.com/Level/read-stream) or [Web Stream](https://github.com/Level/web-stream) then the `size` parameter is dictated by the stream's `highWaterMark` option. For example:
+
+```js
+const { EntryStream } = require('level-read-stream')
+
+// If an entry is 50 bytes on average
+const stream = new EntryStream(db, {
+  highWaterMark: 1000,
+  highWaterMarkBytes: 1000 * 50
+})
+```
+
+Side note: the "watermark" analogy makes more sense in Node.js streams because its internal `highWaterMark` can grow, indicating the highest that the "water" has been. In a `classic-level` iterator however, `highWaterMarkBytes` is fixed once set. Getting exceeded does not change it.
+
+The `highWaterMarkBytes` option is also applied to an internal cache that `classic-level` employs for [`next()`](https://github.com/Level/abstract-level#iteratornext) and [`for await...of`](https://github.com/Level/abstract-level#for-awaitof-iterator). When `next()` is called, that cache is populated with at most 1000 entries, or less than that if `highWaterMarkBytes` is exceeded by the total byte length of entries. To avoid reading too eagerly, the cache is not populated on the first `next()` call, or the first `next()` call after a `seek()`. Only on subsequent `next()` calls.
+
+### Writing
+
+The [`db.put(key, value[, options])`](https://github.com/Level/abstract-level#dbputkey-value-options), [`db.del(key[, options])`](https://github.com/Level/abstract-level#dbdelkey-options) and [`db.batch(operations[, options])`](https://github.com/Level/abstract-level#dbbatchoperations-options) and [`chainedBatch.write([options])`](https://github.com/Level/abstract-level#chainedbatchwriteoptions) methods have an additional option:
+
+- `sync` (boolean, default: `false`): if set to `true`, LevelDB will perform a synchronous write of the data although the operation will be asynchronous as far as Node.js or Electron is concerned. Normally, LevelDB passes the data to the operating system for writing and returns immediately. In contrast, a synchronous write will use [`fsync()`](https://man7.org/linux/man-pages/man2/fsync.2.html) or equivalent, so the write will not complete until the data is actually on disk. Synchronous writes are significantly slower than asynchronous writes.
+
+### Additional Methods
+
+The following methods and properties are not part of the [`abstract-level`](https://github.com/Level/abstract-level) interface.
+
+#### `db.location`
+
+Read-only getter that returns the `location` string that was passed to the constructor (as-is).
+
+#### `db.approximateSize(start, end[, options])`
+
+Get the approximate number of bytes of file system space used by the range `[start..end)`. The result might not include recently written data. The optional `options` object may contain:
+
+- `keyEncoding`: custom key encoding for this operation, used to encode `start` and `end`.
+
+Returns a promise for a number.
+
+#### `db.compactRange(start, end[, options])`
+
+Manually trigger a database compaction in the range `[start..end]`. The optional `options` object may contain:
+
+- `keyEncoding`: custom key encoding for this operation, used to encode `start` and `end`.
+
+Returns a promise.
+
+#### `db.getProperty(property)`
+
+Get internal details from LevelDB. When issued with a valid `property` string, a string value is returned synchronously. Valid properties are:
+
+- `leveldb.num-files-at-levelN`: return the number of files at level _N_, where N is an integer representing a valid level (e.g. "0").
+- `leveldb.stats`: returns a multi-line string describing statistics about LevelDB's internal operation.
+- `leveldb.sstables`: returns a multi-line string describing all of the _sstables_ that make up contents of the current database.
+
+#### `ClassicLevel.destroy(location)`
+
+Completely remove an existing LevelDB database directory. You can use this method in place of a full directory removal if you want to be sure to only remove LevelDB-related files. If the directory only contains LevelDB files, the directory itself will be removed as well. If there are additional, non-LevelDB files in the directory, those files and the directory will be left alone.
+
+Returns a promise for the completion of the destroy operation.
+
+Before calling `destroy()`, close a database if it's using the same `location`:
+
+```js
+const db = new ClassicLevel('./db')
+await db.close()
+await ClassicLevel.destroy('./db')
+```
+
+#### `ClassicLevel.repair(location)`
+
+Attempt a restoration of a damaged database. It can also be used to perform a compaction of the LevelDB log into table files. From LevelDB documentation:
+
+> If a DB cannot be opened, you may attempt to call this method to resurrect as much of the contents of the database as possible. Some data may be lost, so be careful when calling this function on a database that contains important information.
+
+Returns a promise for the completion of the repair operation.
+
+You will find information on the repair operation in the `LOG` file inside the database directory.
+
+Before calling `repair()`, close a database if it's using the same `location`.
+
+## Development
+
+### Getting Started
+
+This repository uses git submodules. Clone it recursively:
+
+```bash
+git clone --recurse-submodules https://github.com/Level/classic-level.git
+```
+
+Alternatively, initialize submodules inside the working tree:
+
+```bash
+cd classic-level
+git submodule update --init --recursive
+```
+
+### Contributing
+
+[`Level/classic-level`](https://github.com/Level/classic-level) 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.
+
+### Publishing
+
+1. Increment the version: `npm version ..`
+2. Push to GitHub: `git push --follow-tags`
+3. Wait for CI to complete
+4. Download prebuilds into `./prebuilds`: `npm run download-prebuilds`
+5. Optionally verify loading a prebuild: `npm run test-prebuild`
+6. Optionally verify which files npm will include: `canadian-pub`
+7. Finally: `npm publish`
+
+## 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

package/node_modules/classic-level/UPGRADING.md

@@ -0,0 +1,131 @@
+# 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).
+
+## 3.0.0
+
+This release upgrades to `abstract-level` 3. Please see its [upgrade guide](https://github.com/Level/abstract-level/blob/v3.0.0/UPGRADING.md). Note that `classic-level` already dropped support of Node.js 16. The only relevant breaking change is the removal of `put`, `del` & `batch` events.
+
+## 2.0.0
+
+This release upgrades to `abstract-level` 2.0.0 which adds [hooks](https://github.com/Level/abstract-level#hooks) and drops callbacks, not-found errors and support of Node.js < 16. Please refer to the [upgrade guide of `abstract-level`](https://github.com/Level/abstract-level/blob/v2.0.0/UPGRADING.md). The only thing to add is that `classic-level` also drops Node.js 16 and Electron < 30, and that the additional methods of `classic-level` like `db.approximateSize()` similarly don't support callbacks anymore.
+
+## 1.0.0
+
+**Introducing `classic-level`: a fork of [`leveldown`](https://github.com/Level/leveldown) that implements the [`abstract-level`](https://github.com/Level/abstract-level) interface instead of [`abstract-leveldown`](https://github.com/Level/abstract-leveldown). It thus has the same API as `level` and `levelup` including encodings, promises and events. In addition, you can now choose to use Uint8Array instead of Buffer. Sublevels are builtin.**
+
+We've put together several upgrade guides for different modules. See the [FAQ](https://github.com/Level/community#faq) to find the best upgrade guide for you. This one describes how to replace `leveldown` with `classic-level`. There will be a separate guide for upgrading `level`.
+
+Support of Node.js 10 has been dropped.
+
+### What is not covered here
+
+If you are using any of the following, please also read the upgrade guide of [`abstract-level@1`](https://github.com/Level/abstract-level/blob/main/UPGRADING.md#100) which goes into more detail about these:
+
+- Specific error messages (replaced with error codes)
+- The `db.iterator().end()` method (renamed to `close()`, with `end()` as an alias)
+- Zero-length keys and range options (now valid)
+- The `db.supports.bufferKeys` property.
+
+### Changes to initialization
+
+We started using classes, which means using `new` is now required. If you previously did:
+
+```js
+const leveldown = require('leveldown')
+const db = leveldown('./db')
+```
+
+You must now do:
+
+```js
+const { ClassicLevel } = require('classic-level')
+const db = new ClassicLevel('./db')
+```
+
+Because `abstract-level` does not require calling `db.open()` before other methods (a feature known as deferred open) it is now preferred to pass options to the constructor. For example:
+
+```js
+const db = new ClassicLevel('./db', {
+  createIfMissing: false,
+  compression: false
+})
+```
+
+If `db.open(options)` is called manually those options will be shallowly merged with options from the constructor:
+
+```js
+// Results in { createIfMissing: false, compression: true }
+await db.open({ compression: true })
+```
+
+This means that if you were using this `db.open(options)` pattern, it works as before, except if you were _also_ wrapping `leveldown` with `levelup` _and_ passing options to the `levelup` constructor. Because `levelup` would overwrite rather than merge options.
+
+### There is only encodings
+
+The `asBuffer`, `valueAsBuffer` and `keyAsBuffer` options have been replaced with encoding options. The default encoding is `'utf8'` which means operations return strings rather than Buffers by default. If you previously did:
+
+```js
+db.get('example', { asBuffer: false }, callback)
+db.get('example', callback)
+```
+
+You must now do:
+
+```js
+db.get('example', callback)
+db.get('example', { valueEncoding: 'buffer' }, callback)
+```
+
+Or using promises (new):
+
+```js
+const str = await db.get('example')
+const buf = await db.get('example', { valueEncoding: 'buffer' })
+```
+
+Or using Uint8Array (new):
+
+```js
+const arr = await db.get('example', { valueEncoding: 'view' })
+```
+
+### Unwrapping the onion
+
+If you were wrapping `leveldown` with `levelup`, `encoding-down` and / or `subleveldown`, remove those modules. If you previously did:
+
+```js
+const leveldown = require('leveldown')
+const levelup = require('levelup')
+const enc = require('encoding-down')
+const subleveldown = require('subleveldown')
+
+const db = levelup(enc(leveldown('./db')))
+const sublevel = subleveldown(db, 'foo')
+```
+
+You must now do:
+
+```js
+const { ClassicLevel } = require('classic-level')
+const db = new ClassicLevel('./db')
+const sublevel = db.sublevel('foo')
+```
+
+### Changes to iterators
+
+- The `highWaterMark` option has been renamed to `highWaterMarkBytes` to remove a conflict with streams. Please see the README for details on this (previously undocumented) option.
+- On iterators with `{ keys: false }` or `{ values: false }` options, the key or value is now `undefined` rather than an empty string (this was only the case in `leveldown`).
+- The `iterator.cache` and `iterator.finished` properties are no longer accessible. If you were using these then you'll want to checkout the new `nextv()` method in the README.
+
+### Sugar on additional methods
+
+The additional methods `db.approximateSize()` and `db.compactRange()` now support the same patterns as other methods:
+
+- Support of encoding options
+- Deferred open (no need to call `db.open()` before these methods)
+- Returning a promise if no callback is provided.
+
+---
+
+_For earlier releases, before `classic-level` was forked from `leveldown` (v6.1.0), please see [the upgrade guide of `leveldown`](https://github.com/Level/leveldown/blob/HEAD/UPGRADING.md)._