@ai-workbench/connect 0.0.0-stage → 0.7.6

package/node_modules/js-yaml/lib/type/null.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const Type = require('../type')
+
+function resolveYamlNull (data) {
+  if (data === null) return true
+
+  const max = data.length
+
+  return (max === 1 && data === '~') ||
+         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'))
+}
+
+function constructYamlNull () {
+  return null
+}
+
+function isNull (object) {
+  return object === null
+}
+
+module.exports = new Type('tag:yaml.org,2002:null', {
+  kind: 'scalar',
+  resolve: resolveYamlNull,
+  construct: constructYamlNull,
+  predicate: isNull,
+  represent: {
+    canonical: function () { return '~' },
+    lowercase: function () { return 'null' },
+    uppercase: function () { return 'NULL' },
+    camelcase: function () { return 'Null' },
+    empty: function () { return '' }
+  },
+  defaultStyle: 'lowercase'
+})

package/node_modules/js-yaml/lib/type/omap.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const Type = require('../type')
+
+const _hasOwnProperty = Object.prototype.hasOwnProperty
+const _toString = Object.prototype.toString
+
+function resolveYamlOmap (data) {
+  if (data === null) return true
+
+  const objectKeys = {}
+  const object = data
+
+  for (let index = 0, length = object.length; index < length; index += 1) {
+    const pair = object[index]
+    let pairHasKey = false
+
+    if (_toString.call(pair) !== '[object Object]') return false
+
+    let pairKey
+    for (pairKey in pair) {
+      if (_hasOwnProperty.call(pair, pairKey)) {
+        if (!pairHasKey) pairHasKey = true
+        else return false
+      }
+    }
+
+    if (!pairHasKey) return false
+
+    if (_hasOwnProperty.call(objectKeys, pairKey)) return false
+    Object.defineProperty(objectKeys, pairKey, { value: true })
+  }
+
+  return true
+}
+
+function constructYamlOmap (data) {
+  return data !== null ? data : []
+}
+
+module.exports = new Type('tag:yaml.org,2002:omap', {
+  kind: 'sequence',
+  resolve: resolveYamlOmap,
+  construct: constructYamlOmap
+})

package/node_modules/js-yaml/lib/type/pairs.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const Type = require('../type')
+
+const _toString = Object.prototype.toString
+
+function resolveYamlPairs (data) {
+  if (data === null) return true
+
+  const object = data
+
+  const result = new Array(object.length)
+
+  for (let index = 0, length = object.length; index < length; index += 1) {
+    const pair = object[index]
+
+    if (_toString.call(pair) !== '[object Object]') return false
+
+    const keys = Object.keys(pair)
+
+    if (keys.length !== 1) return false
+
+    result[index] = [keys[0], pair[keys[0]]]
+  }
+
+  return true
+}
+
+function constructYamlPairs (data) {
+  if (data === null) return []
+
+  const object = data
+  const result = new Array(object.length)
+
+  for (let index = 0, length = object.length; index < length; index += 1) {
+    const pair = object[index]
+
+    const keys = Object.keys(pair)
+
+    result[index] = [keys[0], pair[keys[0]]]
+  }
+
+  return result
+}
+
+module.exports = new Type('tag:yaml.org,2002:pairs', {
+  kind: 'sequence',
+  resolve: resolveYamlPairs,
+  construct: constructYamlPairs
+})

package/node_modules/js-yaml/lib/type/seq.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const Type = require('../type')
+
+module.exports = new Type('tag:yaml.org,2002:seq', {
+  kind: 'sequence',
+  construct: function (data) { return data !== null ? data : [] }
+})

package/node_modules/js-yaml/lib/type/set.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const Type = require('../type')
+
+const _hasOwnProperty = Object.prototype.hasOwnProperty
+
+function resolveYamlSet (data) {
+  if (data === null) return true
+
+  const object = data
+
+  for (const key in object) {
+    if (_hasOwnProperty.call(object, key)) {
+      if (object[key] !== null) return false
+    }
+  }
+
+  return true
+}
+
+function constructYamlSet (data) {
+  return data !== null ? data : {}
+}
+
+module.exports = new Type('tag:yaml.org,2002:set', {
+  kind: 'mapping',
+  resolve: resolveYamlSet,
+  construct: constructYamlSet
+})

package/node_modules/js-yaml/lib/type/str.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const Type = require('../type')
+
+module.exports = new Type('tag:yaml.org,2002:str', {
+  kind: 'scalar',
+  construct: function (data) { return data !== null ? data : '' }
+})

