@selvajs/selva 4.7.0-beta.2 → 4.7.0-beta.4

package/build/server/chunks/chunks/shared.js-DVKQackd.js

@@ -0,0 +1,598 @@
+import { i as is_valid_array_len, M as MAX_ARRAY_INDEX, a as is_valid_array_index, D as DevalueError, b as is_primitive, g as get_type, c as is_plain_object, e as enumerable_symbols, s as stringify_key, d as stringify_string, v as valid_array_indices } from './uneval.js-1VR0v8ir.js';
+import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
+
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.69.1_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte@7.2.0_svelte_a72f1cdc05ff4a6cc1920f4bfb4e9fa9/node_modules/@sveltejs/kit/src/utils/functions.js
+function noop() {}
+/**
+* @template T
+* @param {() => T} fn
+*/
+function once(fn) {
+	let done = false;
+	/** @type T */
+	let result;
+	return () => {
+		if (done) return result;
+		done = true;
+		return result = fn();
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/base64.js
+/**	@type {(array_buffer: ArrayBuffer) => string} */
+function encode_native(array_buffer) {
+	return new Uint8Array(array_buffer).toBase64();
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_native(base64) {
+	return Uint8Array.fromBase64(base64).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_buffer(array_buffer) {
+	return Buffer.from(array_buffer).toString("base64");
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_buffer(base64) {
+	return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_legacy(array_buffer) {
+	const array = new Uint8Array(array_buffer);
+	let binary = "";
+	const chunk_size = 32768;
+	for (let i = 0; i < array.length; i += chunk_size) {
+		const chunk = array.subarray(i, i + chunk_size);
+		binary += String.fromCharCode.apply(null, chunk);
+	}
+	return btoa(binary);
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_legacy(base64) {
+	const binary_string = atob(base64);
+	const len = binary_string.length;
+	const array = new Uint8Array(len);
+	for (let i = 0; i < len; i++) array[i] = binary_string.charCodeAt(i);
+	return array.buffer;
+}
+var native = typeof Uint8Array.fromBase64 === "function";
+var buffer = typeof process === "object" && process.versions?.node !== void 0;
+var encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+var decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/parse.js
+/**
+* Revive a value serialized with `devalue.stringify`
+* @param {string} serialized
+* @param {Record<string, (value: any) => any>} [revivers]
+*/
+function parse(serialized, revivers) {
+	return unflatten(JSON.parse(serialized), revivers);
+}
+/**
+* Revive a value flattened with `devalue.stringify`
+* @param {number | any[]} parsed
+* @param {Record<string, (value: any) => any>} [revivers]
+*/
+function unflatten(parsed, revivers) {
+	if (typeof parsed === "number") return hydrate(parsed, true);
+	if (!Array.isArray(parsed) || parsed.length === 0) throw new Error("Invalid input");
+	const values = parsed;
+	const hydrated = Array(values.length);
+	/**
+	* A set of values currently being hydrated with custom revivers,
+	* used to detect invalid cyclical dependencies
+	* @type {Set<number> | null}
+	*/
+	let hydrating = null;
+	/**
+	* @param {number} index
+	* @returns {any}
+	*/
+	function hydrate(index, standalone = false) {
+		if (index === -1) return void 0;
+		if (index === -3) return NaN;
+		if (index === -4) return Infinity;
+		if (index === -5) return -Infinity;
+		if (index === -6) return -0;
+		if (standalone || typeof index !== "number") throw new Error(`Invalid input`);
+		if (index in hydrated) return hydrated[index];
+		const value = values[index];
+		if (!value || typeof value !== "object") hydrated[index] = value;
+		else if (Array.isArray(value)) if (typeof value[0] === "string") {
+			const type = value[0];
+			const reviver = revivers && Object.hasOwn(revivers, type) ? revivers[type] : void 0;
+			if (reviver) {
+				let i = value[1];
+				if (typeof i !== "number") i = values.push(value[1]) - 1;
+				hydrating ??= /* @__PURE__ */ new Set();
+				if (hydrating.has(i)) throw new Error("Invalid circular reference");
+				hydrating.add(i);
+				hydrated[index] = reviver(hydrate(i));
+				hydrating.delete(i);
+				return hydrated[index];
+			}
+			switch (type) {
+				case "Date":
+					hydrated[index] = new Date(value[1]);
+					break;
+				case "Set":
+					const set = /* @__PURE__ */ new Set();
+					hydrated[index] = set;
+					for (let i = 1; i < value.length; i += 1) set.add(hydrate(value[i]));
+					break;
+				case "Map":
+					const map = /* @__PURE__ */ new Map();
+					hydrated[index] = map;
+					for (let i = 1; i < value.length; i += 2) map.set(hydrate(value[i]), hydrate(value[i + 1]));
+					break;
+				case "RegExp":
+					hydrated[index] = new RegExp(value[1], value[2]);
+					break;
+				case "Object": {
+					const wrapped_index = value[1];
+					if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") throw new Error("Invalid input");
+					hydrated[index] = Object(hydrate(wrapped_index));
+					break;
+				}
+				case "BigInt":
+					hydrated[index] = BigInt(value[1]);
+					break;
+				case "null":
+					const obj = Object.create(null);
+					hydrated[index] = obj;
+					for (let i = 1; i < value.length; i += 2) {
+						if (value[i] === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+						obj[value[i]] = hydrate(value[i + 1]);
+					}
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Float16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array":
+				case "DataView": {
+					if (values[value[1]][0] !== "ArrayBuffer") throw new Error("Invalid data");
+					const TypedArrayConstructor = globalThis[type];
+					const buffer = hydrate(value[1]);
+					hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer, value[2], value[3]) : new TypedArrayConstructor(buffer);
+					break;
+				}
+				case "ArrayBuffer": {
+					const base64 = value[1];
+					if (typeof base64 !== "string") throw new Error("Invalid ArrayBuffer encoding");
+					const arraybuffer = decode64(base64);
+					hydrated[index] = arraybuffer;
+					break;
+				}
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime": {
+					const temporalName = type.slice(9);
+					hydrated[index] = Temporal[temporalName].from(value[1]);
+					break;
+				}
+				case "URL": {
+					const url = new URL(value[1]);
+					hydrated[index] = url;
+					break;
+				}
+				case "URLSearchParams": {
+					const url = new URLSearchParams(value[1]);
+					hydrated[index] = url;
+					break;
+				}
+				default: throw new Error(`Unknown type ${type}`);
+			}
+		} else if (value[0] === -7) {
+			const len = value[1];
+			if (!is_valid_array_len(len)) throw new Error("Invalid input");
+			/** @type {any[]} */
+			const array = [];
+			hydrated[index] = array;
+			array[MAX_ARRAY_INDEX] = void 0;
+			delete array[MAX_ARRAY_INDEX];
+			for (let i = 2; i < value.length; i += 2) {
+				const idx = value[i];
+				if (!is_valid_array_index(idx) || idx >= len) throw new Error("Invalid input");
+				array[idx] = hydrate(value[i + 1]);
+			}
+			array.length = len;
+		} else {
+			const array = new Array(value.length);
+			hydrated[index] = array;
+			for (let i = 0; i < value.length; i += 1) {
+				const n = value[i];
+				if (n === -2) continue;
+				array[i] = hydrate(n);
+			}
+		}
+		else {
+			/** @type {Record<string, any>} */
+			const object = {};
+			hydrated[index] = object;
+			for (const key of Object.keys(value)) {
+				if (key === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+				const n = value[key];
+				object[key] = hydrate(n);
+			}
+		}
+		return hydrated[index];
+	}
+	return hydrate(0);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/stringify.js
+/**
+* Turn a value into a JSON string that can be parsed with `devalue.parse`
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+*/
+function stringify$1(value, reducers) {
+	const stringified = run(false, value, reducers);
+	return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+/**
+* @param {boolean} async
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+*/
+function run(async, value, reducers) {
+	/** @type {any[]} */
+	const stringified = [];
+	/** @type {Map<any, number>} */
+	const indexes = /* @__PURE__ */ new Map();
+	/** @type {Array<{ key: string, fn: (value: any) => any }>} */
+	const custom = [];
+	if (reducers) for (const key of Object.getOwnPropertyNames(reducers)) custom.push({
+		key,
+		fn: reducers[key]
+	});
+	/** @type {string[]} */
+	const keys = [];
+	let p = 0;
+	/**
+	* @param {any} thing
+	* @param {number} [index]
+	*/
+	function flatten(thing, index) {
+		if (thing === void 0) return -1;
+		if (Number.isNaN(thing)) return -3;
+		if (thing === Infinity) return -4;
+		if (thing === -Infinity) return -5;
+		if (thing === 0 && 1 / thing < 0) return -6;
+		if (indexes.has(thing)) return indexes.get(thing);
+		index ??= p++;
+		indexes.set(thing, index);
+		for (const { key, fn } of custom) {
+			const value = fn(thing);
+			if (value) {
+				stringified[index] = `["${key}",${flatten(value)}]`;
+				return index;
+			}
+		}
+		if (typeof thing === "function") throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+		else if (typeof thing === "symbol") throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
+		/** @type {string | Promise<any>} */
+		let str = "";
+		if (is_primitive(thing)) str = stringify_primitive(thing);
+		else if (typeof thing.then === "function") {
+			throw new DevalueError(`Cannot stringify a Promise or thenable — use stringifyAsync instead`, keys, thing, value);
+		} else {
+			const type = get_type(thing);
+			switch (type) {
+				case "Number":
+				case "String":
+				case "Boolean":
+				case "BigInt":
+					str = `["Object",${flatten(thing.valueOf())}]`;
+					break;
+				case "Date":
+					str = `["Date","${!isNaN(thing.getDate()) ? thing.toISOString() : ""}"]`;
+					break;
+				case "URL":
+					str = `["URL",${stringify_string(thing.toString())}]`;
+					break;
+				case "URLSearchParams":
+					str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+					break;
+				case "RegExp":
+					const { source, flags } = thing;
+					str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+					break;
+				case "Array": {
+					let mostly_dense = false;
+					str = "[";
+					for (let i = 0; i < thing.length; i += 1) {
+						if (i > 0) str += ",";
+						if (Object.hasOwn(thing, i)) {
+							keys.push(`[${i}]`);
+							str += flatten(thing[i]);
+							keys.pop();
+						} else if (mostly_dense) str += -2;
+						else {
+							const populated_keys = valid_array_indices(thing);
+							const population = populated_keys.length;
+							const d = String(thing.length).length;
+							if ((thing.length - population) * 3 > 4 + d + population * (d + 1)) {
+								str = "[-7," + thing.length;
+								for (let j = 0; j < populated_keys.length; j++) {
+									const key = populated_keys[j];
+									keys.push(`[${key}]`);
+									str += "," + key + "," + flatten(thing[key]);
+									keys.pop();
+								}
+								break;
+							} else {
+								mostly_dense = true;
+								str += -2;
+							}
+						}
+					}
+					str += "]";
+					break;
+				}
+				case "Set":
+					str = "[\"Set\"";
+					for (const value of thing) str += `,${flatten(value)}`;
+					str += "]";
+					break;
+				case "Map":
+					str = "[\"Map\"";
+					for (const [key, value] of thing) {
+						keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+						str += `,${flatten(key)},${flatten(value)}`;
+						keys.pop();
+					}
+					str += "]";
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Float16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array":
+				case "DataView": {
+					/** @type {import("./types.js").TypedArray} */
+					const typedArray = thing;
+					str = "[\"" + type + "\"," + flatten(typedArray.buffer);
+					if (typedArray.byteLength !== typedArray.buffer.byteLength) str += `,${typedArray.byteOffset},${typedArray.length}`;
+					str += "]";
+					break;
+				}
+				case "ArrayBuffer":
+					str = `["ArrayBuffer","${encode64(thing)}"]`;
+					break;
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime":
+					str = `["${type}",${stringify_string(thing.toString())}]`;
+					break;
+				default:
+					if (!is_plain_object(thing)) throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
+					if (enumerable_symbols(thing).length > 0) throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
+					if (Object.getPrototypeOf(thing) === null) {
+						str = "[\"null\"";
+						for (const key of Object.keys(thing)) {
+							if (key === "__proto__") throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+							keys.push(stringify_key(key));
+							str += `,${stringify_string(key)},${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "]";
+					} else {
+						str = "{";
+						let started = false;
+						for (const key of Object.keys(thing)) {
+							if (key === "__proto__") throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+							if (started) str += ",";
+							started = true;
+							keys.push(stringify_key(key));
+							str += `${stringify_string(key)}:${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "}";
+					}
+			}
+		}
+		stringified[index] = str;
+		return index;
+	}
+	const index = flatten(value);
+	if (index < 0) return `${index}`;
+	return stringified;
+}
+/**
+* @param {any} thing
+* @returns {string}
+*/
+function stringify_primitive(thing) {
+	const type = typeof thing;
+	if (type === "string") return stringify_string(thing);
+	if (thing === void 0) return (-1).toString();
+	if (thing === 0 && 1 / thing < 0) return (-6).toString();
+	if (type === "bigint") return `["BigInt","${thing}"]`;
+	return String(thing);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.69.1_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte@7.2.0_svelte_a72f1cdc05ff4a6cc1920f4bfb4e9fa9/node_modules/@sveltejs/kit/src/runtime/utils.js
+var text_encoder = new TextEncoder();
+/**
+* Like node's path.relative, but without using node
+* @param {string} from
+* @param {string} to
+*/
+function get_relative_path(from, to) {
+	const from_parts = from.split(/[/\\]/);
+	const to_parts = to.split(/[/\\]/);
+	from_parts.pop();
+	while (from_parts[0] === to_parts[0]) {
+		from_parts.shift();
+		to_parts.shift();
+	}
+	let i = from_parts.length;
+	while (i--) from_parts[i] = "..";
+	return from_parts.concat(to_parts).join("/");
+}
+/**
+* @param {Uint8Array} bytes
+* @returns {string}
+*/
+function base64_encode(bytes) {
+	if (globalThis.Buffer) return globalThis.Buffer.from(bytes).toString("base64");
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary);
+}
+/**
+* @param {string} encoded
+* @returns {Uint8Array}
+*/
+function base64_decode(encoded) {
+	if (globalThis.Buffer) {
+		const buffer = globalThis.Buffer.from(encoded, "base64");
+		return new Uint8Array(buffer);
+	}
+	const binary = atob(encoded);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sveltejs+kit@2.69.1_@opentelemetry+api@1.9.1_@sveltejs+vite-plugin-svelte@7.2.0_svelte_a72f1cdc05ff4a6cc1920f4bfb4e9fa9/node_modules/@sveltejs/kit/src/utils/error.js
+/**
+* @param {unknown} err
+* @return {Error}
+*/
+function coalesce_to_error(err) {
+	return err instanceof Error || err && err.name && err.message ? err : new Error(JSON.stringify(err));
+}
+/**
+* This is an identity function that exists to make TypeScript less
+* paranoid about people throwing things that aren't errors, which
+* frankly is not something we should care about
+* @param {unknown} error
+*/
+function normalize_error(error) {
+	return error;
+}
+/**
+* @param {unknown} error
+*/
+function get_status(error) {
+	return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+}
+/**
+* @param {unknown} error
+*/
+function get_message(error) {
+	return error instanceof SvelteKitError ? error.text : "Internal Error";
+}
+var INVALIDATED_PARAM = "x-sveltekit-invalidated";
+var TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
+/**
+* Try to `devalue.stringify` the data object using the provided transport encoders.
+* @param {any} data
+* @param {Transport} transport
+*/
+function stringify(data, transport) {
+	return stringify$1(data, Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode])));
+}
+var remote_object = "__skrao";
+var remote_map = "__skram";
+var remote_set = "__skras";
+var remote_file = "__skraf";
+/** @param {Transport} transport */
+function create_remote_arg_revivers(transport) {
+	const remote_fns_revivers = {
+		/** @type {(value: unknown) => unknown} */
+		[remote_object]: (value) => value,
+		/** @type {(value: unknown) => Map<unknown, unknown>} */
+		[remote_map]: (value) => {
+			if (!Array.isArray(value)) throw new Error("Invalid data for Map reviver");
+			const map = /* @__PURE__ */ new Map();
+			for (const item of value) {
+				if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string" || typeof item[1] !== "string") throw new Error("Invalid data for Map reviver");
+				const [key, val] = item;
+				map.set(parse$1(key), parse$1(val));
+			}
+			return map;
+		},
+		/** @type {(value: unknown) => Set<unknown>} */
+		[remote_set]: (value) => {
+			if (!Array.isArray(value)) throw new Error("Invalid data for Set reviver");
+			const set = /* @__PURE__ */ new Set();
+			for (const item of value) {
+				if (typeof item !== "string") throw new Error("Invalid data for Set reviver");
+				set.add(parse$1(item));
+			}
+			return set;
+		},
+		/** @type {(value: any) => File} */
+		[remote_file]: (value) => {
+			if (!value || typeof value !== "object" || typeof value.name !== "string" || typeof value.type !== "string" || typeof value.size !== "number" || typeof value.lastModified !== "number" || !(value.data instanceof ArrayBuffer)) throw new Error("Invalid data for File reviver");
+			const { data, name, ...meta } = value;
+			return new File([data], name, meta);
+		}
+	};
+	const all_revivers = {
+		...Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.decode])),
+		...remote_fns_revivers
+	};
+	/** @type {(data: string) => unknown} */
+	const parse$1 = (data) => parse(data, all_revivers);
+	return all_revivers;
+}
+/**
+* Parses the argument (if any) for a remote function
+* @param {string} string
+* @param {Transport} transport
+*/
+function parse_remote_arg(string, transport) {
+	if (!string) return void 0;
+	return parse(new TextDecoder().decode(base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))), create_remote_arg_revivers(transport));
+}
+/**
+* @param {string} id
+* @param {string} payload
+*/
+function create_remote_key(id, payload) {
+	return id + "/" + payload;
+}
+/**
+* @param {string} key
+* @returns {{ id: string; payload: string }}
+*/
+function split_remote_key(key) {
+	const i = key.lastIndexOf("/");
+	if (i === -1) throw new Error(`Invalid remote key: ${key}`);
+	return {
+		id: key.slice(0, i),
+		payload: key.slice(i + 1)
+	};
+}
+
+export { INVALIDATED_PARAM as I, TRAILING_SLASH_PARAM as T, get_message as a, normalize_error as b, coalesce_to_error as c, get_relative_path as d, create_remote_key as e, parse_remote_arg as f, get_status as g, stringify$1 as h, split_remote_key as i, base64_encode as j, noop as n, once as o, parse as p, stringify as s, text_encoder as t };
+//# sourceMappingURL=shared.js-DVKQackd.js.map