@nanoforge-dev/editor 0.0.1

package/dist/server/chunks/hooks.server-DqaQ1y1I.js

@@ -0,0 +1,858 @@
+import { a as __commonJSMin, i as with_request_store, n as get_request_store, s as __toESM, t as merge_tracing } from "./server-BlOy0jJl.js";
+import { t as private_env } from "./shared-server-D--cyMsO.js";
+import { a as redirect } from "./exports-j3HcL9It.js";
+import { a as serverAsyncLocalStorage, i as overwriteServerAsyncLocalStorage, n as getStrategyForUrl, o as shouldRedirect, r as isExcludedByRouteStrategy, t as deLocalizeUrl } from "./runtime-ISoc6PNh.js";
+import * as crypto$1 from "node:crypto";
+//#region node_modules/.pnpm/@sveltejs+kit@2.57.1_@sveltejs+vite-plugin-svelte@7.0.0_svelte@5.55.3_@typescript-eslin_c09159cb6a183c6624321f87d00b2d27/node_modules/@sveltejs/kit/src/exports/hooks/sequence.js
+/** @import { Handle, RequestEvent, ResolveOptions } from '@sveltejs/kit' */
+/** @import { MaybePromise } from 'types' */
+/**
+* A helper function for sequencing multiple `handle` calls in a middleware-like manner.
+* The behavior for the `handle` options is as follows:
+* - `transformPageChunk` is applied in reverse order and merged
+* - `preload` is applied in forward order, the first option "wins" and no `preload` options after it are called
+* - `filterSerializedResponseHeaders` behaves the same as `preload`
+*
+* ```js
+* /// file: src/hooks.server.js
+* import { sequence } from '@sveltejs/kit/hooks';
+*
+* /// type: import('@sveltejs/kit').Handle
+* async function first({ event, resolve }) {
+* 	console.log('first pre-processing');
+* 	const result = await resolve(event, {
+* 		transformPageChunk: ({ html }) => {
+* 			// transforms are applied in reverse order
+* 			console.log('first transform');
+* 			return html;
+* 		},
+* 		preload: () => {
+* 			// this one wins as it's the first defined in the chain
+* 			console.log('first preload');
+* 			return true;
+* 		}
+* 	});
+* 	console.log('first post-processing');
+* 	return result;
+* }
+*
+* /// type: import('@sveltejs/kit').Handle
+* async function second({ event, resolve }) {
+* 	console.log('second pre-processing');
+* 	const result = await resolve(event, {
+* 		transformPageChunk: ({ html }) => {
+* 			console.log('second transform');
+* 			return html;
+* 		},
+* 		preload: () => {
+* 			console.log('second preload');
+* 			return true;
+* 		},
+* 		filterSerializedResponseHeaders: () => {
+* 			// this one wins as it's the first defined in the chain
+* 			console.log('second filterSerializedResponseHeaders');
+* 			return true;
+* 		}
+* 	});
+* 	console.log('second post-processing');
+* 	return result;
+* }
+*
+* export const handle = sequence(first, second);
+* ```
+*
+* The example above would print:
+*
+* ```
+* first pre-processing
+* first preload
+* second pre-processing
+* second filterSerializedResponseHeaders
+* second transform
+* first transform
+* second post-processing
+* first post-processing
+* ```
+*
+* @param {...Handle} handlers The chain of `handle` functions
+* @returns {Handle}
+*/
+function sequence(...handlers) {
+	const length = handlers.length;
+	if (!length) return ({ event, resolve }) => resolve(event);
+	return ({ event, resolve }) => {
+		const { state } = get_request_store();
+		return apply_handle(0, event, {});
+		/**
+		* @param {number} i
+		* @param {RequestEvent} event
+		* @param {ResolveOptions | undefined} parent_options
+		* @returns {MaybePromise<Response>}
+		*/
+		function apply_handle(i, event, parent_options) {
+			const handle = handlers[i];
+			return state.tracing.record_span({
+				name: `sveltekit.handle.sequenced.${handle.name ? handle.name : i}`,
+				attributes: {},
+				fn: async (current) => {
+					const traced_event = merge_tracing(event, current);
+					return await with_request_store({
+						event: traced_event,
+						state
+					}, () => handle({
+						event: traced_event,
+						resolve: (event, options) => {
+							/** @type {ResolveOptions['transformPageChunk']} */
+							const transformPageChunk = async ({ html, done }) => {
+								if (options?.transformPageChunk) html = await options.transformPageChunk({
+									html,
+									done
+								}) ?? "";
+								if (parent_options?.transformPageChunk) html = await parent_options.transformPageChunk({
+									html,
+									done
+								}) ?? "";
+								return html;
+							};
+							/** @type {ResolveOptions['filterSerializedResponseHeaders']} */
+							const filterSerializedResponseHeaders = parent_options?.filterSerializedResponseHeaders ?? options?.filterSerializedResponseHeaders;
+							/** @type {ResolveOptions['preload']} */
+							const preload = parent_options?.preload ?? options?.preload;
+							return i < length - 1 ? apply_handle(i + 1, event, {
+								transformPageChunk,
+								filterSerializedResponseHeaders,
+								preload
+							}) : resolve(event, {
+								transformPageChunk,
+								filterSerializedResponseHeaders,
+								preload
+							});
+						}
+					}));
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region .svelte-kit/adapter-bun/entries/hooks.server.js
+/**
+* Server middleware that handles locale-based routing and request processing.
+*
+* Configure `disableAsyncLocalStorage` when generating Paraglide with
+* `paraglideVitePlugin()` or `compile()`, not when calling
+* `paraglideMiddleware()`. Keep AsyncLocalStorage enabled by default and
+* only disable it for runtimes that lack `AsyncLocalStorage` support and
+* guarantee request isolation.
+*
+* This middleware performs several key functions:
+*
+* 1. Determines the locale for the incoming request using configured strategies
+* 2. Handles URL localization and redirects (only for document requests)
+* 3. Maintains locale state using AsyncLocalStorage to prevent request interference
+*
+* When URL strategy is used:
+*
+* - The locale is extracted from the URL for all request types
+* - If URL doesn't match the determined locale, redirects to localized URL (only for document requests)
+* - De-localizes URLs before passing to server (e.g., `/fr/about` → `/about`)
+*
+* @see https://inlang.com/m/gerre34r/library-inlang-paraglideJs/middleware
+*
+* @template T - The return type of the resolve function
+*
+* @param {Request} request - The incoming request object
+* @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request. The callback receives:
+*   - `request`: A modified request with a delocalized URL when the URL strategy is used (e.g., `/fr/about` → `/about`).
+*      If your framework handles URL localization itself (e.g., TanStack Router's `rewrite` option), use the original
+*      request instead to avoid redirect loops.
+*   - `locale`: The determined locale for this request.
+* @param {{
+*   effectiveRequestUrl?: string | URL | ((request: Request) => string | URL),
+*   onRedirect?: (response: Response) => void
+* }} [options] - Options to control middleware behavior. `effectiveRequestUrl` sets the effective request URL used for route matching, URL-based locale detection, redirects, and `getUrlOrigin()`.
+* @returns {Promise<Response>}
+*
+* @example
+* ```typescript
+* // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
+* export const handle = async ({ event, resolve }) => {
+*   return paraglideMiddleware(event.request, ({ request, locale }) => {
+*     // let the framework further resolve the request
+*     return resolve(request);
+*   });
+* };
+* ```
+*
+* @example
+* ```typescript
+* // Usage in a framework like Express JS or Hono
+* app.use(async (req, res, next) => {
+*   const result = await paraglideMiddleware(req, ({ request, locale }) => {
+*     // If a redirect happens this won't be called
+*     return next(request);
+*   });
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Usage with frameworks that handle URL localization/delocalization themselves
+* //
+* // Some frameworks like TanStack Router handle URL localization and delocalization
+* // themselves via their own rewrite APIs (e.g., `rewrite.input`/`rewrite.output`).
+* //
+* // When the framework handles this, the middleware's URL delocalization is not needed.
+* // Using the modified `request` from the callback would cause a redirect loop because
+* // both the middleware and the framework would attempt to delocalize the URL.
+* //
+* // Solution: Pass the original request to the handler instead of the modified one.
+* // The middleware still handles locale detection, cookies, and AsyncLocalStorage context.
+* //
+* // ❌ WRONG - causes redirect loop when framework handles URL rewriting:
+* // paraglideMiddleware(req, ({ request }) => handler.fetch(request))
+* //
+* // ✅ CORRECT - use original request when framework handles URL localization:
+* // paraglideMiddleware(req, () => handler.fetch(req))
+*
+* * *
+* export default {
+*   fetch(req: Request): Promise<Response> {
+*     // TanStack Router handles URL rewriting via deLocalizeUrl/localizeUrl
+*     // so we pass the original `req` instead of the modified `request`
+*     return paraglideMiddleware(req, () => handler.fetch(req))
+*   },
+* }
+* ```
+*/
+async function paraglideMiddleware(request, resolve, options) {
+	if (!serverAsyncLocalStorage) {
+		const { AsyncLocalStorage } = await import("async_hooks");
+		overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
+	} else if (!serverAsyncLocalStorage) overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
+	const url = resolveMiddlewareUrl(request, options?.effectiveRequestUrl);
+	const origin = url.origin;
+	if (isExcludedByRouteStrategy(url.href)) {
+		const locale = "en";
+		const newRequest = cloneRequestWithFallback(request, url);
+		/** @type {Set<string>} */
+		const messageCalls = /* @__PURE__ */ new Set();
+		return await serverAsyncLocalStorage?.run({
+			locale,
+			origin,
+			messageCalls
+		}, () => resolve({
+			locale,
+			request: newRequest
+		}));
+	}
+	const strategy = getStrategyForUrl(url.href);
+	const decision = await shouldRedirect({
+		request,
+		effectiveRequestUrl: url
+	});
+	const locale = decision.locale;
+	if (request.headers.get("Sec-Fetch-Dest") === "document" && decision.shouldRedirect && decision.redirectUrl) {
+		/** @type {Record<string, string>} */
+		const headers = {};
+		if (strategy.includes("preferredLanguage")) headers["Vary"] = "Accept-Language";
+		const response = new Response(null, {
+			status: 307,
+			headers: {
+				Location: decision.redirectUrl.href,
+				...headers
+			}
+		});
+		options?.onRedirect?.(response);
+		return response;
+	}
+	let newRequest;
+	if (strategy.includes("url")) newRequest = cloneRequestWithFallback(request, deLocalizeUrl(url));
+	else newRequest = cloneRequestWithFallback(request, url);
+	/** @type {Set<string>} */
+	const messageCalls = /* @__PURE__ */ new Set();
+	return await serverAsyncLocalStorage?.run({
+		locale,
+		origin,
+		messageCalls
+	}, () => resolve({
+		locale,
+		request: newRequest
+	}));
+}
+/**
+* @param {Request} request
+* @param {string | URL | ((request: Request) => string | URL) | undefined} effectiveRequestUrl
+* @returns {URL}
+*/
+function resolveMiddlewareUrl(request, effectiveRequestUrl) {
+	if (typeof effectiveRequestUrl === "function") return new URL(effectiveRequestUrl(request), request.url);
+	if (typeof effectiveRequestUrl === "string" || effectiveRequestUrl instanceof URL) return new URL(effectiveRequestUrl, request.url);
+	return new URL(request.url);
+}
+/**
+* Some metaframeworks (NextJS) require a new Request object.
+* https://github.com/opral/inlang-paraglide-js/issues/411
+*
+* However, some frameworks (TanStack Start 1.143+) use custom Request
+* implementations that cannot be cloned with `new Request(request)`.
+* https://github.com/opral/paraglide-js/issues/573
+*
+* Effective request URL overrides behind proxies:
+* https://github.com/opral/paraglide-js/issues/652
+*
+* @param {Request} request
+* @param {string | URL} [url]
+* @returns {Request}
+*/
+function cloneRequestWithFallback(request, url = request.url) {
+	const targetUrl = typeof url === "string" ? url : url.href;
+	if (targetUrl === request.url) try {
+		return new Request(request.clone());
+	} catch {
+		try {
+			return new Request(request);
+		} catch {
+			return request;
+		}
+	}
+	try {
+		return new Request(targetUrl, request.clone());
+	} catch {
+		try {
+			return new Request(targetUrl, request);
+		} catch {
+			return request;
+		}
+	}
+}
+/**
+* Creates a mock AsyncLocalStorage implementation for environments where
+* native AsyncLocalStorage is not available or disabled.
+*
+* This mock implementation mimics the behavior of the native AsyncLocalStorage
+* but doesn't require the async_hooks module. It's used as a fallback when
+* the runtime does not expose AsyncLocalStorage or when it has been disabled.
+*
+* @returns {import("./runtime.js").ParaglideAsyncLocalStorage}
+*/
+function createMockAsyncLocalStorage() {
+	/** @type {any} */
+	let currentStore = void 0;
+	return {
+		getStore() {
+			return currentStore;
+		},
+		async run(store, callback) {
+			currentStore = store;
+			try {
+				return await callback();
+			} finally {
+				currentStore = void 0;
+			}
+		}
+	};
+}
+/**
+* Cookie signing and unsigning.
+*
+* Implemented with web crypto instead of Node.js crypto
+* to work in Edge environments such as Cloudflare Worker.
+*/
+/**
+* Convert a string to an ArrayBuffer
+*
+* @param {string} str string to convert to ArrayBuffer (should be the session id)
+* @return {ArrayBuffer} buffer
+*/
+function str2ab(str) {
+	const buffer = new Uint8Array(str.length);
+	for (let i = 0; i < str.length; i += 1) buffer[i] = str.charCodeAt(i);
+	return buffer;
+}
+/**
+* Sign the given `val` with `secret`.
+* The `secret` is a secret key to sign the cookie with.
+* This is used to detect tampering the cookie later.
+*
+* The `secret` can be a string or an array of strings.
+* If an array of strings is provided, only the first element will be used to sign the cookie,
+*   but all the elements will be used to unsign the cookie.
+*
+* @param {string} val Cookie value to sign (should be the session id)
+* @param {string | string[]} secret Secret string to sign with
+* @return {Promise<string>} Signed cookie in the form of `<val>.<signature>` where `<signature>` is a base64 encoded HMAC SHA256 signature
+*/
+async function sign(val, secret) {
+	const keyData = str2ab(typeof secret === "string" ? secret : secret[0]);
+	const key = await crypto.subtle.importKey("raw", keyData, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const signature = await crypto.subtle.sign("HMAC", key, str2ab(val));
+	return `${val}.${btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(signature)))).replace(/=+$/, "")}`;
+}
+/**
+* Unsign and decode the given `input` with `secret`,
+*   returning `false` if the signature is invalid.
+*
+* The `secret` can be a string or an array of strings.
+* If an array of strings is provided, only the first element will be used to sign the cookie,
+*   but all the elements will be used to unsign the cookie.
+*
+* @param {string} input Signed cookie to unsign
+* @param {string | string[]} secret Secret to sign with (should be the same as the one used to sign)
+* @return {Promise<string | null>} Unsigned cookie or `null` if signature is invalid
+*/
+async function unsign(input, secret) {
+	const tentativeValue = input.slice(0, input.lastIndexOf("."));
+	if (typeof secret === "string") return await sign(tentativeValue, secret) === input ? tentativeValue : null;
+	return (await Promise.all(secret.map(async (v) => {
+		return await sign(tentativeValue, v) === input ? tentativeValue : null;
+	}))).find((v) => v !== null) || null;
+}
+/**
+* https://github.com/crypto-utils/uid-safe/tree/master
+*
+* Implemented with web crypto instead of Node.js crypto to work in Edge environments such as Cloudflare Worker.
+*/
+/**
+* Generate a buffer with secure random bytes. *
+* @param size The number of bytes to generate
+* @returns buffer with secure random bytes
+*/
+var randomBytes = (size) => {
+	if (size < 0) throw new RangeError("argument size must not be negative");
+	return crypto.getRandomValues(new Uint8Array(size));
+};
+var EQUAL_END_REGEXP = /=+$/;
+var PLUS_GLOBAL_REGEXP = /\+/g;
+var SLASH_GLOBAL_REGEXP = /\//g;
+var toString = (buf) => {
+	return btoa(String.fromCharCode.apply(null, buf)).replace(EQUAL_END_REGEXP, "").replace(PLUS_GLOBAL_REGEXP, "-").replace(SLASH_GLOBAL_REGEXP, "_");
+};
+/**
+* Generate a UID with the given length.
+* @param length The number of bytes to generate
+* @returns UID(base64 string)
+*/
+var uidSync = (length) => toString(randomBytes(length));
+/**
+* Generate a session ID.
+* @returns {string} session ID(base64 string)
+*/
+var generateSessionId = () => uidSync(24);
+/**
+* Get default cookie options.
+* @returns {CookieSerializeOptions & { path: string }} default cookie options
+*/
+var defaultCookieOptions = () => ({ path: "/" });
+/**
+* Get the TTL in milliseconds for the given cookie options.
+* If `expires` and `maxAge` are set, then `maxAge` takes precedence.
+* See *Note* below for details.
+*
+* *Note* the {@link https://tools.ietf.org/html/rfc6265#section-5.3|cookie storage model specification}
+* states that if both `expires` and `maxAge` are set, then `maxAge` takes precedence, but it is
+* possible not all clients by obey this, so if both are set, they should
+* point to the same date and time.
+*/
+var getTtlMs = (cookie) => {
+	const { expires, maxAge } = cookie;
+	if (maxAge) return maxAge * 1e3;
+	if (expires) {
+		const ms = new Date(expires).getTime() - Date.now();
+		return Math.ceil(ms / 1e3) * 1e3;
+	}
+	return Infinity;
+};
+/**
+* Parse session cookie options.
+* @param {SveltekitSessionConfig} options session options
+* @param {SessionCookieOptions} cookieOptions session cookie options
+* @returns {CookieSerializeOptions & { path: string }} cookie options
+*/
+var parseSessionCookieOptions = (options, cookieOptions) => {
+	const cookie = { ...cookieOptions };
+	if (options.cookie && options.cookie.encode) cookie.encode = (value) => options.cookie.encode(value);
+	if (cookie.expires) cookie.expires = new Date(cookie.expires);
+	return cookie;
+};
+var Session = class Session {
+	constructor(event, options) {
+		this.#id = generateSessionId();
+		this.#cookieName = options.name || "connect.sid";
+		this.#cookie = {
+			...defaultCookieOptions(),
+			...options.cookie
+		};
+		this.#sessionOptions = options;
+		this.#event = event;
+		this.#storeTtlMs = getTtlMs(options.cookie || {});
+	}
+	static async initialize(event, options) {
+		const session = new Session(event, options);
+		const { cookies } = session.#event;
+		const { secret, store, rolling, saveUninitialized } = session.#sessionOptions;
+		const unsignedSid = await unsign(cookies.get(session.#cookieName) || "", secret);
+		if (unsignedSid) {
+			const sessionData = await store.get(unsignedSid);
+			if (sessionData) {
+				session.#id = unsignedSid;
+				session.#cookie = parseSessionCookieOptions(options, sessionData.cookie);
+				session.#data = sessionData.data;
+				session.#storeTtlMs = getTtlMs(sessionData.cookie);
+				if (session.#cookie.maxAge && rolling) {
+					await store.touch(session.#id, session.#cookie.maxAge * 1e3);
+					cookies.set(session.#cookieName, await sign(session.#id, secret), session.#cookie);
+				}
+				return session;
+			}
+		}
+		if (saveUninitialized) {
+			await store.set(session.#id, {
+				cookie: session.#getParsableCookieOptions(),
+				data: session.#data
+			}, session.#storeTtlMs);
+			cookies.set(session.#cookieName, await sign(session.#id, secret), session.#cookie);
+		}
+		return session;
+	}
+	#id;
+	#cookieName;
+	#cookie;
+	#data = {};
+	#sessionOptions;
+	#event;
+	/**
+	* ttl time(milliseconds) for session store.
+	*/
+	#storeTtlMs;
+	/**
+	* Session ID.
+	*/
+	get id() {
+		return this.#id;
+	}
+	/**
+	* Session cookie name.
+	*/
+	get cookieName() {
+		return this.#cookieName;
+	}
+	/**
+	* Session cookie options.
+	*/
+	get cookie() {
+		return this.#cookie;
+	}
+	/**
+	* Session data.
+	*/
+	get data() {
+		return this.#data;
+	}
+	/**
+	* Session store instance.
+	*/
+	get store() {
+		return this.#sessionOptions.store;
+	}
+	#getParsableCookieOptions() {
+		const cookie = { ...this.#cookie };
+		if (cookie.encode) delete cookie.encode;
+		return cookie;
+	}
+	/**
+	* Set data in the session.
+	*
+	* If `saveUninitialized` is `true`, the session is saved without calling `save()`.
+	* Conversely, if `saveUninitialized` is `false`, call `save()` to explicitly save the session.
+	*/
+	async setData(data) {
+		this.#data = data;
+		if (this.#sessionOptions.saveUninitialized) await this.store.set(this.id, {
+			cookie: this.#getParsableCookieOptions(),
+			data: this.#data
+		}, this.#storeTtlMs);
+	}
+	/**
+	* Save the session (save session to store) and set cookie.
+	*/
+	async save() {
+		await this.#sessionOptions.store.set(this.id, {
+			cookie: this.#getParsableCookieOptions(),
+			data: this.#data
+		}, this.#storeTtlMs);
+		this.#event.cookies.set(this.#cookieName, await sign(this.#id, this.#sessionOptions.secret), this.#cookie);
+	}
+	/**
+	* Regenerate the session simply invoke the method.
+	* Once complete, a new Session and `Session` instance will be initialized.
+	*/
+	async regenerate() {
+		await this.destroy();
+		return new Session(this.#event, this.#sessionOptions);
+	}
+	/**
+	* Destroy the session.
+	*/
+	async destroy() {
+		await this.#sessionOptions.store.destroy(this.#id);
+		this.#event.cookies.delete(this.#cookieName, { ...this.#cookie });
+	}
+};
+var import_ttlcache = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/* istanbul ignore next */
+	var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+	var now = () => perf.now();
+	var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+	var isPosIntOrInf = (n) => n === Infinity || isPosInt(n);
+	module.exports = class TTLCache {
+		constructor({ max = Infinity, ttl, updateAgeOnGet = false, checkAgeOnGet = false, noUpdateTTL = false, dispose, noDisposeOnSet = false } = {}) {
+			this.expirations = Object.create(null);
+			this.data = /* @__PURE__ */ new Map();
+			this.expirationMap = /* @__PURE__ */ new Map();
+			if (ttl !== void 0 && !isPosIntOrInf(ttl)) throw new TypeError("ttl must be positive integer or Infinity if set");
+			if (!isPosIntOrInf(max)) throw new TypeError("max must be positive integer or Infinity");
+			this.ttl = ttl;
+			this.max = max;
+			this.updateAgeOnGet = !!updateAgeOnGet;
+			this.checkAgeOnGet = !!checkAgeOnGet;
+			this.noUpdateTTL = !!noUpdateTTL;
+			this.noDisposeOnSet = !!noDisposeOnSet;
+			if (dispose !== void 0) {
+				if (typeof dispose !== "function") throw new TypeError("dispose must be function if set");
+				this.dispose = dispose;
+			}
+			this.timer = void 0;
+			this.timerExpiration = void 0;
+		}
+		setTimer(expiration, ttl) {
+			if (this.timerExpiration < expiration) return;
+			if (this.timer) clearTimeout(this.timer);
+			const t = setTimeout(() => {
+				this.timer = void 0;
+				this.timerExpiration = void 0;
+				this.purgeStale();
+				for (const exp in this.expirations) {
+					this.setTimer(exp, exp - now());
+					break;
+				}
+			}, ttl);
+			/* istanbul ignore else - affordance for non-node envs */
+			if (t.unref) t.unref();
+			this.timerExpiration = expiration;
+			this.timer = t;
+		}
+		cancelTimer() {
+			if (this.timer) {
+				clearTimeout(this.timer);
+				this.timerExpiration = void 0;
+				this.timer = void 0;
+			}
+		}
+		/* istanbul ignore next */
+		cancelTimers() {
+			process.emitWarning("TTLCache.cancelTimers has been renamed to TTLCache.cancelTimer (no \"s\"), and will be removed in the next major version update");
+			return this.cancelTimer();
+		}
+		clear() {
+			const entries = this.dispose !== TTLCache.prototype.dispose ? [...this] : [];
+			this.data.clear();
+			this.expirationMap.clear();
+			this.cancelTimer();
+			this.expirations = Object.create(null);
+			for (const [key, val] of entries) this.dispose(val, key, "delete");
+		}
+		setTTL(key, ttl = this.ttl) {
+			const current = this.expirationMap.get(key);
+			if (current !== void 0) {
+				const exp = this.expirations[current];
+				if (!exp || exp.length <= 1) delete this.expirations[current];
+				else this.expirations[current] = exp.filter((k) => k !== key);
+			}
+			if (ttl !== Infinity) {
+				const expiration = Math.floor(now() + ttl);
+				this.expirationMap.set(key, expiration);
+				if (!this.expirations[expiration]) {
+					this.expirations[expiration] = [];
+					this.setTimer(expiration, ttl);
+				}
+				this.expirations[expiration].push(key);
+			} else this.expirationMap.set(key, Infinity);
+		}
+		set(key, val, { ttl = this.ttl, noUpdateTTL = this.noUpdateTTL, noDisposeOnSet = this.noDisposeOnSet } = {}) {
+			if (!isPosIntOrInf(ttl)) throw new TypeError("ttl must be positive integer or Infinity");
+			if (this.expirationMap.has(key)) {
+				if (!noUpdateTTL) this.setTTL(key, ttl);
+				const oldValue = this.data.get(key);
+				if (oldValue !== val) {
+					this.data.set(key, val);
+					if (!noDisposeOnSet) this.dispose(oldValue, key, "set");
+				}
+			} else {
+				this.setTTL(key, ttl);
+				this.data.set(key, val);
+			}
+			while (this.size > this.max) this.purgeToCapacity();
+			return this;
+		}
+		has(key) {
+			return this.data.has(key);
+		}
+		getRemainingTTL(key) {
+			const expiration = this.expirationMap.get(key);
+			return expiration === Infinity ? expiration : expiration !== void 0 ? Math.max(0, Math.ceil(expiration - now())) : 0;
+		}
+		get(key, { updateAgeOnGet = this.updateAgeOnGet, ttl = this.ttl, checkAgeOnGet = this.checkAgeOnGet } = {}) {
+			const val = this.data.get(key);
+			if (checkAgeOnGet && this.getRemainingTTL(key) === 0) {
+				this.delete(key);
+				return;
+			}
+			if (updateAgeOnGet) this.setTTL(key, ttl);
+			return val;
+		}
+		dispose(_, __) {}
+		delete(key) {
+			const current = this.expirationMap.get(key);
+			if (current !== void 0) {
+				const value = this.data.get(key);
+				this.data.delete(key);
+				this.expirationMap.delete(key);
+				const exp = this.expirations[current];
+				if (exp) if (exp.length <= 1) delete this.expirations[current];
+				else this.expirations[current] = exp.filter((k) => k !== key);
+				this.dispose(value, key, "delete");
+				if (this.size === 0) this.cancelTimer();
+				return true;
+			}
+			return false;
+		}
+		purgeToCapacity() {
+			for (const exp in this.expirations) {
+				const keys = this.expirations[exp];
+				if (this.size - keys.length >= this.max) {
+					delete this.expirations[exp];
+					const entries = [];
+					for (const key of keys) {
+						entries.push([key, this.data.get(key)]);
+						this.data.delete(key);
+						this.expirationMap.delete(key);
+					}
+					for (const [key, val] of entries) this.dispose(val, key, "evict");
+				} else {
+					const s = this.size - this.max;
+					const entries = [];
+					for (const key of keys.splice(0, s)) {
+						entries.push([key, this.data.get(key)]);
+						this.data.delete(key);
+						this.expirationMap.delete(key);
+					}
+					for (const [key, val] of entries) this.dispose(val, key, "evict");
+					return;
+				}
+			}
+		}
+		get size() {
+			return this.data.size;
+		}
+		purgeStale() {
+			const n = Math.ceil(now());
+			for (const exp in this.expirations) {
+				if (exp === "Infinity" || exp > n) return;
+				/* istanbul ignore next
+				* mysterious need for a guard here?
+				* https://github.com/isaacs/ttlcache/issues/26 */
+				const keys = [...this.expirations[exp] || []];
+				const entries = [];
+				delete this.expirations[exp];
+				for (const key of keys) {
+					entries.push([key, this.data.get(key)]);
+					this.data.delete(key);
+					this.expirationMap.delete(key);
+				}
+				for (const [key, val] of entries) this.dispose(val, key, "stale");
+			}
+			if (this.size === 0) this.cancelTimer();
+		}
+		*entries() {
+			for (const exp in this.expirations) for (const key of this.expirations[exp]) yield [key, this.data.get(key)];
+		}
+		*keys() {
+			for (const exp in this.expirations) for (const key of this.expirations[exp]) yield key;
+		}
+		*values() {
+			for (const exp in this.expirations) for (const key of this.expirations[exp]) yield this.data.get(key);
+		}
+		[Symbol.iterator]() {
+			return this.entries();
+		}
+	};
+})))(), 1);
+var ONE_DAY_IN_SECONDS = 86400;
+var MemoryStore = class {
+	#sessions = new import_ttlcache.default();
+	#prefix;
+	#serializer;
+	/**
+	* Time to live in milliseconds.
+	* default: 86400 * 1000
+	*/
+	#ttl;
+	constructor(options) {
+		this.#prefix = options?.prefix || "";
+		this.#serializer = options?.serializer || JSON;
+		this.#ttl = options?.ttl || ONE_DAY_IN_SECONDS * 1e3;
+	}
+	async get(id) {
+		const key = this.#prefix + id;
+		const storeData = this.#sessions.get(key);
+		return storeData ? this.#serializer.parse(storeData) : null;
+	}
+	async set(id, storeData, ttl) {
+		const key = this.#prefix + id;
+		const serialized = this.#serializer.stringify(storeData);
+		if (ttl !== Infinity) {
+			this.#sessions.set(key, serialized, { ttl });
+			return;
+		}
+		this.#sessions.set(key, serialized, { ttl: this.#ttl });
+	}
+	async destroy(id) {
+		const key = this.#prefix + id;
+		this.#sessions.delete(key);
+	}
+	async touch(id, ttl) {
+		const key = this.#prefix + id;
+		this.#sessions.setTTL(key, ttl);
+	}
+};
+var memoryStore = new MemoryStore();
+var sveltekitSessionHandle = (options) => async ({ event, resolve }) => {
+	const { locals } = event;
+	locals.session = await Session.initialize({ cookies: event.cookies }, {
+		store: memoryStore,
+		...options
+	});
+	return await resolve(event);
+};
+if (!private_env.SESSION_SECRET) {
+	private_env.SESSION_SECRET = crypto$1.randomBytes(20).toString("hex");
+	console.log(`SESSION_SECRET not found, generating a temporary one: ${private_env.SESSION_SECRET}`);
+}
+var sessionHandle = sveltekitSessionHandle({ secret: private_env.SESSION_SECRET });
+var checkAuthorizationHandle = async ({ event, resolve }) => {
+	if (!event.locals.session.data.path && event.url.pathname !== "/load-project" && event.url.pathname + event.url.search !== "/cli?/createProject") throw redirect(302, "/load-project");
+	return resolve(event);
+};
+var handleParaglide = ({ event, resolve }) => paraglideMiddleware(event.request, ({ request, locale }) => {
+	event.request = request;
+	return resolve(event, { transformPageChunk: ({ html }) => html.replace("%paraglide.lang%", locale) });
+});
+var handle = sequence(sessionHandle, handleParaglide, checkAuthorizationHandle);
+//#endregion
+export { handle };
+
+//# sourceMappingURL=hooks.server-DqaQ1y1I.js.map