aurix-ai 2.7.3 → 2.7.4

package/native/token-counter/node_modules/enforce-range/node_modules/2/test.js

@@ -1,413 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const {toArray, toIterator, toMap, toNumber, toObject, toString} = require('.')
-
-describe('2', function () {
-  describe('#toArray()', function () {
-    it('should convert array to array', function () {
-      const array = []
-      assert.strictEqual(toArray(array), array)
-    })
-
-    it('should convert arguments object to array', function () {
-      const array = ['first', 'second']
-
-      function argumentsTest () {
-        const args = toArray(arguments)
-        assert(Array.isArray(args))
-        assert.strictEqual(JSON.stringify(args), JSON.stringify(array))
-      }
-
-      argumentsTest.apply(null, array)
-    })
-
-    it('should convert Map to array', function () {
-      const array = [['a', 'b']]
-      const map = new Map(array)
-      assert.strictEqual(JSON.stringify(toArray(map)), JSON.stringify(array))
-    })
-
-    it('should `detectIndexKeys` of array-like Map', function () {
-      const map = new Map([[0, 'a'], ['1', 'b']])
-      assert.strictEqual(JSON.stringify(toArray(map, {detectIndexKeys: true})), JSON.stringify(['a', 'b']))
-    })
-
-    it('should convert Set to array', function () {
-      const array = [1, 2, 3]
-      const set = new Set(array)
-      assert.strictEqual(JSON.stringify(toArray(set)), JSON.stringify(array))
-    })
-
-    it('should convert object to array of key/value pairs', function () {
-      const object = {a: 1, b: 2, c: 3}
-      const array = [['a', 1], ['b', 2], ['c', 3]]
-      assert.strictEqual(JSON.stringify(toArray(object)), JSON.stringify(array))
-    })
-
-    it('should `detectIndexKeys` of array-like object', function () {
-      const object = {0: 'a', 1: 'b'}
-      assert.strictEqual(JSON.stringify(toArray(object, {detectIndexKeys: true})), JSON.stringify(['a', 'b']))
-    })
-
-    it('should `detectIndexKeys` of array-like object with nonsequential keys', function () {
-      const object = {1: 'b', 0: 'a'}
-      assert.strictEqual(JSON.stringify(toArray(object, {detectIndexKeys: true})), JSON.stringify(['a', 'b']))
-    })
-
-    it('should convert primitive value to single-element array', function () {
-      assert.strictEqual(JSON.stringify(toArray('test')), JSON.stringify(['test']))
-    })
-
-    for (const value of [undefined, null, NaN]) { // eslint-disable-line no-undefined
-      it(`should convert ${value} to empty array`, function () {
-        assert.strictEqual(JSON.stringify(toArray(value)), JSON.stringify([]))
-      })
-    }
-  })
-
-  describe('#toIterator()', function () {
-    it('should convert primitive value to single-run iterator', function () {
-      const iterator = toIterator('test')
-      assert.strictEqual(typeof iterator, 'object')
-      assert.strictEqual(typeof iterator.next, 'function')
-      let r = iterator.next()
-      assert.notEqual(r.done, true)
-      assert.strictEqual(r.value, 'test')
-      r = iterator.next()
-      assert.strictEqual(r.done, true)
-    })
-
-    const valueTests = [
-      ['should convert array to iterator', [1, 2]],
-      ['should convert Set to iterator', new Set([1, 2])],
-    ]
-
-    for (const [description, object] of valueTests) {
-      it(description, function () {
-        const iterator = toIterator(object)
-        assert.strictEqual(typeof iterator, 'object')
-        assert.strictEqual(typeof iterator.next, 'function')
-        let r = iterator.next()
-        assert.notEqual(r.done, true)
-        assert.strictEqual(r.value, 1)
-        r = iterator.next()
-        assert.notEqual(r.done, true)
-        assert.strictEqual(r.value, 2)
-        r = iterator.next()
-        assert.strictEqual(r.done, true)
-      })
-    }
-
-    const keyValueTests = [
-      ['should convert Map to iterator', new Map([['a', 1], ['b', 2]])],
-      ['should convert object to iterator', {a: 1, b: 2}],
-    ]
-
-    for (const [description, object] of keyValueTests) {
-      it(description, function () {
-        const iterator = toIterator(object)
-        assert.strictEqual(typeof iterator, 'object')
-        assert.strictEqual(typeof iterator.next, 'function')
-        let r = iterator.next()
-        assert.notEqual(r.done, true)
-        assert(Array.isArray(r.value))
-        assert.strictEqual(r.value.length, 2)
-        assert.strictEqual(r.value[0], 'a')
-        assert.strictEqual(r.value[1], 1)
-        r = iterator.next()
-        assert.notEqual(r.done, true)
-        assert(Array.isArray(r.value))
-        assert.strictEqual(r.value.length, 2)
-        assert.strictEqual(r.value[0], 'b')
-        assert.strictEqual(r.value[1], 2)
-        r = iterator.next()
-        assert.strictEqual(r.done, true)
-      })
-    }
-
-    for (const value of [undefined, null, NaN]) { // eslint-disable-line no-undefined
-      it(`should convert ${value} to empty iterator`, function () {
-        const iterator = toIterator(value)
-        assert.strictEqual(typeof iterator, 'object')
-        const r = iterator.next()
-        assert.strictEqual(r.done, true)
-      })
-    }
-  })
-
-  describe('#toMap()', function () {
-    it('should convert Map to Map', function () {
-      assert(toMap(new Map()) instanceof Map)
-    })
-
-    it('should convert array of key/value pairs to Map', function () {
-      const map = toMap([['a', 1], ['b', 2]])
-      assert.strictEqual(map.get('a'), 1)
-      assert.strictEqual(map.get('b'), 2)
-    })
-
-    it('should convert values-only array to Map', function () {
-      const a = {}
-      const b = []
-      const map = toMap([a, b])
-      assert.strictEqual(map.get(0), a)
-      assert.strictEqual(map.get(1), b)
-    })
-
-    it('should `mirror` array across keys and values', function () {
-      const map = toMap(['100', 200], {mirror: true})
-      assert.strictEqual(map.get('100'), '100')
-      assert.strictEqual(map.get(200), 200)
-    })
-
-    it('should convert object to Map', function () {
-      const map = toMap({a: 1, b: 2})
-      assert.strictEqual(map.get('a'), 1)
-      assert.strictEqual(map.get('b'), 2)
-    })
-
-    it('should convert primitive value to empty Map', function () {
-      const map = toMap('not a map')
-      assert(map instanceof Map)
-      assert.strictEqual(map.size, 0)
-    })
-
-    it('should return the provided fallback if input is unconvertible', function () {
-      const map = toMap('not a map', {fallback: new Map([['a', 1], ['b', 2]])})
-      assert.strictEqual(map.get('a'), 1)
-      assert.strictEqual(map.get('b'), 2)
-    })
-
-    it('should throw error if input is unconvertible and fallback is not a Map', function () {
-      assert.throws(() => { toMap('not a map', {fallback: null}) }, TypeError)
-    })
-  })
-
-  describe('#toNumber()', function () {
-    it('should convert number to number', function () {
-      assert.strictEqual(toNumber(1), 1)
-    })
-
-    it('should convert Number object to number', function () {
-      assert.strictEqual(toNumber(new Number(1)), 1) // eslint-disable-line no-new-wrappers
-    })
-
-    it('should convert integer string to number', function () {
-      assert.strictEqual(toNumber('100'), 100)
-    })
-
-    it('should convert integer String object to number', function () {
-      assert.strictEqual(toNumber(new String('100')), 100) // eslint-disable-line no-new-wrappers
-    })
-
-    it('should convert float string to number', function () {
-      assert.strictEqual(toNumber('1.2'), 1.2)
-    })
-
-    it('should round float to integer if `round` is true', function () {
-      assert.strictEqual(toNumber(4.7, {round: true}), 5)
-    })
-
-    it('should return fallback (default 0) for Infinity', function () {
-      assert.strictEqual(toNumber(Infinity), 0)
-    })
-
-    it('should allow +Infinity if `finite` is false', function () {
-      assert.strictEqual(toNumber(Infinity, {finite: false}), Infinity)
-    })
-
-    it('should allow -Infinity if `finite` is false', function () {
-      assert.strictEqual(toNumber(-Infinity, {finite: false}), -Infinity)
-    })
-
-    it('should return fallback (default 0) for NaN', function () {
-      assert.strictEqual(toNumber(NaN), 0)
-    })
-
-    it('should return 0 if number is invalid and no fallback provided', function () {
-      assert.strictEqual(toNumber('not a number'), 0)
-    })
-
-    it('should return the provided fallback if number is invalid', function () {
-      assert.strictEqual(toNumber('not a number', {fallback: 2}), 2)
-    })
-
-    it('should round fallback if `round` is true', function () {
-      assert.strictEqual(toNumber({}, {fallback: 3.3, round: true}), 3)
-    })
-
-    it('should convert Number object fallback to primitive number', function () {
-      assert.strictEqual(typeof toNumber({}, {fallback: new Number(1)}), 'number') // eslint-disable-line no-new-wrappers
-    })
-
-    it('should throw error if number is invalid and fallback is not a number', function () {
-      assert.throws(() => { toNumber('not a number', {fallback: null}) }, TypeError)
-    })
-  })
-
-  describe('#toObject()', function () {
-    it('should convert object to object', function () {
-      const object = {a: 1, b: 2}
-      assert.strictEqual(JSON.stringify(toObject(object)), JSON.stringify(object))
-    })
-
-    it('should convert array of key/value pairs to object', function () {
-      const object = toObject([['a', 1], ['b', 2]])
-      assert.strictEqual(object.a, 1)
-      assert.strictEqual(object.b, 2)
-    })
-
-    it('should convert array of strings to object with numerical keys', function () {
-      const object = toObject(['a', 'b'])
-      assert.strictEqual(object[0], 'a')
-      assert.strictEqual(object[1], 'b')
-    })
-
-    it('should `mirror` string array across keys and values', function () {
-      const object = toObject(['100', '200'], {mirror: true})
-      assert.strictEqual(object[100], '100')
-      assert.strictEqual(object[200], '200')
-    })
-
-    it('should only `mirror` values to keys if all values can be object keys', function () {
-      const nonKeyable = {}
-      const object = toObject(['100', nonKeyable], {mirror: true})
-      assert.strictEqual(object[0], '100')
-      assert.strictEqual(object[1], nonKeyable)
-    })
-
-    it('should convert Map to object', function () {
-      const object = toObject(new Map([['a', 1], ['b', 2]]))
-      assert.strictEqual(object.a, 1)
-      assert.strictEqual(object.b, 2)
-    })
-
-    it('should convert primitive value to empty object', function () {
-      assert.strictEqual(JSON.stringify(toObject('not an object')), JSON.stringify({}))
-    })
-
-    it('should return the provided fallback if input is unconvertible', function () {
-      assert.strictEqual(JSON.stringify(toObject('not an object', {fallback: {a: 1}})), JSON.stringify({a: 1}))
-    })
-
-    it('should throw error if input is unconvertible and fallback is not object', function () {
-      assert.throws(() => { toObject('not an object', {fallback: null}) }, TypeError)
-    })
-
-    it('should throw error if Map has keys that are not strings/numbers', function () {
-      assert.throws(() => { toObject(new Map([{}, 'test'])) }, TypeError)
-    })
-  })
-
-  describe('#toString()', function () {
-    it('should convert string to string', function () {
-      assert.strictEqual(toString('test'), 'test')
-    })
-
-    it('should convert String object to string', function () {
-      assert.strictEqual(typeof toString(new String('test')), typeof 'test') // eslint-disable-line no-new-wrappers
-    })
-
-    it('should convert number to string', function () {
-      assert.strictEqual(toString(-123), '-123')
-    })
-
-    it('should convert 0 to "0"', function () {
-      assert.strictEqual(toString(0), '0')
-    })
-
-    it('should convert -0 to "0"', function () {
-      assert.strictEqual(toString(-0), '0')
-    })
-
-    it('should convert NaN to empty string', function () {
-      assert.strictEqual(toString(NaN), '')
-    })
-
-    it('should convert Infinity to empty string', function () {
-      assert.strictEqual(toString(Infinity), '')
-    })
-
-    it('should convert true to empty string', function () {
-      assert.strictEqual(toString(true), '')
-    })
-
-    it('should convert false to empty string', function () {
-      assert.strictEqual(toString(true), '')
-    })
-
-    it('should convert null to empty string', function () {
-      assert.strictEqual(toString(null), '')
-    })
-
-    it('should convert undefined to empty string', function () {
-      assert.strictEqual(toString(undefined), '') // eslint-disable-line no-undefined
-    })
-
-    it('should convert function to empty string', function () {
-      assert.strictEqual(toString(function () {}), '')
-    })
-
-    it('should convert array to empty string', function () {
-      assert.strictEqual(toString([]), '')
-    })
-
-    it('should convert plain object to empty string', function () {
-      assert.strictEqual(toString({}), '')
-    })
-
-    it('should convert symbol to empty string', function () {
-      assert.strictEqual(toString(Symbol('test')), '')
-    })
-
-    it('should convert object to string using object’s custom toString() method', function () {
-      class TestClass {
-        toString () {
-          return 'string value'
-        }
-      }
-      const object = new TestClass()
-      assert.strictEqual(toString(object), 'string value')
-    })
-
-    it('should return the provided fallback if input is unconvertible', function () {
-      assert.strictEqual(toString({}, {fallback: 'test'}), 'test')
-    })
-
-    it('should convert String object fallback to primitive string', function () {
-      assert.strictEqual(typeof toString({}, {fallback: new String('test')}), 'string') // eslint-disable-line no-new-wrappers
-    })
-
-    it('should throw error if input is unconvertible and fallback is not string', function () {
-      assert.throws(() => { toString({}, {fallback: null}) }, TypeError)
-    })
-  })
-
-  it('should result in object surviving multiple chained conversions', function () {
-    let data = {a: 1, b: 2}
-    data = toMap(data)
-    data = toArray(data)
-    data = toObject(data)
-    data = toIterator(data)
-    data = toArray(data)
-    data = toMap(data)
-    data = toObject(data)
-    assert.strictEqual(Object.keys(data).length, 2)
-    assert.strictEqual(data.a, 1)
-    assert.strictEqual(data.b, 2)
-  })
-
-  it('should result in array surviving multiple chained conversions', function () {
-    let data = ['first', 'second']
-    data = toMap(data)
-    data = toArray(data, {detectIndexKeys: true})
-    data = toObject(data)
-    data = toIterator(data)
-    data = toArray(data, {detectIndexKeys: true})
-    data = toMap(data)
-    data = toObject(data)
-    data = toArray(data, {detectIndexKeys: true})
-    assert.strictEqual(JSON.stringify(data), JSON.stringify(['first', 'second']))
-  })
-})

