@c15t/svelte 3.0.0-alpha.0

package/dist/kit/routes.js

@@ -0,0 +1,203 @@
+import { deferInitGvlToRoute, serveGvlReference } from '@c15t/core';
+/**
+ * Same-origin consent routes for SvelteKit.
+ *
+ * Manifest mode (RFC 0001) moves policy resolution off the browser's critical
+ * path: the host fetches one geo-independent, CDN-cacheable manifest and
+ * resolves `/init` locally per request. These handlers are the SvelteKit
+ * server piece — the same contract `createNextConsentRouteHandlers` and the
+ * Nuxt route factories implement.
+ *
+ * Cache discipline:
+ * - The manifest route forwards the backend's `Cache-Control`/`ETag`
+ *   verbatim and answers `If-None-Match` with `304`. The edge caches it; this
+ *   process only dedupes bursts (see `@c15t/core/server`).
+ * - The init route is per-request (geo, language, GPC) and therefore
+ *   `private, no-store`.
+ */
+import { fetchCachedManifest, getManifestAge, MANIFEST_PASSTHROUGH_HEADERS, } from '@c15t/core/server';
+import { consentInputsToOverrides, extractConsentRequestInputs, resolveBackendURL, resolveInitFromManifest, } from '@c15t/schema/types';
+import { baseTranslations } from '@c15t/translations/all';
+const INIT_CACHE_CONTROL = 'private, no-store';
+const MANIFEST_ROUTE_SUFFIX = '/manifest';
+/**
+ * Hands a promise to the `waitUntil` a SvelteKit adapter exposes on
+ * `event.platform.context` (Cloudflare Workers and Pages, Vercel edge), so a
+ * background refresh outlives the response on runtimes that would cancel
+ * it. A no-op where the adapter provides none.
+ */
+export const waitUntilFromEvent = function waitUntilFromEvent(revalidation, event) {
+    const context = event.platform?.context;
+    if (context && typeof context.waitUntil === 'function') {
+        context.waitUntil.call(context, revalidation);
+    }
+};
+const bindBackgroundRevalidate = function bindBackgroundRevalidate(options, event) {
+    const onBackgroundRevalidate = options.onBackgroundRevalidate ?? waitUntilFromEvent;
+    return (revalidation) => onBackgroundRevalidate(revalidation, event);
+};
+const getEnv = function getEnv(name) {
+    if (typeof process === 'undefined') {
+        return undefined;
+    }
+    // `process.env` is typed narrowly in a Svelte app's TS project; this
+    // module also runs in plain Node and edge runtimes.
+    return process.env?.[name];
+};
+/**
+ * Resolves a possibly-relative backend URL against the request.
+ *
+ * Only `event.url` decides the origin. SvelteKit derives it from the
+ * adapter's trusted configuration (`ORIGIN`, or `PROTOCOL_HEADER`/
+ * `HOST_HEADER` where a proxy is declared), so seeding from it both fixes a
+ * relative URL on a plain `http://localhost` dev server and keeps a forged
+ * `x-forwarded-host` from steering this server-side fetch at a host of the
+ * caller's choosing.
+ */
+const resolveAgainstRequest = function resolveAgainstRequest(url, event) {
+    return resolveBackendURL(url, {
+        host: event.url.host,
+        'x-forwarded-proto': event.url.protocol.replace(':', ''),
+    });
+};
+/**
+ * Resolves where the manifest lives for this request, honouring explicit
+ * options first and then the `C15T_MANIFEST_URL` / `C15T_BACKEND_URL`
+ * environment variables.
+ */
+const resolveManifestSource = function resolveManifestSource(event, options) {
+    const manifestURL = options.manifestURL ?? getEnv('C15T_MANIFEST_URL');
+    if (manifestURL) {
+        const resolved = resolveAgainstRequest(manifestURL, event);
+        if (!resolved) {
+            throw new Error('@c15t/svelte/kit: invalid manifest URL.');
+        }
+        return { manifestURL: resolved };
+    }
+    const backendURL = options.backendURL ?? getEnv('C15T_BACKEND_URL');
+    if (!backendURL) {
+        throw new Error('@c15t/svelte/kit: configure `backendURL`, `manifestURL`, or the C15T_BACKEND_URL environment variable.');
+    }
+    const resolved = resolveAgainstRequest(backendURL, event);
+    if (!resolved) {
+        throw new Error('@c15t/svelte/kit: invalid backend URL.');
+    }
+    return { manifestURL: `${resolved}${MANIFEST_ROUTE_SUFFIX}` };
+};
+const shouldFetchGvl = function shouldFetchGvl(manifest, payload) {
+    return (manifest.iab?.enabled === true &&
+        manifest.iab.gvl !== undefined &&
+        payload.policyResolution?.status === 'matched' &&
+        payload.policyResolution.policy.model === 'iab');
+};
+const defaultFetchGvl = async function defaultFetchGvl(input) {
+    const response = await input.fetch(input.reference.url, {
+        headers: { 'accept-language': input.language },
+        method: 'GET',
+    });
+    if (response.status === 204) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`@c15t/svelte/kit: GVL responded ${response.status} ${response.statusText}`);
+    }
+    return (await response.json());
+};
+/**
+ * Creates the SvelteKit request handlers for manifest mode.
+ *
+ * Two shapes are supported. A single catch-all route:
+ *
+ * ```ts
+ * // src/routes/api/c15t/[...path]/+server.ts
+ * import { createSvelteKitConsentRouteHandlers } from '@c15t/svelte/kit';
+ *
+ * export const { GET } = createSvelteKitConsentRouteHandlers({
+ *   backendURL: process.env.C15T_BACKEND_URL,
+ * });
+ * ```
+ *
+ * …or one file per route, using `init` and `manifest` directly.
+ *
+ * @param options - Manifest source, fetch implementation, GVL fetcher.
+ * @returns `init`, `manifest`, and a `GET` that dispatches between them.
+ */
+export const createSvelteKitConsentRouteHandlers = function createSvelteKitConsentRouteHandlers(options = {}) {
+    const init = async (event) => {
+        const { manifestURL } = resolveManifestSource(event, options);
+        const { manifest } = await fetchCachedManifest({
+            config: { manifestURL },
+            fetch: options.fetch,
+            onBackgroundRevalidate: bindBackgroundRevalidate(options, event),
+        });
+        const listResponse = await serveGvlReference(event.request, (language) => manifest.iab?.gvl
+            ? (options.fetchGvl ?? defaultFetchGvl)({
+                fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
+                language,
+                reference: manifest.iab.gvl,
+            })
+            : Promise.resolve(null));
+        if (listResponse) {
+            return listResponse;
+        }
+        const inputs = extractConsentRequestInputs(event.request.headers);
+        const payload = resolveInitFromManifest(manifest, {
+            country: inputs.country,
+            gpc: inputs.gpc,
+            language: inputs.language ?? 'en',
+            region: inputs.region,
+        }, { baseTranslations });
+        if (shouldFetchGvl(manifest, payload) && manifest.iab?.gvl) {
+            const language = payload.translations.language.split('-')[0] || 'en';
+            payload.gvl = await (options.fetchGvl ?? defaultFetchGvl)({
+                fetch: (options.fetch ??
+                    globalThis.fetch.bind(globalThis)),
+                language,
+                reference: manifest.iab.gvl,
+            });
+        }
+        // The resolver's inputs are the only place GPC survives on the SSR
+        // path — the browser never sends `Sec-GPC` to this route when the
+        // page was server-rendered. Echo them back so the kernel folds the
+        // same overrides it would have derived client-side.
+        payload.resolvedOverrides = consentInputsToOverrides({
+            country: inputs.country,
+            language: inputs.language,
+            region: inputs.region,
+        });
+        payload.resolvedPrivacySignals = { gpc: inputs.gpc };
+        return Response.json(deferInitGvlToRoute(payload, new URL(event.request.url).pathname), {
+            headers: { 'cache-control': INIT_CACHE_CONTROL },
+        });
+    };
+    const manifest = async (event) => {
+        const { manifestURL } = resolveManifestSource(event, options);
+        const query = event.url.searchParams.toString();
+        const result = await fetchCachedManifest({
+            config: { manifestURL },
+            fetch: options.fetch,
+            onBackgroundRevalidate: bindBackgroundRevalidate(options, event),
+            query,
+        });
+        const headers = new Headers({ 'content-type': 'application/json' });
+        for (const name of MANIFEST_PASSTHROUGH_HEADERS) {
+            const value = result.headers[name];
+            if (value) {
+                headers.set(name, value);
+            }
+        }
+        headers.set('age', String(getManifestAge(result)));
+        const { etag } = result.headers;
+        if (etag && event.request.headers.get('if-none-match') === etag) {
+            return new Response(null, { headers, status: 304 });
+        }
+        return new Response(JSON.stringify(result.manifest), {
+            headers,
+            status: 200,
+        });
+    };
+    const GET = (event) => event.url.pathname.endsWith(MANIFEST_ROUTE_SUFFIX)
+        ? manifest(event)
+        : init(event);
+    return { GET, init, manifest };
+};

