@turnipxenon/pineapple 5.3.15 → 5.3.17

package/dist/external/paraglide/server.d.ts

@@ -1,6 +1,12 @@
 /**
  * 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
@@ -13,18 +19,27 @@
  * - 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://paraglidejs.com/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
- * @param {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
+ * @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 serverMiddleware(event.request, ({ request, locale }) => {
+ *   return paraglideMiddleware(event.request, ({ request, locale }) => {
  *     // let the framework further resolve the request
  *     return resolve(request);
  *   });
@@ -35,7 +50,7 @@
  * ```typescript
  * // Usage in a framework like Express JS or Hono
  * app.use(async (req, res, next) => {
- *   const result = await serverMiddleware(req, ({ request, locale }) => {
+ *   const result = await paraglideMiddleware(req, ({ request, locale }) => {
  *     // If a redirect happens this won't be called
  *     return next(request);
  *   });
@@ -44,25 +59,39 @@
  *
  * @example
  * ```typescript
- * // Usage in serverless environments like Cloudflare Workers
- * // ⚠️ WARNING: This should ONLY be used in serverless environments like Cloudflare Workers.
- * // Disabling AsyncLocalStorage in traditional server environments risks cross-request pollution where state from
- * // one request could leak into another concurrent request.
+ * // 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: async (request) => {
- *     return serverMiddleware(
- *       request,
- *       ({ request, locale }) => handleRequest(request, locale),
- *       { disableAsyncLocalStorage: true }
- *     );
- *   }
- * };
+ *   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))
+ *   },
+ * }
  * ```
  */
 export function paraglideMiddleware<T>(request: Request, resolve: (args: {
     request: Request;
     locale: import("./runtime.js").Locale;
-}) => T | Promise<T>, callbacks?: {
-    onRedirect: (response: Response) => void;
+}) => T | Promise<T>, options?: {
+    effectiveRequestUrl?: string | URL | ((request: Request) => string | URL);
+    onRedirect?: (response: Response) => void;
 }): Promise<Response>;
 //# sourceMappingURL=server.d.ts.map

package/dist/external/paraglide/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/lib/external/paraglide/server.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,oCA9Ca,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,cACrF;IAAE,UAAU,EAAC,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAA;CAAE,GACzC,OAAO,CAAC,QAAQ,CAAC,CAkH7B"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/lib/external/paraglide/server.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AACH,oCAlEa,CAAC,WAEH,OAAO,WACP,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,YAKrF;IACN,mBAAmB,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,GAAG,GAAG,CAAC,CAAC;IAC1E,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAA;CAC1C,GACS,OAAO,CAAC,QAAQ,CAAC,CA0J7B"}

package/dist/external/paraglide/server.js

@@ -5,6 +5,12 @@ import * as runtime from "./runtime.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
@@ -17,18 +23,27 @@ import * as runtime from "./runtime.js";
  * - 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://paraglidejs.com/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
