@turnipxenon/pineapple 4.5.0 → 5.0.0-alpha.1

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

@@ -0,0 +1,68 @@
+/**
+ * Server middleware that handles locale-based routing and request processing.
+ *
+ * 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`)
+ *
+ * @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
+ * @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 }) => {
+ *     // 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 serverMiddleware(req, ({ request, locale }) => {
+ *     // If a redirect happens this won't be called
+ *     return next(request);
+ *   });
+ * });
+ * ```
+ *
+ * @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.
+ * export default {
+ *   fetch: async (request) => {
+ *     return serverMiddleware(
+ *       request,
+ *       ({ request, locale }) => handleRequest(request, locale),
+ *       { disableAsyncLocalStorage: true }
+ *     );
+ *   }
+ * };
+ * ```
+ */
+export function paraglideMiddleware<T>(request: Request, resolve: (args: {
+    request: Request;
+    locale: import("./runtime.js").Locale;
+}) => T | Promise<T>, callbacks?: {
+    onRedirect: (response: Response) => void;
+}): Promise<Response>;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +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"}

package/dist/external/paraglide/server.js

@@ -0,0 +1,175 @@
+/* eslint-disable */
+
+import * as runtime from "./runtime.js";
+
+/**
+ * Server middleware that handles locale-based routing and request processing.
+ *
+ * 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`)
+ *
+ * @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
+ * @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 }) => {
+ *     // 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 serverMiddleware(req, ({ request, locale }) => {
+ *     // If a redirect happens this won't be called
+ *     return next(request);
+ *   });
+ * });
+ * ```
+ *
+ * @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.
+ * export default {
+ *   fetch: async (request) => {
+ *     return serverMiddleware(
+ *       request,
+ *       ({ request, locale }) => handleRequest(request, locale),
+ *       { disableAsyncLocalStorage: true }
+ *     );
+ *   }
+ * };
+ * ```
+ */
+export async function paraglideMiddleware(request, resolve, callbacks) {
+    if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
+        const { AsyncLocalStorage } = await import("async_hooks");
+        runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
+    }
+    else if (!runtime.serverAsyncLocalStorage) {
+        runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
+    }
+    const decision = await runtime.shouldRedirect({ request });
+    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" &&
+        decision.shouldRedirect &&
+        decision.redirectUrl) {
+        // Create headers object with Vary header if preferredLanguage strategy is used
+        /** @type {Record<string, string>} */
+        const headers = {};
+        if (runtime.strategy.includes("preferredLanguage")) {
+            headers["Vary"] = "Accept-Language";
+        }
+        const response = new Response(null, {
+            status: 307,
+            headers: {
+                Location: decision.redirectUrl.href,
+                ...headers,
+            },
+        });
+        callbacks?.onRedirect(response);
+        return response;
+    }
+    // If the strategy includes "url", we need to de-localize the URL
+    // before passing it to the server middleware.
+    //
+    // 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);
+    // 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 }));
+    // Only modify HTML responses
+    if (runtime.experimentalMiddlewareLocaleSplitting &&
+        response.headers.get("Content-Type")?.includes("html")) {
+        const body = await response.text();
+        const messages = [];
+        // using .values() to avoid polyfilling in older projects. else the following error is thrown
+        // Type 'Set<string>' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.
+        for (const messageCall of Array.from(messageCalls)) {
+            const [id, locale] = 
+            /** @type {[string, import("./runtime.js").Locale]} */ (messageCall.split(":"));
+            messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
+        }
+        const script = `<script>globalThis.__paraglide_ssr = { ${messages.join(",")} }</script>`;
+        // Insert the script before the closing head tag
+        const newBody = body.replace("</head>", `${script}</head>`);
+        // Create a new response with the modified body
+        // Clone all headers except Content-Length which will be set automatically
+        const newHeaders = new Headers(response.headers);
+        newHeaders.delete("Content-Length"); // Let the browser calculate the correct length
+        return new Response(newBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders,
+        });
+    }
+    return response;
+}
+/**
+ * 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.
+ *
+ * @returns {import("./runtime.js").ParaglideAsyncLocalStorage}
+ */
+function createMockAsyncLocalStorage() {
+    /** @type {any} */
+    let currentStore = undefined;
+    return {
+        getStore() {
+            return currentStore;
+        },
+        async run(store, callback) {
+            currentStore = store;
+            try {
+                return await callback();
+            }
+            finally {
+                currentStore = undefined;
+            }
+        },
+    };
+}
+/**
+ * The compiled messages for the server middleware.
+ *
+ * Only populated if `enableMiddlewareOptimizations` is set to `true`.
+ *
+ * @type {Record<string, Record<import("./runtime.js").Locale, string>>}
+ */
+const compiledBundles = {};

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export * from "./util/util";
 export * from "./api/index";
 export type { IDialogManager } from "./components/dialog_manager/IDialogManager";
 export { default as BlogTemplate } from "./ui/templates/blog_template/BlogTemplate.svelte";