package/dist/kit/types.d.ts

@@ -0,0 +1,56 @@
+import type { KernelConfig } from '@c15t/core';
+import type { ManifestFetch, ManifestSourceConfig } from '@c15t/core/server';
+import type { ConsentRequestHeaderInputs } from '@c15t/schema/types';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * What {@link c15tHandle} stores on `event.locals.c15t`.
+ *
+ * `config` is the serializable {@link KernelConfig} to hand the provider as
+ * `prefetch`; `inputs` is the normalized geo/language/GPC context the handle
+ * derived from the request, kept so downstream loads and route handlers do
+ * not re-parse headers.
+ */
+export interface C15tLocals {
+    /** Kernel config seeded from the consent cookie and request inputs. */
+    config: KernelConfig;
+    /** Normalized country / region / language / GPC for this request. */
+    inputs: ConsentRequestInputs;
+    /**
+     * The cookie name the handle actually read, when it was given one.
+     * `loadConsent` falls back to it so a per-call geo override does not
+     * silently re-read the default `c15t` key and lose persisted consent.
+     */
+    cookieName?: string;
+}
+/** Normalized consent request context. Re-exported for `App.Locals` users. */
+export type ConsentRequestInputs = ConsentRequestHeaderInputs;
+/** Shared options for reading the consent cookie and request context. */
+export interface ConsentRequestOptions {
+    /**
+     * Cookie name holding persisted consent. Defaults to `c15t` — the
+     * persistence module's storage key. Set this only if you customized
+     * `storageConfig.storageKey` client-side; it must match.
+     */
+    cookieName?: string;
+    /** Force the resolved country, ignoring geo headers. */
+    country?: string;
+    /** Force the resolved region, ignoring geo headers. */
+    region?: string;
+    /** Force the resolved language, ignoring `Accept-Language`. */
+    language?: string;
+}
+/** Manifest-mode wiring shared by the route handlers and `loadConsent`. */
+export interface ConsentManifestOptions extends ManifestSourceConfig {
+    /** Fetch implementation. Defaults to the global `fetch`. */
+    fetch?: ManifestFetch;
+    /**
+     * Receives the promise of a background manifest revalidation started by
+     * this request, with the request event, so the host can keep it alive
+     * past the response on runtimes that stop detached work once a response
+     * is sent. Defaults to handing it to `event.platform.context.waitUntil`
+     * when the adapter provides one (Cloudflare, Vercel edge); nothing is
+     * registered otherwise. The promise never rejects. Not called when the
+     * manifest is fresh or the request itself waits on the upstream.
+     */
+    onBackgroundRevalidate?: (revalidation: Promise<void>, event: RequestEvent) => void;
+}