package/node_modules/js-yaml/lib/type/timestamp.js

@@ -0,0 +1,88 @@
+'use strict'
+
+const Type = require('../type')
+
+const YAML_DATE_REGEXP = new RegExp(
+  '^([0-9][0-9][0-9][0-9])' + // [1] year
+  '-([0-9][0-9])' + // [2] month
+  '-([0-9][0-9])$')                   // [3] day
+
+const YAML_TIMESTAMP_REGEXP = new RegExp(
+  '^([0-9][0-9][0-9][0-9])' + // [1] year
+  '-([0-9][0-9]?)' + // [2] month
+  '-([0-9][0-9]?)' + // [3] day
+  '(?:[Tt]|[ \\t]+)' + // ...
+  '([0-9][0-9]?)' + // [4] hour
+  ':([0-9][0-9])' + // [5] minute
+  ':([0-9][0-9])' + // [6] second
+  '(?:\\.([0-9]*))?' + // [7] fraction
+  '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tzHour
+  '(?::([0-9][0-9]))?))?$')           // [11] tzMinute
+
+function resolveYamlTimestamp (data) {
+  if (data === null) return false
+  if (YAML_DATE_REGEXP.exec(data) !== null) return true
+  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true
+  return false
+}
+
+function constructYamlTimestamp (data) {
+  let fraction = 0
+  let delta = null
+
+  let match = YAML_DATE_REGEXP.exec(data)
+  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data)
+
+  if (match === null) throw new Error('Date resolve error')
+
+  // match: [1] year [2] month [3] day
+
+  const year = +(match[1])
+  const month = +(match[2]) - 1 // JS month starts with 0
+  const day = +(match[3])
+
+  if (!match[4]) { // no hour
+    return new Date(Date.UTC(year, month, day))
+  }
+
+  // match: [4] hour [5] minute [6] second [7] fraction
+
+  const hour = +(match[4])
+  const minute = +(match[5])
+  const second = +(match[6])
+
+  if (match[7]) {
+    fraction = match[7].slice(0, 3)
+    while (fraction.length < 3) { // milli-seconds
+      fraction += '0'
+    }
+    fraction = +fraction
+  }
+
+  // match: [8] tz [9] tz_sign [10] tzHour [11] tzMinute
+
+  if (match[9]) {
+    const tzHour = +(match[10])
+    const tzMinute = +(match[11] || 0)
+    delta = (tzHour * 60 + tzMinute) * 60000 // delta in mili-seconds
+    if (match[9] === '-') delta = -delta
+  }
+
+  const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction))
+
+  if (delta) date.setTime(date.getTime() - delta)
+
+  return date
+}
+
+function representYamlTimestamp (object /*, style */) {
+  return object.toISOString()
+}
+
+module.exports = new Type('tag:yaml.org,2002:timestamp', {
+  kind: 'scalar',
+  resolve: resolveYamlTimestamp,
+  construct: constructYamlTimestamp,
+  instanceOf: Date,
+  represent: representYamlTimestamp
+})

package/node_modules/js-yaml/lib/type.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const YAMLException = require('./exception')
+
+const TYPE_CONSTRUCTOR_OPTIONS = [
+  'kind',
+  'multi',
+  'resolve',
+  'construct',
+  'instanceOf',
+  'predicate',
+  'represent',
+  'representName',
+  'defaultStyle',
+  'styleAliases'
+]
+
+const YAML_NODE_KINDS = [
+  'scalar',
+  'sequence',
+  'mapping'
+]
+
+function compileStyleAliases (map) {
+  const result = {}
+
+  if (map !== null) {
+    Object.keys(map).forEach(function (style) {
+      map[style].forEach(function (alias) {
+        result[String(alias)] = style
+      })
+    })
+  }
+
+  return result
+}
+
+function Type (tag, options) {
+  options = options || {}
+
+  Object.keys(options).forEach(function (name) {
+    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
+      throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.')
+    }
+  })
+
+  // TODO: Add tag format check.
+  this.options = options // keep original options in case user wants to extend this type later
+  this.tag = tag
+  this.kind = options['kind'] || null
+  this.resolve = options['resolve'] || function () { return true }
+  this.construct = options['construct'] || function (data) { return data }
+  this.instanceOf = options['instanceOf'] || null
+  this.predicate = options['predicate'] || null
+  this.represent = options['represent'] || null
+  this.representName = options['representName'] || null
+  this.defaultStyle = options['defaultStyle'] || null
+  this.multi = options['multi'] || false
+  this.styleAliases = compileStyleAliases(options['styleAliases'] || null)
+
+  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+    throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.')
+  }
+}
+
+module.exports = Type