-export { default as DialogOverlay } from "./ui/modules/dialog_overlay/DialogOverlay.svelte";
+export { default as UniversalOverlay } from "./ui/modules/universal-overlay/UniversalOverlay.svelte";
 export { dialogManager } from "./components/dialog_manager/DialogManager";
 export * from "./modules/parsnip/index";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAEA,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,sBAAsB,CAAC;AACrC,cAAc,gDAAgD,CAAC;AAC/D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yCAAyC,CAAC;AACxD,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAE5B,YAAY,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AACpF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,qDAAqD,CAAC;AAC9F,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,2DAA2D,CAAC;AACxG,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAE7E,cAAc,yBAAyB,CAAC"}

package/dist/index.js

@@ -10,6 +10,6 @@ export * from "./types/pineapple_fiber/DialogDetail";
 export * from "./util/util";
 export * from "./api/index";
 export { default as BlogTemplate } from "./ui/templates/blog_template/BlogTemplate.svelte";
-export { default as DialogOverlay } from "./ui/modules/dialog_overlay/DialogOverlay.svelte";
+export { default as UniversalOverlay } from "./ui/modules/universal-overlay/UniversalOverlay.svelte";
 export { dialogManager } from "./components/dialog_manager/DialogManager";
 export * from "./modules/parsnip/index";

package/dist/modules/overrideable_meta/OverridableMeta.svelte

