@nuxt/ui 2.18.4 → 3.0.0-alpha.0

package/dist/runtime/composables/useFormField.d.ts

@@ -0,0 +1,31 @@
+import { type InjectionKey, type Ref, type ComputedRef } from 'vue';
+import { type UseEventBusReturn } from '@vueuse/core';
+import type { FormFieldProps } from '../types.js';
+import type { FormEvent, FormFieldInjectedOptions, FormInjectedOptions } from '../types/form.js';
+import type { GetObjectField } from '../types/utils.js';
+type Props<T> = {
+    id?: string;
+    name?: string;
+    size?: GetObjectField<T, 'size'>;
+    color?: GetObjectField<T, 'color'>;
+    eagerValidation?: boolean;
+    legend?: string;
+    highlight?: boolean;
+    disabled?: boolean;
+};
+export declare const formOptionsInjectionKey: InjectionKey<ComputedRef<FormInjectedOptions>>;
+export declare const formBusInjectionKey: InjectionKey<UseEventBusReturn<FormEvent, string>>;
+export declare const formFieldInjectionKey: InjectionKey<ComputedRef<FormFieldInjectedOptions<FormFieldProps>>>;
+export declare const formInputsInjectionKey: InjectionKey<Ref<Record<string, string>>>;
+export declare function useFormField<T>(props?: Props<T>): {
+    id: ComputedRef<string | undefined>;
+    name: ComputedRef<string | undefined>;
+    size: ComputedRef<"md" | "xs" | "sm" | "lg" | "xl" | NonNullable<GetObjectField<T, "size">> | undefined>;
+    color: ComputedRef<"error" | GetObjectField<T, "color"> | undefined>;
+    highlight: ComputedRef<boolean | undefined>;
+    disabled: ComputedRef<boolean | undefined>;
+    emitFormBlur: () => void;
+    emitFormInput: import("@vueuse/core").PromisifyFn<() => void>;
+    emitFormChange: () => void;
+};
+export {};

package/dist/runtime/composables/useFormField.js

@@ -0,0 +1,50 @@
+import { inject, ref, computed } from "vue";
+import { useDebounceFn } from "@vueuse/core";
+export const formOptionsInjectionKey = Symbol("nuxt-ui.form-options");
+export const formBusInjectionKey = Symbol("nuxt-ui.form-events");
+export const formFieldInjectionKey = Symbol("nuxt-ui.form-field");
+export const formInputsInjectionKey = Symbol("nuxt-ui.form-inputs");
+export function useFormField(props) {
+  const formOptions = inject(formOptionsInjectionKey, void 0);
+  const formBus = inject(formBusInjectionKey, void 0);
+  const formField = inject(formFieldInjectionKey, void 0);
+  const formInputs = inject(formInputsInjectionKey, void 0);
+  if (formField) {
+    if (props?.id) {
+      formField.value.id = props?.id;
+    }
+    if (formInputs && formField.value.name) {
+      formInputs.value[formField.value.name] = formField.value.id;
+    }
+  }
+  const blurred = ref(false);
+  function emitFormEvent(type, name) {
+    if (formBus && formField && name) {
+      formBus.emit({ type, name });
+    }
+  }
+  function emitFormBlur() {
+    emitFormEvent("blur", formField?.value.name);
+    blurred.value = true;
+  }
+  function emitFormChange() {
+    emitFormEvent("change", formField?.value.name);
+  }
+  const emitFormInput = useDebounceFn(
+    () => {
+      emitFormEvent("input", formField?.value.name);
+    },
+    formField?.value.validateOnInputDelay ?? formOptions?.value.validateOnInputDelay ?? 0
+  );
+  return {
+    id: computed(() => props?.id ?? formField?.value.id),
+    name: computed(() => props?.name ?? formField?.value.name),
+    size: computed(() => props?.size ?? formField?.value.size),
+    color: computed(() => formField?.value.error ? "error" : props?.color),
+    highlight: computed(() => formField?.value.error ? true : props?.highlight),
+    disabled: computed(() => formOptions?.value.disabled || props?.disabled),
+    emitFormBlur,
+    emitFormInput,
+    emitFormChange
+  };
+}

package/dist/runtime/composables/useKbd.d.ts

