@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/vendor/shared-3g9mwCWP.mjs

@@ -0,0 +1,31 @@
+import "node:module";
+
+//#region \0rolldown/runtime.js
+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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+export { __toESM as n, __commonJSMin as t };

package/dist/vendor/std-env.d.mts

@@ -0,0 +1,88 @@
+//#region ../../node_modules/.pnpm/std-env@3.10.0/node_modules/std-env/dist/index.d.ts
+type EnvObject = Record<string, string | undefined>;
+declare const env: EnvObject;
+declare const nodeENV: string;
+/** Value of process.platform */
+declare const platform: string;
+/** Detect if `CI` environment variable is set or a provider CI detected */
+declare const isCI: boolean;
+/** Detect if stdout.TTY is available */
+declare const hasTTY: boolean;
+/** Detect if global `window` object is available */
+declare const hasWindow: boolean;
+/** Detect if `DEBUG` environment variable is set */
+declare const isDebug: boolean;
+/** Detect if `NODE_ENV` environment variable is `test` */
+declare const isTest: boolean;
+/** Detect if `NODE_ENV` environment variable is `production` */
+declare const isProduction: boolean;
+/** Detect if `NODE_ENV` environment variable is `dev` or `development` */
+declare const isDevelopment: boolean;
+/** Detect if MINIMAL environment variable is set, running in CI or test or TTY is unavailable */
+declare const isMinimal: boolean;
+/** Detect if process.platform is Windows */
+declare const isWindows: boolean;
+/** Detect if process.platform is Linux */
+declare const isLinux: boolean;
+/** Detect if process.platform is macOS (darwin kernel) */
+declare const isMacOS: boolean;
+/** Color Support */
+declare const isColorSupported: boolean;
+/** Node.js versions */
+declare const nodeVersion: string | null;
+declare const nodeMajorVersion: number | null;
+interface Process extends Partial<Omit<typeof globalThis.process, "versions">> {
+  env: EnvObject;
+  versions: Record<string, string>;
+}
+declare const process: Process;
+type ProviderName = "" | "appveyor" | "aws_amplify" | "azure_pipelines" | "azure_static" | "appcircle" | "bamboo" | "bitbucket" | "bitrise" | "buddy" | "buildkite" | "circle" | "cirrus" | "cloudflare_pages" | "cloudflare_workers" | "codebuild" | "codefresh" | "drone" | "drone" | "dsari" | "github_actions" | "gitlab" | "gocd" | "layerci" | "hudson" | "jenkins" | "magnum" | "netlify" | "nevercode" | "render" | "sail" | "semaphore" | "screwdriver" | "shippable" | "solano" | "strider" | "teamcity" | "travis" | "vercel" | "appcenter" | "codesandbox" | "stackblitz" | "stormkit" | "cleavr" | "zeabur" | "codesphere" | "railway" | "deno-deploy" | "firebase_app_hosting";
+type ProviderInfo = {
+  name: ProviderName;
+  ci?: boolean;
+  [meta: string]: any;
+};
+/** Current provider info */
+declare const providerInfo: ProviderInfo;
+declare const provider: ProviderName;
+type RuntimeName = "workerd" | "deno" | "netlify" | "node" | "bun" | "edge-light" | "fastly" | "";
+type RuntimeInfo = {
+  name: RuntimeName;
+};
+/**
+ * Indicates if running in Node.js or a Node.js compatible runtime.
+ *
+ * **Note:** When running code in Bun and Deno with Node.js compatibility mode, `isNode` flag will be also `true`, indicating running in a Node.js compatible runtime.
+ *
+ * Use `runtime === "node"` if you need strict check for Node.js runtime.
+ */
+declare const isNode: boolean;
+/**
+ * Indicates if running in Bun runtime.
+ */
+declare const isBun: boolean;
+/**
+ * Indicates if running in Deno runtime.
+ */
+declare const isDeno: boolean;
+/**
+ * Indicates if running in Fastly runtime.
+ */
+declare const isFastly: boolean;
+/**
+ * Indicates if running in Netlify runtime.
+ */
+declare const isNetlify: boolean;
+/**
+ *
+ * Indicates if running in EdgeLight (Vercel Edge) runtime.
+ */
+declare const isEdgeLight: boolean;
+/**
+ * Indicates if running in Cloudflare Workers runtime.
+ */
+declare const isWorkerd: boolean;
+declare const runtimeInfo: RuntimeInfo | undefined;
+declare const runtime: RuntimeName;
+//#endregion
+export { type EnvObject, type Process, type ProviderInfo, type ProviderName, type RuntimeInfo, type RuntimeName, env, hasTTY, hasWindow, isBun, isCI, isColorSupported, isDebug, isDeno, isDevelopment, isEdgeLight, isFastly, isLinux, isMacOS, isMinimal, isNetlify, isNode, isProduction, isTest, isWindows, isWorkerd, nodeENV, nodeMajorVersion, nodeVersion, platform, process, provider, providerInfo, runtime, runtimeInfo };