package/dist/kit/types.js

@@ -0,0 +1 @@
+export {};

package/dist/primitives/accordion/accordion-item-content.svelte

@@ -0,0 +1,35 @@
+<script lang="ts">
+	import { getOpenState } from '@c15t/ui/primitives';
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	import { getAccordionItemContext } from './context';
+
+	const item = getAccordionItemContext();
+
+	const open = $derived(item.open);
+	const triggerId = $derived(item.triggerId);
+	const contentId = $derived(item.contentId);
+	const dataState = $derived(getOpenState(open));
+
+	let {
+		children,
+		class: className,
+		...restProps
+	}: HTMLAttributes<HTMLElement> & {
+		children?: Snippet;
+		class?: string;
+	} = $props();
+</script>
+
+<section
+	id={contentId}
+	class={className}
+	aria-hidden={!open}
+	aria-labelledby={triggerId}
+	data-slot="accordion-content"
+	data-state={dataState}
+	{...restProps}
+>
+	{@render children?.()}
+</section>

package/dist/primitives/accordion/accordion-item-content.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLAttributes<HTMLElement> & {
+    children?: Snippet;
+    class?: string;
+};
+declare const AccordionItemContent: import("svelte").Component<$$ComponentProps, {}, "">;
+type AccordionItemContent = ReturnType<typeof AccordionItemContent>;
+export default AccordionItemContent;

