rune-lab 0.4.5 → 0.4.7

package/dist/RuneProvider.svelte.d.ts

@@ -1,5 +1,5 @@
-import { SvelteComponentTyped } from "svelte";
-import type { PersistenceDriver } from "./kernel/src/mod.js";
+import { type Component, type Snippet } from "svelte";
+import type { PersistenceDriver, RunePlugin } from "./kernel/src/mod.js";
 import type { AppData } from "./kernel/src/mod.js";
 /**
  * Namespaced configuration for Rune Lab plugins.
@@ -16,22 +16,14 @@ export interface RuneLabConfig {
   /** Namespaced config for plugins */
   [pluginId: string]: unknown;
 }
-declare const __propDef: {
-  props: Record<string, never>;
-  events: {
-    [evt: string]: CustomEvent<any>;
-  };
-  slots: {};
-  exports?: {};
-  bindings?: string;
+type $$ComponentProps = {
+  children: Snippet;
+  config?: RuneLabConfig;
+  plugins?: RunePlugin[];
+  onThemeChange?: (newTheme: any, oldTheme: any) => void;
+  onLanguageChange?: (newLang: any, oldLang: any) => void;
+  onCurrencyChange?: (newCurrency: any, oldCurrency: any) => void;
 };
-export type RuneProviderProps = typeof __propDef.props;
-export type RuneProviderEvents = typeof __propDef.events;
-export type RuneProviderSlots = typeof __propDef.slots;
-export default class RuneProvider extends SvelteComponentTyped<
-  RuneProviderProps,
-  RuneProviderEvents,
-  RuneProviderSlots
-> {
-}
-export {};
+declare const RuneProvider: Component<$$ComponentProps, {}, "">;
+type RuneProvider = ReturnType<typeof RuneProvider>;
+export default RuneProvider;

package/dist/i18n/message-resolver.test.d.ts

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

package/dist/i18n/messages.d.ts

@@ -0,0 +1,2 @@
+import * as m from "./paraglide/messages.js";
+export { m };

package/dist/i18n/messages.js

@@ -0,0 +1,7 @@
+// @ts-ignore: paraglide-js generated files are hidden by .gitignore and missing declarations during type-check
+import * as m from "./paraglide/messages.js";
+// re-export all the messages as m
+export { m };
+// * Note: This is a re-export of the messages from the paraglide-js package.
+// * This is to reduce the `Could not find a declaration file for module` error.
+// This error always happens because the generated `paraglide` directory contains it's own `.gitignore` file, so, the typecheck doesn't see the generated files and throws an error, but the build still works. :)

package/dist/i18n/paraglide/README.md

@@ -4,7 +4,7 @@
 > strings.
 
 Compiled from:
-`/home/yrrrrrf/docs/lab/code/typescript/rune-lab/src/lib/i18n/project.inlang`
+`/home/yrrrrrf/docs/lab/code/typescript/rune-lab/src/package/src/lib/i18n/project.inlang`
 
 ## What is this folder?
 
@@ -101,18 +101,25 @@ for details.
 Messages can contain markup tags for bold, links, and other inline elements.
 Translators control where tags appear; developers control how they render.
 
+Important:
+
+- Tag names are app-defined. There is no built-in list of HTML tags.
+- `{#b}...{/b}` does not automatically render as `<b>...</b>`.
+- Renderers/snippets are looked up by the same tag name used in the message.
+
 ### Message syntax
 
 ```json
 {
-  "cta": "{#link to=|/docs|}Read the docs{/link}",
-  "bold_text": "This is {#bold}important{/bold}"
+  "cta": "{#link to=|/docs| rel=$relationship @track}Read the docs{/link}",
+  "welcome": "{#b}Hi {name}{/b}{#icon/}"
 }
 ```
 
 - `{#tagName}` opens a tag, `{/tagName}` closes it.
-- Options: `to=|/docs|` (accessed via `options.to`).
-- Attributes: `@track` (boolean, accessed via `attributes.track`).
+- `{#tagName/}` creates a standalone tag.
+- Options: `to=|/docs|` or `rel=$relationship` (accessed via `options.*`).
+- Attributes: `@track` or `@variant=|hero|` (accessed via `attributes.*`).
 
 This is the default inlang message syntax. Paraglide's message format is
 plugin-based — you can use
@@ -122,13 +129,18 @@ plugin-based — you can use
 
 ### Rendering markup
 
-Calling `m.cta()` returns **plain text** (markup stripped). To render markup,
-use the framework adapter or the low-level `parts()` API:
+Calling the message function still returns **plain text** (markup stripped):
 
 ```js
-const parts = m.cta.parts({});
+m.cta({ relationship: "noopener" }); // "Read the docs"
+```
+
+To render markup, use the framework adapter or the low-level `parts()` API:
+
+```js
+const parts = m.cta.parts({ relationship: "noopener" });
 // [
-//   { type: "markup-start", name: "link", options: { to: "/docs" }, attributes: {} },
+//   { type: "markup-start", name: "link", options: { to: "/docs", rel: "noopener" }, attributes: { track: true } },
 //   { type: "text", value: "Read the docs" },
 //   { type: "markup-end", name: "link" }
 // ]
@@ -146,14 +158,19 @@ renderers:
 import { ParaglideMessage } from "@inlang/paraglide-js-react"; // or -vue, -svelte, -solid
 
 <ParaglideMessage
-  message={m.cta}
-  inputs={{}}
+  message={m.welcome}
+  inputs={{ name: "Ada" }}
   markup={{
-    link: ({ children, options }) => <a href={options.to}>{children}</a>,
+    b: ({ children }) => <b>{children}</b>,
+    icon: () => <span aria-hidden="true" className="icon-wave" />,
   }}
 />;
 ```
 
+The available renderer/snippet names come from the message itself. You can
+inspect them through `message.parts()`, and TypeScript uses the same names to
+type-check your markup renderers.
+
 See the
 [markup documentation](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/markup)
 for details.

package/dist/i18n/paraglide/messages/_index.js

@@ -32,7 +32,6 @@ export * from "./themes.js";
 export * from "./all_themes.js";
 export * from "./all_currencies.js";
 export * from "./all_languages.js";
-export * from "./extended_controls.js";
 export * from "./light.js";
 export * from "./dark.js";
 export * from "./system.js";
@@ -69,20 +68,3 @@ export * from "./sunset.js";
 export * from "./caramellatte.js";
 export * from "./abyss.js";
 export * from "./silk.js";
-export * from "./live_store_dashboard.js";
-export * from "./real_time_monitor_desc.js";
-export * from "./api_status.js";
-export * from "./active_toasts.js";
-export * from "./commands_label.js";
-export * from "./app_info.js";
-export * from "./appearance.js";
-export * from "./localization.js";
-export * from "./name_label.js";
-export * from "./version_label.js";
-export * from "./current_theme.js";
-export * from "./current_language.js";
-export * from "./current_currency.js";
-export * from "./state_label.js";
-export * from "./url_label.js";
-export * from "./currently_in_queue.js";
-export * from "./registered_in_registry.js";

package/dist/i18n/paraglide/runtime.js

@@ -685,6 +685,10 @@ export function assertIsLocale(input) {
   );
 }
 
