@odx/foundation 1.0.0-beta.99 → 1.0.0-rc.0

package/dist/lib/format.d.ts

@@ -0,0 +1,58 @@
+import { UnitIdentifier } from './models.js';
+export interface FormatOptions {
+    dateTimeFormatOptions?: DateTimeFormatOptions;
+    numberFormatOptions?: NumberFormatOptions;
+    listFormatOptions?: ListFormatOptions;
+    relativeTimeFormatOptions?: RelativeTimeFormatOptions;
+}
+interface BaseFormatOptions {
+    locale?: Intl.Locale | Intl.UnicodeBCP47LocaleIdentifier;
+}
+export interface DateTimeFormatOptions extends Omit<Intl.DateTimeFormatOptions, 'dateStyle'>, BaseFormatOptions {
+    dateStyle?: 'iso8601' | Intl.DateTimeFormatOptions['dateStyle'];
+}
+export declare function parseDate(value: number | string | Date): Date | null;
+export declare function formatDate(input: number | string | Date, options?: DateTimeFormatOptions): string;
+export interface NumberFormatOptions extends Intl.NumberFormatOptions, BaseFormatOptions {
+    unit?: UnitIdentifier;
+}
+export declare function formatNumber(input: number | string, options?: NumberFormatOptions): string;
+export interface ListFormatOptions extends Intl.ListFormatOptions, BaseFormatOptions {
+}
+export declare function formatList(input: string[], options?: ListFormatOptions): string;
+declare const TIME_UNIT_MAP: {
+    readonly second: {
+        readonly max: 59000;
+        readonly value: 1000;
+    };
+    readonly minute: {
+        readonly max: 2760000;
+        readonly value: 60000;
+    };
+    readonly hour: {
+        readonly max: 72000000;
+        readonly value: 3600000;
+    };
+    readonly day: {
+        readonly max: 518400000;
+        readonly value: 86400000;
+    };
+    readonly week: {
+        readonly max: 2419200000;
+        readonly value: 604800000;
+    };
+    readonly month: {
+        readonly max: 28512000000;
+        readonly value: 2592000000;
+    };
+    readonly year: {
+        readonly max: number;
+        readonly value: 31536000000;
+    };
+};
+export interface RelativeTimeFormatOptions extends Intl.RelativeTimeFormatOptions, BaseFormatOptions {
+    minUnit?: keyof typeof TIME_UNIT_MAP;
+}
+export declare function formatRelativeTime(input: number | string | Date, options?: RelativeTimeFormatOptions): string;
+export {};
+//# sourceMappingURL=format.d.ts.map

package/dist/lib/format.js

@@ -0,0 +1,63 @@
+function parseDate(value) {
+  const createDate = (value2) => Number.isNaN(value2) ? null : new Date(value2);
+  if (value instanceof Date) {
+    return createDate(value.getTime());
+  }
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime()) && typeof value === "string") {
+    return createDate(Number(value));
+  }
+  return createDate(date.getTime());
+}
+function formatDate(input, options) {
+  const value = parseDate(input);
+  if (!value) return "";
+  if (options?.dateStyle === "iso8601") {
+    return new Intl.DateTimeFormat("sv-SE", { dateStyle: "short" }).format(value);
+  }
+  return new Intl.DateTimeFormat(options?.locale, options).format(value);
+}
+function formatNumber(input, options) {
+  const value = Number(input);
+  if (Number.isNaN(value)) return "";
+  if (options?.currency) {
+    options.style = "currency";
+  } else if (options?.unit) {
+    options.style = "unit";
+  }
+  return new Intl.NumberFormat(options?.locale, options).format(value);
+}
+function formatList(input, options) {
+  if (input.length === 0) return "";
+  return new Intl.ListFormat(options?.locale, options).format(input);
+}
+const TIME_UNIT_MAP = {
+  second: { max: 59e3, value: 1e3 },
+  // max 59 seconds
+  minute: { max: 276e4, value: 6e4 },
+  // max 46 minutes
+  hour: { max: 72e6, value: 36e5 },
+  // max 20 hours
+  day: { max: 5184e5, value: 864e5 },
+  // max 6 days
+  week: { max: 24192e5, value: 6048e5 },
+  // max 28 days
+  month: { max: 28512e6, value: 2592e6 },
+  // max 11 months
+  year: { max: Number.POSITIVE_INFINITY, value: 31536e6 }
+};
+function formatRelativeTime(input, options) {
+  const value = parseDate(input);
+  if (!value) return "";
+  const relativeTime = value.getTime() - Date.now();
+  const minUnit = options?.minUnit && TIME_UNIT_MAP[options.minUnit] || TIME_UNIT_MAP.second;
+  const [unit, unitConfig] = Object.entries(TIME_UNIT_MAP).find(
+    ([_, { value: value2, max }]) => Math.abs(relativeTime) < max && minUnit.value <= value2
+  );
+  return new Intl.RelativeTimeFormat(options?.locale, options).format(
+    Math.round(relativeTime / unitConfig.value),
+    unit
+  );
+}
+
+export { formatDate, formatList, formatNumber, formatRelativeTime, parseDate };

