conductor-oss 0.3.4 → 0.4.0

package/web/.next/standalone/node_modules/lru-cache/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "lru-cache",
+  "description": "A cache object that deletes the least-recently-used items.",
+  "version": "7.18.3",
+  "author": "Isaac Z. Schlueter <i@izs.me>",
+  "keywords": [
+    "mru",
+    "lru",
+    "cache"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "npm run prepare",
+    "pretest": "npm run prepare",
+    "presnap": "npm run prepare",
+    "prepare": "node ./scripts/transpile-to-esm.js",
+    "size": "size-limit",
+    "test": "tap",
+    "snap": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags",
+    "format": "prettier --write .",
+    "typedoc": "typedoc ./index.d.ts"
+  },
+  "type": "commonjs",
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": "git://github.com/isaacs/node-lru-cache.git",
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^7.0.8",
+    "@types/node": "^17.0.31",
+    "@types/tap": "^15.0.6",
+    "benchmark": "^2.1.4",
+    "c8": "^7.11.2",
+    "clock-mock": "^1.0.6",
+    "eslint-config-prettier": "^8.5.0",
+    "prettier": "^2.6.2",
+    "size-limit": "^7.0.8",
+    "tap": "^16.3.4",
+    "ts-node": "^10.7.0",
+    "tslib": "^2.4.0",
+    "typedoc": "^0.23.24",
+    "typescript": "^4.6.4"
+  },
+  "license": "ISC",
+  "files": [
+    "index.js",
+    "index.mjs",
+    "index.d.ts"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "prettier": {
+    "semi": false,
+    "printWidth": 70,
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "jsxSingleQuote": false,
+    "bracketSameLine": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf"
+  },
+  "tap": {
+    "nyc-arg": [
+      "--include=index.js"
+    ],
+    "node-arg": [
+      "--expose-gc",
+      "--require",
+      "ts-node/register"
+    ],
+    "ts": false
+  },
+  "size-limit": [
+    {
+      "path": "./index.js"
+    }
+  ]
+}

package/web/.next/standalone/node_modules/ms/index.js

@@ -0,0 +1,162 @@
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function (val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}

package/web/.next/standalone/node_modules/ms/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ms",
+  "version": "2.1.3",
+  "description": "Tiny millisecond conversion utility",
+  "repository": "vercel/ms",
+  "main": "./index",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "precommit": "lint-staged",
+    "lint": "eslint lib/* bin/*",
+    "test": "mocha tests.js"
+  },
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "env": {
+      "node": true,
+      "es6": true
+    }
+  },
+  "lint-staged": {
+    "*.js": [
+      "npm run lint",
+      "prettier --single-quote --write",
+      "git add"
+    ]
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "4.18.2",
+    "expect.js": "0.3.1",
+    "husky": "0.14.3",
+    "lint-staged": "5.0.0",
+    "mocha": "4.0.1",
+    "prettier": "2.0.5"
+  }
+}

package/web/.next/standalone/node_modules/netmask/lib/netmask.js