@@ -0,0 +1,28 @@
+export declare const kbdKeysMap: {
+    meta: string;
+    command: string;
+    shift: string;
+    ctrl: string;
+    option: string;
+    alt: string;
+    enter: string;
+    delete: string;
+    backspace: string;
+    escape: string;
+    tab: string;
+    capslock: string;
+    arrowup: string;
+    arrowright: string;
+    arrowdown: string;
+    arrowleft: string;
+    pageup: string;
+    pagedown: string;
+    home: string;
+    end: string;
+};
+export type KbdKey = keyof typeof kbdKeysMap;
+export declare const useKbd: () => {
+    macOS: import("vue").ComputedRef<false | "" | RegExpMatchArray | null | undefined>;
+    metaSymbol: import("vue").Ref<string, string>;
+    getKbdKey: (value?: KbdKey | string) => string | undefined;
+};

package/dist/runtime/composables/useKbd.js

@@ -0,0 +1,46 @@
+import { createSharedComposable } from "@vueuse/core";
+import { ref, computed, onMounted } from "vue";
+export const kbdKeysMap = {
+  meta: "",
+  command: "\u2318",
+  shift: "\u21E7",
+  ctrl: "\u2303",
+  option: "\u2325",
+  alt: "\u2387",
+  enter: "\u21B5",
+  delete: "\u2326",
+  backspace: "\u232B",
+  escape: "\u238B",
+  tab: "\u21E5",
+  capslock: "\u21EA",
+  arrowup: "\u2191",
+  arrowright: "\u2192",
+  arrowdown: "\u2193",
+  arrowleft: "\u2190",
+  pageup: "\u21DE",
+  pagedown: "\u21DF",
+  home: "\u2196",
+  end: "\u2198"
+};
+const _useKbd = () => {
+  const macOS = computed(() => import.meta.client && navigator && navigator.userAgent && navigator.userAgent.match(/Macintosh;/));
+  const metaSymbol = ref(" ");
+  onMounted(() => {
+    metaSymbol.value = macOS.value ? kbdKeysMap.command : kbdKeysMap.ctrl;
+  });
+  function getKbdKey(value) {
+    if (!value) {
+      return;
+    }
+    if (value === "meta") {
+      return metaSymbol.value;
+    }
+    return kbdKeysMap[value] || value.toUpperCase();
+  }
+  return {
+    macOS,
+    metaSymbol,
+    getKbdKey
+  };
+};
+export const useKbd = createSharedComposable(_useKbd);

package/dist/runtime/composables/useModal.d.ts

@@ -1,13 +1,17 @@
 import type { ShallowRef, Component, InjectionKey } from 'vue';
+import type { ModalProps } from '../types.js';
 import type { ComponentProps } from '../types/component.js';
-import type { Modal, ModalState } from '../types/modal.js';
+export interface ModalState {
+    component: Component | string;
+    props: ModalProps;
+}
 export declare const modalInjectionKey: InjectionKey<ShallowRef<ModalState>>;
 declare function _useModal(): {
-    open: <T extends Component>(component: T, props?: Modal & ComponentProps<T>) => void;
+    open: <T extends Component>(component: T, props?: ModalProps & ComponentProps<T>) => void;
     close: () => Promise<void>;
     reset: () => void;
-    patch: <T extends Component = {}>(props: Partial<Modal & ComponentProps<T>>) => void;
-    isOpen: import("vue").Ref<boolean>;
+    patch: <T extends Component = Record<string, never>>(props: Partial<ModalProps & ComponentProps<T>>) => void;
+    isOpen: import("vue").Ref<boolean, boolean>;
 };
 export declare const useModal: typeof _useModal;
 export {};

package/dist/runtime/composables/useModal.js