package/dist/primitives/accordion/accordion-item-trigger.svelte

@@ -0,0 +1,54 @@
+<script lang="ts">
+	import { getDataDisabled, getOpenState } from '@c15t/ui/primitives';
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	import { getAccordionItemContext, getAccordionRootContext } from './context';
+
+	const root = getAccordionRootContext();
+	const item = getAccordionItemContext();
+
+	const open = $derived(item.open);
+	const disabled = $derived(item.disabled);
+	const triggerId = $derived(item.triggerId);
+	const contentId = $derived(item.contentId);
+	const itemValue = $derived(item.value);
+	const dataState = $derived(getOpenState(open));
+	const dataDisabled = $derived(getDataDisabled(disabled));
+
+	let {
+		children,
+		class: className,
+		onclick,
+		type = 'button',
+		...restProps
+	}: HTMLAttributes<HTMLButtonElement> & {
+		children?: Snippet;
+		class?: string;
+		type?: 'button' | 'submit' | 'reset';
+	} = $props();
+
+	const handleClick = function handleClick(
+		event: MouseEvent & { currentTarget: EventTarget & HTMLButtonElement }
+	) {
+		root.toggleItem(itemValue);
+		onclick?.(event);
+	};
+</script>
+
+<button
+	{type}
+	id={triggerId}
+	class={className}
+	aria-controls={contentId}
+	aria-disabled={disabled || undefined}
+	aria-expanded={open}
+	data-slot="accordion-trigger"
+	data-state={dataState}
+	data-disabled={dataDisabled}
+	{disabled}
+	{...restProps}
+	onclick={handleClick}
+>
+	{@render children?.()}
+</button>

package/dist/primitives/accordion/accordion-item-trigger.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLAttributes<HTMLButtonElement> & {
+    children?: Snippet;
+    class?: string;
+    type?: 'button' | 'submit' | 'reset';
+};
+declare const AccordionItemTrigger: import("svelte").Component<$$ComponentProps, {}, "">;
+type AccordionItemTrigger = ReturnType<typeof AccordionItemTrigger>;
+export default AccordionItemTrigger;

package/dist/primitives/accordion/accordion-item.svelte

@@ -0,0 +1,61 @@
+<script lang="ts">
+	import {
+		getDataDisabled,
+		getOpenState,
+		isAccordionItemOpen,
+	} from '@c15t/ui/primitives';
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	import { getAccordionRootContext, setAccordionItemContext } from './context';
+
+	const componentId = $props.id();
+	const root = getAccordionRootContext();
+
+	let {
+		children,
+		class: className,
+		disabled = false,
+		value,
+		...restProps
+	}: HTMLAttributes<HTMLDivElement> & {
+		children?: Snippet;
+		class?: string;
+		disabled?: boolean;
+		value: string;
+	} = $props();
+
+	const open = $derived(isAccordionItemOpen(root.type, root.value, value));
+	const dataState = $derived(getOpenState(open));
+	const dataDisabled = $derived(getDataDisabled(disabled));
+	const triggerId = `c15t-accordion-trigger-${componentId}`;
+	const contentId = `c15t-accordion-content-${componentId}`;
+
+	setAccordionItemContext({
+		get contentId() {
+			return contentId;
+		},
+		get disabled() {
+			return disabled;
+		},
+		get open() {
+			return open;
+		},
+		get triggerId() {
+			return triggerId;
+		},
+		get value() {
+			return value;
+		},
+	});
+</script>
+
+<div
+	class={className}
+	data-slot="accordion-item"
+	data-state={dataState}
+	data-disabled={dataDisabled}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

