aurix-ai 0.1.0

package/native/token-counter/node_modules/parser-factory/node_modules/arrify/readme.md

@@ -0,0 +1,39 @@
+# arrify [![Build Status](https://travis-ci.org/sindresorhus/arrify.svg?branch=master)](https://travis-ci.org/sindresorhus/arrify)
+
+> Convert a value to an array
+
+
+## Install
+
+```
+$ npm install arrify
+```
+
+
+## Usage
+
+```js
+const arrify = require('arrify');
+
+arrify('🦄');
+//=> ['🦄']
+
+arrify(['🦄']);
+//=> ['🦄']
+
+arrify(new Set(['🦄']));
+//=> ['🦄']
+
+arrify(null);
+//=> []
+
+arrify(undefined);
+//=> []
+```
+
+*Supplying `null` or `undefined` results in an empty array.*
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)

package/native/token-counter/node_modules/parser-factory/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "parser-factory",
+  "version": "1.1.1",
+  "description": "Helps you construct a custom string parser, for times when you need something more procedural than regex.",
+  "keywords": [
+    "build",
+    "custom",
+    "string",
+    "parser"
+  ],
+  "author": {
+    "name": "Fr. John Lamansky",
+    "url": "lamansky.com"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/lamansky/parser-factory",
+  "repository": "lamansky/parser-factory",
+  "main": "index.js",
+  "files": [],
+  "engines": {
+    "node": ">=8.3.0"
+  },
+  "dependencies": {
+    "arrify": "^2.0.1",
+    "case-insensitive": "^1.0.0",
+    "enforce-range": "^1.0.0",
+    "is-instance-of": "^1.0.2",
+    "longest-first": "^1.0.0",
+    "m-o": "^2.2.0",
+    "vfn": "^1.1.0"
+  },
+  "devDependencies": {
+    "eslint-config-lamansky": "^2.0.0"
+  },
+  "eslintConfig": {
+    "extends": "lamansky"
+  }
+}

package/native/token-counter/node_modules/parser-factory/readme.md