@@ -0,0 +1,208 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+  var Netmask, atob, chr, chr0, chrA, chra, ip2long, long2ip;
+
+  long2ip = function(long) {
+    var a, b, c, d;
+    a = (long & (0xff << 24)) >>> 24;
+    b = (long & (0xff << 16)) >>> 16;
+    c = (long & (0xff << 8)) >>> 8;
+    d = long & 0xff;
+    return [a, b, c, d].join('.');
+  };
+
+  ip2long = function(ip) {
+    var b, c, i, j, n, ref;
+    b = [];
+    for (i = j = 0; j <= 3; i = ++j) {
+      if (ip.length === 0) {
+        break;
+      }
+      if (i > 0) {
+        if (ip[0] !== '.') {
+          throw new Error('Invalid IP');
+        }
+        ip = ip.substring(1);
+      }
+      ref = atob(ip), n = ref[0], c = ref[1];
+      ip = ip.substring(c);
+      b.push(n);
+    }
+    if (ip.length !== 0) {
+      throw new Error('Invalid IP');
+    }
+    switch (b.length) {
+      case 1:
+        if (b[0] > 0xFFFFFFFF) {
+          throw new Error('Invalid IP');
+        }
+        return b[0] >>> 0;
+      case 2:
+        if (b[0] > 0xFF || b[1] > 0xFFFFFF) {
+          throw new Error('Invalid IP');
+        }
+        return (b[0] << 24 | b[1]) >>> 0;
+      case 3:
+        if (b[0] > 0xFF || b[1] > 0xFF || b[2] > 0xFFFF) {
+          throw new Error('Invalid IP');
+        }
+        return (b[0] << 24 | b[1] << 16 | b[2]) >>> 0;
+      case 4:
+        if (b[0] > 0xFF || b[1] > 0xFF || b[2] > 0xFF || b[3] > 0xFF) {
+          throw new Error('Invalid IP');
+        }
+        return (b[0] << 24 | b[1] << 16 | b[2] << 8 | b[3]) >>> 0;
+      default:
+        throw new Error('Invalid IP');
+    }
+  };
+
+  chr = function(b) {
+    return b.charCodeAt(0);
+  };
+
+  chr0 = chr('0');
+
+  chra = chr('a');
+
+  chrA = chr('A');
+
+  atob = function(s) {
+    var base, dmax, i, n, start;
+    n = 0;
+    base = 10;
+    dmax = '9';
+    i = 0;
+    if (s.length > 1 && s[i] === '0') {
+      if (s[i + 1] === 'x' || s[i + 1] === 'X') {
+        i += 2;
+        base = 16;
+      } else if ('0' <= s[i + 1] && s[i + 1] <= '9') {
+        i++;
+        base = 8;
+        dmax = '7';
+      }
+    }
+    start = i;
+    while (i < s.length) {
+      if ('0' <= s[i] && s[i] <= dmax) {
+        n = (n * base + (chr(s[i]) - chr0)) >>> 0;
+      } else if (base === 16) {
+        if ('a' <= s[i] && s[i] <= 'f') {
+          n = (n * base + (10 + chr(s[i]) - chra)) >>> 0;
+        } else if ('A' <= s[i] && s[i] <= 'F') {
+          n = (n * base + (10 + chr(s[i]) - chrA)) >>> 0;
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+      if (n > 0xFFFFFFFF) {
+        throw new Error('too large');
+      }
+      i++;
+    }
+    if (i === start) {
+      throw new Error('empty octet');
+    }
+    return [n, i];
+  };
+
+  Netmask = (function() {
+    function Netmask(net, mask) {
+      var error, i, j, ref;
+      if (typeof net !== 'string') {
+        throw new Error("Missing `net' parameter");
+      }
+      if (!mask) {
+        ref = net.split('/', 2), net = ref[0], mask = ref[1];
+      }
+      if (!mask) {
+        mask = 32;
+      }
+      if (typeof mask === 'string' && mask.indexOf('.') > -1) {
+        try {
+          this.maskLong = ip2long(mask);
+        } catch (error1) {
+          error = error1;
+          throw new Error("Invalid mask: " + mask);
+        }
+        for (i = j = 32; j >= 0; i = --j) {
+          if (this.maskLong === (0xffffffff << (32 - i)) >>> 0) {
+            this.bitmask = i;
+            break;
+          }
+        }
+      } else if (mask || mask === 0) {
+        this.bitmask = parseInt(mask, 10);
+        this.maskLong = 0;
+        if (this.bitmask > 0) {
+          this.maskLong = (0xffffffff << (32 - this.bitmask)) >>> 0;
+        }
+      } else {
+        throw new Error("Invalid mask: empty");
+      }
+      try {
+        this.netLong = (ip2long(net) & this.maskLong) >>> 0;
+      } catch (error1) {
+        error = error1;
+        throw new Error("Invalid net address: " + net);
+      }
+      if (!(this.bitmask <= 32)) {
+        throw new Error("Invalid mask for ip4: " + mask);
+      }
+      this.size = Math.pow(2, 32 - this.bitmask);
+      this.base = long2ip(this.netLong);
+      this.mask = long2ip(this.maskLong);
+      this.hostmask = long2ip(~this.maskLong);
+      this.first = this.bitmask <= 30 ? long2ip(this.netLong + 1) : this.base;
+      this.last = this.bitmask <= 30 ? long2ip(this.netLong + this.size - 2) : long2ip(this.netLong + this.size - 1);
+      this.broadcast = this.bitmask <= 30 ? long2ip(this.netLong + this.size - 1) : void 0;
+    }
+
+    Netmask.prototype.contains = function(ip) {
+      if (typeof ip === 'string' && (ip.indexOf('/') > 0 || ip.split('.').length !== 4)) {
+        ip = new Netmask(ip);
+      }
+      if (ip instanceof Netmask) {
+        return this.contains(ip.base) && this.contains(ip.broadcast || ip.last);
+      } else {
+        return (ip2long(ip) & this.maskLong) >>> 0 === (this.netLong & this.maskLong) >>> 0;
+      }
+    };
+
+    Netmask.prototype.next = function(count) {
+      if (count == null) {
+        count = 1;
+      }
+      return new Netmask(long2ip(this.netLong + (this.size * count)), this.mask);
+    };
+
+    Netmask.prototype.forEach = function(fn) {
+      var index, lastLong, long;
+      long = ip2long(this.first);
+      lastLong = ip2long(this.last);
+      index = 0;
+      while (long <= lastLong) {
+        fn(long2ip(long), long, index);
+        index++;
+        long++;
+      }
+    };
+
+    Netmask.prototype.toString = function() {
+      return this.base + "/" + this.bitmask;
+    };
+
+    return Netmask;
+
+  })();
+
+  exports.ip2long = ip2long;
+
+  exports.long2ip = long2ip;
+
+  exports.Netmask = Netmask;
+
+}).call(this);