package/native/token-counter/node_modules/enforce-range/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "enforce-range",
-  "version": "1.0.0",
-  "description": "Enforce a minimum and/or maximum value for a number.",
-  "keywords": [
-    "number",
-    "range",
-    "min",
-    "minimum",
-    "max",
-    "maximum",
-    "value"
-  ],
-  "author": "John Lamansky",
-  "license": "MIT",
-  "homepage": "https://github.com/lamansky/enforce-range",
-  "repository": "lamansky/enforce-range",
-  "main": "index.js",
-  "files": [],
-  "dependencies": {
-    "2": "^1.0.2"
-  },
-  "devDependencies": {
-    "eslint-config-lamansky": "^1.0.0",
-    "mocha": "^4.0.1"
-  },
-  "scripts": {
-    "test": "mocha"
-  },
-  "eslintConfig": {
-    "extends": "lamansky",
-    "env": {
-      "mocha": true
-    }
-  }
-}

package/native/token-counter/node_modules/enforce-range/readme.md

@@ -1,53 +0,0 @@
-# enforce-range
-
-Enforce a minimum and/or maximum value for a number.
-
-## Installation
-
-```bash
-npm install enforce-range --save
-```
-
-## Usage
-
-```javascript
-const enforceRange = require('enforce-range')
-
-// Number should be between 0 and 100
-enforceRange(0, 100, 51) // 51
-enforceRange(0, 100, -123) // 0
-enforceRange(0, 100, 456) // 100
-```
-
-### Partial Application
-
-If you provide only the first two arguments (a minimum and a maximum value), the module will create a partially-applied function which enforces that range. Here's the above example repeated with this usage mode:
-
-```javascript
-const enforce0to100 = require('enforce-range')(0, 100)
-
-// Number should be between 0 and 100
-enforce0to100(51) // 51
-enforce0to100(-123) // 0
-enforce0to100(456) // 100
-```
-
-### Open-Ended Ranges
-
-If, for some reason, you want this module to enforce a range that is only bound on one end, you can do so by passing `null` or ±`Infinity` as the minimum/maximum value. (However, in such a case you’re probably better off cutting the overhead of using a module and just using `Math.min()` or `Math.max()`.)
-
-```javascript
-const enforceRange = require('enforce-range')
-
-// Maximum only
-enforceRange(null, 100, 200) // 100
-enforceRange(-Infinity, 100, 200) // 100
-
-// Minimum only
-enforceRange(0, null, 51) // 51
-enforceRange(0, Infinity, 51) // 51
-
-// No range enforcement at all (module does nothing)
-enforceRange(null, null, 12345) // 12345
-enforceRange(-Infinity, Infinity, 12345) // 12345
-```