package/dist/lib/localization.d.ts

@@ -0,0 +1,12 @@
+import { FormatOptions } from './format.js';
+export interface LocalizationOptions extends FormatOptions {
+    defaultLocale: () => Intl.Locale | Intl.UnicodeBCP47LocaleIdentifier;
+    fallbackLanguage: () => Intl.UnicodeBCP47LocaleIdentifier;
+    fallbackTranslation: (key: string) => string;
+}
+export declare const LocalizationOptions: (config?: Partial<LocalizationOptions>) => LocalizationOptions;
+export declare function setLocalizationOptions(options?: Partial<LocalizationOptions> | null): void;
+export declare function getLocalizationOptions(options?: Partial<LocalizationOptions> | null): LocalizationOptions;
+export declare function getLocale(localeInput?: Intl.Locale | Intl.UnicodeBCP47LocaleIdentifier | null): Intl.Locale;
+export declare function setLocale(localeInput?: Intl.Locale | Intl.UnicodeBCP47LocaleIdentifier | null): void;
+//# sourceMappingURL=localization.d.ts.map

package/dist/lib/localization.js

@@ -0,0 +1,28 @@
+import { sharedSignal } from './signals.js';
+
+const locale = sharedSignal("locale", null);
+const localizationOptions = sharedSignal("localizationOptions", null);
+const LocalizationOptions = (config) => ({
+  defaultLocale: () => navigator.language,
+  fallbackLanguage: () => "en",
+  fallbackTranslation: (key) => key,
+  ...config,
+  relativeTimeFormatOptions: {
+    minUnit: "minute",
+    ...config?.relativeTimeFormatOptions
+  }
+});
+function setLocalizationOptions(options) {
+  localizationOptions.set(getLocalizationOptions(options));
+}
+function getLocalizationOptions(options) {
+  return LocalizationOptions(options ?? localizationOptions.get() ?? {});
+}
+function getLocale(localeInput) {
+  return new Intl.Locale(localeInput || locale.get() || getLocalizationOptions().defaultLocale());
+}
+function setLocale(localeInput) {
+  locale.set(localeInput ? getLocale(localeInput) : null);
+}
+
+export { LocalizationOptions, getLocale, getLocalizationOptions, setLocale, setLocalizationOptions };

package/dist/lib/models.d.ts