package/web/.next/standalone/node_modules/netmask/package.json

@@ -0,0 +1,36 @@
+{
+    "author": "Olivier Poitrey <rs@rhapsodyk.net>",
+    "name": "netmask",
+    "description": "Parse and lookup IP network blocks",
+    "version": "2.0.2",
+    "homepage": "https://github.com/rs/node-netmask",
+    "bugs": "https://github.com/rs/node-netmask/issues",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/rs/node-netmask.git"
+    },
+    "keywords": [
+        "net",
+        "mask",
+        "ip",
+        "network",
+        "cidr",
+        "netmask",
+        "subnet",
+        "ipcalc"
+    ],
+    "main": "./lib/netmask",
+    "scripts": {
+        "prepublish": "coffee -c lib/*.coffee",
+        "test": "coffee -c lib/*.coffee && vows --spec test/* && mocha tests/*"
+    },
+    "engines": {
+        "node": ">= 0.4.0"
+    },
+    "devDependencies": {
+        "coffee-script": ">=1.2.0",
+        "mocha": "^8.3.2",
+        "vows": "*"
+    }
+}

package/web/.next/standalone/node_modules/once/once.js

@@ -0,0 +1,42 @@
+var wrappy = require('wrappy')
+module.exports = wrappy(once)
+module.exports.strict = wrappy(onceStrict)
+
+once.proto = once(function () {
+  Object.defineProperty(Function.prototype, 'once', {
+    value: function () {
+      return once(this)
+    },
+    configurable: true
+  })
+
+  Object.defineProperty(Function.prototype, 'onceStrict', {
+    value: function () {
+      return onceStrict(this)
+    },
+    configurable: true
+  })
+})
+
+function once (fn) {
+  var f = function () {
+    if (f.called) return f.value
+    f.called = true
+    return f.value = fn.apply(this, arguments)
+  }
+  f.called = false
+  return f
+}
+
+function onceStrict (fn) {
+  var f = function () {
+    if (f.called)
+      throw new Error(f.onceError)
+    f.called = true
+    return f.value = fn.apply(this, arguments)
+  }
+  var name = fn.name || 'Function wrapped with `once`'
+  f.onceError = name + " shouldn't be called more than once"
+  f.called = false
+  return f
+}

package/web/.next/standalone/node_modules/once/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "once",
+  "version": "1.4.0",
+  "description": "Run a function exactly one time",
+  "main": "once.js",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "wrappy": "1"
+  },
+  "devDependencies": {
+    "tap": "^7.0.1"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "files": [
+    "once.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/once"
+  },
+  "keywords": [
+    "once",
+    "function",
+    "one",
+    "single"
+  ],
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "license": "ISC"
+}