aurix-ai 0.1.0

package/native/token-counter/node_modules/empty-iterator/license.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright ©2018 John Lamansky
+
+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/empty-iterator/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "empty-iterator",
+  "version": "1.0.0",
+  "description": "Creates an iterator that finishes immediately.",
+  "keywords": [
+    "empty",
+    "iterator"
+  ],
+  "author": "John Lamansky",
+  "license": "MIT",
+  "homepage": "https://github.com/lamansky/empty-iterator",
+  "repository": "lamansky/empty-iterator",
+  "main": "index.js",
+  "files": [],
+  "engines": {
+    "node": ">=4.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "eslint-config-lamansky": "^1.0.0",
+    "is-iterator": "^1.0.1",
+    "mocha": "^5.1.1"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "eslintConfig": {
+    "extends": "lamansky",
+    "env": {
+      "mocha": true
+    }
+  }
+}

package/native/token-counter/node_modules/empty-iterator/readme.md

@@ -0,0 +1,23 @@
+# empty-iterator
+
+Creates an iterator that finishes immediately.
+
+## Installation
+
+Requires [Node.js](https://nodejs.org/) 4.0.0 or above.
+
+```bash
+npm i empty-iterator
+```
+
+## API
+
+The module exports a single function with no parameters. Each time it is called, it creates and returns a new empty iterator.
+
+## Example
+
+```javascript
+const emptyIterator = require('empty-iterator')
+
+emptyIterator().next().done // true
+```

package/native/token-counter/node_modules/enforce-range/index.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const toNumber = require('2/number')
+
+module.exports = function enforceRange (min, max, value) {
+  if (arguments.length === 2) return v => enforceRange(min, max, v)
+
+  if (min === null) min = -Infinity
+  if (max === null) max = Infinity
+  ;[min, max, value] = [min, max, value].map(n => toNumber(n, {fallback: null, finite: false}))
+  if (min > max) throw new RangeError('min cannot be more than max')
+  value = Math.max(min, value)
+  value = Math.min(max, value)
+  return value
+}

package/native/token-counter/node_modules/enforce-range/license.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright ©2017 John Lamansky
+
+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/enforce-range/node_modules/2/array.js

@@ -0,0 +1,43 @@
+'use strict'
+
+/**
+ * Converts a map, iterable, object, or primitive into an array.
+ * @param  {any} thingToConvert
+ * @param  {object} options
+ * @param  {bool} [options.detectIndexKeys=false] Whether or not map/object keys
+ *   should be assumed to represent array indices if the keys go from 0...n-1
+ * @return {array}
+ */
+module.exports = function (thingToConvert, {detectIndexKeys = false} = {}) {
+  if (typeof thingToConvert === 'undefined' || thingToConvert === null || Number.isNaN(thingToConvert)) {
+    return []
+  }
+
+  if (Array.isArray(thingToConvert)) {
+    return thingToConvert
+  }
+
+  if (thingToConvert instanceof Map) {
+    if (detectIndexKeys && JSON.stringify([...thingToConvert.keys()].map(String)) === JSON.stringify([...Array(thingToConvert.size).keys()].map(String))) {
+      return Array.from(thingToConvert.values())
+    } else {
+      return Array.from(thingToConvert)
+    }
+  }
+
+  if (typeof thingToConvert[Symbol.iterator] !== 'undefined' && typeof thingToConvert !== 'string') {
+    return Array.from(thingToConvert)
+  }
+
+  if (typeof thingToConvert === 'object' && thingToConvert !== null) {
+    const objectKeysArray = [...Object.keys(thingToConvert)]
+    objectKeysArray.sort() // JS does not guarantee object key order, so sort the keys.
+    if (detectIndexKeys && JSON.stringify(objectKeysArray) === JSON.stringify([...Array(Object.keys(thingToConvert).length).keys()].map(String))) {
+      return objectKeysArray.map(key => thingToConvert[key])
+    } else {
+      return Object.entries(thingToConvert)
+    }
+  }
+
+  return [thingToConvert]
+}

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

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = {
+  toArray: require('./array'),
+  toIterator: require('./iterator'),
+  toMap: require('./map'),
+  toNumber: require('./number'),
+  toObject: require('./object'),
+  toString: require('./string'),
+}

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

@@ -0,0 +1,26 @@
+'use strict'
+
+/**
+ * Converts an iterable, an object, or a primitive into an iterator.
+ * @param  {any} thingToConvert
+ * @return {object}
+ */
+module.exports = function (thingToConvert) {
+  // Turn undefined/null/NaN into an empty iterator
+  if (typeof thingToConvert === 'undefined' || thingToConvert === null || Number.isNaN(thingToConvert)) {
+    return [][Symbol.iterator]()
+  }
+
+  // Turn a primitive into an iterator
+  if (typeof thingToConvert !== 'object') {
+    return [thingToConvert][Symbol.iterator]()
+  }
+
+  // Turn an Array, Set, Map, etc. into an iterator
+  if (Symbol.iterator in thingToConvert) {
+    return thingToConvert[Symbol.iterator]()
+  }
+
+  // Turn an object into an iterator
+  return Object.entries(thingToConvert)[Symbol.iterator]()
+}

package/native/token-counter/node_modules/enforce-range/node_modules/2/license.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright ©2017 John Lamansky
+
+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/enforce-range/node_modules/2/map.js

@@ -0,0 +1,47 @@
+'use strict'
+
+/**
+ * Converts an array or object into a Map.
+ * @param  {any} thingToConvert
+ * @param  {object} options
+ * @param  {Map|null} [options.fallback=new Map()]
+ *   The Map to return if `thingToConvert` cannot be turned into a Map.
+ *   Set to null to throw an error instead.
+ * @param  {bool} [options.detectPairs=true]
+ *   This option only applies if `thingToConvert` is an array.
+ *   If set to `true`, an array of two-element arrays (the kind that’s used
+ *   to construct a Map) will be treated as an array of key-value entries.
+ * @param  {bool} [options.mirror=false]
+ *   This option only applies if `thingToConvert` is an array.
+ *   If set to `true`, array values are used as both keys and values
+ *   (i.e. the keys and values mirror each other).
+ *   If `false`, array indices (0 to n-1) are used as the Map keys.
+ * @return {Map}
+ */
+module.exports = function (thingToConvert, {fallback = new Map(), detectPairs = true, mirror = false} = {}) {
+  if (thingToConvert instanceof Map) {
+    return thingToConvert
+  }
+
+  if (Array.isArray(thingToConvert)) {
+    if (detectPairs && thingToConvert.every(item => Array.isArray(item) && item.length === 2)) {
+      return new Map(thingToConvert)
+    } else if (mirror) {
+      return new Map(thingToConvert.map(item => [item, item]))
+    } else {
+      return new Map(thingToConvert.map((item, index) => [index, item]))
+    }
+  }
+
+  if (typeof thingToConvert === 'object' && thingToConvert !== null) {
+    return new Map(Object.keys(thingToConvert).map(
+      key => [key, thingToConvert[key]]
+    ))
+  }
+
+  if (!(fallback instanceof Map)) {
+    throw new TypeError('Failed to convert input of an unrecognized type into a Map.')
+  }
+
+  return fallback
+}

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

@@ -0,0 +1,33 @@
+'use strict'
+
+/**
+ * Converts a string or Number object into a primitive number.
+ * @param  {any} thingToConvert
+ * @param  {object} options
+ * @param  {number|null} [options.fallback=0]
+ *   The number to return if `thingToConvert` cannot be turned into a number.
+ *   Set to `null` to throw an error instead.
+ * @param  {bool} [options.finite=true]
+ *   If true, only finite numbers are considered valid numbers.
+ *   Therefore, if `thingToConvert` is `+Infinity` or `-Infinity`,
+ *   the `fallback` will be returned.
+ * @param  {bool} [options.round=false]
+ *   If `true`, floats will be rounded to integers.
+ * @return {number}
+ */
+module.exports = function (thingToConvert, {fallback = 0, finite = true, round = false} = {}) {
+  let number = thingToConvert === null ? NaN : Number(thingToConvert)
+  if (Number.isFinite(number) || (!finite && !Number.isNaN(number))) {
+    if (round) number = Math.round(number)
+    return number
+  }
+
+  if (fallback instanceof Number) {
+    return Number(fallback)
+  } else if (typeof fallback !== 'number') {
+    throw new TypeError('Failed to convert input of an unrecognized type into a number.')
+  }
+
+  if (round) fallback = Math.round(fallback)
+  return fallback
+}

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

@@ -0,0 +1,61 @@
+'use strict'
+
+const toString = require('./string')
+
+/**
+ * Converts a Map or array into an object.
+ * @param  {any} thingToConvert
+ * @param  {object} options
+ * @param  {object|null} [options.fallback={}]
+ *   The object to return if `thingToConvert` cannot be turned into an object.
+ *   Set to `null` to throw an error instead.
+ * @param  {bool} [options.mirror=false]
+ *   This option only applies if `thingToConvert` is an array.
+ *   If set to `true`, array values are used as both keys and values
+ *   (i.e. the keys and values mirror each other).
+ *   If `false`, array indices (0 to n-1) are used as the object keys.
+ *   If some array values have types which are among those supported as
+ *   object keys (strings, numbers, and symbols), then mirroring will not happen.
+ * @return {object}
+ */
+module.exports = function (thingToConvert, {fallback = {}, mirror = false} = {}) {
+  if (thingToConvert instanceof Map) {
+    const object = {}
+    for (const [key, value] of thingToConvert.entries()) {
+      try {
+        object[typeof key === 'symbol' ? key : toString(key, {fallback: null})] = value
+      } catch (x) {
+        throw new TypeError('Cannot convert map to object because map has keys which objects do not support. Objects can only have string/number/symbol keys.')
+      }
+    }
+    return object
+  } else if (Array.isArray(thingToConvert)) {
+    if (thingToConvert.every(entry => Array.isArray(entry) && entry.length === 2)) {
+      const object = {}
+      for (const [key, value] of thingToConvert) {
+        object[key] = value
+      }
+      return object
+    } else if (mirror && thingToConvert.every(value => ['string', 'number', 'symbol'].includes(typeof value))) {
+      const object = {}
+      for (const value of thingToConvert) {
+        object[value] = value
+      }
+      return object
+    } else {
+      const object = {}
+      for (let i = 0; i < thingToConvert.length; i++) {
+        object[i] = thingToConvert[i]
+      }
+      return object
+    }
+  } else if (typeof thingToConvert === 'object' && thingToConvert !== null) {
+    return thingToConvert
+  }
+
+  if (typeof fallback !== 'object' || fallback === null) {
+    throw new TypeError('Failed to convert input of an unrecognized type into an object.')
+  }
+
+  return fallback
+}

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

@@ -0,0 +1,41 @@
+{
+  "name": "2",
+  "version": "1.0.2",
+  "description": "The Type Conversion Library. Numbers, Strings, Arrays, Maps, Objects, and Iterators.",
+  "keywords": [
+    "type",
+    "convert",
+    "conversion",
+    "to",
+    "array",
+    "iterator",
+    "map",
+    "number",
+    "int",
+    "integer",
+    "float",
+    "object",
+    "string"
+  ],
+  "author": "John Lamansky",
+  "license": "MIT",
+  "homepage": "https://github.com/lamansky/2",
+  "repository": "lamansky/2",
+  "main": "index.js",
+  "engines": {
+    "node": ">=7.0.0"
+  },
+  "devDependencies": {
+    "eslint-config-lamansky": "^1.0.0",
+    "mocha": "^3.2.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "eslintConfig": {
+    "extends": "lamansky",
+    "env": {
+      "mocha": true
+    }
+  }
+}

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

@@ -0,0 +1,210 @@
+# “2”: The Type Conversion Library
+
+A [Node.js](https://nodejs.org/) module for converting between various JavaScript types: arrays, iterators, maps, numbers, objects, and strings.
+
+```javascript
+const {toArray, toIterator, toMap, toNumber, toObject, toString} = require('2')
+
+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) // {a: 1, b: 2}
+
+data = '1.23'
+data = toNumber(data)
+data = toString(data) // '1.23'
+```
+
+## Installation
+
+```bash
+npm install 2 --save
+```
+
+## Usage
+
+### Requiring the Functions
+
+You can require needed functions via a destructuring assignment:
+
+```javascript
+const {toArray, toIterator, toMap, toNumber, toObject, toString} = require('2')
+```
+
+Or you can require individual functions via submodules:
+
+```javascript
+const toArray = require('2/array')
+const toIterator = require('2/iterator')
+const toMap = require('2/map')
+const toNumber = require('2/number')
+const toObject = require('2/object')
+const toString = require('2/string')
+```
+
+### Converting to Arrays
+```javascript
+const toArray = require('2/array')
+
+// Map => Array
+let map = new Map()
+map.set('a', 1)
+map.set('b', 2)
+toArray(map) // [['a', 1], ['b', 2]]
+
+// Iterator => Array
+toArray(map.values()) // [1, 2]
+
+// Object => Array
+toArray({a: 1, b: 2}) // [['a', 1], ['b', 2]]
+
+// Array-like object => Array
+toArray({0: 'first', 1: 'second'}, {detectIndexKeys: true}) // ['first', 'second']
+
+// Primitive value => Array
+toArray('test') // ['test']
+```
+
+### Converting to Iterators
+```javascript
+const toIterator = require('2/iterator')
+
+// Object => Iterator
+let iterator = toIterator({a: 1, b: 2})
+iterator.next().value // ['a', 1]
+iterator.next().value // ['b', 2]
+iterator.next().done // true
+
+// Primitive value => Iterator
+toIterator('test').next().value // 'test'
+```
+
+### Converting to Maps
+```javascript
+const toMap = require('2/map')
+
+// Array of key/value pairs => Map
+toMap([['a', 1], ['b', 2]])
+map.get('a') // 1
+map.get('b') // 2
+
+// Array of values => Map
+let map = toMap(['a', 'b'])
+map.get(0) // 'a'
+map.get(1) // 'b'
+
+// Object => Map
+map = toMap({a: 1, b: 2})
+map.get('a') // 1
+map.get('b') // 2
+```
+
+### Converting to Numbers
+```javascript
+const toNumber = require('2/number')
+
+toNumber('1.2') // 1.2
+toNumber(Infinity) // 0
+toNumber(NaN) // 0
+toNumber('not a number') // 0
+
+// Can specify a fallback other than zero:
+toNumber('not a number', {fallback: 100}) // 100
+
+// You can choose to throw an error for invalid inputs by
+// providing a null fallback:
+toNumber('not a number', {fallback: null}) // throws error
+
+// Option to round floats:
+toNumber('4.7') // 4.7
+toNumber('4.7', {round: true}) // 5
+
+// By default, Infinity is not considered a valid number,
+// but this can be changed:
+toNumber(Infinity) // 0
+toNumber(Infinity, {finite: false}) // Infinity
+
+// Number object => Number
+let numberObject = new Number(123)
+typeof numberObject // 'object'
+typeof toNumber(numberObject) // 'number'
+```
+
+### Converting to Objects
+```javascript
+const toObject = require('2/object')
+
+// Array of key/value pairs => Object
+let obj = toObject([['a', 1], ['b', 2]])
+obj.a // 1
+obj.b // 2
+
+// Array => Object
+let obj = toObject(['first', 'second'])
+Object.keys(obj).length // 2
+obj[0] // 'first'
+obj[1] // 'second'
+
+// In the above example, the array indices become the object keys.
+// But you can make the keys mirror the values instead:
+let obj = toObject(['first', 'second'], {mirror: true})
+Object.keys(obj).length // 2
+obj.first // 'first'
+obj.second // 'second'
+
+// Map => Object
+let map = new Map()
+map.set('key1', 'value1')
+map.set('key2', 'value2')
+let obj = toObject(map)
+obj.key1 // 'value1'
+obj.key2 // 'value2'
+```
+
+### Converting to Strings
+```javascript
+const toString = require('2/string')
+
+toString(123) // '123'
+toString(-0) // '0'
+
+toString(true) // ''
+toString(false) // ''
+toString(undefined) // ''
+toString(null) // ''
+toString(Infinity) // ''
+toString(NaN) // ''
+toString({}) // ''
+toString([]) // ''
+toString(function () {}) // ''
+toString(Symbol('test')) // ''
+
+// Compare the above to standard JavaScript string conversion:
+String(true) // 'true'
+String(false) // 'false'
+String(undefined) // 'undefined'
+String(null) // 'null'
+String(Infinity) // 'Infinity'
+String(NaN) // 'NaN'
+String({}) // '[object Object]'
+String([]) // ''
+String(function () {}) // 'function () {}'
+String(Symbol('test')) // 'Symbol(test)'
+
+// Default fallback is an empty string, but you can change it:
+toString(undefined) // ''
+toString(undefined, {fallback: 'N/A'}) // 'N/A'
+
+// You can choose to throw an error for invalid inputs by
+// providing a null fallback:
+toString(undefined, {fallback: null}) // throws error
+
+// String object => String
+let stringObject = new String('test')
+typeof stringObject // 'object'
+typeof toString(stringObject) // 'string'
+```

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

@@ -0,0 +1,37 @@
+'use strict'
+
+/**
+ * Converts a number or `toString`able object into a primitive string.
+ * @param  {any} thingToConvert
+ * @param  {object} options
+ * @param  {string|null} [options.fallback='']
+ *   The string to return if `thingToConvert` cannot be turned into a string.
+ *   Set to `null` to throw an error instead.
+ * @return {string}
+ */
+module.exports = function (thingToConvert, {fallback = ''} = {}) {
+  if (typeof thingToConvert === 'string') {
+    return thingToConvert
+  }
+
+  if (thingToConvert instanceof String) {
+    return thingToConvert + ''
+  }
+
+  if (typeof thingToConvert === 'number' && Number.isFinite(thingToConvert)) {
+    return thingToConvert + ''
+  }
+
+  if (typeof thingToConvert === 'object' && thingToConvert !== null &&
+      thingToConvert.toString !== Object.prototype.toString) {
+    return String(thingToConvert)
+  }
+
+  if (fallback instanceof String) {
+    return fallback + ''
+  } else if (typeof fallback !== 'string') {
+    throw new TypeError('Failed to convert input of an unrecognized type into a string.')
+  }
+
+  return fallback
+}