+/**
+ * @typedef {object} ExtractLocaleFromRequestOptions
+ * @property {string | URL} [effectiveRequestUrl] - Effective request URL to use for route matching and locale detection with the URL strategy.
+ */
 /**
  * Extracts a locale from a request.
  *
@@ -702,12 +706,18 @@ export function assertIsLocale(input) {
  *   const locale = extractLocaleFromRequest(request);
  *
  * @param {Request} request
+ * @param {ExtractLocaleFromRequestOptions} [options]
  * @returns {Locale}
  */
-export const extractLocaleFromRequest = (request) => {
+export const extractLocaleFromRequest = (request, options = {}) => {
+  const effectiveRequestUrl = resolveEffectiveRequestUrl(
+    request,
+    options.effectiveRequestUrl,
+  );
   return extractLocaleFromRequestWithStrategies(
     request,
-    getStrategyForUrl(request.url),
+    getStrategyForUrl(effectiveRequestUrl),
+    effectiveRequestUrl,
   );
 };
 /**
@@ -715,9 +725,15 @@ export const extractLocaleFromRequest = (request) => {
  *
  * @param {Request} request
  * @param {typeof strategy} strategies
+ * @param {string | URL} [url]
  * @returns {Locale}
  */
-export const extractLocaleFromRequestWithStrategies = (request, strategies) => {
+export const extractLocaleFromRequestWithStrategies = (
+  request,
+  strategies,
+  url = request.url,
+) => {
+  const effectiveRequestUrl = resolveEffectiveRequestUrl(request, url);
   /** @type {string|undefined} */
   let locale;
   for (const strat of strategies) {
@@ -728,7 +744,7 @@ export const extractLocaleFromRequestWithStrategies = (request, strategies) => {
         .find((c) => c.startsWith(cookieName + "="))
         ?.split("=")[1];
     } else if (TREE_SHAKE_URL_STRATEGY_USED && strat === "url") {
-      locale = extractLocaleFromUrl(request.url);
+      locale = extractLocaleFromUrl(effectiveRequestUrl);
     } else if (
       TREE_SHAKE_PREFERRED_LANGUAGE_STRATEGY_USED &&
       strat === "preferredLanguage"
@@ -754,6 +770,20 @@ export const extractLocaleFromRequestWithStrategies = (request, strategies) => {
     "No locale found. There is an error in your strategy. Try adding 'baseLocale' as the very last strategy. Read more here https://inlang.com/m/gerre34r/library-inlang-paraglideJs/errors#no-locale-found",
   );
 };
+/**
+ * @param {Request} request
+ * @param {string | URL | undefined} effectiveRequestUrl
+ * @returns {URL}
+ */
+function resolveEffectiveRequestUrl(
+  request,
+  effectiveRequestUrl = request.url,
+) {
+  if (effectiveRequestUrl instanceof URL) {
+    return new URL(effectiveRequestUrl.href);
+  }
+  return new URL(effectiveRequestUrl, request.url);
+}
 
 /**
  * Asynchronously extracts a locale from a request.
@@ -783,12 +813,17 @@ export const extractLocaleFromRequestWithStrategies = (request, strategies) => {
  *   const locale = await extractLocaleFromRequestAsync(request);
  *
  * @param {Request} request - The request object to extract the locale from.
+ * @param {{ effectiveRequestUrl?: string | URL }} [options] - Effective request URL to use for route matching and locale detection with the URL strategy.
  * @returns {Promise<Locale>} The extracted locale.
  */
-export const extractLocaleFromRequestAsync = async (request) => {
+export const extractLocaleFromRequestAsync = async (request, options = {}) => {
   /** @type {string|undefined} */
   let locale;
-  const strategy = getStrategyForUrl(request.url);
+  const effectiveRequestUrl = resolveEffectiveRequestUrlFromRequestAsync(
+    request,
+    options.effectiveRequestUrl,
+  );
+  const strategy = getStrategyForUrl(effectiveRequestUrl);
   // Process custom strategies first, in order
   for (const strat of strategy) {
     if (isCustomStrategy(strat) && customServerStrategies.has(strat)) {
@@ -805,8 +840,26 @@ export const extractLocaleFromRequestAsync = async (request) => {
     }
   }
   // If no custom strategy provided a valid locale, fall back to sync version
-  return extractLocaleFromRequestWithStrategies(request, strategy);
+  return extractLocaleFromRequestWithStrategies(
+    request,
+    strategy,
+    effectiveRequestUrl,
+  );
 };
+/**
+ * @param {Request} request
+ * @param {string | URL | undefined} effectiveRequestUrl
+ * @returns {URL}
+ */
+function resolveEffectiveRequestUrlFromRequestAsync(
+  request,
+  effectiveRequestUrl = request.url,
+) {
+  if (effectiveRequestUrl instanceof URL) {
+    return new URL(effectiveRequestUrl.href);
+  }
+  return new URL(effectiveRequestUrl, request.url);
+}
 
 /**
  * Extracts a cookie from the document.
@@ -1314,7 +1367,7 @@ export function aggregateGroups(match) {
 /**
  * @typedef {object} ShouldRedirectServerInput
  * @property {Request} request
- * @property {string | URL} [url]
+ * @property {string | URL} [effectiveRequestUrl] - Effective request URL to use for route matching, locale detection with the URL strategy, and redirect targets.
  * @property {Locale} [locale]
  *
  * @typedef {object} ShouldRedirectClientInput
@@ -1362,6 +1415,23 @@ export function aggregateGroups(match) {
  *   return render(request, decision.locale);
  * }
  *
+ * @example
+ * // Server side usage behind a proxy where request.url is not public-facing
+ * export async function handle(request) {
+ *   const effectiveRequestUrl = new URL(request.url);
+ *   effectiveRequestUrl.protocol = "https:";
+ *   effectiveRequestUrl.host = "example.com";
+ *
+ *   const decision = await shouldRedirect({
+ *     request,
+ *     effectiveRequestUrl,
+ *   });
+ *
+ *   if (decision.shouldRedirect) {
+ *     return Response.redirect(decision.redirectUrl, 307);
+ *   }
+ * }
+ *
  * @param {ShouldRedirectInput} [input]
  * @returns {Promise<ShouldRedirectResult>}
  */
@@ -1394,9 +1464,11 @@ async function resolveLocale(input, currentUrl) {
     return locale;
   }
   if (input.request) {
-    return extractLocaleFromRequestAsync(input.request);
+    return extractLocaleFromRequestAsync(input.request, {
+      effectiveRequestUrl: currentUrl,
+    });
   }
-  if (typeof input.url !== "undefined") {
+  if ("url" in input && typeof input.url !== "undefined") {
     return getLocaleForUrl(currentUrl.href);
   }
   return getLocale();
@@ -1408,13 +1480,27 @@ async function resolveLocale(input, currentUrl) {
  * @returns {URL}
  */
 function resolveUrl(input) {
+  if (
+    "effectiveRequestUrl" in input && input.effectiveRequestUrl instanceof URL
+  ) {
+    return new URL(input.effectiveRequestUrl.href);
+  }
+  if (
+    "effectiveRequestUrl" in input &&
+    typeof input.effectiveRequestUrl === "string"
+  ) {
+    return new URL(
+      input.effectiveRequestUrl,
+      input.request ? input.request.url : getUrlOrigin(),
+    );
+  }
   if (input.request) {
     return new URL(input.request.url);
   }
-  if (input.url instanceof URL) {
+  if ("url" in input && input.url instanceof URL) {
     return new URL(input.url.href);
   }
-  if (typeof input.url === "string") {
+  if ("url" in input && typeof input.url === "string") {
     return new URL(input.url, getUrlOrigin());
   }
   if (typeof window !== "undefined" && window?.location?.href) {

package/dist/i18n/paraglide/server.js

@@ -33,7 +33,10 @@ import * as runtime from "./runtime.js";
  *      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 {{ onRedirect:(response: Response) => void }} [callbacks] - Callbacks to handle events from middleware
+ * @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
@@ -88,17 +91,18 @@ import * as runtime from "./runtime.js";
  * }
  * ```
  */
-export async function paraglideMiddleware(request, resolve, callbacks) {
+export async function paraglideMiddleware(request, resolve, options) {
   if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
     const { AsyncLocalStorage } = await import("async_hooks");
     runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
   } else if (!runtime.serverAsyncLocalStorage) {
     runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
   }
-  if (runtime.isExcludedByRouteStrategy(request.url)) {
+  const url = resolveMiddlewareUrl(request, options?.effectiveRequestUrl);
+  const origin = url.origin;
+  if (runtime.isExcludedByRouteStrategy(url.href)) {
     const locale = runtime.baseLocale;
-    const origin = new URL(request.url).origin;
-    const newRequest = cloneRequestWithFallback(request);
+    const newRequest = cloneRequestWithFallback(request, url);
     /** @type {Set<string>} */
     const messageCalls = new Set();
     return /** @type {Response} */ (await runtime.serverAsyncLocalStorage?.run({
@@ -107,10 +111,12 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
       messageCalls,
     }, () => resolve({ locale, request: newRequest })));
   }
-  const strategy = runtime.getStrategyForUrl(request.url);
-  const decision = await runtime.shouldRedirect({ request });
+  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 (
@@ -131,7 +137,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
@@ -142,9 +148,9 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
   // the server can't render the correct page.
   let newRequest;
   if (strategy.includes("url")) {
-    newRequest = new Request(runtime.deLocalizeUrl(request.url), request);
+    newRequest = cloneRequestWithFallback(request, runtime.deLocalizeUrl(url));
   } else {
-    newRequest = cloneRequestWithFallback(request);
+    newRequest = cloneRequestWithFallback(request, url);
   }
   // the message functions that have been called in this request
   /** @type {Set<string>} */
@@ -170,10 +176,9 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
       messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
     }
     // Prevent translated content from terminating the inline script tag.
-    const escapedMessages = messages.join(",").replace(
-      /<\/(script)/gi,
-      "<\\/$1",
-    );
+    const escapedMessages = messages
+      .join(",")
+      .replace(/<\/(script)/gi, "<\\/$1");
     const script =
       `<script>globalThis.__paraglide = globalThis.__paraglide ?? {}; globalThis.__paraglide.ssr = { ${escapedMessages} }</script>`;
     // Insert the script before the closing head tag
@@ -190,6 +195,23 @@ 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
@@ -198,16 +220,33 @@ export async function paraglideMiddleware(request, resolve, callbacks) {
  * 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) {
+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(request.clone());
+    return new Request(targetUrl, request.clone());
   } catch {
     try {
-      return new Request(request);
+      return new Request(targetUrl, request);
     } catch {
       return request;
     }

package/dist/kernel/src/persistence/createConfigStore.svelte.js

@@ -22,15 +22,19 @@ class ConfigStoreImpl {
     if (saved && this.get(saved)) {
       this.current = saved;
     }
-    if (DEV) {
-      console.log(
-        `${options.icon ?? "⚙️"} ${options.displayName} configured:`,
-        {
-          current: this.current,
-        },
-      );
+    // Only log here if we were initialized with a real driver (not the default in-memory)
+    if (DEV && options.driver) {
+      this.#logConfig();
     }
   }
+  #logConfig() {
+    console.log(
+      `${this.#options.icon ?? "⚙️"} ${this.#options.displayName} configured:`,
+      {
+        current: this.current,
+      },
+    );
+  }
   /**
    * Replace the persistence driver and immediately re-read any saved value.
    *
@@ -46,6 +50,9 @@ class ConfigStoreImpl {
     if (saved && this.get(saved)) {
       this.current = saved;
     }
+    if (DEV) {
+      this.#logConfig();
+    }
   }
   /**
    * Set current item with validation

package/dist/kernel/src/persistence/drivers.test.d.ts

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

package/dist/kernel/src/persistence/provider.test.d.ts

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

package/dist/kernel/src/registry/registry.test.d.ts

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

package/dist/mod.js

@@ -4,4 +4,4 @@ export * from "./kernel/src/mod.js";
 export * from "./runes/layout/src/mod.js";
 export * from "./runes/palettes/src/mod.js";
 export * from "./runes/plugins/money/src/mod.js";
-export const version = () => "0.4.5";
+export const version = () => "0.4.7";

package/dist/runes/layout/src/AppSettingSelector.svelte

@@ -23,15 +23,7 @@
         tooltip,
         direction = "bottom",
         responsive = true,
-    } = $props<{
-        options: T[];
-        value: T;
-        item: Snippet<[T]>;
-        triggerLabel: Snippet<[T]>;
-        tooltip?: string;
-        direction?: "top" | "bottom" | "left" | "right" | "end" | "auto";
-        responsive?: boolean;
-    }>();
+    }: AppSettingSelectorProps<T> = $props();
 
     let modal = $state<HTMLDialogElement>();
 
@@ -150,7 +142,10 @@
                                     class="w-full text-left py-3 cursor-pointer hover:bg-base-200 px-4 transition-colors"
                                     onclick={() => modal?.close()}
                                     onkeydown={(e) => {
-                                        if (e.key === "Enter" || e.key === " ") {
+                                        if (
+                                            e.key === "Enter" ||
+                                            e.key === " "
+                                        ) {
                                             e.preventDefault();
                                             modal?.close();
                                         }

package/dist/runes/layout/src/AppSettingSelector.svelte.d.ts

@@ -1,4 +1,3 @@
-import { SvelteComponentTyped } from "svelte";
 import { type Snippet } from "svelte";
 export interface AppSettingSelectorProps<T> {
   options: T[];
@@ -9,26 +8,41 @@ export interface AppSettingSelectorProps<T> {
   direction?: "top" | "bottom" | "left" | "right" | "end" | "auto";
   responsive?: boolean;
 }
+declare function $$render<T>(): {
+  props: AppSettingSelectorProps<T>;
+  exports: {};
+  bindings: "";
+  slots: {};
+  events: {};
+};
 declare class __sveltets_Render<T> {
-  props(): Record<string, never>;
-  events(): {} & {
-    [evt: string]: CustomEvent<any>;
-  };
-  slots(): {};
+  props(): ReturnType<typeof $$render<T>>["props"];
+  events(): ReturnType<typeof $$render<T>>["events"];
+  slots(): ReturnType<typeof $$render<T>>["slots"];
+  bindings(): "";
+  exports(): {};
 }
-export type AppSettingSelectorProps_<T> = ReturnType<
-  __sveltets_Render<T>["props"]
->;
-export type AppSettingSelectorEvents<T> = ReturnType<
-  __sveltets_Render<T>["events"]
->;
-export type AppSettingSelectorSlots<T> = ReturnType<
-  __sveltets_Render<T>["slots"]
->;
-export default class AppSettingSelector<T> extends SvelteComponentTyped<
-  AppSettingSelectorProps_<T>,
-  AppSettingSelectorEvents<T>,
-  AppSettingSelectorSlots<T>
-> {
+interface $$IsomorphicComponent {
+  new <T>(
+    options: import("svelte").ComponentConstructorOptions<
+      ReturnType<__sveltets_Render<T>["props"]>
+    >,
+  ):
+    & import("svelte").SvelteComponent<
+      ReturnType<__sveltets_Render<T>["props"]>,
+      ReturnType<__sveltets_Render<T>["events"]>,
+      ReturnType<__sveltets_Render<T>["slots"]>
+    >
+    & {
+      $$bindings?: ReturnType<__sveltets_Render<T>["bindings"]>;
+    }
+    & ReturnType<__sveltets_Render<T>["exports"]>;
+  <T>(
+    internal: unknown,
+    props: ReturnType<__sveltets_Render<T>["props"]> & {},
+  ): ReturnType<__sveltets_Render<T>["exports"]>;
+  z_$$bindings?: ReturnType<__sveltets_Render<any>["bindings"]>;
 }
-export {};
+declare const AppSettingSelector: $$IsomorphicComponent;
+type AppSettingSelector<T> = InstanceType<typeof AppSettingSelector<T>>;
+export default AppSettingSelector;