package/native/token-counter/node_modules/english-list/.travis.yml

@@ -1,6 +0,0 @@
----
-language: node_js
-node_js: node
-script:
-- npm run test
-- npm run lint

package/native/token-counter/node_modules/english-list/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Kyle E. Mitchell
-
-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/native/token-counter/node_modules/english-list/README.md

@@ -1,44 +0,0 @@
-Make "X, Y, and Z"-style lists from arrays.
-
-```javascript
-var list = require('english-list')
-var assert = require('assert')
-
-assert.equal(
-  list('and', ['John']),
-  'John'
-)
-
-assert.equal(
-  list('and', ['John', 'Paul']),
-  'John and Paul'
-)
-
-assert.equal(
-  list('and', ['John', 'Paul', 'George']),
-  'John, Paul, and George'
-)
-
-assert.equal(
-  list('and', ['John', 'Paul', 'George'], false),
-  'John, Paul and George'
-)
-
-assert.equal(
-  list('and', ['John', 'Paul', 'George'], true),
-  'John, Paul, and George'
-)
-
-assert.equal(
-  list('or', ['John', 'Paul', 'George']),
-  'John, Paul, or George'
-)
-
-assert.throws(function () {
-  list('and', null)
-}, TypeError)
-
-assert.throws(function () {
-  list('and', [])
-}, Error)
-```

