conductor-oss 0.3.4 → 0.4.0

package/web/.next/standalone/node_modules/cosmiconfig/dist/loaders.js

@@ -0,0 +1,150 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-require-imports */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTs = exports.loadTsSync = exports.loadYaml = exports.loadJson = exports.loadJs = exports.loadJsSync = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const crypto_1 = require("crypto");
+let importFresh;
+const loadJsSync = function loadJsSync(filepath) {
+    if (importFresh === undefined) {
+        importFresh = require('import-fresh');
+    }
+    return importFresh(filepath);
+};
+exports.loadJsSync = loadJsSync;
+const loadJs = async function loadJs(filepath) {
+    try {
+        const { href } = (0, url_1.pathToFileURL)(await (0, promises_1.realpath)(filepath));
+        return (await import(href)).default;
+    }
+    catch (error) {
+        try {
+            return (0, exports.loadJsSync)(filepath, '');
+        }
+        catch (requireError) {
+            /* istanbul ignore next -- @preserve */
+            if (requireError.code === 'ERR_REQUIRE_ESM' ||
+                (requireError instanceof SyntaxError &&
+                    requireError
+                        .toString()
+                        .includes('Cannot use import statement outside a module'))) {
+                throw error;
+            }
+            throw requireError;
+        }
+    }
+};
+exports.loadJs = loadJs;
+let parseJson;
+const loadJson = function loadJson(filepath, content) {
+    if (parseJson === undefined) {
+        parseJson = require('parse-json');
+    }
+    try {
+        return parseJson(content);
+    }
+    catch (error) {
+        error.message = `JSON Error in ${filepath}:\n${error.message}`;
+        throw error;
+    }
+};
+exports.loadJson = loadJson;
+let yaml;
+const loadYaml = function loadYaml(filepath, content) {
+    if (yaml === undefined) {
+        yaml = require('js-yaml');
+    }
+    try {
+        return yaml.load(content);
+    }
+    catch (error) {
+        error.message = `YAML Error in ${filepath}:\n${error.message}`;
+        throw error;
+    }
+};
+exports.loadYaml = loadYaml;
+let typescript;
+const loadTsSync = function loadTsSync(filepath, content) {
+    /* istanbul ignore next -- @preserve */
+    if (typescript === undefined) {
+        typescript = require('typescript');
+    }
+    const compiledFilepath = `${filepath}.${(0, crypto_1.randomUUID)()}.cjs`;
+    try {
+        const config = resolveTsConfig(path_1.default.dirname(filepath)) ?? {};
+        config.compilerOptions = {
+            ...config.compilerOptions,
+            module: typescript.ModuleKind.NodeNext,
+            moduleResolution: typescript.ModuleResolutionKind.NodeNext,
+            target: typescript.ScriptTarget.ES2022,
+            noEmit: false,
+        };
+        content = typescript.transpileModule(content, config).outputText;
+        (0, fs_1.writeFileSync)(compiledFilepath, content);
+        return (0, exports.loadJsSync)(compiledFilepath, content).default;
+    }
+    catch (error) {
+        error.message = `TypeScript Error in ${filepath}:\n${error.message}`;
+        throw error;
+    }
+    finally {
+        if ((0, fs_1.existsSync)(compiledFilepath)) {
+            (0, fs_1.rmSync)(compiledFilepath);
+        }
+    }
+};
+exports.loadTsSync = loadTsSync;
+const loadTs = async function loadTs(filepath, content) {
+    if (typescript === undefined) {
+        typescript = (await import('typescript')).default;
+    }
+    const compiledFilepath = `${filepath}.${(0, crypto_1.randomUUID)()}.mjs`;
+    let transpiledContent;
+    try {
+        try {
+            const config = resolveTsConfig(path_1.default.dirname(filepath)) ?? {};
+            config.compilerOptions = {
+                ...config.compilerOptions,
+                module: typescript.ModuleKind.ES2022,
+                moduleResolution: typescript.ModuleResolutionKind.Bundler,
+                target: typescript.ScriptTarget.ES2022,
+                noEmit: false,
+            };
+            transpiledContent = typescript.transpileModule(content, config).outputText;
+            await (0, promises_1.writeFile)(compiledFilepath, transpiledContent);
+        }
+        catch (error) {
+            error.message = `TypeScript Error in ${filepath}:\n${error.message}`;
+            throw error;
+        }
+        // eslint-disable-next-line @typescript-eslint/return-await
+        return await (0, exports.loadJs)(compiledFilepath, transpiledContent);
+    }
+    finally {
+        if ((0, fs_1.existsSync)(compiledFilepath)) {
+            await (0, promises_1.rm)(compiledFilepath);
+        }
+    }
+};
+exports.loadTs = loadTs;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function resolveTsConfig(directory) {
+    const filePath = typescript.findConfigFile(directory, (fileName) => {
+        return typescript.sys.fileExists(fileName);
+    });
+    if (filePath !== undefined) {
+        const { config, error } = typescript.readConfigFile(filePath, (path) => typescript.sys.readFile(path));
+        if (error) {
+            throw new Error(`Error in ${filePath}: ${error.messageText.toString()}`);
+        }
+        return config;
+    }
+    return;
+}
+//# sourceMappingURL=loaders.js.map