package/node_modules/js-yaml/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "js-yaml",
+  "version": "4.3.2",
+  "description": "YAML 1.2 parser and serializer",
+  "keywords": [
+    "yaml",
+    "parser",
+    "serializer",
+    "pyyaml"
+  ],
+  "author": "Vladimir Zapparov <dervus.grim@gmail.com>",
+  "contributors": [
+    "Aleksey V Zapparov <ixti@member.fsf.org> (http://www.ixti.net/)",
+    "Vitaly Puzrin <vitaly@rcdesign.ru> (https://github.com/puzrin)",
+    "Martin Grenfell <martin.grenfell@gmail.com> (http://got-ravings.blogspot.com)"
+  ],
+  "license": "MIT",
+  "repository": "nodeca/js-yaml",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/puzrin"
+    },
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/nodeca"
+    }
+  ],
+  "files": [
+    "index.js",
+    "lib/",
+    "bin/",
+    "dist/"
+  ],
+  "publishConfig": {
+    "tag": "v4-legacy"
+  },
+  "bin": {
+    "js-yaml": "bin/js-yaml.js"
+  },
+  "module": "./dist/js-yaml.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/js-yaml.mjs",
+      "require": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint-fix": "eslint . --fix",
+    "test": "npm run lint && npm run test:core && npm run test:build",
+    "test:core": "node --test test/core/*.test.*",
+    "test:build": "npm run build && node --test test/build/*.test.*",
+    "coverage": "npm run build && c8 --include 'lib/**' -r text -r html -r lcov node --test test/core/*.test.*",
+    "build": "node support/build-dist.mjs",
+    "build:demo": "npm run lint && node support/build_demo.mjs",
+    "gh-demo": "npm run build:demo && gh-pages -d demo -f",
+    "prepack": "npm test && npm run build"
+  },
+  "unpkg": "dist/js-yaml.min.js",
+  "jsdelivr": "dist/js-yaml.min.js",
+  "dependencies": {
+    "argparse": "^2.0.1"
+  },
+  "devDependencies": {
+    "@babel/core": "8.0.1",
+    "@babel/preset-env": "8.0.1",
+    "@rollup/plugin-commonjs": "29.0.3",
+    "@rollup/plugin-terser": "0.4.4",
+    "c8": "^11.0.0",
+    "codemirror": "^5.65.21",
+    "eslint": "^9.39.4",
+    "fast-check": "^4.8.0",
+    "gh-pages": "^6.3.0",
+    "neostandard": "^0.13.0",
+    "tinybench": "^6.0.2",
+    "vite": "7.3.6",
+    "vite-plugin-node-polyfills": "^0.28.0",
+    "vite-plugin-singlefile": "^2.3.3",
+    "workerpool": "^10.0.2"
+  }
+}

package/node_modules/pend/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (Expat)
+
+Copyright (c) 2014 Andrew Kelley
+
+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/pend/README.md

@@ -0,0 +1,41 @@
+# Pend
+
+Dead-simple optimistic async helper.
+
+## Usage
+
+```js
+var Pend = require('pend');
+var pend = new Pend();
+pend.max = 10; // defaults to Infinity
+setTimeout(pend.hold(), 1000); // pend.wait will have to wait for this hold to finish
+pend.go(function(cb) {
+  console.log("this function is immediately executed");
+  setTimeout(function() {
+    console.log("calling cb 1");
+    cb();
+  }, 500);
+});
+pend.go(function(cb) {
+  console.log("this function is also immediately executed");
+  setTimeout(function() {
+    console.log("calling cb 2");
+    cb();
+  }, 1000);
+});
+pend.wait(function(err) {
+  console.log("this is excuted when the first 2 have returned.");
+  console.log("err is a possible error in the standard callback style.");
+});
+```
+
+Output:
+
+```
+this function is immediately executed
+this function is also immediately executed
+calling cb 1
+calling cb 2
+this is excuted when the first 2 have returned.
+err is a possible error in the standard callback style.
+```

package/node_modules/pend/index.js

