@mindflight/mindbrain-personal-studio 0.6.1

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

@@ -0,0 +1,1338 @@
+import { t as text_decoder, b as base64_decode } from './utils.js-DGYJFmnf.js';
+import { D as DevalueError, i as is_primitive, g as get_type, a as is_plain_object, e as enumerable_symbols, s as stringify_key, b as stringify_string, v as valid_array_indices } from './render-context.js-CTu5Wkzp.js';
+
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+
+class HttpError {
+	/**
+	 * @param {number} status
+	 * @param {{message: string} extends App.Error ? (App.Error | string | undefined) : App.Error} body
+	 */
+	constructor(status, body) {
+		this.status = status;
+		if (typeof body === 'string') {
+			this.body = { message: body };
+		} else if (body) {
+			this.body = body;
+		} else {
+			this.body = { message: `Error: ${status}` };
+		}
+	}
+
+	toString() {
+		return JSON.stringify(this.body);
+	}
+}
+
+class Redirect {
+	/**
+	 * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status
+	 * @param {string} location
+	 */
+	constructor(status, location) {
+		this.status = status;
+		this.location = location;
+	}
+}
+
+/**
+ * An error that was thrown from within the SvelteKit runtime that is not fatal and doesn't result in a 500, such as a 404.
+ * `SvelteKitError` goes through `handleError`.
+ * @extends Error
+ */
+class SvelteKitError extends Error {
+	/**
+	 * @param {number} status
+	 * @param {string} text
+	 * @param {string} message
+	 */
+	constructor(status, text, message) {
+		super(message);
+		this.status = status;
+		this.text = text;
+	}
+}
+
+/**
+ * @template [T=undefined]
+ */
+class ActionFailure {
+	/**
+	 * @param {number} status
+	 * @param {T} data
+	 */
+	constructor(status, data) {
+		this.status = status;
+		this.data = data;
+	}
+}
+
+const text_encoder = new TextEncoder();
+new TextDecoder();
+
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+
+
+// TODO 3.0: remove these types as they are not used anymore (we can't remove them yet because that would be a breaking change)
+/**
+ * @template {number} TNumber
+ * @template {any[]} [TArray=[]]
+ * @typedef {TNumber extends TArray['length'] ? TArray[number] : LessThan<TNumber, [...TArray, TArray['length']]>} LessThan
+ */
+
+/**
+ * @template {number} TStart
+ * @template {number} TEnd
+ * @typedef {Exclude<TEnd | LessThan<TEnd>, LessThan<TStart>>} NumericRange
+ */
+
+// Keep the status codes as `number` because restricting to certain numbers makes it unnecessarily hard to use compared to the benefits
+// (we have runtime errors already to check for invalid codes). Also see https://github.com/sveltejs/kit/issues/11780
+
+// we have to repeat the JSDoc because the display for function overloads is broken
+// see https://github.com/microsoft/TypeScript/issues/55056
+
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this will cause SvelteKit to
+ * return an error response without invoking `handleError`.
+ * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {App.Error} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @overload
+ * @param {number} status
+ * @param {App.Error} body
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
+ */
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this will cause SvelteKit to
+ * return an error response without invoking `handleError`.
+ * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body] An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @overload
+ * @param {number} status
+ * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body]
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
+ */
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this will cause SvelteKit to
+ * return an error response without invoking `handleError`.
+ * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
+ */
+function error(status, body) {
+	if ((isNaN(status) || status < 400 || status > 599)) {
+		throw new Error(`HTTP error status codes must be between 400 and 599 — ${status} is invalid`);
+	}
+
+	throw new HttpError(status, body);
+}
+
+/**
+ * Checks whether this is a redirect thrown by {@link redirect}.
+ * @param {unknown} e The object to check.
+ * @return {e is Redirect}
+ */
+function isRedirect(e) {
+	return e instanceof Redirect;
+}
+
+/**
+ * Create a JSON `Response` object from the supplied data.
+ * @param {any} data The value that will be serialized as JSON.
+ * @param {ResponseInit} [init] Options such as `status` and `headers` that will be added to the response. `Content-Type: application/json` and `Content-Length` headers will be added automatically.
+ */
+function json(data, init) {
+	// TODO deprecate this in favour of `Response.json` when it's
+	// more widely supported
+	const body = JSON.stringify(data);
+
+	// we can't just do `text(JSON.stringify(data), init)` because
+	// it will set a default `content-type` header. duplicated code
+	// means less duplicated work
+	const headers = new Headers(init?.headers);
+	if (!headers.has('content-length')) {
+		headers.set('content-length', text_encoder.encode(body).byteLength.toString());
+	}
+
+	if (!headers.has('content-type')) {
+		headers.set('content-type', 'application/json');
+	}
+
+	return new Response(body, {
+		...init,
+		headers
+	});
+}
+
+/**
+ * Create a `Response` object from the supplied body.
+ * @param {string} body The value that will be used as-is.
+ * @param {ResponseInit} [init] Options such as `status` and `headers` that will be added to the response. A `Content-Length` header will be added automatically.
+ */
+function text(body, init) {
+	const headers = new Headers(init?.headers);
+	if (!headers.has('content-length')) {
+		const encoded = text_encoder.encode(body);
+		headers.set('content-length', encoded.byteLength.toString());
+		return new Response(encoded, {
+			...init,
+			headers
+		});
+	}
+
+	return new Response(body, {
+		...init,
+		headers
+	});
+}
+
+// eslint-disable-next-line n/prefer-global/process
+const IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
+
+/** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { RequestStore } from 'types' */
+/** @import { AsyncLocalStorage } from 'node:async_hooks' */
+
+
+/** @type {RequestStore | null} */
+let sync_store = null;
+
+/** @type {AsyncLocalStorage<RequestStore | null> | null} */
+let als;
+
+import('node:async_hooks')
+	.then((hooks) => (als = new hooks.AsyncLocalStorage()))
+	.catch(() => {
+		// can't use AsyncLocalStorage, but can still call getRequestEvent synchronously.
+		// this isn't behind `supports` because it's basically just StackBlitz (i.e.
+		// in-browser usage) that doesn't support it AFAICT
+	});
+
+/**
+ * @template T
+ * @param {RequestStore | null} store
+ * @param {() => T} fn
+ */
+function with_request_store(store, fn) {
+	try {
+		sync_store = store;
+		return als ? als.run(store, fn) : fn();
+	} finally {
+		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
+		// and handle only one request at a time in `src/runtime/server/index.js`.
+		if (!IN_WEBCONTAINER) {
+			sync_store = null;
+		}
+	}
+}
+
+/**
+ * @template {{ tracing: { enabled: boolean, root: import('@opentelemetry/api').Span, current: import('@opentelemetry/api').Span } }} T
+ * @param {T} event_like
+ * @param {import('@opentelemetry/api').Span} current
+ * @returns {T}
+ */
+function merge_tracing(event_like, current) {
+	return {
+		...event_like,
+		tracing: {
+			...event_like.tracing,
+			current
+		}
+	};
+}
+
+const SVELTE_KIT_ASSETS = "/_svelte_kit_assets";
+const ENDPOINT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+const PAGE_METHODS = ["GET", "POST", "HEAD"];
+function encode64(arraybuffer) {
+  const dv = new DataView(arraybuffer);
+  let binaryString = "";
+  for (let i = 0; i < arraybuffer.byteLength; i++) {
+    binaryString += String.fromCharCode(dv.getUint8(i));
+  }
+  return binaryToAscii(binaryString);
+}
+function decode64(string) {
+  const binaryString = asciiToBinary(string);
+  const arraybuffer = new ArrayBuffer(binaryString.length);
+  const dv = new DataView(arraybuffer);
+  for (let i = 0; i < arraybuffer.byteLength; i++) {
+    dv.setUint8(i, binaryString.charCodeAt(i));
+  }
+  return arraybuffer;
+}
+const KEY_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function asciiToBinary(data) {
+  if (data.length % 4 === 0) {
+    data = data.replace(/==?$/, "");
+  }
+  let output = "";
+  let buffer = 0;
+  let accumulatedBits = 0;
+  for (let i = 0; i < data.length; i++) {
+    buffer <<= 6;
+    buffer |= KEY_STRING.indexOf(data[i]);
+    accumulatedBits += 6;
+    if (accumulatedBits === 24) {
+      output += String.fromCharCode((buffer & 16711680) >> 16);
+      output += String.fromCharCode((buffer & 65280) >> 8);
+      output += String.fromCharCode(buffer & 255);
+      buffer = accumulatedBits = 0;
+    }
+  }
+  if (accumulatedBits === 12) {
+    buffer >>= 4;
+    output += String.fromCharCode(buffer);
+  } else if (accumulatedBits === 18) {
+    buffer >>= 2;
+    output += String.fromCharCode((buffer & 65280) >> 8);
+    output += String.fromCharCode(buffer & 255);
+  }
+  return output;
+}
+function binaryToAscii(str) {
+  let out = "";
+  for (let i = 0; i < str.length; i += 3) {
+    const groupsOfSix = [void 0, void 0, void 0, void 0];
+    groupsOfSix[0] = str.charCodeAt(i) >> 2;
+    groupsOfSix[1] = (str.charCodeAt(i) & 3) << 4;
+    if (str.length > i + 1) {
+      groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
+      groupsOfSix[2] = (str.charCodeAt(i + 1) & 15) << 2;
+    }
+    if (str.length > i + 2) {
+      groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
+      groupsOfSix[3] = str.charCodeAt(i + 2) & 63;
+    }
+    for (let j = 0; j < groupsOfSix.length; j++) {
+      if (typeof groupsOfSix[j] === "undefined") {
+        out += "=";
+      } else {
+        out += KEY_STRING[groupsOfSix[j]];
+      }
+    }
+  }
+  return out;
+}
+const UNDEFINED = -1;
+const HOLE = -2;
+const NAN = -3;
+const POSITIVE_INFINITY = -4;
+const NEGATIVE_INFINITY = -5;
+const NEGATIVE_ZERO = -6;
+const SPARSE = -7;
+function parse(serialized, revivers) {
+  return unflatten(JSON.parse(serialized), 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 = (
+    /** @type {any[]} */
+    parsed
+  );
+  const hydrated = Array(values.length);
+  let hydrating = null;
+  function hydrate(index, standalone = false) {
+    if (index === UNDEFINED) return void 0;
+    if (index === NAN) return NaN;
+    if (index === POSITIVE_INFINITY) return Infinity;
+    if (index === NEGATIVE_INFINITY) return -Infinity;
+    if (index === NEGATIVE_ZERO) 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 object = Object(value[1]);
+            if (Object.hasOwn(object, "__proto__")) {
+              throw new Error("Cannot parse an object with a `__proto__` property");
+            }
+            hydrated[index] = object;
+            break;
+          case "BigInt":
+            hydrated[index] = BigInt(value[1]);
+            break;
+          case "null":
+            const obj = /* @__PURE__ */ 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 "Int32Array":
+          case "Uint32Array":
+          case "Float32Array":
+          case "Float64Array":
+          case "BigInt64Array":
+          case "BigUint64Array": {
+            if (values[value[1]][0] !== "ArrayBuffer") {
+              throw new Error("Invalid data");
+            }
+            const TypedArrayConstructor = globalThis[type];
+            const buffer = hydrate(value[1]);
+            const typedArray = new TypedArrayConstructor(buffer);
+            hydrated[index] = value[2] !== void 0 ? typedArray.subarray(value[2], value[3]) : typedArray;
+            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] === SPARSE) {
+        const len = value[1];
+        if (!Number.isInteger(len) || len < 0) {
+          throw new Error("Invalid input");
+        }
+        const array = new Array(len);
+        hydrated[index] = array;
+        for (let i = 2; i < value.length; i += 2) {
+          const idx = value[i];
+          if (!Number.isInteger(idx) || idx < 0 || idx >= len) {
+            throw new Error("Invalid input");
+          }
+          array[idx] = hydrate(value[i + 1]);
+        }
+      } 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 === HOLE) continue;
+          array[i] = hydrate(n);
+        }
+      }
+    } else {
+      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);
+}
+function stringify$1(value, reducers) {
+  const stringified = [];
+  const indexes = /* @__PURE__ */ new Map();
+  const custom = [];
+  if (reducers) {
+    for (const key of Object.getOwnPropertyNames(reducers)) {
+      custom.push({ key, fn: reducers[key] });
+    }
+  }
+  const keys = [];
+  let p = 0;
+  function flatten(thing) {
+    if (thing === void 0) return UNDEFINED;
+    if (Number.isNaN(thing)) return NAN;
+    if (thing === Infinity) return POSITIVE_INFINITY;
+    if (thing === -Infinity) return NEGATIVE_INFINITY;
+    if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
+    if (indexes.has(thing)) return indexes.get(thing);
+    const index2 = p++;
+    indexes.set(thing, index2);
+    for (const { key, fn } of custom) {
+      const value2 = fn(thing);
+      if (value2) {
+        stringified[index2] = `["${key}",${flatten(value2)}]`;
+        return index2;
+      }
+    }
+    if (typeof thing === "function") {
+      throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+    }
+    let str = "";
+    if (is_primitive(thing)) {
+      str = stringify_primitive(thing);
+    } else {
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+          str = `["Object",${stringify_primitive(thing)}]`;
+          break;
+        case "BigInt":
+          str = `["BigInt",${thing}]`;
+          break;
+        case "Date":
+          const valid = !isNaN(thing.getDate());
+          str = `["Date","${valid ? 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 += HOLE;
+            } else {
+              const populated_keys = valid_array_indices(
+                /** @type {any[]} */
+                thing
+              );
+              const population = populated_keys.length;
+              const d = String(thing.length).length;
+              const hole_cost = (thing.length - population) * 3;
+              const sparse_cost = 4 + d + population * (d + 1);
+              if (hole_cost > sparse_cost) {
+                str = "[" + SPARSE + "," + 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 += HOLE;
+              }
+            }
+          }
+          str += "]";
+          break;
+        }
+        case "Set":
+          str = '["Set"';
+          for (const value2 of thing) {
+            str += `,${flatten(value2)}`;
+          }
+          str += "]";
+          break;
+        case "Map":
+          str = '["Map"';
+          for (const [key, value2] of thing) {
+            keys.push(
+              `.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
+            );
+            str += `,${flatten(key)},${flatten(value2)}`;
+            keys.pop();
+          }
+          str += "]";
+          break;
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+        case "BigInt64Array":
+        case "BigUint64Array": {
+          const typedArray = thing;
+          str = '["' + type + '",' + flatten(typedArray.buffer);
+          const a = thing.byteOffset;
+          const b = a + thing.byteLength;
+          if (a > 0 || b !== typedArray.buffer.byteLength) {
+            const m = +/(\d+)/.exec(type)[1] / 8;
+            str += `,${a / m},${b / m}`;
+          }
+          str += "]";
+          break;
+        }
+        case "ArrayBuffer": {
+          const arraybuffer = thing;
+          const base64 = encode64(arraybuffer);
+          str = `["ArrayBuffer","${base64}"]`;
+          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[index2] = str;
+    return index2;
+  }
+  const index = flatten(value);
+  if (index < 0) return `${index}`;
+  return `[${stringified.join(",")}]`;
+}
+function stringify_primitive(thing) {
+  const type = typeof thing;
+  if (type === "string") return stringify_string(thing);
+  if (thing instanceof String) return stringify_string(thing.toString());
+  if (thing === void 0) return UNDEFINED.toString();
+  if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
+  if (type === "bigint") return `["BigInt","${thing}"]`;
+  return String(thing);
+}
+function set_nested_value(object, path_string, value) {
+  if (path_string.startsWith("n:")) {
+    path_string = path_string.slice(2);
+    value = value === "" ? void 0 : parseFloat(value);
+  } else if (path_string.startsWith("b:")) {
+    path_string = path_string.slice(2);
+    value = value === "on";
+  }
+  deep_set(object, split_path(path_string), value);
+}
+function convert_formdata(data) {
+  const result = {};
+  for (let key of data.keys()) {
+    const is_array = key.endsWith("[]");
+    let values = data.getAll(key);
+    if (is_array) key = key.slice(0, -2);
+    if (values.length > 1 && !is_array) {
+      throw new Error(`Form cannot contain duplicated keys — "${key}" has ${values.length} values`);
+    }
+    values = values.filter(
+      (entry) => typeof entry === "string" || entry.name !== "" || entry.size > 0
+    );
+    if (key.startsWith("n:")) {
+      key = key.slice(2);
+      values = values.map((v) => v === "" ? void 0 : parseFloat(
+        /** @type {string} */
+        v
+      ));
+    } else if (key.startsWith("b:")) {
+      key = key.slice(2);
+      values = values.map((v) => v === "on");
+    }
+    set_nested_value(result, key, is_array ? values : values[0]);
+  }
+  return result;
+}
+const BINARY_FORM_CONTENT_TYPE = "application/x-sveltekit-formdata";
+const BINARY_FORM_VERSION = 0;
+const HEADER_BYTES = 1 + 4 + 2;
+async function deserialize_binary_form(request) {
+  if (request.headers.get("content-type") !== BINARY_FORM_CONTENT_TYPE) {
+    const form_data = await request.formData();
+    return { data: convert_formdata(form_data), meta: {}, form_data };
+  }
+  if (!request.body) {
+    throw deserialize_error("no body");
+  }
+  const content_length = parseInt(request.headers.get("content-length") ?? "");
+  if (Number.isNaN(content_length)) {
+    throw deserialize_error("invalid Content-Length header");
+  }
+  const reader = request.body.getReader();
+  const chunks = [];
+  function get_chunk(index) {
+    if (index in chunks) return chunks[index];
+    let i = chunks.length;
+    while (i <= index) {
+      chunks[i] = reader.read().then((chunk) => chunk.value);
+      i++;
+    }
+    return chunks[index];
+  }
+  async function get_buffer(offset, length) {
+    let start_chunk;
+    let chunk_start = 0;
+    let chunk_index;
+    for (chunk_index = 0; ; chunk_index++) {
+      const chunk = await get_chunk(chunk_index);
+      if (!chunk) return null;
+      const chunk_end = chunk_start + chunk.byteLength;
+      if (offset >= chunk_start && offset < chunk_end) {
+        start_chunk = chunk;
+        break;
+      }
+      chunk_start = chunk_end;
+    }
+    if (offset + length <= chunk_start + start_chunk.byteLength) {
+      return start_chunk.subarray(offset - chunk_start, offset + length - chunk_start);
+    }
+    const chunks2 = [start_chunk.subarray(offset - chunk_start)];
+    let cursor = start_chunk.byteLength - offset + chunk_start;
+    while (cursor < length) {
+      chunk_index++;
+      let chunk = await get_chunk(chunk_index);
+      if (!chunk) return null;
+      if (chunk.byteLength > length - cursor) {
+        chunk = chunk.subarray(0, length - cursor);
+      }
+      chunks2.push(chunk);
+      cursor += chunk.byteLength;
+    }
+    const buffer = new Uint8Array(length);
+    cursor = 0;
+    for (const chunk of chunks2) {
+      buffer.set(chunk, cursor);
+      cursor += chunk.byteLength;
+    }
+    return buffer;
+  }
+  const header = await get_buffer(0, HEADER_BYTES);
+  if (!header) throw deserialize_error("too short");
+  if (header[0] !== BINARY_FORM_VERSION) {
+    throw deserialize_error(`got version ${header[0]}, expected version ${BINARY_FORM_VERSION}`);
+  }
+  const header_view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+  const data_length = header_view.getUint32(1, true);
+  if (HEADER_BYTES + data_length > content_length) {
+    throw deserialize_error("data overflow");
+  }
+  const file_offsets_length = header_view.getUint16(5, true);
+  if (HEADER_BYTES + data_length + file_offsets_length > content_length) {
+    throw deserialize_error("file offset table overflow");
+  }
+  const data_buffer = await get_buffer(HEADER_BYTES, data_length);
+  if (!data_buffer) throw deserialize_error("data too short");
+  let file_offsets;
+  let files_start_offset;
+  if (file_offsets_length > 0) {
+    const file_offsets_buffer = await get_buffer(HEADER_BYTES + data_length, file_offsets_length);
+    if (!file_offsets_buffer) throw deserialize_error("file offset table too short");
+    const parsed_offsets = JSON.parse(text_decoder.decode(file_offsets_buffer));
+    if (!Array.isArray(parsed_offsets) || parsed_offsets.some((n) => typeof n !== "number" || !Number.isInteger(n) || n < 0)) {
+      throw deserialize_error("invalid file offset table");
+    }
+    file_offsets = /** @type {Array<number>} */
+    parsed_offsets;
+    files_start_offset = HEADER_BYTES + data_length + file_offsets_length;
+  }
+  const file_spans = [];
+  const [data, meta] = parse(text_decoder.decode(data_buffer), {
+    File: ([name, type, size, last_modified, index]) => {
+      if (typeof name !== "string" || typeof type !== "string" || typeof size !== "number" || typeof last_modified !== "number" || typeof index !== "number") {
+        throw deserialize_error("invalid file metadata");
+      }
+      let offset = file_offsets[index];
+      if (offset === void 0) {
+        throw deserialize_error("duplicate file offset table index");
+      }
+      file_offsets[index] = void 0;
+      offset += files_start_offset;
+      if (offset + size > content_length) {
+        throw deserialize_error("file data overflow");
+      }
+      file_spans.push({ offset, size });
+      return new Proxy(new LazyFile(name, type, size, last_modified, get_chunk, offset), {
+        getPrototypeOf() {
+          return File.prototype;
+        }
+      });
+    }
+  });
+  file_spans.sort((a, b) => a.offset - b.offset || a.size - b.size);
+  for (let i = 1; i < file_spans.length; i++) {
+    const previous = file_spans[i - 1];
+    const current = file_spans[i];
+    const previous_end = previous.offset + previous.size;
+    if (previous_end < current.offset) {
+      throw deserialize_error("gaps in file data");
+    }
+    if (previous_end > current.offset) {
+      throw deserialize_error("overlapping file data");
+    }
+  }
+  void (async () => {
+    let has_more = true;
+    while (has_more) {
+      const chunk = await get_chunk(chunks.length);
+      has_more = !!chunk;
+    }
+  })();
+  return { data, meta, form_data: null };
+}
+function deserialize_error(message) {
+  return new SvelteKitError(400, "Bad Request", `Could not deserialize binary form: ${message}`);
+}
+class LazyFile {
+  /** @type {(index: number) => Promise<Uint8Array<ArrayBuffer> | undefined>} */
+  #get_chunk;
+  /** @type {number} */
+  #offset;
+  /**
+   * @param {string} name
+   * @param {string} type
+   * @param {number} size
+   * @param {number} last_modified
+   * @param {(index: number) => Promise<Uint8Array<ArrayBuffer> | undefined>} get_chunk
+   * @param {number} offset
+   */
+  constructor(name, type, size, last_modified, get_chunk, offset) {
+    this.name = name;
+    this.type = type;
+    this.size = size;
+    this.lastModified = last_modified;
+    this.webkitRelativePath = "";
+    this.#get_chunk = get_chunk;
+    this.#offset = offset;
+    this.arrayBuffer = this.arrayBuffer.bind(this);
+    this.bytes = this.bytes.bind(this);
+    this.slice = this.slice.bind(this);
+    this.stream = this.stream.bind(this);
+    this.text = this.text.bind(this);
+  }
+  /** @type {ArrayBuffer | undefined} */
+  #buffer;
+  async arrayBuffer() {
+    this.#buffer ??= await new Response(this.stream()).arrayBuffer();
+    return this.#buffer;
+  }
+  async bytes() {
+    return new Uint8Array(await this.arrayBuffer());
+  }
+  /**
+   * @param {number=} start
+   * @param {number=} end
+   * @param {string=} contentType
+   */
+  slice(start = 0, end = this.size, contentType = this.type) {
+    if (start < 0) {
+      start = Math.max(this.size + start, 0);
+    } else {
+      start = Math.min(start, this.size);
+    }
+    if (end < 0) {
+      end = Math.max(this.size + end, 0);
+    } else {
+      end = Math.min(end, this.size);
+    }
+    const size = Math.max(end - start, 0);
+    const file = new LazyFile(
+      this.name,
+      contentType,
+      size,
+      this.lastModified,
+      this.#get_chunk,
+      this.#offset + start
+    );
+    return file;
+  }
+  stream() {
+    let cursor = 0;
+    let chunk_index = 0;
+    return new ReadableStream({
+      start: async (controller) => {
+        let chunk_start = 0;
+        let start_chunk;
+        for (chunk_index = 0; ; chunk_index++) {
+          const chunk = await this.#get_chunk(chunk_index);
+          if (!chunk) return null;
+          const chunk_end = chunk_start + chunk.byteLength;
+          if (this.#offset >= chunk_start && this.#offset < chunk_end) {
+            start_chunk = chunk;
+            break;
+          }
+          chunk_start = chunk_end;
+        }
+        if (this.#offset + this.size <= chunk_start + start_chunk.byteLength) {
+          controller.enqueue(
+            start_chunk.subarray(this.#offset - chunk_start, this.#offset + this.size - chunk_start)
+          );
+          controller.close();
+        } else {
+          controller.enqueue(start_chunk.subarray(this.#offset - chunk_start));
+          cursor = start_chunk.byteLength - this.#offset + chunk_start;
+        }
+      },
+      pull: async (controller) => {
+        chunk_index++;
+        let chunk = await this.#get_chunk(chunk_index);
+        if (!chunk) {
+          controller.error("incomplete file data");
+          controller.close();
+          return;
+        }
+        if (chunk.byteLength > this.size - cursor) {
+          chunk = chunk.subarray(0, this.size - cursor);
+        }
+        controller.enqueue(chunk);
+        cursor += chunk.byteLength;
+        if (cursor >= this.size) {
+          controller.close();
+        }
+      }
+    });
+  }
+  async text() {
+    return text_decoder.decode(await this.arrayBuffer());
+  }
+}
+const path_regex = /^[a-zA-Z_$]\w*(\.[a-zA-Z_$]\w*|\[\d+\])*$/;
+function split_path(path) {
+  if (!path_regex.test(path)) {
+    throw new Error(`Invalid path ${path}`);
+  }
+  return path.split(/\.|\[|\]/).filter(Boolean);
+}
+function check_prototype_pollution(key) {
+  if (key === "__proto__" || key === "constructor" || key === "prototype") {
+    throw new Error(
+      `Invalid key "${key}"`
+    );
+  }
+}
+function deep_set(object, keys, value) {
+  let current = object;
+  for (let i = 0; i < keys.length - 1; i += 1) {
+    const key = keys[i];
+    check_prototype_pollution(key);
+    const is_array = /^\d+$/.test(keys[i + 1]);
+    const exists = Object.hasOwn(current, key);
+    const inner = current[key];
+    if (exists && is_array !== Array.isArray(inner)) {
+      throw new Error(`Invalid array key ${keys[i + 1]}`);
+    }
+    if (!exists) {
+      current[key] = is_array ? [] : {};
+    }
+    current = current[key];
+  }
+  const final_key = keys[keys.length - 1];
+  check_prototype_pollution(final_key);
+  current[final_key] = value;
+}
+function negotiate(accept, types) {
+  const parts = [];
+  accept.split(",").forEach((str, i) => {
+    const match = /([^/ \t]+)\/([^; \t]+)[ \t]*(?:;[ \t]*q=([0-9.]+))?/.exec(str);
+    if (match) {
+      const [, type, subtype, q = "1"] = match;
+      parts.push({ type, subtype, q: +q, i });
+    }
+  });
+  parts.sort((a, b) => {
+    if (a.q !== b.q) {
+      return b.q - a.q;
+    }
+    if (a.subtype === "*" !== (b.subtype === "*")) {
+      return a.subtype === "*" ? 1 : -1;
+    }
+    if (a.type === "*" !== (b.type === "*")) {
+      return a.type === "*" ? 1 : -1;
+    }
+    return a.i - b.i;
+  });
+  let accepted;
+  let min_priority = Infinity;
+  for (const mimetype of types) {
+    const [type, subtype] = mimetype.split("/");
+    const priority = parts.findIndex(
+      (part) => (part.type === type || part.type === "*") && (part.subtype === subtype || part.subtype === "*")
+    );
+    if (priority !== -1 && priority < min_priority) {
+      accepted = mimetype;
+      min_priority = priority;
+    }
+  }
+  return accepted;
+}
+function is_content_type(request, ...types) {
+  const type = request.headers.get("content-type")?.split(";", 1)[0].trim() ?? "";
+  return types.includes(type.toLowerCase());
+}
+function is_form_content_type(request) {
+  return is_content_type(
+    request,
+    "application/x-www-form-urlencoded",
+    "multipart/form-data",
+    "text/plain",
+    BINARY_FORM_CONTENT_TYPE
+  );
+}
+function coalesce_to_error(err) {
+  return err instanceof Error || err && /** @type {any} */
+  err.name && /** @type {any} */
+  err.message ? (
+    /** @type {Error} */
+    err
+  ) : new Error(JSON.stringify(err));
+}
+function normalize_error(error) {
+  return (
+    /** @type {import('../exports/internal/index.js').Redirect | HttpError | SvelteKitError | Error} */
+    error
+  );
+}
+function get_status(error) {
+  return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+}
+function get_message(error) {
+  return error instanceof SvelteKitError ? error.text : "Internal Error";
+}
+const escape_html_attr_dict = {
+  "&": "&amp;",
+  '"': "&quot;"
+  // Svelte also escapes < because the escape function could be called inside a `noscript` there
+  // https://github.com/sveltejs/svelte/security/advisories/GHSA-8266-84wp-wv5c
+  // However, that doesn't apply in SvelteKit
+};
+const escape_html_dict = {
+  "&": "&amp;",
+  "<": "&lt;"
+};
+const surrogates = (
+  // high surrogate without paired low surrogate
+  "[\\ud800-\\udbff](?![\\udc00-\\udfff])|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\udc00-\\udfff]"
+);
+const escape_html_attr_regex = new RegExp(
+  `[${Object.keys(escape_html_attr_dict).join("")}]|` + surrogates,
+  "g"
+);
+const escape_html_regex = new RegExp(
+  `[${Object.keys(escape_html_dict).join("")}]|` + surrogates,
+  "g"
+);
+function escape_html(str, is_attr) {
+  const dict = is_attr ? escape_html_attr_dict : escape_html_dict;
+  const escaped_str = str.replace(is_attr ? escape_html_attr_regex : escape_html_regex, (match) => {
+    if (match.length === 2) {
+      return match;
+    }
+    return dict[match] ?? `&#${match.charCodeAt(0)};`;
+  });
+  return escaped_str;
+}
+function method_not_allowed(mod, method) {
+  return text(`${method} method not allowed`, {
+    status: 405,
+    headers: {
+      // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405
+      // "The server must generate an Allow header field in a 405 status code response"
+      allow: allowed_methods(mod).join(", ")
+    }
+  });
+}
+function allowed_methods(mod) {
+  const allowed = ENDPOINT_METHODS.filter((method) => method in mod);
+  if ("GET" in mod && !("HEAD" in mod)) {
+    allowed.push("HEAD");
+  }
+  return allowed;
+}
+function get_global_name(options) {
+  return `__sveltekit_${options.version_hash}`;
+}
+function static_error_page(options, status, message) {
+  let page = options.templates.error({ status, message: escape_html(message) });
+  return text(page, {
+    headers: { "content-type": "text/html; charset=utf-8" },
+    status
+  });
+}
+async function handle_fatal_error(event, state, options, error) {
+  error = error instanceof HttpError ? error : coalesce_to_error(error);
+  const status = get_status(error);
+  const body = await handle_error_and_jsonify(event, state, options, error);
+  const type = negotiate(event.request.headers.get("accept") || "text/html", [
+    "application/json",
+    "text/html"
+  ]);
+  if (event.isDataRequest || type === "application/json") {
+    return json(body, {
+      status
+    });
+  }
+  return static_error_page(options, status, body.message);
+}
+async function handle_error_and_jsonify(event, state, options, error) {
+  if (error instanceof HttpError) {
+    return { message: "Unknown Error", ...error.body };
+  }
+  const status = get_status(error);
+  const message = get_message(error);
+  return await with_request_store(
+    { event, state },
+    () => options.hooks.handleError({ error, event, status, message })
+  ) ?? { message };
+}
+function redirect_response(status, location) {
+  const response = new Response(void 0, {
+    status,
+    headers: { location }
+  });
+  return response;
+}
+function clarify_devalue_error(event, error) {
+  if (error.path) {
+    return `Data returned from \`load\` while rendering ${event.route.id} is not serializable: ${error.message} (${error.path}). If you need to serialize/deserialize custom types, use transport hooks: https://svelte.dev/docs/kit/hooks#Universal-hooks-transport.`;
+  }
+  if (error.path === "") {
+    return `Data returned from \`load\` while rendering ${event.route.id} is not a plain object`;
+  }
+  return error.message;
+}
+function serialize_uses(node) {
+  const uses = {};
+  if (node.uses && node.uses.dependencies.size > 0) {
+    uses.dependencies = Array.from(node.uses.dependencies);
+  }
+  if (node.uses && node.uses.search_params.size > 0) {
+    uses.search_params = Array.from(node.uses.search_params);
+  }
+  if (node.uses && node.uses.params.size > 0) {
+    uses.params = Array.from(node.uses.params);
+  }
+  if (node.uses?.parent) uses.parent = 1;
+  if (node.uses?.route) uses.route = 1;
+  if (node.uses?.url) uses.url = 1;
+  return uses;
+}
+function has_prerendered_path(manifest, pathname) {
+  return manifest._.prerendered_routes.has(pathname) || pathname.at(-1) === "/" && manifest._.prerendered_routes.has(pathname.slice(0, -1));
+}
+function format_server_error(status, error, event) {
+  const formatted_text = `
+\x1B[1;31m[${status}] ${event.request.method} ${event.url.pathname}\x1B[0m`;
+  if (status === 404) {
+    return formatted_text;
+  }
+  return `${formatted_text}
+${error.stack}`;
+}
+function get_node_type(node_id) {
+  const parts = node_id?.split("/");
+  const filename = parts?.at(-1);
+  if (!filename) return "unknown";
+  const dot_parts = filename.split(".");
+  return dot_parts.slice(0, -1).join(".");
+}
+const INVALIDATED_PARAM = "x-sveltekit-invalidated";
+const TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
+function stringify(data, transport) {
+  const encoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode]));
+  return stringify$1(data, encoders);
+}
+const remote_object = "__skrao";
+const remote_map = "__skram";
+const remote_set = "__skras";
+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;
+    }
+  };
+  const user_revivers = Object.fromEntries(
+    Object.entries(transport).map(([k, v]) => [k, v.decode])
+  );
+  const all_revivers = { ...user_revivers, ...remote_fns_revivers };
+  const parse$1 = (data) => parse(data, all_revivers);
+  return all_revivers;
+}
+function parse_remote_arg(string, transport) {
+  if (!string) return void 0;
+  const json_string = text_decoder.decode(
+    // no need to add back `=` characters, atob can handle it
+    base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))
+  );
+  return parse(json_string, create_remote_arg_revivers(transport));
+}
+function create_remote_key(id, payload) {
+  return id + "/" + payload;
+}
+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 { ActionFailure as A, split_remote_key as B, isRedirect as C, SVELTE_KIT_ASSETS as D, ENDPOINT_METHODS as E, HttpError as H, INVALIDATED_PARAM as I, PAGE_METHODS as P, Redirect as R, SvelteKitError as S, TRAILING_SLASH_PARAM as T, handle_fatal_error as a, method_not_allowed as b, create_remote_key as c, clarify_devalue_error as d, handle_error_and_jsonify as e, format_server_error as f, get_global_name as g, has_prerendered_path as h, is_form_content_type as i, json as j, get_status as k, normalize_error as l, merge_tracing as m, negotiate as n, static_error_page as o, error as p, parse_remote_arg as q, redirect_response as r, serialize_uses as s, text as t, stringify as u, deserialize_binary_form as v, with_request_store as w, get_node_type as x, stringify$1 as y, escape_html as z };
+//# sourceMappingURL=shared.js-DuDDTJVi.js.map