@farm.js/islx 0.0.0-stage → 0.0.2

package/dist/_chunks/actions-Eutk6UzT.mjs

@@ -0,0 +1,326 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { walk } from "estree-walker";
+import isReference from "is-reference";
+import MagicString from "magic-string";
+import { analyze } from "periscopic";
+// src/compiler/actions.ts
+/**
+* The server-action compiler: a pure function from a module's source to its source for the
+* server or the browser. Bundler plugins call it; it parses with the parser they pass.
+*
+* - A `"use server"` module: on the server every export registers as an action; in the browser
+*   the module becomes references that call those ids, so its code never reaches a bundle.
+* - An inline `"use server"` function in server code: hoisted to module scope, taking the
+*   variables it read from the component around it as one array. Where it was written, it
+*   becomes a reference that carries those variables, sealed.
+*/
+/** A mistake in the source, with where it is. Bundlers show `loc` with a code frame. */
+var ActionCompileError = class extends Error {
+	loc;
+	id;
+	constructor(message, file, code, offset) {
+		const before = code.slice(0, offset).split("\n");
+		const line = before.length;
+		const column = before.at(-1).length;
+		super(`${message} (${file}:${line}:${column + 1})`);
+		this.name = "ActionCompileError";
+		this.id = file;
+		this.loc = {
+			file,
+			line,
+			column
+		};
+	}
+};
+/**
+* Whether the module's directive prologue (the strings before any other statement, after
+* comments) holds `directive`. A linear scan, for a cheap check before parsing.
+*/
+function hasModuleDirective(code, directive) {
+	let index = 0;
+	while (index < code.length) {
+		const char = code.charCodeAt(index);
+		if (char === 32 || char >= 9 && char <= 13 || char === 65279 || char === 160) index++;
+		else if (code.startsWith("//", index)) {
+			const end = code.indexOf("\n", index);
+			if (end === -1) return false;
+			index = end + 1;
+		} else if (code.startsWith("/*", index)) {
+			const end = code.indexOf("*/", index + 2);
+			if (end === -1) return false;
+			index = end + 2;
+		} else if (char === 34 || char === 39) {
+			const quote = code[index];
+			const end = code.indexOf(quote, index + 1);
+			if (end === -1) return false;
+			const value = code.slice(index + 1, end);
+			index = end + 1;
+			while (index < code.length && /[ \t]/.test(code[index])) index++;
+			if (code[index] === ";") index++;
+			else if (index < code.length && code[index] !== "\n" && code[index] !== "\r") return false;
+			if (value === directive) return true;
+		} else return false;
+	}
+	return false;
+}
+/** The id an action has on both sides: a hash of its module path from the root and its name. */
+function getActionId(root, file, name, salt = "") {
+	const relative = path.relative(root, file.split("?", 1)[0]).split(path.sep).join("/");
+	return createHash("sha256").update(`${salt}${relative}#${name}`).digest("base64url").slice(0, 22);
+}
+function hasDirective(statements, directive) {
+	for (const statement of statements ?? []) {
+		if (statement.type !== "ExpressionStatement") return false;
+		const expression = statement.expression;
+		const value = statement.directive ?? (expression?.type === "Literal" ? expression.value : void 0);
+		if (typeof value !== "string") return false;
+		if (value === directive) return true;
+	}
+	return false;
+}
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+function isInlineAction(node, directive) {
+	return FUNCTION_TYPES.has(node.type) && node.body?.type === "BlockStatement" && hasDirective(node.body.body, directive);
+}
+function actionName(node, parent) {
+	if (node.id?.name) return node.id.name;
+	if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") return parent.id.name;
+	if (parent?.type === "Property" && parent.key?.type === "Identifier") return parent.key.name;
+	if (parent?.type === "JSXExpressionContainer") return null;
+	return null;
+}
+/** Exports of a `"use server"` module, refusing what cannot be an action. */
+function collectExports(program, fail, directive) {
+	const exports = [];
+	const onlyAsync = `A "${directive}" module may export only async functions`;
+	const checkFunction = (node, name) => {
+		if (FUNCTION_TYPES.has(node.type)) {
+			if (!node.async) fail(`${onlyAsync}: make ${name} async`, node);
+			if (node.generator) fail(`${onlyAsync}: ${name} is a generator`, node);
+			return;
+		}
+		if (node.type === "Literal" || node.type === "ObjectExpression" || node.type === "ArrayExpression" || node.type === "TemplateLiteral" || node.type === "ClassExpression") fail(`${onlyAsync}; ${name} is not a function`, node);
+	};
+	for (const node of program.body ?? []) {
+		if (node.type === "ExportAllDeclaration") fail(`"${directive}" modules cannot re-export with \`export *\`: export each action by name`, node);
+		if (node.type === "ExportNamedDeclaration") {
+			if (node.exportKind === "type") continue;
+			if (node.source) fail(`"${directive}" modules cannot re-export from another module: import the actions, then export them`, node);
+			const declaration = node.declaration;
+			if (declaration?.type === "FunctionDeclaration") {
+				checkFunction(declaration, declaration.id.name);
+				exports.push({
+					exported: declaration.id.name,
+					local: declaration.id.name,
+					node: declaration
+				});
+			} else if (declaration?.type === "VariableDeclaration") for (const declarator of declaration.declarations ?? []) {
+				if (declarator.id?.type !== "Identifier") fail(`${onlyAsync}; destructured exports are not supported`, declarator);
+				if (declarator.init) checkFunction(declarator.init, declarator.id.name);
+				exports.push({
+					exported: declarator.id.name,
+					local: declarator.id.name,
+					node: declarator
+				});
+			}
+			else if (declaration?.type === "ClassDeclaration") fail(`${onlyAsync}; ${declaration.id?.name ?? "a class"} is a class`, declaration);
+			else if (declaration && !String(declaration.type).startsWith("TS")) fail(onlyAsync, declaration);
+			for (const specifier of node.specifiers ?? []) {
+				if (specifier.exportKind === "type") continue;
+				const exported = specifier.exported?.name ?? specifier.exported?.value;
+				exports.push({
+					exported,
+					local: specifier.local?.name ?? null,
+					node: specifier
+				});
+			}
+		} else if (node.type === "ExportDefaultDeclaration") {
+			const declaration = node.declaration;
+			checkFunction(declaration, "the default export");
+			const local = FUNCTION_TYPES.has(declaration.type) && declaration.id?.name || declaration.type === "Identifier" && declaration.name || null;
+			exports.push({
+				exported: "default",
+				local,
+				node
+			});
+		}
+	}
+	return exports;
+}
+/**
+* Compiles a module's server actions, or returns null when it has none. Throws an
+* `ActionCompileError` for a mistake, such as an inline action in browser code.
+*/
+function transformActions(options) {
+	const { code, id, root, environment } = options;
+	const salt = options.salt ?? "";
+	const serverRuntime = options.runtime?.server ?? "@farm.js/islx/server";
+	const clientRuntime = options.runtime?.client ?? "@farm.js/islx/client";
+	const directive = options.directive ?? "use server";
+	const moduleDirective = hasModuleDirective(code, directive);
+	if (!moduleDirective && !code.includes(directive)) return null;
+	const program = options.parse(code);
+	const file = id.split("?", 1)[0];
+	const relative = path.relative(root, file).split(path.sep).join("/");
+	const fail = (message, node) => {
+		throw new ActionCompileError(message, file, code, node.start);
+	};
+	const actionId = (name) => getActionId(root, file, name, salt);
+	const label = (name) => `${name} (${relative})`;
+	if (moduleDirective && environment === "client") {
+		const exports = collectExports(program, fail, directive);
+		const lines = [`import { createServerReference as $$islx_ref } from ${JSON.stringify(clientRuntime)};`];
+		for (const entry of exports) {
+			const reference = `$$islx_ref(${JSON.stringify(actionId(entry.exported))}, undefined, ${JSON.stringify(entry.exported === "default" ? "default" : entry.exported)})`;
+			lines.push(entry.exported === "default" ? `export default ${reference};` : `export const ${entry.exported} = ${reference};`);
+		}
+		const output = new MagicString(code);
+		output.overwrite(0, code.length, `${lines.join("\n")}\n`);
+		return {
+			code: output.toString(),
+			map: output.generateMap({
+				hires: true,
+				source: file
+			})
+		};
+	}
+	const { map, scope: moduleScope } = analyze(program);
+	const scopes = [moduleScope];
+	const scopeNodes = [program];
+	const inline = [];
+	const active = [];
+	let functionDepth = 0;
+	const ownFunctionDepth = [];
+	walk(program, {
+		enter(rawNode, rawParent) {
+			const node = rawNode;
+			const parent = rawParent;
+			if (typeof node.type === "string" && node.type.startsWith("TS")) {
+				this.skip();
+				return;
+			}
+			const scope = node === program ? void 0 : map.get(node);
+			if (scope) {
+				scopes.push(scope);
+				scopeNodes.push(node);
+			}
+			if (FUNCTION_TYPES.has(node.type)) {
+				if (isInlineAction(node, directive) && !(moduleDirective && functionDepth === 0)) {
+					if (environment === "client") fail(`An inline "${directive}" function can only be written in server code. Move it to a "${directive}" module and import it here`, node);
+					if (!node.async) fail("A server action must be an async function", node);
+					if (node.generator) fail("A server action cannot be a generator", node);
+					const action = {
+						node,
+						parent,
+						nested: functionDepth > 0,
+						name: actionName(node, parent),
+						captured: [],
+						scopeIndex: scopes.length - 1
+					};
+					inline.push(action);
+					active.push(action);
+					ownFunctionDepth.push(0);
+				} else if (node.type !== "ArrowFunctionExpression") for (let index = 0; index < ownFunctionDepth.length; index++) ownFunctionDepth[index]++;
+				functionDepth++;
+				return;
+			}
+			if (active.length === 0) return;
+			if (node.type === "ThisExpression" || node.type === "Identifier" && node.name === "arguments" && parent && isReference(node, parent)) {
+				for (let index = 0; index < active.length; index++) if (ownFunctionDepth[index] === 0) fail(`A server action cannot use \`${node.type === "ThisExpression" ? "this" : "arguments"}\`: pass what it needs as an argument`, node);
+				return;
+			}
+			if (node.type !== "Identifier" || !parent || !isReference(node, parent)) return;
+			if (parent.id === node && FUNCTION_TYPES.has(parent.type)) return;
+			const owner = scopes.at(-1).find_owner(node.name);
+			if (!owner || owner === moduleScope) return;
+			const ownerIndex = scopes.lastIndexOf(owner);
+			for (const action of active) if (ownerIndex > 0 && ownerIndex < action.scopeIndex && !action.captured.includes(node.name)) {
+				if (action.node.type === "FunctionDeclaration" && action.name === node.name) fail(`The server action ${node.name} refers to itself. To call it again, move it to a "${directive}" module`, node);
+				action.captured.push(node.name);
+			}
+		},
+		leave(rawNode) {
+			const node = rawNode;
+			if (scopeNodes.at(-1) === node && node !== program) {
+				scopes.pop();
+				scopeNodes.pop();
+			}
+			if (FUNCTION_TYPES.has(node.type)) {
+				functionDepth--;
+				if (active.at(-1)?.node === node) {
+					active.pop();
+					ownFunctionDepth.pop();
+				} else if (node.type !== "ArrowFunctionExpression") for (let index = 0; index < ownFunctionDepth.length; index++) ownFunctionDepth[index]--;
+			}
+		}
+	});
+	if (inline.length === 0 && !moduleDirective) return null;
+	const output = new MagicString(code);
+	const footer = [];
+	let usesBind = false;
+	let usesInline = false;
+	let usesReference = false;
+	const numbered = [...inline].sort((a, b) => a.node.start - b.node.start);
+	const ids = new Map(numbered.map((action, index) => [action, index]));
+	for (const action of [...inline].sort((a, b) => b.node.start - a.node.start)) {
+		const index = ids.get(action);
+		const name = action.name ?? `action ${index + 1}`;
+		const idValue = actionId(`inline:${index}`);
+		const { node } = action;
+		if (!action.nested) {
+			usesReference = true;
+			if (node.type === "FunctionDeclaration") footer.push(`$$islx_ref(${node.id.name}, ${JSON.stringify(idValue)}, ${JSON.stringify(label(name))});`);
+			else {
+				output.prependLeft(node.start, "$$islx_ref(");
+				output.appendRight(node.end, `, ${JSON.stringify(idValue)}, ${JSON.stringify(label(name))})`);
+			}
+			continue;
+		}
+		usesBind = true;
+		usesInline = true;
+		const hoisted = `$$islx_action_${index}`;
+		const params = node.params.map((param) => output.slice(param.start, param.end));
+		const captured = action.captured.length > 0 ? `[${action.captured.join(", ")}]` : "$$islx_captured";
+		const body = output.slice(node.body.start + 1, node.body.end - 1);
+		footer.push(`async function ${hoisted}(${[captured, ...params].join(", ")}) {${body}}`, `$$islx_inline(${hoisted}, ${JSON.stringify(idValue)}, ${action.captured.length}, ${JSON.stringify(label(name))});`);
+		const reference = `$$islx_bind(${JSON.stringify(idValue)}, () => [${action.captured.join(", ")}], ${JSON.stringify(action.captured)})`;
+		if (node.type === "FunctionDeclaration") {
+			const block = action.parent;
+			if (!block || block.type !== "BlockStatement" && block.type !== "StaticBlock") fail("Declare this server action directly inside a function body", node);
+			output.remove(node.start, node.end);
+			output.appendRight(block.start + 1, `const ${node.id.name} = ${reference};`);
+		} else output.overwrite(node.start, node.end, reference);
+	}
+	if (moduleDirective) {
+		usesReference = true;
+		for (const entry of collectExports(program, fail, directive)) {
+			if (!entry.local) {
+				const declaration = entry.node.declaration;
+				output.overwrite(entry.node.start, declaration.start, "const $$islx_default = ");
+				footer.push("export { $$islx_default as default };");
+				entry.local = "$$islx_default";
+			}
+			footer.push(`$$islx_ref(${entry.local}, ${JSON.stringify(actionId(entry.exported))}, ${JSON.stringify(label(entry.exported))});`);
+		}
+	}
+	const imports = [
+		usesBind && "bindInlineAction as $$islx_bind",
+		usesInline && "registerInlineAction as $$islx_inline",
+		usesReference && "registerServerReference as $$islx_ref"
+	].filter(Boolean);
+	output.prepend(`import { ${imports.join(", ")} } from ${JSON.stringify(serverRuntime)};\n`);
+	output.append(`\n${footer.join("\n")}\n`);
+	return {
+		code: output.toString(),
+		map: output.generateMap({
+			hires: true,
+			source: file
+		})
+	};
+}
+export { transformActions as i, getActionId as n, hasModuleDirective as r, ActionCompileError as t };