@@ -0,0 +1,55 @@
+module.exports = Pend;
+
+function Pend() {
+  this.pending = 0;
+  this.max = Infinity;
+  this.listeners = [];
+  this.waiting = [];
+  this.error = null;
+}
+
+Pend.prototype.go = function(fn) {
+  if (this.pending < this.max) {
+    pendGo(this, fn);
+  } else {
+    this.waiting.push(fn);
+  }
+};
+
+Pend.prototype.wait = function(cb) {
+  if (this.pending === 0) {
+    cb(this.error);
+  } else {
+    this.listeners.push(cb);
+  }
+};
+
+Pend.prototype.hold = function() {
+  return pendHold(this);
+};
+
+function pendHold(self) {
+  self.pending += 1;
+  var called = false;
+  return onCb;
+  function onCb(err) {
+    if (called) throw new Error("callback called twice");
+    called = true;
+    self.error = self.error || err;
+    self.pending -= 1;
+    if (self.waiting.length > 0 && self.pending < self.max) {
+      pendGo(self, self.waiting.shift());
+    } else if (self.pending === 0) {
+      var listeners = self.listeners;
+      self.listeners = [];
+      listeners.forEach(cbListener);
+    }
+  }
+  function cbListener(listener) {
+    listener(self.error);
+  }
+}
+
+function pendGo(self, fn) {
+  fn(pendHold(self));
+}

package/node_modules/pend/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "pend",
+  "version": "1.2.0",
+  "description": "dead-simple optimistic async helper",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "author": "Andrew Kelley <superjoe30@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/andrewrk/node-pend.git"
+  },
+  "bugs": {
+    "url": "https://github.com/andrewrk/node-pend/issues"
+  }
+}

package/node_modules/pend/test.js

@@ -0,0 +1,137 @@
+var assert = require('assert');
+var Pend = require('./');
+
+var tests = [
+  {
+    name: "basic",
+    fn: testBasic,
+  },
+  {
+    name: "max",
+    fn: testWithMax,
+  },
+  {
+    name: "callback twice",
+    fn: testCallbackTwice,
+  },
+  {
+    name: "calling wait twice",
+    fn: testCallingWaitTwice,
+  },
+  {
+    name: "hold()",
+    fn: testHoldFn,
+  },
+];
+var testCount = tests.length;
+
+doOneTest();
+
+function doOneTest() {
+  var test = tests.shift();
+  if (!test) {
+    console.log(testCount + " tests passed.");
+    return;
+  }
+  process.stdout.write(test.name + "...");
+  test.fn(function() {
+    process.stdout.write("OK\n");
+    doOneTest();
+  });
+}
+
+function testBasic(cb) {
+  var pend = new Pend();
+  var results = [];
+  pend.go(function(cb) {
+    results.push(1);
+    setTimeout(function() {
+      results.push(3);
+      cb();
+    }, 500);
+  });
+  pend.go(function(cb) {
+    results.push(2);
+    setTimeout(function() {
+      results.push(4);
+      cb();
+    }, 1000);
+  });
+  pend.wait(function(err) {
+    assert.deepEqual(results, [1,2,3,4]);
+    cb();
+  });
+  assert.deepEqual(results, [1, 2]);
+}
+
+function testWithMax(cb) {
+  var pend = new Pend();
+  var results = [];
+  pend.max = 2;
+  pend.go(function(cb) {
+    results.push('a');
+    setTimeout(function() {
+      results.push(1);
+      cb();
+    }, 500);
+  });
+  pend.go(function(cb) {
+    results.push('b');
+    setTimeout(function() {
+      results.push(1);
+      cb();
+    }, 500);
+  });
+  pend.go(function(cb) {
+    results.push('c');
+    setTimeout(function() {
+      results.push(2);
+      cb();
+    }, 100);
+  });
+  pend.wait(function(err) {
+    assert.deepEqual(results, ['a', 'b', 1, 'c', 1, 2]);
+    cb();
+  });
+  assert.deepEqual(results, ['a', 'b']);
+}
+
+function testCallbackTwice(cb) {
+  var pend = new Pend();
+  pend.go(function(cb) {
+    setTimeout(cb, 100);
+  });
+  pend.go(function(cb) {
+    cb();
+    assert.throws(cb, /callback called twice/);
+  });
+  pend.wait(cb);
+}
+
+function testCallingWaitTwice(cb) {
+  var pend = new Pend();
+  pend.go(function(cb) {
+    setTimeout(cb, 100);
+  });
+  pend.wait(function() {
+    pend.go(function(cb) {
+      setTimeout(cb, 50);
+    });
+    pend.go(function(cb) {
+      setTimeout(cb, 10);
+    });
+    pend.go(function(cb) {
+      setTimeout(cb, 20);
+    });
+    pend.wait(cb);
+  });
+}
+
+function testHoldFn(cb) {
+  var pend = new Pend();
+  setTimeout(pend.hold(), 100);
+  pend.go(function(cb) {
+    cb();
+  });
+  pend.wait(cb);
+}