@@ -19,8 +19,7 @@ export const load = async (): Promise<OverridableMetaProps> => {
 -->
 
 <script lang="ts">
-	import { page } from "$app/state";
-	import { pinyaHead } from "../../ui/templates/runes.svelte";
+	import { pinyaHead } from "../../ui/templates/pinya-base/pinyaBaseRunes.svelte.js";
 
 	interface Props {
 		rootUrl?: string;

package/dist/modules/overrideable_meta/OverridableMeta.svelte.d.ts

@@ -1,10 +1,15 @@
-interface Props {
-    rootUrl?: string;
-    title?: string;
-    ogTitle?: string;
-    ogDescription?: string;
-    ogImage?: string[];
-}
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+type OverridableMetaProps_ = typeof __propDef.props;
+export { OverridableMetaProps_ as OverridableMetaProps };
+export type OverridableMetaEvents = typeof __propDef.events;
+export type OverridableMetaSlots = typeof __propDef.slots;
 /**
  * OverridableMeta is convenient Svelte component allowing each page to override the head meta values
  * based on their +page.ts.
@@ -24,6 +29,6 @@ interface Props {
  * };
  * </code>
  */
-declare const OverridableMeta: import("svelte").Component<Props, {}, "">;
-type OverridableMeta = ReturnType<typeof OverridableMeta>;
-export default OverridableMeta;
+export default class OverridableMeta extends SvelteComponentTyped<OverridableMetaProps_, OverridableMetaEvents, OverridableMetaSlots> {
+}
+//# sourceMappingURL=OverridableMeta.svelte.d.ts.map

package/dist/modules/overrideable_meta/OverridableMeta.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverridableMeta.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/overrideable_meta/OverridableMeta.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAkDD,QAAA,MAAM,SAAS;;;;;;CAA0C,CAAC;AAC1D,KAAK,qBAAqB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACpD,OAAO,EAAE,qBAAqB,IAAI,oBAAoB,EAAE,CAAC;AACzD,MAAM,MAAM,qBAAqB,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AAC5D,MAAM,MAAM,oBAAoB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,oBAAoB,CAAC,qBAAqB,EAAE,qBAAqB,EAAE,oBAAoB,CAAC;CACpI"}

package/dist/modules/overrideable_meta/OverridableMetaProps.d.ts

@@ -10,3 +10,4 @@ export interface OverridableMetaProps {
     datePublished?: string;
     lastUpdated?: string;
 }
+//# sourceMappingURL=OverridableMetaProps.d.ts.map

package/dist/modules/overrideable_meta/OverridableMetaProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverridableMetaProps.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/overrideable_meta/OverridableMetaProps.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/modules/overrideable_meta/index.d.ts

@@ -1,2 +1,3 @@
 export { default as OverridableMeta } from "./OverridableMeta.svelte";
 export * from "./OverridableMetaProps";
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/overrideable_meta/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/overrideable_meta/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACtE,cAAc,wBAAwB,CAAC"}

package/dist/modules/parsnip/ParsnipBlockChildren.svelte.d.ts

@@ -1,8 +1,15 @@
-import type { Content } from "mdast";
-type $$ComponentProps = {
-    blockChildren: Content[];
-    shouldUnwrapParagraph?: boolean;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const ParsnipBlockChildren: import("svelte").Component<$$ComponentProps, {}, "">;
-type ParsnipBlockChildren = ReturnType<typeof ParsnipBlockChildren>;
-export default ParsnipBlockChildren;
+export type ParsnipBlockChildrenProps = typeof __propDef.props;
+export type ParsnipBlockChildrenEvents = typeof __propDef.events;
+export type ParsnipBlockChildrenSlots = typeof __propDef.slots;
+export default class ParsnipBlockChildren extends SvelteComponentTyped<ParsnipBlockChildrenProps, ParsnipBlockChildrenEvents, ParsnipBlockChildrenSlots> {
+}
+export {};
+//# sourceMappingURL=ParsnipBlockChildren.svelte.d.ts.map

package/dist/modules/parsnip/ParsnipBlockChildren.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsnipBlockChildren.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/parsnip/ParsnipBlockChildren.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAoDD,QAAA,MAAM,SAAS;;;;;;CAA0C,CAAC;AAC1D,MAAM,MAAM,yBAAyB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAC/D,MAAM,MAAM,0BAA0B,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACjE,MAAM,MAAM,yBAAyB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAE/D,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,oBAAoB,CAAC,yBAAyB,EAAE,0BAA0B,EAAE,yBAAyB,CAAC;CACvJ"}

package/dist/modules/parsnip/ParsnipEmbedWikilink.svelte.d.ts

@@ -1,15 +1,15 @@
-interface EmbedWikilink {
-    type: 'embedWikilink';
-    value: string;
-    fileAccessor: {
-        target: string;
-        isEmbed: false;
-        basePath: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
     };
-}
-type $$ComponentProps = {
-    wikilink: EmbedWikilink;
+    slots: {};
 };
-declare const ParsnipEmbedWikilink: import("svelte").Component<$$ComponentProps, {}, "">;
-type ParsnipEmbedWikilink = ReturnType<typeof ParsnipEmbedWikilink>;
-export default ParsnipEmbedWikilink;
+export type ParsnipEmbedWikilinkProps = typeof __propDef.props;
+export type ParsnipEmbedWikilinkEvents = typeof __propDef.events;
+export type ParsnipEmbedWikilinkSlots = typeof __propDef.slots;
+export default class ParsnipEmbedWikilink extends SvelteComponentTyped<ParsnipEmbedWikilinkProps, ParsnipEmbedWikilinkEvents, ParsnipEmbedWikilinkSlots> {
+}
+export {};
+//# sourceMappingURL=ParsnipEmbedWikilink.svelte.d.ts.map

package/dist/modules/parsnip/ParsnipEmbedWikilink.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsnipEmbedWikilink.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/parsnip/ParsnipEmbedWikilink.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AA2BD,QAAA,MAAM,SAAS;;;;;;CAA0C,CAAC;AAC1D,MAAM,MAAM,yBAAyB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAC/D,MAAM,MAAM,0BAA0B,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACjE,MAAM,MAAM,yBAAyB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAE/D,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,oBAAoB,CAAC,yBAAyB,EAAE,0BAA0B,EAAE,yBAAyB,CAAC;CACvJ"}

package/dist/modules/parsnip/ParsnipEntry.d.ts

@@ -5,3 +5,4 @@ export interface ParsnipEntry extends ParsnipEntrySummary {
         ast: Root;
     };
 }
+//# sourceMappingURL=ParsnipEntry.d.ts.map

package/dist/modules/parsnip/ParsnipEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsnipEntry.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/parsnip/ParsnipEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC/E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAElC,MAAM,WAAW,YAAa,SAAQ,mBAAmB;IACxD,GAAG,EAAE;QAAE,GAAG,EAAE,IAAI,CAAA;KAAE,CAAC;CACnB"}

package/dist/modules/parsnip/ParsnipHeading.svelte.d.ts

@@ -1,7 +1,15 @@
-import type { Heading } from "mdast";
-type $$ComponentProps = {
-    heading: Heading;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const ParsnipHeading: import("svelte").Component<$$ComponentProps, {}, "">;
-type ParsnipHeading = ReturnType<typeof ParsnipHeading>;
-export default ParsnipHeading;
+export type ParsnipHeadingProps = typeof __propDef.props;
+export type ParsnipHeadingEvents = typeof __propDef.events;
+export type ParsnipHeadingSlots = typeof __propDef.slots;
+export default class ParsnipHeading extends SvelteComponentTyped<ParsnipHeadingProps, ParsnipHeadingEvents, ParsnipHeadingSlots> {
+}
+export {};
+//# sourceMappingURL=ParsnipHeading.svelte.d.ts.map

package/dist/modules/parsnip/ParsnipHeading.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsnipHeading.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/parsnip/ParsnipHeading.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AA4BD,QAAA,MAAM,SAAS;;;;;;CAA0C,CAAC;AAC1D,MAAM,MAAM,mBAAmB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACzD,MAAM,MAAM,oBAAoB,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AAC3D,MAAM,MAAM,mBAAmB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAEzD,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,oBAAoB,CAAC,mBAAmB,EAAE,oBAAoB,EAAE,mBAAmB,CAAC;CAC/H"}

package/dist/modules/parsnip/ParsnipList.svelte.d.ts

@@ -1,7 +1,15 @@
-import type { List } from "mdast";
-type $$ComponentProps = {
-    list: List;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const ParsnipList: import("svelte").Component<$$ComponentProps, {}, "">;
-type ParsnipList = ReturnType<typeof ParsnipList>;
-export default ParsnipList;
+export type ParsnipListProps = typeof __propDef.props;
+export type ParsnipListEvents = typeof __propDef.events;
+export type ParsnipListSlots = typeof __propDef.slots;
+export default class ParsnipList extends SvelteComponentTyped<ParsnipListProps, ParsnipListEvents, ParsnipListSlots> {
+}
+export {};
+//# sourceMappingURL=ParsnipList.svelte.d.ts.map

package/dist/modules/parsnip/ParsnipList.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsnipList.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/parsnip/ParsnipList.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAgCD,QAAA,MAAM,SAAS;;;;;;CAA0C,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AACtD,MAAM,MAAM,iBAAiB,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACxD,MAAM,MAAM,gBAAgB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAEtD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,oBAAoB,CAAC,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,CAAC;CACnH"}

package/dist/modules/parsnip/ParsnipOverall.d.ts

@@ -42,3 +42,4 @@ export interface ParsnipOverall {
     tags: TagEntry[];
     baseUrl: string;
 }
+//# sourceMappingURL=ParsnipOverall.d.ts.map

package/dist/modules/parsnip/ParsnipOverall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsnipOverall.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/parsnip/ParsnipOverall.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC/B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC3D;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE;QACL;;WAEG;QACH,KAAK,EAAE,MAAM,CAAC;QACd;;WAEG;QACH,KAAK,EAAE,MAAM,CAAC;KACd,CAAA;CACD;AAED,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CAChB"}

package/dist/modules/parsnip/ParsnipParagraph.svelte

@@ -1,10 +1,10 @@
-<script lang="ts">
-	import ParsnipPhrasingChildren from "./ParsnipPhrasingChildren.svelte";
-	import { type Paragraph } from "mdast";
-	// <!--	determine if we want to wrap it with p or not -->
-	const { paragraph }: { paragraph: Paragraph } = $props();
-</script>
-
-<p>
-	<ParsnipPhrasingChildren phrasingChildren={paragraph.children} />
-</p>
+<script lang="ts">
+	import ParsnipPhrasingChildren from "./ParsnipPhrasingChildren.svelte";
+	import { type Paragraph } from "mdast";
+	// <!--	determine if we want to wrap it with p or not -->
+	const { paragraph }: { paragraph: Paragraph } = $props();
+</script>
+
+<p>
+	<ParsnipPhrasingChildren phrasingChildren={paragraph.children} />
+</p>

package/dist/modules/parsnip/ParsnipParagraph.svelte.d.ts

@@ -1,7 +1,15 @@
-import { type Paragraph } from "mdast";
-type $$ComponentProps = {
-    paragraph: Paragraph;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const ParsnipParagraph: import("svelte").Component<$$ComponentProps, {}, "">;
-type ParsnipParagraph = ReturnType<typeof ParsnipParagraph>;
-export default ParsnipParagraph;
+export type ParsnipParagraphProps = typeof __propDef.props;
+export type ParsnipParagraphEvents = typeof __propDef.events;
+export type ParsnipParagraphSlots = typeof __propDef.slots;
+export default class ParsnipParagraph extends SvelteComponentTyped<ParsnipParagraphProps, ParsnipParagraphEvents, ParsnipParagraphSlots> {
+}
+export {};
+//# sourceMappingURL=ParsnipParagraph.svelte.d.ts.map

package/dist/modules/parsnip/ParsnipParagraph.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsnipParagraph.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/parsnip/ParsnipParagraph.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAkBD,QAAA,MAAM,SAAS;;;;;;CAA0C,CAAC;AAC1D,MAAM,MAAM,qBAAqB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAC3D,MAAM,MAAM,sBAAsB,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AAC7D,MAAM,MAAM,qBAAqB,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAE3D,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,oBAAoB,CAAC,qBAAqB,EAAE,sBAAsB,EAAE,qBAAqB,CAAC;CACvI"}

package/dist/modules/parsnip/ParsnipPhrasingChildren.svelte

@@ -1,30 +1,30 @@
-<script lang="ts">
-	import ParsnipEmbedWikilink from "./ParsnipEmbedWikilink.svelte";
-	import ParsnipWikilink from "./ParsnipWikilink.svelte";
-	import { type PhrasingContent } from "mdast";
-	import Self from "./ParsnipPhrasingChildren.svelte";
-
-	const { phrasingChildren }: { phrasingChildren: PhrasingContent[] } = $props();
-</script>
-
-{#each phrasingChildren as child (child)}
-	{#if child.type === 'text'}
-		{child.value}
-	{:else if child.type === 'strong'}
-		<strong>
-			<Self phrasingChildren={child.children} />
-		</strong>
-	{:else if child.type === 'inlineCode'}
-		<code class="inline-code">{child.value}</code>
-	{:else if child.type === 'link'}
-		<a href={child.url}>
-			<Self phrasingChildren={child.children} />
-		</a>
-	{:else if child.type === 'embedWikilink'}
-		<ParsnipEmbedWikilink wikilink={child} />
-	{:else if child.type === 'wikilink'}
-		<ParsnipWikilink wikilink={child} />
-	{:else }
-		{JSON.stringify(child, undefined, 2)}
-	{/if}
-{/each}
+<script lang="ts">
+	import ParsnipEmbedWikilink from "./ParsnipEmbedWikilink.svelte";
+	import ParsnipWikilink from "./ParsnipWikilink.svelte";
+	import { type PhrasingContent } from "mdast";
+	import Self from "./ParsnipPhrasingChildren.svelte";
+
+	const { phrasingChildren }: { phrasingChildren: PhrasingContent[] } = $props();
+</script>
+
+{#each phrasingChildren as child (child)}
+	{#if child.type === 'text'}
+		{child.value}
+	{:else if child.type === 'strong'}
+		<strong>
+			<Self phrasingChildren={child.children} />
+		</strong>
+	{:else if child.type === 'inlineCode'}
+		<code class="inline-code">{child.value}</code>
+	{:else if child.type === 'link'}
+		<a href={child.url}>
+			<Self phrasingChildren={child.children} />
+		</a>
+	{:else if child.type === 'embedWikilink'}
+		<ParsnipEmbedWikilink wikilink={child} />
+	{:else if child.type === 'wikilink'}
+		<ParsnipWikilink wikilink={child} />
+	{:else }
+		{JSON.stringify(child, undefined, 2)}
+	{/if}
+{/each}

package/dist/modules/parsnip/ParsnipPhrasingChildren.svelte.d.ts

@@ -1,7 +1,15 @@
-import { type PhrasingContent } from "mdast";
-type $$ComponentProps = {
-    phrasingChildren: PhrasingContent[];
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
 };
-declare const ParsnipPhrasingChildren: import("svelte").Component<$$ComponentProps, {}, "">;
-type ParsnipPhrasingChildren = ReturnType<typeof ParsnipPhrasingChildren>;
-export default ParsnipPhrasingChildren;
+export type ParsnipPhrasingChildrenProps = typeof __propDef.props;
+export type ParsnipPhrasingChildrenEvents = typeof __propDef.events;
+export type ParsnipPhrasingChildrenSlots = typeof __propDef.slots;
+export default class ParsnipPhrasingChildren extends SvelteComponentTyped<ParsnipPhrasingChildrenProps, ParsnipPhrasingChildrenEvents, ParsnipPhrasingChildrenSlots> {
+}
+export {};
+//# sourceMappingURL=ParsnipPhrasingChildren.svelte.d.ts.map

package/dist/modules/parsnip/ParsnipPhrasingChildren.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsnipPhrasingChildren.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/parsnip/ParsnipPhrasingChildren.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAE5C;AAwCD,QAAA,MAAM,SAAS;;;;;;CAA0C,CAAC;AAC1D,MAAM,MAAM,4BAA4B,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAClE,MAAM,MAAM,6BAA6B,GAAG,OAAO,SAAS,CAAC,MAAM,CAAC;AACpE,MAAM,MAAM,4BAA4B,GAAG,OAAO,SAAS,CAAC,KAAK,CAAC;AAElE,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,oBAAoB,CAAC,4BAA4B,EAAE,6BAA6B,EAAE,4BAA4B,CAAC;CACnK"}