aurix-ai 0.1.0

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

@@ -0,0 +1,109 @@
+'use strict'
+
+const otherwise = require('otherwise')
+const roundTo = require('round-to')
+const sbo = require('sbo')
+
+const thousandsSepOnly = [' ', '\u2009', "'"]
+const numberDigits = '0123456789'
+
+const infinities = [
+  ['infinity', '+infinity'],
+  ['-infinity', '\u2212infinity'],
+]
+const suffixes = ['kg', 'm', 'b']
+
+const stringToNumber = require('parser-factory')('main', {
+  main ({char, consume, consumeRest, shift}, {userArgs: [{decimalComma, decimalPlacesInInt, ignoreBadChars} = {}]}) {
+    let thousandsSep = ''
+    let decimalSep = ''
+    let decimals = ''
+    let units = ''
+    let group = ''
+    let sign = 1
+
+    let leftParen
+    const rightParen = consume(')')
+
+    for (const [i, s] of suffixes.entries()) {
+      if (consume(...s)) {
+        units = '000'.repeat(i + 1)
+        break
+      }
+    }
+
+    while (char()) {
+      const sep = consume(',', '.', ...thousandsSepOnly)
+      if (sep) {
+        if (!decimals && !thousandsSep && !thousandsSepOnly.includes(sep)) {
+          decimalSep = sep
+          decimals = units
+          units = ''
+          group = ''
+        } else if ((group.length !== 3 && !(group.length === 2 && units.length >= 5 && (units - 3) % 2 === 0)) || (thousandsSep && thousandsSep !== sep && !(thousandsSep === '.' && sep === ' ')) || (decimalSep && decimalSep === sep)) {
+          if (!ignoreBadChars) return NaN
+        } else {
+          if (!thousandsSep) thousandsSep = sep
+          group = ''
+        }
+      } else if (consumeRest('-', '\u2212')) {
+        sign = -1
+      } else if (rightParen && consumeRest('(')) {
+        sign = -1
+        leftParen = true
+      } else {
+        const n = shift(1)
+        if (numberDigits.includes(n)) {
+          units = n + units
+          group = n + group
+        } else if (!ignoreBadChars) {
+          return NaN
+        }
+      }
+    }
+
+    if (!ignoreBadChars && rightParen && !leftParen) return NaN
+
+    if (decimals.length === 3 && decimalSep && !thousandsSep && !decimalComma === (decimalSep === ',')) {
+      units += decimals
+      decimals = ''
+    } else if (decimals) {
+      if (decimalPlacesInInt > 0) {
+        decimals = decimals.substr(0, decimalPlacesInInt).padEnd(2, '0')
+      } else {
+        decimals = '.' + decimals
+      }
+    }
+
+    const n = units + decimals
+    if (!n.length) return NaN
+    return sign * Number(n)
+  },
+})
+
+module.exports = sbo(function toNumber (x, {decimalComma, decimalPlacesInInt, elseCall, elseReturn = 0, elseThrow, finite = true, ignoreBadChars, round = false} = {}) {
+  if (x instanceof String) x = String(x)
+  if (typeof x === 'string') {
+    x = x.toLowerCase()
+
+    const testForInfinityString = positive => infinities[+!positive].some(
+      ignoreBadChars ? inf => x.includes(inf) : inf => x === inf,
+    )
+
+    x = testForInfinityString(true) ? Infinity
+      : testForInfinityString(false) ? -Infinity
+        : stringToNumber(
+          x.split('').reverse().join(''),
+          {decimalComma, decimalPlacesInInt, ignoreBadChars},
+        )
+  } else if (x !== null) {
+    x = Number(x)
+  }
+  if (x === null || Number.isNaN(x) || (finite && !Number.isFinite(x))) {
+    return otherwise({elseCall, elseReturn, elseThrow}, {defaultErrorClass: TypeError})
+  }
+  if (!decimalPlacesInInt && (round || round === 0)) {
+    return roundTo(x, round === true ? 0 : +round)
+  }
+  return x
+})

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

