@zubridge/electron
Version:
A streamlined state management library for Electron applications using Zustand.
1,456 lines (1,439 loc) • 65.6 kB
JavaScript
// Renderer-safe build with polyfilled Node.js modules
const require_chunk = require('./chunk-CPpYY54z.cjs');
let __oxc_project_runtime_helpers_defineProperty = require("@oxc-project/runtime/helpers/defineProperty");
__oxc_project_runtime_helpers_defineProperty = require_chunk.__toESM(__oxc_project_runtime_helpers_defineProperty);
let __oxc_project_runtime_helpers_classPrivateFieldInitSpec = require("@oxc-project/runtime/helpers/classPrivateFieldInitSpec");
__oxc_project_runtime_helpers_classPrivateFieldInitSpec = require_chunk.__toESM(__oxc_project_runtime_helpers_classPrivateFieldInitSpec);
let __oxc_project_runtime_helpers_classPrivateFieldGet2 = require("@oxc-project/runtime/helpers/classPrivateFieldGet2");
__oxc_project_runtime_helpers_classPrivateFieldGet2 = require_chunk.__toESM(__oxc_project_runtime_helpers_classPrivateFieldGet2);
let __oxc_project_runtime_helpers_classPrivateFieldSet2 = require("@oxc-project/runtime/helpers/classPrivateFieldSet2");
__oxc_project_runtime_helpers_classPrivateFieldSet2 = require_chunk.__toESM(__oxc_project_runtime_helpers_classPrivateFieldSet2);
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/_internal/utils.mjs
/* @__NO_SIDE_EFFECTS__ */
function createNotImplementedError(name) {
return /* @__PURE__ */ new Error(`[unenv] ${name} is not implemented yet!`);
}
/* @__NO_SIDE_EFFECTS__ */
function notImplemented(name) {
const fn = () => {
throw /* @__PURE__ */ createNotImplementedError(name);
};
return Object.assign(fn, { __unenv__: true });
}
/* @__NO_SIDE_EFFECTS__ */
function notImplementedAsync(name) {
const fn = /* @__PURE__ */ notImplemented(name);
fn.__promisify__ = () => /* @__PURE__ */ notImplemented(name + ".__promisify__");
fn.native = fn;
return fn;
}
/* @__NO_SIDE_EFFECTS__ */
function notImplementedClass(name) {
return class {
constructor() {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "__unenv__", true);
throw new Error(`[unenv] ${name} is not implemented yet!`);
}
};
}
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/util/types.mjs
var types_exports = /* @__PURE__ */ require_chunk.__export({
isAnyArrayBuffer: () => isAnyArrayBuffer,
isArgumentsObject: () => isArgumentsObject,
isArrayBuffer: () => isArrayBuffer,
isArrayBufferView: () => isArrayBufferView,
isAsyncFunction: () => isAsyncFunction,
isBigInt64Array: () => isBigInt64Array,
isBigIntObject: () => isBigIntObject,
isBigUint64Array: () => isBigUint64Array,
isBooleanObject: () => isBooleanObject,
isBoxedPrimitive: () => isBoxedPrimitive,
isCryptoKey: () => isCryptoKey,
isDataView: () => isDataView,
isDate: () => isDate$1,
isExternal: () => isExternal,
isFloat32Array: () => isFloat32Array,
isFloat64Array: () => isFloat64Array,
isGeneratorFunction: () => isGeneratorFunction,
isGeneratorObject: () => isGeneratorObject,
isInt16Array: () => isInt16Array,
isInt32Array: () => isInt32Array,
isInt8Array: () => isInt8Array,
isKeyObject: () => isKeyObject,
isMap: () => isMap,
isMapIterator: () => isMapIterator,
isModuleNamespaceObject: () => isModuleNamespaceObject,
isNativeError: () => isNativeError,
isNumberObject: () => isNumberObject,
isPromise: () => isPromise,
isProxy: () => isProxy,
isRegExp: () => isRegExp$1,
isSet: () => isSet,
isSetIterator: () => isSetIterator,
isSharedArrayBuffer: () => isSharedArrayBuffer,
isStringObject: () => isStringObject,
isSymbolObject: () => isSymbolObject,
isTypedArray: () => isTypedArray,
isUint16Array: () => isUint16Array,
isUint32Array: () => isUint32Array,
isUint8Array: () => isUint8Array,
isUint8ClampedArray: () => isUint8ClampedArray,
isWeakMap: () => isWeakMap,
isWeakSet: () => isWeakSet
});
const isExternal = (_obj) => false;
const isDate$1 = (val) => val instanceof Date;
const isArgumentsObject = /* @__PURE__ */ notImplemented("util.types.isArgumentsObject");
const isBigIntObject = (val) => typeof val === "bigint";
const isBooleanObject = (val) => typeof val === "boolean";
const isNumberObject = (val) => typeof val === "number";
const isStringObject = (val) => typeof val === "string";
const isSymbolObject = (val) => typeof val === "symbol";
const isNativeError = /* @__PURE__ */ notImplemented("util.types.isNativeError");
const isRegExp$1 = (val) => val instanceof RegExp;
const isAsyncFunction = /* @__PURE__ */ notImplemented("util.types.isAsyncFunction");
const isGeneratorFunction = /* @__PURE__ */ notImplemented("util.types.isGeneratorFunction");
const isGeneratorObject = /* @__PURE__ */ notImplemented("util.types.isGeneratorObject");
const isPromise = (val) => val instanceof Promise;
const isMap = (val) => val instanceof Map;
const isSet = (val) => val instanceof Set;
const isMapIterator = /* @__PURE__ */ notImplemented("util.types.isMapIterator");
const isSetIterator = /* @__PURE__ */ notImplemented("util.types.isSetIterator");
const isWeakMap = (val) => val instanceof WeakMap;
const isWeakSet = (val) => val instanceof WeakSet;
const isArrayBuffer = (val) => val instanceof ArrayBuffer;
const isDataView = (val) => val instanceof DataView;
const isSharedArrayBuffer = (val) => val instanceof SharedArrayBuffer;
const isProxy = /* @__PURE__ */ notImplemented("util.types.isProxy");
const isModuleNamespaceObject = /* @__PURE__ */ notImplemented("util.types.isModuleNamespaceObject");
const isAnyArrayBuffer = /* @__PURE__ */ notImplemented("util.types.isAnyArrayBuffer");
const isBoxedPrimitive = /* @__PURE__ */ notImplemented("util.types.isBoxedPrimitive");
const isArrayBufferView = /* @__PURE__ */ notImplemented("util.types.isArrayBufferView");
const isTypedArray = /* @__PURE__ */ notImplemented("util.types.isTypedArray");
const isUint8Array = /* @__PURE__ */ notImplemented("util.types.isUint8Array");
const isUint8ClampedArray = /* @__PURE__ */ notImplemented("util.types.isUint8ClampedArray");
const isUint16Array = /* @__PURE__ */ notImplemented("util.types.isUint16Array");
const isUint32Array = /* @__PURE__ */ notImplemented("util.types.isUint32Array");
const isInt8Array = /* @__PURE__ */ notImplemented("util.types.isInt8Array");
const isInt16Array = /* @__PURE__ */ notImplemented("util.types.isInt16Array");
const isInt32Array = /* @__PURE__ */ notImplemented("util.types.isInt32Array");
const isFloat32Array = /* @__PURE__ */ notImplemented("util.types.isFloat32Array");
const isFloat64Array = /* @__PURE__ */ notImplemented("util.types.isFloat64Array");
const isBigInt64Array = /* @__PURE__ */ notImplemented("util.types.isBigInt64Array");
const isBigUint64Array = /* @__PURE__ */ notImplemented("util.types.isBigUint64Array");
const isKeyObject = /* @__PURE__ */ notImplemented("util.types.isKeyObject");
const isCryptoKey = /* @__PURE__ */ notImplemented("util.types.isCryptoKey");
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/util/types.mjs
var types_default = types_exports;
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/util/inherits.mjs
function inherits(ctor, superCtor) {
if (!superCtor) return;
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, { constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
} });
}
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/util/promisify.mjs
const customSymbol = /* @__PURE__ */ Symbol("customPromisify");
function _promisify(fn) {
if (fn[customSymbol]) return fn[customSymbol];
return function(...args) {
return new Promise((resolve, reject) => {
try {
fn.call(this, ...args, (err, val) => {
if (err) return reject(err);
resolve(val);
});
} catch (error) {
reject(error);
}
});
};
}
const promisify = /* @__PURE__ */ Object.assign(_promisify, { custom: customSymbol });
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/util/mime.mjs
var MIMEType = class {
constructor(input) {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "__unenv__", true);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "params", new MIMEParams());
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "type", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "subtype", void 0);
const [essence = "", ...params] = String(input).split(";");
const [type$1 = "", subtype = ""] = essence.split("/");
this.type = type$1;
this.subtype = subtype;
this.params = new MIMEParams();
for (const param of params) {
const [name, value] = param.split("=");
this.params.set(name, value);
}
}
get essence() {
return this.type + "/" + this.subtype;
}
toString() {
const paramsStr = this.params.toString();
return this.essence + (paramsStr ? `;${paramsStr}` : "");
}
};
var MIMEParams = class extends Map {
constructor(..._args) {
super(..._args);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "__unenv__", true);
}
get(name) {
return super.get(name) || null;
}
toString() {
return [...this.entries()].map(([name, value]) => `${name}=${value}`).join("&");
}
};
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/util/legacy-types.mjs
const isRegExp = (val) => val instanceof RegExp;
const isDate = (val) => val instanceof Date;
const isArray = (val) => Array.isArray(val);
const isBoolean = (val) => typeof val === "boolean";
const isNull = (val) => val === null;
const isNullOrUndefined = (val) => val === null || val === void 0;
const isNumber = (val) => typeof val === "number";
const isString = (val) => typeof val === "string";
const isSymbol = (val) => typeof val === "symbol";
const isUndefined = (val) => val === void 0;
const isFunction = (val) => typeof val === "function";
const isBuffer = (val) => {
return val && typeof val === "object" && typeof val.copy === "function" && typeof val.fill === "function" && typeof val.readUInt8 === "function";
};
const isDeepStrictEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
const isObject = (val) => val !== null && typeof val === "object" && Object.getPrototypeOf(val).isPrototypeOf(Object);
const isError = (val) => val instanceof Error;
const isPrimitive = (val) => {
if (typeof val === "object") return val === null;
return typeof val !== "function";
};
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/util/log.mjs
const log = (...args) => {
console.log(...args);
};
const debuglog = (section, _cb) => {
const fn = (msg, ...params) => {
if (fn.enabled) console.debug(`[${section}] ${msg}`, ...params);
};
fn.enabled = true;
return fn;
};
const debug = debuglog;
const inspect$1 = (object) => JSON.stringify(object, null, 2);
const format = (...args) => _format(...args);
const formatWithOptions = (_options, ...args) => _format(...args);
function _format(fmt, ...args) {
const re = /(%?)(%([djos]))/g;
if (args.length > 0) fmt = fmt.replace(re, (match, escaped, ptn, flag) => {
let arg = args.shift();
switch (flag) {
case "o":
if (Array.isArray(arg)) {
arg = JSON.stringify(arg);
break;
}
break;
case "s":
arg = "" + arg;
break;
case "d":
arg = Number(arg);
break;
case "j":
arg = JSON.stringify(arg);
break;
}
if (!escaped) return arg;
args.unshift(arg);
return match;
});
if (args.length > 0) fmt += " " + args.join(" ");
fmt = fmt.replace(/%{2}/g, "%");
return "" + fmt;
}
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/util.mjs
const TextDecoder$1 = globalThis.TextDecoder;
const TextEncoder = globalThis.TextEncoder;
const deprecate = (fn) => fn;
const _errnoException = /* @__PURE__ */ notImplemented("util._errnoException");
const _exceptionWithHostPort = /* @__PURE__ */ notImplemented("util._exceptionWithHostPort");
const _extend = /* @__PURE__ */ notImplemented("util._extend");
const aborted = /* @__PURE__ */ notImplemented("util.aborted");
const callbackify = /* @__PURE__ */ notImplemented("util.callbackify");
const getSystemErrorMap = /* @__PURE__ */ notImplemented("util.getSystemErrorMap");
const getSystemErrorName = /* @__PURE__ */ notImplemented("util.getSystemErrorName");
const toUSVString = /* @__PURE__ */ notImplemented("util.toUSVString");
const stripVTControlCharacters = /* @__PURE__ */ notImplemented("util.stripVTControlCharacters");
const transferableAbortController = /* @__PURE__ */ notImplemented("util.transferableAbortController");
const transferableAbortSignal = /* @__PURE__ */ notImplemented("util.transferableAbortSignal");
const parseArgs = /* @__PURE__ */ notImplemented("util.parseArgs");
const parseEnv = /* @__PURE__ */ notImplemented("util.parseEnv");
const styleText = /* @__PURE__ */ notImplemented("util.styleText");
/** @deprecated */
const getCallSite = /* @__PURE__ */ notImplemented("util.getCallSite");
const getCallSites = /* @__PURE__ */ notImplemented("util.getCallSites");
const getSystemErrorMessage = /* @__PURE__ */ notImplemented("util.getSystemErrorMessage");
var util_default = {
_errnoException,
_exceptionWithHostPort,
_extend,
aborted,
callbackify,
deprecate,
getCallSite,
getCallSites,
getSystemErrorMessage,
getSystemErrorMap,
getSystemErrorName,
inherits,
promisify,
stripVTControlCharacters,
toUSVString,
TextDecoder: TextDecoder$1,
TextEncoder,
types: types_default,
transferableAbortController,
transferableAbortSignal,
parseArgs,
parseEnv,
styleText,
MIMEParams,
MIMEType,
isArray,
isBoolean,
isBuffer,
isDate,
isDeepStrictEqual,
isError,
isFunction,
isNull,
isNullOrUndefined,
isNumber,
isObject,
isPrimitive,
isRegExp,
isString,
isSymbol,
isUndefined,
debug,
debuglog,
format,
formatWithOptions,
inspect: inspect$1,
log
};
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/async_hooks/async-hook.mjs
const kInit = /* @__PURE__ */ Symbol("init");
const kBefore = /* @__PURE__ */ Symbol("before");
const kAfter = /* @__PURE__ */ Symbol("after");
const kDestroy = /* @__PURE__ */ Symbol("destroy");
const kPromiseResolve = /* @__PURE__ */ Symbol("promiseResolve");
var _AsyncHook = class {
constructor(callbacks = {}) {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "__unenv__", true);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "_enabled", false);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "_callbacks", {});
this._callbacks = callbacks;
}
enable() {
this._enabled = true;
return this;
}
disable() {
this._enabled = false;
return this;
}
get [kInit]() {
return this._callbacks.init;
}
get [kBefore]() {
return this._callbacks.before;
}
get [kAfter]() {
return this._callbacks.after;
}
get [kDestroy]() {
return this._callbacks.destroy;
}
get [kPromiseResolve]() {
return this._callbacks.promiseResolve;
}
};
const executionAsyncId = function executionAsyncId$1() {
return 0;
};
const asyncWrapProviders = Object.assign(Object.create(null), {
NONE: 0,
DIRHANDLE: 1,
DNSCHANNEL: 2,
ELDHISTOGRAM: 3,
FILEHANDLE: 4,
FILEHANDLECLOSEREQ: 5,
BLOBREADER: 6,
FSEVENTWRAP: 7,
FSREQCALLBACK: 8,
FSREQPROMISE: 9,
GETADDRINFOREQWRAP: 10,
GETNAMEINFOREQWRAP: 11,
HEAPSNAPSHOT: 12,
HTTP2SESSION: 13,
HTTP2STREAM: 14,
HTTP2PING: 15,
HTTP2SETTINGS: 16,
HTTPINCOMINGMESSAGE: 17,
HTTPCLIENTREQUEST: 18,
JSSTREAM: 19,
JSUDPWRAP: 20,
MESSAGEPORT: 21,
PIPECONNECTWRAP: 22,
PIPESERVERWRAP: 23,
PIPEWRAP: 24,
PROCESSWRAP: 25,
PROMISE: 26,
QUERYWRAP: 27,
QUIC_ENDPOINT: 28,
QUIC_LOGSTREAM: 29,
QUIC_PACKET: 30,
QUIC_SESSION: 31,
QUIC_STREAM: 32,
QUIC_UDP: 33,
SHUTDOWNWRAP: 34,
SIGNALWRAP: 35,
STATWATCHER: 36,
STREAMPIPE: 37,
TCPCONNECTWRAP: 38,
TCPSERVERWRAP: 39,
TCPWRAP: 40,
TTYWRAP: 41,
UDPSENDWRAP: 42,
UDPWRAP: 43,
SIGINTWATCHDOG: 44,
WORKER: 45,
WORKERHEAPSNAPSHOT: 46,
WRITEWRAP: 47,
ZLIB: 48,
CHECKPRIMEREQUEST: 49,
PBKDF2REQUEST: 50,
KEYPAIRGENREQUEST: 51,
KEYGENREQUEST: 52,
KEYEXPORTREQUEST: 53,
CIPHERREQUEST: 54,
DERIVEBITSREQUEST: 55,
HASHREQUEST: 56,
RANDOMBYTESREQUEST: 57,
RANDOMPRIMEREQUEST: 58,
SCRYPTREQUEST: 59,
SIGNREQUEST: 60,
TLSWRAP: 61,
VERIFYREQUEST: 62
});
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/async_hooks/async-resource.mjs
let _asyncIdCounter = 100;
var _AsyncResource = class {
constructor(type$1, triggerAsyncId = executionAsyncId()) {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "__unenv__", true);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "type", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "_asyncId", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "_triggerAsyncId", void 0);
this.type = type$1;
this._asyncId = -1 * _asyncIdCounter++;
this._triggerAsyncId = typeof triggerAsyncId === "number" ? triggerAsyncId : triggerAsyncId?.triggerAsyncId;
}
static bind(fn, type$1, thisArg) {
return new AsyncResource(type$1 ?? "anonymous").bind(fn);
}
bind(fn, thisArg) {
const binded = (...args) => this.runInAsyncScope(fn, thisArg, ...args);
binded.asyncResource = this;
return binded;
}
runInAsyncScope(fn, thisArg, ...args) {
return fn.apply(thisArg, args);
}
emitDestroy() {
return this;
}
asyncId() {
return this._asyncId;
}
triggerAsyncId() {
return this._triggerAsyncId;
}
};
const AsyncResource = globalThis.AsyncResource || _AsyncResource;
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/events/events.mjs
let defaultMaxListeners = 10;
const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype);
const inspect = (value, _opts) => value;
const ERR_INVALID_THIS = Error;
const ERR_UNHANDLED_ERROR = Error;
const ERR_INVALID_ARG_TYPE = Error;
const AbortError = Error;
const genericNodeError = Error;
const kRejection = /* @__PURE__ */ Symbol.for("nodejs.rejection");
const kCapture = /* @__PURE__ */ Symbol.for("kCapture");
const kErrorMonitor = /* @__PURE__ */ Symbol.for("events.errorMonitor");
const kShapeMode = /* @__PURE__ */ Symbol.for("shapeMode");
const kMaxEventTargetListeners = /* @__PURE__ */ Symbol.for("events.maxEventTargetListeners");
const kEnhanceStackBeforeInspector = /* @__PURE__ */ Symbol.for("kEnhanceStackBeforeInspector");
const kWatermarkData = /* @__PURE__ */ Symbol.for("nodejs.watermarkData");
const kEventEmitter = /* @__PURE__ */ Symbol.for("kEventEmitter");
const kAsyncResource = /* @__PURE__ */ Symbol.for("kAsyncResource");
const kFirstEventParam = /* @__PURE__ */ Symbol.for("kFirstEventParam");
const kResistStopPropagation = /* @__PURE__ */ Symbol.for("kResistStopPropagation");
const kMaxEventTargetListenersWarned = /* @__PURE__ */ Symbol.for("events.maxEventTargetListenersWarned");
var _EventEmitter = class _EventEmitter {
static get on() {
return on$1;
}
static get once() {
return once$1;
}
static get getEventListeners() {
return getEventListeners;
}
static get getMaxListeners() {
return getMaxListeners$1;
}
static get addAbortListener() {
return addAbortListener;
}
static get EventEmitterAsyncResource() {
return EventEmitterAsyncResource;
}
static get EventEmitter() {
return _EventEmitter;
}
static setMaxListeners(n = defaultMaxListeners, ...eventTargets) {
if (eventTargets.length === 0) defaultMaxListeners = n;
else for (const target of eventTargets) if (isEventTarget(target)) {
target[kMaxEventTargetListeners] = n;
target[kMaxEventTargetListenersWarned] = false;
} else if (typeof target.setMaxListeners === "function") target.setMaxListeners(n);
else throw new ERR_INVALID_ARG_TYPE("eventTargets", ["EventEmitter", "EventTarget"], target);
}
static listenerCount(emitter, type$1) {
if (typeof emitter.listenerCount === "function") return emitter.listenerCount(type$1);
_EventEmitter.prototype.listenerCount.call(emitter, type$1);
}
static init() {
throw new Error("EventEmitter.init() is not implemented.");
}
static get captureRejections() {
return this[kCapture];
}
static set captureRejections(value) {
this[kCapture] = value;
}
static get defaultMaxListeners() {
return defaultMaxListeners;
}
static set defaultMaxListeners(arg) {
defaultMaxListeners = arg;
}
constructor(opts) {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "_events", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "_eventsCount", 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "_maxListeners", defaultMaxListeners);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, kCapture, false);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, kShapeMode, false);
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
this._events = { __proto__: null };
this._eventsCount = 0;
this[kShapeMode] = false;
} else this[kShapeMode] = true;
this._maxListeners = this._maxListeners || void 0;
if (opts?.captureRejections) this[kCapture] = Boolean(opts.captureRejections);
else this[kCapture] = _EventEmitter.prototype[kCapture];
}
/**
* Increases the max listeners of the event emitter.
* @param {number} n
* @returns {EventEmitter}
*/
setMaxListeners(n) {
this._maxListeners = n;
return this;
}
/**
* Returns the current max listener value for the event emitter.
* @returns {number}
*/
getMaxListeners() {
return _getMaxListeners(this);
}
/**
* Synchronously calls each of the listeners registered
* for the event.
* @param {...any} [args]
* @returns {boolean}
*/
emit(type$1, ...args) {
let doError = type$1 === "error";
const events = this._events;
if (events !== void 0) {
if (doError && events[kErrorMonitor] !== void 0) this.emit(kErrorMonitor, ...args);
doError = doError && events.error === void 0;
} else if (!doError) return false;
if (doError) {
let er;
if (args.length > 0) er = args[0];
if (er instanceof Error) {
try {
const capture = {};
Error.captureStackTrace?.(capture, _EventEmitter.prototype.emit);
Object.defineProperty(er, kEnhanceStackBeforeInspector, {
__proto__: null,
value: Function.prototype.bind(enhanceStackTrace, this, er, capture),
configurable: true
});
} catch {}
throw er;
}
let stringifiedEr;
try {
stringifiedEr = inspect(er);
} catch {
stringifiedEr = er;
}
const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
err.context = er;
throw err;
}
const handler = events[type$1];
if (handler === void 0) return false;
if (typeof handler === "function") {
const result = handler.apply(this, args);
if (result !== void 0 && result !== null) addCatch(this, result, type$1, args);
} else {
const len = handler.length;
const listeners$1 = arrayClone(handler);
for (let i = 0; i < len; ++i) {
const result = listeners$1[i].apply(this, args);
if (result !== void 0 && result !== null) addCatch(this, result, type$1, args);
}
}
return true;
}
/**
* Adds a listener to the event emitter.
* @returns {EventEmitter}
*/
addListener(type$1, listener) {
_addListener(this, type$1, listener, false);
return this;
}
on(type$1, listener) {
return this.addListener(type$1, listener);
}
/**
* Adds the `listener` function to the beginning of
* the listeners array.
*/
prependListener(type$1, listener) {
_addListener(this, type$1, listener, true);
return this;
}
/**
* Adds a one-time `listener` function to the event emitter.
*/
once(type$1, listener) {
checkListener(listener);
this.on(type$1, _onceWrap(this, type$1, listener));
return this;
}
/**
* Adds a one-time `listener` function to the beginning of
* the listeners array.
*/
prependOnceListener(type$1, listener) {
checkListener(listener);
this.prependListener(type$1, _onceWrap(this, type$1, listener));
return this;
}
/**
* Removes the specified `listener` from the listeners array.
* @param {string | symbol} type
* @param {Function} listener
* @returns {EventEmitter}
*/
removeListener(type$1, listener) {
checkListener(listener);
const events = this._events;
if (events === void 0) return this;
const list = events[type$1];
if (list === void 0) return this;
if (list === listener || list.listener === listener) {
this._eventsCount -= 1;
if (this[kShapeMode]) events[type$1] = void 0;
else if (this._eventsCount === 0) this._events = { __proto__: null };
else {
delete events[type$1];
if (events.removeListener) this.emit("removeListener", type$1, list.listener || listener);
}
} else if (typeof list !== "function") {
let position = -1;
for (let i = list.length - 1; i >= 0; i--) if (list[i] === listener || list[i].listener === listener) {
position = i;
break;
}
if (position < 0) return this;
if (position === 0) list.shift();
else spliceOne(list, position);
if (list.length === 1) events[type$1] = list[0];
if (events.removeListener !== void 0) this.emit("removeListener", type$1, listener);
}
return this;
}
off(type$1, listener) {
return this.removeListener(type$1, listener);
}
/**
* Removes all listeners from the event emitter. (Only
* removes listeners for a specific event name if specified
* as `type`).
*/
removeAllListeners(type$1) {
const events = this._events;
if (events === void 0) return this;
if (events.removeListener === void 0) {
if (arguments.length === 0) {
this._events = { __proto__: null };
this._eventsCount = 0;
} else if (events[type$1] !== void 0) if (--this._eventsCount === 0) this._events = { __proto__: null };
else delete events[type$1];
this[kShapeMode] = false;
return this;
}
if (arguments.length === 0) {
for (const key of Reflect.ownKeys(events)) {
if (key === "removeListener") continue;
this.removeAllListeners(key);
}
this.removeAllListeners("removeListener");
this._events = { __proto__: null };
this._eventsCount = 0;
this[kShapeMode] = false;
return this;
}
const listeners$1 = events[type$1];
if (typeof listeners$1 === "function") this.removeListener(type$1, listeners$1);
else if (listeners$1 !== void 0) for (let i = listeners$1.length - 1; i >= 0; i--) this.removeListener(type$1, listeners$1[i]);
return this;
}
/**
* Returns a copy of the array of listeners for the event name
* specified as `type`.
* @param {string | symbol} type
* @returns {Function[]}
*/
listeners(type$1) {
return _listeners(this, type$1, true);
}
/**
* Returns a copy of the array of listeners and wrappers for
* the event name specified as `type`.
* @returns {Function[]}
*/
rawListeners(type$1) {
return _listeners(this, type$1, false);
}
/**
* Returns an array listing the events for which
* the emitter has registered listeners.
* @returns {any[]}
*/
eventNames() {
return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
}
/**
* Returns the number of listeners listening to event name
*/
listenerCount(eventName, listener) {
const events = this._events;
if (events !== void 0) {
const evlistener = events[eventName];
if (typeof evlistener === "function") {
if (listener != null) return listener === evlistener || listener === evlistener.listener ? 1 : 0;
return 1;
} else if (evlistener !== void 0) {
if (listener != null) {
let matching = 0;
for (let i = 0, l = evlistener.length; i < l; i++) if (evlistener[i] === listener || evlistener[i].listener === listener) matching++;
return matching;
}
return evlistener.length;
}
}
return 0;
}
};
(0, __oxc_project_runtime_helpers_defineProperty.default)(_EventEmitter, "captureRejectionSymbol", kRejection);
(0, __oxc_project_runtime_helpers_defineProperty.default)(_EventEmitter, "errorMonitor", kErrorMonitor);
(0, __oxc_project_runtime_helpers_defineProperty.default)(_EventEmitter, "kMaxEventTargetListeners", kMaxEventTargetListeners);
(0, __oxc_project_runtime_helpers_defineProperty.default)(_EventEmitter, "kMaxEventTargetListenersWarned", kMaxEventTargetListenersWarned);
(0, __oxc_project_runtime_helpers_defineProperty.default)(_EventEmitter, "usingDomains", false);
var EventEmitterAsyncResource = class extends _EventEmitter {
/**
* @param {{
* name?: string,
* triggerAsyncId?: number,
* requireManualDestroy?: boolean,
* }} [options]
*/
constructor(options) {
let name;
if (typeof options === "string") {
name = options;
options = void 0;
} else name = options?.name || new.target.name;
super(options);
this[kAsyncResource] = new EventEmitterReferencingAsyncResource(this, name, options);
}
/**
* @param {symbol,string} event
* @param {...any} args
* @returns {boolean}
*/
emit(event, ...args) {
if (this[kAsyncResource] === void 0) throw new ERR_INVALID_THIS("EventEmitterAsyncResource");
const { asyncResource } = this;
Array.prototype.unshift(args, super.emit, this, event);
return Reflect.apply(asyncResource.runInAsyncScope, asyncResource, args);
}
/**
* @returns {void}
*/
emitDestroy() {
if (this[kAsyncResource] === void 0) throw new ERR_INVALID_THIS("EventEmitterAsyncResource");
this.asyncResource.emitDestroy();
}
/**
* @type {number}
*/
get asyncId() {
if (this[kAsyncResource] === void 0) throw new ERR_INVALID_THIS("EventEmitterAsyncResource");
return this.asyncResource.asyncId();
}
/**
* @type {number}
*/
get triggerAsyncId() {
if (this[kAsyncResource] === void 0) throw new ERR_INVALID_THIS("EventEmitterAsyncResource");
return this.asyncResource.triggerAsyncId();
}
/**
* @type {EventEmitterReferencingAsyncResource}
*/
get asyncResource() {
if (this[kAsyncResource] === void 0) throw new ERR_INVALID_THIS("EventEmitterAsyncResource");
return this[kAsyncResource];
}
};
var EventEmitterReferencingAsyncResource = class extends AsyncResource {
/**
* @param {EventEmitter} ee
* @param {string} [type]
* @param {{
* triggerAsyncId?: number,
* requireManualDestroy?: boolean,
* }} [options]
*/
constructor(ee, type$1, options) {
super(type$1, options);
this[kEventEmitter] = ee;
}
/**
* @type {EventEmitter}
*/
get eventEmitter() {
if (this[kEventEmitter] === void 0) throw new ERR_INVALID_THIS("EventEmitterReferencingAsyncResource");
return this[kEventEmitter];
}
};
/**
* Returns an `AsyncIterator` that iterates `event` events.
* @param {EventEmitter} emitter
* @param {string | symbol} event
* @param {{
* signal: AbortSignal;
* close?: string[];
* highWaterMark?: number,
* lowWaterMark?: number
* }} [options]
* @returns {AsyncIterator}
*/
const on$1 = function on$2(emitter, event, options = {}) {
const signal = options.signal;
if (signal?.aborted) throw new AbortError(void 0, { cause: signal?.reason });
const highWatermark = options.highWaterMark ?? options.highWatermark ?? Number.MAX_SAFE_INTEGER;
const lowWatermark = options.lowWaterMark ?? options.lowWatermark ?? 1;
const unconsumedEvents = new FixedQueue();
const unconsumedPromises = new FixedQueue();
let paused = false;
let error = null;
let finished = false;
let size = 0;
const iterator = Object.setPrototypeOf({
next() {
if (size) {
const value = unconsumedEvents.shift();
size--;
if (paused && size < lowWatermark) {
emitter.resume?.();
paused = false;
}
return Promise.resolve(createIterResult(value, false));
}
if (error) {
const p = Promise.reject(error);
error = null;
return p;
}
if (finished) return closeHandler();
return new Promise(function(resolve, reject) {
unconsumedPromises.push({
resolve,
reject
});
});
},
return() {
return closeHandler();
},
throw(err) {
if (!err || !(err instanceof Error)) throw new ERR_INVALID_ARG_TYPE("EventEmitter.AsyncIterator", "Error", err);
errorHandler(err);
},
[Symbol.asyncIterator]() {
return this;
},
[kWatermarkData]: {
get size() {
return size;
},
get low() {
return lowWatermark;
},
get high() {
return highWatermark;
},
get isPaused() {
return paused;
}
}
}, AsyncIteratorPrototype);
const { addEventListener, removeAll } = listenersController();
addEventListener(emitter, event, options[kFirstEventParam] ? eventHandler : function(...args) {
return eventHandler(args);
});
if (event !== "error" && typeof emitter.on === "function") addEventListener(emitter, "error", errorHandler);
const closeEvents = options?.close;
if (closeEvents?.length) for (const closeEvent of closeEvents) addEventListener(emitter, closeEvent, closeHandler);
const abortListenerDisposable = signal ? addAbortListener(signal, abortListener) : null;
return iterator;
function abortListener() {
errorHandler(new AbortError(void 0, { cause: signal?.reason }));
}
function eventHandler(value) {
if (unconsumedPromises.isEmpty()) {
size++;
if (!paused && size > highWatermark) {
paused = true;
emitter.pause?.();
}
unconsumedEvents.push(value);
} else unconsumedPromises.shift().resolve(createIterResult(value, false));
}
function errorHandler(err) {
if (unconsumedPromises.isEmpty()) error = err;
else unconsumedPromises.shift().reject(err);
closeHandler();
}
function closeHandler() {
abortListenerDisposable?.[Symbol.dispose]();
removeAll();
finished = true;
const doneResult = createIterResult(void 0, true);
while (!unconsumedPromises.isEmpty()) unconsumedPromises.shift().resolve(doneResult);
return Promise.resolve(doneResult);
}
};
/**
* Creates a `Promise` that is fulfilled when the emitter
* emits the given event.
* @param {EventEmitter} emitter
* @param {string} name
* @param {{ signal: AbortSignal; }} [options]
* @returns {Promise}
*/
const once$1 = async function once$2(emitter, name, options = {}) {
const signal = options?.signal;
if (signal?.aborted) throw new AbortError(void 0, { cause: signal?.reason });
return new Promise((resolve, reject) => {
const errorListener = (err) => {
if (typeof emitter.removeListener === "function") emitter.removeListener(name, resolver);
if (signal != null) eventTargetAgnosticRemoveListener(signal, "abort", abortListener);
reject(err);
};
const resolver = (...args) => {
if (typeof emitter.removeListener === "function") emitter.removeListener("error", errorListener);
if (signal != null) eventTargetAgnosticRemoveListener(signal, "abort", abortListener);
resolve(args);
};
eventTargetAgnosticAddListener(emitter, name, resolver, {
__proto__: null,
once: true,
[kResistStopPropagation]: true
});
if (name !== "error" && typeof emitter.once === "function") emitter.once("error", errorListener);
function abortListener() {
eventTargetAgnosticRemoveListener(emitter, name, resolver);
eventTargetAgnosticRemoveListener(emitter, "error", errorListener);
reject(new AbortError(void 0, { cause: signal?.reason }));
}
if (signal != null) eventTargetAgnosticAddListener(signal, "abort", abortListener, {
__proto__: null,
once: true,
[kResistStopPropagation]: true
});
});
};
const addAbortListener = function addAbortListener$1(signal, listener) {
if (signal === void 0) throw new ERR_INVALID_ARG_TYPE("signal", "AbortSignal", signal);
let removeEventListener;
if (signal.aborted) queueMicrotask(() => listener());
else {
signal.addEventListener("abort", listener, {
__proto__: null,
once: true,
[kResistStopPropagation]: true
});
removeEventListener = () => {
signal.removeEventListener("abort", listener);
};
}
return {
__proto__: null,
[Symbol.dispose]() {
removeEventListener?.();
}
};
};
/**
* Returns a copy of the array of listeners for the event name
* specified as `type`.
* @returns {Function[]}
*/
const getEventListeners = function getEventListeners$1(emitterOrTarget, type$1) {
if (typeof emitterOrTarget.listeners === "function") return emitterOrTarget.listeners(type$1);
if (isEventTarget(emitterOrTarget)) {
const root = emitterOrTarget[kEvents].get(type$1);
const listeners$1 = [];
let handler = root?.next;
while (handler?.listener !== void 0) {
const listener = handler.listener?.deref ? handler.listener.deref() : handler.listener;
listeners$1.push(listener);
handler = handler.next;
}
return listeners$1;
}
throw new ERR_INVALID_ARG_TYPE("emitter", ["EventEmitter", "EventTarget"], emitterOrTarget);
};
/**
* Returns the max listeners set.
* @param {EventEmitter | EventTarget} emitterOrTarget
* @returns {number}
*/
const getMaxListeners$1 = function getMaxListeners$2(emitterOrTarget) {
if (typeof emitterOrTarget?.getMaxListeners === "function") return _getMaxListeners(emitterOrTarget);
else if (emitterOrTarget?.[kMaxEventTargetListeners]) return emitterOrTarget[kMaxEventTargetListeners];
throw new ERR_INVALID_ARG_TYPE("emitter", ["EventEmitter", "EventTarget"], emitterOrTarget);
};
const kSize = 2048;
const kMask = kSize - 1;
var FixedCircularBuffer = class {
constructor() {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "bottom", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "top", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "list", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "next", void 0);
this.bottom = 0;
this.top = 0;
this.list = new Array(kSize);
this.next = null;
}
isEmpty() {
return this.top === this.bottom;
}
isFull() {
return (this.top + 1 & kMask) === this.bottom;
}
push(data) {
this.list[this.top] = data;
this.top = this.top + 1 & kMask;
}
shift() {
const nextItem = this.list[this.bottom];
if (nextItem === void 0) return null;
this.list[this.bottom] = void 0;
this.bottom = this.bottom + 1 & kMask;
return nextItem;
}
};
var FixedQueue = class {
constructor() {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "head", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "tail", void 0);
this.head = this.tail = new FixedCircularBuffer();
}
isEmpty() {
return this.head.isEmpty();
}
push(data) {
if (this.head.isFull()) this.head = this.head.next = new FixedCircularBuffer();
this.head.push(data);
}
shift() {
const tail = this.tail;
const next = tail.shift();
if (tail.isEmpty() && tail.next !== null) {
this.tail = tail.next;
tail.next = null;
}
return next;
}
};
function isEventTarget(emitter) {
return typeof emitter?.addEventListener === "function";
}
function checkListener(listener) {}
function addCatch(that, promise, type$1, args) {
if (!that[kCapture]) return;
try {
const then = promise.then;
if (typeof then === "function") then.call(promise, void 0, function(err) {
setTimeout(emitUnhandledRejectionOrErr, 0, that, err, type$1, args);
});
} catch (error_) {
that.emit("error", error_);
}
}
function emitUnhandledRejectionOrErr(ee, err, type$1, args) {
if (typeof ee[kRejection] === "function") ee[kRejection](err, type$1, ...args);
else {
const prev = ee[kCapture];
try {
ee[kCapture] = false;
ee.emit("error", err);
} finally {
ee[kCapture] = prev;
}
}
}
function _getMaxListeners(that) {
if (that._maxListeners === void 0) return defaultMaxListeners;
return that._maxListeners;
}
function enhanceStackTrace(err, own) {
let ctorInfo = "";
try {
const { name } = this.constructor;
if (name !== "EventEmitter") ctorInfo = ` on ${name} instance`;
} catch {}
const sep = `\nEmitted 'error' event${ctorInfo} at:\n`;
const ownStack = (own.stack || "").split("\n").slice(1);
return err.stack + sep + ownStack.join("\n");
}
function _addListener(target, type$1, listener, prepend) {
let m;
let events;
let existing;
checkListener(listener);
events = target._events;
if (events === void 0) {
events = target._events = { __proto__: null };
target._eventsCount = 0;
} else {
if (events.newListener !== void 0) {
target.emit("newListener", type$1, listener.listener ?? listener);
events = target._events;
}
existing = events[type$1];
}
if (existing === void 0) {
events[type$1] = listener;
++target._eventsCount;
} else {
if (typeof existing === "function") existing = events[type$1] = prepend ? [listener, existing] : [existing, listener];
else if (prepend) existing.unshift(listener);
else existing.push(listener);
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
const w = new genericNodeError(`Possible EventEmitter memory leak detected. ${existing.length} ${String(type$1)} listeners added to ${inspect(target, { depth: -1 })}. MaxListeners is ${m}. Use emitter.setMaxListeners() to increase limit`, {
name: "MaxListenersExceededWarning",
emitter: target,
type: type$1,
count: existing.length
});
console.warn(w);
}
}
return target;
}
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0) return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type$1, listener) {
const state = {
fired: false,
wrapFn: void 0,
target,
type: type$1,
listener
};
const wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
function _listeners(target, type$1, unwrap) {
const events = target._events;
if (events === void 0) return [];
const evlistener = events[type$1];
if (evlistener === void 0) return [];
if (typeof evlistener === "function") return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener);
}
function arrayClone(arr) {
switch (arr.length) {
case 2: return [arr[0], arr[1]];
case 3: return [
arr[0],
arr[1],
arr[2]
];
case 4: return [
arr[0],
arr[1],
arr[2],
arr[3]
];
case 5: return [
arr[0],
arr[1],
arr[2],
arr[3],
arr[4]
];
case 6: return [
arr[0],
arr[1],
arr[2],
arr[3],
arr[4],
arr[5]
];
}
return Array.prototype.slice.call(arr);
}
function unwrapListeners(arr) {
const ret = arrayClone(arr);
for (let i = 0; i < ret.length; ++i) {
const orig = ret[i].listener;
if (typeof orig === "function") ret[i] = orig;
}
return ret;
}
function createIterResult(value, done) {
return {
value,
done
};
}
function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) {
if (typeof emitter.removeListener === "function") emitter.removeListener(name, listener);
else if (typeof emitter.removeEventListener === "function") emitter.removeEventListener(name, listener, flags);
else throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter);
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === "function") if (flags?.once) emitter.once(name, listener);
else emitter.on(name, listener);
else if (typeof emitter.addEventListener === "function") emitter.addEventListener(name, listener, flags);
else throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter);
}
function listenersController() {
const listeners$1 = [];
return {
addEventListener(emitter, event, handler, flags) {
eventTargetAgnosticAddListener(emitter, event, handler, flags);
Array.prototype.push(listeners$1, [
emitter,
event,
handler,
flags
]);
},
removeAll() {
while (listeners$1.length > 0) Reflect.apply(eventTargetAgnosticRemoveListener, void 0, listeners$1.pop());
}
};
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++) list[index] = list[index + 1];
list.pop();
}
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/tty/read-stream.mjs
var ReadStream = class {
constructor(fd) {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "fd", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "isRaw", false);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "isTTY", false);
this.fd = fd;
}
setRawMode(mode) {
this.isRaw = mode;
return this;
}
};
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/tty/write-stream.mjs
var WriteStream = class {
constructor(fd) {
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "fd", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "columns", 80);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "rows", 24);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "isTTY", false);
this.fd = fd;
}
clearLine(dir, callback) {
callback && callback();
return false;
}
clearScreenDown(callback) {
callback && callback();
return false;
}
cursorTo(x, y, callback) {
callback && typeof callback === "function" && callback();
return false;
}
moveCursor(dx, dy, callback) {
callback && callback();
return false;
}
getColorDepth(env$2) {
return 1;
}
hasColors(count, env$2) {
return false;
}
getWindowSize() {
return [this.columns, this.rows];
}
write(str, encoding, cb) {
if (str instanceof Uint8Array) str = new TextDecoder().decode(str);
try {
console.log(str);
} catch {}
cb && typeof cb === "function" && cb();
return false;
}
};
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/tty.mjs
const isatty = function() {
return false;
};
var tty_default = {
ReadStream,
WriteStream,
isatty
};
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/process/node-version.mjs
const NODE_VERSION = "22.14.0";
//#endregion
//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/process/process.mjs
var _stdin = /* @__PURE__ */ new WeakMap();
var _stdout = /* @__PURE__ */ new WeakMap();
var _stderr = /* @__PURE__ */ new WeakMap();
var _cwd = /* @__PURE__ */ new WeakMap();
var Process = class Process extends _EventEmitter {
constructor(impl) {
super();
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "env", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "hrtime", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "nextTick", void 0);
(0, __oxc_project_runtime_helpers_classPrivateFieldInitSpec.default)(this, _stdin, void 0);
(0, __oxc_project_runtime_helpers_classPrivateFieldInitSpec.default)(this, _stdout, void 0);
(0, __oxc_project_runtime_helpers_classPrivateFieldInitSpec.default)(this, _stderr, void 0);
(0, __oxc_project_runtime_helpers_classPrivateFieldInitSpec.default)(this, _cwd, "/");
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "arch", "");
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "platform", "");
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "argv", []);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "argv0", "");
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "execArgv", []);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "execPath", "");
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "title", "");
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "pid", 200);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "ppid", 100);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "permission", { has: /* @__PURE__ */ notImplemented("process.permission.has") });
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "report", {
directory: "",
filename: "",
signal: "SIGUSR2",
compact: false,
reportOnFatalError: false,
reportOnSignal: false,
reportOnUncaughtException: false,
getReport: /* @__PURE__ */ notImplemented("process.report.getReport"),
writeReport: /* @__PURE__ */ notImplemented("process.report.writeReport")
});
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "finalization", {
register: /* @__PURE__ */ notImplemented("process.finalization.register"),
unregister: /* @__PURE__ */ notImplemented("process.finalization.unregister"),
registerBeforeExit: /* @__PURE__ */ notImplemented("process.finalization.registerBeforeExit")
});
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "memoryUsage", Object.assign(() => ({
arrayBuffers: 0,
rss: 0,
external: 0,
heapTotal: 0,
heapUsed: 0
}), { rss: () => 0 }));
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "mainModule", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "domain", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "send", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "exitCode", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "channel", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "getegid", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "geteuid", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "getgid", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "getgroups", void 0);
(0, __oxc_project_runtime_helpers_defineProperty.default)(this, "getuid", void 0);
(0, __oxc_project_runtime_help