package/dist/_chunks/build-COIcs7wm.mjs

@@ -0,0 +1,9 @@
+// src/server/build.ts
+const BUILD_KEY = Symbol.for("islx.build");
+function setBuildDefaults(defaults) {
+	globalThis[BUILD_KEY] = defaults;
+}
+function getBuildDefaults() {
+	return globalThis[BUILD_KEY] ?? {};
+}
+export { setBuildDefaults as n, getBuildDefaults as t };

package/dist/_chunks/codec-CK8kZp4u.d.mts

@@ -0,0 +1,64 @@
+/** Standard base64 of bytes. */
+declare function toBase64(bytes: Uint8Array): string;
+/** Bytes of standard base64. Throws on anything else. */
+declare function fromBase64(base64: string): Uint8Array;
+/** A tagged object. */
+declare function tagged(tag: string, value?: unknown): Record<string, unknown>;
+/** Whether a plain object must travel wrapped as `o`, because its own keys include `$`. */
+declare function needsObjectTag(object: object): boolean;
+/**
+ * The tag for a value JSON cannot hold and that has no children (everything above but `M`, `S`
+ * and `o`), or undefined when the value needs none.
+ */
+declare function encodeLeaf(value: unknown): Record<string, unknown> | undefined;
+/** Returned by `decodeTagged` for the runtime's reference tags (`r`, `s`, `a`). */
+declare const NOT_A_VALUE: unique symbol;
+/** A plain object from entries; `defineProperty`, so a "__proto__" key stays an ordinary key. */
+declare function plainObject(entries: Iterable<[string, unknown]>): Record<string, unknown>;
+/**
+ * The value a tagged object stands for, decoding children (a `Map`'s or `Set`'s entries, an `o`
+ * object's properties) with `decodeChild`. Returns `NOT_A_VALUE` for the runtime's reference tags,
+ * and throws for an unknown or malformed tag.
+ */
+declare function decodeTagged(object: Record<string, unknown>, decodeChild: (value: unknown) => unknown): unknown;
+/** Thrown by `encode` for a value it cannot carry; names where the value sits. */
+declare class EncodeError extends TypeError {
+  /** Where the value sits, from the root: `["user", "roles", 2]`. */
+  readonly path: readonly (string | number)[];
+  /** What is wrong with it: "functions are not serializable". */
+  readonly reason: string;
+  constructor(reason: string, path: readonly (string | number)[]);
+  /** The path as written in code: `user.roles[2]`. */
+  get location(): string;
+}
+interface EncodeOptions {
+  /**
+   * Encodes a function, such as a server action, or returns undefined to refuse it. Without it,
+   * functions throw.
+   */
+  encodeFunction?: (value: Function) => unknown;
+  /**
+   * Encodes an object the codec cannot carry itself (`FormData`, a `Blob`), or returns
+   * undefined to refuse it.
+   */
+  encodeObject?: (value: object) => unknown;
+  /** Names the root of the value in error messages. */
+  path?: readonly (string | number)[];
+}
+/**
+ * Encodes a value for JSON with the tags above: plain objects, arrays and the types listed.
+ * Symbols, class instances, circular values and (without `encodeFunction`) functions throw an
+ * `EncodeError` that names where the value sits.
+ */
+declare function encode(value: unknown, options?: EncodeOptions): unknown;
+interface DecodeOptions {
+  /**
+   * Decodes one of the runtime's reference tags (`r`, `s`, `a`), or returns undefined to refuse
+   * it. Without it, every reference throws: input from a browser must not name the runtime's own
+   * references unless the caller checks them.
+   */
+  decodeReference?: (object: Record<string, unknown>) => unknown;
+}
+/** Decodes what `encode` produced, after `JSON.parse`. Reference tags are rejected by default. */
+declare function decode(value: unknown, options?: DecodeOptions): unknown;
+export { decode as a, encodeLeaf as c, plainObject as d, tagged as f, NOT_A_VALUE as i, fromBase64 as l, EncodeError as n, decodeTagged as o, toBase64 as p, EncodeOptions as r, encode as s, DecodeOptions as t, needsObjectTag as u };