@@ -0,0 +1,23 @@
+'use strict'
+
+const addCounter = require('add-counter')
+const every = require('@lamansky/every')
+const isArrayOfLength = require('is-array-of-length')
+const isInstanceOf = require('is-instance-of')
+const isIterable = require('is-iterable')
+const isObject = require('is-object')
+const map = require('map-iter')
+const newObject = require('new-object')
+const otherwise = require('otherwise')
+const sbo = require('sbo')
+
+module.exports = sbo(function toObject (x, {arrays = [], descriptors: descDefaults, elseCall, elseReturn = {}, elseThrow, maps = [], mirror = false, throwIfEquivKeys = true} = {}) {
+  if (isInstanceOf(x, [Map, maps])) return newObject(x.entries(), {descDefaults, throwIfEquivKeys})
+  if (isIterable(x) && typeof x !== 'string') {
+    if (every(x, el => isArrayOfLength(el, 2))) return newObject(x, {descDefaults, throwIfEquivKeys})
+    if (mirror) return newObject(map(x, v => [v, v]), {descDefaults, throwIfEquivKeys})
+    return newObject(addCounter(x), {descDefaults})
+  }
+  if (isObject(x)) return x
+  return otherwise({elseCall, elseReturn, elseThrow}, {defaultErrorClass: TypeError})
+})

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