@@ -0,0 +1,39 @@
+export type Alignment = (typeof Alignment)[keyof typeof Alignment];
+export declare const Alignment: {
+    readonly START: "start";
+    readonly CENTER: "center";
+    readonly END: "end";
+};
+export type Spacing = (typeof Spacing)[keyof typeof Spacing];
+export declare const Spacing: {
+    readonly 0: "0";
+    readonly SM: "sm";
+    readonly MD: "md";
+    readonly LG: "lg";
+};
+export type Justify = (typeof Justify)[keyof typeof Justify];
+export declare const Justify: {
+    readonly START: "start";
+    readonly END: "end";
+    readonly CENTER: "center";
+    readonly SPACE_BETWEEN: "space-between";
+    readonly SPACE_AROUND: "space-around";
+    readonly SPACE_EVENLY: "space-evenly";
+};
+export type Variant = (typeof Variant)[keyof typeof Variant];
+export declare const Variant: {
+    readonly NEUTRAL: "neutral";
+    readonly PRIMARY: "primary";
+    readonly ACCENT: "accent";
+    readonly SUCCESS: "success";
+    readonly WARNING: "warning";
+    readonly DANGER: "danger";
+    readonly ACCENT_GHOST: "accent-ghost";
+    readonly DANGER_GHOST: "danger-ghost";
+    readonly CONFIRMATION: "confirmation";
+    readonly SUBTLE: "subtle";
+    readonly GHOST: "ghost";
+};
+export type UnitIdentifier = SingleUnitIdentifier | `${SingleUnitIdentifier}-per-${SingleUnitIdentifier}` | (string & {});
+export type SingleUnitIdentifier = 'acre' | 'bit' | 'byte' | 'celsius' | 'centimeter' | 'day' | 'degree' | 'fahrenheit' | 'fluid-ounce' | 'foot' | 'gallon' | 'gigabit' | 'gigabyte' | 'gram' | 'hectare' | 'hour' | 'inch' | 'kilobit' | 'kilobyte' | 'kilogram' | 'kilometer' | 'liter' | 'megabit' | 'megabyte' | 'meter' | 'microsecond' | 'mile' | 'mile-scandinavian' | 'milliliter' | 'millimeter' | 'millisecond' | 'minute' | 'month' | 'nanosecond' | 'ounce' | 'percent' | 'petabyte' | 'pound' | 'second' | 'stone' | 'terabit' | 'terabyte' | 'week' | 'yard' | 'year';
+//# sourceMappingURL=models.d.ts.map

package/dist/lib/models.js

@@ -0,0 +1,34 @@
+const Alignment = {
+  START: "start",
+  CENTER: "center",
+  END: "end"
+};
+const Spacing = {
+  0: "0",
+  SM: "sm",
+  MD: "md",
+  LG: "lg"
+};
+const Justify = {
+  START: "start",
+  END: "end",
+  CENTER: "center",
+  SPACE_BETWEEN: "space-between",
+  SPACE_AROUND: "space-around",
+  SPACE_EVENLY: "space-evenly"
+};
+const Variant = {
+  NEUTRAL: "neutral",
+  PRIMARY: "primary",
+  ACCENT: "accent",
+  SUCCESS: "success",
+  WARNING: "warning",
+  DANGER: "danger",
+  ACCENT_GHOST: "accent-ghost",
+  DANGER_GHOST: "danger-ghost",
+  CONFIRMATION: "confirmation",
+  SUBTLE: "subtle",
+  GHOST: "ghost"
+};
+
+export { Alignment, Justify, Spacing, Variant };

package/dist/lib/signals.d.ts

@@ -0,0 +1,20 @@
+import { Signal as NativeSignal } from 'signal-polyfill';
+export type Signal<T> = NativeSignal.State<T> & {
+    update: (updateFn: (value: T) => T) => void;
+};
+export type SignalOptions<T> = NativeSignal.Options<T> & {
+    watched?(): void;
+    unwatched?(): void;
+};
+export type ReadonlySignal<T> = NativeSignal.Computed<T>;
+export declare function signal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
+/**
+ * Creates or retrieves a shared signal stored on the global object. This is useful for signals that need to be shared across multiple modules without explicitly passing them around, such as localization settings or translation records.
+ */
+export declare function sharedSignal<T>(key: string, ...args: Parameters<typeof signal<T>>): ReturnType<typeof signal<T>>;
+export declare function computed<T>(computeFn: () => T, options?: SignalOptions<T>): ReadonlySignal<T>;
+export declare function effect(callback: (() => void) | (() => () => void)): () => void;
+declare global {
+    var __ODX_SHARED_SIGNALS__: Record<string, unknown>;
+}
+//# sourceMappingURL=signals.d.ts.map

package/dist/lib/signals.js

