@bonginkan/maria
Version:
MARIA OS v5.9.5 – Self-Evolving Organizational Intelligence OS | Speed Improvement Phase 3: LLM Optimization + Command Refactoring | Performance Measurement + Run Evidence System | Zero ESLint/TypeScript Errors | 人とAIが役割を持ち、学び、進化し続けるための仕事のOS | GraphRAG ×
1,286 lines (1,276 loc) • 21.1 MB
JavaScript
#!/usr/bin/env node
'use strict';
var util$1 = require('util');
var chalk16 = require('chalk');
var fs87 = require('fs');
var path259 = require('path');
var dotenv = require('dotenv');
var Stream4 = require('stream');
var buffer = require('buffer');
var http = require('http');
var net = require('net');
var Url = require('url');
var https = require('https');
var zlib2 = require('zlib');
var async_hooks = require('async_hooks');
var crypto7 = require('crypto');
var os31 = require('os');
var module$1 = require('module');
var zod = require('zod');
var fs232 = require('fs/promises');
var promises = require('timers/promises');
var secretManager = require('@google-cloud/secret-manager');
var events = require('events');
var child_process = require('child_process');
var process2 = require('process');
var promises$1 = require('stream/promises');
var string_decoder = require('string_decoder');
var perf_hooks = require('perf_hooks');
var yaml5 = require('js-yaml');
var readline3 = require('readline');
var Ajv = require('ajv');
var addFormats = require('ajv-formats');
var micromatch = require('micromatch');
var toml = require('toml');
var winston = require('winston');
var firestore = require('@google-cloud/firestore');
var Ajv2020 = require('ajv/dist/2020');
var semver = require('semver');
var querystring = require('querystring');
var googleAuthLibrary = require('google-auth-library');
var pLimit = require('p-limit');
var neo4j = require('neo4j-driver');
var prompts = require('prompts');
var Ajv20203 = require('ajv/dist/2020.js');
var commander = require('commander');
var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var chalk16__namespace = /*#__PURE__*/_interopNamespace(chalk16);
var fs87__namespace = /*#__PURE__*/_interopNamespace(fs87);
var path259__namespace = /*#__PURE__*/_interopNamespace(path259);
var dotenv__namespace = /*#__PURE__*/_interopNamespace(dotenv);
var Stream4__default = /*#__PURE__*/_interopDefault(Stream4);
var http__namespace = /*#__PURE__*/_interopNamespace(http);
var Url__namespace = /*#__PURE__*/_interopNamespace(Url);
var https__default = /*#__PURE__*/_interopDefault(https);
var zlib2__namespace = /*#__PURE__*/_interopNamespace(zlib2);
var crypto7__namespace = /*#__PURE__*/_interopNamespace(crypto7);
var os31__namespace = /*#__PURE__*/_interopNamespace(os31);
var fs232__namespace = /*#__PURE__*/_interopNamespace(fs232);
var process2__namespace = /*#__PURE__*/_interopNamespace(process2);
var yaml5__namespace = /*#__PURE__*/_interopNamespace(yaml5);
var readline3__namespace = /*#__PURE__*/_interopNamespace(readline3);
var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
var micromatch__default = /*#__PURE__*/_interopDefault(micromatch);
var winston__default = /*#__PURE__*/_interopDefault(winston);
var Ajv2020__default = /*#__PURE__*/_interopDefault(Ajv2020);
var semver__default = /*#__PURE__*/_interopDefault(semver);
var querystring__namespace = /*#__PURE__*/_interopNamespace(querystring);
var pLimit__default = /*#__PURE__*/_interopDefault(pLimit);
var neo4j__default = /*#__PURE__*/_interopDefault(neo4j);
var prompts__default = /*#__PURE__*/_interopDefault(prompts);
var Ajv20203__default = /*#__PURE__*/_interopDefault(Ajv20203);
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x2)(function(x2) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x2 + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
__defProp(target, "default", { value: mod, enumerable: true }) ,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
function isTestEnv() {
return process.env.NODE_ENV === "test" || process.env.VITEST === "true" || process.env.VITEST_WORKER_ID != null || process.env.JEST_WORKER_ID != null;
}
function isMockFn(fn) {
if (!fn || typeof fn !== "function") return false;
const meta72 = fn;
return Array.isArray(meta72.mock?.calls);
}
function stdoutLine(...args) {
const text = format(...args);
if (isTestEnv()) {
process.stdout.write(`${text}
`);
if (isMockFn(console.log)) console.log(text);
return;
}
process.stdout.write(`${text}
`);
}
function stderrLine(...args) {
const text = format(...args);
if (isTestEnv()) {
process.stderr.write(`${text}
`);
if (isMockFn(console.error)) console.error(text);
return;
}
process.stderr.write(`${text}
`);
}
var format;
var init_tty = __esm({
"src/shared/utils/tty.ts"() {
format = util$1.format;
}
});
var LogLevel, Logger, ChildCapableConsoleLogger, logger, envLogLevel, envLogFormat;
var init_logger = __esm({
"src/utils/logger.ts"() {
init_tty();
LogLevel = /* @__PURE__ */ ((LogLevel2) => {
LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
return LogLevel2;
})(LogLevel || {});
Logger = class _Logger {
level = 2 /* WARN */;
// Default to WARN to reduce noise
prefix;
format = "pretty";
constructor(context) {
this.prefix = context ? `[MARIA CODE][${context}]` : "[MARIA CODE]";
}
setLevel(level) {
this.level = level;
}
setFormat(format2) {
this.format = format2;
}
out(level, tag, args) {
const consoleFn = console[level];
if (this.format === "json") {
const payload = {
ts: (/* @__PURE__ */ new Date()).toISOString(),
level: tag.replace(/\[|\]/g, "").toLowerCase(),
msg: args.map(String).join(" ")
};
consoleFn(JSON.stringify(payload));
return;
}
const debugMode = process.env.MARIA_DEBUG === "1";
const isError = tag.includes("[ERROR]");
let outArgs = args;
if (isError && !debugMode) {
const filtered = [];
for (const a of args) {
const t2 = typeof a;
if (a == null || t2 === "string" || t2 === "number" || t2 === "boolean") {
filtered.push(a);
}
}
outArgs = filtered;
}
if (tag) {
consoleFn(tag, ...outArgs);
} else {
consoleFn(...outArgs);
}
}
debug(message, fields) {
if (this.level <= 0 /* DEBUG */) {
const args = fields ? [message, fields] : [message];
this.out("log", chalk16__namespace.default.magenta(`${this.prefix} [DEBUG]`), args);
}
}
info(message, fields) {
if (this.level <= 1 /* INFO */) {
const args = fields ? [message, fields] : [message];
this.out("log", chalk16__namespace.default.bold.magenta(`${this.prefix} [INFO]`), args);
}
}
warn(message, fields) {
if (this.level <= 2 /* WARN */) {
const args = fields ? [message, fields] : [message];
this.out("warn", chalk16__namespace.default.bold.magenta(`${this.prefix} [WARN]`), args);
}
}
error(message, fields) {
if (this.level <= 3 /* ERROR */) {
const args = fields ? [message, fields] : [message];
this.out("error", chalk16__namespace.default.bold.magenta(`${this.prefix} [ERROR]`), args);
}
}
success(...args) {
if (this.level <= 1 /* INFO */) {
this.out("log", chalk16__namespace.default.bold.magenta(`${this.prefix} [SUCCESS]`), args);
}
}
task(taskName, status, message) {
if (process.env.MARIA_BENCH_MODE === "1") return;
if (this.level > 1 /* INFO */) {
return;
}
const statusIcons = {
start: "\u{1F680}",
progress: "\u23F3",
complete: "\u2705",
error: "\u274C"
};
const statusColors = {
start: chalk16__namespace.default.bold.magenta,
progress: chalk16__namespace.default.magenta,
complete: chalk16__namespace.default.bold.magenta,
error: chalk16__namespace.default.bold.magenta
};
const icon = statusIcons[status];
const color = statusColors[status];
const formattedMessage = message ? `: ${message}` : "";
stdoutLine(color(`${this.prefix} ${icon} ${taskName}${formattedMessage}`));
}
table(data) {
if (this.level > 1 /* INFO */) {
return;
}
stdoutLine(data);
}
json(obj, pretty = true) {
if (this.level > 0 /* DEBUG */) {
return;
}
if (this.format === "json") {
this.out("log", "", [JSON.stringify(obj)]);
} else {
stdoutLine(chalk16__namespace.default.magenta(`${this.prefix} [JSON]`));
stdoutLine(pretty ? JSON.stringify(obj, null, 2) : JSON.stringify(obj));
}
}
divider() {
if (this.level > 1 /* INFO */) {
return;
}
stdoutLine(chalk16__namespace.default.magenta("\u2500".repeat(60)));
}
/**
* Create a child logger with additional context.
*
* For compatibility with existing code, supports a pino-like signature:
* `logger.child({ module: "name" })`.
* - If context is a string, use it directly as the prefix context.
* - If context is an object, prefer the `module` field; otherwise join `key=value` pairs.
*/
child(context) {
let ctx;
if (typeof context === "string") {
ctx = context;
} else if (context && typeof context === "object") {
const obj = context;
if (typeof obj.module === "string" && obj.module.length > 0) {
ctx = obj.module;
} else {
const entries = Object.entries(obj).filter(([_, v]) => v != null).map(([k, v]) => `${k}=${String(v)}`);
ctx = entries.join(",");
}
}
const childLogger = new _Logger(ctx);
childLogger.setLevel(this.level);
childLogger.setFormat(this.format);
return childLogger;
}
clear() {
console.clear();
}
/**
* Render a progress bar.
*/
progress(current, total, label) {
if (process.env.MARIA_BENCH_MODE === "1") return;
if (this.level > 1 /* INFO */) {
return;
}
const percentage = Math.round(current / total * 100);
const barLength = 30;
const filled = Math.round(percentage / 100 * barLength);
const empty = barLength - filled;
const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
const progressText = `${current}/${total}`;
const labelText = label ? ` ${label}` : "";
process.stdout.write(
`\r${chalk16__namespace.default.bold.magenta(bar)} ${percentage}% ${progressText}${labelText}`
);
if (current === total) {
process.stdout.write("\n");
}
}
};
ChildCapableConsoleLogger = class _ChildCapableConsoleLogger extends Logger {
constructor(context) {
super(context);
}
child(fields) {
const moduleName = fields && typeof fields.module === "string" && fields.module || void 0;
const ctx = moduleName ? moduleName : void 0;
return new _ChildCapableConsoleLogger(ctx);
}
};
logger = new ChildCapableConsoleLogger();
envLogLevel = process.env["MARIA_LOG_LEVEL"]?.toUpperCase();
if (envLogLevel && LogLevel[envLogLevel] !== void 0) {
logger.setLevel(LogLevel[envLogLevel]);
}
envLogFormat = process.env["MARIA_LOG_FORMAT"]?.toLowerCase();
if (envLogFormat === "json" || envLogFormat === "pretty") {
logger.setFormat(envLogFormat);
}
}
});
// src/adapters/logging/default.ts
var defaultLogger;
var init_default = __esm({
"src/adapters/logging/default.ts"() {
init_logger();
defaultLogger = logger;
}
});
// src/ui/integrated-cli/responsive-width.ts
function getSafeTerminalWidth() {
if (process.env.MARIA_FIXED_WIDTH) {
const fixed = Number(process.env.MARIA_FIXED_WIDTH);
if (Number.isFinite(fixed) && fixed > 0) {
return fixed;
}
}
const isTTY = process.stdout && process.stdout.isTTY;
if (isTTY && typeof process.stdout.columns === "number" && process.stdout.columns > 0) {
return process.stdout.columns;
}
const envColumns = Number(process.env.COLUMNS);
if (Number.isFinite(envColumns) && envColumns > 0) {
return envColumns;
}
if (process.platform === "win32") {
try {
const { execSync } = __require("child_process");
const result = execSync('powershell -command "$host.UI.RawUI.WindowSize.Width"', {
encoding: "utf8",
stdio: ["pipe", "pipe", "ignore"]
// Suppress stderr
});
const width = parseInt(result.trim());
if (Number.isFinite(width) && width > 0) {
return width;
}
} catch {
}
}
return 80;
}
function getResponsiveWidth(config2) {
if (process.env.MARIA_DISABLE_RESPONSIVE === "1") {
return config2?.maxWidth;
}
const terminalWidth = getSafeTerminalWidth();
const marginLeft = config2?.marginLeft ?? 5;
const marginRight = config2?.marginRight ?? 5;
const minWidth = config2?.minWidth;
const maxWidth = config2?.maxWidth;
const availableWidth = terminalWidth - marginLeft - marginRight;
return Math.max(minWidth, Math.min(availableWidth, maxWidth));
}
function disposeSharedLayoutManager() {
if (sharedManager) {
sharedManager.dispose();
sharedManager = null;
}
}
function isCI() {
return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.JENKINS_HOME || process.env.TRAVIS || process.env.CIRCLECI || process.env.BUILDKITE || process.env.DRONE);
}
function autoConfigureForEnvironment() {
if (isCI() || !process.stdout.isTTY) {
if (!process.env.MARIA_FIXED_WIDTH) {
process.env.MARIA_FIXED_WIDTH = "80";
}
}
}
var sharedManager;
var init_responsive_width = __esm({
"src/ui/integrated-cli/responsive-width.ts"() {
sharedManager = null;
autoConfigureForEnvironment();
if (process.env.NODE_ENV !== "production") {
process.on("exit", () => {
disposeSharedLayoutManager();
});
}
}
});
function getVersion() {
if (_cachedVersion) {
return _cachedVersion;
}
try {
const packageJson4 = getPackageJson();
_cachedVersion = packageJson4.version;
return _cachedVersion;
} catch (_error) {
_cachedVersion = "latest";
return _cachedVersion;
}
}
function getPackageJson() {
if (_cachedPackageJson) {
return _cachedPackageJson;
}
try {
const possiblePaths = [
// When running from built dist/
path259.join(__dirname, "../../package.json"),
// When running from source
path259.join(__dirname, "../../../package.json"),
// Current working directory
path259.join(process.cwd(), "package.json"),
// One level up from current working directory
path259.join(process.cwd(), "../package.json"),
// For globally installed packages
path259.join(__dirname, "../../../../package.json"),
path259.join(__dirname, "../../../../../package.json"),
// npm global install locations
"/usr/local/lib/node_modules/@bonginkan/maria/package.json",
"/usr/lib/node_modules/@bonginkan/maria/package.json",
// User home npm global
path259.join(
process.env.HOME || "",
".npm-global/lib/node_modules/@bonginkan/maria/package.json"
),
path259.join(
process.env.HOME || "",
".nvm/versions/node",
process.version,
"lib/node_modules/@bonginkan/maria/package.json"
)
];
let packageJsonPath = null;
for (const path343 of possiblePaths) {
if (fs87.existsSync(path343)) {
try {
const content = fs87.readFileSync(path343, "utf-8");
const parsed = JSON.parse(content);
if (parsed.name === "@bonginkan/maria") {
packageJsonPath = path343;
break;
}
} catch {
continue;
}
}
}
if (!packageJsonPath) {
throw new Error("package.json not found in any expected location");
}
const packageJsonContent = fs87.readFileSync(packageJsonPath, "utf-8");
_cachedPackageJson = JSON.parse(packageJsonContent);
return _cachedPackageJson;
} catch (_error) {
throw new Error(`Failed to read package.json: ${_error}`);
}
}
var _cachedVersion, _cachedPackageJson;
var init_version = __esm({
"src/utils/version.ts"() {
_cachedVersion = null;
_cachedPackageJson = null;
getVersion();
}
});
function isLocalMode() {
return String(process.env.LOCAL_MODE || "").trim() === "1" || String(process.env.MARIA_AUTH_MODE || "").trim().toLowerCase() === "local" || String(process.env.MARIA_LOCAL_ONLY || "").trim() === "1";
}
function findEnvRoot(startDir) {
const explicit = String(process.env.MARIA_ENV_ROOT || "").trim();
if (explicit) return explicit;
let cur = startDir;
for (let i2 = 0; i2 < 25; i2 += 1) {
const envLocal = path259__namespace.join(cur, ".env.local");
const env = path259__namespace.join(cur, ".env");
const lmstudio = path259__namespace.join(cur, ".env.lmstudio");
if (fs87__namespace.existsSync(envLocal) || fs87__namespace.existsSync(env) || fs87__namespace.existsSync(lmstudio)) return cur;
const parent = path259__namespace.dirname(cur);
if (parent === cur) break;
cur = parent;
}
return startDir;
}
function loadEnvironmentVariables(options) {
if (environmentLoaded && true) return;
environmentLoaded = true;
const cwd2 = process.cwd();
const envRoot = findEnvRoot(cwd2);
const _envPath = path259__namespace.join(envRoot, ".env");
if (fs87__namespace.existsSync(_envPath)) {
const _result = dotenv__namespace.config({ path: _envPath });
if (_result.error) {
defaultLogger.warn("Error loading .env", { error: _result.error });
}
}
const _envLocalPath = path259__namespace.join(envRoot, ".env.local");
const hasEnvLocal = fs87__namespace.existsSync(_envLocalPath);
if (hasEnvLocal) {
const _result = dotenv__namespace.config({ path: _envLocalPath, override: true });
if (_result.error) {
defaultLogger.warn("Error loading .env.local", { error: _result.error });
}
} else if (isLocalMode()) {
defaultLogger.warn("LOCAL_MODE: .env.local not found", {
envRoot,
message: "Create .env.local to configure local LLM (ollama/lmstudio/vllm)."
});
}
const _lmstudioEnvPath = path259__namespace.join(envRoot, ".env.lmstudio");
if (fs87__namespace.existsSync(_lmstudioEnvPath)) {
const _result = dotenv__namespace.config({ path: _lmstudioEnvPath, override: false });
if (_result.error) {
defaultLogger.warn("Error loading .env.lmstudio", { error: _result.error });
}
}
if (!process.env.MARIA_API_BASE) process.env.MARIA_API_BASE = "https://api.maria-code.ai";
if (!process.env.MARIA_USE_API) process.env.MARIA_USE_API = "1";
if (!process.env.MARIA_USE_REMOTE_MEDIA) process.env.MARIA_USE_REMOTE_MEDIA = "1";
if (isLocalMode()) {
if (!process.env.MARIA_PLAN_ID) process.env.MARIA_PLAN_ID = "pro";
if (!process.env.MARIA_LOCAL_LLM_PROVIDER) process.env.MARIA_LOCAL_LLM_PROVIDER = "ollama";
const provider = String(process.env.MARIA_LOCAL_LLM_PROVIDER || "").trim().toLowerCase();
if (!process.env.MARIA_LOCAL_LLM_MODEL) {
if (provider === "ollama") process.env.MARIA_LOCAL_LLM_MODEL = "gpt-oss:latest";
else if (provider === "lmstudio") process.env.MARIA_LOCAL_LLM_MODEL = "openai/gpt-oss-120b";
else process.env.MARIA_LOCAL_LLM_MODEL = "vllm-model";
}
if (provider === "lmstudio") {
if (!process.env.LMSTUDIO_BASE_URL) process.env.LMSTUDIO_BASE_URL = "http://127.0.0.1:1234/v1";
if (!process.env.MARIA_LMSTUDIO_AUTO_START) process.env.MARIA_LMSTUDIO_AUTO_START = "1";
} else if (provider === "ollama") {
if (!process.env.OLLAMA_API_BASE) process.env.OLLAMA_API_BASE = "http://localhost:11434";
} else if (provider === "vllm") {
if (!process.env.VLLM_API_BASE) process.env.VLLM_API_BASE = "http://localhost:8000/v1";
}
}
}
var environmentLoaded;
var init_env_loader = __esm({
"src/utils/env-loader.ts"() {
init_default();
environmentLoaded = false;
}
});
// src/providers/config.ts
var _isLocalOnly, DEFAULT_PROVIDER2, DEFAULT_MODEL2;
var init_config = __esm({
"src/providers/config.ts"() {
init_env_loader();
loadEnvironmentVariables();
_isLocalOnly = String(process.env.LOCAL_MODE || "").trim() === "1" || String(process.env.MARIA_AUTH_MODE || "").trim().toLowerCase() === "local";
DEFAULT_PROVIDER2 = _isLocalOnly ? process.env.MARIA_LOCAL_LLM_PROVIDER || "lmstudio" : process.env.DEFAULT_PROVIDER || "google";
DEFAULT_MODEL2 = (_isLocalOnly ? process.env.MARIA_LOCAL_LLM_MODEL || process.env.LMSTUDIO_MODEL || process.env.MARIA_DEFAULT_MODEL : process.env.MARIA_DEFAULT_MODEL || process.env.OPENAI_MODEL) || (_isLocalOnly ? "openai/gpt-oss-120b" : "gemini-2.5-flash");
}
});
// node_modules/.pnpm/data-uri-to-buffer@4.0.1/node_modules/data-uri-to-buffer/dist/index.js
function dataUriToBuffer(uri) {
if (!/^data:/i.test(uri)) {
throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
}
uri = uri.replace(/\r?\n/g, "");
const firstComma = uri.indexOf(",");
if (firstComma === -1 || firstComma <= 4) {
throw new TypeError("malformed data: URI");
}
const meta72 = uri.substring(5, firstComma).split(";");
let charset = "";
let base64 = false;
const type = meta72[0] || "text/plain";
let typeFull = type;
for (let i2 = 1; i2 < meta72.length; i2++) {
if (meta72[i2] === "base64") {
base64 = true;
} else if (meta72[i2]) {
typeFull += `;${meta72[i2]}`;
if (meta72[i2].indexOf("charset=") === 0) {
charset = meta72[i2].substring(8);
}
}
}
if (!meta72[0] && !charset.length) {
typeFull += ";charset=US-ASCII";
charset = "US-ASCII";
}
const encoding = base64 ? "base64" : "ascii";
const data = unescape(uri.substring(firstComma + 1));
const buffer = Buffer.from(data, encoding);
buffer.type = type;
buffer.typeFull = typeFull;
buffer.charset = charset;
return buffer;
}
var dist_default;
var init_dist = __esm({
"node_modules/.pnpm/data-uri-to-buffer@4.0.1/node_modules/data-uri-to-buffer/dist/index.js"() {
dist_default = dataUriToBuffer;
}
});
// node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
var require_ponyfill_es2018 = __commonJS({
"node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports$1, module) {
(function(global2, factory) {
typeof exports$1 === "object" && typeof module !== "undefined" ? factory(exports$1) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.WebStreamsPolyfill = {}));
})(exports$1, (function(exports2) {
function noop3() {
return void 0;
}
function typeIsObject(x2) {
return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
}
const rethrowAssertionErrorRejection = noop3;
function setFunctionName(fn, name) {
try {
Object.defineProperty(fn, "name", {
value: name,
configurable: true
});
} catch (_a2) {
}
}
const originalPromise = Promise;
const originalPromiseThen = Promise.prototype.then;
const originalPromiseReject = Promise.reject.bind(originalPromise);
function newPromise(executor) {
return new originalPromise(executor);
}
function promiseResolvedWith(value) {
return newPromise((resolve71) => resolve71(value));
}
function promiseRejectedWith(reason) {
return originalPromiseReject(reason);
}
function PerformPromiseThen(promise, onFulfilled, onRejected) {
return originalPromiseThen.call(promise, onFulfilled, onRejected);
}
function uponPromise(promise, onFulfilled, onRejected) {
PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), void 0, rethrowAssertionErrorRejection);
}
function uponFulfillment(promise, onFulfilled) {
uponPromise(promise, onFulfilled);
}
function uponRejection(promise, onRejected) {
uponPromise(promise, void 0, onRejected);
}
function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
}
function setPromiseIsHandledToTrue(promise) {
PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection);
}
let _queueMicrotask = (callback) => {
if (typeof queueMicrotask === "function") {
_queueMicrotask = queueMicrotask;
} else {
const resolvedPromise = promiseResolvedWith(void 0);
_queueMicrotask = (cb) => PerformPromiseThen(resolvedPromise, cb);
}
return _queueMicrotask(callback);
};
function reflectCall(F2, V, args) {
if (typeof F2 !== "function") {
throw new TypeError("Argument is not a function");
}
return Function.prototype.apply.call(F2, V, args);
}
function promiseCall(F2, V, args) {
try {
return promiseResolvedWith(reflectCall(F2, V, args));
} catch (value) {
return promiseRejectedWith(value);
}
}
const QUEUE_MAX_ARRAY_SIZE = 16384;
class SimpleQueue {
constructor() {
this._cursor = 0;
this._size = 0;
this._front = {
_elements: [],
_next: void 0
};
this._back = this._front;
this._cursor = 0;
this._size = 0;
}
get length() {
return this._size;
}
// For exception safety, this method is structured in order:
// 1. Read state
// 2. Calculate required state mutations
// 3. Perform state mutations
push(element) {
const oldBack = this._back;
let newBack = oldBack;
if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {
newBack = {
_elements: [],
_next: void 0
};
}
oldBack._elements.push(element);
if (newBack !== oldBack) {
this._back = newBack;
oldBack._next = newBack;
}
++this._size;
}
// Like push(), shift() follows the read -> calculate -> mutate pattern for
// exception safety.
shift() {
const oldFront = this._front;
let newFront = oldFront;
const oldCursor = this._cursor;
let newCursor = oldCursor + 1;
const elements = oldFront._elements;
const element = elements[oldCursor];
if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
newFront = oldFront._next;
newCursor = 0;
}
--this._size;
this._cursor = newCursor;
if (oldFront !== newFront) {
this._front = newFront;
}
elements[oldCursor] = void 0;
return element;
}
// The tricky thing about forEach() is that it can be called
// re-entrantly. The queue may be mutated inside the callback. It is easy to
// see that push() within the callback has no negative effects since the end
// of the queue is checked for on every iteration. If shift() is called
// repeatedly within the callback then the next iteration may return an
// element that has been removed. In this case the callback will be called
// with undefined values until we either "catch up" with elements that still
// exist or reach the back of the queue.
forEach(callback) {
let i2 = this._cursor;
let node = this._front;
let elements = node._elements;
while (i2 !== elements.length || node._next !== void 0) {
if (i2 === elements.length) {
node = node._next;
elements = node._elements;
i2 = 0;
if (elements.length === 0) {
break;
}
}
callback(elements[i2]);
++i2;
}
}
// Return the element that would be returned if shift() was called now,
// without modifying the queue.
peek() {
const front = this._front;
const cursor = this._cursor;
return front._elements[cursor];
}
}
const AbortSteps = /* @__PURE__ */ Symbol("[[AbortSteps]]");
const ErrorSteps = /* @__PURE__ */ Symbol("[[ErrorSteps]]");
const CancelSteps = /* @__PURE__ */ Symbol("[[CancelSteps]]");
const PullSteps = /* @__PURE__ */ Symbol("[[PullSteps]]");
const ReleaseSteps = /* @__PURE__ */ Symbol("[[ReleaseSteps]]");
function ReadableStreamReaderGenericInitialize(reader, stream2) {
reader._ownerReadableStream = stream2;
stream2._reader = reader;
if (stream2._state === "readable") {
defaultReaderClosedPromiseInitialize(reader);
} else if (stream2._state === "closed") {
defaultReaderClosedPromiseInitializeAsResolved(reader);
} else {
defaultReaderClosedPromiseInitializeAsRejected(reader, stream2._storedError);
}
}
function ReadableStreamReaderGenericCancel(reader, reason) {
const stream2 = reader._ownerReadableStream;
return ReadableStreamCancel(stream2, reason);
}
function ReadableStreamReaderGenericRelease(reader) {
const stream2 = reader._ownerReadableStream;
if (stream2._state === "readable") {
defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
} else {
defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
}
stream2._readableStreamController[ReleaseSteps]();
stream2._reader = void 0;
reader._ownerReadableStream = void 0;
}
function readerLockException(name) {
return new TypeError("Cannot " + name + " a stream using a released reader");
}
function defaultReaderClosedPromiseInitialize(reader) {
reader._closedPromise = newPromise((resolve71, reject) => {
reader._closedPromise_resolve = resolve71;
reader._closedPromise_reject = reject;
});
}
function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
defaultReaderClosedPromiseInitialize(reader);
defaultReaderClosedPromiseReject(reader, reason);
}
function defaultReaderClosedPromiseInitializeAsResolved(reader) {
defaultReaderClosedPromiseInitialize(reader);
defaultReaderClosedPromiseResolve(reader);
}
function defaultReaderClosedPromiseReject(reader, reason) {
if (reader._closedPromise_reject === void 0) {
return;
}
setPromiseIsHandledToTrue(reader._closedPromise);
reader._closedPromise_reject(reason);
reader._closedPromise_resolve = void 0;
reader._closedPromise_reject = void 0;
}
function defaultReaderClosedPromiseResetToRejected(reader, reason) {
defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
}
function defaultReaderClosedPromiseResolve(reader) {
if (reader._closedPromise_resolve === void 0) {
return;
}
reader._closedPromise_resolve(void 0);
reader._closedPromise_resolve = void 0;
reader._closedPromise_reject = void 0;
}
const NumberIsFinite = Number.isFinite || function(x2) {
return typeof x2 === "number" && isFinite(x2);
};
const MathTrunc = Math.trunc || function(v) {
return v < 0 ? Math.ceil(v) : Math.floor(v);
};
function isDictionary(x2) {
return typeof x2 === "object" || typeof x2 === "function";
}
function assertDictionary(obj, context) {
if (obj !== void 0 && !isDictionary(obj)) {
throw new TypeError(`${context} is not an object.`);
}
}
function assertFunction(x2, context) {
if (typeof x2 !== "function") {
throw new TypeError(`${context} is not a function.`);
}
}
function isObject2(x2) {
return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
}
function assertObject(x2, context) {
if (!isObject2(x2)) {
throw new TypeError(`${context} is not an object.`);
}
}
function assertRequiredArgument(x2, position, context) {
if (x2 === void 0) {
throw new TypeError(`Parameter ${position} is required in '${context}'.`);
}
}
function assertRequiredField(x2, field, context) {
if (x2 === void 0) {
throw new TypeError(`${field} is required in '${context}'.`);
}
}
function convertUnrestrictedDouble(value) {
return Number(value);
}
function censorNegativeZero(x2) {
return x2 === 0 ? 0 : x2;
}
function integerPart(x2) {
return censorNegativeZero(MathTrunc(x2));
}
function convertUnsignedLongLongWithEnforceRange(value, context) {
const lowerBound = 0;
const upperBound = Number.MAX_SAFE_INTEGER;
let x2 = Number(value);
x2 = censorNegativeZero(x2);
if (!NumberIsFinite(x2)) {
throw new TypeError(`${context} is not a finite number`);
}
x2 = integerPart(x2);
if (x2 < lowerBound || x2 > upperBound) {
throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);
}
if (!NumberIsFinite(x2) || x2 === 0) {
return 0;
}
return x2;
}
function assertReadableStream(x2, context) {
if (!IsReadableStream(x2)) {
throw new TypeError(`${context} is not a ReadableStream.`);
}
}
function AcquireReadableStreamDefaultReader(stream2) {
return new ReadableStreamDefaultReader(stream2);
}
function ReadableStreamAddReadRequest(stream2, readRequest) {
stream2._reader._readRequests.push(readRequest);
}
function ReadableStreamFulfillReadRequest(stream2, chunk2, done) {
const reader = stream2._reader;
const readRequest = reader._readRequests.shift();
if (done) {
readRequest._closeSteps();
} else {
readRequest._chunkSteps(chunk2);
}
}
function ReadableStreamGetNumReadRequests(stream2) {
return stream2._reader._readRequests.length;
}
function ReadableStreamHasDefaultReader(stream2) {
const reader = stream2._reader;
if (reader === void 0) {
return false;
}
if (!IsReadableStreamDefaultReader(reader)) {
return false;
}
return true;
}
class ReadableStreamDefaultReader {
constructor(stream2) {
assertRequiredArgument(stream2, 1, "ReadableStreamDefaultReader");
assertReadableStream(stream2, "First parameter");
if (IsReadableStreamLocked(stream2)) {
throw new TypeError("This stream has already been locked for exclusive reading by another reader");
}
ReadableStreamReaderGenericInitialize(this, stream2);
this._readRequests = new SimpleQueue();
}
/**
* Returns a promise that will be fulfilled when the stream becomes closed,
* or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
*/
get closed() {
if (!IsReadableStreamDefaultReader(this)) {
return promiseRejectedWith(defaultReaderBrandCheckException("closed"));
}
return this._closedPromise;
}
/**
* If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
*/
cancel(reason = void 0) {
if (!IsReadableStreamDefaultReader(this)) {
return promiseRejectedWith(defaultReaderBrandCheckException("cancel"));
}
if (this._ownerReadableStream === void 0) {
return promiseRejectedWith(readerLockException("cancel"));
}
return ReadableStreamReaderGenericCancel(this, reason);
}
/**
* Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
*
* If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
*/
read() {
if (!IsReadableStreamDefaultReader(this)) {
return promiseRejectedWith(defaultReaderBrandCheckException("read"));
}
if (this._ownerReadableStream === void 0) {
return promiseRejectedWith(readerLockException("read from"));
}
let resolvePromise;
let rejectPromise;
const promise = newPromise((resolve71, reject) => {
resolvePromise = resolve71;
rejectPromise = reject;
});
const readRequest = {
_chunkSteps: (chunk2) => resolvePromise({ value: chunk2, done: false }),
_closeSteps: () => resolvePromise({ value: void 0, done: true }),
_errorSteps: (e2) => rejectPromise(e2)
};
ReadableStreamDefaultReaderRead(this, readRequest);
return promise;
}
/**
* Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
* If the associated stream is errored when the lock is released, the reader will appear errored in the same way
* from now on; otherwise, the reader will appear closed.
*
* A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
* the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
* do so will throw a `TypeError` and leave the reader locked to the stream.
*/
releaseLock() {
if (!IsReadableStreamDefaultReader(this)) {
throw defaultReaderBrandCheckException("releaseLock");
}
if (this._ownerReadableStream === void 0) {
return;
}
ReadableStreamDefaultReaderRelease(this);
}
}
Object.defineProperties(ReadableStreamDefaultReader.prototype, {
cancel: { enumerable: true },
read: { enumerable: true },
releaseLock: { enumerable: true },
closed: { enumerable: true }
});
setFunctionName(ReadableStreamDefaultReader.prototype.cancel, "cancel");
setFunctionName(ReadableStreamDefaultReader.prototype.read, "read");
setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock");
if (typeof Symbol.toStringTag === "symbol") {
Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
value: "ReadableStreamDefaultReader",
configurable: true
});
}
function IsReadableStreamDefaultReader(x2) {
if (!typeIsObject(x2)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x2, "_readRequests")) {
return false;
}
return x2 instanceof ReadableStreamDefaultReader;
}
function ReadableStreamDefaultReaderRead(reader, readRequest) {
const stream2 = reader._ownerReadableStream;
stream2._disturbed = true;
if (stream2._state === "closed") {
readRequest._closeSteps();
} else if (stream2._state === "errored") {
readRequest._errorSteps(stream2._storedError);
} else {
stream2._readableStreamController[PullSteps](readRequest);
}
}
function ReadableStreamDefaultReaderRelease(reader) {
ReadableStreamReaderGenericRelease(reader);
const e2 = new TypeError("Reader was released");
ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
}
function ReadableStreamDefaultReaderErrorReadRequests(reader, e2) {
const readRequests = reader._readRequests;
reader._readRequests = new SimpleQueue();
readRequests.forEach((readRequest) => {
readRequest._errorSteps(e2);
});
}
function defaultReaderBrandCheckException(name) {
return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
}
const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
}).prototype);
class ReadableStreamAsyncIteratorImpl {
constructor(reader, preventCancel) {
this._ongoingPromise = void 0;
this._isFinished = false;
this._reader = reader;
this._preventCancel = preventCancel;
}
next() {
const nextSteps = () => this._nextSteps();
this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps();
return this._ongoingPromise;
}
return(value) {
const returnSteps = () => this._returnSteps(value);
return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps();
}
_nextSteps() {
if (this._isFinished) {
return Promise.resolve({ value: void 0, done: true });
}
const reader = this._reader;
let resolvePromise;
let rejectPromise;
const promise = newPromise((resolve71, reject) => {
resolvePromise = resolve71;
rejectPromise = reject;
});
const readRequest = {
_chunkSteps: (chunk2) => {
this._ongoingPromise = void 0;
_queueMicrotask(() => resolvePromise({ value: chunk2, done: false }));
},
_closeSteps: () => {
this._ongoingPromise = void 0;
this._isFinished = true;
ReadableStreamReaderGenericRelease(reader);
resolvePromise({ value: void 0, done: true });
},
_errorSteps: (reason) => {
this._ongoingPromise = void 0;
this._isFinished = true;
ReadableStreamReaderGenericRelease(reader);
rejectPromise(reason);
}
};
ReadableStreamDefaultReaderRead(reader, readRequest);
return promise;
}
_returnSteps(value) {
if (this._isFinished) {
return Promise.resolve({ value, done: true });
}
this._isFinished = true;
const reader = this._reader;
if (!this._preventCancel) {
const result = ReadableStreamReaderGenericCancel(reader, value);
ReadableStreamReaderGenericRelease(reader);
return transformPromiseWith(result, () => ({ value, done: true }));
}
ReadableStreamReaderGenericRelease(reader);
return promiseResolvedWith({ value, done: true });
}
}
const ReadableStreamAsyncIteratorPrototype = {
next() {
if (!IsReadableStreamAsyncIterator(this)) {
return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
}
return this._asyncIteratorImpl.next();
},
return(value) {
if (!IsReadableStreamAsyncIterator(this)) {
return promiseRejectedWith(streamAsyncIteratorBrandCheckException("return"));
}
return this._asyncIteratorImpl.return(value);
}
};
Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
function AcquireReadableStreamAsyncIterator(stream2, preventCancel) {
const reader = AcquireReadableStreamDefaultReader(stream2);
const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
iterator._asyncIteratorImpl = impl;
return iterator;
}
function IsReadableStreamAsyncIterator(x2) {
if (!typeIsObject(x2)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x2, "_asyncIteratorImpl")) {
return false;
}
try {
return x2._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
} catch (_a2) {
return false;
}
}
function streamAsyncIteratorBrandCheckException(name) {
return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
}
const NumberIsNaN = Number.isNaN || function(x2) {
return x2 !== x2;
};
var _a, _b, _c;
function CreateArrayFromList(elements) {
return elements.slice();
}
function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
}
let TransferArrayBuffer = (O) => {
if (typeof O.transfer === "function") {
TransferArrayBuffer = (buffer) => buffer.transfer();
} else if (typeof structuredClone === "function") {
TransferArrayBuffer = (buffer) => structuredClone(buffer, { transfer: [buffer] });
} else {
TransferArrayBuffer = (buffer) => buffer;
}
return TransferArrayBuffer(O);
};
let IsDetachedBuffer = (O) => {
if (typeof O.detached === "boolean") {
IsDetachedBuffer = (buffer) => buffer.detached;
} else {
IsDetachedBuffer = (buffer) => buffer.byteLength === 0;
}
return IsDetachedBuffer(O);
};
function ArrayBufferSlice(buffer, begin, end) {
if (buffer.slice) {
return buffer.slice(begin, end);
}
const length = end - begin;
const slice = new ArrayBuffer(length);
CopyDataBlockBytes(slice, 0, buffer, begin, length);
return slice;
}
function GetMethod(receiver, prop) {
const func = receiver[prop];
if (func === void 0 || func === null) {
return void 0;
}
if (typeof func !== "function") {
throw new TypeError(`${String(prop)} is not a function`);
}
return func;
}
function CreateAsyncFromSyncIterator(syncIteratorRecord) {
const syncIterable = {
[Symbol.iterator]: () => syncIteratorRecord.iterator
};
const asyncIterator = (async function* () {
return yield* syncIterable;
})();
const nextMethod = asyncIterator.next;
return { iterator: asyncIterator, nextMethod, done: false };
}
co