@@ -0,0 +1,60 @@
+{
+  "name": "2",
+  "version": "3.0.0",
+  "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": {
+    "name": "Fr. John Lamansky",
+    "url": "lamansky.com"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/lamansky/2",
+  "repository": "lamansky/2",
+  "main": "index.js",
+  "engines": {
+    "node": ">=8.3.0"
+  },
+  "dependencies": {
+    "@lamansky/every": "^1.0.0",
+    "add-counter": "^1.0.0",
+    "empty-iterator": "^1.0.0",
+    "is-array-of-length": "^1.0.0",
+    "is-instance-of": "^1.0.2",
+    "is-iterable": "^1.1.1",
+    "is-nil": "^1.0.1",
+    "is-object": "^1.0.1",
+    "map-iter": "^1.0.0",
+    "new-object": "^4.0.0",
+    "otherwise": "^2.0.0",
+    "parser-factory": "^1.1.0",
+    "round-to": "^4.0.0",
+    "sbo": "^1.1.0"
+  },
+  "devDependencies": {
+    "eslint-config-lamansky": "^2.0.0",
+    "mocha": "^6.2.2"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "eslintConfig": {
+    "extends": "lamansky",
+    "env": {
+      "mocha": true
+    }
+  }
+}

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

@@ -0,0 +1,246 @@
+# “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')
+
+const obj = {a: 1, b: 2}
+obj::toMap()::toArray()::toObject()::toIterator()
+  ::toArray()::toMap()::toObject() // {a: 1, b: 2}
+
+let data = '1.23'
+data = toNumber(data)
+data = toString(data) // '1.23'
+```
+
+## Installation
+
+Requires [Node.js](https://nodejs.org/) 8.3.0 or above.
+
+```bash
+npm i 2
+```
+
+## Usage
+
+### Requiring the Functions
+
+You can require needed functions via a destructuring assignment:
+
+```javascript
+const {toArray, toIterator, toMap, toNumber, toObject, toString} = require('2')
+```
+
+(If your project has a linting rule that precludes shadowing the global `toString` function, you can also destructure the `toStr` function, which is the same as `toString`.)
+
+You can also 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
+const 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
+const map1 = toMap([['a', 1], ['b', 2]])
+map1.get('a') // 1
+map1.get('b') // 2
+
+// Array of values => Map
+const map2 = toMap(['a', 'b'])
+map2.get(0) // 'a'
+map2.get(1) // 'b'
+
+// Object => Map
+const map3 = toMap({a: 1, b: 2})
+map3.get('a') // 1
+map3.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', {elseReturn: 100}) // 100
+
+// You can choose to throw an error for invalid inputs.
+toNumber('not a number', {elseThrow: true}) // throws error
+toNumber('not a number', {elseThrow: new TypeError('Not a number!')})
+
+// 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
+const numberObject = new Number(123)
+typeof numberObject // 'object'
+typeof toNumber(numberObject) // 'number'
+
+// Can parse strings that have digit grouping:
+toNumber('1,234') // 1234
+// The built-in Number function, on the other hand, cannot:
+Number('1,234') // NaN
+
+// Can be configured to interpret the comma as a decimal point:
+toNumber('1,234', {decimalComma: true}) // 1.234
+```
+
+### Converting to Objects
+```javascript
+const toObject = require('2/object')
+
+// Array of key/value pairs => Object
+const obj1 = toObject([['a', 1], ['b', 2]])
+obj1.a // 1
+obj1.b // 2
+
+// Array => Object
+const obj2 = toObject(['first', 'second'])
+Object.keys(obj2).length // 2
+obj2[0] // 'first'
+obj2[1] // 'second'
+
+// In the above example, the array indices become the object keys.
+// But you can make the keys mirror the values instead:
+const obj3 = toObject(['first', 'second'], {mirror: true})
+Object.keys(obj3).length // 2
+obj3.first // 'first'
+obj3.second // 'second'
+
+// Map => Object
+const map = new Map()
+map.set('key1', 'value1')
+map.set('key2', 'value2')
+const obj4 = toObject(map)
+obj4.key1 // 'value1'
+obj4.key2 // 'value2'
+
+// Duplicate keys
+toObject([['key', 1], ['key', 2]]) // throws an error (default behavior)
+const obj5 = toObject([['key', 1], ['key', 2]], {throwIfEquivKeys: false}) // error-throwing disabled
+Object.keys(obj5).length // 1
+obj5.key // 2
+
+// Setting property descriptors
+const obj6 = toObject([['a', 1], ['b', 2]], {descriptors: {enumerable: false}})
+Object.keys(obj6).length // 0 (because the properties are non-enumerable)
+obj6.a // 1
+obj6.b // 2
+```
+
+### 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, {elseReturn: 'N/A'}) // 'N/A'
+
+// You can choose to throw an error for invalid inputs.
+toString(undefined, {elseThrow: true}) // throws error
+
+// String object => String
+const stringObject = new String('test')
+typeof stringObject // 'object'
+typeof toString(stringObject) // 'string'
+```
+
+## Version Migration Guide
+
+Here are backward-incompatible changes you need to know about.
+
+### 2.x ⇒ 3.x
+
+* The minimum supported Node version is now 8.3.0 (instead of 7.0.0).
+* `toNumber` no lounger rounds the `elseReturn` value when `round` is `true`. If you need this behavior, apply `Math.round` to your `elseReturn` value manually.
+* `toObject` will now throw an error if an entries array contains duplicate keys. In version 2, the last equivalent key would have silently overwritten the prior ones. You can restore the previous behavior by setting the new `throwIfEquivKeys` option to `false`.
+
+### 1.x ⇒ 2.x
+
+* `fallback` has been renamed to `elseReturn`.
+* Use `elseThrow: true` instead of `fallback: null`.
+* Unlike the old `fallback` parameter, `elseReturn` does _not_ type-enforce its values.
+* `toObject` with `mirror: true` will now throw an error if any key would overwrite another key. In version 1, this would have been allowed.
+* `toObject` with `mirror: true` will now allow an object to become an object key, so long as its string representation is not equivalent to that of any other key. In version 1, attempting to use an object as an object key would silently fail and would result in numeric index keys being used instead.

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

@@ -0,0 +1,11 @@
+'use strict'
+
+const isObject = require('is-object')
+const otherwise = require('otherwise')
+const sbo = require('sbo')
+
+module.exports = sbo(function toStr (x, {elseCall, elseReturn = '', elseThrow} = {}) {
+  if (typeof x === 'string') return x
+  if (x instanceof String || Number.isFinite(x) || (isObject(x) && x.toString !== Object.prototype.toString)) return String(x)
+  return otherwise({elseCall, elseReturn, elseThrow}, {defaultErrorClass: TypeError})
+})