package/web/.next/standalone/node_modules/cosmiconfig/dist/merge.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeAll = exports.hasOwn = void 0;
+/* eslint-disable @typescript-eslint/unbound-method */
+exports.hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
+const objToString = Function.prototype.call.bind(Object.prototype.toString);
+/* eslint-enable @typescript-eslint/unbound-method */
+function isPlainObject(obj) {
+    return objToString(obj) === '[object Object]';
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function merge(target, source, options) {
+    for (const key of Object.keys(source)) {
+        const newValue = source[key];
+        if ((0, exports.hasOwn)(target, key)) {
+            if (Array.isArray(target[key]) && Array.isArray(newValue)) {
+                if (options.mergeArrays) {
+                    target[key].push(...newValue);
+                    continue;
+                }
+            }
+            else if (isPlainObject(target[key]) && isPlainObject(newValue)) {
+                target[key] = merge(target[key], newValue, options);
+                continue;
+            }
+        }
+        target[key] = newValue;
+    }
+    return target;
+}
+/**
+ * Merges multiple objects. Doesn't care about cloning non-primitives, as we load all these objects fresh from a file.
+ */
+function mergeAll(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+objects, options) {
+    return objects.reduce((target, source) => merge(target, source, options), {});
+}
+exports.mergeAll = mergeAll;
+//# sourceMappingURL=merge.js.map

package/web/.next/standalone/node_modules/cosmiconfig/dist/readFile.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readFile = readFile;
+exports.readFileSync = readFileSync;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function fsReadFileAsync(pathname, encoding) {
+  return new Promise((resolve, reject) => {
+    _fs.default.readFile(pathname, encoding, (error, contents) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      resolve(contents);
+    });
+  });
+}
+
+async function readFile(filepath, options = {}) {
+  const throwNotFound = options.throwNotFound === true;
+
+  try {
+    const content = await fsReadFileAsync(filepath, 'utf8');
+    return content;
+  } catch (error) {
+    if (throwNotFound === false && (error.code === 'ENOENT' || error.code === 'EISDIR')) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+function readFileSync(filepath, options = {}) {
+  const throwNotFound = options.throwNotFound === true;
+
+  try {
+    const content = _fs.default.readFileSync(filepath, 'utf8');
+
+    return content;
+  } catch (error) {
+    if (throwNotFound === false && (error.code === 'ENOENT' || error.code === 'EISDIR')) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+//# sourceMappingURL=readFile.js.map

package/web/.next/standalone/node_modules/cosmiconfig/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/web/.next/standalone/node_modules/cosmiconfig/dist/util.js

@@ -0,0 +1,99 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDirectorySync = exports.isDirectory = exports.removeUndefinedValuesFromObject = exports.getPropertyByPath = exports.emplace = void 0;
+const fs_1 = __importStar(require("fs"));
+/**
+ * @internal
+ */
+function emplace(map, key, fn) {
+    const cached = map.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = fn();
+    map.set(key, result);
+    return result;
+}
+exports.emplace = emplace;
+// Resolves property names or property paths defined with period-delimited
+// strings or arrays of strings. Property names that are found on the source
+// object are used directly (even if they include a period).
+// Nested property names that include periods, within a path, are only
+// understood in array paths.
+/**
+ * @internal
+ */
+function getPropertyByPath(source, path) {
+    if (typeof path === 'string' &&
+        Object.prototype.hasOwnProperty.call(source, path)) {
+        return source[path];
+    }
+    const parsedPath = typeof path === 'string' ? path.split('.') : path;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return parsedPath.reduce((previous, key) => {
+        if (previous === undefined) {
+            return previous;
+        }
+        return previous[key];
+    }, source);
+}
+exports.getPropertyByPath = getPropertyByPath;
+/** @internal */
+function removeUndefinedValuesFromObject(options) {
+    return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+}
+exports.removeUndefinedValuesFromObject = removeUndefinedValuesFromObject;
+/** @internal */
+/* istanbul ignore next -- @preserve */
+async function isDirectory(path) {
+    try {
+        const stat = await fs_1.promises.stat(path);
+        return stat.isDirectory();
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+}
+exports.isDirectory = isDirectory;
+/** @internal */
+/* istanbul ignore next -- @preserve */
+function isDirectorySync(path) {
+    try {
+        const stat = fs_1.default.statSync(path);
+        return stat.isDirectory();
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+}
+exports.isDirectorySync = isDirectorySync;
+//# sourceMappingURL=util.js.map

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

@@ -0,0 +1,103 @@
+{
+  "name": "cosmiconfig",
+  "version": "9.0.1",
+  "description": "Find and load configuration from a package.json property, rc file, TypeScript module, and more!",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "scripts": {
+    "clean": "git clean -Xdf -e '!node_modules' .",
+    "build": "npm run build:tsc",
+    "build:tsc": "cross-env NODE_ENV=production tsc -b",
+    "dev": "npm run build:tsc -- --watch",
+    "lint": "eslint --ext .js,.ts .",
+    "lint:fix": "eslint --ext .js,.ts . --fix",
+    "lint:md": "remark-preset-davidtheclark",
+    "format": "prettier \"**/*.{js,ts,json,yml,yaml}\" --write",
+    "format:md": "remark-preset-davidtheclark --format",
+    "format:check": "prettier \"**/*.{js,ts,json,yml,yaml}\" --check",
+    "test": "vitest run --coverage",
+    "test:watch": "vitest",
+    "check:all": "npm run test && npm run lint && npm run format:check",
+    "prepublishOnly": "npm run check:all && npm run build",
+    "prepare": "husky install"
+  },
+  "lint-staged": {
+    "*.{js,ts}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,yml,yaml}": [
+      "prettier --write"
+    ],
+    "*.md": [
+      "remark-preset-davidtheclark",
+      "remark-preset-davidtheclark --format"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cosmiconfig/cosmiconfig.git"
+  },
+  "keywords": [
+    "load",
+    "configuration",
+    "config"
+  ],
+  "author": "Daniel Fischer <daniel@d-fischer.dev>",
+  "contributors": [
+    "Randolf J <jrandolf@google.com>",
+    "David Clark <david.dave.clark@gmail.com>",
+    "Bogdan Chadkin <trysound@yandex.ru>",
+    "Suhas Karanth <sudo.suhas@gmail.com>"
+  ],
+  "funding": "https://github.com/sponsors/d-fischer",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/cosmiconfig/cosmiconfig/issues"
+  },
+  "homepage": "https://github.com/cosmiconfig/cosmiconfig#readme",
+  "peerDependencies": {
+    "typescript": ">=4.9.5"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "env-paths": "^2.2.1",
+    "import-fresh": "^3.3.0",
+    "js-yaml": "^4.1.0",
+    "parse-json": "^5.2.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.5",
+    "@types/node": "^14",
+    "@types/parse-json": "^4.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/parser": "^6.5.0",
+    "@vitest/coverage-istanbul": "^0.34.3",
+    "cross-env": "^7.0.3",
+    "eslint": "^8.48.0",
+    "eslint-config-davidtheclark-node": "^0.2.2",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-import-resolver-typescript": "^3.6.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-vitest": "^0.2.8",
+    "husky": "^8.0.3",
+    "lint-staged": "^14.0.1",
+    "parent-module": "^3.0.0",
+    "prettier": "^3.0.3",
+    "remark-preset-davidtheclark": "^0.12.0",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.3"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}

package/web/.next/standalone/node_modules/data-uri-to-buffer/dist/common.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDataUriToBuffer = void 0;
+/**
+ * Returns a `Buffer` instance from the given data URI `uri`.
+ *
+ * @param {String} uri Data URI to turn into a Buffer instance
+ */
+const makeDataUriToBuffer = (convert) => (uri) => {
+    uri = String(uri);
+    if (!/^data:/i.test(uri)) {
+        throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
+    }
+    // strip newlines
+    uri = uri.replace(/\r?\n/g, '');
+    // split the URI up into the "metadata" and the "data" portions
+    const firstComma = uri.indexOf(',');
+    if (firstComma === -1 || firstComma <= 4) {
+        throw new TypeError('malformed data: URI');
+    }
+    // remove the "data:" scheme and parse the metadata
+    const meta = uri.substring(5, firstComma).split(';');
+    let charset = '';
+    let base64 = false;
+    const type = meta[0] || 'text/plain';
+    let typeFull = type;
+    for (let i = 1; i < meta.length; i++) {
+        if (meta[i] === 'base64') {
+            base64 = true;
+        }
+        else if (meta[i]) {
+            typeFull += `;${meta[i]}`;
+            if (meta[i].indexOf('charset=') === 0) {
+                charset = meta[i].substring(8);
+            }
+        }
+    }
+    // defaults to US-ASCII only if type is not provided
+    if (!meta[0] && !charset.length) {
+        typeFull += ';charset=US-ASCII';
+        charset = 'US-ASCII';
+    }
+    // get the encoded data portion and decode URI-encoded chars
+    const data = unescape(uri.substring(firstComma + 1));
+    const buffer = base64 ? convert.base64ToArrayBuffer(data) : convert.stringToBuffer(data);
+    return {
+        type,
+        typeFull,
+        charset,
+        buffer,
+    };
+};
+exports.makeDataUriToBuffer = makeDataUriToBuffer;
+//# sourceMappingURL=common.js.map

package/web/.next/standalone/node_modules/data-uri-to-buffer/dist/node.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataUriToBuffer = void 0;
+const common_1 = require("./common");
+function nodeBuffertoArrayBuffer(nodeBuf) {
+    if (nodeBuf.byteLength === nodeBuf.buffer.byteLength) {
+        return nodeBuf.buffer; // large strings may get their own memory allocation
+    }
+    const buffer = new ArrayBuffer(nodeBuf.byteLength);
+    const view = new Uint8Array(buffer);
+    view.set(nodeBuf);
+    return buffer;
+}
+function base64ToArrayBuffer(base64) {
+    return nodeBuffertoArrayBuffer(Buffer.from(base64, 'base64'));
+}
+function stringToBuffer(str) {
+    return nodeBuffertoArrayBuffer(Buffer.from(str, 'ascii'));
+}
+/**
+ * Returns a `Buffer` instance from the given data URI `uri`.
+ *
+ * @param {String} uri Data URI to turn into a Buffer instance
+ */
+exports.dataUriToBuffer = (0, common_1.makeDataUriToBuffer)({ stringToBuffer, base64ToArrayBuffer });
+//# sourceMappingURL=node.js.map

package/web/.next/standalone/node_modules/data-uri-to-buffer/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "data-uri-to-buffer",
+  "version": "6.0.2",
+  "description": "Create an ArrayBuffer instance from a Data URI string",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "node": "./dist/node.js",
+    "default": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TooTallNate/proxy-agents.git",
+    "directory": "packages/data-uri-to-buffer"
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "keywords": [
+    "data",
+    "uri",
+    "datauri",
+    "data-uri",
+    "buffer",
+    "convert",
+    "rfc2397",
+    "2397"
+  ],
+  "author": "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io/)",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^27.0.2",
+    "@types/node": "^14.18.45",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.4",
+    "tsconfig": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --env node --verbose --bail",
+    "lint": "eslint . --ext .ts",
+    "pack": "node ../../scripts/pack.mjs"
+  }
+}

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

@@ -0,0 +1,64 @@
+{
+  "name": "debug",
+  "version": "4.4.3",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/debug-js/debug.git"
+  },
+  "description": "Lightweight debugging utility for Node.js and the browser",
+  "keywords": [
+    "debug",
+    "log",
+    "debugger"
+  ],
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "author": "Josh Junon (https://github.com/qix-)",
+  "contributors": [
+    "TJ Holowaychuk <tj@vision-media.ca>",
+    "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io)",
+    "Andrew Rhyne <rhyneandrew@gmail.com>"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "lint": "xo",
+    "test": "npm run test:node && npm run test:browser && npm run lint",
+    "test:node": "mocha test.js test.node.js",
+    "test:browser": "karma start --single-run",
+    "test:coverage": "cat ./coverage/lcov.info | coveralls"
+  },
+  "dependencies": {
+    "ms": "^2.1.3"
+  },
+  "devDependencies": {
+    "brfs": "^2.0.1",
+    "browserify": "^16.2.3",
+    "coveralls": "^3.0.2",
+    "karma": "^3.1.4",
+    "karma-browserify": "^6.0.0",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-mocha": "^1.3.0",
+    "mocha": "^5.2.0",
+    "mocha-lcov-reporter": "^1.2.0",
+    "sinon": "^14.0.0",
+    "xo": "^0.23.0"
+  },
+  "peerDependenciesMeta": {
+    "supports-color": {
+      "optional": true
+    }
+  },
+  "main": "./src/index.js",
+  "browser": "./src/browser.js",
+  "engines": {
+    "node": ">=6.0"
+  },
+  "xo": {
+    "rules": {
+      "import/extensions": "off"
+    }
+  }
+}