package/dist/vendor/std-env.mjs

@@ -0,0 +1,159 @@
+//#region ../../node_modules/.pnpm/std-env@3.10.0/node_modules/std-env/dist/index.mjs
+const r = Object.create(null), i = (e) => globalThis.process?.env || import.meta.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (e ? r : globalThis), o = new Proxy(r, {
+	get(e, s) {
+		return i()[s] ?? r[s];
+	},
+	has(e, s) {
+		const E = i();
+		return s in E || s in r;
+	},
+	set(e, s, E) {
+		const B = i(!0);
+		return B[s] = E, !0;
+	},
+	deleteProperty(e, s) {
+		if (!s) return !1;
+		const E = i(!0);
+		return delete E[s], !0;
+	},
+	ownKeys() {
+		const e = i(!0);
+		return Object.keys(e);
+	}
+}), t = typeof process < "u" && process.env && process.env.NODE_ENV || "", f = [
+	["APPVEYOR"],
+	[
+		"AWS_AMPLIFY",
+		"AWS_APP_ID",
+		{ ci: !0 }
+	],
+	["AZURE_PIPELINES", "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI"],
+	["AZURE_STATIC", "INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN"],
+	["APPCIRCLE", "AC_APPCIRCLE"],
+	["BAMBOO", "bamboo_planKey"],
+	["BITBUCKET", "BITBUCKET_COMMIT"],
+	["BITRISE", "BITRISE_IO"],
+	["BUDDY", "BUDDY_WORKSPACE_ID"],
+	["BUILDKITE"],
+	["CIRCLE", "CIRCLECI"],
+	["CIRRUS", "CIRRUS_CI"],
+	[
+		"CLOUDFLARE_PAGES",
+		"CF_PAGES",
+		{ ci: !0 }
+	],
+	[
+		"CLOUDFLARE_WORKERS",
+		"WORKERS_CI",
+		{ ci: !0 }
+	],
+	["CODEBUILD", "CODEBUILD_BUILD_ARN"],
+	["CODEFRESH", "CF_BUILD_ID"],
+	["DRONE"],
+	["DRONE", "DRONE_BUILD_EVENT"],
+	["DSARI"],
+	["GITHUB_ACTIONS"],
+	["GITLAB", "GITLAB_CI"],
+	["GITLAB", "CI_MERGE_REQUEST_ID"],
+	["GOCD", "GO_PIPELINE_LABEL"],
+	["LAYERCI"],
+	["HUDSON", "HUDSON_URL"],
+	["JENKINS", "JENKINS_URL"],
+	["MAGNUM"],
+	["NETLIFY"],
+	[
+		"NETLIFY",
+		"NETLIFY_LOCAL",
+		{ ci: !1 }
+	],
+	["NEVERCODE"],
+	["RENDER"],
+	["SAIL", "SAILCI"],
+	["SEMAPHORE"],
+	["SCREWDRIVER"],
+	["SHIPPABLE"],
+	["SOLANO", "TDDIUM"],
+	["STRIDER"],
+	["TEAMCITY", "TEAMCITY_VERSION"],
+	["TRAVIS"],
+	["VERCEL", "NOW_BUILDER"],
+	[
+		"VERCEL",
+		"VERCEL",
+		{ ci: !1 }
+	],
+	[
+		"VERCEL",
+		"VERCEL_ENV",
+		{ ci: !1 }
+	],
+	["APPCENTER", "APPCENTER_BUILD_ID"],
+	[
+		"CODESANDBOX",
+		"CODESANDBOX_SSE",
+		{ ci: !1 }
+	],
+	[
+		"CODESANDBOX",
+		"CODESANDBOX_HOST",
+		{ ci: !1 }
+	],
+	["STACKBLITZ"],
+	["STORMKIT"],
+	["CLEAVR"],
+	["ZEABUR"],
+	[
+		"CODESPHERE",
+		"CODESPHERE_APP_ID",
+		{ ci: !0 }
+	],
+	["RAILWAY", "RAILWAY_PROJECT_ID"],
+	["RAILWAY", "RAILWAY_SERVICE_ID"],
+	["DENO-DEPLOY", "DENO_DEPLOYMENT_ID"],
+	[
+		"FIREBASE_APP_HOSTING",
+		"FIREBASE_APP_HOSTING",
+		{ ci: !0 }
+	]
+];
+function b() {
+	if (globalThis.process?.env) for (const e of f) {
+		const s = e[1] || e[0];
+		if (globalThis.process?.env[s]) return {
+			name: e[0].toLowerCase(),
+			...e[2]
+		};
+	}
+	return globalThis.process?.env?.SHELL === "/bin/jsh" && globalThis.process?.versions?.webcontainer ? {
+		name: "stackblitz",
+		ci: !1
+	} : {
+		name: "",
+		ci: !1
+	};
+}
+const l = b(), p = l.name;
+function n(e) {
+	return e ? e !== "false" : !1;
+}
+const I = globalThis.process?.platform || "", T = n(o.CI) || l.ci !== !1, R = n(globalThis.process?.stdout && globalThis.process?.stdout.isTTY), U = typeof window < "u", d = n(o.DEBUG), a = t === "test" || n(o.TEST), g = t === "production", h = t === "dev" || t === "development", v = n(o.MINIMAL) || T || a || !R, A = /^win/i.test(I), M = /^linux/i.test(I), m = /^darwin/i.test(I), Y = !n(o.NO_COLOR) && (n(o.FORCE_COLOR) || (R || A) && o.TERM !== "dumb" || T), C = (globalThis.process?.versions?.node || "").replace(/^v/, "") || null, V = Number(C?.split(".")[0]) || null, W = globalThis.process || Object.create(null), _ = { versions: {} }, y = new Proxy(W, { get(e, s) {
+	if (s === "env") return o;
+	if (s in e) return e[s];
+	if (s in _) return _[s];
+} }), O = globalThis.process?.release?.name === "node", c = !!globalThis.Bun || !!globalThis.process?.versions?.bun, D = !!globalThis.Deno, L = !!globalThis.fastly, S = !!globalThis.Netlify, u = !!globalThis.EdgeRuntime, N = globalThis.navigator?.userAgent === "Cloudflare-Workers", F = [
+	[S, "netlify"],
+	[u, "edge-light"],
+	[N, "workerd"],
+	[L, "fastly"],
+	[D, "deno"],
+	[c, "bun"],
+	[O, "node"]
+];
+function G() {
+	const e = F.find((s) => s[0]);
+	if (e) return { name: e[1] };
+}
+const P = G(), K = P?.name || "";
+
+//#endregion
+export { o as env, R as hasTTY, U as hasWindow, c as isBun, T as isCI, Y as isColorSupported, d as isDebug, D as isDeno, h as isDevelopment, u as isEdgeLight, L as isFastly, M as isLinux, m as isMacOS, v as isMinimal, S as isNetlify, O as isNode, g as isProduction, a as isTest, A as isWindows, N as isWorkerd, t as nodeENV, V as nodeMajorVersion, C as nodeVersion, I as platform, y as process, p as provider, l as providerInfo, K as runtime, P as runtimeInfo };