- * @param {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
+ * @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 serverMiddleware(event.request, ({ request, locale }) => {
+ *   return paraglideMiddleware(event.request, ({ request, locale }) => {
  *     // let the framework further resolve the request
  *     return resolve(request);
  *   });
@@ -39,7 +54,7 @@ import * as runtime from "./runtime.js";
  * ```typescript
  * // Usage in a framework like Express JS or Hono
  * app.use(async (req, res, next) => {
- *   const result = await serverMiddleware(req, ({ request, locale }) => {
+ *   const result = await paraglideMiddleware(req, ({ request, locale }) => {
  *     // If a redirect happens this won't be called
  *     return next(request);
  *   });
@@ -48,32 +63,61 @@ import * as runtime from "./runtime.js";
  *
  * @example
  * ```typescript
- * // Usage in serverless environments like Cloudflare Workers
- * // ⚠️ WARNING: This should ONLY be used in serverless environments like Cloudflare Workers.
- * // Disabling AsyncLocalStorage in traditional server environments risks cross-request pollution where state from
- * // one request could leak into another concurrent request.
+ * // 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: async (request) => {
- *     return serverMiddleware(
- *       request,
- *       ({ request, locale }) => handleRequest(request, locale),
- *       { disableAsyncLocalStorage: true }
- *     );
- *   }
- * };
+ *   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))
+ *   },
+ * }
  * ```
  */
-export async function paraglideMiddleware(request, resolve, callbacks) {
-    if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
-        const { AsyncLocalStorage } = await import("async_hooks");
-        runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
+export async function paraglideMiddleware(request, resolve, options) {
+    let requestAsyncLocalStorage = runtime.serverAsyncLocalStorage;
+    requestAsyncLocalStorage = runtime.getServerAsyncLocalStorage();
+    if (!runtime.disableAsyncLocalStorage && !requestAsyncLocalStorage) {
+      const { AsyncLocalStorage } = await import("async_hooks");
+      requestAsyncLocalStorage = runtime.getServerAsyncLocalStorage();
+      if (!requestAsyncLocalStorage) {
+        requestAsyncLocalStorage = new AsyncLocalStorage();
+        runtime.overwriteServerAsyncLocalStorage(requestAsyncLocalStorage);
+      }
     }
-    else if (!runtime.serverAsyncLocalStorage) {
-        runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
+    if (!requestAsyncLocalStorage) {
+      requestAsyncLocalStorage = createMockAsyncLocalStorage();
+      runtime.overwriteServerAsyncLocalStorage(requestAsyncLocalStorage);
     }
-    const decision = await runtime.shouldRedirect({ request });
+    const url = resolveMiddlewareUrl(request, options?.effectiveRequestUrl);
+    const origin = url.origin;
+    if (runtime.isExcludedByRouteStrategy(url.href)) {
+        const locale = runtime.baseLocale;
+        const newRequest = cloneRequestWithFallback(request, url);
+        /** @type {Set<string>} */
+        const messageCalls = new Set();
+        return /** @type {Response} */ (await requestAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest })));
+    }
+    const strategy = runtime.getStrategyForUrl(url.href);
+    const decision = await runtime.shouldRedirect({ request, effectiveRequestUrl: url });
     const locale = decision.locale;
-    const origin = new URL(request.url).origin;
     // if the client makes a request to a URL that doesn't match
     // the localizedUrl, redirect the client to the localized URL
     if (request.headers.get("Sec-Fetch-Dest") === "document" &&
@@ -82,7 +126,7 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
         // Create headers object with Vary header if preferredLanguage strategy is used
         /** @type {Record<string, string>} */
         const headers = {};
-        if (runtime.strategy.includes("preferredLanguage")) {
+        if (strategy.includes("preferredLanguage")) {
             headers["Vary"] = "Accept-Language";
         }
         const response = new Response(null, {
@@ -92,7 +136,7 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
                 ...headers,
             },
         });
-        callbacks?.onRedirect(response);
+        options?.onRedirect?.(response);
         return response;
     }
     // If the strategy includes "url", we need to de-localize the URL
@@ -101,15 +145,17 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     // The middleware is responsible for mapping a localized URL to the
     // de-localized URL e.g. `/en/about` to `/about`. Otherwise,
     // the server can't render the correct page.
-    const newRequest = runtime.strategy.includes("url")
-        ? new Request(runtime.deLocalizeUrl(request.url), request)
-        : // need to create a new request object because some metaframeworks (nextjs!) throw otherwise
-            // https://github.com/opral/inlang-paraglide-js/issues/411
-            new Request(request);
+    let newRequest;
+    if (strategy.includes("url")) {
+        newRequest = cloneRequestWithFallback(request, runtime.deLocalizeUrl(url));
+    }
+    else {
+        newRequest = cloneRequestWithFallback(request, url);
+    }
     // the message functions that have been called in this request
     /** @type {Set<string>} */
     const messageCalls = new Set();
-    const response = await runtime.serverAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest }));
+    const response = await requestAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest }));
     // Only modify HTML responses
     if (runtime.experimentalMiddlewareLocaleSplitting &&
         response.headers.get("Content-Type")?.includes("html")) {
@@ -122,7 +168,16 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
             /** @type {[string, import("./runtime.js").Locale]} */ (messageCall.split(":"));
             messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
         }
-        const script = `<script>globalThis.__paraglide_ssr = { ${messages.join(",")} }</script>`;
+        // Prevent translated content from terminating the inline script tag.
+        const escapedMessages = messages
+            .join(",")
+            .replace(/<\/(script)/gi, "<\\/$1");
+        // Reuse the request's CSP nonce (if any) so the injected script is allowed under a strict CSP
+        const nonce = response.headers
+            .get("Content-Security-Policy")
+            ?.match(/'nonce-([\w+/=-]+)'/)?.[1];
+        const nonceAttr = nonce ? `nonce="${nonce}"` : "";
+        const script = `<script ${nonceAttr}>globalThis.__paraglide = globalThis.__paraglide ?? {}; globalThis.__paraglide.ssr = { ${escapedMessages} }</script>`;
         // Insert the script before the closing head tag
         const newBody = body.replace("</head>", `${script}</head>`);
         // Create a new response with the modified body
@@ -137,13 +192,71 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
     }
     return response;
 }
+/**
+ * @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 {
+            // Clone first so building a new Request does not consume the original body stream.
+            return new Request(request.clone());
+        }
+        catch {
+            try {
+                return new Request(request);
+            }
+            catch {
+                return request;
+            }
+        }
+    }
+    try {
+        // Clone first so building a new Request does not consume the original body stream.
+        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 designed to be used in
- * environments like Cloudflare Workers where AsyncLocalStorage is not available.
+ * 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}
  */
@@ -165,6 +278,8 @@ function createMockAsyncLocalStorage() {
         },
     };
 }
+// Used in generated server.js when async local storage is disabled.
+void createMockAsyncLocalStorage;
 /**
  * The compiled messages for the server middleware.
  *

package/dist/modules/parsnip/external-images/externalImages.remote.d.ts

@@ -3,6 +3,6 @@ export declare const getPhotoDetails: import("@sveltejs/kit").RemoteQueryFunctio
     description: any;
     tags: string[];
     createdAt: any;
-} | null>;
-export declare const getPhotoCollectionMeta: import("@sveltejs/kit").RemoteQueryFunction<string, any>;
+} | null, string>;
+export declare const getPhotoCollectionMeta: import("@sveltejs/kit").RemoteQueryFunction<string, any, string>;
 //# sourceMappingURL=externalImages.remote.d.ts.map

package/dist/modules/parsnip/external-images/externalImages.remote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"externalImages.remote.d.ts","sourceRoot":"","sources":["../../../../src/lib/modules/parsnip/external-images/externalImages.remote.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,eAAe;;;UARG,MAAM,EAAE;;SAQ0B,CAAC;AAElE,eAAO,MAAM,sBAAsB,0DAajC,CAAC"}
+{"version":3,"file":"externalImages.remote.d.ts","sourceRoot":"","sources":["../../../../src/lib/modules/parsnip/external-images/externalImages.remote.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,eAAe;;;UARG,MAAM,EAAE;;iBAQ0B,CAAC;AAElE,eAAO,MAAM,sBAAsB,kEAajC,CAAC"}

package/package.json

@@ -1,57 +1,57 @@
 {
   "name": "@turnipxenon/pineapple",
   "description": "personal package for base styling for other personal projects",
-  "version": "5.3.15",
+  "version": "5.3.17",
   "devDependencies": {
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-conventional": "^19.8.1",
     "@eslint/compat": "^1.4.1",
-    "@eslint/js": "^9.39.2",
-    "@inlang/paraglide-js": "~2.4.0",
+    "@eslint/js": "^9.39.5",
+    "@inlang/paraglide-js": "^2.23.2",
     "@prisma/client": "^5.22.0",
-    "@sveltejs/adapter-cloudflare": "^7.2.6",
-    "@sveltejs/kit": "^2.53.4",
-    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/adapter-cloudflare": "^7.2.9",
+    "@sveltejs/kit": "^2.70.2",
+    "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "@types/mdast": "^4.0.4",
-    "@types/node": "^20.19.31",
-    "eslint": "^9.39.2",
+    "@types/node": "^20.19.43",
+    "eslint": "^9.39.5",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-svelte": "^3.14.0",
+    "eslint-plugin-svelte": "^3.23.0",
     "globals": "^16.5.0",
-    "highlight.js": "^11.11.1",
+    "highlight.js": "^11.12.0",
     "htmlparser2": "^9.1.0",
     "husky": "^9.1.7",
     "mdast-util-from-markdown": "^1.3.1",
     "node-html-parser": "^6.1.13",
-    "prettier": "^3.8.1",
-    "prettier-plugin-svelte": "^3.4.1",
+    "prettier": "^3.9.6",
+    "prettier-plugin-svelte": "^3.5.2",
     "prisma": "^5.22.0",
-    "publint": "^0.3.17",
-    "sass": "^1.97.3",
+    "publint": "^0.3.23",
+    "sass": "^1.102.0",
     "string-width": "^7.2.0",
-    "svelte": "^5.53.5",
-    "svelte-check": "^4.3.6",
-    "svelte2tsx": "^0.7.47",
+    "svelte": "^5.56.9",
+    "svelte-check": "^4.7.6",
+    "svelte2tsx": "^0.7.61",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18",
-    "wrangler": "4.59.1"
+    "typescript-eslint": "^8.67.0",
+    "vite": "^7.3.6",
+    "vitest": "^4.1.10",
+    "wrangler": "^4.123.0"
   },
   "dependencies": {
-    "@shikijs/transformers": "^3.22.0",
+    "@shikijs/transformers": "^3.23.0",
     "melt": "^0.44.0",
     "mode-watcher": "^0.5.1",
-    "shiki": "^3.22.0",
+    "shiki": "^3.23.0",
     "shiki-transformer-copy-button": "0.0.3",
     "svelte-modals": "^2.0.1",
-    "valibot": "^1.2.0"
+    "valibot": "^1.4.2"
   },
   "peerDependencies": {
-    "svelte": "5.53.5",
+    "svelte": "^5.55.7",
     "svelte-modals": "^2.0.1"
   },
   "exports": {
@@ -126,7 +126,7 @@
   "scripts": {
     "dev": "vite dev",
     "build": "vite build",
-    "package": "svelte-kit sync && svelte-package && publint",
+    "package": "svelte-kit sync && svelte-package && node scripts/strip-dist-gitignore.mjs && publint",
     "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
     "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
     "check-baseline": "bash scripts/check-baseline.sh",

package/dist/external/paraglide/messages/en.d.ts

@@ -1,5 +0,0 @@
-export const example_message: (inputs: {
-    username: NonNullable<unknown>;
-}) => string;
-export const settings: (inputs: {}) => string;
-//# sourceMappingURL=en.d.ts.map

package/dist/external/paraglide/messages/en.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../src/lib/external/paraglide/messages/en.js"],"names":[],"mappings":"AAGA,8BAA0C,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CAAE,KAAK,MAAM,CAE9F;AAEF,uBAAmC,CAAC,MAAM,EAAE,EAAE,KAAK,MAAM,CAEvD"}

package/dist/external/paraglide/messages/en.js

@@ -1,10 +0,0 @@
-/* eslint-disable */
-
-
-export const example_message = /** @type {(inputs: { username: NonNullable<unknown> }) => string} */ (i) => {
-	return `Hello world ${i.username}`
-};
-
-export const settings = /** @type {(inputs: {}) => string} */ () => {
-	return `Settings`
-};

package/dist/external/paraglide/messages/fr.d.ts

@@ -1,5 +0,0 @@
-export const example_message: (inputs: {
-    username: NonNullable<unknown>;
-}) => string;
-export const settings: (inputs: {}) => string;
-//# sourceMappingURL=fr.d.ts.map

package/dist/external/paraglide/messages/fr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fr.d.ts","sourceRoot":"","sources":["../../../../src/lib/external/paraglide/messages/fr.js"],"names":[],"mappings":"AAGA,8BAA0C,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CAAE,KAAK,MAAM,CAE9F;AAEF,uBAAmC,CAAC,MAAM,EAAE,EAAE,KAAK,MAAM,CAEvD"}

package/dist/external/paraglide/messages/fr.js

@@ -1,10 +0,0 @@
-/* eslint-disable */
-
-
-export const example_message = /** @type {(inputs: { username: NonNullable<unknown> }) => string} */ (i) => {
-	return `Bonjour ${i.username}`
-};
-
-export const settings = /** @type {(inputs: {}) => string} */ () => {
-	return `Paramètres`
-};

package/dist/external/paraglide/messages/tl.d.ts

@@ -1,5 +0,0 @@
-export const example_message: (inputs: {
-    username: NonNullable<unknown>;
-}) => string;
-export { settings } from "./en.js";
-//# sourceMappingURL=tl.d.ts.map

package/dist/external/paraglide/messages/tl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tl.d.ts","sourceRoot":"","sources":["../../../../src/lib/external/paraglide/messages/tl.js"],"names":[],"mappings":"AAGA,8BAA0C,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CAAE,KAAK,MAAM,CAE9F"}

package/dist/external/paraglide/messages/tl.js

@@ -1,7 +0,0 @@
-/* eslint-disable */
-
-
-export const example_message = /** @type {(inputs: { username: NonNullable<unknown> }) => string} */ (i) => {
-	return `Kamusta ${i.username}`
-};
-export { settings } from "./en.js"