@@ -0,0 +1,47 @@
+import { Signal } from 'signal-polyfill';
+
+function transformOptions(options) {
+  if (!options) return;
+  return { equals: options.equals, [Signal.subtle.watched]: options.watched, [Signal.subtle.unwatched]: options.unwatched };
+}
+function signal(value, options) {
+  const state = new Signal.State(value, transformOptions(options));
+  state.update = (updateFn) => state.set(updateFn(state.get()));
+  return state;
+}
+function sharedSignal(key, ...args) {
+  if (!(key in globalThis.__ODX_SHARED_SIGNALS__)) {
+    globalThis.__ODX_SHARED_SIGNALS__[key] = signal(...args);
+  }
+  return globalThis.__ODX_SHARED_SIGNALS__[key];
+}
+function computed(computeFn, options) {
+  return new Signal.Computed(computeFn, transformOptions(options));
+}
+let needsEnqueue = true;
+const watcher = new Signal.subtle.Watcher(() => {
+  if (!needsEnqueue) return;
+  needsEnqueue = false;
+  queueMicrotask(() => {
+    needsEnqueue = true;
+    for (const signal2 of watcher.getPending()) signal2.get();
+    watcher.watch();
+  });
+});
+function effect(callback) {
+  let cleanup;
+  const signal2 = computed(() => {
+    cleanup?.();
+    cleanup = callback() || void 0;
+  });
+  watcher.watch(signal2);
+  signal2.get();
+  return () => {
+    watcher.unwatch(signal2);
+    cleanup?.();
+    cleanup = void 0;
+  };
+}
+globalThis.__ODX_SHARED_SIGNALS__ ||= {};
+
+export { computed, effect, sharedSignal, signal };

package/dist/lib/theming.d.ts

@@ -0,0 +1,18 @@
+import { ThemeConfig } from '@odx/design-tokens';
+import { ReadonlySignal } from './signals.js';
+declare global {
+    var odxDarkModeEnabled: ReadonlySignal<boolean> | undefined;
+    var __ODX_THEME_ROOT__: HTMLElement;
+}
+export declare const userPrefersDarkMode: boolean;
+export declare const darkModeIcon = "core::night-mode";
+export declare const lightModeIcon = "core::brightness";
+export declare function setTheme(config: ThemeConfig, root?: HTMLElement): void;
+export declare function isDarkModeEnabled(): boolean;
+export declare function toggleDarkMode(enabled?: boolean | 'auto', root?: HTMLElement): void;
+export interface AttachDarkModeToggleOptions<T extends HTMLElement> {
+    update?(host: T, darkModeEnabled: boolean, icon: string): void;
+    root?: HTMLElement;
+}
+export declare function attachDarkModeToggle<T extends HTMLElement>(host: T, options?: AttachDarkModeToggleOptions<T>): () => void;
+//# sourceMappingURL=theming.d.ts.map

package/dist/lib/theming.js

@@ -0,0 +1,38 @@
+import { darkModeClass, lightModeClass, setTheme as setTheme$1 } from '@odx/design-tokens';
+import { sharedSignal, effect } from './signals.js';
+
+const { matches: userPrefersDarkMode = false } = globalThis.matchMedia?.("(prefers-color-scheme: dark)") ?? {};
+const darkModeIcon = "core::night-mode";
+const lightModeIcon = "core::brightness";
+const hasDarkModeClass = document.documentElement.classList.contains(darkModeClass);
+const hasLightModeClass = document.documentElement.classList.contains(lightModeClass);
+const darkModeEnabled = sharedSignal("darkModeEnabled", hasDarkModeClass || hasLightModeClass ? hasDarkModeClass : userPrefersDarkMode);
+globalThis.__ODX_THEME_ROOT__ ??= document.documentElement;
+function setTheme(config, root = globalThis.__ODX_THEME_ROOT__) {
+  setTheme$1(config, root);
+  if (config.mode === "auto") {
+    darkModeEnabled.set(userPrefersDarkMode);
+  } else {
+    darkModeEnabled.set(config.mode === "dark" ? true : !isDarkModeEnabled());
+  }
+}
+function isDarkModeEnabled() {
+  return darkModeEnabled.get();
+}
+function toggleDarkMode(enabled, root = globalThis.__ODX_THEME_ROOT__) {
+  if (enabled === "auto") {
+    setTheme({ mode: enabled }, root);
+  } else {
+    setTheme({ mode: enabled ? "dark" : "light" }, root);
+  }
+}
+function attachDarkModeToggle(host, options = {}) {
+  host.addEventListener("click", () => toggleDarkMode(void 0, options.root));
+  return effect(() => {
+    const darkModeEnabled2 = isDarkModeEnabled();
+    host.setAttribute("icon", darkModeEnabled2 ? darkModeIcon : lightModeIcon);
+    options.update?.(host, darkModeEnabled2, darkModeEnabled2 ? darkModeIcon : lightModeIcon);
+  });
+}
+
+export { attachDarkModeToggle, darkModeIcon, isDarkModeEnabled, lightModeIcon, setTheme, toggleDarkMode, userPrefersDarkMode };