@@ -19,6 +19,7 @@ function _useModal() {
     isOpen.value = false;
   }
   function reset() {
+    if (!modalState) return;
     modalState.value = {
       component: "div",
       props: {}

package/dist/runtime/composables/useSlideover.d.ts

@@ -1,13 +1,17 @@
 import type { ShallowRef, Component, InjectionKey } from 'vue';
+import type { SlideoverProps } from '../types.js';
 import type { ComponentProps } from '../types/component.js';
-import type { Slideover, SlideoverState } from '../types/slideover.js';
-export declare const slidOverInjectionKey: InjectionKey<ShallowRef<SlideoverState>>;
+export interface SlideoverState {
+    component: Component | string;
+    props: SlideoverProps;
+}
+export declare const slideoverInjectionKey: InjectionKey<ShallowRef<SlideoverState>>;
 declare function _useSlideover(): {
-    open: <T extends Component>(component: T, props?: Slideover & ComponentProps<T>) => void;
+    open: <T extends Component>(component: T, props?: SlideoverProps & ComponentProps<T>) => void;
     close: () => Promise<void>;
     reset: () => void;
-    patch: <T extends Component = {}>(props: Partial<Slideover & ComponentProps<T>>) => void;
-    isOpen: import("vue").Ref<boolean>;
+    patch: <T extends Component = Record<string, never>>(props: Partial<SlideoverState & ComponentProps<T>>) => void;
+    isOpen: import("vue").Ref<boolean, boolean>;
 };
 export declare const useSlideover: typeof _useSlideover;
 export {};

package/dist/runtime/composables/useSlideover.js

@@ -1,8 +1,8 @@
 import { ref, inject } from "vue";
 import { createSharedComposable } from "@vueuse/core";
-export const slidOverInjectionKey = Symbol("nuxt-ui.slideover");
+export const slideoverInjectionKey = Symbol("nuxt-ui.slideover");
 function _useSlideover() {
-  const slideoverState = inject(slidOverInjectionKey);
+  const slideoverState = inject(slideoverInjectionKey);
   const isOpen = ref(false);
   function open(component, props) {
     if (!slideoverState) {
@@ -19,6 +19,7 @@ function _useSlideover() {
     isOpen.value = false;
   }
   function reset() {
+    if (!slideoverState) return;
     slideoverState.value = {
       component: "div",
       props: {}

package/dist/runtime/composables/useToast.d.ts

@@ -1,20 +1,12 @@
-import type { Notification } from '../types/notification.js';
+import type { ToastProps } from '../types.js';
+export interface Toast extends Omit<ToastProps, 'defaultOpen'> {
+    id: string | number;
+    click?: (toast: Toast) => void;
+}
 export declare function useToast(): {
-    add: (notification: Partial<Notification>) => {
-        id: string;
-        title?: string;
-        description?: string;
-        icon?: string;
-        avatar?: import("../types").Avatar;
-        closeButton?: import("../types").Button;
-        timeout?: number;
-        actions?: import("../types").NotificationAction[];
-        click?: (...args: any[]) => void;
-        callback?: (...args: any[]) => void;
-        color?: import("../types").NotificationColor;
-        ui?: any;
-    };
-    remove: (id: string) => void;
-    update: (id: string, notification: Partial<Notification>) => void;
+    toasts: import("vue").Ref<Toast[], Toast[]>;
+    add: (toast: Partial<Toast>) => Toast;
+    update: (id: string | number, toast: Partial<Toast>) => void;
+    remove: (id: string | number) => void;
     clear: () => void;
 };

package/dist/runtime/composables/useToast.js

@@ -1,34 +1,48 @@
 import { useState } from "#imports";
 export function useToast() {
-  const notifications = useState("notifications", () => []);
-  function add(notification) {
+  const toasts = useState("toasts", () => []);
+  function add(toast) {
     const body = {
       id: (/* @__PURE__ */ new Date()).getTime().toString(),
-      ...notification
+      open: true,
+      ...toast
     };
-    const index = notifications.value.findIndex((n) => n.id === body.id);
+    const index = toasts.value.findIndex((t) => t.id === body.id);
     if (index === -1) {
-      notifications.value.push(body);
+      toasts.value.push(body);
     }
+    toasts.value = toasts.value.slice(-5);
     return body;
   }
-  function remove(id) {
-    notifications.value = notifications.value.filter((n) => n.id !== id);
+  function update(id, toast) {
+    const index = toasts.value.findIndex((t) => t.id === id);
+    if (index !== -1) {
+      toasts.value[index] = {
+        ...toasts.value[index],
+        ...toast
+      };
+    }
   }
-  function update(id, notification) {
-    const index = notifications.value.findIndex((n) => n.id === id);
+  function remove(id) {
+    const index = toasts.value.findIndex((t) => t.id === id);
     if (index !== -1) {
-      const previous = notifications.value[index];
-      notifications.value.splice(index, 1, { ...previous, ...notification });
+      toasts.value[index] = {
+        ...toasts.value[index],
+        open: false
+      };
     }
+    setTimeout(() => {
+      toasts.value = toasts.value.filter((t) => t.id !== id);
+    }, 200);
   }
   function clear() {
-    notifications.value = [];
+    toasts.value = [];
   }
   return {
+    toasts,
     add,
-    remove,
     update,
+    remove,
     clear
   };
 }

package/dist/runtime/plugins/colors.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
-export default _default;

package/dist/runtime/plugins/colors.js

@@ -1,27 +1,18 @@
 import { computed } from "vue";
-import { get, hexToRgb } from "../utils/index.js";
 import { defineNuxtPlugin, useAppConfig, useNuxtApp, useHead } from "#imports";
-import colors from "#tailwind-config/theme/colors";
 export default defineNuxtPlugin(() => {
   const appConfig = useAppConfig();
   const nuxtApp = useNuxtApp();
+  const shades = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+  function generateColor(key, value) {
+    return `${shades.map((shade) => `--color-${key}-${shade}: var(--color-${value}-${shade});`).join("\n  ")}`;
+  }
   const root = computed(() => {
-    const primary = get(colors, appConfig.ui.primary);
-    const gray = get(colors, appConfig.ui.gray);
-    if (!primary) {
-      console.warn(`[@nuxt/ui] Primary color '${appConfig.ui.primary}' not found in Tailwind config`);
-    }
-    if (!gray) {
-      console.warn(`[@nuxt/ui] Gray color '${appConfig.ui.gray}' not found in Tailwind config`);
-    }
     return `:root {
-${Object.entries(primary || colors.green).map(([key, value]) => `--color-primary-${key}: ${hexToRgb(value)};`).join("\n")}
---color-primary-DEFAULT: var(--color-primary-500);
-
-${Object.entries(gray || colors.cool).map(([key, value]) => `--color-gray-${key}: ${hexToRgb(value)};`).join("\n")}
+  ${Object.entries(appConfig.ui.colors).map(([key, value]) => generateColor(key, value)).join("\n  ")}
+  --color-primary-DEFAULT: var(--color-primary-500);
 }
-
-.dark {
+@media (prefers-color-scheme: dark) {
   --color-primary-DEFAULT: var(--color-primary-400);
 }
 `;
@@ -30,7 +21,8 @@ ${Object.entries(gray || colors.cool).map(([key, value]) => `--color-gray-${key}
     style: [{
       innerHTML: () => root.value,
       tagPriority: -2,
-      id: "nuxt-ui-colors"
+      id: "nuxt-ui-colors",
+      type: "text/css"
     }]
   };
   if (import.meta.client && nuxtApp.isHydrating && !nuxtApp.payload.serverRendered) {

package/dist/runtime/plugins/{slideovers.js → slideover.js}

@@ -1,10 +1,10 @@
-import { defineNuxtPlugin } from "#imports";
 import { shallowRef } from "vue";
-import { slidOverInjectionKey } from "../composables/useSlideover.js";
+import { defineNuxtPlugin } from "#imports";
+import { slideoverInjectionKey } from "../composables/useSlideover.js";
 export default defineNuxtPlugin((nuxtApp) => {
   const slideoverState = shallowRef({
     component: "div",
     props: {}
   });
-  nuxtApp.vueApp.provide(slidOverInjectionKey, slideoverState);
+  nuxtApp.vueApp.provide(slideoverInjectionKey, slideoverState);
 });

package/dist/runtime/types/app.config.d.ts

@@ -0,0 +1,6 @@
+declare module '#build/app.config' {
+  import type { AppConfig } from '@nuxt/schema'
+
+  const _default: AppConfig
+  export default _default
+}

package/dist/runtime/types/component.d.ts

@@ -1,14 +1,17 @@
-export type ComponentProps<T> =
-T extends new () => { $props: infer P } ? NonNullable<P> :
-  T extends (props: infer P, ...args: any) => any ? P :
-      {}
-
-export type ComponentSlots<T> =
-T extends new () => { $slots: infer S } ? NonNullable<S> :
-  T extends (props: any, ctx: { slots: infer S; attrs: any; emit: any }, ...args: any) => any ? NonNullable<S> :
-      {}
-
-export type ComponentEmit<T> =
-T extends new () => { $emit: infer E } ? NonNullable<E> :
-  T extends (props: any, ctx: { slots: any; attrs: any; emit: infer E }, ...args: any) => any ? NonNullable<E> :
-      {}
+export type ComponentProps<T> = T extends new () => {
+    $props: infer P;
+} ? NonNullable<P> : T extends (props: infer P, ...args: any) => any ? P : Record<string, never>;
+export type ComponentSlots<T> = T extends new () => {
+    $slots: infer S;
+} ? NonNullable<S> : T extends (props: any, ctx: {
+    slots: infer S;
+    attrs: any;
+    emit: any;
+}, ...args: any) => any ? NonNullable<S> : Record<string, never>;
+export type ComponentEmit<T> = T extends new () => {
+    $emit: infer E;
+} ? NonNullable<E> : T extends (props: any, ctx: {
+    slots: any;
+    attrs: any;
+    emit: infer E;
+}, ...args: any) => any ? NonNullable<E> : Record<string, never>;

package/dist/runtime/types/form.d.ts

@@ -1,38 +1,69 @@
-import type { Ref } from 'vue'
-
-export interface FormError<T extends string = string> {
-  path: T
-  message: string
+import type { ComputedRef, Ref } from 'vue';
+import type { ZodSchema } from 'zod';
+import type { Schema as JoiSchema } from 'joi';
+import type { ObjectSchema as YupObjectSchema } from 'yup';
+import type { GenericSchema as ValibotSchema, GenericSchemaAsync as ValibotSchemaAsync, SafeParser as ValibotSafeParser, SafeParserAsync as ValibotSafeParserAsync } from 'valibot';
+import type { GetObjectField } from './utils.js';
+export interface Form<T> {
+    validate(opts?: {
+        name: string | string[];
+        silent?: false;
+        nested?: boolean;
+    }): Promise<T | false>;
+    clear(path?: string): void;
+    errors: Ref<FormError[]>;
+    setErrors(errs: FormError[], path?: string): void;
+    getErrors(path?: string): FormError[];
+    submit(): Promise<void>;
+    disabled: ComputedRef<boolean>;
+}
+export type FormSchema<T extends Record<string, any>> = ZodSchema | YupObjectSchema<T> | ValibotSchema | ValibotSchemaAsync | ValibotSafeParser<any, any> | ValibotSafeParserAsync<any, any> | JoiSchema<T>;
+export type FormInputEvents = 'input' | 'blur' | 'change';
+export interface FormError<P extends string = string> {
+    name: P;
+    message: string;
 }
-
 export interface FormErrorWithId extends FormError {
-  id: string
+    id: string;
 }
-
-export interface Form<T> {
-  validate(path?: string | string[], opts?: { silent?: true }): Promise<T | false>;
-  validate(path?: string | string[], opts?: { silent?: false }): Promise<T>;
-  clear(path?: string): void
-  errors: Ref<FormError[]>
-  setErrors(errs: FormError[], path?: string): void
-  getErrors(path?: string): FormError[]
-  submit(): Promise<void>
+export type FormSubmitEvent<T> = SubmitEvent & {
+    data: T;
+};
+export type FormValidationError = {
+    errors: FormErrorWithId[];
+    childrens: FormValidationError[];
+};
+export type FormErrorEvent = SubmitEvent & FormValidationError;
+export type FormEventType = FormInputEvents;
+export type FormChildAttachEvent = {
+    type: 'attach';
+    formId: string | number;
+    validate: Form<any>['validate'];
+};
+export type FormChildDetachEvent = {
+    type: 'detach';
+    formId: string | number;
+};
+export type FormInputEvent = {
+    type: FormEventType;
+    name?: string;
+};
+export type FormEvent = FormInputEvent | FormChildAttachEvent | FormChildDetachEvent;
+export interface FormInjectedOptions {
+    disabled?: boolean;
+    validateOnInputDelay?: number;
 }
-
-export type FormSubmitEvent<T> = SubmitEvent & { data: T }
-export type FormErrorEvent = SubmitEvent & { errors: FormErrorWithId[] }
-
-export type FormEventType = 'blur' | 'input' | 'change' | 'submit'
-
-export interface FormEvent {
-  type: FormEventType
-  path?: string
+export interface FormFieldInjectedOptions<T> {
+    id: string;
+    name?: string;
+    size?: GetObjectField<T, 'size'>;
+    error?: string | boolean;
+    eagerValidation?: boolean;
+    validateOnInputDelay?: number;
 }
-
-export interface InjectedFormGroupValue {
-  inputId: Ref<string | undefined>
-  name: Ref<string>
-  size: Ref<string | number | symbol>
-  error: Ref<string | boolean | undefined>
-  eagerValidation: Ref<boolean>
+export declare class FormValidationException extends Error {
+    formId: string | number;
+    errors: FormErrorWithId[];
+    childrens: FormValidationException[];
+    constructor(formId: string | number, errors: FormErrorWithId[], childErrors: FormValidationException[]);
 }

package/dist/runtime/types/form.js

@@ -0,0 +1,12 @@
+export class FormValidationException extends Error {
+  formId;
+  errors;
+  childrens;
+  constructor(formId, errors, childErrors) {
+    super("Form validation exception");
+    this.formId = formId;
+    this.errors = errors;
+    this.childrens = childErrors;
+    Object.setPrototypeOf(this, FormValidationException.prototype);
+  }
+}

package/dist/runtime/types/index.d.ts

@@ -1,31 +1,42 @@
-export * from './accordion.js';
-export * from './alert.js';
-export * from './avatar.js';
-export * from './badge.js';
-export * from './breadcrumb.js';
-export * from './button.js';
-export * from './chip.js';
-export * from './clipboard.js';
-export * from './command-palette.js';
-export * from './divider.js';
-export * from './dropdown.js';
-export * from './form-group.js';
+export * from '../components/Accordion.vue.js';
+export * from '../components/Alert.vue.js';
+export * from '../components/App.vue.js';
+export * from '../components/Avatar.vue.js';
+export * from '../components/AvatarGroup.vue.js';
+export * from '../components/Badge.vue.js';
+export * from '../components/Breadcrumb.vue.js';
+export * from '../components/Button.vue.js';
+export * from '../components/Card.vue.js';
+export * from '../components/Checkbox.vue.js';
+export * from '../components/Chip.vue.js';
+export * from '../components/Collapsible.vue.js';
+export * from '../components/CommandPalette.vue.js';
+export * from '../components/Container.vue.js';
+export * from '../components/ContextMenu.vue.js';
+export * from '../components/Drawer.vue.js';
+export * from '../components/DropdownMenu.vue.js';
+export * from '../components/Form.vue.js';
+export * from '../components/FormField.vue.js';
+export * from '../components/Input.vue.js';
+export * from '../components/InputMenu.vue.js';
+export * from '../components/Kbd.vue.js';
+export * from '../components/Link.vue.js';
+export * from '../components/Modal.vue.js';
+export * from '../components/NavigationMenu.vue.js';
+export * from '../components/Pagination.vue.js';
+export * from '../components/Popover.vue.js';
+export * from '../components/Progress.vue.js';
+export * from '../components/RadioGroup.vue.js';
+export * from '../components/Select.vue.js';
+export * from '../components/SelectMenu.vue.js';
+export * from '../components/Separator.vue.js';
+export * from '../components/Skeleton.vue.js';
+export * from '../components/Slideover.vue.js';
+export * from '../components/Slider.vue.js';
+export * from '../components/Switch.vue.js';
+export * from '../components/Tabs.vue.js';
+export * from '../components/Textarea.vue.js';
+export * from '../components/Toast.vue.js';
+export * from '../components/Toaster.vue.js';
+export * from '../components/Tooltip.vue.js';
 export * from './form.js';
-export * from './horizontal-navigation.js';
-export * from './input.js';
-export * from './kbd.js';
-export * from './link.js';
-export * from './meter.js';
-export * from './modal.js';
-export * from './slideover.js';
-export * from './notification.js';
-export * from './popper.js';
-export * from './progress.js';
-export * from './range.js';
-export * from './select.js';
-export * from './tabs.js';
-export * from './textarea.js';
-export * from './toggle.js';
-export * from './tooltip.js';
-export * from './vertical-navigation.js';
-export * from './utils.js';