@cartanova/qgrid-cli 0.1.1 → 1.0.0

package/bundle/dist/node_modules/.pnpm/tinybench@2.9.0/node_modules/tinybench/dist/index.js

@@ -0,0 +1,506 @@
+import "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/tinybench@2.9.0/node_modules/tinybench/dist/index.js
+var $ = Object.defineProperty;
+var C = (s) => {
+	throw TypeError(s);
+};
+var D = (s, n, t) => n in s ? $(s, n, {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: t
+}) : s[n] = t;
+var O = (s, n, t) => D(s, typeof n != "symbol" ? n + "" : n, t), q = (s, n, t) => n.has(s) || C("Cannot " + t);
+var d = (s, n, t) => (q(s, n, "read from private field"), t ? t.call(s) : n.get(s)), k = (s, n, t) => n.has(s) ? C("Cannot add the same private member more than once") : n instanceof WeakSet ? n.add(s) : n.set(s, t), f = (s, n, t, e) => (q(s, n, "write to private field"), e ? e.call(s, t) : n.set(s, t), t);
+var F = (s, n, t, e) => ({
+	set _(r) {
+		f(s, n, r, t);
+	},
+	get _() {
+		return d(s, n, e);
+	}
+});
+var M = class {
+	constructor(n) {
+		O(this, "value");
+		O(this, "next");
+		this.value = n;
+	}
+}, m, w, E, g = class {
+	constructor() {
+		k(this, m);
+		k(this, w);
+		k(this, E);
+		this.clear();
+	}
+	enqueue(n) {
+		let t = new M(n);
+		d(this, m) ? (d(this, w).next = t, f(this, w, t)) : (f(this, m, t), f(this, w, t)), F(this, E)._++;
+	}
+	dequeue() {
+		let n = d(this, m);
+		if (n) return f(this, m, d(this, m).next), F(this, E)._--, n.value;
+	}
+	clear() {
+		f(this, m, void 0), f(this, w, void 0), f(this, E, 0);
+	}
+	get size() {
+		return d(this, E);
+	}
+	*[Symbol.iterator]() {
+		let n = d(this, m);
+		for (; n;) yield n.value, n = n.next;
+	}
+};
+m = /* @__PURE__ */ new WeakMap(), w = /* @__PURE__ */ new WeakMap(), E = /* @__PURE__ */ new WeakMap();
+function y(s) {
+	if (!((Number.isInteger(s) || s === Number.POSITIVE_INFINITY) && s > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+	let n = new g(), t = 0, e = () => {
+		t--, n.size > 0 && n.dequeue()();
+	}, r = async (h, p, a) => {
+		t++;
+		let l = (async () => h(...a))();
+		p(l);
+		try {
+			await l;
+		} catch (T) {}
+		e();
+	}, i = (h, p, a) => {
+		n.enqueue(r.bind(void 0, h, p, a)), (async () => (await Promise.resolve(), t < s && n.size > 0 && n.dequeue()()))();
+	}, c = (h, ...p) => new Promise((a) => {
+		i(h, a, p);
+	});
+	return Object.defineProperties(c, {
+		activeCount: { get: () => t },
+		pendingCount: { get: () => n.size },
+		clearQueue: { value: () => {
+			n.clear();
+		} }
+	}), c;
+}
+function o(s, n = null) {
+	let t = new Event(s);
+	return n && Object.defineProperty(t, "task", {
+		value: n,
+		enumerable: !0,
+		writable: !1,
+		configurable: !1
+	}), t;
+}
+var N = {
+	1: 12.71,
+	2: 4.303,
+	3: 3.182,
+	4: 2.776,
+	5: 2.571,
+	6: 2.447,
+	7: 2.365,
+	8: 2.306,
+	9: 2.262,
+	10: 2.228,
+	11: 2.201,
+	12: 2.179,
+	13: 2.16,
+	14: 2.145,
+	15: 2.131,
+	16: 2.12,
+	17: 2.11,
+	18: 2.101,
+	19: 2.093,
+	20: 2.086,
+	21: 2.08,
+	22: 2.074,
+	23: 2.069,
+	24: 2.064,
+	25: 2.06,
+	26: 2.056,
+	27: 2.052,
+	28: 2.048,
+	29: 2.045,
+	30: 2.042,
+	31: 2.0399,
+	32: 2.0378,
+	33: 2.0357,
+	34: 2.0336,
+	35: 2.0315,
+	36: 2.0294,
+	37: 2.0273,
+	38: 2.0252,
+	39: 2.0231,
+	40: 2.021,
+	41: 2.0198,
+	42: 2.0186,
+	43: 2.0174,
+	44: 2.0162,
+	45: 2.015,
+	46: 2.0138,
+	47: 2.0126,
+	48: 2.0114,
+	49: 2.0102,
+	50: 2.009,
+	51: 2.0081,
+	52: 2.0072,
+	53: 2.0063,
+	54: 2.0054,
+	55: 2.0045,
+	56: 2.0036,
+	57: 2.0027,
+	58: 2.0018,
+	59: 2.0009,
+	60: 2,
+	61: 1.9995,
+	62: 1.999,
+	63: 1.9985,
+	64: 1.998,
+	65: 1.9975,
+	66: 1.997,
+	67: 1.9965,
+	68: 1.996,
+	69: 1.9955,
+	70: 1.995,
+	71: 1.9945,
+	72: 1.994,
+	73: 1.9935,
+	74: 1.993,
+	75: 1.9925,
+	76: 1.992,
+	77: 1.9915,
+	78: 1.991,
+	79: 1.9905,
+	80: 1.99,
+	81: 1.9897,
+	82: 1.9894,
+	83: 1.9891,
+	84: 1.9888,
+	85: 1.9885,
+	86: 1.9882,
+	87: 1.9879,
+	88: 1.9876,
+	89: 1.9873,
+	90: 1.987,
+	91: 1.9867,
+	92: 1.9864,
+	93: 1.9861,
+	94: 1.9858,
+	95: 1.9855,
+	96: 1.9852,
+	97: 1.9849,
+	98: 1.9846,
+	99: 1.9843,
+	100: 1.984,
+	101: 1.9838,
+	102: 1.9836,
+	103: 1.9834,
+	104: 1.9832,
+	105: 1.983,
+	106: 1.9828,
+	107: 1.9826,
+	108: 1.9824,
+	109: 1.9822,
+	110: 1.982,
+	111: 1.9818,
+	112: 1.9816,
+	113: 1.9814,
+	114: 1.9812,
+	115: 1.9819,
+	116: 1.9808,
+	117: 1.9806,
+	118: 1.9804,
+	119: 1.9802,
+	120: 1.98,
+	infinity: 1.96
+};
+var J = (s) => s / 1e6, U = () => J(Number(process.hrtime.bigint())), B = () => performance.now();
+function W(s) {
+	return s !== null && typeof s == "object" && typeof s.then == "function";
+}
+var S = (s, n) => s.reduce((e, r) => e + (r - n) ** 2, 0) / (s.length - 1) || 0, X = (async () => {}).constructor, Z = (s) => s.constructor === X, z = async (s) => {
+	if (Z(s.fn)) return !0;
+	try {
+		if (s.opts.beforeEach != null) try {
+			await s.opts.beforeEach.call(s);
+		} catch (e) {}
+		let n = s.fn(), t = W(n);
+		if (t) try {
+			await n;
+		} catch (e) {}
+		if (s.opts.afterEach != null) try {
+			await s.opts.afterEach.call(s);
+		} catch (e) {}
+		return t;
+	} catch (n) {
+		return !1;
+	}
+};
+var b = class extends EventTarget {
+	constructor(t, e, r, i = {}) {
+		super();
+		this.runs = 0;
+		this.bench = t, this.name = e, this.fn = r, this.opts = i;
+	}
+	async loop(t, e) {
+		var T;
+		let r = this.bench.concurrency === "task", { threshold: i } = this.bench, c = 0, h = [];
+		if (this.opts.beforeAll != null) try {
+			await this.opts.beforeAll.call(this);
+		} catch (u) {
+			return { error: u };
+		}
+		let p = await z(this), a = async () => {
+			this.opts.beforeEach != null && await this.opts.beforeEach.call(this);
+			let u = 0;
+			if (p) {
+				let v = this.bench.now();
+				await this.fn.call(this), u = this.bench.now() - v;
+			} else {
+				let v = this.bench.now();
+				this.fn.call(this), u = this.bench.now() - v;
+			}
+			h.push(u), c += u, this.opts.afterEach != null && await this.opts.afterEach.call(this);
+		}, l = y(i);
+		try {
+			let u = [];
+			for (; (c < t || h.length + l.activeCount + l.pendingCount < e) && !((T = this.bench.signal) != null && T.aborted);) r ? u.push(l(a)) : await a();
+			u.length && await Promise.all(u);
+		} catch (u) {
+			return { error: u };
+		}
+		if (this.opts.afterAll != null) try {
+			await this.opts.afterAll.call(this);
+		} catch (u) {
+			return { error: u };
+		}
+		return { samples: h };
+	}
+	/**
+	* run the current task and write the results in `Task.result` object
+	*/
+	async run() {
+		var r, i;
+		if ((r = this.result) != null && r.error) return this;
+		this.dispatchEvent(o("start", this)), await this.bench.setup(this, "run");
+		let { samples: t, error: e } = await this.loop(this.bench.time, this.bench.iterations);
+		if (this.bench.teardown(this, "run"), t) {
+			let c = t.reduce((L, A) => L + A, 0);
+			this.runs = t.length, t.sort((L, A) => L - A);
+			let h = c / this.runs, p = 1e3 / h, a = t.length, l = a - 1, T = t[0], u = t[l], v = c / t.length || 0, P = S(t, v), R = Math.sqrt(P), I = R / Math.sqrt(a), _ = N[String(Math.round(l) || 1)] || N.infinity, K = I * _, j = K / v * 100, H = t[Math.ceil(a * .75) - 1], V = t[Math.ceil(a * .99) - 1], Q = t[Math.ceil(a * .995) - 1], Y = t[Math.ceil(a * .999) - 1];
+			if ((i = this.bench.signal) != null && i.aborted) return this;
+			this.setResult({
+				totalTime: c,
+				min: T,
+				max: u,
+				hz: p,
+				period: h,
+				samples: t,
+				mean: v,
+				variance: P,
+				sd: R,
+				sem: I,
+				df: l,
+				critical: _,
+				moe: K,
+				rme: j,
+				p75: H,
+				p99: V,
+				p995: Q,
+				p999: Y
+			});
+		}
+		if (e) {
+			if (this.setResult({ error: e }), this.bench.throws) throw e;
+			this.dispatchEvent(o("error", this)), this.bench.dispatchEvent(o("error", this));
+		}
+		return this.dispatchEvent(o("cycle", this)), this.bench.dispatchEvent(o("cycle", this)), this.dispatchEvent(o("complete", this)), this;
+	}
+	/**
+	* warmup the current task
+	*/
+	async warmup() {
+		var e;
+		if ((e = this.result) != null && e.error) return;
+		this.dispatchEvent(o("warmup", this)), await this.bench.setup(this, "warmup");
+		let { error: t } = await this.loop(this.bench.warmupTime, this.bench.warmupIterations);
+		if (this.bench.teardown(this, "warmup"), t && (this.setResult({ error: t }), this.bench.throws)) throw t;
+	}
+	addEventListener(t, e, r) {
+		super.addEventListener(t, e, r);
+	}
+	removeEventListener(t, e, r) {
+		super.removeEventListener(t, e, r);
+	}
+	/**
+	* change the result object values
+	*/
+	setResult(t) {
+		this.result = {
+			...this.result,
+			...t
+		}, Object.freeze(this.result);
+	}
+	/**
+	* reset the task to make the `Task.runs` a zero-value and remove the `Task.result`
+	* object
+	*/
+	reset() {
+		this.dispatchEvent(o("reset", this)), this.runs = 0, this.result = void 0;
+	}
+};
+var x = class extends EventTarget {
+	constructor(t = {}) {
+		var e, r, i, c, h, p, a, l;
+		super();
+		this._tasks = /* @__PURE__ */ new Map();
+		this._todos = /* @__PURE__ */ new Map();
+		/**
+		* Executes tasks concurrently based on the specified concurrency mode.
+		*
+		* - When `mode` is set to `null` (default), concurrency is disabled.
+		* - When `mode` is set to 'task', each task's iterations (calls of a task function) run concurrently.
+		* - When `mode` is set to 'bench', different tasks within the bench run concurrently.
+		*/
+		this.concurrency = null;
+		/**
+		* The maximum number of concurrent tasks to run. Defaults to Infinity.
+		*/
+		this.threshold = Infinity;
+		this.warmupTime = 100;
+		this.warmupIterations = 5;
+		this.time = 500;
+		this.iterations = 10;
+		this.now = B;
+		this.now = (e = t.now) != null ? e : this.now, this.warmupTime = (r = t.warmupTime) != null ? r : this.warmupTime, this.warmupIterations = (i = t.warmupIterations) != null ? i : this.warmupIterations, this.time = (c = t.time) != null ? c : this.time, this.iterations = (h = t.iterations) != null ? h : this.iterations, this.signal = t.signal, this.throws = (p = t.throws) != null ? p : !1, this.setup = (a = t.setup) != null ? a : () => {}, this.teardown = (l = t.teardown) != null ? l : () => {}, this.signal && this.signal.addEventListener("abort", () => {
+			this.dispatchEvent(o("abort"));
+		}, { once: !0 });
+	}
+	runTask(t) {
+		var e;
+		return (e = this.signal) != null && e.aborted ? t : t.run();
+	}
+	/**
+	* run the added tasks that were registered using the
+	* {@link add} method.
+	* Note: This method does not do any warmup. Call {@link warmup} for that.
+	*/
+	async run() {
+		if (this.concurrency === "bench") return this.runConcurrently(this.threshold, this.concurrency);
+		this.dispatchEvent(o("start"));
+		let t = [];
+		for (let e of [...this._tasks.values()]) t.push(await this.runTask(e));
+		return this.dispatchEvent(o("complete")), t;
+	}
+	/**
+	* See Bench.{@link concurrency}
+	*/
+	async runConcurrently(t = Infinity, e = "bench") {
+		if (this.threshold = t, this.concurrency = e, e === "task") return this.run();
+		this.dispatchEvent(o("start"));
+		let r = y(t), i = [];
+		for (let h of [...this._tasks.values()]) i.push(r(() => this.runTask(h)));
+		let c = await Promise.all(i);
+		return this.dispatchEvent(o("complete")), c;
+	}
+	/**
+	* warmup the benchmark tasks.
+	* This is not run by default by the {@link run} method.
+	*/
+	async warmup() {
+		if (this.concurrency === "bench") {
+			await this.warmupConcurrently(this.threshold, this.concurrency);
+			return;
+		}
+		this.dispatchEvent(o("warmup"));
+		for (let [, t] of this._tasks) await t.warmup();
+	}
+	/**
+	* warmup the benchmark tasks concurrently.
+	* This is not run by default by the {@link runConcurrently} method.
+	*/
+	async warmupConcurrently(t = Infinity, e = "bench") {
+		if (this.threshold = t, this.concurrency = e, e === "task") {
+			await this.warmup();
+			return;
+		}
+		this.dispatchEvent(o("warmup"));
+		let r = y(t), i = [];
+		for (let [, c] of this._tasks) i.push(r(() => c.warmup()));
+		await Promise.all(i);
+	}
+	/**
+	* reset each task and remove its result
+	*/
+	reset() {
+		this.dispatchEvent(o("reset")), this._tasks.forEach((t) => {
+			t.reset();
+		});
+	}
+	/**
+	* add a benchmark task to the task map
+	*/
+	add(t, e, r = {}) {
+		let i = new b(this, t, e, r);
+		return this._tasks.set(t, i), this.dispatchEvent(o("add", i)), this;
+	}
+	/**
+	* add a benchmark todo to the todo map
+	*/
+	todo(t, e = () => {}, r = {}) {
+		let i = new b(this, t, e, r);
+		return this._todos.set(t, i), this.dispatchEvent(o("todo", i)), this;
+	}
+	/**
+	* remove a benchmark task from the task map
+	*/
+	remove(t) {
+		let e = this.getTask(t);
+		return e && (this.dispatchEvent(o("remove", e)), this._tasks.delete(t)), this;
+	}
+	addEventListener(t, e, r) {
+		super.addEventListener(t, e, r);
+	}
+	removeEventListener(t, e, r) {
+		super.removeEventListener(t, e, r);
+	}
+	/**
+	* table of the tasks results
+	*/
+	table(t) {
+		return this.tasks.map((e) => {
+			if (e.result) {
+				if (e.result.error) throw e.result.error;
+				return (t == null ? void 0 : t(e)) || {
+					"Task Name": e.name,
+					"ops/sec": e.result.error ? "NaN" : parseInt(e.result.hz.toString(), 10).toLocaleString(),
+					"Average Time (ns)": e.result.error ? "NaN" : e.result.mean * 1e3 * 1e3,
+					Margin: e.result.error ? "NaN" : `\xB1${e.result.rme.toFixed(2)}%`,
+					Samples: e.result.error ? "NaN" : e.result.samples.length
+				};
+			}
+			return null;
+		});
+	}
+	/**
+	* (getter) tasks results as an array
+	*/
+	get results() {
+		return [...this._tasks.values()].map((t) => t.result);
+	}
+	/**
+	* (getter) tasks as an array
+	*/
+	get tasks() {
+		return [...this._tasks.values()];
+	}
+	get todos() {
+		return [...this._todos.values()];
+	}
+	/**
+	* get a task based on the task name
+	*/
+	getTask(t) {
+		return this._tasks.get(t);
+	}
+};
+//#endregion
+export { x as Bench, b as Task, U as hrtimeNow, B as now };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/tinybench@2.9.0/node_modules/tinybench/dist/index.js"],"sourcesContent":["var $ = Object.defineProperty;\nvar C = (s) => {\n  throw TypeError(s);\n};\nvar D = (s, n, t) => n in s ? $(s, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[n] = t;\nvar O = (s, n, t) => D(s, typeof n != \"symbol\" ? n + \"\" : n, t), q = (s, n, t) => n.has(s) || C(\"Cannot \" + t);\nvar d = (s, n, t) => (q(s, n, \"read from private field\"), t ? t.call(s) : n.get(s)), k = (s, n, t) => n.has(s) ? C(\"Cannot add the same private member more than once\") : n instanceof WeakSet ? n.add(s) : n.set(s, t), f = (s, n, t, e) => (q(s, n, \"write to private field\"), e ? e.call(s, t) : n.set(s, t), t);\nvar F = (s, n, t, e) => ({\n  set _(r) {\n    f(s, n, r, t);\n  },\n  get _() {\n    return d(s, n, e);\n  }\n});\n\n// node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js\nvar M = class {\n  constructor(n) {\n    O(this, \"value\");\n    O(this, \"next\");\n    this.value = n;\n  }\n}, m, w, E, g = class {\n  constructor() {\n    k(this, m);\n    k(this, w);\n    k(this, E);\n    this.clear();\n  }\n  enqueue(n) {\n    let t = new M(n);\n    d(this, m) ? (d(this, w).next = t, f(this, w, t)) : (f(this, m, t), f(this, w, t)), F(this, E)._++;\n  }\n  dequeue() {\n    let n = d(this, m);\n    if (n)\n      return f(this, m, d(this, m).next), F(this, E)._--, n.value;\n  }\n  clear() {\n    f(this, m, void 0), f(this, w, void 0), f(this, E, 0);\n  }\n  get size() {\n    return d(this, E);\n  }\n  *[Symbol.iterator]() {\n    let n = d(this, m);\n    for (; n; )\n      yield n.value, n = n.next;\n  }\n};\nm = new WeakMap(), w = new WeakMap(), E = new WeakMap();\n\n// node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js\nfunction y(s) {\n  if (!((Number.isInteger(s) || s === Number.POSITIVE_INFINITY) && s > 0))\n    throw new TypeError(\"Expected `concurrency` to be a number from 1 and up\");\n  let n = new g(), t = 0, e = () => {\n    t--, n.size > 0 && n.dequeue()();\n  }, r = async (h, p, a) => {\n    t++;\n    let l = (async () => h(...a))();\n    p(l);\n    try {\n      await l;\n    } catch (T) {\n    }\n    e();\n  }, i = (h, p, a) => {\n    n.enqueue(r.bind(void 0, h, p, a)), (async () => (await Promise.resolve(), t < s && n.size > 0 && n.dequeue()()))();\n  }, c = (h, ...p) => new Promise((a) => {\n    i(h, a, p);\n  });\n  return Object.defineProperties(c, {\n    activeCount: {\n      get: () => t\n    },\n    pendingCount: {\n      get: () => n.size\n    },\n    clearQueue: {\n      value: () => {\n        n.clear();\n      }\n    }\n  }), c;\n}\n\n// src/event.ts\nfunction o(s, n = null) {\n  let t = new Event(s);\n  return n && Object.defineProperty(t, \"task\", {\n    value: n,\n    enumerable: !0,\n    writable: !1,\n    configurable: !1\n  }), t;\n}\n\n// src/constants.ts\nvar G = {\n  1: 12.71,\n  2: 4.303,\n  3: 3.182,\n  4: 2.776,\n  5: 2.571,\n  6: 2.447,\n  7: 2.365,\n  8: 2.306,\n  9: 2.262,\n  10: 2.228,\n  11: 2.201,\n  12: 2.179,\n  13: 2.16,\n  14: 2.145,\n  15: 2.131,\n  16: 2.12,\n  17: 2.11,\n  18: 2.101,\n  19: 2.093,\n  20: 2.086,\n  21: 2.08,\n  22: 2.074,\n  23: 2.069,\n  24: 2.064,\n  25: 2.06,\n  26: 2.056,\n  27: 2.052,\n  28: 2.048,\n  29: 2.045,\n  30: 2.042,\n  31: 2.0399,\n  32: 2.0378,\n  33: 2.0357,\n  34: 2.0336,\n  35: 2.0315,\n  36: 2.0294,\n  37: 2.0273,\n  38: 2.0252,\n  39: 2.0231,\n  40: 2.021,\n  41: 2.0198,\n  42: 2.0186,\n  43: 2.0174,\n  44: 2.0162,\n  45: 2.015,\n  46: 2.0138,\n  47: 2.0126,\n  48: 2.0114,\n  49: 2.0102,\n  50: 2.009,\n  51: 2.0081,\n  52: 2.0072,\n  53: 2.0063,\n  54: 2.0054,\n  55: 2.0045,\n  56: 2.0036,\n  57: 2.0027,\n  58: 2.0018,\n  59: 2.0009,\n  60: 2,\n  61: 1.9995,\n  62: 1.999,\n  63: 1.9985,\n  64: 1.998,\n  65: 1.9975,\n  66: 1.997,\n  67: 1.9965,\n  68: 1.996,\n  69: 1.9955,\n  70: 1.995,\n  71: 1.9945,\n  72: 1.994,\n  73: 1.9935,\n  74: 1.993,\n  75: 1.9925,\n  76: 1.992,\n  77: 1.9915,\n  78: 1.991,\n  79: 1.9905,\n  80: 1.99,\n  81: 1.9897,\n  82: 1.9894,\n  83: 1.9891,\n  84: 1.9888,\n  85: 1.9885,\n  86: 1.9882,\n  87: 1.9879,\n  88: 1.9876,\n  89: 1.9873,\n  90: 1.987,\n  91: 1.9867,\n  92: 1.9864,\n  93: 1.9861,\n  94: 1.9858,\n  95: 1.9855,\n  96: 1.9852,\n  97: 1.9849,\n  98: 1.9846,\n  99: 1.9843,\n  100: 1.984,\n  101: 1.9838,\n  102: 1.9836,\n  103: 1.9834,\n  104: 1.9832,\n  105: 1.983,\n  106: 1.9828,\n  107: 1.9826,\n  108: 1.9824,\n  109: 1.9822,\n  110: 1.982,\n  111: 1.9818,\n  112: 1.9816,\n  113: 1.9814,\n  114: 1.9812,\n  115: 1.9819,\n  116: 1.9808,\n  117: 1.9806,\n  118: 1.9804,\n  119: 1.9802,\n  120: 1.98,\n  infinity: 1.96\n}, N = G;\n\n// src/utils.ts\nvar J = (s) => s / 1e6, U = () => J(Number(process.hrtime.bigint())), B = () => performance.now();\nfunction W(s) {\n  return s !== null && typeof s == \"object\" && typeof s.then == \"function\";\n}\nvar S = (s, n) => s.reduce((e, r) => e + (r - n) ** 2, 0) / (s.length - 1) || 0, X = (async () => {\n}).constructor, Z = (s) => s.constructor === X, z = async (s) => {\n  if (Z(s.fn))\n    return !0;\n  try {\n    if (s.opts.beforeEach != null)\n      try {\n        await s.opts.beforeEach.call(s);\n      } catch (e) {\n      }\n    let n = s.fn(), t = W(n);\n    if (t)\n      try {\n        await n;\n      } catch (e) {\n      }\n    if (s.opts.afterEach != null)\n      try {\n        await s.opts.afterEach.call(s);\n      } catch (e) {\n      }\n    return t;\n  } catch (n) {\n    return !1;\n  }\n};\n\n// src/task.ts\nvar b = class extends EventTarget {\n  constructor(t, e, r, i = {}) {\n    super();\n    /*\n     * the number of times the task\n     * function has been executed\n     */\n    this.runs = 0;\n    this.bench = t, this.name = e, this.fn = r, this.opts = i;\n  }\n  async loop(t, e) {\n    var T;\n    let r = this.bench.concurrency === \"task\", { threshold: i } = this.bench, c = 0, h = [];\n    if (this.opts.beforeAll != null)\n      try {\n        await this.opts.beforeAll.call(this);\n      } catch (u) {\n        return { error: u };\n      }\n    let p = await z(this), a = async () => {\n      this.opts.beforeEach != null && await this.opts.beforeEach.call(this);\n      let u = 0;\n      if (p) {\n        let v = this.bench.now();\n        await this.fn.call(this), u = this.bench.now() - v;\n      } else {\n        let v = this.bench.now();\n        this.fn.call(this), u = this.bench.now() - v;\n      }\n      h.push(u), c += u, this.opts.afterEach != null && await this.opts.afterEach.call(this);\n    }, l = y(i);\n    try {\n      let u = [];\n      for (; (c < t || h.length + l.activeCount + l.pendingCount < e) && !((T = this.bench.signal) != null && T.aborted); )\n        r ? u.push(l(a)) : await a();\n      u.length && await Promise.all(u);\n    } catch (u) {\n      return { error: u };\n    }\n    if (this.opts.afterAll != null)\n      try {\n        await this.opts.afterAll.call(this);\n      } catch (u) {\n        return { error: u };\n      }\n    return { samples: h };\n  }\n  /**\n   * run the current task and write the results in `Task.result` object\n   */\n  async run() {\n    var r, i;\n    if ((r = this.result) != null && r.error)\n      return this;\n    this.dispatchEvent(o(\"start\", this)), await this.bench.setup(this, \"run\");\n    let { samples: t, error: e } = await this.loop(this.bench.time, this.bench.iterations);\n    if (this.bench.teardown(this, \"run\"), t) {\n      let c = t.reduce((L, A) => L + A, 0);\n      this.runs = t.length, t.sort((L, A) => L - A);\n      let h = c / this.runs, p = 1e3 / h, a = t.length, l = a - 1, T = t[0], u = t[l], v = c / t.length || 0, P = S(t, v), R = Math.sqrt(P), I = R / Math.sqrt(a), _ = N[String(Math.round(l) || 1)] || N.infinity, K = I * _, j = K / v * 100, H = t[Math.ceil(a * 0.75) - 1], V = t[Math.ceil(a * 0.99) - 1], Q = t[Math.ceil(a * 0.995) - 1], Y = t[Math.ceil(a * 0.999) - 1];\n      if ((i = this.bench.signal) != null && i.aborted)\n        return this;\n      this.setResult({\n        totalTime: c,\n        min: T,\n        max: u,\n        hz: p,\n        period: h,\n        samples: t,\n        mean: v,\n        variance: P,\n        sd: R,\n        sem: I,\n        df: l,\n        critical: _,\n        moe: K,\n        rme: j,\n        p75: H,\n        p99: V,\n        p995: Q,\n        p999: Y\n      });\n    }\n    if (e) {\n      if (this.setResult({ error: e }), this.bench.throws)\n        throw e;\n      this.dispatchEvent(o(\"error\", this)), this.bench.dispatchEvent(o(\"error\", this));\n    }\n    return this.dispatchEvent(o(\"cycle\", this)), this.bench.dispatchEvent(o(\"cycle\", this)), this.dispatchEvent(o(\"complete\", this)), this;\n  }\n  /**\n   * warmup the current task\n   */\n  async warmup() {\n    var e;\n    if ((e = this.result) != null && e.error)\n      return;\n    this.dispatchEvent(o(\"warmup\", this)), await this.bench.setup(this, \"warmup\");\n    let { error: t } = await this.loop(this.bench.warmupTime, this.bench.warmupIterations);\n    if (this.bench.teardown(this, \"warmup\"), t && (this.setResult({ error: t }), this.bench.throws))\n      throw t;\n  }\n  addEventListener(t, e, r) {\n    super.addEventListener(t, e, r);\n  }\n  removeEventListener(t, e, r) {\n    super.removeEventListener(t, e, r);\n  }\n  /**\n   * change the result object values\n   */\n  setResult(t) {\n    this.result = { ...this.result, ...t }, Object.freeze(this.result);\n  }\n  /**\n   * reset the task to make the `Task.runs` a zero-value and remove the `Task.result`\n   * object\n   */\n  reset() {\n    this.dispatchEvent(o(\"reset\", this)), this.runs = 0, this.result = void 0;\n  }\n};\n\n// src/bench.ts\nvar x = class extends EventTarget {\n  constructor(t = {}) {\n    var e, r, i, c, h, p, a, l;\n    super();\n    /*\n     * @private the task map\n     */\n    this._tasks = /* @__PURE__ */ new Map();\n    this._todos = /* @__PURE__ */ new Map();\n    /**\n    * Executes tasks concurrently based on the specified concurrency mode.\n    *\n    * - When `mode` is set to `null` (default), concurrency is disabled.\n    * - When `mode` is set to 'task', each task's iterations (calls of a task function) run concurrently.\n    * - When `mode` is set to 'bench', different tasks within the bench run concurrently.\n    */\n    this.concurrency = null;\n    /**\n     * The maximum number of concurrent tasks to run. Defaults to Infinity.\n     */\n    this.threshold = 1 / 0;\n    this.warmupTime = 100;\n    this.warmupIterations = 5;\n    this.time = 500;\n    this.iterations = 10;\n    this.now = B;\n    this.now = (e = t.now) != null ? e : this.now, this.warmupTime = (r = t.warmupTime) != null ? r : this.warmupTime, this.warmupIterations = (i = t.warmupIterations) != null ? i : this.warmupIterations, this.time = (c = t.time) != null ? c : this.time, this.iterations = (h = t.iterations) != null ? h : this.iterations, this.signal = t.signal, this.throws = (p = t.throws) != null ? p : !1, this.setup = (a = t.setup) != null ? a : () => {\n    }, this.teardown = (l = t.teardown) != null ? l : () => {\n    }, this.signal && this.signal.addEventListener(\n      \"abort\",\n      () => {\n        this.dispatchEvent(o(\"abort\"));\n      },\n      { once: !0 }\n    );\n  }\n  runTask(t) {\n    var e;\n    return (e = this.signal) != null && e.aborted ? t : t.run();\n  }\n  /**\n   * run the added tasks that were registered using the\n   * {@link add} method.\n   * Note: This method does not do any warmup. Call {@link warmup} for that.\n   */\n  async run() {\n    if (this.concurrency === \"bench\")\n      return this.runConcurrently(this.threshold, this.concurrency);\n    this.dispatchEvent(o(\"start\"));\n    let t = [];\n    for (let e of [...this._tasks.values()])\n      t.push(await this.runTask(e));\n    return this.dispatchEvent(o(\"complete\")), t;\n  }\n  /**\n   * See Bench.{@link concurrency}\n   */\n  async runConcurrently(t = 1 / 0, e = \"bench\") {\n    if (this.threshold = t, this.concurrency = e, e === \"task\")\n      return this.run();\n    this.dispatchEvent(o(\"start\"));\n    let r = y(t), i = [];\n    for (let h of [...this._tasks.values()])\n      i.push(r(() => this.runTask(h)));\n    let c = await Promise.all(i);\n    return this.dispatchEvent(o(\"complete\")), c;\n  }\n  /**\n   * warmup the benchmark tasks.\n   * This is not run by default by the {@link run} method.\n   */\n  async warmup() {\n    if (this.concurrency === \"bench\") {\n      await this.warmupConcurrently(this.threshold, this.concurrency);\n      return;\n    }\n    this.dispatchEvent(o(\"warmup\"));\n    for (let [, t] of this._tasks)\n      await t.warmup();\n  }\n  /**\n   * warmup the benchmark tasks concurrently.\n   * This is not run by default by the {@link runConcurrently} method.\n   */\n  async warmupConcurrently(t = 1 / 0, e = \"bench\") {\n    if (this.threshold = t, this.concurrency = e, e === \"task\") {\n      await this.warmup();\n      return;\n    }\n    this.dispatchEvent(o(\"warmup\"));\n    let r = y(t), i = [];\n    for (let [, c] of this._tasks)\n      i.push(r(() => c.warmup()));\n    await Promise.all(i);\n  }\n  /**\n   * reset each task and remove its result\n   */\n  reset() {\n    this.dispatchEvent(o(\"reset\")), this._tasks.forEach((t) => {\n      t.reset();\n    });\n  }\n  /**\n   * add a benchmark task to the task map\n   */\n  add(t, e, r = {}) {\n    let i = new b(this, t, e, r);\n    return this._tasks.set(t, i), this.dispatchEvent(o(\"add\", i)), this;\n  }\n  /**\n   * add a benchmark todo to the todo map\n   */\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  todo(t, e = () => {\n  }, r = {}) {\n    let i = new b(this, t, e, r);\n    return this._todos.set(t, i), this.dispatchEvent(o(\"todo\", i)), this;\n  }\n  /**\n   * remove a benchmark task from the task map\n   */\n  remove(t) {\n    let e = this.getTask(t);\n    return e && (this.dispatchEvent(o(\"remove\", e)), this._tasks.delete(t)), this;\n  }\n  addEventListener(t, e, r) {\n    super.addEventListener(t, e, r);\n  }\n  removeEventListener(t, e, r) {\n    super.removeEventListener(t, e, r);\n  }\n  /**\n   * table of the tasks results\n   */\n  table(t) {\n    return this.tasks.map((e) => {\n      if (e.result) {\n        if (e.result.error)\n          throw e.result.error;\n        return (t == null ? void 0 : t(e)) || {\n          \"Task Name\": e.name,\n          \"ops/sec\": e.result.error ? \"NaN\" : parseInt(e.result.hz.toString(), 10).toLocaleString(),\n          \"Average Time (ns)\": e.result.error ? \"NaN\" : e.result.mean * 1e3 * 1e3,\n          Margin: e.result.error ? \"NaN\" : `\\xB1${e.result.rme.toFixed(2)}%`,\n          Samples: e.result.error ? \"NaN\" : e.result.samples.length\n        };\n      }\n      return null;\n    });\n  }\n  /**\n   * (getter) tasks results as an array\n   */\n  get results() {\n    return [...this._tasks.values()].map((t) => t.result);\n  }\n  /**\n   * (getter) tasks as an array\n   */\n  get tasks() {\n    return [...this._tasks.values()];\n  }\n  get todos() {\n    return [...this._todos.values()];\n  }\n  /**\n   * get a task based on the task name\n   */\n  getTask(t) {\n    return this._tasks.get(t);\n  }\n};\nexport {\n  x as Bench,\n  b as Task,\n  U as hrtimeNow,\n  B as now\n};\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/bundle/dist/node_modules/.pnpm/tinyrainbow@3.1.0/node_modules/tinyrainbow/dist/index.js

@@ -0,0 +1,86 @@
+//#region ../../node_modules/.pnpm/tinyrainbow@3.1.0/node_modules/tinyrainbow/dist/index.js
+var b = {
+	reset: [0, 0],
+	bold: [
+		1,
+		22,
+		"\x1B[22m\x1B[1m"
+	],
+	dim: [
+		2,
+		22,
+		"\x1B[22m\x1B[2m"
+	],
+	italic: [3, 23],
+	underline: [4, 24],
+	inverse: [7, 27],
+	hidden: [8, 28],
+	strikethrough: [9, 29],
+	black: [30, 39],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	white: [37, 39],
+	gray: [90, 39],
+	bgBlack: [40, 49],
+	bgRed: [41, 49],
+	bgGreen: [42, 49],
+	bgYellow: [43, 49],
+	bgBlue: [44, 49],
+	bgMagenta: [45, 49],
+	bgCyan: [46, 49],
+	bgWhite: [47, 49],
+	blackBright: [90, 39],
+	redBright: [91, 39],
+	greenBright: [92, 39],
+	yellowBright: [93, 39],
+	blueBright: [94, 39],
+	magentaBright: [95, 39],
+	cyanBright: [96, 39],
+	whiteBright: [97, 39],
+	bgBlackBright: [100, 49],
+	bgRedBright: [101, 49],
+	bgGreenBright: [102, 49],
+	bgYellowBright: [103, 49],
+	bgBlueBright: [104, 49],
+	bgMagentaBright: [105, 49],
+	bgCyanBright: [106, 49],
+	bgWhiteBright: [107, 49]
+};
+function i(e) {
+	return String(e);
+}
+i.open = "";
+i.close = "";
+function B() {
+	let e = typeof process != "undefined" ? process : void 0, r = (e == null ? void 0 : e.env) || {}, a = r.FORCE_TTY !== "false", l = (e == null ? void 0 : e.argv) || [];
+	return !("NO_COLOR" in r || l.includes("--no-color")) && ("FORCE_COLOR" in r || l.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && r.TERM !== "dumb" || "CI" in r) || typeof window != "undefined" && !!window.chrome;
+}
+function C({ force: e } = {}) {
+	let r = e || B(), a = (t, o, u, n) => {
+		let g = "", s = 0;
+		do
+			g += t.substring(s, n) + u, s = n + o.length, n = t.indexOf(o, s);
+		while (~n);
+		return g + t.substring(s);
+	}, l = (t, o, u = t) => {
+		let n = (g) => {
+			let s = String(g), h = s.indexOf(o, t.length);
+			return ~h ? t + a(s, o, u, h) + o : t + s + o;
+		};
+		return n.open = t, n.close = o, n;
+	}, c = { isColorSupported: r }, f = (t) => `\x1B[${t}m`;
+	for (let t in b) {
+		let o = b[t];
+		c[t] = r ? l(f(o[0]), f(o[1]), o[2]) : i;
+	}
+	return c;
+}
+var y = C();
+//#endregion
+export { y };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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