package/dist/lib/utils/breakpoint.d.ts

@@ -0,0 +1,38 @@
+import { Signal } from '../signals.js';
+declare global {
+    namespace ODX.Breakpoints {
+        interface Config {
+            sm: true;
+            md: true;
+            lg: true;
+            xl: true;
+        }
+    }
+}
+type FilteredKeys<T extends object> = {
+    [K in keyof T as T[K] extends true ? K : never]: T[K];
+};
+export type BreakpointOperator = '<' | '<=' | '>=' | '>';
+export interface BreakpointConfig {
+    name: keyof FilteredKeys<ODX.Breakpoints.Config>;
+    min: number;
+    max: number;
+    customQuery?: string;
+}
+export interface Breakpoint extends BreakpointConfig {
+    id: BreakpointConfig['name'] | `${BreakpointOperator}${BreakpointConfig['name']}`;
+    query: string;
+    operator?: BreakpointOperator;
+}
+export declare const registeredBreakpoints: ReadonlyMap<Breakpoint['id'], Breakpoint>;
+export declare const breakpointAttribute = "odx-breakpoint";
+export declare function buildBreakpoint(breakpoint: BreakpointConfig, operator?: BreakpointOperator): Breakpoint;
+export declare function expandBreakpoints(...breakpoints: BreakpointConfig[]): Breakpoint[];
+export declare function observeBreakpoint(id: Breakpoint['id'], initialValue?: boolean): Signal<Breakpoint & {
+    matches: boolean;
+}>;
+export declare function createBreakpointUpdater(breakpoints: Breakpoint[], update?: (target: HTMLElement, change: Breakpoint & {
+    matches: boolean;
+}) => void): () => void;
+export {};
+//# sourceMappingURL=breakpoint.d.ts.map

package/dist/lib/utils/breakpoint.js

@@ -0,0 +1,103 @@
+import { signal } from '../signals.js';
+import { observeMedia } from './shared-media-observer.js';
+
+const operators = ["<", "<=", ">=", ">"];
+const registeredBreakpoints = /* @__PURE__ */ new Map();
+const breakpointAttribute = "odx-breakpoint";
+function buildBreakpoint(breakpoint, operator) {
+  const id = operator ? `${operator}${breakpoint.name}` : breakpoint.name;
+  let query = `(min-width: ${breakpoint.min}px) and (max-width: ${breakpoint.max}px)`;
+  switch (operator) {
+    case "<":
+      query = `(max-width: ${breakpoint.min - 0.02}px)`;
+      break;
+    case "<=":
+      query = `(max-width: ${breakpoint.max}px)`;
+      break;
+    case ">=":
+      query = `(min-width: ${breakpoint.min}px)`;
+      break;
+    case ">":
+      query = `(min-width: ${breakpoint.max + 0.02}px)`;
+      break;
+  }
+  return { ...breakpoint, id, operator, query: [query, breakpoint.customQuery].filter(Boolean).join(" and ") };
+}
+function expandBreakpoints(...breakpoints) {
+  return breakpoints.flatMap((breakpoint) => [void 0, ...operators].map((operator) => buildBreakpoint(breakpoint, operator)));
+}
+function observeBreakpoint(id, initialValue = false) {
+  const breakpoint = registeredBreakpoints.get(id);
+  let unobserveMedia;
+  const state = signal(
+    { ...breakpoint, matches: initialValue },
+    {
+      watched() {
+        if (!breakpoint) return;
+        unobserveMedia = observeMedia(breakpoint.query, ({ matches }) => {
+          state.set({ ...breakpoint, matches });
+        });
+      },
+      unwatched() {
+        unobserveMedia?.();
+        unobserveMedia = void 0;
+      }
+    }
+  );
+  return state;
+}
+function createBreakpointUpdater(breakpoints, update) {
+  for (const breakpoint of breakpoints) {
+    registeredBreakpoints.set(breakpoint.id, breakpoint);
+  }
+  const breakpointCache = /* @__PURE__ */ new WeakMap();
+  const breakpointObservers = breakpoints.map((breakpoint) => observeBreakpoint(breakpoint.id, false));
+  return () => {
+    const elements = document.querySelectorAll(`[${breakpointAttribute}]`);
+    const changes = breakpointObservers.reduce(
+      (breakpoints2, breakpoint) => {
+        breakpoints2[breakpoint.get().id] = breakpoint.get();
+        return breakpoints2;
+      },
+      {}
+    );
+    let i = elements.length;
+    while (i--) {
+      const element = elements[i];
+      const change = changes[element.getAttribute(breakpointAttribute) || ""];
+      if (!change || change.matches === breakpointCache.get(element)) continue;
+      breakpointCache.set(element, change.matches);
+      updateHostElement(element, change.matches);
+      update?.(element, change);
+    }
+  };
+}
+function updateHostElement(host, active) {
+  const attributeName = "data-odx-breakpoint-slot";
+  const classNames = host.getAttribute("odx-breakpoint-class");
+  if (classNames) {
+    for (const className of classNames.split(" ")) {
+      host.classList.toggle(className, active);
+    }
+    return;
+  }
+  host.hidden = !active;
+  let initialSlot = host.getAttribute(attributeName);
+  if (initialSlot == null) {
+    initialSlot = host.slot;
+    host.setAttribute(attributeName, initialSlot);
+  }
+  if (active) {
+    host.removeAttribute(attributeName);
+    if (initialSlot === "") {
+      host.removeAttribute("slot");
+      return;
+    }
+    host.slot = "";
+    host.slot = initialSlot;
+  } else {
+    host.slot = "_odx_breakpoint_hidden";
+  }
+}
+
+export { breakpointAttribute, buildBreakpoint, createBreakpointUpdater, expandBreakpoints, observeBreakpoint, registeredBreakpoints };

