@machhub-dev/node-red-nodes 1.0.5

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/buffer-from/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016, 2018 Linus Unnebäck
+
+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/buffer-from/index.js

@@ -0,0 +1,72 @@
+/* eslint-disable node/no-deprecated-api */
+
+var toString = Object.prototype.toString
+
+var isModern = (
+  typeof Buffer !== 'undefined' &&
+  typeof Buffer.alloc === 'function' &&
+  typeof Buffer.allocUnsafe === 'function' &&
+  typeof Buffer.from === 'function'
+)
+
+function isArrayBuffer (input) {
+  return toString.call(input).slice(8, -1) === 'ArrayBuffer'
+}
+
+function fromArrayBuffer (obj, byteOffset, length) {
+  byteOffset >>>= 0
+
+  var maxLength = obj.byteLength - byteOffset
+
+  if (maxLength < 0) {
+    throw new RangeError("'offset' is out of bounds")
+  }
+
+  if (length === undefined) {
+    length = maxLength
+  } else {
+    length >>>= 0
+
+    if (length > maxLength) {
+      throw new RangeError("'length' is out of bounds")
+    }
+  }
+
+  return isModern
+    ? Buffer.from(obj.slice(byteOffset, byteOffset + length))
+    : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)))
+}
+
+function fromString (string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8'
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('"encoding" must be a valid string encoding')
+  }
+
+  return isModern
+    ? Buffer.from(string, encoding)
+    : new Buffer(string, encoding)
+}
+
+function bufferFrom (value, encodingOrOffset, length) {
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number')
+  }
+
+  if (isArrayBuffer(value)) {
+    return fromArrayBuffer(value, encodingOrOffset, length)
+  }
+
+  if (typeof value === 'string') {
+    return fromString(value, encodingOrOffset)
+  }
+
+  return isModern
+    ? Buffer.from(value)
+    : new Buffer(value)
+}
+
+module.exports = bufferFrom

package/node_modules/buffer-from/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "buffer-from",
+  "version": "1.1.2",
+  "license": "MIT",
+  "repository": "LinusU/buffer-from",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "test": "standard && node test"
+  },
+  "devDependencies": {
+    "standard": "^12.0.1"
+  },
+  "keywords": [
+    "buffer",
+    "buffer from"
+  ]
+}

package/node_modules/buffer-from/readme.md