package/dist/_chunks/codec-DqfVYKsx.mjs

@@ -0,0 +1,279 @@
+import { N as getTag } from "./wire-CXOodE06.mjs";
+// src/protocol/codec.ts
+/**
+* Values JSON cannot hold. Each travels as a tagged object: the reserved key `$` holds a short tag
+* and `v` holds the data.
+*
+*   undefined                 {"$":"u"}
+*   NaN, ±Infinity, -0        {"$":"n","v":"NaN"}
+*   12345678901234567890n     {"$":"B","v":"12345678901234567890"}
+*   new Date(…)               {"$":"D","v":"2026-10-28T09:00:00.000Z"}   (null for an invalid date)
+*   new Map([[k, v]])         {"$":"M","v":[[k, v]]}                      (keys and values tagged)
+*   new Set([v])              {"$":"S","v":[v]}
+*   new URL(…)                {"$":"U","v":"https://example.com/"}
+*   /ab+c/gi                  {"$":"R","v":["ab+c","gi"]}
+*   Uint8Array, ArrayBuffer…  {"$":"Y","v":["Uint8Array","base64…"]}
+*   app data with a "$" key   {"$":"o","v":{…}}                          (never read as a tag)
+*
+* Decoding accepts input from the browser (server action arguments): it builds plain objects
+* without assigning `__proto__`, and rejects unknown or malformed tags.
+*/
+const TYPED_ARRAYS = {
+	Int8Array,
+	Uint8Array,
+	Uint8ClampedArray,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	BigInt64Array,
+	BigUint64Array
+};
+/** Standard base64 of bytes. */
+function toBase64(bytes) {
+	let binary = "";
+	for (let index = 0; index < bytes.length; index += 32768) binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+	return btoa(binary);
+}
+/** Bytes of standard base64. Throws on anything else. */
+function fromBase64(base64) {
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+	return bytes;
+}
+/** A tagged object. */
+function tagged(tag, value) {
+	return value === void 0 ? { ["$"]: tag } : {
+		["$"]: tag,
+		["v"]: value
+	};
+}
+/** Whether a plain object must travel wrapped as `o`, because its own keys include `$`. */
+function needsObjectTag(object) {
+	return Object.prototype.hasOwnProperty.call(object, "$");
+}
+/**
+* The tag for a value JSON cannot hold and that has no children (everything above but `M`, `S`
+* and `o`), or undefined when the value needs none.
+*/
+function encodeLeaf(value) {
+	switch (typeof value) {
+		case "undefined": return tagged("u");
+		case "bigint": return tagged("B", value.toString());
+		case "number":
+			if (Number.isNaN(value)) return tagged("n", "NaN");
+			if (value === Infinity) return tagged("n", "Infinity");
+			if (value === -Infinity) return tagged("n", "-Infinity");
+			if (Object.is(value, -0)) return tagged("n", "-0");
+			return;
+		case "object": break;
+		default: return;
+	}
+	if (value === null) return void 0;
+	if (value instanceof Date) return tagged("D", Number.isNaN(value.getTime()) ? null : value.toISOString());
+	if (typeof URL === "function" && value instanceof URL) return tagged("U", value.href);
+	if (value instanceof RegExp) return tagged("R", [value.source, value.flags]);
+	if (value instanceof ArrayBuffer) return tagged("Y", ["ArrayBuffer", toBase64(new Uint8Array(value))]);
+	if (ArrayBuffer.isView(value)) {
+		const name = value instanceof DataView ? "DataView" : value.constructor.name;
+		if (name !== "DataView" && !(name in TYPED_ARRAYS)) return void 0;
+		return tagged("Y", [name, toBase64(new Uint8Array(value.buffer, value.byteOffset, value.byteLength))]);
+	}
+}
+/** Returned by `decodeTagged` for the runtime's reference tags (`r`, `s`, `a`). */
+const NOT_A_VALUE = Symbol.for("islx.codec.not-a-value");
+/** A plain object from entries; `defineProperty`, so a "__proto__" key stays an ordinary key. */
+function plainObject(entries) {
+	const object = {};
+	for (const [key, value] of entries) setOwn(object, key, value);
+	return object;
+}
+/**
+* Sets an own property. Plain assignment keeps the object fast; only a `"__proto__"` key needs
+* `defineProperty`, which assignment would turn into a prototype change.
+*/
+function setOwn(object, key, value) {
+	if (key === "__proto__") Object.defineProperty(object, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	else object[key] = value;
+}
+/**
+* The value a tagged object stands for, decoding children (a `Map`'s or `Set`'s entries, an `o`
+* object's properties) with `decodeChild`. Returns `NOT_A_VALUE` for the runtime's reference tags,
+* and throws for an unknown or malformed tag.
+*/
+function decodeTagged(object, decodeChild) {
+	const tag = object["$"];
+	const data = object["v"];
+	switch (tag) {
+		case "r":
+		case "s":
+		case "a":
+		case "F":
+		case "K": return NOT_A_VALUE;
+		case "o":
+			if (data && typeof data === "object" && !Array.isArray(data)) return plainObject(Object.entries(data).map(([key, value]) => [key, decodeChild(value)]));
+			break;
+		case "u": return;
+		case "n":
+			if (data === "NaN") return NaN;
+			if (data === "Infinity") return Infinity;
+			if (data === "-Infinity") return -Infinity;
+			if (data === "-0") return -0;
+			break;
+		case "B":
+			if (typeof data === "string" && /^-?\d+$/.test(data)) return BigInt(data);
+			break;
+		case "D":
+			if (data === null) return /* @__PURE__ */ new Date(NaN);
+			if (typeof data === "string") return new Date(data);
+			break;
+		case "U":
+			if (typeof data === "string") return new URL(data);
+			break;
+		case "R":
+			if (Array.isArray(data) && typeof data[0] === "string" && typeof data[1] === "string") return new RegExp(data[0], data[1]);
+			break;
+		case "Y": {
+			if (!Array.isArray(data) || typeof data[0] !== "string" || typeof data[1] !== "string") break;
+			const bytes = fromBase64(data[1]);
+			if (data[0] === "ArrayBuffer") return bytes.buffer;
+			if (data[0] === "DataView") return new DataView(bytes.buffer);
+			const TypedArray = Object.prototype.hasOwnProperty.call(TYPED_ARRAYS, data[0]) ? TYPED_ARRAYS[data[0]] : void 0;
+			if (!TypedArray || bytes.byteLength % TypedArray.BYTES_PER_ELEMENT !== 0) break;
+			return new TypedArray(bytes.buffer, 0, bytes.byteLength / TypedArray.BYTES_PER_ELEMENT);
+		}
+		case "M":
+			if (Array.isArray(data) && data.every((entry) => Array.isArray(entry) && entry.length === 2)) return new Map(data.map(([key, value]) => [decodeChild(key), decodeChild(value)]));
+			break;
+		case "S":
+			if (Array.isArray(data)) return new Set(data.map(decodeChild));
+			break;
+		default: throw new TypeError(`unknown ${JSON.stringify(tag)} tag`);
+	}
+	throw new TypeError(`malformed ${JSON.stringify(tag)} tag`);
+}
+/** Describes where in a value encoding failed, for error messages: `user.roles[2]`. */
+function describePath(path) {
+	return path.map((part, index) => typeof part === "number" ? `[${part}]` : /^[A-Za-z_$][\w$]*$/.test(part) ? `${index === 0 ? "" : "."}${part}` : `[${JSON.stringify(part)}]`).join("");
+}
+/** Thrown by `encode` for a value it cannot carry; names where the value sits. */
+var EncodeError = class extends TypeError {
+	/** Where the value sits, from the root: `["user", "roles", 2]`. */
+	path;
+	/** What is wrong with it: "functions are not serializable". */
+	reason;
+	constructor(reason, path) {
+		super(path.length > 0 ? `${describePath(path)}: ${reason}` : reason);
+		this.name = "EncodeError";
+		this.path = [...path];
+		this.reason = reason;
+	}
+	/** The path as written in code: `user.roles[2]`. */
+	get location() {
+		return describePath(this.path);
+	}
+};
+/**
+* Encodes a value for JSON with the tags above: plain objects, arrays and the types listed.
+* Symbols, class instances, circular values and (without `encodeFunction`) functions throw an
+* `EncodeError` that names where the value sits.
+*/
+function encode(value, options = {}) {
+	const seen = /* @__PURE__ */ new Set();
+	const path = [...options.path ?? []];
+	const fail = (reason) => {
+		throw new EncodeError(reason, path);
+	};
+	const visit = (value) => {
+		const leaf = encodeLeaf(value);
+		if (leaf) return leaf;
+		if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+		if (typeof value === "number") return value;
+		if (typeof value === "function") {
+			const encoded = options.encodeFunction?.(value);
+			return encoded === void 0 ? fail("functions are not serializable") : encoded;
+		}
+		if (typeof value !== "object") return fail(`${typeof value} values are not serializable`);
+		if (seen.has(value)) return fail("circular values are not serializable");
+		seen.add(value);
+		try {
+			if (Array.isArray(value)) return value.map((entry, index) => {
+				path.push(index);
+				try {
+					return visit(entry);
+				} finally {
+					path.pop();
+				}
+			});
+			if (value instanceof Map) {
+				let index = 0;
+				return tagged("M", Array.from(value, ([key, entry]) => {
+					path.push(index++);
+					try {
+						return [visit(key), visit(entry)];
+					} finally {
+						path.pop();
+					}
+				}));
+			}
+			if (value instanceof Set) {
+				let index = 0;
+				return tagged("S", Array.from(value, (entry) => {
+					path.push(index++);
+					try {
+						return visit(entry);
+					} finally {
+						path.pop();
+					}
+				}));
+			}
+			if (typeof value.$$typeof === "symbol") return fail("elements (JSX) are not serializable");
+			const prototype = Object.getPrototypeOf(value);
+			if (prototype !== Object.prototype && prototype !== null) {
+				const special = options.encodeObject?.(value);
+				if (special !== void 0) return special;
+				const name = value.constructor?.name;
+				return fail(`class instances${name ? ` (${name})` : ""} are not serializable`);
+			}
+			const encoded = plainObject(Object.entries(value).map(([key, entry]) => {
+				path.push(key);
+				try {
+					return [key, visit(entry)];
+				} finally {
+					path.pop();
+				}
+			}));
+			return needsObjectTag(value) ? tagged("o", encoded) : encoded;
+		} finally {
+			seen.delete(value);
+		}
+	};
+	return visit(value);
+}
+/** Decodes what `encode` produced, after `JSON.parse`. Reference tags are rejected by default. */
+function decode(value, options = {}) {
+	const visit = (value) => {
+		if (Array.isArray(value)) return value.map(visit);
+		if (!value || typeof value !== "object") return value;
+		if (getTag(value) !== void 0) {
+			const object = value;
+			const decoded = decodeTagged(object, visit);
+			if (decoded !== NOT_A_VALUE) return decoded;
+			const reference = options.decodeReference?.(object);
+			if (reference !== void 0) return reference;
+			throw new TypeError(`a ${JSON.stringify(object["$"])} reference is not allowed here`);
+		}
+		if (needsObjectTag(value)) throw new TypeError("malformed \"$\" tag");
+		return plainObject(Object.entries(value).map(([key, entry]) => [key, visit(entry)]));
+	};
+	return visit(value);
+}
+export { encode as a, needsObjectTag as c, tagged as d, toBase64 as f, decodeTagged as i, plainObject as l, NOT_A_VALUE as n, encodeLeaf as o, decode as r, fromBase64 as s, EncodeError as t, setOwn as u };