polykey-cli
Version:
Polykey CLI
1,577 lines (1,545 loc) • 6.98 MB
JavaScript
#!/usr/bin/env node
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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined")
return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" 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 name2 in all)
__defProp(target, name2, { get: all[name2], enumerable: true });
};
var __copyProps = (to, from3, except, desc) => {
if (from3 && typeof from3 === "object" || typeof from3 === "function") {
for (let key2 of __getOwnPropNames(from3))
if (!__hasOwnProp.call(to, key2) && key2 !== except)
__defProp(to, key2, { get: () => from3[key2], enumerable: !(desc = __getOwnPropDesc(from3, key2)) || 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.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// shims/require-shim.mjs
import { createRequire } from "node:module";
import { fileURLToPath } from "node:url";
import path from "node:path";
var __dirname;
var init_require_shim = __esm({
"shims/require-shim.mjs"() {
__require = createRequire(import.meta.url);
__dirname = path.dirname(fileURLToPath(import.meta.url));
}
});
// node_modules/@matrixai/logger/dist/types.js
var LogLevel;
var init_types = __esm({
"node_modules/@matrixai/logger/dist/types.js"() {
init_require_shim();
(function(LogLevel2) {
LogLevel2[LogLevel2["NOTSET"] = 0] = "NOTSET";
LogLevel2[LogLevel2["DEBUG"] = 1] = "DEBUG";
LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
LogLevel2[LogLevel2["SILENT"] = 100] = "SILENT";
})(LogLevel || (LogLevel = {}));
}
});
// node_modules/@matrixai/logger/dist/utils.js
function levelToString(level2) {
switch (level2) {
case LogLevel.NOTSET:
return "NOTSET";
case LogLevel.DEBUG:
return "DEBUG";
case LogLevel.INFO:
return "INFO";
case LogLevel.WARN:
return "WARN";
case LogLevel.ERROR:
return "ERROR";
case LogLevel.SILENT:
return "SILENT";
}
}
function evalLogDataValue(_key, value) {
if (typeof value === "function") {
return value();
} else {
return value;
}
}
function evalLogData(data3) {
return JSON.stringify(data3, evalLogDataValue);
}
var hasCaptureStackTrace, hasStackTraceLimit;
var init_utils = __esm({
"node_modules/@matrixai/logger/dist/utils.js"() {
init_require_shim();
init_types();
hasCaptureStackTrace = "captureStackTrace" in Error;
hasStackTraceLimit = "stackTraceLimit" in Error;
__name(levelToString, "levelToString");
__name(evalLogDataValue, "evalLogDataValue");
__name(evalLogData, "evalLogData");
}
});
// node_modules/@matrixai/logger/dist/formatting.js
var formatting_exports = {};
__export(formatting_exports, {
data: () => data,
date: () => date,
format: () => format,
formatter: () => formatter,
jsonFormatter: () => jsonFormatter,
key: () => key,
keys: () => keys,
level: () => level,
msg: () => msg,
stack: () => stack
});
function format(strings, ...values) {
return (record) => {
let result = strings[0];
for (let i = 0; i < values.length; i++) {
const value = values[i];
if (value === key) {
result += record.key;
} else if (value === keys) {
result += record.keys;
} else if (value === date) {
result += record.date().toISOString();
} else if (value === msg) {
if (record.msg != null)
result += record.msg;
} else if (value === level) {
result += levelToString(record.level);
} else if (value === data) {
result += evalLogData(record.data);
} else if (value === stack) {
const stack2 = record.stack();
if (stack2 !== "")
result += "\n" + stack2;
} else {
result += value.toString();
}
result += strings[i + 1];
}
return result;
};
}
var level, key, keys, date, msg, stack, data, formatter, jsonFormatter;
var init_formatting = __esm({
"node_modules/@matrixai/logger/dist/formatting.js"() {
init_require_shim();
init_utils();
level = Symbol("level");
key = Symbol("key");
keys = Symbol("keys");
date = Symbol("date");
msg = Symbol("msg");
stack = Symbol("stack");
data = Symbol("data");
__name(format, "format");
formatter = format`${level}:${key}:${msg}`;
jsonFormatter = /* @__PURE__ */ __name((record) => {
return JSON.stringify({
level: levelToString(record.level),
key: record.key,
msg: record.msg,
...record.data
}, evalLogDataValue);
}, "jsonFormatter");
}
});
// node_modules/@matrixai/logger/dist/Handler.js
var Handler, Handler_default;
var init_Handler = __esm({
"node_modules/@matrixai/logger/dist/Handler.js"() {
init_require_shim();
init_formatting();
Handler = class {
static {
__name(this, "Handler");
}
formatter;
constructor(formatter2 = formatter) {
this.formatter = formatter2;
}
setFormatter(formatter2) {
this.formatter = formatter2;
}
handle(record, format4) {
const output2 = format4 != null ? format4(record) : this.format(record);
this.emit(output2);
}
format(record) {
return this.formatter(record);
}
};
Handler_default = Handler;
}
});
// node_modules/@matrixai/logger/dist/handlers/ConsoleErrHandler.js
var ConsoleErrHandler, ConsoleErrHandler_default;
var init_ConsoleErrHandler = __esm({
"node_modules/@matrixai/logger/dist/handlers/ConsoleErrHandler.js"() {
init_require_shim();
init_Handler();
ConsoleErrHandler = class extends Handler_default {
static {
__name(this, "ConsoleErrHandler");
}
emit(output2) {
console.error(output2);
}
};
ConsoleErrHandler_default = ConsoleErrHandler;
}
});
// node_modules/@matrixai/logger/dist/Logger.js
var Logger, Logger_default;
var init_Logger = __esm({
"node_modules/@matrixai/logger/dist/Logger.js"() {
init_require_shim();
init_types();
init_ConsoleErrHandler();
init_utils();
Logger = class _Logger {
static {
__name(this, "Logger");
}
key;
level;
filter;
keys;
handlers;
parent;
_loggers = /* @__PURE__ */ new Map();
loggersRegistry;
constructor(key2 = "root", level2 = LogLevel.NOTSET, handlers = [new ConsoleErrHandler_default()], parent2) {
this.key = key2;
this.level = level2;
this.handlers = new Set(handlers);
this.parent = parent2;
this.keys = parent2 != null ? `${parent2.keys}.${key2}` : key2;
this.loggersRegistry = new FinalizationRegistry((key3) => {
this._loggers.delete(key3);
});
}
get loggers() {
return new Map([...this._loggers.entries()].map(([key2, loggerRef]) => {
const logger2 = loggerRef.deref();
if (logger2 != null) {
return [key2, logger2];
} else {
return void 0;
}
}).filter((e) => e != null));
}
getChild(key2) {
let loggerRef = this._loggers.get(key2);
let logger2 = loggerRef?.deref();
if (logger2 != null)
return logger2;
logger2 = new _Logger(key2, LogLevel.NOTSET, [], this);
loggerRef = new WeakRef(logger2);
this._loggers.set(key2, loggerRef);
this.loggersRegistry.register(logger2, key2);
return logger2;
}
getParent() {
return this.parent;
}
setLevel(level2) {
this.level = level2;
}
getEffectiveLevel() {
if (this.level !== LogLevel.NOTSET) {
return this.level;
}
if (this.parent) {
return this.parent.getEffectiveLevel();
}
return this.level;
}
isEnabledFor(level2) {
return level2 >= this.level;
}
addHandler(handler) {
this.handlers.add(handler);
}
removeHandler(handler) {
this.handlers.delete(handler);
}
clearHandlers() {
this.handlers.clear();
}
hasHandlers() {
if (this.handlers.size) {
return true;
} else {
return this.parent?.hasHandlers() ?? false;
}
}
setFilter(filter4) {
this.filter = filter4;
}
unsetFilter() {
delete this.filter;
}
debug(msg2, formatOrData, format4) {
if (formatOrData == null || typeof formatOrData === "function") {
return this.log(msg2, {}, LogLevel.DEBUG, formatOrData);
} else {
return this.log(msg2, formatOrData, LogLevel.DEBUG, format4);
}
}
info(msg2, formatOrData, format4) {
if (formatOrData == null || typeof formatOrData === "function") {
return this.log(msg2, {}, LogLevel.INFO, formatOrData);
} else {
return this.log(msg2, formatOrData, LogLevel.INFO, format4);
}
}
warn(msg2, formatOrData, format4) {
if (formatOrData == null || typeof formatOrData === "function") {
return this.log(msg2, {}, LogLevel.WARN, formatOrData);
} else {
return this.log(msg2, formatOrData, LogLevel.WARN, format4);
}
}
error(msg2, formatOrData, format4) {
if (formatOrData == null || typeof formatOrData === "function") {
return this.log(msg2, {}, LogLevel.ERROR, formatOrData);
} else {
return this.log(msg2, formatOrData, LogLevel.ERROR, format4);
}
}
log(msg2, data3, level2, format4) {
if (level2 < this.getEffectiveLevel())
return;
const record = this.makeRecord(msg2, data3, level2);
this.callHandlers(record, level2, format4);
}
/**
* Constructs a `LogRecord`
* The `LogRecord` can contain lazy values via wrapping with a lambda
* This improves performance as they are not evaluated unless needed during formatting
*/
makeRecord(msg2, data3, level2) {
return {
logger: this,
key: this.key,
keys: this.keys,
level: level2,
msg: msg2?.toString(),
data: data3,
date: () => /* @__PURE__ */ new Date(),
stack: () => {
let stack2;
if (hasCaptureStackTrace && hasStackTraceLimit) {
Error.stackTraceLimit++;
const error = {};
Error.captureStackTrace(error, _Logger.prototype.log);
Error.stackTraceLimit--;
stack2 = error.stack;
stack2 = stack2.slice(stack2.indexOf("\n", stack2.indexOf("\n") + 1) + 1);
} else {
stack2 = new Error().stack ?? "";
stack2 = stack2.slice(stack2.indexOf("\n") + 1);
}
return stack2;
}
};
}
callHandlers(record, level2, format4, keys2 = "") {
if (level2 < this.getEffectiveLevel())
return;
keys2 = `${this.key}.${keys2}`;
if (this.filter != null && !this.filter.test(keys2))
return;
for (const handler of this.handlers) {
handler.handle(record, format4);
}
if (this.parent) {
this.parent.callHandlers(record, level2, format4, keys2);
}
}
};
Logger_default = Logger;
}
});
// node_modules/@matrixai/logger/dist/handlers/ConsoleOutHandler.js
var ConsoleOutHandler, ConsoleOutHandler_default;
var init_ConsoleOutHandler = __esm({
"node_modules/@matrixai/logger/dist/handlers/ConsoleOutHandler.js"() {
init_require_shim();
init_Handler();
ConsoleOutHandler = class extends Handler_default {
static {
__name(this, "ConsoleOutHandler");
}
emit(output2) {
console.log(output2);
}
};
ConsoleOutHandler_default = ConsoleOutHandler;
}
});
// node_modules/@matrixai/logger/dist/handlers/StreamHandler.js
import process2 from "node:process";
var StreamHandler, StreamHandler_default;
var init_StreamHandler = __esm({
"node_modules/@matrixai/logger/dist/handlers/StreamHandler.js"() {
init_require_shim();
init_Handler();
StreamHandler = class extends Handler_default {
static {
__name(this, "StreamHandler");
}
emit(output2) {
process2.stderr.write(output2 + "\n");
}
};
StreamHandler_default = StreamHandler;
}
});
// node_modules/@matrixai/logger/dist/handlers/index.js
var init_handlers = __esm({
"node_modules/@matrixai/logger/dist/handlers/index.js"() {
init_require_shim();
init_ConsoleErrHandler();
init_ConsoleOutHandler();
init_StreamHandler();
}
});
// node_modules/@matrixai/logger/dist/index.js
var dist_exports = {};
__export(dist_exports, {
ConsoleErrHandler: () => ConsoleErrHandler_default,
ConsoleOutHandler: () => ConsoleOutHandler_default,
Handler: () => Handler_default,
LogLevel: () => LogLevel,
StreamHandler: () => StreamHandler_default,
default: () => Logger_default,
evalLogData: () => evalLogData,
evalLogDataValue: () => evalLogDataValue,
formatting: () => formatting_exports,
hasCaptureStackTrace: () => hasCaptureStackTrace,
hasStackTraceLimit: () => hasStackTraceLimit,
levelToString: () => levelToString
});
var init_dist = __esm({
"node_modules/@matrixai/logger/dist/index.js"() {
init_require_shim();
init_Logger();
init_Handler();
init_formatting();
init_handlers();
init_utils();
init_types();
}
});
// node_modules/@matrixai/resources/dist/utils.js
async function withF(acquires, f) {
const releases = [];
const resources = [];
let e_;
try {
for (const acquire of acquires) {
const [release, resource] = await acquire(resources);
releases.push(release);
resources.push(resource);
}
return await f(resources);
} catch (e) {
e_ = e;
throw e;
} finally {
releases.reverse();
for (const release of releases) {
await release(e_);
}
}
}
async function* withG(acquires, g) {
const releases = [];
const resources = [];
let e_;
try {
for (const acquire of acquires) {
const [release, resource] = await acquire(resources);
releases.push(release);
resources.push(resource);
}
return yield* g(resources);
} catch (e) {
e_ = e;
throw e;
} finally {
releases.reverse();
for (const release of releases) {
await release(e_);
}
}
}
var init_utils2 = __esm({
"node_modules/@matrixai/resources/dist/utils.js"() {
init_require_shim();
__name(withF, "withF");
__name(withG, "withG");
}
});
// node_modules/@matrixai/resources/dist/types.js
var init_types2 = __esm({
"node_modules/@matrixai/resources/dist/types.js"() {
init_require_shim();
}
});
// node_modules/@matrixai/resources/dist/index.js
var init_dist2 = __esm({
"node_modules/@matrixai/resources/dist/index.js"() {
init_require_shim();
init_utils2();
init_types2();
}
});
// node_modules/@matrixai/events/dist/AbstractEvent.js
var AbstractEvent, AbstractEvent_default;
var init_AbstractEvent = __esm({
"node_modules/@matrixai/events/dist/AbstractEvent.js"() {
init_require_shim();
AbstractEvent = class extends Event {
static {
__name(this, "AbstractEvent");
}
detail;
constructorParams;
constructor(type = new.target.name, options, constructorParams) {
if (typeof type === "string") {
super(type, options);
this.detail = options?.detail;
} else {
super(new.target.name, type);
this.detail = type.detail;
constructorParams = options;
}
this.constructorParams = constructorParams ?? arguments;
}
/**
* Events cannot be re-dispatched. This was probably to prevent infinite
* loops. So instead of re-dispatching the same instance, we re-dispatch
* a clone of the instance.
*/
clone() {
try {
return new this.constructor(...this.constructorParams);
} catch (e) {
if (e.name === "TypeError") {
throw new TypeError(`Cloning ${this.constructor.name} requires the original constructor arguments to be passed into super`);
}
throw e;
}
}
};
AbstractEvent_default = AbstractEvent;
}
});
// node_modules/@matrixai/events/dist/EventDefault.js
var EventDefault, EventDefault_default;
var init_EventDefault = __esm({
"node_modules/@matrixai/events/dist/EventDefault.js"() {
init_require_shim();
init_AbstractEvent();
EventDefault = class _EventDefault extends AbstractEvent_default {
static {
__name(this, "EventDefault");
}
constructor(options) {
super(_EventDefault.name, options, arguments);
}
};
EventDefault_default = EventDefault;
}
});
// node_modules/@matrixai/events/dist/EventAll.js
var EventAll, EventAll_default;
var init_EventAll = __esm({
"node_modules/@matrixai/events/dist/EventAll.js"() {
init_require_shim();
init_AbstractEvent();
EventAll = class _EventAll extends AbstractEvent_default {
static {
__name(this, "EventAll");
}
constructor(options) {
super(_EventAll.name, options, arguments);
}
};
EventAll_default = EventAll;
}
});
// node_modules/@matrixai/events/dist/EventError.js
var EventError, EventError_default;
var init_EventError = __esm({
"node_modules/@matrixai/events/dist/EventError.js"() {
init_require_shim();
init_AbstractEvent();
EventError = class _EventError extends AbstractEvent_default {
static {
__name(this, "EventError");
}
constructor(options) {
super(_EventError.name, options, arguments);
}
};
EventError_default = EventError;
}
});
// node_modules/@matrixai/events/dist/utils.js
var utils_exports2 = {};
__export(utils_exports2, {
_eventHandled: () => _eventHandled,
_eventHandlers: () => _eventHandlers,
_eventTarget: () => _eventTarget,
_handleEventError: () => _handleEventError,
canonicalizeOptions: () => canonicalizeOptions,
eventHandled: () => eventHandled,
eventHandlers: () => eventHandlers,
eventTarget: () => eventTarget,
handleEventError: () => handleEventError,
isEqualOptions: () => isEqualOptions
});
function canonicalizeOptions(options) {
return {
capture: false,
once: false,
passive: false,
...typeof options === "boolean" ? { capture: options } : typeof options === "object" ? options : void 0
};
}
function isEqualOptions(options1, options2) {
return options1.capture === options2.capture;
}
var _eventTarget, eventTarget, _eventHandlers, eventHandlers, _eventHandled, eventHandled, _handleEventError, handleEventError;
var init_utils3 = __esm({
"node_modules/@matrixai/events/dist/utils.js"() {
init_require_shim();
_eventTarget = Symbol("_eventTarget");
eventTarget = Symbol("eventTarget");
_eventHandlers = Symbol("_eventHandlers");
eventHandlers = Symbol("eventHandlers");
_eventHandled = Symbol("_eventHandled");
eventHandled = Symbol("eventHandled");
_handleEventError = Symbol("_handleEventError");
handleEventError = Symbol("handleEventError");
__name(canonicalizeOptions, "canonicalizeOptions");
__name(isEqualOptions, "isEqualOptions");
}
});
// node_modules/@matrixai/events/dist/Evented.js
function Evented() {
return (constructor) => {
const constructor_ = class extends constructor {
static {
__name(this, "constructor_");
}
[_eventTarget] = new EventTarget();
[_eventHandlers] = /* @__PURE__ */ new Map();
[_eventHandled] = /* @__PURE__ */ new WeakSet();
[_handleEventError] = (evt) => {
throw evt.detail;
};
constructor(...args) {
super(...args);
this[_eventTarget].addEventListener(EventError_default.name, this[_handleEventError]);
}
get [eventTarget]() {
return this[_eventTarget];
}
get [eventHandlers]() {
return this[_eventHandlers];
}
get [eventHandled]() {
return this[_eventHandled];
}
get [handleEventError]() {
return this[_handleEventError];
}
/**
* This can be O(n) per type due to searching for both handler and options.
*/
addEventListener(type, callback, options) {
options = canonicalizeOptions(options);
const that = this;
let handler;
let handlerSet;
let optionsEqual = false;
if (typeof callback === "function" || typeof callback?.handleEvent === "function") {
handlerSet = this[_eventHandlers].get(type);
if (handlerSet === void 0) {
handlerSet = /* @__PURE__ */ new Set();
this[_eventHandlers].set(type, handlerSet);
}
for (const handlerInfo of handlerSet) {
if (handlerInfo.callback === callback) {
handler = handlerInfo.handler;
if (isEqualOptions(handlerInfo.options, options)) {
optionsEqual = true;
break;
}
}
}
}
if (typeof callback === "function") {
if (handler == null) {
handler = /* @__PURE__ */ __name(async function(e) {
that[_eventHandled].add(e);
let result;
try {
result = callback.call(that, e);
} catch (e2) {
this.dispatchEvent(new EventError_default({
detail: e2
}));
}
if (typeof result?.then === "function") {
try {
await result;
} catch (e2) {
this.dispatchEvent(new EventError_default({
detail: e2
}));
}
}
}, "handler");
handlerSet.add({
callback,
options,
handler
});
} else if (!optionsEqual) {
handlerSet.add({
callback,
options,
handler
});
}
} else if (typeof callback?.handleEvent === "function") {
if (handler == null) {
handler = /* @__PURE__ */ __name(async function(e) {
that[_eventHandled].add(e);
let result;
try {
result = callback.handleEvent(e);
} catch (e2) {
this.dispatchEvent(new EventError_default({
detail: e2
}));
}
if (typeof result?.then === "function") {
try {
await result;
} catch (e2) {
this.dispatchEvent(new EventError_default({
detail: e2
}));
}
}
return result;
}, "handler");
handlerSet.add({
callback,
options,
handler
});
} else if (!optionsEqual) {
handlerSet.add({
callback,
options,
handler
});
}
} else {
handler = callback;
}
this[_eventTarget].addEventListener(type, handler, options);
if (type === EventError_default.name && handlerSet?.size === 1) {
this[_eventTarget].removeEventListener(EventError_default.name, this[_handleEventError]);
}
}
/**
* This can be O(n) per type due to searching for both handler and options.
*/
removeEventListener(type, callback, options) {
options = canonicalizeOptions(options);
let handler;
let handlerSet;
let handlerInfoToBeRemoved;
if (callback != null) {
handlerSet = this[_eventHandlers].get(type);
if (handlerSet === void 0) {
return;
}
for (const handlerInfo of handlerSet) {
if (handlerInfo.callback === callback && isEqualOptions(handlerInfo.options, options)) {
handler = handlerInfo.handler;
handlerInfoToBeRemoved = handlerInfo;
break;
}
}
if (handler == null) {
return;
}
} else {
handler = callback;
}
this[_eventTarget].removeEventListener(type, handler, options);
if (handlerSet != null && handlerInfoToBeRemoved != null) {
handlerSet.delete(handlerInfoToBeRemoved);
if (type === EventError_default.name && handlerSet.size === 0) {
this[_eventTarget].addEventListener(EventError_default.name, this[_handleEventError]);
}
}
}
dispatchEvent(event) {
Object.defineProperties(event, {
target: {
value: this,
writable: false
},
currentTarget: {
value: this,
writable: false
}
});
if (event instanceof EventError_default) {
return this[_eventTarget].dispatchEvent(event);
} else {
let status2 = this[_eventTarget].dispatchEvent(event);
if (status2 && !this[_eventHandled].has(event)) {
const eventDefault = new EventDefault_default({
bubbles: event.bubbles,
cancelable: event.cancelable,
composed: event.composed,
detail: event
});
Object.defineProperties(eventDefault, {
target: {
value: this,
writable: false
},
currentTarget: {
value: this,
writable: false
}
});
status2 = this[_eventTarget].dispatchEvent(eventDefault);
}
if (status2) {
const eventAll = new EventAll_default({
bubbles: event.bubbles,
cancelable: event.cancelable,
composed: event.composed,
detail: event
});
Object.defineProperties(eventAll, {
target: {
value: this,
writable: false
},
currentTarget: {
value: this,
writable: false
}
});
status2 = this[_eventTarget].dispatchEvent(eventAll);
}
return status2;
}
}
};
Object.defineProperty(constructor_, "name", Object.getOwnPropertyDescriptor(constructor, "name"));
return constructor_;
};
}
var init_Evented = __esm({
"node_modules/@matrixai/events/dist/Evented.js"() {
init_require_shim();
init_EventAll();
init_EventDefault();
init_EventError();
init_utils3();
__name(Evented, "Evented");
}
});
// node_modules/@matrixai/events/dist/types.js
var init_types3 = __esm({
"node_modules/@matrixai/events/dist/types.js"() {
init_require_shim();
}
});
// node_modules/@matrixai/events/dist/index.js
var init_dist3 = __esm({
"node_modules/@matrixai/events/dist/index.js"() {
init_require_shim();
init_AbstractEvent();
init_EventDefault();
init_EventAll();
init_EventError();
init_Evented();
init_utils3();
init_types3();
}
});
// node_modules/@matrixai/async-cancellable/dist/PromiseCancellable.js
var PromiseCancellable, PromiseCancellable_default;
var init_PromiseCancellable = __esm({
"node_modules/@matrixai/async-cancellable/dist/PromiseCancellable.js"() {
init_require_shim();
PromiseCancellable = class _PromiseCancellable extends Promise {
static {
__name(this, "PromiseCancellable");
}
static get [Symbol.species]() {
return Promise;
}
static resolve(value) {
if (value instanceof _PromiseCancellable)
return value;
return super.resolve(value);
}
static reject(reason) {
return super.reject(reason);
}
static all(values, controller) {
const pC = super.all(values);
if (typeof controller === "function") {
pC.abortController = new AbortController();
controller(pC.abortController.signal);
} else if (controller != null) {
pC.abortController = controller;
}
return pC;
}
static allSettled(values, controller) {
const pC = super.allSettled(values);
if (typeof controller === "function") {
pC.abortController = new AbortController();
controller(pC.abortController.signal);
} else if (controller != null) {
pC.abortController = controller;
}
return pC;
}
static race(values, controller) {
const pC = super.race(values);
if (typeof controller === "function") {
pC.abortController = new AbortController();
controller(pC.abortController.signal);
} else if (controller != null) {
pC.abortController = controller;
}
return pC;
}
static any(values, controller) {
const pC = super.any(values);
if (typeof controller === "function") {
pC.abortController = new AbortController();
controller(pC.abortController.signal);
} else if (controller != null) {
pC.abortController = controller;
}
return pC;
}
static from(p, controller) {
return new this((resolve, reject) => {
void p.then(resolve, reject);
}, controller);
}
reject;
abortController;
constructor(executor, controller) {
let abortController;
let signal;
let signalHandled;
if (typeof controller === "function") {
abortController = new AbortController();
controller(abortController.signal);
signal = abortController.signal;
signalHandled = true;
} else if (controller != null) {
abortController = controller;
signal = controller.signal;
signalHandled = true;
} else {
abortController = new AbortController();
signal = new Proxy(abortController.signal, {
get(target, prop2, receiver) {
if (prop2 === "addEventListener") {
return /* @__PURE__ */ __name(function addEventListener(...args) {
signalHandled = true;
return target[prop2].apply(this, args);
}, "addEventListener");
} else {
return Reflect.get(target, prop2, receiver);
}
},
set(target, prop2, value) {
if (prop2 === "onabort") {
signalHandled = true;
}
return Reflect.set(target, prop2, value);
},
deleteProperty(target, prop2) {
if (prop2 === "onabort") {
signalHandled = true;
}
return Reflect.deleteProperty(target, prop2);
}
});
signalHandled = false;
}
let reject_;
super((resolve, reject) => {
reject_ = /* @__PURE__ */ __name((reason) => {
if (reason instanceof DOMException && reason.name === "AbortError") {
reason = void 0;
}
reject(reason);
}, "reject_");
executor(resolve, reject_, signal);
});
if (!signalHandled) {
abortController.signal.addEventListener("abort", () => {
reject_(abortController.signal.reason);
}, { once: true });
}
this.reject = reject_;
this.abortController = abortController;
}
get [Symbol.toStringTag]() {
return this.constructor.name;
}
cancel(reason) {
this.abortController.abort(reason);
}
then(onFulfilled, onRejected, controller) {
let signal;
let onFulfilled_;
let onRejected_;
if (typeof onFulfilled === "function") {
onFulfilled_ = /* @__PURE__ */ __name((value) => onFulfilled(value, signal), "onFulfilled_");
}
if (typeof onRejected === "function") {
onRejected_ = /* @__PURE__ */ __name((reason) => onRejected(reason, signal), "onRejected_");
}
const p = super.then(onFulfilled_, onRejected_);
const pC = _PromiseCancellable.from(p, controller);
signal = pC.abortController.signal;
return pC;
}
catch(onRejected, controller) {
let signal;
let onRejected_;
if (typeof onRejected === "function") {
onRejected_ = /* @__PURE__ */ __name((reason) => onRejected(reason, signal), "onRejected_");
}
const pC = super.catch(onRejected_);
if (typeof controller === "function") {
pC.abortController = new AbortController();
controller(pC.abortController.signal);
} else if (controller != null) {
pC.abortController = controller;
}
signal = pC.abortController.signal;
return pC;
}
finally(onFinally, controller) {
let signal;
let onFinally_;
if (typeof onFinally === "function") {
onFinally_ = /* @__PURE__ */ __name(() => onFinally(signal), "onFinally_");
}
const pC = super.finally(onFinally_);
if (typeof controller === "function") {
pC.abortController = new AbortController();
controller(pC.abortController.signal);
} else if (controller != null) {
pC.abortController = controller;
}
signal = pC.abortController.signal;
return pC;
}
};
PromiseCancellable_default = PromiseCancellable;
}
});
// node_modules/@matrixai/async-cancellable/dist/types.js
var init_types4 = __esm({
"node_modules/@matrixai/async-cancellable/dist/types.js"() {
init_require_shim();
}
});
// node_modules/@matrixai/async-cancellable/dist/index.js
var init_dist4 = __esm({
"node_modules/@matrixai/async-cancellable/dist/index.js"() {
init_require_shim();
init_PromiseCancellable();
init_types4();
}
});
// node_modules/ts-custom-error/dist/custom-error.js
var require_custom_error = __commonJS({
"node_modules/ts-custom-error/dist/custom-error.js"(exports) {
init_require_shim();
function fixProto(target, prototype) {
var setPrototypeOf = Object.setPrototypeOf;
setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
}
__name(fixProto, "fixProto");
function fixStack(target, fn) {
if (fn === void 0) {
fn = target.constructor;
}
var captureStackTrace = Error.captureStackTrace;
captureStackTrace && captureStackTrace(target, fn);
}
__name(fixStack, "fixStack");
var __extends3 = function() {
var _extendStatics = /* @__PURE__ */ __name(function extendStatics3(d, b) {
_extendStatics = Object.setPrototypeOf || {
__proto__: []
} instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) {
if (Object.prototype.hasOwnProperty.call(b2, p))
d2[p] = b2[p];
}
};
return _extendStatics(d, b);
}, "extendStatics");
return function(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
_extendStatics(d, b);
function __() {
this.constructor = d;
}
__name(__, "__");
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
var CustomError2 = function(_super) {
__extends3(CustomError3, _super);
function CustomError3(message) {
var _newTarget = this.constructor;
var _this = _super.call(this, message) || this;
Object.defineProperty(_this, "name", {
value: _newTarget.name,
enumerable: false,
configurable: true
});
fixProto(_this, _newTarget.prototype);
fixStack(_this);
return _this;
}
__name(CustomError3, "CustomError");
return CustomError3;
}(Error);
var __spreadArray2 = function(to, from3, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from3.length, ar; i < l; i++) {
if (ar || !(i in from3)) {
if (!ar)
ar = Array.prototype.slice.call(from3, 0, i);
ar[i] = from3[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from3));
};
function customErrorFactory(fn, parent2) {
if (parent2 === void 0) {
parent2 = Error;
}
function CustomError3() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (!(this instanceof CustomError3))
return new (CustomError3.bind.apply(CustomError3, __spreadArray2([void 0], args, false)))();
parent2.apply(this, args);
Object.defineProperty(this, "name", {
value: fn.name || parent2.name,
enumerable: false,
configurable: true
});
fn.apply(this, args);
fixStack(this, CustomError3);
}
__name(CustomError3, "CustomError");
return Object.defineProperties(CustomError3, {
prototype: {
value: Object.create(parent2.prototype, {
constructor: {
value: CustomError3,
writable: true,
configurable: true
}
})
}
});
}
__name(customErrorFactory, "customErrorFactory");
exports.CustomError = CustomError2;
exports.customErrorFactory = customErrorFactory;
}
});
// node_modules/@matrixai/errors/dist/AbstractError.js
import { performance as performance2 } from "node:perf_hooks";
var import_ts_custom_error, AbstractError, AbstractError_default;
var init_AbstractError = __esm({
"node_modules/@matrixai/errors/dist/AbstractError.js"() {
init_require_shim();
import_ts_custom_error = __toESM(require_custom_error(), 1);
AbstractError = class extends import_ts_custom_error.CustomError {
static {
__name(this, "AbstractError");
}
/**
* Static description of exception
*/
static description = "";
/**
* Runtime decoding of JSON POJO to exception instance
* When overriding this, you cannot use `super.fromJSON`
* You must write it fully, and use the same type-hacks
* to support polymorphic `this` in static methods
* https://github.com/microsoft/TypeScript/issues/5863
*/
static fromJSON(json) {
if (typeof json !== "object" || json.type !== this.name || typeof json.data !== "object" || typeof json.data.message !== "string" || isNaN(Date.parse(json.data.timestamp)) || typeof json.data.data !== "object" || "stack" in json.data && typeof json.data.stack !== "string") {
throw new TypeError(`Cannot decode JSON to ${this.name}`);
}
const e = new this(json.data.message, {
timestamp: new Date(json.data.timestamp),
data: json.data.data,
cause: json.data.cause
});
e.stack = json.data.stack;
return e;
}
/**
* Arbitrary data
*/
data;
/**
* Causation of the exception
* Can be used to know what caused this exception
*/
cause;
/**
* Timestamp when exception was constructed in milliseconds
* Guaranteed to be weakly monotonic
*/
timestamp;
constructor(message = "", options = {}) {
super(message);
this.timestamp = options.timestamp ?? new Date(performance2.timeOrigin + performance2.now());
this.data = options.data ?? {};
this.cause = options.cause;
}
get description() {
return this.constructor["description"];
}
/**
* Encoding to JSON pojo
* When overriding this, you can use `super.toJSON`
* The `replacer` will:
* - delete undefined values in objects
* - replace undefined values for null in arrays
*/
toJSON() {
return {
type: this.constructor.name,
description: this.description,
data: {
message: this.message,
timestamp: this.timestamp,
data: this.data,
cause: this.cause,
stack: this.stack
}
};
}
};
AbstractError_default = AbstractError;
}
});
// node_modules/@matrixai/errors/dist/utils.js
var utils_exports3 = {};
__export(utils_exports3, {
checkError: () => checkError
});
function checkError(error, p, visited = /* @__PURE__ */ new Set()) {
if (visited.has(error))
return false;
visited.add(error);
const status2 = p(error);
if (status2)
return true;
if (error instanceof AggregateError) {
for (const e of error.errors) {
const status3 = checkError(e, p, visited);
if (status3)
return status3;
}
return checkError(error.cause, p, visited);
} else if (error instanceof Error) {
return checkError(error.cause, p, visited);
}
return false;
}
var init_utils4 = __esm({
"node_modules/@matrixai/errors/dist/utils.js"() {
init_require_shim();
__name(checkError, "checkError");
}
});
// node_modules/@matrixai/errors/dist/types.js
var init_types5 = __esm({
"node_modules/@matrixai/errors/dist/types.js"() {
init_require_shim();
}
});
// node_modules/@matrixai/errors/dist/index.js
var init_dist5 = __esm({
"node_modules/@matrixai/errors/dist/index.js"() {
init_require_shim();
init_AbstractError();
init_utils4();
init_types5();
}
});
// node_modules/@matrixai/timer/dist/errors.js
var ErrorTimer, ErrorTimerEnded;
var init_errors = __esm({
"node_modules/@matrixai/timer/dist/errors.js"() {
init_require_shim();
init_dist5();
ErrorTimer = class extends AbstractError_default {
static {
__name(this, "ErrorTimer");
}
static description = "Timer error";
};
ErrorTimerEnded = class extends ErrorTimer {
static {
__name(this, "ErrorTimerEnded");
}
static description = "The timer has already ended";
};
}
});
// node_modules/@matrixai/timer/dist/Timer.js
import { performance as performance3 } from "node:perf_hooks";
var Timer, Timer_default;
var init_Timer = __esm({
"node_modules/@matrixai/timer/dist/Timer.js"() {
init_require_shim();
init_dist4();
init_errors();
Timer = class {
static {
__name(this, "Timer");
}
/**
* Delay in milliseconds
* This may be `Infinity`
*/
_delay;
/**
* If it is lazy, the timer will not eagerly reject
* on cancellation if the handler has started executing
*/
lazy;
/**
* Timestamp when this is constructed
* Guaranteed to be weakly monotonic within the process lifetime
* Compare this with `performance.now()` not `Date.now()`
*/
timestamp;
/**
* Timestamp when this is scheduled to finish and execute the handler
* Guaranteed to be weakly monotonic within the process lifetime
* Compare this with `performance.now()` not `Date.now()`
*/
_scheduled;
/**
* Handler to be executed
*/
handler;
/**
* Deconstructed promise
*/
p;
/**
* Resolve deconstructed promise
*/
resolveP;
/**
* Reject deconstructed promise
*/
rejectP;
/**
* Abort controller allows immediate cancellation
*/
abortController;
/**
* Internal timeout reference
*/
timeoutRef;
/**
* The status indicates when we have started settling or settled
*/
_status = null;
constructor(handlerOrOpts, delay = 0, lazy = false, controller) {
let handler;
if (typeof handlerOrOpts === "function") {
handler = handlerOrOpts;
} else if (typeof handlerOrOpts === "object" && handlerOrOpts !== null) {
handler = handlerOrOpts.handler;
delay = handlerOrOpts.delay ?? delay;
lazy = handlerOrOpts.lazy ?? lazy;
controller = handlerOrOpts.controller ?? controller;
}
if (isNaN(delay)) {
delay = 0;
} else {
delay = Math.max(delay, 0);
if (isFinite(delay)) {
delay = Math.min(delay, 2 ** 31 - 1);
}
}
this.handler = handler;
this._delay = delay;
this.lazy = lazy;
let abortController;
if (typeof controller === "function") {
abortController = new AbortController();
controller(abortController.signal);
} else if (controller != null) {
abortController = controller;
} else {
abortController = new AbortController();
abortController.signal.addEventListener("abort", () => void this.reject(abortController.signal.reason));
}
this.p = new PromiseCancellable_default((resolve, reject) => {
this.resolveP = resolve.bind(this.p);
this.rejectP = reject.bind(this.p);
}, abortController);
this.abortController = abortController;
if (isFinite(delay)) {
this.timeoutRef = setTimeout(() => void this.fulfill(), delay);
this.timestamp = new Date(performance3.timeOrigin + performance3.now());
this._scheduled = new Date(this.timestamp.getTime() + delay);
} else {
this.timeoutRef = setInterval(() => {
}, 2 ** 31 - 1);
this.timestamp = new Date(performance3.timeOrigin + performance3.now());
}
}
get [Symbol.toStringTag]() {
return this.constructor.name;
}
get status() {
return this._status;
}
/**
* Timestamp when this is scheduled to finish and execute the handler
* Guaranteed to be weakly monotonic within the process lifetime
* Compare this with `performance.now()` not `Date.now()`
*/
get scheduled() {
return this._scheduled;
}
/**
* Delay in milliseconds
* This may be `Infinity`
*/
get delay() {
return this._delay;
}
/**
* Gets the remaining time in milliseconds
* This will return `Infinity` if `delay` is `Infinity`
* This will return `0` if status is `settling` or `settled`
*/
getTimeout() {
if (this._status !== null)
return 0;
if (this._scheduled == null)
return Infinity;
return Math.max(Math.trunc(this._scheduled.getTime() - (performance3.timeOrigin + performance3.now())), 0);
}
/**
* To remaining time as a string
* This may return `'Infinity'` if `this.delay` is `Infinity`
* This will return `'0'` if status is `settling` or `settled`
*/
toString() {
return this.getTimeout().toString();
}
/**
* To remaining time as a number
* This may return `Infinity` if `this.delay` is `Infinity`
* This will return `0` if status is `settling` or `settled`
*/
valueOf() {
return this.getTimeout();
}
/**
* Cancels the timer
* Unlike `PromiseCancellable`, canceling the timer will not result
* in an unhandled promise rejection, all promise rejections are ignored
*/
cancel(reason) {
void this.p.catch(() => {
});
this.p.cancel(reason);
}
then(onFulfilled, onRejected, controller) {
return this.p.then(onFulfilled, onRejected, controller);
}
catch(onRejected, controller) {
return this.p.catch(onRejected, controller);
}
finally(onFinally, controller) {
return this.p.finally(onFinally, controller);
}
/**
* Refreshes the timer to the original