@@ -0,0 +1,69 @@
+# Buffer From
+
+A [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.
+
+## Installation
+
+```sh
+npm install --save buffer-from
+```
+
+## Usage
+
+```js
+const bufferFrom = require('buffer-from')
+
+console.log(bufferFrom([1, 2, 3, 4]))
+//=> <Buffer 01 02 03 04>
+
+const arr = new Uint8Array([1, 2, 3, 4])
+console.log(bufferFrom(arr.buffer, 1, 2))
+//=> <Buffer 02 03>
+
+console.log(bufferFrom('test', 'utf8'))
+//=> <Buffer 74 65 73 74>
+
+const buf = bufferFrom('test')
+console.log(bufferFrom(buf))
+//=> <Buffer 74 65 73 74>
+```
+
+## API
+
+### bufferFrom(array)
+
+- `array` &lt;Array&gt;
+
+Allocates a new `Buffer` using an `array` of octets.
+
+### bufferFrom(arrayBuffer[, byteOffset[, length]])
+
+- `arrayBuffer` &lt;ArrayBuffer&gt; The `.buffer` property of a TypedArray or ArrayBuffer
+- `byteOffset` &lt;Integer&gt; Where to start copying from `arrayBuffer`. **Default:** `0`
+- `length` &lt;Integer&gt; How many bytes to copy from `arrayBuffer`. **Default:** `arrayBuffer.length - byteOffset`
+
+When passed a reference to the `.buffer` property of a TypedArray instance, the
+newly created `Buffer` will share the same allocated memory as the TypedArray.
+
+The optional `byteOffset` and `length` arguments specify a memory range within
+the `arrayBuffer` that will be shared by the `Buffer`.
+
+### bufferFrom(buffer)
+
+- `buffer` &lt;Buffer&gt; An existing `Buffer` to copy data from
+
+Copies the passed `buffer` data onto a new `Buffer` instance.
+
+### bufferFrom(string[, encoding])
+
+- `string` &lt;String&gt; A string to encode.
+- `encoding` &lt;String&gt; The encoding of `string`. **Default:** `'utf8'`
+
+Creates a new `Buffer` containing the given JavaScript string `string`. If
+provided, the `encoding` parameter identifies the character encoding of
+`string`.
+
+## See also
+
+- [buffer-alloc](https://github.com/LinusU/buffer-alloc) A ponyfill for `Buffer.alloc`
+- [buffer-alloc-unsafe](https://github.com/LinusU/buffer-alloc-unsafe) A ponyfill for `Buffer.allocUnsafe`

package/node_modules/commist/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: ci
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x, 16.x, 18.x]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install
+        run: |
+          npm install
+
+      - name: Run tests
+        run: |
+          npm run test

package/node_modules/commist/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2022 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/commist/README.md

@@ -0,0 +1,113 @@
+commist
+=======
+
+Build command line application with multiple commands the easy way.
+To be used with [minimist](http://npm.im/minimist).
+
+```js
+'use strict'
+
+const program = require('commist')()
+const result = program
+  .register('abcd', function(args) {
+    console.log('just do', args)
+  })
+  .register({ command: 'restore', equals: true }, function(args) {
+    console.log('restore', args)
+  })
+  .register('args', function(args) {
+    args = minimist(args)
+    console.log('just do', args)
+  })
+  .register('abcde code', function(args) {
+    console.log('doing something', args)
+  })
+  .register('another command', function(args) {
+    console.log('anothering', args)
+  })
+  .parse(process.argv.splice(2))
+
+if (result) {
+  console.log('no command called, args', result)
+}
+```
+
+To handle `async` operations, use `parseAsync` instead,
+which let you await on registered commands execution.
+
+```js
+'use strict'
+
+const program = require('commist')()
+
+const result = await program
+  .register('abcd', async function(args) {
+    await executeCommand(args)
+    await doOtherStuff()
+  })
+  .parseAsync(process.argv.splice(2))
+
+if (result) {
+  console.log('no command called, args', result)
+}
+```
+
+When calling _commist_ programs, you can abbreviate down to three char
+words. In the above example, these are valid commands:
+
+```
+node example.js abc
+node example.js abc cod
+node example.js anot comm
+```
+
+Moreover, little spelling mistakes are corrected too:
+
+```
+node example.js abcs cod
+```
+
+If you want that the command must be strict equals, you can register the
+command with the json configuration:
+
+```js
+  program.register({ command: 'restore', strict: true }, function(args) {
+    console.log('restore', args)
+  })
+```
+
+If you want to limit the maximum levenshtein distance of your commands,
+you can use `maxDistance: 2`:
+
+```js
+const program = require('commist')()
+const minimist = require('minimist')
+
+const result = program
+  .register('abcd', function(args) {
+    console.log('just do', args)
+  })
+  .register({ command: 'restore', equals: true }, function(args) {
+    console.log('restore', args)
+  })
+  .register('args', function(args) {
+    args = minimist(args)
+    console.log('just do', args)
+  })
+  .register('abcde code', function(args) {
+    console.log('doing something', args)
+  })
+  .register('another command', function(args) {
+    console.log('anothering', args)
+  })
+  .parse(process.argv.splice(2))
+
+if (result) {
+  console.log('no command called, args', result)
+}
+```
+
+License
+-------
+
+MIT

package/node_modules/commist/example.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const program = require('./')()
+const minimist = require('minimist')
+const result = program
+  .register('abcd', function (args) {
+    console.log('just do', args)
+  })
+  .register({ command: 'restore', strict: true }, function (args) {
+    console.log('restore', args)
+  })
+  .register('args', function (args) {
+    args = minimist(args)
+    console.log('just do', args)
+  })
+  .register('abcde code', function (args) {
+    console.log('doing something', args)
+  })
+  .register('another command', function (args) {
+    console.log('anothering', args)
+  })
+  .parse(process.argv.splice(2))
+
+if (result) {
+  console.log('no command called, args', result)
+}

package/node_modules/commist/index.js

@@ -0,0 +1,155 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2014-2022 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.
+*/
+
+'use strict'
+
+const leven = require('./leven')
+
+function commist (opts) {
+  opts = opts || {}
+  const commands = []
+  const maxDistance = opts.maxDistance || Infinity
+
+  function lookup (array) {
+    if (typeof array === 'string') { array = array.split(' ') }
+
+    let res = commands.map(function (cmd) {
+      return cmd.match(array)
+    })
+
+    res = res.filter(function (match) {
+      if (match.partsNotMatched !== 0) {
+        return false
+      }
+      return match.distances.reduce(function (acc, curr) {
+        return acc && curr <= maxDistance
+      }, true)
+    })
+
+    res = res.sort(function (a, b) {
+      if (a.inputNotMatched > b.inputNotMatched) { return 1 }
+
+      if (a.inputNotMatched === b.inputNotMatched && a.totalDistance > b.totalDistance) { return 1 }
+
+      return -1
+    })
+
+    res = res.map(function (match) {
+      return match.cmd
+    })
+
+    return res
+  }
+
+  function parse (args) {
+    const matching = lookup(args)
+
+    if (matching.length > 0) {
+      matching[0].call(args)
+
+      // return null to indicate there is nothing left to do
+      return null
+    }
+
+    return args
+  }
+
+  async function parseAsync (args) {
+    const matching = lookup(args)
+
+    if (matching.length > 0) {
+      await matching[0].call(args)
+      // return null to indicate there is nothing left to do
+      return null
+    }
+
+    return args
+  }
+
+  function register (inputCommand, func) {
+    let commandOptions = {
+      command: inputCommand,
+      strict: false,
+      func
+    }
+
+    if (typeof inputCommand === 'object') {
+      commandOptions = Object.assign(commandOptions, inputCommand)
+    }
+
+    const matching = lookup(commandOptions.command)
+
+    matching.forEach(function (match) {
+      if (match.string === commandOptions.command) { throw new Error('command already registered: ' + commandOptions.command) }
+    })
+
+    commands.push(new Command(commandOptions))
+
+    return this
+  }
+
+  return {
+    register,
+    parse,
+    parseAsync,
+    lookup
+  }
+}
+
+function Command (options) {
+  this.string = options.command
+  this.strict = options.strict
+  this.parts = this.string.split(' ')
+  this.length = this.parts.length
+  this.func = options.func
+}
+
+Command.prototype.call = function call (argv) {
+  return this.func(argv.slice(this.length))
+}
+
+Command.prototype.match = function match (string) {
+  return new CommandMatch(this, string)
+}
+
+function CommandMatch (cmd, array) {
+  this.cmd = cmd
+  this.distances = cmd.parts.map(function (elem, i) {
+    if (array[i] !== undefined) {
+      if (cmd.strict) {
+        return elem === array[i] ? 0 : undefined
+      } else {
+        return leven(elem, array[i])
+      }
+    } else { return undefined }
+  }).filter(function (distance, i) {
+    return distance !== undefined && distance < cmd.parts[i].length
+  })
+
+  this.partsNotMatched = cmd.length - this.distances.length
+  this.inputNotMatched = array.length - this.distances.length
+  this.totalDistance = this.distances.reduce(function (acc, i) { return acc + i }, 0)
+}
+
+module.exports = commist