@eslamdevui/ui 3.2.0-beta.1 → 3.2.0-beta.2

package/dist/runtime/components/prose/Hr.vue.d.ts

@@ -0,0 +1,5 @@
+export interface ProseHrProps {
+    class?: any;
+}
+declare const _default: import("vue").DefineComponent<ProseHrProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseHrProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/prose/Icon.vue

@@ -0,0 +1,19 @@
+<script>
+import theme from "#build/ui/prose/icon";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  name: { type: String, required: true },
+  class: { type: null, required: false }
+});
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.icon || {} }));
+</script>
+
+<template>
+  <UIcon :name="name" :class="ui({ class: props.class })" />
+</template>

package/dist/runtime/components/prose/Icon.vue.d.ts

@@ -0,0 +1,6 @@
+export interface ProseIconProps {
+    name: string;
+    class?: any;
+}
+declare const _default: import("vue").DefineComponent<ProseIconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/prose/Img.vue

@@ -0,0 +1,40 @@
+<script>
+import theme from "#build/ui/prose/img";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { withTrailingSlash, withLeadingSlash, joinURL } from "ufo";
+import { useRuntimeConfig, useAppConfig } from "#imports";
+import ImageComponent from "#build/ui-image-component";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  src: { type: String, required: true },
+  alt: { type: String, required: true },
+  width: { type: [String, Number], required: false },
+  height: { type: [String, Number], required: false },
+  class: { type: null, required: false }
+});
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.img || {} }));
+const refinedSrc = computed(() => {
+  if (props.src?.startsWith("/") && !props.src.startsWith("//")) {
+    const _base = withLeadingSlash(withTrailingSlash(useRuntimeConfig().app.baseURL));
+    if (_base !== "/" && !props.src.startsWith(_base)) {
+      return joinURL(_base, props.src);
+    }
+  }
+  return props.src;
+});
+</script>
+
+<template>
+  <component
+    :is="ImageComponent"
+    :src="refinedSrc"
+    :alt="alt"
+    :width="width"
+    :height="height"
+    :class="ui({ class: props.class })"
+  />
+</template>

package/dist/runtime/components/prose/Img.vue.d.ts

@@ -0,0 +1,9 @@
+export interface ProseImgProps {
+    src: string;
+    alt: string;
+    width?: string | number;
+    height?: string | number;
+    class?: any;
+}
+declare const _default: import("vue").DefineComponent<ProseImgProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseImgProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/prose/Kbd.vue

@@ -0,0 +1,19 @@
+<script>
+import theme from "#build/ui/prose/kbd";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  value: { type: String, required: true },
+  class: { type: null, required: false }
+});
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.kbd || {} }));
+</script>
+
+<template>
+  <UKbd :value="value" :class="ui({ class: props.class })" />
+</template>

package/dist/runtime/components/prose/Kbd.vue.d.ts

@@ -0,0 +1,6 @@
+export interface ProseKbdProps {
+    value: string;
+    class?: any;
+}
+declare const _default: import("vue").DefineComponent<ProseKbdProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseKbdProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/prose/Li.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/li";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.li || {} }));
+</script>
+
+<template>
+  <li :class="ui({ class: props.class })">
+    <slot />
+  </li>
+</template>

package/dist/runtime/components/prose/Li.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseLiProps {
+    class?: any;
+}
+export interface ProseLiSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseLiProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseLiProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseLiSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Ol.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/ol";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.ol || {} }));
+</script>
+
+<template>
+  <ol :class="ui({ class: props.class })">
+    <slot />
+  </ol>
+</template>

package/dist/runtime/components/prose/Ol.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseOlProps {
+    class?: any;
+}
+export interface ProseOlSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseOlProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseOlProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseOlSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/P.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/p";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.p || {} }));
+</script>
+
+<template>
+  <p :class="ui({ class: props.class })">
+    <slot />
+  </p>
+</template>

package/dist/runtime/components/prose/P.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProsePProps {
+    class?: any;
+}
+export interface ProsePSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProsePProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProsePProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProsePSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Pre.vue