package/dist/vendor/tinybench.d.mts

@@ -0,0 +1,317 @@
+//#region ../../node_modules/.pnpm/tinybench@2.9.0/node_modules/tinybench/dist/index.d.cts
+/**
+ * A class that represents each benchmark task in Tinybench. It keeps track of the
+ * results, name, Bench instance, the task function and the number times the task
+ * function has been executed.
+ */
+declare class Task extends EventTarget {
+  bench: Bench;
+  /**
+   * task name
+   */
+  name: string;
+  fn: Fn;
+  runs: number;
+  /**
+   * the result object
+   */
+  result?: TaskResult;
+  /**
+   * Task options
+   */
+  opts: FnOptions;
+  constructor(bench: Bench, name: string, fn: Fn, opts?: FnOptions);
+  private loop;
+  /**
+   * run the current task and write the results in `Task.result` object
+   */
+  run(): Promise<this>;
+  /**
+   * warmup the current task
+   */
+  warmup(): Promise<void>;
+  addEventListener<K extends TaskEvents, T = TaskEventsMap[K]>(type: K, listener: T, options?: AddEventListenerOptionsArgument): void;
+  removeEventListener<K extends TaskEvents, T = TaskEventsMap[K]>(type: K, listener: T, options?: RemoveEventListenerOptionsArgument): void;
+  /**
+   * change the result object values
+   */
+  setResult(result: Partial<TaskResult>): void;
+  /**
+   * reset the task to make the `Task.runs` a zero-value and remove the `Task.result`
+   * object
+   */
+  reset(): void;
+}
+/**
+ * the task function
+ */
+type Fn = () => any | Promise<any>;
+interface FnOptions {
+  /**
+   * An optional function that is run before iterations of this task begin
+   */
+  beforeAll?: (this: Task) => void | Promise<void>;
+  /**
+   * An optional function that is run before each iteration of this task
+   */
+  beforeEach?: (this: Task) => void | Promise<void>;
+  /**
+   * An optional function that is run after each iteration of this task
+   */
+  afterEach?: (this: Task) => void | Promise<void>;
+  /**
+   * An optional function that is run after all iterations of this task end
+   */
+  afterAll?: (this: Task) => void | Promise<void>;
+}
+/**
+ * the benchmark task result object
+ */
+type TaskResult = {
+  error?: unknown;
+  /**
+   * The amount of time in milliseconds to run the benchmark task (cycle).
+   */
+  totalTime: number;
+  /**
+   * the minimum value in the samples
+   */
+  min: number;
+  /**
+   * the maximum value in the samples
+   */
+  max: number;
+  /**
+   * the number of operations per second
+   */
+  hz: number;
+  /**
+   * how long each operation takes (ms)
+   */
+  period: number;
+  /**
+   * task samples of each task iteration time (ms)
+   */
+  samples: number[];
+  /**
+   * samples mean/average (estimate of the population mean)
+   */
+  mean: number;
+  /**
+   * samples variance (estimate of the population variance)
+   */
+  variance: number;
+  /**
+   * samples standard deviation (estimate of the population standard deviation)
+   */
+  sd: number;
+  /**
+   * standard error of the mean (a.k.a. the standard deviation of the sampling distribution of the sample mean)
+   */
+  sem: number;
+  /**
+   * degrees of freedom
+   */
+  df: number;
+  /**
+   * critical value of the samples
+   */
+  critical: number;
+  /**
+   * margin of error
+   */
+  moe: number;
+  /**
+   * relative margin of error
+   */
+  rme: number;
+  /**
+   * p75 percentile
+   */
+  p75: number;
+  /**
+   * p99 percentile
+   */
+  p99: number;
+  /**
+   * p995 percentile
+   */
+  p995: number;
+  /**
+   * p999 percentile
+   */
+  p999: number;
+};
+/**
+  * Both the `Task` and `Bench` objects extend the `EventTarget` object,
+  * so you can attach a listeners to different types of events
+  * to each class instance using the universal `addEventListener` and
+ * `removeEventListener`
+ */
+/**
+ * Bench events
+ */
+type BenchEvents = 'abort' | 'complete' | 'error' | 'reset' | 'start' | 'warmup' | 'cycle' | 'add' | 'remove' | 'todo';
+type Hook = (task: Task, mode: 'warmup' | 'run') => void | Promise<void>;
+type NoopEventListener = () => any | Promise<any>;
+type TaskEventListener = (e: Event & {
+  task: Task;
+}) => any | Promise<any>;
+interface BenchEventsMap {
+  abort: NoopEventListener;
+  start: NoopEventListener;
+  complete: NoopEventListener;
+  warmup: NoopEventListener;
+  reset: NoopEventListener;
+  add: TaskEventListener;
+  remove: TaskEventListener;
+  cycle: TaskEventListener;
+  error: TaskEventListener;
+  todo: TaskEventListener;
+}
+/**
+ * task events
+ */
+type TaskEvents = 'abort' | 'complete' | 'error' | 'reset' | 'start' | 'warmup' | 'cycle';
+type TaskEventsMap = {
+  abort: NoopEventListener;
+  start: TaskEventListener;
+  error: TaskEventListener;
+  cycle: TaskEventListener;
+  complete: TaskEventListener;
+  warmup: TaskEventListener;
+  reset: TaskEventListener;
+};
+type Options = {
+  /**
+   * time needed for running a benchmark task (milliseconds) @default 500
+   */
+  time?: number;
+  /**
+   * number of times that a task should run if even the time option is finished @default 10
+   */
+  iterations?: number;
+  /**
+   * function to get the current timestamp in milliseconds
+   */
+  now?: () => number;
+  /**
+   * An AbortSignal for aborting the benchmark
+   */
+  signal?: AbortSignal;
+  /**
+   * Throw if a task fails (events will not work if true)
+   */
+  throws?: boolean;
+  /**
+   * warmup time (milliseconds) @default 100ms
+   */
+  warmupTime?: number;
+  /**
+   * warmup iterations @default 5
+   */
+  warmupIterations?: number;
+  /**
+   * setup function to run before each benchmark task (cycle)
+   */
+  setup?: Hook;
+  /**
+   * teardown function to run after each benchmark task (cycle)
+   */
+  teardown?: Hook;
+};
+type BenchEvent = Event & {
+  task: Task | null;
+};
+type RemoveEventListenerOptionsArgument = Parameters<typeof EventTarget.prototype.removeEventListener>[2];
+type AddEventListenerOptionsArgument = Parameters<typeof EventTarget.prototype.addEventListener>[2];
+/**
+ * The Benchmark instance for keeping track of the benchmark tasks and controlling
+ * them.
+ */
+declare class Bench extends EventTarget {
+  _tasks: Map<string, Task>;
+  _todos: Map<string, Task>;
+  /**
+  * 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.
+  */
+  concurrency: 'task' | 'bench' | null;
+  /**
+   * The maximum number of concurrent tasks to run. Defaults to Infinity.
+   */
+  threshold: number;
+  signal?: AbortSignal;
+  throws: boolean;
+  warmupTime: number;
+  warmupIterations: number;
+  time: number;
+  iterations: number;
+  now: () => number;
+  setup: Hook;
+  teardown: Hook;
+  constructor(options?: Options);
+  private runTask;
+  /**
+   * 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.
+   */
+  run(): Promise<Task[]>;
+  /**
+   * See Bench.{@link concurrency}
+   */
+  runConcurrently(threshold?: number, mode?: NonNullable<Bench['concurrency']>): Promise<Task[]>;
+  /**
+   * warmup the benchmark tasks.
+   * This is not run by default by the {@link run} method.
+   */
+  warmup(): Promise<void>;
+  /**
+   * warmup the benchmark tasks concurrently.
+   * This is not run by default by the {@link runConcurrently} method.
+   */
+  warmupConcurrently(threshold?: number, mode?: NonNullable<Bench['concurrency']>): Promise<void>;
+  /**
+   * reset each task and remove its result
+   */
+  reset(): void;
+  /**
+   * add a benchmark task to the task map
+   */
+  add(name: string, fn: Fn, opts?: FnOptions): this;
+  /**
+   * add a benchmark todo to the todo map
+   */
+  todo(name: string, fn?: Fn, opts?: FnOptions): this;
+  /**
+   * remove a benchmark task from the task map
+   */
+  remove(name: string): this;
+  addEventListener<K extends BenchEvents, T = BenchEventsMap[K]>(type: K, listener: T, options?: AddEventListenerOptionsArgument): void;
+  removeEventListener<K extends BenchEvents, T = BenchEventsMap[K]>(type: K, listener: T, options?: RemoveEventListenerOptionsArgument): void;
+  /**
+   * table of the tasks results
+   */
+  table(convert?: (task: Task) => Record<string, string | number> | undefined): (Record<string, string | number> | null)[];
+  /**
+   * (getter) tasks results as an array
+   */
+  get results(): (TaskResult | undefined)[];
+  /**
+   * (getter) tasks as an array
+   */
+  get tasks(): Task[];
+  get todos(): Task[];
+  /**
+   * get a task based on the task name
+   */
+  getTask(name: string): Task | undefined;
+}
+declare const hrtimeNow: () => number;
+declare const now: () => number;
+//#endregion
+export { Bench, type BenchEvent, type BenchEvents, type Fn, type Hook, type Options, Task, type TaskEvents, type TaskResult, hrtimeNow, now };