@farthershore/cli 0.3.10 → 0.3.12

package/node_modules/safe-stable-stringify/readme.md

@@ -1,179 +0,0 @@
-# safe-stable-stringify
-
-Safe, deterministic and fast serialization alternative to [JSON.stringify][].
-Zero dependencies. ESM and CJS. 100% coverage.
-
-Gracefully handles circular structures and bigint instead of throwing.
-
-Optional custom circular values, deterministic behavior or strict JSON
-compatibility check.
-
-## stringify(value[, replacer[, space]])
-
-The same as [JSON.stringify][].
-
-* `value` {any}
-* `replacer` {string[]|function|null}
-* `space` {number|string}
-* Returns: {string}
-
-```js
-const stringify = require('safe-stable-stringify')
-
-const bigint = { a: 0, c: 2n, b: 1 }
-
-stringify(bigint)
-// '{"a":0,"b":1,"c":2}'
-JSON.stringify(bigint)
-// TypeError: Do not know how to serialize a BigInt
-
-const circular = { b: 1, a: 0 }
-circular.circular = circular
-
-stringify(circular)
-// '{"a":0,"b":1,"circular":"[Circular]"}'
-JSON.stringify(circular)
-// TypeError: Converting circular structure to JSON
-
-stringify(circular, ['a', 'b'], 2)
-// {
-//   "a": 0,
-//   "b": 1
-// }
-```
-
-## stringify.configure(options)
-
-* `bigint` {boolean} If `true`, bigint values are converted to a number. Otherwise
-  they are ignored. **Default:** `true`.
-* `circularValue` {string|null|undefined|ErrorConstructor} Defines the value for
-  circular references. Set to `undefined`, circular properties are not
-  serialized (array entries are replaced with `null`). Set to `Error`, to throw
-  on circular references. **Default:** `'[Circular]'`.
-* `deterministic` {boolean|function} If `true` or a `Array#sort(comparator)`
-  comparator method, guarantee a deterministic key order instead of relying on
-  the insertion order. **Default:** `true`.
-* `maximumBreadth` {number} Maximum number of entries to serialize per object
-  (at least one). The serialized output contains information about how many
-  entries have not been serialized. Ignored properties are counted as well
-  (e.g., properties with symbol values). Using the array replacer overrules this
-  option. **Default:** `Infinity`
-* `maximumDepth` {number} Maximum number of object nesting levels (at least 1)
-  that will be serialized. Objects at the maximum level are serialized as
-  `'[Object]'` and arrays as `'[Array]'`. **Default:** `Infinity`
-* `strict` {boolean} Instead of handling any JSON value gracefully, throw an
-  error in case it may not be represented as JSON (functions, NaN, ...).
-  Circular values and bigint values throw as well in case either option is not
-  explicitly defined. Sets and Maps are not detected as well as Symbol keys!
-  **Default:** `false`
-* Returns: {function} A stringify function with the options applied.
-
-```js
-import { configure } from 'safe-stable-stringify'
-
-const stringify = configure({
-  bigint: true,
-  circularValue: 'Magic circle!',
-  deterministic: false,
-  maximumDepth: 1,
-  maximumBreadth: 4
-})
-
-const circular = {
-  bigint: 999_999_999_999_999_999n,
-  typed: new Uint8Array(3),
-  deterministic: "I don't think so",
-}
-circular.circular = circular
-circular.ignored = true
-circular.alsoIgnored = 'Yes!'
-
-const stringified = stringify(circular, null, 4)
-
-console.log(stringified)
-// {
-//     "bigint": 999999999999999999,
-//     "typed": "[Object]",
-//     "deterministic": "I don't think so",
-//     "circular": "Magic circle!",
-//     "...": "2 items not stringified"
-// }
-
-const throwOnCircular = configure({
-  circularValue: Error
-})
-
-throwOnCircular(circular);
-// TypeError: Converting circular structure to JSON
-```
-
-## Differences to JSON.stringify
-
-1. _Circular values_ are replaced with the string `[Circular]` (configurable).
-1. _Object keys_ are sorted instead of using the insertion order (configurable).
-1. _BigInt_ values are stringified as regular number instead of throwing a
-   TypeError (configurable).
-1. _Boxed primitives_ (e.g., `Number(5)`) are not unboxed and are handled as
-   regular object.
-
-Those are the only differences to `JSON.stringify()`. This is a side effect free
-variant and [`toJSON`][], [`replacer`][] and the [`spacer`][] work the same as
-with `JSON.stringify()`.
-
-## Performance / Benchmarks
-
-Currently this is by far the fastest known stable (deterministic) stringify
-implementation. This is especially important for big objects and TypedArrays.
-
-(Dell Precision 5540, i7-9850H CPU @ 2.60GHz, Node.js 16.11.1)
-
-```md
-simple:   simple object x 3,463,894 ops/sec ±0.44% (98 runs sampled)
-simple:   circular      x 1,236,007 ops/sec ±0.46% (99 runs sampled)
-simple:   deep          x 18,942 ops/sec ±0.41% (93 runs sampled)
-simple:   deep circular x 18,690 ops/sec ±0.72% (96 runs sampled)
-
-replacer:   simple object x 2,664,940 ops/sec ±0.31% (98 runs sampled)
-replacer:   circular      x 1,015,981 ops/sec ±0.09% (99 runs sampled)
-replacer:   deep          x 17,328 ops/sec ±0.38% (97 runs sampled)
-replacer:   deep circular x 17,071 ops/sec ±0.21% (98 runs sampled)
-
-array:   simple object x 3,869,608 ops/sec ±0.22% (98 runs sampled)
-array:   circular      x 3,853,943 ops/sec ±0.45% (96 runs sampled)
-array:   deep          x 3,563,227 ops/sec ±0.20% (100 runs sampled)
-array:   deep circular x 3,286,475 ops/sec ±0.07% (100 runs sampled)
-
-indentation:   simple object x 2,183,162 ops/sec ±0.66% (97 runs sampled)
-indentation:   circular      x 872,538 ops/sec ±0.57% (98 runs sampled)
-indentation:   deep          x 16,795 ops/sec ±0.48% (93 runs sampled)
-indentation:   deep circular x 16,443 ops/sec ±0.40% (97 runs sampled)
-```
-
-Comparing `safe-stable-stringify` with known alternatives:
-
-```md
-fast-json-stable-stringify x 18,765 ops/sec ±0.71% (94 runs sampled)
-json-stable-stringify x 13,870 ops/sec ±0.72% (94 runs sampled)
-fast-stable-stringify x 21,343 ops/sec ±0.33% (95 runs sampled)
-faster-stable-stringify x 17,707 ops/sec ±0.44% (97 runs sampled)
-json-stringify-deterministic x 11,208 ops/sec ±0.57% (98 runs sampled)
-fast-safe-stringify x 21,460 ops/sec ±0.75% (99 runs sampled)
-this x 30,367 ops/sec ±0.39% (96 runs sampled)
-
-The fastest is this
-```
-
-The `fast-safe-stringify` comparison uses the modules stable implementation.
-
-## Acknowledgements
-
-Sponsored by [MaibornWolff](https://www.maibornwolff.de/) and [nearForm](http://nearform.com)
-
-## License
-
-MIT
-
-[`replacer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The%20replacer%20parameter
-[`spacer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The%20space%20argument
-[`toJSON`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#toJSON()_behavior
-[JSON.stringify]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify

package/node_modules/sonic-boom/.eslintignore

@@ -1,2 +0,0 @@
-types/index.d.ts
-types/index.test-d.ts

package/node_modules/sonic-boom/.taprc

@@ -1,3 +0,0 @@
-timeout: 240
-allow-incomplete-coverage: true
-reporter: terse

package/node_modules/sonic-boom/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Matteo Collina
-
-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/sonic-boom/README.md

@@ -1,153 +0,0 @@
-# sonic-boom
-
-[![NPM Package Version](https://img.shields.io/npm/v/sonic-boom)](https://www.npmjs.com/package/sonic-boom)
-[![Build Status](https://github.com/pinojs/sonic-boom/workflows/CI/badge.svg)](https://github.com/pinojs/sonic-boom/actions?query=workflow%3ACI)
-[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
-
-Extremely fast utf8-only stream implementation to write to files and
-file descriptors.
-
-This implementation is partial, but support backpressure and `.pipe()` in is here.
-However, it is 2-3x faster than Node Core `fs.createWriteStream()`:
-
-```
-benchSonic*1000: 1916.904ms
-benchSonicSync*1000: 8605.265ms
-benchSonic4k*1000: 1965.231ms
-benchSonicSync4k*1000: 1588.224ms
-benchCore*1000: 5851.959ms
-benchConsole*1000: 7605.713ms
-```
-
-Note that sync mode without buffering is _slower_ than a Node Core WritableStream, however
-this mode matches the expected behavior of `console.log()`.
-
-Note that if this is used to log to a windows terminal (`cmd.exe` or
-powershell), it is needed to run `chcp 65001` in the terminal to
-correctly display utf-8 characters, see
-[chcp](https://ss64.com/nt/chcp.html) for more details.
-
-## Install
-
-```
-npm i sonic-boom
-```
-
-## Example
-
-```js
-'use strict'
-
-const SonicBoom = require('sonic-boom')
-const sonic = new SonicBoom({ fd: process.stdout.fd }) // or { dest: '/path/to/destination' }
-
-for (let i = 0; i < 10; i++) {
-  sonic.write('hello sonic\n')
-}
-```
-
-## API
-
-### SonicBoom(opts)
-
-Creates a new instance of SonicBoom.
-
-The options are:
-
-* `fd`: a file descriptor, something that is returned by `fs.open` or
-   `fs.openSync`.
-* `dest`: a string that is a path to a file to be written to (mode controlled by the `append` option).
-* `minLength`: the minimum length of the internal buffer that is
-  required to be full before flushing.
-* `maxLength`: the maximum length of the internal buffer. If a write operation would cause the buffer
-  to exceed `maxLength`, the data written is dropped and a `drop` event is emitted with the dropped data
-* `maxWrite`: the maximum number of bytes that can be written; default: 16384
-* `periodicFlush`: calls `flush` every x`ms`.
-* `sync`: perform writes synchronously (similar to `console.log`).
-* `fsync`: perform a [fsyncSync](https://nodejs.org/api/fs.html#fsfsyncsyncfd) every time a write is completed.
-* `append`: appends writes to dest file instead of truncating it (default `true`).
-* `mode`: specify the creating file `mode` (see [fs.open()](https://nodejs.org/api/fs.html#fsopenpath-flags-mode-callback) from Node.js core).
-* `contentMode`: which type of data you can send to the `write` function, supported values are `utf8` or `buffer`. (default `utf8`)
-* `mkdir`: ensure directory for dest file exists when `true` (default `false`).
-* `retryEAGAIN(err, writeBufferLen, remainingBufferLen)`: a function that will be called when sonic-boom
-    write/writeSync/flushSync encounters a EAGAIN or EBUSY error. If the return value is
-    true sonic-boom will retry the operation, otherwise it will bubble the
-    error. `err` is the error that caused this function to be called,
-    `writeBufferLen` is the length of the buffer sonic-boom tried to write, and
-    `remainingBufferLen` is the length of the remaining buffer sonic-boom didn't try to write.
-
-For `sync:false`  a `SonicBoom` instance will emit the `'ready'` event when a file descriptor is available.
-For `sync:true` this is not relevant because the `'ready'` event will be fired when the `SonicBoom` instance is created, before it can be subscribed to.
-
-
-### SonicBoom#write(string)
-
-Writes the string to the file.
-It will return false to signal the producer to slow down.
-
-### SonicBoom#flush([cb])
-
-Writes the current buffer to the file if a write was not in progress.
-Do nothing if `minLength` is zero or if it is already writing.
-
-call the callback when the flush operation is completed. when failed the callback is called with an error.
-
-### SonicBoom#reopen([file])
-
-Reopen the file in place, useful for log rotation.
-
-Example:
-
-```js
-const stream = new SonicBoom('./my.log')
-process.on('SIGUSR2', function () {
-  stream.reopen()
-})
-```
-
-### SonicBoom#flushSync()
-
-Flushes the buffered data synchronously. This is a costly operation.
-
-### SonicBoom#end()
-
-Closes the stream, the data will be flushed down asynchronously
-
-### SonicBoom#destroy()
-
-Closes the stream immediately, the data is not flushed.
-
-### Events
-
-
-#### SonicBoom#close
-
-See [Stream#close](https://nodejs.org/api/stream.html#event-close). The `'close'` event when the instance has been closed.
-
-#### SonicBoom#drain
-
-See [Stream#drain](https://nodejs.org/api/stream.html#event-drain). The `'drain'` event is emitted when source can resume sending data.
-
-#### SonicBoom#drop <any>
-
-When destination file maximal length is reached, the `'drop'` event is emitted with data that could not be written. 
-
-#### SonicBoom#error <Error>
-
-The `'error'` event is emitted when the destination file can not be opened, or written.
-
-#### SonicBoom#finish
-
-See [Stream#finish](https://nodejs.org/api/stream.html#event-finish). The `'finish'` event after calling `end()` method and when all data was written.
-
-#### SonicBoom#ready
-
-The `'ready'` event occurs when the created instance is ready to process input.
-
-#### SonicBoom#write <number>
-
-The `'write'` event occurs every time data is written to the underlying file. It emits the number of written bytes.
-
-## License
-
-MIT

package/node_modules/sonic-boom/bench.js

@@ -1,98 +0,0 @@
-'use strict'
-
-const bench = require('fastbench')
-const SonicBoom = require('./')
-const Console = require('console').Console
-const fs = require('fs')
-
-const core = fs.createWriteStream('/dev/null')
-const fd = fs.openSync('/dev/null', 'w')
-const sonic = new SonicBoom({ fd })
-const sonic4k = new SonicBoom({ fd, minLength: 4096 })
-const sonicSync = new SonicBoom({ fd, sync: true })
-const sonicSync4k = new SonicBoom({ fd, minLength: 4096, sync: true })
-const sonicBuffer = new SonicBoom({ fd, contentMode: 'buffer' })
-const sonic4kBuffer = new SonicBoom({ fd, contentMode: 'buffer', minLength: 4096 })
-const sonicSyncBuffer = new SonicBoom({ fd, contentMode: 'buffer', sync: true })
-const sonicSync4kBuffer = new SonicBoom({ fd, contentMode: 'buffer', minLength: 4096, sync: true })
-const dummyConsole = new Console(fs.createWriteStream('/dev/null'))
-
-const MAX = 10000
-
-const buf = Buffer.alloc(50, 'hello', 'utf8')
-const str = buf.toString()
-
-setTimeout(doBench, 100)
-
-const run = bench([
-  function benchSonic (cb) {
-    sonic.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      sonic.write(str)
-    }
-  },
-  function benchSonicSync (cb) {
-    sonicSync.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      sonicSync.write(str)
-    }
-  },
-  function benchSonic4k (cb) {
-    sonic4k.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      sonic4k.write(str)
-    }
-  },
-  function benchSonicSync4k (cb) {
-    sonicSync4k.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      sonicSync4k.write(str)
-    }
-  },
-  function benchCore (cb) {
-    core.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      core.write(str)
-    }
-  },
-  function benchConsole (cb) {
-    for (let i = 0; i < MAX; i++) {
-      dummyConsole.log(str)
-    }
-    setImmediate(cb)
-  },
-  function benchSonicBuf (cb) {
-    sonicBuffer.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      sonicBuffer.write(buf)
-    }
-  },
-  function benchSonicSyncBuf (cb) {
-    sonicSyncBuffer.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      sonicSyncBuffer.write(buf)
-    }
-  },
-  function benchSonic4kBuf (cb) {
-    sonic4kBuffer.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      sonic4kBuffer.write(buf)
-    }
-  },
-  function benchSonicSync4kBuf (cb) {
-    sonicSync4kBuffer.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      sonicSync4kBuffer.write(buf)
-    }
-  },
-  function benchCoreBuf (cb) {
-    core.once('drain', cb)
-    for (let i = 0; i < MAX; i++) {
-      core.write(buf)
-    }
-  }
-], 1000)
-
-function doBench () {
-  run(run)
-}

package/node_modules/sonic-boom/check.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const SonicBoom = require('.')
-const sonic = new SonicBoom({ fd: process.stdout.fd })
-
-let count = 0
-function scheduleWrites () {
-  for (let i = 0; i < 1000; i++) {
-    sonic.write('hello sonic\n')
-    console.log('hello console')
-  }
-
-  if (++count < 10) {
-    setTimeout(scheduleWrites, 100)
-  }
-}
-
-scheduleWrites()

package/node_modules/sonic-boom/example.js

@@ -1,8 +0,0 @@
-'use strict'
-
-const SonicBoom = require('.')
-const sonic = new SonicBoom({ fd: process.stdout.fd }) // or 'destination'
-
-for (let i = 0; i < 10; i++) {
-  sonic.write('hello sonic\n')
-}

package/node_modules/sonic-boom/fixtures/firehose.js

@@ -1,22 +0,0 @@
-'use strict'
-
-const SonicBoom = require('..')
-
-const out = new SonicBoom({ fd: process.stdout.fd })
-const str = Buffer.alloc(1000).fill('a').toString()
-
-let i = 0
-
-function write () {
-  if (i++ === 10) {
-    return
-  }
-
-  if (out.write(str)) {
-    write()
-  } else {
-    out.once('drain', write)
-  }
-}
-
-write()