@meridiona/meridian-darwin-arm64 1.0.0

package/ui/ui/node_modules/shimmer/index.js

@@ -0,0 +1,121 @@
+'use strict'
+
+function isFunction (funktion) {
+  return typeof funktion === 'function'
+}
+
+// Default to complaining loudly when things don't go according to plan.
+var logger = console.error.bind(console)
+
+// Sets a property on an object, preserving its enumerability.
+// This function assumes that the property is already writable.
+function defineProperty (obj, name, value) {
+  var enumerable = !!obj[name] && obj.propertyIsEnumerable(name)
+  Object.defineProperty(obj, name, {
+    configurable: true,
+    enumerable: enumerable,
+    writable: true,
+    value: value
+  })
+}
+
+// Keep initialization idempotent.
+function shimmer (options) {
+  if (options && options.logger) {
+    if (!isFunction(options.logger)) logger("new logger isn't a function, not replacing")
+    else logger = options.logger
+  }
+}
+
+function wrap (nodule, name, wrapper) {
+  if (!nodule || !nodule[name]) {
+    logger('no original function ' + name + ' to wrap')
+    return
+  }
+
+  if (!wrapper) {
+    logger('no wrapper function')
+    logger((new Error()).stack)
+    return
+  }
+
+  if (!isFunction(nodule[name]) || !isFunction(wrapper)) {
+    logger('original object and wrapper must be functions')
+    return
+  }
+
+  var original = nodule[name]
+  var wrapped = wrapper(original, name)
+
+  defineProperty(wrapped, '__original', original)
+  defineProperty(wrapped, '__unwrap', function () {
+    if (nodule[name] === wrapped) defineProperty(nodule, name, original)
+  })
+  defineProperty(wrapped, '__wrapped', true)
+
+  defineProperty(nodule, name, wrapped)
+  return wrapped
+}
+
+function massWrap (nodules, names, wrapper) {
+  if (!nodules) {
+    logger('must provide one or more modules to patch')
+    logger((new Error()).stack)
+    return
+  } else if (!Array.isArray(nodules)) {
+    nodules = [nodules]
+  }
+
+  if (!(names && Array.isArray(names))) {
+    logger('must provide one or more functions to wrap on modules')
+    return
+  }
+
+  nodules.forEach(function (nodule) {
+    names.forEach(function (name) {
+      wrap(nodule, name, wrapper)
+    })
+  })
+}
+
+function unwrap (nodule, name) {
+  if (!nodule || !nodule[name]) {
+    logger('no function to unwrap.')
+    logger((new Error()).stack)
+    return
+  }
+
+  if (!nodule[name].__unwrap) {
+    logger('no original to unwrap to -- has ' + name + ' already been unwrapped?')
+  } else {
+    return nodule[name].__unwrap()
+  }
+}
+
+function massUnwrap (nodules, names) {
+  if (!nodules) {
+    logger('must provide one or more modules to patch')
+    logger((new Error()).stack)
+    return
+  } else if (!Array.isArray(nodules)) {
+    nodules = [nodules]
+  }
+
+  if (!(names && Array.isArray(names))) {
+    logger('must provide one or more functions to unwrap on modules')
+    return
+  }
+
+  nodules.forEach(function (nodule) {
+    names.forEach(function (name) {
+      unwrap(nodule, name)
+    })
+  })
+}
+
+shimmer.wrap = wrap
+shimmer.massWrap = massWrap
+shimmer.unwrap = unwrap
+shimmer.massUnwrap = massUnwrap
+
+module.exports = shimmer

package/ui/ui/node_modules/shimmer/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "shimmer",
+  "version": "1.2.1",
+  "description": "Safe(r) monkeypatching for JavaScript.",
+  "main": "index.js",
+  "scripts": {
+    "test": "standard && tap test/*.tap.js --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/othiym23/shimmer.git"
+  },
+  "keywords": [
+    "monkeypatch",
+    "swizzle",
+    "wrapping",
+    "danger",
+    "hmm",
+    "shim"
+  ],
+  "author": "Forrest L Norvell <ogd@aoaioxxysz.net>",
+  "license": "BSD-2-Clause",
+  "devDependencies": {
+    "sinon": "^7.2.2",
+    "standard": "^12.0.1",
+    "tap": "^12.1.1"
+  }
+}

package/ui/ui/node_modules/sonic-boom/LICENSE

@@ -0,0 +1,21 @@
+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/ui/ui/node_modules/sonic-boom/README.md

@@ -0,0 +1,153 @@
+# 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/ui/ui/node_modules/sonic-boom/bench.js

@@ -0,0 +1,98 @@
+'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/ui/ui/node_modules/sonic-boom/check.js

@@ -0,0 +1,18 @@
+'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/ui/ui/node_modules/sonic-boom/example.js

@@ -0,0 +1,8 @@
+'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/ui/ui/node_modules/sonic-boom/fixtures/firehose.js

@@ -0,0 +1,22 @@
+'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()