env-runner 0.1.15 → 0.2.0

package/README.md

@@ -41,6 +41,8 @@ npx env-runner app.ts
 | `--host <host>`   | Host to bind to                                                                                   | `localhost`    |
 | `-w, --watch`     | Watch entry file for changes and auto-reload                                                      |                |
 
+`--runner miniflare` needs `miniflare` installed in your project — the runner imports it optionally when no module is passed.
+
 ### Server (`EnvServer`)
 
 High-level API that combines runner loading, file watching, and auto-reload:
@@ -54,6 +56,8 @@ const envServer = new EnvServer({
   entry: "./app.ts",
   watch: true,
   watchPaths: ["./src"],
+  // Runner-specific constructor options, e.g. `{ miniflare }` for `runner: "miniflare"`
+  runnerOptions: {},
 });
 
 envServer.onReady((_runner, address) => {
@@ -73,9 +77,36 @@ await envServer.reload();
 // Use with any HTTP server
 const server = serve({
   fetch: (request) => envServer.fetch(request),
+  // Proxy WebSocket upgrades to the worker (see "WebSocket proxying" below)
+  plugins: [await envServer.wsSrvxPlugin()],
+});
+```
+
+#### WebSocket proxying
+
+To proxy WebSocket upgrades to the worker, attach the plugin returned by
+`wsSrvxPlugin()` (available on both `RunnerManager` and `EnvServer`) to your
+[srvx](https://srvx.h3.dev) server:
+
+```ts
+const server = serve({
+  fetch: (request) => envServer.fetch(request),
+  plugins: [await envServer.wsSrvxPlugin()],
 });
 ```
 
+The plugin picks the proxy strategy by **host** runtime:
+
+- **Node** — proxies the raw upgrade socket to the worker (transparent
+  passthrough; subprotocol/extension negotiation stays end-to-end).
+- **Bun/Deno** — those runtimes serve natively and expose no Node upgrade
+  socket, so the client WebSocket is terminated with [crossws](https://crossws.h3.dev)
+  and bridged to the worker over a standard `WebSocket` client.
+
+It reads the active runner lazily, so it keeps working across hot-reloads, and
+waits for the worker to become ready before proxying. Your entry module should
+expose WebSocket hooks via the `websocket` field (see [Workers](#workers)).
+
 ### Manager (`RunnerManager`)
 
 Proxy manager for hot-reload with message queueing and listener forwarding:
@@ -130,6 +161,29 @@ import { VercelEnvRunner } from "env-runner/runners/vercel";
 import { NetlifyEnvRunner } from "env-runner/runners/netlify";
 ```
 
+#### Runtime dependencies
+
+`env-runner` declares **no peer dependencies**. Runners that build on external packages take them as explicit options instead, and every such option accepts the **same three shapes**:
+
+| Value                                                                       | Meaning                                                                                                     |
+| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| the imported module (`import * as miniflare from "miniflare"`)              | the version you installed is the version that runs                                                          |
+| a specifier — `"miniflare"`, `import.meta.resolve("miniflare")`, or a `URL` | resolved from the current working directory, so bare specifiers hit your `node_modules`, not `env-runner`'s |
+| `false`                                                                     | opt out of the package entirely                                                                             |
+
+Omitting the option falls back to an optional dynamic import of the package; only then does the runner error (`miniflare`) or degrade (minimal wrangler reader, Netlify shim, queue no-op).
+
+| Runner      | Package            | Option                                   | Without it                            |
+| ----------- | ------------------ | ---------------------------------------- | ------------------------------------- |
+| `miniflare` | `miniflare`        | `miniflare`                              | throws — the runner cannot run        |
+| `miniflare` | `wrangler`         | `wranglerModule`                         | built-in minimal JSON reader          |
+| `vercel`    | `@vercel/queue`    | `sdk` (on `registerVercelQueueConsumer`) | warn-once no-op                       |
+| `netlify`   | `@netlify/runtime` | `netlifyRuntime`                         | lightweight `globalThis.Netlify` shim |
+
+`netlifyRuntime` is the one exception to the table above: the runtime has to start **inside** the worker thread, where a live module instance cannot be handed over, so it accepts a specifier (or `false`) only.
+
+The shared resolver is exported as `resolveRuntimeDep()` (type `RuntimeDep<T>`) if you build runners of your own.
+
 All runners implement the [`EnvRunner`](./src/types.ts) interface:
 
 ```ts
@@ -147,7 +201,8 @@ await using runner = new NodeProcessEnvRunner({
 // Relative URLs are resolved against a placeholder origin
 const response = await runner.fetch("/api");
 
-// Proxy WebSocket upgrades
+// Proxy a raw WebSocket upgrade to the worker (Node host only — low-level;
+// prefer `manager.wsSrvxPlugin()` for cross-runtime proxying)
 runner.upgrade?.({ node: { req, socket, head } });
 
 // Wait for runner to be ready
@@ -287,16 +342,20 @@ On `MiniflareEnvRunner` there is no in-worker registration: the runner's module
 
 #### Miniflare Runner
 
-Run your app in the Cloudflare Workers runtime using [miniflare](https://github.com/cloudflare/workers-sdk/tree/main/packages/miniflare):
+Run your app in the Cloudflare Workers runtime using [miniflare](https://github.com/cloudflare/workers-sdk/tree/main/packages/miniflare).
+
+`env-runner` declares no peer dependencies — install `miniflare` yourself and pass it to the runner (see [Runtime dependencies](#runtime-dependencies)):
 
 ```bash
 npm install miniflare
 ```
 
 ```ts
+import * as miniflare from "miniflare";
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
 
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   miniflareOptions: {
@@ -308,7 +367,7 @@ await using runner = new MiniflareEnvRunner({
 const response = await runner.fetch("http://localhost/api");
 ```
 
-The `miniflareOptions` object is passed directly to the [Miniflare constructor](https://developers.cloudflare.com/workers/testing/miniflare/) — you can configure bindings, KV, D1, Durable Objects, and any other Miniflare option.
+Passing `miniflare` explicitly is preferred — the version you install is then the version that runs. A specifier works too (`miniflare: "miniflare"`). If you omit it, the runner imports `miniflare` itself and only fails (with an actionable error) when the package isn't installed either. The `miniflareOptions` object is passed directly to the [Miniflare constructor](https://developers.cloudflare.com/workers/testing/miniflare/) — you can configure bindings, KV, D1, Durable Objects, and any other Miniflare option.
 
 When you don't set a `compatibilityDate` (via `miniflareOptions` or a wrangler config), it defaults to the date supported by the installed `workerd` binary rather than today's date — the binary always lags the calendar slightly, and pinning a future date makes `workerd` refuse to start.
 
@@ -320,6 +379,7 @@ Set the `wrangler` option to load a Cloudflare [Wrangler config](https://develop
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
 
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   wrangler: true, // auto-discover wrangler.{json,jsonc,toml} next to the entry, then cwd
@@ -334,6 +394,7 @@ You can also pass an **inline** config object (raw `wrangler.json` shape) instea
 
 ```ts
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   wrangler: {
@@ -347,7 +408,22 @@ await using runner = new MiniflareEnvRunner({
 
 When an inline config is passed, a `wrangler.{json,jsonc,toml}` file is still auto-discovered (next to the entry, then cwd) and loaded, and the inline config is **merged on top of it** — inline values win per key, binding records (e.g. `vars`) merge, and `compatibilityFlags` are unioned. This lets you keep a committed `wrangler` file and override a few fields programmatically.
 
-When the [`wrangler`](https://www.npmjs.com/package/wrangler) package is installed (an optional peer dependency), it is used for full fidelity — TOML, `env` inheritance, `.dev.vars`, and every binding type. When `wrangler` is **not** installed, a built-in minimal reader handles plain JSON files and inline objects (common fields only) and logs a one-time warning; JSONC and TOML files are skipped with a warning (they need `wrangler` to parse). Values you pass in `miniflareOptions` always take precedence over config-derived ones — binding records (e.g. `bindings`) merge per key, and `compatibilityFlags` are merged.
+Pass the [`wrangler`](https://www.npmjs.com/package/wrangler) package as `wranglerModule` — the imported module or a specifier — for full fidelity: TOML, `env` inheritance, `.dev.vars`, and every binding type.
+
+```ts
+import * as miniflare from "miniflare";
+import * as wrangler from "wrangler";
+
+await using runner = new MiniflareEnvRunner({
+  miniflare,
+  wranglerModule: wrangler,
+  name: "my-worker",
+  data: { entry: "./worker.ts" },
+  wrangler: true,
+});
+```
+
+Without `wranglerModule`, `wrangler` is imported optionally; if that fails too, a built-in minimal reader handles plain JSON files and inline objects (common fields only) and JSONC/TOML files are skipped with a warning (they need `wrangler` to parse). Pass `wranglerModule: false` to always use the minimal reader. Values you pass in `miniflareOptions` always take precedence over config-derived ones — binding records (e.g. `bindings`) merge per key, and `compatibilityFlags` are merged.
 
 #### Module Transform Pipeline
 
@@ -357,6 +433,7 @@ Pass a `transformRequest` callback to route module resolution through Vite's (or
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
 
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   // Route module resolution through Vite's transform pipeline
@@ -396,6 +473,7 @@ To explicitly declare exports or override auto-detection:
 
 ```ts
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   // Explicit exports (merged with auto-detected ones)
@@ -425,6 +503,7 @@ By default, `close()` disposes the Miniflare instance. With `persistent: true`,
 
 ```ts
 const runner1 = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   persistent: true,
@@ -435,6 +514,7 @@ const runner1 = new MiniflareEnvRunner({
 await runner1.close();
 
 const runner2 = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   persistent: true,
@@ -456,6 +536,25 @@ await using runner = new VercelEnvRunner({
 });
 ```
 
+#### Vercel Queues (local delivery)
+
+Framework integrations running inside the vercel runner can bind a topic to a handler for local delivery. Pass [`@vercel/queue`](https://www.npmjs.com/package/@vercel/queue) as `sdk` — the imported module or a specifier (omit it and the SDK is imported optionally; if it isn't installed, registration warns once and becomes a no-op so dev startup is never blocked):
+
+```ts
+import * as sdk from "@vercel/queue";
+import { registerVercelQueueConsumer } from "env-runner/runners/vercel/queue-dev";
+
+const unregister = await registerVercelQueueConsumer({
+  sdk,
+  topic: "orders",
+  handler: (message, metadata) => dispatch(message, metadata),
+  consumerGroup: "my-framework", // re-registering the same group replaces the handler (HMR-safe)
+  retryAfterSeconds: 5, // or `retry: (error, metadata) => ({ acknowledge: true })`
+});
+```
+
+One `QueueClient` is constructed per SDK instance and shared across registrations.
+
 #### Netlify Runner
 
 Simulates a Netlify deployment environment with automatic header injection (`x-nf-client-connection-ip`, `x-nf-account-id`, `x-nf-site-id`, `x-nf-deploy-id`, `x-nf-deploy-context`, `x-nf-geo`, `x-nf-request-id`, forwarding headers) and `globalThis.Netlify` setup:
@@ -469,6 +568,18 @@ await using runner = new NetlifyEnvRunner({
 });
 ```
 
+For the full compute runtime — `globalThis.Netlify` with context plus `globalThis.caches` — install [`@netlify/runtime`](https://www.npmjs.com/package/@netlify/runtime) and point the runner at it with `netlifyRuntime`:
+
+```ts
+await using runner = new NetlifyEnvRunner({
+  name: "my-app",
+  netlifyRuntime: import.meta.resolve("@netlify/runtime"),
+  data: { entry: "./app.ts" },
+});
+```
+
+The runtime has to start inside the worker thread, so this is the one runtime-dependency option that takes a module _specifier_ rather than an imported instance — a live module cannot cross that boundary. A bare specifier (`"@netlify/runtime"`) is resolved from the current working directory. If it cannot be imported, the runner warns and falls back to the shim, and `netlifyRuntime: false` forces the shim outright.
+
 ### Vite Environment API
 
 env-runner provides helpers for integrating with Vite's [Environment API](https://vite.dev/guide/api-environment-runtimes.html):
@@ -508,6 +619,7 @@ import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
 import { createViteHotChannel } from "env-runner/vite";
 
 const runner = new MiniflareEnvRunner({
+  miniflare,
   name: "worker",
   data: { entry: "./src/worker.ts" },
   transformRequest: (id) => devEnvironment.transformRequest(id),

package/dist/_chunks/common-base-runner.d.mts

@@ -50,6 +50,7 @@ declare abstract class BaseEnvRunner implements EnvRunner, AsyncDisposable {
     data?: EnvRunnerData;
   });
   get ready(): boolean;
+  get address(): WorkerAddress | undefined;
   fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
   upgrade(context: {
     node: {

package/dist/_chunks/common-base-runner.mjs

@@ -23,13 +23,20 @@ var BaseEnvRunner = class {
 	get ready() {
 		return Boolean(!this.closed && this._address && this._hasRuntime());
 	}
+	get address() {
+		return this._address;
+	}
 	async fetch(input, init) {
 		for (let i = 0; i < 5 && !this._address && !this.closed; i++) await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
 		if (!this._address) return new Response(`${this._runtimeType()} env runner is unavailable`, { status: 503 });
 		return proxyFetch(this._address, this._resolveFetchInput(input), init);
 	}
 	async upgrade(context) {
-		if (!this.ready || !this._address) return;
+		if (!this.ready) await this.waitForReady().catch(() => {});
+		if (!this.ready || !this._address) {
+			context.node.socket.destroy();
+			return;
+		}
 		try {
 			await proxyUpgrade(this._address, context.node.req, context.node.socket, context.node.head);
 		} catch {}
@@ -40,7 +47,7 @@ var BaseEnvRunner = class {
 	offMessage(listener) {
 		this._messageListeners.delete(listener);
 	}
-	waitForReady(timeout = 5e3) {
+	waitForReady(timeout = 15e3) {
 		if (this.ready) return Promise.resolve();
 		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Runner closed before becoming ready"));
 		return new Promise((resolve, reject) => {

package/dist/_chunks/common-runtime-deps.d.mts

@@ -0,0 +1,51 @@
+/**
+ * A runtime dependency the application owns, not `env-runner`.
+ *
+ * Every runner option that names an external package accepts the same three
+ * shapes, so the choice is about ergonomics rather than per-runner API:
+ *
+ * - the **imported module** (`import * as miniflare from "miniflare"`) — the
+ *   version installed by the app is the version that runs
+ * - a **module specifier** (`"miniflare"`, `import.meta.resolve("miniflare")`,
+ *   or a `URL`) — resolved from {@link ResolveRuntimeDepOptions.from} (cwd by
+ *   default), so a bare specifier resolves against the app rather than against
+ *   `env-runner`'s own `node_modules`
+ * - `false` — opt out of the package entirely
+ *
+ * Omitting the option falls back to an optional `import()` of the package.
+ */
+type RuntimeDep<T> = T | string | URL | false;
+interface ResolveRuntimeDepOptions<T> {
+  /** Package name, used for the fallback import and in messages. */
+  name: string;
+  /** Constructor/function option name, used in messages. */
+  option: string;
+  /** Value as passed by the caller. */
+  value?: RuntimeDep<T>;
+  /**
+   * Named export the resolved module must expose. A module that lacks it is
+   * treated as the wrong package (throws for an explicit value).
+   */
+  expect?: string;
+  /** Directory bare specifiers resolve from. @default process.cwd() */
+  from?: string;
+  /**
+   * Throw when the package cannot be resolved at all. Otherwise an
+   * unavailable optional package resolves to `undefined` and the caller
+   * degrades (minimal reader, shim, no-op).
+   */
+  required?: boolean;
+  /** Extra sentence appended to the "not installed" error when `required`. */
+  hint?: string;
+}
+/**
+ * Resolve a {@link RuntimeDep} to an imported module.
+ *
+ * Resolution order: `false` → `undefined`; an imported module → validated and
+ * returned as-is; a specifier → imported (errors propagate, since an explicit
+ * specifier that cannot load is a mistake worth surfacing); omitted → optional
+ * `import(name)`, which yields `undefined` when the package isn't installed
+ * unless {@link ResolveRuntimeDepOptions.required} is set.
+ */
+declare function resolveRuntimeDep<T>(opts: ResolveRuntimeDepOptions<T>): Promise<T | undefined>;
+export { RuntimeDep, resolveRuntimeDep };

package/dist/_chunks/common-runtime-deps.mjs

@@ -0,0 +1,46 @@
+import { pathToFileURL } from "node:url";
+import { resolveModulePath } from "exsolve";
+function isSpecifier(value) {
+	return typeof value === "string" || value instanceof URL;
+}
+function resolveSpecifier(value, from = process.cwd()) {
+	if (value instanceof URL) return value.href;
+	if (value.includes("://")) return value;
+	const resolved = resolveModulePath(value, {
+		from: from.endsWith("/") ? from : from + "/",
+		try: true
+	});
+	return resolved ? pathToFileURL(resolved).href : value;
+}
+async function resolveRuntimeDep(opts) {
+	const { name, option, value, expect, from, required, hint } = opts;
+	if (value === false) return;
+	if (value !== void 0) {
+		if (!isSpecifier(value)) return validate(value, expect, name, option);
+		const raw = typeof value === "string" ? value : value.href;
+		let mod;
+		try {
+			mod = await import(resolveSpecifier(value, from));
+		} catch (error) {
+			throw new TypeError(`[env-runner] failed to import \`${name}\` from the \`${option}\` specifier "${raw}".`, { cause: error });
+		}
+		return validate(mod, expect, name, option);
+	}
+	try {
+		return validate(await import(resolveSpecifier(name, from)), expect, name, option);
+	} catch (error) {
+		if (required) throw new TypeError(`[env-runner] the \`${name}\` package is required: install it, or pass it as the \`${option}\` option (the imported module or a specifier).` + (hint ? ` ${hint}` : ""), { cause: error });
+		return;
+	}
+}
+function validate(mod, expect, name, option) {
+	if (expect && typeof mod?.[expect] !== "function") throw new TypeError(`[env-runner] the \`${option}\` option does not export \`${expect}\` — pass the imported \`${name}\` package or a specifier for it.`);
+	return mod;
+}
+function resolveRuntimeDepSpecifier(value, option, from) {
+	if (value === false) return false;
+	if (value === void 0) return;
+	if (!isSpecifier(value)) throw new TypeError(`[env-runner] the \`${option}\` option must be a module specifier (string or URL): the package is imported inside the worker, so an imported module cannot be passed. Use \`import.meta.resolve()\`.`);
+	return resolveSpecifier(value, from);
+}
+export { resolveRuntimeDep, resolveRuntimeDepSpecifier };

package/dist/_chunks/libs/es-module-lexer.mjs

@@ -2,82 +2,82 @@
 	return A[A.Static = 1] = "Static", A[A.Dynamic = 2] = "Dynamic", A[A.ImportMeta = 3] = "ImportMeta", A[A.StaticSourcePhase = 4] = "StaticSourcePhase", A[A.DynamicSourcePhase = 5] = "DynamicSourcePhase", A[A.StaticDeferPhase = 6] = "StaticDeferPhase", A[A.DynamicDeferPhase = 7] = "DynamicDeferPhase", A;
 })({});
 const A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
-function parse(E, g = "@") {
-	if (!C) return init.then(() => parse(E));
-	const I = E.length + 1, D = (C.__heap_base.value || C.__heap_base) + 4 * I - C.memory.buffer.byteLength;
-	D > 0 && C.memory.grow(Math.ceil(D / 65536));
-	const w = C.sa(I - 1);
-	if ((A ? B : Q)(E, new Uint16Array(C.memory.buffer, w, I)), !C.parse()) throw Object.assign(/* @__PURE__ */ new Error(`Parse error ${g}:${E.slice(0, C.e()).split("\n").length}:${C.e() - E.lastIndexOf("\n", C.e() - 1)}`), { idx: C.e() });
-	const i = [], G = [];
-	for (; C.ri();) {
-		const A = C.is(), Q = C.ie(), B = C.it(), g = C.ai(), I = C.id(), D = C.ss(), w = C.se();
+function parse(C, g = "@") {
+	if (!E) return init.then(() => parse(C, g));
+	const I = C.length + 1, w = (E.__heap_base.value || E.__heap_base) + 4 * I - E.memory.buffer.byteLength;
+	w > 0 && E.memory.grow(Math.ceil(w / 65536));
+	const D = E.sa(I - 1);
+	if ("undefined" != typeof Buffer ? Buffer.from(E.memory.buffer, D, 2 * (I - 1)).write(C, "utf16le") : (A ? Q : B)(C, new Uint16Array(E.memory.buffer, D, I)), !E.parse()) throw Object.assign(/* @__PURE__ */ new Error(`Parse error ${g}:${C.slice(0, E.e()).split("\n").length}:${E.e() - C.lastIndexOf("\n", E.e() - 1)}`), { idx: E.e() });
+	const o = [], G = [];
+	for (; E.ri();) {
+		const A = E.is(), B = E.ie(), Q = E.it(), g = E.ai(), I = E.id(), w = E.ss(), D = E.se();
 		let G;
-		C.ip() && (G = o(E.slice(-1 === I ? A - 1 : A, -1 === I ? Q + 1 : Q)));
-		const R = [];
-		for (C.rsa(); C.ra();) {
-			const A = C.aks(), Q = C.ake(), B = C.avs(), g = C.ave();
-			R.push([s(E.slice(A, Q)), s(E.slice(B, g))]);
+		E.ip() && (G = i(C.slice(-1 === I ? A - 1 : A, -1 === I ? B + 1 : B)));
+		let J = null;
+		for (J = [], E.rsa(); E.ra();) {
+			const A = E.aks(), B = E.ake(), Q = E.avs(), g = E.ave();
+			J.push([s(C.slice(A, B)), s(C.slice(Q, g))]);
 		}
-		i.push({
+		0 === J.length && (J = null), o.push({
 			n: G,
-			t: B,
+			t: Q,
 			s: A,
-			e: Q,
-			ss: D,
-			se: w,
+			e: B,
+			ss: w,
+			se: D,
 			d: I,
 			a: g,
-			at: R.length > 0 ? R : null
+			at: J
 		});
 	}
-	for (; C.re();) {
-		const A = C.es(), Q = C.ee(), B = C.els(), g = C.ele(), I = C.ess(), D = s(E.slice(A, Q)), w = B < 0 ? void 0 : s(E.slice(B, g));
+	for (; E.re();) {
+		const A = E.es(), B = E.ee(), Q = E.els(), g = E.ele(), I = Q < 0 ? void 0 : s(C.slice(Q, g)), w = s(C.slice(A, B));
 		G.push({
 			s: A,
-			e: Q,
-			ls: B,
+			e: B,
+			ls: Q,
 			le: g,
-			ss: I,
-			n: D,
-			ln: w
+			ss: E.ess(),
+			n: w,
+			ln: I
 		});
 	}
-	function o(A) {
+	function i(A) {
 		try {
 			return (0, eval)(A);
 		} catch (A) {}
 	}
 	function s(A) {
 		if (!A) return A;
-		const Q = A[0];
-		return ("\"" === Q || "'" === Q) && o(A) || A;
+		const B = A[0];
+		return ("\"" === B || "'" === B) && i(A) || A;
 	}
 	return [
-		i,
+		o,
 		G,
-		!!C.f(),
-		!!C.ms()
+		!!E.f(),
+		!!E.ms()
 	];
 }
-function Q(A, Q) {
-	const B = A.length;
-	let C = 0;
-	for (; C < B;) {
-		const B = A.charCodeAt(C);
-		Q[C++] = (255 & B) << 8 | B >>> 8;
+function B(A, B) {
+	const Q = A.length;
+	let E = 0;
+	for (; E < Q;) {
+		const Q = A.charCodeAt(E);
+		B[E++] = (255 & Q) << 8 | Q >>> 8;
 	}
 }
-function B(A, Q) {
-	const B = A.length;
-	let C = 0;
-	for (; C < B;) Q[C] = A.charCodeAt(C++);
+function Q(A, B) {
+	const Q = A.length;
+	let E = 0;
+	for (; E < Q;) B[E] = A.charCodeAt(E++);
 }
-let C;
-const E = () => {
-	return A = "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", "undefined" != typeof Buffer ? Buffer.from(A, "base64") : Uint8Array.from(atob(A), (A) => A.charCodeAt(0));
+let E;
+const C = () => {
+	return A = "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", "undefined" != typeof Buffer ? Buffer.from(A, "base64") : Uint8Array.from(atob(A), (A) => A.charCodeAt(0));
 	var A;
 };
-const init = WebAssembly.compile(E()).then(WebAssembly.instantiate).then(({ exports: A }) => {
-	C = A;
+const init = WebAssembly.compile(C()).then(WebAssembly.instantiate).then(({ exports: A }) => {
+	E = A;
 });
 export { init, parse };