package/native/token-counter/node_modules/english-list/index.js

@@ -1,34 +0,0 @@
-module.exports = function (conjunction, array, serialComma) {
-  if (!Array.isArray(array) || !conjunction.toString) {
-    throw new TypeError()
-  }
-  conjunction = conjunction.toString()
-  serialComma = serialComma === undefined ? true : !!serialComma
-  var length = array.length
-  if (length === 0) {
-    throw new Error('Cannot create an English list of an empty array')
-  } else if (length === 1) {
-    return array[0].toString()
-  } else if (length === 2) {
-    return (
-      array[0].toString() +
-      ' ' +
-      conjunction +
-      ' ' +
-      array[1].toString()
-    )
-  } else {
-    var strings = array.map(function (element) {
-      return element.toString()
-    })
-    var front = strings.slice(0, length - 1)
-    var last = strings[length - 1]
-    return (
-      front.join(', ') +
-      (serialComma ? ', ' : ' ') +
-      conjunction +
-      ' ' +
-      last
-    )
-  }
-}

package/native/token-counter/node_modules/english-list/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "english-list",
-  "description": "make \"X, Y, and Z\"-style lists from arrays",
-  "version": "1.0.0",
-  "author": "Kyle E. Mitchell <kyle@kemitchell.com> (http://kemitchell.com)",
-  "bugs": "https://github.com/kemitchell/english-list.js/issues",
-  "devDependencies": {
-    "defence-cli": "^2.0.1",
-    "literate-assertions": "^0.1.1",
-    "replace-require-self": "^1.1.1",
-    "standard": "^10.0.3",
-    "standard-markdown": "^4.0.2"
-  },
-  "homepage": "https://github.com/kemitchell/english-list.js",
-  "keywords": [
-    "array",
-    "conjunction",
-    "English",
-    "enumeration",
-    "language",
-    "list",
-    "natural"
-  ],
-  "license": "MIT",
-  "repository": "kemitchell/english-list.js",
-  "scripts": {
-    "travis-ci": "npm run test",
-    "lint": "standard && standard-markdown",
-    "test": "defence -i javascript README.md | replace-require-self | node"
-  }
-}

package/native/token-counter/node_modules/english-list/test.log

@@ -1,6 +0,0 @@
-
-> english-list@1.0.0-prerelease-1 test /home/kyle/english-list.js
-> defence -i javascript README.md | replace-require-self | node
-
-sh: 1: defence: not found
-sh: 1: replace-require-self: not found

package/native/token-counter/node_modules/errate/index.js

@@ -1,19 +0,0 @@
-'use strict'
-
-const copyOwn = require('copy-own')
-const isClassOf = require('is-class-of')
-const is = require('is-instance-of')
-const trimCall = require('trim-call')
-
-module.exports = function errate (e, Cls = Error, {defaultMessage, forceClass = true} = {}) {
-  if (isClassOf(e, 'Error')) {
-    Cls = e
-    e = null
-  } else if (!isClassOf(Cls, 'Error')) {
-    throw new TypeError('Invalid error class')
-  }
-  if (!e || e === true) return trimCall.new(Cls, defaultMessage)
-  if (is(e, Cls)) return e
-  if (is(e, 'Error')) return forceClass ? copyOwn(e, new Cls()) : e
-  return new Cls(e)
-}