@@ -0,0 +1,15 @@
+# parser-factory
+
+Helps you construct a custom string parser, for times when you need something more procedural than regex.
+
+## Installation
+
+Requires [Node.js](https://nodejs.org/) 8.3.0 or above.
+
+```bash
+npm i parser-factory
+```
+
+## Example
+
+To see this module in action, check out the [conscript](https://github.com/lamansky/conscript.js) module.

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

@@ -0,0 +1,5 @@
+'use strict'
+
+const f = x => typeof x === 'function'
+
+module.exports = (x, or = a => a) => f(x) ? x : f(or) ? or : () => or

package/native/token-counter/node_modules/pfn/license.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright ©2018–2019 Fr. 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/pfn/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "pfn",
+  "version": "1.1.0",
+  "description": "Possible Function. Wraps what might be a function, with fallback behavior in case it’s not. Perfect for use in functions that accept optional callback arguments.",
+  "keywords": [
+    "optional",
+    "function",
+    "callback",
+    "fallback"
+  ],
+  "author": {
+    "name": "Fr. John Lamansky",
+    "url": "lamansky.com"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/lamansky/pfn",
+  "repository": "lamansky/pfn",
+  "main": "index.js",
+  "files": [
+    "strict.js"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "dependencies": {
+    "is-nil": "^1.0.1"
+  },
+  "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/pfn/readme.md

@@ -0,0 +1,111 @@
+# Possible Function (pfn)
+
+Wraps what might be a function, with fallback behavior in case it’s not. Perfect for use in functions that accept optional callback arguments.
+
+## Installation
+
+Requires [Node.js](https://nodejs.org/) 6.0.0 or above.
+
+```bash
+npm i pfn
+```
+
+## API
+
+There are two ways you can import the module: `require('pfn')` or `require('pfn/strict')`. Each exposes a single function with the same signature. The difference is that strict mode will throw an error if `fn` is anything other than a function, `null`, or `undefined`. Normal mode will silently defer to `or` if `fn` is of an unexpected type.
+
+### Parameters
+
+1. `fn` (any): The value that may or may not be a function.
+2. Optional: `or` (any): The function that will be called, or the value that will be returned, if `fn` is not a function. Defaults to a passthrough function (`a => a`).
+
+### Return Value
+
+Always returns a Function.
+
+* `fn`, if `fn` is a Function
+* `or`, if `or` is a Function
+* A Function that returns `or`, if neither `fn` nor `or` is a function
+
+## Examples
+
+`pfn` wraps a value that may or may not be a function. If the underlying value is not a function, then `pfn` will execute one of the following fallback behaviors.
+
+### Passthrough Fallback
+
+If the value turns out to not be a function, `pfn` will, by default, pass through whatever is given as the first argument. This is useful for optional filters.
+
+```javascript
+const pfn = require('pfn')
+
+function sayHello (name, filter) {
+  filter = pfn(filter)
+  return filter('Hello, ' + name)
+}
+
+// No filter is provided, so the hello message is returned without change:
+sayHello('world') // 'Hello, world'
+
+// A filter is provided which changes the hello message:
+sayHello('world', m => m + '!!') // 'Hello, world!!'
+```
+
+### Return-Value Fallback
+
+If the value turns out to not be a function, `pfn` can be configured to return a value of your choosing.
+
+```javascript
+const pfn = require('pfn')
+
+function sayHello (nameCallback) {
+  nameCallback = pfn(nameCallback, 'world')
+  return 'Hello, ' + nameCallback()
+}
+
+sayHello() // 'Hello, world'
+sayHello(() => 'Dolly') // 'Hello, Dolly'
+```
+
+### Self Fallback
+
+If you provide the possible function as its own fallback, then you can accept either a value or a function as an argument for your code. For example, the `sayHello` function in the following example can accept either a string or a function.
+
+Don’t use the module’s strict mode (`require('pfn/strict')`) if you want self-fallback behavior, because strict mode will throw an error if the first parameter is anything other than a function, `null`, or `undefined`.
+
+```javascript
+const pfn = require('pfn')
+
+function sayHello (name) {
+  name = pfn(name, name)
+  return 'Hello, ' + name()
+}
+
+sayHello('world') // 'Hello, world'
+sayHello(() => 'world') // 'Hello, world'
+```
+
+### Custom Fallback
+
+If the wrapped value turns out to not be a function, the wrapping function can execute a custom fallback function instead:
+
+```javascript
+const pfn = require('pfn')
+const mightBeAFunction = null
+const callback = pfn(mightBeAFunction, (...args) => args.length)
+callback('arg 1', 'arg 2') // 2
+```
+
+## Related
+
+This module is part of the `fn` family of modules.
+
+* [efn](https://github.com/lamansky/efn): Extracted Function
+* [ffn](https://github.com/lamansky/ffn): Filtering Function
+* [jfn](https://github.com/lamansky/jfn): Joined Function
+* [mfn](https://github.com/lamansky/mfn): Memoized Function
+* [ofn](https://github.com/lamansky/ofn): Overloaded Function
+* [qfn](https://github.com/lamansky/qfn): Qualified Function
+* [vfn](https://github.com/lamansky/vfn): Variadic Function
+* [wfn](https://github.com/lamansky/wfn): Wrapper Function
+* [xfn](https://github.com/lamansky/xfn): Extended Function
+* [3fn](https://github.com/lamansky/3fn): Three-Way Comparison Function

package/native/token-counter/node_modules/pfn/strict.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const f = x => typeof x === 'function'
+const nil = require('is-nil')
+const toss = err => { throw err }
+
+module.exports = (x, or = a => a) => f(x) ? x : nil(x) ? (f(or) ? or : () => or)
+  : toss(new TypeError('Value cannot be a non-function'))

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

@@ -0,0 +1,5 @@
+'use strict'
+
+const isPlainObject = require('is-plain-object')
+
+module.exports = (key, x) => isPlainObject(x) ? x : typeof x === 'undefined' ? {} : {[key]: x}

package/native/token-counter/node_modules/plainify/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/plainify/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "plainify",
+  "version": "1.0.0",
+  "description": "Wraps a value in a plain object, if it isn’t one already.",
+  "keywords": [
+    "plain",
+    "object",
+    "options"
+  ],
+  "author": "John Lamansky",
+  "license": "MIT",
+  "homepage": "https://github.com/lamansky/plainify",
+  "repository": "lamansky/plainify",
+  "main": "index.js",
+  "files": [],
+  "engines": {
+    "node": ">=4.0.0"
+  },
+  "dependencies": {
+    "is-plain-object": "^2.0.4"
+  },
+  "devDependencies": {
+    "equals": "^1.0.5",
+    "eslint-config-lamansky": "^1.0.0",
+    "mocha": "^5.1.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "eslintConfig": {
+    "extends": "lamansky",
+    "env": {
+      "mocha": true
+    }
+  }
+}

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

@@ -0,0 +1,47 @@
+# plainify
+
+Wraps a value in a plain object, if it isn’t one already.
+
+Lets you specify a default single key for an options object, for example.
+
+## Installation
+
+Requires [Node.js](https://nodejs.org/) 4.0.0 or above.
+
+```bash
+npm i plainify
+```
+
+## API
+
+The module exports a single function.
+
+### Parameters
+
+1. `key` (string or symbol): The key under which to file `x` if it’s not already a plain object.
+2. `x` (any)
+
+### Return Value
+
+Returns `x` as-is if it’s a plain object. Otherwise, returns a new plain object with one entry, having `key` as the key and `x` as the value.
+
+## Example
+
+Let’s say you have an options object with keys `a`, `b`, and `c`. You can use `plainify` to specify `b` as the default key.
+
+```javascript
+const plainify = require('plainify')
+
+function example (options) {
+  const {a, b, c} = plainify('b', options)
+  // ...
+}
+
+example({a: 1}) // a=1; b and c are undefined
+example(2) // b=2; a and c are undefined
+example() // a, b, and c are undefined
+```
+
+## Related
+
+Inspired by [arrify](https://github.com/sindresorhus/arrify).

package/native/token-counter/node_modules/possible-function/changelog.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 1.0.1 (2017-03-14)
+* Bugfix: Class methods are now bound to their object.
+
+## 1.0.0 (2017-03-02)
+* Initial version

package/native/token-counter/node_modules/possible-function/index.js

@@ -0,0 +1,43 @@
+'use strict'
+
+/**
+ * Wraps what might be a function. Returns a wrapper-function that provides
+ * fallback behavior in case the underlying value is not a function.
+ * @param  {function|array=} mightBeAFunction A value that might be a function,
+ *   or a two-element array with [object, 'method'] that might refer to an
+ *   object method.
+ * @param  {function|any=} elseReturn A value to return if `mightBeAFunction`
+ *   is not a function, or a function that generates such a return value.
+ *   If omitted, the first argument given to the returned wrapper-function is
+ *   passed through.
+ * @return {function} A function that calls `mightBeAFunction` if it’s a
+ *   function, and if not, returns a value as defined by `elseReturn`.
+ */
+module.exports = function PossibleFunction (mightBeAFunction, elseReturn) {
+  if (this instanceof PossibleFunction) {
+    throw new TypeError('PossibleFunction is not a constructor')
+  }
+
+  if (Array.isArray(mightBeAFunction) && mightBeAFunction.length === 2) {
+    const [object, functionName] = mightBeAFunction
+    if (typeof object === 'object' && typeof functionName === 'string' && typeof object[functionName] === 'function') {
+      mightBeAFunction = object[functionName].bind(object)
+    }
+  }
+
+  return function () {
+    if (typeof mightBeAFunction === 'function') {
+      return mightBeAFunction(...arguments)
+    }
+
+    if (typeof elseReturn === 'undefined' && arguments.length > 0) {
+      return arguments[0]
+    }
+
+    if (typeof elseReturn === 'function') {
+      return elseReturn(...arguments)
+    }
+
+    return elseReturn
+  }
+}

package/native/token-counter/node_modules/possible-function/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/possible-function/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "possible-function",
+  "version": "1.0.1",
+  "description": "Defines fallback behavior in case a variable is not a function. Perfect for optional callback parameters.",
+  "keywords": [
+    "function",
+    "callback",
+    "filter",
+    "optional",
+    "fallback",
+    "wrapper"
+  ],
+  "author": "John Lamansky",
+  "license": "MIT",
+  "homepage": "https://github.com/lamansky/possible-function",
+  "repository": "lamansky/possible-function",
+  "main": "index.js",
+  "engines": {
+    "node": ">=5.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/possible-function/readme.md

@@ -0,0 +1,77 @@
+# possible-function
+
+Defines fallback behavior in case a variable is not a function. Perfect for optional callback parameters. Packaged as a [Node.js](https://nodejs.org/) module.
+
+## Installation
+
+```
+npm install possible-function --save
+```
+
+The module exposes a single factory function.
+
+## Usage
+
+`PossibleFunction` wraps a value that may or may be a function. If the underlying value is not a function, then the `PossibleFunction` wrapper will execute one of the following fallback behaviors.
+
+### Passthrough Fallback
+
+If the wrapped value turns out to not be a function, the wrapping function will, by default, pass through whatever is given as the first argument. This is useful for optional filters.
+
+```javascript
+const PossibleFunction = require('possible-function')
+
+function sayHello (name, filter) {
+  filter = PossibleFunction(filter)
+  return filter('Hello, ' + name)
+}
+
+// No filter is provided, so the hello message is returned without change:
+sayHello('world') // 'Hello, world'
+
+// A filter is provided which changes the hello message:
+sayHello('world', m => m + '!!') // 'Hello, world!!'
+```
+
+### Return-Value Fallback
+
+If the wrapped value turns out to not be a function, the wrapping function can be configured to return a value of your choosing.
+
+```javascript
+const PossibleFunction = require('possible-function')
+
+function sayHello (nameCallback) {
+  nameCallback = PossibleFunction(nameCallback, 'world')
+  return 'Hello, ' + nameCallback()
+}
+
+sayHello() // 'Hello, world'
+sayHello(() => 'Dolly') // 'Hello, Dolly'
+```
+
+### Self Fallback
+
+If you provide the possible function as its own fallback, then you can accept either a value or a function as an argument for your code. For example, the `sayHello` function in the following example can accept either a string or a function.
+
+```javascript
+const PossibleFunction = require('possible-function')
+
+function sayHello (nameCallback) {
+  nameCallback = PossibleFunction(nameCallback, nameCallback)
+  return 'Hello, ' + nameCallback()
+}
+
+sayHello('world') // 'Hello, world'
+sayHello(() => 'world') // 'Hello, world'
+```
+
+### Custom Fallback
+
+If the wrapped value turns out to not be a function, the wrapping function can execute a custom fallback function instead:
+
+```javascript
+const PossibleFunction = require('possible-function')
+const mightBeAFunction = null
+const callback = PossibleFunction(mightBeAFunction, (...args) => args.length)
+callback('arg 1', 'arg 2') // 2
+```

package/native/token-counter/node_modules/possible-function/test.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const assert = require('assert')
+const PossibleFunction = require('.')
+
+describe('PossibleFunction()', function () {
+  it('should call the underlying value if it’s a function', function (done) {
+    PossibleFunction(done)()
+  })
+
+  it('should pass through the first argument if wrapped value is not a function', function () {
+    assert.strictEqual(PossibleFunction(null)('test'), 'test')
+  })
+
+  it('should return fallback value if wrapped value is not a function', function () {
+    assert.strictEqual(PossibleFunction(null, 'fallback')('test'), 'fallback')
+  })
+
+  it('should support class method arrays', function (done) {
+    class Test {
+      example (arg) {
+        if (arg && this instanceof Test) done()
+      }
+    }
+    const test = new Test()
+    PossibleFunction([test, 'example'])(true)
+  })
+
+  it('should support a fallback function', function () {
+    assert.strictEqual(PossibleFunction(null, arg => arg ? 'yes' : 'no')(true), 'yes')
+  })
+})

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

@@ -0,0 +1,11 @@
+'use strict'
+
+const pfn = require('pfn')
+const wfn = require('wfn')
+
+module.exports = (fn, test = false) => {
+  test = pfn(test, test)
+  return wfn(fn, function qfn () {
+    return test.apply(this, arguments) ? fn.apply(this, arguments) : arguments[0]
+  })
+}

package/native/token-counter/node_modules/qfn/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.