@witchcraft/ui 0.4.0 → 0.4.2

package/dist/runtime/components/{LibRecorder/LibRecorder.vue.d.ts → WRecorder/WRecorder.vue.d.ts}

@@ -1,6 +1,6 @@
-import { type HTMLAttributes } from "vue";
-import { type BaseInteractiveProps, type LabelProps, type LinkableByIdProps, type TailwindClassProp } from "../shared/props.js";
-type RealProps = LinkableByIdProps & BaseInteractiveProps & LabelProps & {
+import type { HTMLAttributes } from "vue";
+import type { BaseInteractiveProps, TailwindClassProp } from "../../types/index.js";
+type __VLS_Props = /** @vue-ignore */ Omit<HTMLAttributes, "class"> & /** @vue-ignore */ TailwindClassProp & BaseInteractiveProps & {
     border?: boolean;
     /** A value to display while recording, if none given the i18n `recorder.recording` key is used. */
     recordingValue?: string;
@@ -19,54 +19,39 @@ type RealProps = LinkableByIdProps & BaseInteractiveProps & LabelProps & {
         bind: (el: HTMLElement) => void;
         unbind: (el: HTMLElement) => void;
     };
-    /** The id of the element. If not provided, the id will be generated automatically. */
-    id?: string;
 };
-interface Props extends 
-/** @vue-ignore */
-Partial<Omit<HTMLAttributes, "class"> & TailwindClassProp>, RealProps {
-}
-declare const _default: import("vue").DefineComponent<Props & {
+type __VLS_ModelProps = {
     /**
      * Puts the element into recording mode if true. See {@link props.recorder}.
      */
-    recording?: boolean;
+    "recording"?: boolean;
     /** The final value of the recorder. For intermediate values while recording, pass a recorder and set an appropriate recording value. */
     modelValue: string;
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;
     "update:recording": (value: boolean) => any;
 } & {
     "recorder:blur": ($event: FocusEvent) => any;
-    "recorder:click": (args_0: {
+    "recorder:pointerdown": (args_0: {
         event: MouseEvent | KeyboardEvent;
         indicator: HTMLElement;
         input: HTMLInputElement;
     }) => any;
     "focus:parent": () => any;
-}, string, import("vue").PublicProps, Readonly<Props & {
-    /**
-     * Puts the element into recording mode if true. See {@link props.recorder}.
-     */
-    recording?: boolean;
-    /** The final value of the recorder. For intermediate values while recording, pass a recorder and set an appropriate recording value. */
-    modelValue: string;
-}> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    "onUpdate:recording"?: ((value: boolean) => any) | undefined;
     "onRecorder:blur"?: (($event: FocusEvent) => any) | undefined;
-    "onRecorder:click"?: ((args_0: {
+    "onRecorder:pointerdown"?: ((args_0: {
         event: MouseEvent | KeyboardEvent;
         indicator: HTMLElement;
         input: HTMLInputElement;
     }) => any) | undefined;
     "onFocus:parent"?: (() => any) | undefined;
+    "onUpdate:recording"?: ((value: boolean) => any) | undefined;
 }>, {
-    id: string;
-    disabled: boolean;
-    readonly: boolean;
     border: boolean;
-    unstyle: boolean;
     recordingTitle: string;
     recorder: Record<string, any>;
     binders: {
@@ -74,4 +59,5 @@ declare const _default: import("vue").DefineComponent<Props & {
         unbind: (el: HTMLElement) => void;
     };
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/{LibRoot/LibRoot.d.vue.ts → WRoot/WRoot.d.vue.ts}

@@ -1,11 +1,12 @@
 import type { Theme } from "metamorphosis";
+import type { HTMLAttributes } from "vue";
 import { NotificationHandler } from "../../helpers/NotificationHandler.js";
+import type { TailwindClassProp } from "../../types/index.js";
 type __VLS_Props = {
     theme?: Theme;
     outline?: boolean;
     forceOutline?: boolean;
     testWrapperMode?: boolean;
-    id?: string;
     /** You can set a ref to the root element by passing :getRef="_ => el = _" */
     getRef?: (el: HTMLElement | null) => void;
     /** True by default, should be passed import.meta.client if using nuxt, or false when running server side. */
@@ -13,26 +14,27 @@ type __VLS_Props = {
     useBuiltinTranslations?: boolean;
     useNotifications?: boolean;
     notificationHandler?: NotificationHandler;
+    wrapperAttrs?: Omit<HTMLAttributes, "class"> & TailwindClassProp;
 };
-declare var __VLS_9: {};
+declare var __VLS_11: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_9) => any;
+    default?: (props: typeof __VLS_11) => any;
 };
-declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
-    darkMode: import("../../composables/useDarkMode.js").DarkModeState & import("../../composables/useDarkMode.js").DarkModeCommands;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    darkMode: import("../../main.lib.js").DarkModeState & import("../../main.lib.js").DarkModeCommands;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    theme: Theme;
-    id: string;
-    isClientSide: boolean;
     useBuiltinTranslations: boolean;
+    theme: Theme;
     outline: boolean;
+    isClientSide: boolean;
     forceOutline: boolean;
     testWrapperMode: boolean;
     getRef: (el: HTMLElement | null) => void;
     useNotifications: boolean;
     notificationHandler: NotificationHandler;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/runtime/components/{LibRoot/LibRoot.vue → WRoot/WRoot.vue}

@@ -1,26 +1,29 @@
 <template>
 <div
-	:id="id"
 	tabindex="-1"
 	:class="twMerge(
   showOutline ? 'group outlined outlined-visible' : '[&_*]:outline-hidden',
   darkMode && ' dark',
-  $attrs['wrapperAttrs']?.class
+  wrapperAttrs?.class
 )"
-	v-bind="{ ...$attrs['wrapperAttrs'], attrs: void 0, class: void 0 }"
+	v-bind="{
+  id: 'app',
+  ...wrapperAttrs,
+  class: void 0
+}"
 	:ref="handleRef"
 >
 	<!-- id root is useful for teleports, so they are at the topmost level where they can still be styled -->
 	<!-- See TestControls for why the margins here -->
 	<div
 		id="root"
-		v-bind="{ ...$attrs.attrs, class: void 0, wrapperAttrs: void 0 }"
+		v-bind="{ ...$attrs, class: void 0 }"
 		:class="twMerge(
   `
-			dark:bg-fg
-			dark:text-bg
-			bg-bg
-			text-fg
+			dark:bg-neutral-900
+			dark:text-white
+			bg-neutral-50
+			text-black
 		`,
   testWrapperMode && `
 			px-10
@@ -31,7 +34,7 @@
 			flex
 			flex-col
 		`,
-  $attrs.attrs?.class
+  $attrs.class
 )"
 	>
 		<TestControls
@@ -49,9 +52,8 @@
 
 <script setup>
 import { unreachable } from "@alanscodelog/utils/unreachable";
-import { computed, onBeforeUnmount, onMounted, ref, toRaw } from "vue";
+import { computed, onBeforeUnmount, onMounted, ref, toRaw, useAttrs } from "vue";
 import { useAccesibilityOutline } from "../../composables/useAccesibilityOutline.js";
-import { useDivideAttrs } from "../../composables/useDivideAttrs.js";
 import { useNotificationHandler } from "../../composables/useNotificationHandler.js";
 import { useSetupDarkMode } from "../../composables/useSetupDarkMode.js";
 import { useSetupI18n } from "../../composables/useSetupI18n.js";
@@ -60,21 +62,21 @@ import { useShowDevOnlyKey } from "../../composables/useShowDevOnlyKey.js";
 import { NotificationHandler } from "../../helpers/NotificationHandler.js";
 import { theme as defaultTheme } from "../../theme.js";
 import { twMerge } from "../../utils/twMerge.js";
-import Notifications from "../LibNotifications/LibNotifications.vue";
 import TestControls from "../TestControls/TestControls.vue";
-const $attrs = useDivideAttrs(["wrapper"]);
+import Notifications from "../WNotifications/WNotifications.vue";
 defineOptions({ name: "Root", inheritAttrs: false, suspensible: false });
+const $attrs = useAttrs();
 const props = defineProps({
   theme: { type: Object, required: false, default: void 0 },
   outline: { type: Boolean, required: false, default: true },
   forceOutline: { type: Boolean, required: false, default: false },
   testWrapperMode: { type: Boolean, required: false, default: false },
-  id: { type: String, required: false, default: "app" },
   getRef: { type: Function, required: false, default: void 0 },
   isClientSide: { type: Boolean, required: false, default: true },
   useBuiltinTranslations: { type: Boolean, required: false, default: true },
   useNotifications: { type: Boolean, required: false, default: true },
-  notificationHandler: { type: Object, required: false, default: void 0 }
+  notificationHandler: { type: Object, required: false, default: void 0 },
+  wrapperAttrs: { type: Object, required: false }
 });
 const el = ref(null);
 function handleRef(_) {

package/dist/runtime/components/{LibRoot/LibRoot.vue.d.ts → WRoot/WRoot.vue.d.ts}

@@ -1,11 +1,12 @@
 import type { Theme } from "metamorphosis";
+import type { HTMLAttributes } from "vue";
 import { NotificationHandler } from "../../helpers/NotificationHandler.js";
+import type { TailwindClassProp } from "../../types/index.js";
 type __VLS_Props = {
     theme?: Theme;
     outline?: boolean;
     forceOutline?: boolean;
     testWrapperMode?: boolean;
-    id?: string;
     /** You can set a ref to the root element by passing :getRef="_ => el = _" */
     getRef?: (el: HTMLElement | null) => void;
     /** True by default, should be passed import.meta.client if using nuxt, or false when running server side. */
@@ -13,26 +14,27 @@ type __VLS_Props = {
     useBuiltinTranslations?: boolean;
     useNotifications?: boolean;
     notificationHandler?: NotificationHandler;
+    wrapperAttrs?: Omit<HTMLAttributes, "class"> & TailwindClassProp;
 };
-declare var __VLS_9: {};
+declare var __VLS_11: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_9) => any;
+    default?: (props: typeof __VLS_11) => any;
 };
-declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
-    darkMode: import("../../composables/useDarkMode.js").DarkModeState & import("../../composables/useDarkMode.js").DarkModeCommands;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    darkMode: import("../../main.lib.js").DarkModeState & import("../../main.lib.js").DarkModeCommands;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    theme: Theme;
-    id: string;
-    isClientSide: boolean;
     useBuiltinTranslations: boolean;
+    theme: Theme;
     outline: boolean;
+    isClientSide: boolean;
     forceOutline: boolean;
     testWrapperMode: boolean;
     getRef: (el: HTMLElement | null) => void;
     useNotifications: boolean;
     notificationHandler: NotificationHandler;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/runtime/components/WSimpleInput/WSimpleInput.d.vue.ts

@@ -0,0 +1,34 @@
+import { type InputHTMLAttributes } from "vue";
+import type { BaseInteractiveProps, TailwindClassProp } from "../../types/index.js";
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(Omit<InputHTMLAttributes, "class" | "onInput" | "onSubmit" | "disabled" | "type" | "readonly" | "autocomplete"> & TailwindClassProp & Pick<BaseInteractiveProps, "border" | "unstyle"> & {
+        id?: string;
+        label?: string;
+        valid?: boolean;
+        type?: InputHTMLAttributes["type"];
+    } & {
+        modelValue: T;
+    }) & {
+        onSubmit?: ((val: T) => any) | undefined;
+        onInput?: ((val: InputEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: {
+        (e: "submit", val: T): void;
+        (e: "input", val: InputEvent): void;
+    } & ((event: "update:modelValue", value: T) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/components/{LibSimpleInput/LibSimpleInput.vue → WSimpleInput/WSimpleInput.vue}

@@ -1,7 +1,7 @@
 <template>
 <input
-	:id="id ?? fallbackId"
-	:class="twMerge(
+	:id="finalId"
+	:class="!unstyle && twMerge(
   `
 		simple-input
 		flex-1
@@ -71,12 +71,11 @@
 )"
 	:data-border="border"
 	:data-invalid="!valid"
-	:type="type"
-	:placeholder="placeholder"
-	:disabled="disabled"
-	:readonly="readonly"
 	v-model="modelValue"
-	v-bind="{ ...$attrs, class: void 0, ...ariaLabel }"
+	v-bind="{
+  ...$attrs,
+  class: void 0
+}"
 	@keydown="handleKeydown"
 	@input="emit('input', $event)"
 >
@@ -84,39 +83,30 @@
 
 <script setup>
 import { useAttrs } from "vue";
-import { useAriaLabel } from "../../composables/useAriaLabel.js";
+import { useFallbackId } from "../../composables/useFallbackId.js";
 import { usePreHydrationValue } from "../../composables/usePreHydrationValue.js";
 import { hasModifiers } from "../../helpers/hasModifiers.js";
 import { twMerge } from "../../utils/twMerge.js";
-import { getFallbackId } from "../shared/props.js";
 defineOptions({
-  name: "LibSimpleInput",
+  name: "WSimpleInput",
   inheritAttrs: false
 });
-const fallbackId = getFallbackId();
 const props = defineProps({
+  unstyle: { type: Boolean, required: false },
+  border: { type: Boolean, required: false, default: true },
   id: { type: String, required: false, default: "" },
   label: { type: String, required: false, default: "" },
-  disabled: { type: Boolean, required: false, default: false },
-  readonly: { type: Boolean, required: false, default: false },
-  border: { type: Boolean, required: false, default: true },
-  unstyle: { type: Boolean, required: false, default: false },
-  placeholder: { type: null, required: false, default: "" },
-  type: { type: null, required: false, default: void 0 },
-  valid: { type: Boolean, required: false, default: true }
+  valid: { type: Boolean, required: false, default: true },
+  type: { type: null, required: false, default: void 0 }
 });
+const finalId = useFallbackId(props);
 const modelValue = defineModel({ type: null, ...{ required: true } });
 const emit = defineEmits(["submit", "input"]);
 const $attrs = useAttrs();
-const ariaLabel = useAriaLabel(props, fallbackId);
 function handleKeydown(e) {
   if (e.key === "Enter" && !hasModifiers(e)) {
     emit("submit", modelValue.value);
   }
 }
-usePreHydrationValue(props.id ?? fallbackId, modelValue);
-</script>
-
-<script>
-
+usePreHydrationValue(finalId, modelValue);
 </script>

package/dist/runtime/components/WSimpleInput/WSimpleInput.vue.d.ts

@@ -0,0 +1,34 @@
+import { type InputHTMLAttributes } from "vue";
+import type { BaseInteractiveProps, TailwindClassProp } from "../../types/index.js";
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(Omit<InputHTMLAttributes, "class" | "onInput" | "onSubmit" | "disabled" | "type" | "readonly" | "autocomplete"> & TailwindClassProp & Pick<BaseInteractiveProps, "border" | "unstyle"> & {
+        id?: string;
+        label?: string;
+        valid?: boolean;
+        type?: InputHTMLAttributes["type"];
+    } & {
+        modelValue: T;
+    }) & {
+        onSubmit?: ((val: T) => any) | undefined;
+        onInput?: ((val: InputEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: {
+        (e: "submit", val: T): void;
+        (e: "input", val: InputEvent): void;
+    } & ((event: "update:modelValue", value: T) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/components/WTable/WTable.d.vue.ts

@@ -0,0 +1,102 @@
+import { type VirtualizerOptions } from "@tanstack/vue-virtual";
+import { type HTMLAttributes, type TableHTMLAttributes } from "vue";
+import type { ResizableOptions, TableColConfig, TailwindClassProp } from "../../types/index.js";
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        resizable?: Partial<ResizableOptions>;
+        values: T[];
+        /** Let's the table know the shape of the data since values might be empty. */
+        cols?: (keyof T)[];
+        rounded?: boolean;
+        border?: boolean;
+        cellBorder?: boolean;
+        /** Disables the header. This also sets the selector to `tr:first-child > td` instead to avoid issues with the vResizableCols directive. */
+        header?: boolean;
+        colConfig?: TableColConfig<T>;
+        /**
+         * See tanstack/vue-virtual {@link https://tanstack.com/virtual/latest/docs/api/virtualizer}
+         *
+         * The defaults are:
+         *
+         * - enabled: false
+         * - method: "fixed"
+         * - overscan: (50 if fixed, 10 if dynamic)
+         * - estimateSize: () => { return 33 }
+         *
+         * This also has an additional option, `method`, which can be set to `fixed` or `dynamic` (experimental).
+         *
+         * Notes:
+         *
+         * - Because of how virtualization works, initial layout (before .resizable-cols-setup class is applied) will only have access to the headers and not the rows. This can cause cols to look very small, especially if using resizable.fitWidth false.
+         *
+         * ### Fixed
+         *
+         * `fixed` is the default and will set the height of ALL items to the height of the first item onMounted (tanstack does not do this and if your estimateSize if off, the scrolling is weird).
+         *
+         * Since the table now truncates rows by default, they will always be the same height unless you change the inner styling. In fixed mode, `forceRecalculateFixedVirtualizer` is exposed if you need to force re-calculation.
+         *
+         * If using slots, be sure to at least pass the `class` slot prop to the td element. `style` with width is also supplied but is not required if you're displaying the table as a table.
+         *
+         * ### Dynamic (experimental)
+         *
+         * In `dynamic` mode we use tanstack's measureElement method. This is more expensive, but it will work with any heights.
+         *
+         * Dynamic mode also requires the table displays itself using grid and flex post setup as otherwise dynamic mode doesn't work.
+         *
+         * You don't need to do anything unless using slots. If using slots, pass the given `ref` slot prop to ref (internally this is tanstack's measureElement) and the class and style slot props at the very least:
+         * ```vue
+         * <template #[`${colName}`]="slotProps">
+         * 	<td
+         * 		:ref="slotProps.ref"
+         * 		:class="slotProps.class"
+         * 		:style="slotProps.style"
+         * 	>
+         * 		{{ slotProps.value }}
+         * 	</td>
+         * </template>
+         * ```
+         */
+        virtualizerOptions?: Partial<VirtualizerOptions<any, any>> & {
+            method?: "fixed" | "dynamic";
+        };
+        /** Whether to enable sticky header styles. This requires `border:false`. This moves the border to the wrapper and styles a straight border between the scroll bar and the rounded border. */
+        stickyHeader?: boolean;
+        /** Which key to use for the rows (only if not using virtualization). */
+        itemKey?: keyof T | ((item: T) => string);
+        /** Pass attributes to the wrapper div. To pass to the table you can use regular top level attributes. */
+        wrapperAttrs?: Omit<HTMLAttributes, "class"> & TailwindClassProp;
+    } & Omit<TableHTMLAttributes, "class" | "disabled" | "readonly"> & TailwindClassProp> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        forceRecalculateFixedVirtualizer: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        [x: `header-${string}`]: ((props: {
+            colKey: keyof T;
+            config: any;
+            style: {
+                width: undefined;
+            };
+            class: string | undefined;
+        }) => any) | undefined;
+    } & { [K in NonNullable<keyof T>]?: ((props: {
+        class: string | undefined;
+        style: {
+            width: undefined;
+        };
+        item: T | undefined;
+        value: NonNullable<T>[keyof T];
+    }) => any) | undefined; };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};