@@ -0,0 +1,63 @@
+<script>
+import theme from "#build/ui/prose/pre";
+</script>
+
+<script setup>
+import { ref, computed } from "vue";
+import { useClipboard } from "@vueuse/core";
+import { useAppConfig } from "#imports";
+import { useLocalePro } from "../../composables/useLocalePro";
+import CodeIcon from "./CodeIcon.vue";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  icon: { type: String, required: false },
+  code: { type: String, required: false },
+  language: { type: String, required: false },
+  filename: { type: String, required: false },
+  highlights: { type: Array, required: false },
+  hideHeader: { type: Boolean, required: false },
+  meta: { type: String, required: false },
+  class: { type: null, required: false },
+  ui: { type: null, required: false }
+});
+defineSlots();
+const { t } = useLocalePro();
+const clipboard = useClipboard();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.pre || {} })());
+const copied = ref(false);
+function copy() {
+  clipboard.copy(props.code || "");
+  copied.value = true;
+  setTimeout(() => {
+    copied.value = false;
+  }, 2e3);
+}
+</script>
+
+<template>
+  <div :class="ui.root({ class: [props.ui?.root], filename: !!filename })">
+    <div v-if="filename && !hideHeader" :class="ui.header({ class: props.ui?.header })">
+      <CodeIcon :icon="icon" :filename="filename" :class="ui.icon({ class: props.ui?.icon })" />
+
+      <span :class="ui.filename({ class: props.ui?.filename })">{{ filename }}</span>
+    </div>
+
+    <UButton
+      :icon="copied ? appConfig.ui.icons.copyCheck : appConfig.ui.icons.copy"
+      color="neutral"
+      variant="outline"
+      size="sm"
+      :aria-label="t('prose.pre.copy')"
+      :class="ui.copy({ class: props.ui?.copy })"
+      tabindex="-1"
+      @click="copy"
+    />
+
+    <pre :class="ui.base({ class: [props.ui?.base, props.class] })" v-bind="$attrs"><slot /></pre>
+  </div>
+</template>
+
+<style>
+.shiki span.line{display:block}.shiki span.line.highlight{margin:0 -16px;padding:0 16px;@apply bg-(--ui-bg-accented)/50}
+</style>

package/dist/runtime/components/prose/Pre.vue.d.ts

@@ -0,0 +1,25 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ComponentConfig } from '../../types';
+import theme from '#build/ui/prose/pre';
+type ProsePre = ComponentConfig<typeof theme, AppConfig, 'pre', 'ui.prose'>;
+export interface ProsePreProps {
+    icon?: string;
+    code?: string;
+    language?: string;
+    filename?: string;
+    highlights?: number[];
+    hideHeader?: boolean;
+    meta?: string;
+    class?: any;
+    ui?: ProsePre['slots'];
+}
+export interface ProsePreSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProsePreProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProsePreProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProsePreSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Script.vue

@@ -0,0 +1,12 @@
+<script setup>
+defineProps({
+  src: { type: String, required: true }
+});
+const isDev = import.meta.dev;
+</script>
+
+<template>
+  <div v-if="isDev">
+    Rendering the <code>script</code> element is dangerous and is disabled by default. Consider implementing your own <code>ProseScript</code> element to have control over script rendering.
+  </div>
+</template>

package/dist/runtime/components/prose/Script.vue.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/components/prose/Steps.vue

@@ -0,0 +1,22 @@
+<script>
+import theme from "#build/ui/prose/steps";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  level: { type: null, required: false },
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.steps || {} }));
+</script>
+
+<template>
+  <div :class="ui({ class: props.class, level: props.level })">
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/prose/Steps.vue.d.ts

@@ -0,0 +1,22 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ComponentConfig } from '../../types';
+import theme from '#build/ui/prose/steps';
+type ProseSteps = ComponentConfig<typeof theme, AppConfig, 'steps', 'ui.prose'>;
+export interface ProseStepsProps {
+    /**
+     * The heading level to apply to the steps.
+     * @defaultValue '3'
+     */
+    level?: ProseSteps['variants']['level'];
+    class?: any;
+}
+export interface ProseStepsSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseStepsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseStepsProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseStepsSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Strong.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/strong";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.strong || {} }));
+</script>
+
+<template>
+  <strong :class="ui({ class: props.class })">
+    <slot />
+  </strong>
+</template>

package/dist/runtime/components/prose/Strong.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseStrongProps {
+    class?: any;
+}
+export interface ProseStrongSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseStrongProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseStrongProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseStrongSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Table.vue

@@ -0,0 +1,24 @@
+<script>
+import theme from "#build/ui/prose/table";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false },
+  ui: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.table || {} })());
+</script>
+
+<template>
+  <div :class="ui.root({ class: [props.ui?.root, props.class] })">
+    <table :class="ui.base({ class: props.ui?.base })">
+      <slot />
+    </table>
+  </div>
+</template>

