origam 2.5.0 → 2.6.2

package/dist/src/nuxt/plugin.client.js

@@ -1,6 +1,5 @@
 import { watch } from "vue";
 import { useTheme } from "../composables/index.js";
-import { ORIGAM_THEME_ATTR } from "../consts/index.js";
 import { createOrigam } from "../origam.js";
 import { defineNuxtPlugin, useCookie, useRuntimeConfig } from "#app";
 export default defineNuxtPlugin({
@@ -8,27 +7,46 @@ export default defineNuxtPlugin({
   setup(nuxtApp) {
     const runtimeConfig = useRuntimeConfig().public;
     const config = runtimeConfig.origam;
-    const cookie = useCookie(config.cookieName, {
+    const themeCookie = useCookie(config.cookieName, {
       maxAge: config.cookieMaxAge,
       sameSite: "lax",
       path: "/"
     });
-    const fromDom = typeof document !== "undefined" && document.documentElement.dataset.theme || null;
-    const initialTheme = fromDom ?? cookie.value ?? config.defaultTheme;
-    const origam = createOrigam();
+    const modeCookie = useCookie(config.modeCookieName, {
+      maxAge: config.cookieMaxAge,
+      sameSite: "lax",
+      path: "/"
+    });
+    const themeFromDom = typeof document !== "undefined" && document.documentElement.dataset.theme || null;
+    const initialTheme = themeFromDom ?? themeCookie.value ?? config.defaultTheme;
+    const initialMode = modeCookie.value ?? config.defaultMode;
+    const themes = config.themes ?? [];
+    const origam = createOrigam({ themes, ssr: true });
     nuxtApp.vueApp.use(origam);
     const themeApi = useTheme();
     themeApi.setTheme(initialTheme);
+    themeApi.setMode(initialMode);
+    watch(
+      [themeApi.theme, themeApi.resolvedMode],
+      ([brand, mode]) => {
+        origam._defaultsRef.value = origam._activeDefaultsFor(
+          brand === "auto" ? "" : brand,
+          mode
+        );
+      },
+      { immediate: true }
+    );
     watch(themeApi.theme, (next) => {
-      cookie.value = next;
-      if (typeof document !== "undefined") {
-        document.documentElement.setAttribute(ORIGAM_THEME_ATTR, next);
-      }
+      themeCookie.value = next;
+    }, { flush: "post" });
+    watch(themeApi.mode, (next) => {
+      modeCookie.value = next;
     }, { flush: "post" });
     return {
       provide: {
         origam: {
-          theme: initialTheme
+          theme: initialTheme,
+          mode: initialMode
         }
       }
     };

package/dist/src/nuxt/plugin.server.cjs

@@ -5,20 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 
 var _origam = require("../origam.cjs");
+var _applyTheme = require("../utils/Theme/apply-theme.util.cjs");
 var _consts = require("../consts/index.cjs");
 var _app = require("#app");
-function resolveServerTheme(cookieValue, config, headers) {
+function resolveServerTheme(cookieValue, config) {
   if (cookieValue && cookieValue !== _consts.ORIGAM_THEME_AUTO) {
     return cookieValue;
   }
-  if (config.defaultTheme && config.defaultTheme !== _consts.ORIGAM_THEME_AUTO && cookieValue !== _consts.ORIGAM_THEME_AUTO) {
+  if (config.defaultTheme && config.defaultTheme !== _consts.ORIGAM_THEME_AUTO) {
     return config.defaultTheme;
   }
+  return _consts.ORIGAM_THEME_AUTO;
+}
+function resolveServerMode(cookieValue, config, headers) {
+  if (cookieValue === _consts.ORIGAM_MODE_LIGHT || cookieValue === _consts.ORIGAM_MODE_DARK) {
+    return cookieValue;
+  }
+  if (config.defaultMode === _consts.ORIGAM_MODE_LIGHT || config.defaultMode === _consts.ORIGAM_MODE_DARK) {
+    return config.defaultMode;
+  }
   const hint = headers["sec-ch-prefers-color-scheme"];
-  if (hint === _consts.ORIGAM_THEME_DARK) {
-    return config.themes.includes(_consts.ORIGAM_THEME_DARK) ? _consts.ORIGAM_THEME_DARK : config.themes[0] ?? _consts.ORIGAM_THEME_LIGHT;
+  if (hint === _consts.ORIGAM_MODE_DARK && config.modes.includes(_consts.ORIGAM_MODE_DARK)) {
+    return _consts.ORIGAM_MODE_DARK;
   }
-  return config.themes.includes(_consts.ORIGAM_THEME_LIGHT) ? _consts.ORIGAM_THEME_LIGHT : config.themes[0] ?? _consts.ORIGAM_THEME_LIGHT;
+  if (hint === _consts.ORIGAM_MODE_LIGHT && config.modes.includes(_consts.ORIGAM_MODE_LIGHT)) {
+    return _consts.ORIGAM_MODE_LIGHT;
+  }
+  return _consts.ORIGAM_MODE_LIGHT;
 }
 module.exports = (0, _app.defineNuxtPlugin)({
   name: "origam:server",
@@ -26,24 +39,51 @@ module.exports = (0, _app.defineNuxtPlugin)({
   setup(nuxtApp) {
     const runtimeConfig = (0, _app.useRuntimeConfig)().public;
     const config = runtimeConfig.origam;
-    const cookie = (0, _app.useCookie)(config.cookieName, {
+    const themeCookie = (0, _app.useCookie)(config.cookieName, {
+      maxAge: config.cookieMaxAge,
+      sameSite: "lax",
+      path: "/"
+    });
+    const modeCookie = (0, _app.useCookie)(config.modeCookieName, {
       maxAge: config.cookieMaxAge,
       sameSite: "lax",
       path: "/"
     });
     const headers = (0, _app.useRequestHeaders)(["sec-ch-prefers-color-scheme"]);
-    const resolved = resolveServerTheme(cookie.value, config, headers);
+    const resolvedTheme = resolveServerTheme(themeCookie.value, config);
+    const resolvedMode = resolveServerMode(modeCookie.value, config, headers);
+    const htmlAttrs = {
+      [_consts.ORIGAM_MODE_ATTR]: resolvedMode
+    };
+    if (resolvedTheme !== _consts.ORIGAM_THEME_AUTO) {
+      htmlAttrs[_consts.ORIGAM_THEME_ATTR] = resolvedTheme;
+    }
+    const themes = config.themes ?? [];
+    const activeThemes = themes.filter(theme => {
+      const brandMatches = resolvedTheme === _consts.ORIGAM_THEME_AUTO ? theme.name === void 0 || theme.name === "" : theme.name === resolvedTheme;
+      const modeMatches = theme.mode === void 0 || theme.mode === resolvedMode;
+      return brandMatches && modeMatches;
+    });
+    const ssrThemeCss = activeThemes.map(_applyTheme.themeToCss).join("\n");
     (0, _app.useHead)({
-      htmlAttrs: {
-        "data-theme": resolved
-      }
+      htmlAttrs,
+      style: ssrThemeCss ? [{
+        id: "origam-theme-ssr",
+        key: "origam-theme-ssr",
+        innerHTML: ssrThemeCss
+      }] : []
+    });
+    const origam = (0, _origam.createOrigam)({
+      themes,
+      ssr: true
     });
-    const origam = (0, _origam.createOrigam)();
+    origam._defaultsRef.value = origam._activeDefaultsFor(resolvedTheme === _consts.ORIGAM_THEME_AUTO ? "" : resolvedTheme, resolvedMode);
     nuxtApp.vueApp.use(origam);
     return {
       provide: {
         origam: {
-          theme: resolved
+          theme: resolvedTheme,
+          mode: resolvedMode
         }
       }
     };

package/dist/src/nuxt/plugin.server.js

@@ -1,18 +1,37 @@
 import { createOrigam } from "../origam.js";
-import { ORIGAM_THEME_AUTO, ORIGAM_THEME_DARK, ORIGAM_THEME_LIGHT } from "../consts/index.js";
+import { themeToCss } from "../utils/Theme/apply-theme.util.js";
+import {
+  ORIGAM_MODE_ATTR,
+  ORIGAM_MODE_DARK,
+  ORIGAM_MODE_LIGHT,
+  ORIGAM_THEME_ATTR,
+  ORIGAM_THEME_AUTO
+} from "../consts/index.js";
 import { defineNuxtPlugin, useCookie, useHead, useRequestHeaders, useRuntimeConfig } from "#app";
-function resolveServerTheme(cookieValue, config, headers) {
+function resolveServerTheme(cookieValue, config) {
   if (cookieValue && cookieValue !== ORIGAM_THEME_AUTO) {
     return cookieValue;
   }
-  if (config.defaultTheme && config.defaultTheme !== ORIGAM_THEME_AUTO && cookieValue !== ORIGAM_THEME_AUTO) {
+  if (config.defaultTheme && config.defaultTheme !== ORIGAM_THEME_AUTO) {
     return config.defaultTheme;
   }
+  return ORIGAM_THEME_AUTO;
+}
+function resolveServerMode(cookieValue, config, headers) {
+  if (cookieValue === ORIGAM_MODE_LIGHT || cookieValue === ORIGAM_MODE_DARK) {
+    return cookieValue;
+  }
+  if (config.defaultMode === ORIGAM_MODE_LIGHT || config.defaultMode === ORIGAM_MODE_DARK) {
+    return config.defaultMode;
+  }
   const hint = headers["sec-ch-prefers-color-scheme"];
-  if (hint === ORIGAM_THEME_DARK) {
-    return config.themes.includes(ORIGAM_THEME_DARK) ? ORIGAM_THEME_DARK : config.themes[0] ?? ORIGAM_THEME_LIGHT;
+  if (hint === ORIGAM_MODE_DARK && config.modes.includes(ORIGAM_MODE_DARK)) {
+    return ORIGAM_MODE_DARK;
+  }
+  if (hint === ORIGAM_MODE_LIGHT && config.modes.includes(ORIGAM_MODE_LIGHT)) {
+    return ORIGAM_MODE_LIGHT;
   }
-  return config.themes.includes(ORIGAM_THEME_LIGHT) ? ORIGAM_THEME_LIGHT : config.themes[0] ?? ORIGAM_THEME_LIGHT;
+  return ORIGAM_MODE_LIGHT;
 }
 export default defineNuxtPlugin({
   name: "origam:server",
@@ -20,24 +39,47 @@ export default defineNuxtPlugin({
   setup(nuxtApp) {
     const runtimeConfig = useRuntimeConfig().public;
     const config = runtimeConfig.origam;
-    const cookie = useCookie(config.cookieName, {
+    const themeCookie = useCookie(config.cookieName, {
+      maxAge: config.cookieMaxAge,
+      sameSite: "lax",
+      path: "/"
+    });
+    const modeCookie = useCookie(config.modeCookieName, {
       maxAge: config.cookieMaxAge,
       sameSite: "lax",
       path: "/"
     });
     const headers = useRequestHeaders(["sec-ch-prefers-color-scheme"]);
-    const resolved = resolveServerTheme(cookie.value, config, headers);
+    const resolvedTheme = resolveServerTheme(themeCookie.value, config);
+    const resolvedMode = resolveServerMode(modeCookie.value, config, headers);
+    const htmlAttrs = {
+      [ORIGAM_MODE_ATTR]: resolvedMode
+    };
+    if (resolvedTheme !== ORIGAM_THEME_AUTO) {
+      htmlAttrs[ORIGAM_THEME_ATTR] = resolvedTheme;
+    }
+    const themes = config.themes ?? [];
+    const activeThemes = themes.filter((theme) => {
+      const brandMatches = resolvedTheme === ORIGAM_THEME_AUTO ? theme.name === void 0 || theme.name === "" : theme.name === resolvedTheme;
+      const modeMatches = theme.mode === void 0 || theme.mode === resolvedMode;
+      return brandMatches && modeMatches;
+    });
+    const ssrThemeCss = activeThemes.map(themeToCss).join("\n");
     useHead({
-      htmlAttrs: {
-        "data-theme": resolved
-      }
+      htmlAttrs,
+      style: ssrThemeCss ? [{ id: "origam-theme-ssr", key: "origam-theme-ssr", innerHTML: ssrThemeCss }] : []
     });
-    const origam = createOrigam();
+    const origam = createOrigam({ themes, ssr: true });
+    origam._defaultsRef.value = origam._activeDefaultsFor(
+      resolvedTheme === ORIGAM_THEME_AUTO ? "" : resolvedTheme,
+      resolvedMode
+    );
     nuxtApp.vueApp.use(origam);
     return {
       provide: {
         origam: {
-          theme: resolved
+          theme: resolvedTheme,
+          mode: resolvedMode
         }
       }
     };

package/dist/src/origam.cjs

@@ -3,12 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.activeDefaultsFor = activeDefaultsFor;
 exports.createOrigam = createOrigam;
 var origamComponents = _interopRequireWildcard(require("./components/index.cjs"));
 var _composables = require("./composables/index.cjs");
 var _consts = require("./consts/index.cjs");
 var origamDirectives = _interopRequireWildcard(require("./directives/index.cjs"));
+var _contrast = require("./directives/Contrast/contrast.directive.cjs");
 var _utils = require("./utils/index.cjs");
+var _origam = require("./themes/origam.theme.cjs");
 require("@mdi/font/css/materialdesignicons.css");
 var _vue = require("vue");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
@@ -24,6 +27,11 @@ function createOrigam(origam = {}) {
     components = origamComponents,
     directives = origamDirectives
   } = options;
+  const suppliedThemes = [...(options.theme ? [options.theme] : []), ...(options.themes ?? [])];
+  const allThemes = [..._origam.origamTheme, ...suppliedThemes];
+  const installedThemes = (0, _utils.installedThemesFromList)(allThemes);
+  const defaultsRef = (0, _composables.createDefaults)({});
+  defaultsRef.value = activeDefaultsFor(allThemes, allThemes[0]?.name ?? "", void 0);
   const scope = (0, _vue.effectScope)();
   return scope.run(() => {
     const icons = (0, _composables.createIcons)(options.icons);
@@ -31,7 +39,11 @@ function createOrigam(origam = {}) {
     const locale = (0, _composables.createLocale)(options.locale);
     const date = (0, _composables.createDate)(options.date, locale);
     const goTo = (0, _composables.createGoTo)(options.goTo, locale);
+    (0, _contrast.setContrastConfig)(options.contrast);
     const install = app => {
+      if (allThemes.length) {
+        (0, _utils.applyThemes)(allThemes);
+      }
       for (const key in directives) {
         app.directive(key, directives[key]);
       }
@@ -53,6 +65,8 @@ function createOrigam(origam = {}) {
       app.provide(_consts.ORIGAM_DATE_OPTIONS_KEY, date.options);
       app.provide(_consts.ORIGAM_DATE_ADAPTER_KEY, date.instance);
       app.provide(_consts.ORIGAM_GO_TO_KEY, goTo);
+      app.provide(_consts.ORIGAM_THEMES_KEY, installedThemes);
+      app.provide(_consts.ORIGAM_DEFAULTS_KEY, defaultsRef);
       if (_consts.IN_BROWSER && options.ssr) {
         if (app.$nuxt) {
           app.$nuxt.hook("app:suspense:resolve", () => {
@@ -96,13 +110,36 @@ function createOrigam(origam = {}) {
       icons,
       locale,
       date,
-      goTo
+      goTo,
+      themes: installedThemes,
+      // Reactive per-component DEFAULT PROPS map (provided under
+      // ORIGAM_DEFAULTS_KEY). The Nuxt plugins reassign `.value` (a NEW
+      // object) whenever the active brand / mode changes so `useDefaults`
+      // computeds re-run. NEVER mutate it in place.
+      _defaultsRef: defaultsRef,
+      // Re-export the collapse helper so the plugins can recompute the
+      // active defaults from the same install list on a theme switch.
+      _activeDefaultsFor: (brand, mode) => activeDefaultsFor(allThemes, brand, mode)
     };
   });
 }
+function activeDefaultsFor(themes, brand, mode) {
+  let merged = {};
+  for (const theme of themes) {
+    if (!theme.components) continue;
+    const brandMatches = !theme.name || theme.name === brand;
+    const themeModeAgnostic = theme.mode === void 0 || theme.mode === "auto";
+    const modeMatches = themeModeAgnostic || mode === void 0 || theme.mode === mode;
+    if (brandMatches && modeMatches) {
+      merged = (0, _utils.mergeDeep)(merged, theme.components);
+    }
+  }
+  return merged;
+}
 function inject(key) {
   const vm = this.$;
-  const provides = vm.parent?.provides ?? vm.vnode.appContext?.provides;
+  const parentProvides = vm.parent?.provides;
+  const provides = parentProvides ?? vm.vnode.appContext?.provides;
   if (provides && key in provides) {
     return provides[key];
   }

package/dist/src/origam.d.ts

@@ -1,4 +1,5 @@
-import type { IOrigamOptions } from './interfaces';
+import type { IDefault, IOrigamOptions, IOrigamTheme } from './interfaces';
+import type { TModeResolved } from './types';
 import '@mdi/font/css/materialdesignicons.css';
 import { App } from 'vue';
 export declare function createOrigam(origam?: IOrigamOptions): {
@@ -66,4 +67,21 @@ export declare function createOrigam(origam?: IOrigamOptions): {
         };
     };
     goTo: import("./interfaces").IGoToInstance;
+    themes: import("./types").TInstalledThemes;
+    _defaultsRef: import("vue").Ref<IDefault, IDefault>;
+    _activeDefaultsFor: (brand: string, mode?: TModeResolved) => IDefault;
 };
+/**
+ * Collapse the per-component DEFAULT PROPS (`theme.components`) of the themes
+ * matching the ACTIVE brand×mode into a single `IDefault`. A theme matches when
+ * its `name` equals `brand` AND its `mode` is compatible with the active `mode`:
+ *   - the theme is mode-agnostic (`mode` unset or `'auto'`), OR
+ *   - the active `mode` is unset (match every mode of the brand — used for the
+ *     mode-less install-time seed before the plugins resolve a concrete mode), OR
+ *   - the theme's `mode` equals the active `mode`.
+ * Matching themes are deep-merged in install order (later wins) via the shared
+ * `mergeDeep` util — no hand-rolled merge.
+ *
+ * Pure (no DOM / Vue access) so it runs identically on the server and client.
+ */
+export declare function activeDefaultsFor(themes: IOrigamTheme[], brand: string, mode?: TModeResolved): IDefault;

package/dist/src/origam.js

@@ -1,16 +1,20 @@
 import * as origamComponents from "./components/index.js";
-import { createDate, createDisplay, createGoTo, createIcons, createLocale } from "./composables/index.js";
+import { createDate, createDefaults, createDisplay, createGoTo, createIcons, createLocale } from "./composables/index.js";
 import {
   IN_BROWSER,
   ORIGAM_DATE_ADAPTER_KEY,
   ORIGAM_DATE_OPTIONS_KEY,
+  ORIGAM_DEFAULTS_KEY,
   ORIGAM_DISPLAY_KEY,
   ORIGAM_GO_TO_KEY,
   ORIGAM_ICONS_KEY,
-  ORIGAM_LOCALE_KEY
+  ORIGAM_LOCALE_KEY,
+  ORIGAM_THEMES_KEY
 } from "./consts/index.js";
 import * as origamDirectives from "./directives/index.js";
-import { getUid, mergeDeep } from "./utils/index.js";
+import { setContrastConfig } from "./directives/Contrast/contrast.directive.js";
+import { applyThemes, getUid, installedThemesFromList, mergeDeep } from "./utils/index.js";
+import { origamTheme } from "./themes/origam.theme.js";
 import "@mdi/font/css/materialdesignicons.css";
 import { defineComponent, effectScope, nextTick, reactive } from "vue";
 export function createOrigam(origam = {}) {
@@ -21,6 +25,14 @@ export function createOrigam(origam = {}) {
     components = origamComponents,
     directives = origamDirectives
   } = options;
+  const suppliedThemes = [
+    ...options.theme ? [options.theme] : [],
+    ...options.themes ?? []
+  ];
+  const allThemes = [...origamTheme, ...suppliedThemes];
+  const installedThemes = installedThemesFromList(allThemes);
+  const defaultsRef = createDefaults({});
+  defaultsRef.value = activeDefaultsFor(allThemes, allThemes[0]?.name ?? "", void 0);
   const scope = effectScope();
   return scope.run(() => {
     const icons = createIcons(options.icons);
@@ -28,7 +40,11 @@ export function createOrigam(origam = {}) {
     const locale = createLocale(options.locale);
     const date = createDate(options.date, locale);
     const goTo = createGoTo(options.goTo, locale);
+    setContrastConfig(options.contrast);
     const install = (app) => {
+      if (allThemes.length) {
+        applyThemes(allThemes);
+      }
       for (const key in directives) {
         app.directive(key, directives[key]);
       }
@@ -50,6 +66,8 @@ export function createOrigam(origam = {}) {
       app.provide(ORIGAM_DATE_OPTIONS_KEY, date.options);
       app.provide(ORIGAM_DATE_ADAPTER_KEY, date.instance);
       app.provide(ORIGAM_GO_TO_KEY, goTo);
+      app.provide(ORIGAM_THEMES_KEY, installedThemes);
+      app.provide(ORIGAM_DEFAULTS_KEY, defaultsRef);
       if (IN_BROWSER && options.ssr) {
         if (app.$nuxt) {
           app.$nuxt.hook("app:suspense:resolve", () => {
@@ -91,13 +109,36 @@ export function createOrigam(origam = {}) {
       icons,
       locale,
       date,
-      goTo
+      goTo,
+      themes: installedThemes,
+      // Reactive per-component DEFAULT PROPS map (provided under
+      // ORIGAM_DEFAULTS_KEY). The Nuxt plugins reassign `.value` (a NEW
+      // object) whenever the active brand / mode changes so `useDefaults`
+      // computeds re-run. NEVER mutate it in place.
+      _defaultsRef: defaultsRef,
+      // Re-export the collapse helper so the plugins can recompute the
+      // active defaults from the same install list on a theme switch.
+      _activeDefaultsFor: (brand, mode) => activeDefaultsFor(allThemes, brand, mode)
     };
   });
 }
+export function activeDefaultsFor(themes, brand, mode) {
+  let merged = {};
+  for (const theme of themes) {
+    if (!theme.components) continue;
+    const brandMatches = !theme.name || theme.name === brand;
+    const themeModeAgnostic = theme.mode === void 0 || theme.mode === "auto";
+    const modeMatches = themeModeAgnostic || mode === void 0 || theme.mode === mode;
+    if (brandMatches && modeMatches) {
+      merged = mergeDeep(merged, theme.components);
+    }
+  }
+  return merged;
+}
 function inject(key) {
   const vm = this.$;
-  const provides = vm.parent?.provides ?? vm.vnode.appContext?.provides;
+  const parentProvides = vm.parent?.provides;
+  const provides = parentProvides ?? vm.vnode.appContext?.provides;
   if (provides && key in provides) {
     return provides[key];
   }

package/dist/src/services/Commons/date-adapter.service.d.ts

@@ -16,7 +16,7 @@ export declare class DateAdapter implements IDateAdapter<Date> {
     addDays(date: Date, amount: number): Date;
     addWeeks(date: Date, amount: number): Date;
     addMonths(date: Date, amount: number): Date;
-    getWeekArray(date: Date, firstDayOfWeek?: number | string): never[];
+    getWeekArray(date: Date, firstDayOfWeek?: number | string): Date[][];
     startOfWeek(date: Date, firstDayOfWeek?: number | string): Date;
     endOfWeek(date: Date): Date;
     startOfMonth(date: Date): Date;

package/dist/src/themes/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "origamDarkTheme", {
+  enumerable: true,
+  get: function () {
+    return _origam.origamDarkTheme;
+  }
+});
+Object.defineProperty(exports, "origamLightTheme", {
+  enumerable: true,
+  get: function () {
+    return _origam.origamLightTheme;
+  }
+});
+Object.defineProperty(exports, "origamTheme", {
+  enumerable: true,
+  get: function () {
+    return _origam.origamTheme;
+  }
+});
+var _origam = require("./origam.theme.cjs");

package/dist/src/themes/index.d.ts

@@ -0,0 +1 @@
+export { origamDarkTheme, origamLightTheme, origamTheme } from './origam.theme';

package/dist/src/themes/index.js

@@ -0,0 +1 @@
+export { origamDarkTheme, origamLightTheme, origamTheme } from "./origam.theme.js";