package/dist/primitives/accordion/accordion-item.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
+    children?: Snippet;
+    class?: string;
+    disabled?: boolean;
+    value: string;
+};
+declare const AccordionItem: import("svelte").Component<$$ComponentProps, {}, "">;
+type AccordionItem = ReturnType<typeof AccordionItem>;
+export default AccordionItem;

package/dist/primitives/accordion/accordion-root.svelte

@@ -0,0 +1,61 @@
+<script lang="ts">
+	import type { AccordionType } from '@c15t/ui/primitives';
+	import { toggleAccordionValue } from '@c15t/ui/primitives';
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	import { setAccordionRootContext } from './context';
+
+	let {
+		children,
+		class: className,
+		collapsible = false,
+		type,
+		value = $bindable<string | string[] | undefined>(
+			type === 'multiple' ? [] : undefined
+		),
+		...restProps
+	}: HTMLAttributes<HTMLDivElement> & {
+		children?: Snippet;
+		class?: string;
+		collapsible?: boolean;
+		type: AccordionType;
+		value?: string | string[];
+	} = $props();
+
+	const setValue = function setValue(nextValue: string | string[] | undefined) {
+		value = nextValue;
+	};
+
+	const toggleItem = function toggleItem(itemValue: string) {
+		setValue(
+			toggleAccordionValue({
+				collapsible,
+				itemValue,
+				type,
+				value,
+			})
+		);
+	};
+
+	setAccordionRootContext({
+		get collapsible() {
+			return collapsible;
+		},
+		toggleItem,
+		get type() {
+			return type;
+		},
+		get value() {
+			return value;
+		},
+	});
+</script>
+
+<div
+	class={className}
+	data-slot="accordion-root"
+	{...restProps}
+>
+	{@render children?.()}
+</div>

package/dist/primitives/accordion/accordion-root.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { AccordionType } from '@c15t/ui/primitives';
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
+    children?: Snippet;
+    class?: string;
+    collapsible?: boolean;
+    type: AccordionType;
+    value?: string | string[];
+};
+declare const AccordionRoot: import("svelte").Component<$$ComponentProps, {}, "value">;
+type AccordionRoot = ReturnType<typeof AccordionRoot>;
+export default AccordionRoot;

package/dist/primitives/accordion/context.d.ts

@@ -0,0 +1,18 @@
+import type { AccordionType } from '@c15t/ui/primitives';
+export interface AccordionRootContextValue {
+    readonly collapsible: boolean;
+    readonly type: AccordionType;
+    readonly value: string | string[] | undefined;
+    toggleItem: (itemValue: string) => void;
+}
+export interface AccordionItemContextValue {
+    readonly contentId: string;
+    readonly disabled: boolean;
+    readonly open: boolean;
+    readonly triggerId: string;
+    readonly value: string;
+}
+export declare const setAccordionRootContext: (value: AccordionRootContextValue) => void;
+export declare const getAccordionRootContext: () => AccordionRootContextValue;
+export declare const setAccordionItemContext: (value: AccordionItemContextValue) => void;
+export declare const getAccordionItemContext: () => AccordionItemContextValue;

package/dist/primitives/accordion/context.js