package/dist/runtime/components/prose/Table.vue.d.ts

@@ -0,0 +1,18 @@
+import theme from '#build/ui/prose/table';
+import type { AppConfig } from '@nuxt/schema';
+import type { ComponentConfig } from '../../types';
+type ProseTable = ComponentConfig<typeof theme, AppConfig, 'table', 'ui.prose'>;
+export interface ProseTableProps {
+    class?: any;
+    ui?: ProseTable['slots'];
+}
+export interface ProseTableSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTableProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseTableProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTableSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Tabs.vue

@@ -0,0 +1,78 @@
+<script>
+import theme from "#build/ui/prose/tabs";
+</script>
+
+<script setup>
+import { computed, watch, onMounted, ref, onBeforeUpdate } from "vue";
+import { useState, useAppConfig } from "#imports";
+import { transformUI } from "../../utils";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  defaultValue: { type: String, required: false, default: "0" },
+  sync: { type: String, required: false },
+  hash: { type: String, required: false },
+  class: { type: null, required: false }
+});
+const slots = defineSlots();
+const model = defineModel({ type: String });
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.tabs || {} }));
+const rerenderCount = ref(1);
+const items = computed(() => {
+  const _ = rerenderCount.value;
+  return slots.default?.()?.flatMap(transformSlot).filter(Boolean) || [];
+});
+function transformSlot(slot, index) {
+  if (typeof slot.type === "symbol") {
+    return slot.children?.map(transformSlot);
+  }
+  return {
+    index,
+    label: slot.props?.label || `${index}`,
+    description: slot.props?.description,
+    icon: slot.props?.icon,
+    component: slot
+  };
+}
+onMounted(() => {
+  if (props.sync) {
+    const syncKey = `tabs-${props.sync}`;
+    const syncValue = useState(syncKey, () => localStorage.getItem(syncKey));
+    watch(syncValue, () => {
+      if (!syncValue.value) return;
+      model.value = syncValue.value;
+    }, { immediate: true });
+    watch(model, () => {
+      if (!model.value) return;
+      syncValue.value = model.value;
+      localStorage.setItem(syncKey, model.value);
+    });
+  }
+});
+async function onUpdateModelValue() {
+  if (props.hash) {
+    const hash = props.hash.startsWith("#") ? props.hash : `#${props.hash}`;
+    setTimeout(() => {
+      document.querySelector(hash)?.scrollIntoView();
+    }, 200);
+  }
+}
+onBeforeUpdate(() => rerenderCount.value++);
+</script>
+
+<template>
+  <UTabs
+    v-model="model"
+    color="primary"
+    variant="link"
+    :items="items"
+    :class="props.class"
+    :unmount-on-hide="false"
+    :ui="transformUI(ui())"
+    @update:model-value="onUpdateModelValue"
+  >
+    <template #content="{ item }">
+      <component :is="item.component" />
+    </template>
+  </UTabs>
+</template>

package/dist/runtime/components/prose/Tabs.vue.d.ts

@@ -0,0 +1,36 @@
+export interface ProseTabsProps {
+    /**
+     * The default tab to select.
+     * @example '1'
+     */
+    defaultValue?: string;
+    /**
+     * Sync the selected tab with a local storage key.
+     */
+    sync?: string;
+    /**
+     * The hash to scroll to when the tab is selected.
+     */
+    hash?: string;
+    class?: any;
+}
+export interface ProseTabsSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTabsProps & {
+    modelValue?: string | undefined;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<ProseTabsProps & {
+    modelValue?: string | undefined;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    defaultValue: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTabsSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/TabsItem.vue

@@ -0,0 +1,25 @@
+<script>
+import theme from "#build/ui/prose/tabs-item";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  label: { type: String, required: true },
+  description: { type: String, required: false },
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.tabsItem || {} }));
+</script>
+
+<template>
+  <div :class="ui({ class: props.class })">
+    <slot>
+      {{ description }}
+    </slot>
+  </div>
+</template>

package/dist/runtime/components/prose/TabsItem.vue.d.ts

@@ -0,0 +1,15 @@
+export interface ProseTabsItemProps {
+    label: string;
+    description?: string;
+    class?: any;
+}
+export interface ProseTabsItemSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTabsItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseTabsItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTabsItemSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Tbody.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/tbody";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.tbody || {} }));
+</script>
+
+<template>
+  <tbody :class="ui({ class: props.class })">
+    <slot />
+  </tbody>
+</template>