package/dist/lib/utils/shared-media-observer.d.ts

@@ -0,0 +1,4 @@
+export type MediaObserverEventListener = (event: MediaQueryListEvent) => void;
+export declare function observeMedia(query: string, listener: MediaObserverEventListener): () => void;
+export declare function unobserveMedia(query: string, listener: MediaObserverEventListener): void;
+//# sourceMappingURL=shared-media-observer.d.ts.map

package/dist/lib/utils/shared-media-observer.js

@@ -0,0 +1,43 @@
+const mediaQueryRegistry = /* @__PURE__ */ new Map();
+const eventListenerRegistry = /* @__PURE__ */ new Map();
+function handleMediaChange(event) {
+  const listeners = eventListenerRegistry.get(event.media);
+  if (!listeners?.size) return;
+  const listenersArray = Array.from(listeners);
+  let i = listenersArray.length;
+  while (i--) {
+    listenersArray[i]?.(event);
+  }
+}
+function observeMedia(query, listener) {
+  let listeners = eventListenerRegistry.get(query);
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    eventListenerRegistry.set(query, listeners);
+  }
+  listeners.add(listener);
+  let mediaQueryList = mediaQueryRegistry.get(query);
+  if (!mediaQueryList) {
+    mediaQueryList = globalThis.matchMedia(query);
+    mediaQueryRegistry.set(query, mediaQueryList);
+    mediaQueryList.addEventListener("change", handleMediaChange);
+  }
+  const initialEvent = new MediaQueryListEvent("change", {
+    media: mediaQueryList.media,
+    matches: mediaQueryList.matches
+  });
+  listener(initialEvent);
+  return () => unobserveMedia(query, listener);
+}
+function unobserveMedia(query, listener) {
+  const listeners = eventListenerRegistry.get(query);
+  if (!listeners?.delete(listener)) return;
+  if (listeners.size > 0) return;
+  eventListenerRegistry.delete(query);
+  const mediaQueryList = mediaQueryRegistry.get(query);
+  if (!mediaQueryList) return;
+  mediaQueryList.removeEventListener("change", handleMediaChange);
+  mediaQueryRegistry.delete(query);
+}
+
+export { observeMedia, unobserveMedia };

package/dist/main.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/breakpoints.js';
+export * from './lib/format.js';
+export * from './lib/localization.js';
+export type { UnitIdentifier } from './lib/models.js';
+export * from './lib/signals.js';
+export * from './lib/theming.js';
+//# sourceMappingURL=main.d.ts.map