@@ -0,0 +1,23 @@
+import { getContext, setContext } from 'svelte';
+const ACCORDION_ROOT_CONTEXT_KEY = Symbol('c15t-svelte-accordion-root');
+const ACCORDION_ITEM_CONTEXT_KEY = Symbol('c15t-svelte-accordion-item');
+export const setAccordionRootContext = function setAccordionRootContext(value) {
+    setContext(ACCORDION_ROOT_CONTEXT_KEY, value);
+};
+export const getAccordionRootContext = function getAccordionRootContext() {
+    const context = getContext(ACCORDION_ROOT_CONTEXT_KEY);
+    if (!context) {
+        throw new Error('Accordion primitives must be used within Accordion.Root');
+    }
+    return context;
+};
+export const setAccordionItemContext = function setAccordionItemContext(value) {
+    setContext(ACCORDION_ITEM_CONTEXT_KEY, value);
+};
+export const getAccordionItemContext = function getAccordionItemContext() {
+    const context = getContext(ACCORDION_ITEM_CONTEXT_KEY);
+    if (!context) {
+        throw new Error('Accordion primitives must be used within Accordion.Item');
+    }
+    return context;
+};

package/dist/primitives/accordion/index.d.ts

@@ -0,0 +1,29 @@
+import ItemContent from './accordion-item-content.svelte';
+import ItemTrigger from './accordion-item-trigger.svelte';
+import Item from './accordion-item.svelte';
+import Root from './accordion-root.svelte';
+export declare const Accordion: {
+    Item: import("svelte").Component<import("svelte/elements").HTMLAttributes<HTMLDivElement> & {
+        children?: import("svelte").Snippet;
+        class?: string;
+        disabled?: boolean;
+        value: string;
+    }, {}, "">;
+    ItemContent: import("svelte").Component<import("svelte/elements").HTMLAttributes<HTMLElement> & {
+        children?: import("svelte").Snippet;
+        class?: string;
+    }, {}, "">;
+    ItemTrigger: import("svelte").Component<import("svelte/elements").HTMLAttributes<HTMLButtonElement> & {
+        children?: import("svelte").Snippet;
+        class?: string;
+        type?: "button" | "submit" | "reset";
+    }, {}, "">;
+    Root: import("svelte").Component<import("svelte/elements").HTMLAttributes<HTMLDivElement> & {
+        children?: import("svelte").Snippet;
+        class?: string;
+        collapsible?: boolean;
+        type: import("@c15t/ui/primitives").AccordionType;
+        value?: string | string[];
+    }, {}, "value">;
+};
+export { Item, ItemContent, ItemTrigger, Root };

package/dist/primitives/accordion/index.js

@@ -0,0 +1,11 @@
+import ItemContent from './accordion-item-content.svelte';
+import ItemTrigger from './accordion-item-trigger.svelte';
+import Item from './accordion-item.svelte';
+import Root from './accordion-root.svelte';
+export const Accordion = {
+    Item,
+    ItemContent,
+    ItemTrigger,
+    Root,
+};
+export { Item, ItemContent, ItemTrigger, Root };

package/dist/primitives/collapsible/collapsible-content.svelte

@@ -0,0 +1,36 @@
+<script lang="ts">
+	import { getCollapsibleState } from '@c15t/ui/primitives';
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	import { getCollapsibleRootContext } from './context';
+
+	const root = getCollapsibleRootContext();
+
+	const open = $derived(root.open);
+	const contentId = $derived(root.contentId);
+	const triggerId = $derived(root.triggerId);
+	const dataState = $derived(getCollapsibleState(open));
+
+	let {
+		children,
+		class: className,
+		...restProps
+	}: HTMLAttributes<HTMLDivElement> & {
+		children?: Snippet;
+		class?: string;
+	} = $props();
+</script>
+
+<div
+	id={contentId}
+	class={className}
+	aria-hidden={!open}
+	aria-labelledby={triggerId}
+	data-slot="collapsible-content"
+	data-state={dataState}
+	inert={!open}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

package/dist/primitives/collapsible/collapsible-content.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
+    children?: Snippet;
+    class?: string;
+};
+declare const CollapsibleContent: import("svelte").Component<$$ComponentProps, {}, "">;
+type CollapsibleContent = ReturnType<typeof CollapsibleContent>;
+export default CollapsibleContent;