@sewadah/selaras 0.1.1

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

@@ -0,0 +1,40 @@
+import type { VariantProps } from 'tailwind-variants';
+import type { PinInputThemeSlots } from '../theme/pin-input.js';
+import type { UiProp } from '../utils/ui.js';
+import { pinInputTheme } from '../theme/pin-input.js';
+type PinInputVariants = VariantProps<typeof pinInputTheme>;
+export interface PinInputProps {
+    id?: string;
+    modelValue?: (string | number)[];
+    defaultValue?: (string | number)[];
+    /** Number of boxes. @default 5 */
+    length?: number;
+    placeholder?: string;
+    /** Password-style dot masking. */
+    mask?: boolean;
+    /** Sets autocomplete="one-time-code" for SMS autofill, and auto-focuses the first empty box. */
+    otp?: boolean;
+    /** 'number' enables the mobile numeric keypad but loses leading zeros - values are stored as real numbers, not strings ("007" becomes 7). @default 'text' */
+    type?: 'text' | 'number';
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: PinInputVariants['size'];
+    color?: PinInputVariants['color'];
+    name?: string;
+    required?: boolean;
+    ui?: UiProp<PinInputThemeSlots>;
+}
+export interface PinInputEmits {
+    'update:modelValue': [value: (string | number)[]];
+    /** Fires once, when every box has a value. */
+    'complete': [value: (string | number)[]];
+}
+declare const __VLS_export: import("vue").DefineComponent<PinInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: (string | number)[]) => any;
+    complete: (value: (string | number)[]) => any;
+}, string, import("vue").PublicProps, Readonly<PinInputProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+    onComplete?: ((value: (string | number)[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,52 @@
+import type { PopoverThemeSlots } from '../theme/popover.js';
+import type { UiProp } from '../utils/ui.js';
+export interface PopoverProps {
+    open?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    /** Forwarded to Reka UI's own PopoverRoot `modal` prop - `true` traps focus and blocks interaction with the rest of the page, like a lightweight modal dialog. */
+    modal?: boolean;
+    /** When `false`, Escape and an outside click (or, since a popover is non-modal by default, an outside element merely receiving focus) no longer close the popover - the `escapeKeyDown`/`pointerDownOutside`/`focusOutside` events still fire, so a consumer can still react, but none of them close it on their own anymore. */
+    dismissible?: boolean;
+    /** When `false`, closing the popover no longer returns keyboard focus to its trigger. Reka does this by default regardless of *why* the popover closed, including a purely programmatic `open` change - which matters for a popover that can open via hover rather than a deliberate click/keypress: focus landing back on a trigger nobody meant to focus can itself count as focus moving "outside" whatever *other* popover the pointer has since moved on to, closing that one too. Defaults to `true`, matching Reka's own out-of-the-box behavior. */
+    returnFocusOnClose?: boolean;
+    /** Shows the little pointer triangle connecting the popover to its trigger. */
+    arrow?: boolean;
+    ui?: UiProp<PopoverThemeSlots>;
+}
+export interface PopoverEmits {
+    'update:open': [value: boolean];
+    'escapeKeyDown': [event: KeyboardEvent];
+    'pointerDownOutside': [event: Event];
+    'focusOutside': [event: Event];
+    /** Fires right before Reka moves keyboard focus into the popover on open. Forwarded raw (no `dismissible`-style prop gating it, unlike the events above) - a consumer that only wants to suppress this for *some* opens (e.g. a hover-opened popover where a mouse-driven open shouldn't yank focus, but a keyboard-driven one still should) needs to decide per-event, which a static prop can't express. Call `event.preventDefault()` in a listener to skip the default autofocus for that one open. */
+    'openAutoFocus': [event: Event];
+}
+export interface PopoverSlots {
+    /** The trigger element. */
+    default?: () => any;
+    /** The popover's own content. */
+    content?: () => any;
+}
+type __VLS_Slots = PopoverSlots;
+declare const __VLS_base: import("vue").DefineComponent<PopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: Event) => any;
+    openAutoFocus: (event: Event) => any;
+    focusOutside: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<PopoverProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: Event) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onFocusOutside?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Popover.vue

@@ -0,0 +1,77 @@
+<script setup>
+import { PopoverArrow, PopoverContent, PopoverPortal, PopoverRoot, PopoverTrigger } from "reka-ui";
+import { computed, ref, watch } from "vue";
+import { popoverTheme } from "../theme/popover";
+import { resolveSlot, useComponentTheme } from "../utils/ui";
+const props = defineProps({
+  open: { type: Boolean, required: false },
+  side: { type: String, required: false, default: "bottom" },
+  align: { type: String, required: false, default: "center" },
+  modal: { type: Boolean, required: false, default: false },
+  dismissible: { type: Boolean, required: false, default: true },
+  returnFocusOnClose: { type: Boolean, required: false, default: true },
+  arrow: { type: Boolean, required: false, default: false },
+  ui: { type: Object, required: false }
+});
+const emit = defineEmits(["update:open", "escapeKeyDown", "pointerDownOutside", "focusOutside", "openAutoFocus"]);
+defineSlots();
+function onEscapeKeyDown(event) {
+  if (!props.dismissible)
+    event.preventDefault();
+  emit("escapeKeyDown", event);
+}
+function onPointerDownOutside(event) {
+  if (!props.dismissible)
+    event.preventDefault();
+  emit("pointerDownOutside", event);
+}
+function onFocusOutside(event) {
+  if (!props.dismissible)
+    event.preventDefault();
+  emit("focusOutside", event);
+}
+function onCloseAutoFocus(event) {
+  if (!props.returnFocusOnClose)
+    event.preventDefault();
+}
+function onOpenAutoFocus(event) {
+  emit("openAutoFocus", event);
+}
+const theme = useComponentTheme("popover", popoverTheme);
+const ui = computed(() => theme.value());
+const contentProps = computed(() => resolveSlot(ui.value.content, props.ui?.content));
+const arrowProps = computed(() => resolveSlot(ui.value.arrow, props.ui?.arrow));
+const internalOpen = ref(props.open ?? false);
+watch(() => props.open, (value) => {
+  if (value !== void 0)
+    internalOpen.value = value;
+});
+function onUpdateOpen(value) {
+  internalOpen.value = value;
+  emit("update:open", value);
+}
+</script>
+
+<template>
+  <PopoverRoot :open="internalOpen" :modal="modal" @update:open="onUpdateOpen">
+    <PopoverTrigger v-if="$slots.default" as-child>
+      <slot />
+    </PopoverTrigger>
+    <PopoverPortal>
+      <PopoverContent
+        :side="side"
+        :align="align"
+        :side-offset="8"
+        v-bind="contentProps"
+        @escape-key-down="onEscapeKeyDown"
+        @pointer-down-outside="onPointerDownOutside"
+        @focus-outside="onFocusOutside"
+        @close-auto-focus="onCloseAutoFocus"
+        @open-auto-focus="onOpenAutoFocus"
+      >
+        <slot name="content" />
+        <PopoverArrow v-if="arrow" v-bind="arrowProps" />
+      </PopoverContent>
+    </PopoverPortal>
+  </PopoverRoot>
+</template>

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

@@ -0,0 +1,52 @@
+import type { PopoverThemeSlots } from '../theme/popover.js';
+import type { UiProp } from '../utils/ui.js';
+export interface PopoverProps {
+    open?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    /** Forwarded to Reka UI's own PopoverRoot `modal` prop - `true` traps focus and blocks interaction with the rest of the page, like a lightweight modal dialog. */
+    modal?: boolean;
+    /** When `false`, Escape and an outside click (or, since a popover is non-modal by default, an outside element merely receiving focus) no longer close the popover - the `escapeKeyDown`/`pointerDownOutside`/`focusOutside` events still fire, so a consumer can still react, but none of them close it on their own anymore. */
+    dismissible?: boolean;
+    /** When `false`, closing the popover no longer returns keyboard focus to its trigger. Reka does this by default regardless of *why* the popover closed, including a purely programmatic `open` change - which matters for a popover that can open via hover rather than a deliberate click/keypress: focus landing back on a trigger nobody meant to focus can itself count as focus moving "outside" whatever *other* popover the pointer has since moved on to, closing that one too. Defaults to `true`, matching Reka's own out-of-the-box behavior. */
+    returnFocusOnClose?: boolean;
+    /** Shows the little pointer triangle connecting the popover to its trigger. */
+    arrow?: boolean;
+    ui?: UiProp<PopoverThemeSlots>;
+}
+export interface PopoverEmits {
+    'update:open': [value: boolean];
+    'escapeKeyDown': [event: KeyboardEvent];
+    'pointerDownOutside': [event: Event];
+    'focusOutside': [event: Event];
+    /** Fires right before Reka moves keyboard focus into the popover on open. Forwarded raw (no `dismissible`-style prop gating it, unlike the events above) - a consumer that only wants to suppress this for *some* opens (e.g. a hover-opened popover where a mouse-driven open shouldn't yank focus, but a keyboard-driven one still should) needs to decide per-event, which a static prop can't express. Call `event.preventDefault()` in a listener to skip the default autofocus for that one open. */
+    'openAutoFocus': [event: Event];
+}
+export interface PopoverSlots {
+    /** The trigger element. */
+    default?: () => any;
+    /** The popover's own content. */
+    content?: () => any;
+}
+type __VLS_Slots = PopoverSlots;
+declare const __VLS_base: import("vue").DefineComponent<PopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: Event) => any;
+    openAutoFocus: (event: Event) => any;
+    focusOutside: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<PopoverProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: Event) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onFocusOutside?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,32 @@
+import type { VariantProps } from 'tailwind-variants';
+import type { ProgressThemeSlots } from '../theme/progress.js';
+import type { UiProp } from '../utils/ui.js';
+import { progressTheme } from '../theme/progress.js';
+type ProgressVariants = VariantProps<typeof progressTheme>;
+type __VLS_Slots = ProgressSlots;
+export interface ProgressProps {
+    /** `null`/unset renders an indeterminate progress - Reka's own ProgressRoot semantics. */
+    modelValue?: number | null;
+    /** @default 100 */
+    max?: number;
+    /** @default 'linear' */
+    type?: 'linear' | 'circular';
+    size?: ProgressVariants['size'];
+    color?: ProgressVariants['color'];
+    ui?: UiProp<ProgressThemeSlots>;
+}
+export interface ProgressSlots {
+    /** Custom label content - centered inside the ring for `circular`, placed by you anywhere for `linear` (there's no room to overlay text on an 8px-tall bar). */
+    default?: (props: {
+        percent: number | null;
+    }) => any;
+}
+declare const __VLS_base: import("vue").DefineComponent<ProgressProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Progress.vue

@@ -0,0 +1,76 @@
+<script setup>
+import { ProgressIndicator, ProgressRoot } from "reka-ui";
+import { computed } from "vue";
+import { progressTheme } from "../theme/progress";
+import { resolveSlot, useComponentTheme, useRootProps } from "../utils/ui";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  modelValue: { type: [Number, null], required: false },
+  max: { type: Number, required: false, default: 100 },
+  type: { type: String, required: false, default: "linear" },
+  size: { type: null, required: false },
+  color: { type: null, required: false },
+  ui: { type: Object, required: false }
+});
+defineSlots();
+const CIRCLE_SIZES = {
+  sm: { diameter: 32, strokeWidth: 3 },
+  md: { diameter: 48, strokeWidth: 4 },
+  lg: { diameter: 64, strokeWidth: 5 }
+};
+const percent = computed(() => {
+  if (props.modelValue == null)
+    return null;
+  return Math.min(100, Math.max(0, props.modelValue / props.max * 100));
+});
+const circleSpec = computed(() => CIRCLE_SIZES[props.size ?? "md"]);
+const radius = computed(() => (circleSpec.value.diameter - circleSpec.value.strokeWidth) / 2);
+const circumference = computed(() => 2 * Math.PI * radius.value);
+const dashOffset = computed(() => percent.value == null ? circumference.value * 0.75 : circumference.value * (1 - percent.value / 100));
+const theme = useComponentTheme("progress", progressTheme);
+const ui = computed(() => theme.value({
+  size: props.size,
+  color: props.color,
+  indeterminate: props.modelValue == null
+}));
+const rootProps = useRootProps(() => ui.value.root, () => props.ui?.root);
+const indicatorProps = computed(() => resolveSlot(ui.value.indicator, props.ui?.indicator));
+const circleRootProps = computed(() => resolveSlot(ui.value.circleRoot, props.ui?.circleRoot));
+const circleWrapperProps = computed(() => resolveSlot(ui.value.circleWrapper, props.ui?.circleWrapper));
+const circleTrackProps = computed(() => resolveSlot(ui.value.circleTrack, props.ui?.circleTrack));
+const circleIndicatorProps = computed(() => resolveSlot(ui.value.circleIndicator, props.ui?.circleIndicator));
+const labelProps = computed(() => resolveSlot(ui.value.label, props.ui?.label));
+</script>
+
+<template>
+  <ProgressRoot v-if="type === 'linear'" :model-value="modelValue" :max="max" v-bind="rootProps">
+    <ProgressIndicator v-bind="indicatorProps" :style="modelValue == null ? void 0 : { width: `${percent}%` }" />
+  </ProgressRoot>
+  <ProgressRoot v-else :model-value="modelValue" :max="max" v-bind="circleRootProps">
+    <svg :width="circleSpec.diameter" :height="circleSpec.diameter" :viewBox="`0 0 ${circleSpec.diameter} ${circleSpec.diameter}`" v-bind="circleWrapperProps">
+      <circle
+        :cx="circleSpec.diameter / 2"
+        :cy="circleSpec.diameter / 2"
+        :r="radius"
+        fill="none"
+        :stroke-width="circleSpec.strokeWidth"
+        v-bind="circleTrackProps"
+      />
+      <ProgressIndicator
+        as="circle"
+        :cx="circleSpec.diameter / 2"
+        :cy="circleSpec.diameter / 2"
+        :r="radius"
+        fill="none"
+        :stroke-width="circleSpec.strokeWidth"
+        stroke-linecap="round"
+        :stroke-dasharray="circumference"
+        :stroke-dashoffset="dashOffset"
+        v-bind="circleIndicatorProps"
+      />
+    </svg>
+    <div v-if="$slots.default" v-bind="labelProps">
+      <slot :percent="percent" />
+    </div>
+  </ProgressRoot>
+</template>

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

@@ -0,0 +1,32 @@
+import type { VariantProps } from 'tailwind-variants';
+import type { ProgressThemeSlots } from '../theme/progress.js';
+import type { UiProp } from '../utils/ui.js';
+import { progressTheme } from '../theme/progress.js';
+type ProgressVariants = VariantProps<typeof progressTheme>;
+type __VLS_Slots = ProgressSlots;
+export interface ProgressProps {
+    /** `null`/unset renders an indeterminate progress - Reka's own ProgressRoot semantics. */
+    modelValue?: number | null;
+    /** @default 100 */
+    max?: number;
+    /** @default 'linear' */
+    type?: 'linear' | 'circular';
+    size?: ProgressVariants['size'];
+    color?: ProgressVariants['color'];
+    ui?: UiProp<ProgressThemeSlots>;
+}
+export interface ProgressSlots {
+    /** Custom label content - centered inside the ring for `circular`, placed by you anywhere for `linear` (there's no room to overlay text on an 8px-tall bar). */
+    default?: (props: {
+        percent: number | null;
+    }) => any;
+}
+declare const __VLS_base: import("vue").DefineComponent<ProgressProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,18 @@
+export interface ProseH1Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH1Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH1Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ProseH1.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { computed } from "vue";
+import { proseTheme } from "../theme/prose";
+import { resolveSlot, useComponentTheme, useRootProps } from "../utils/ui";
+defineOptions({ inheritAttrs: false });
+defineProps({
+  id: { type: String, required: false }
+});
+const theme = useComponentTheme("prose", proseTheme);
+const ui = computed(() => theme.value());
+const rootProps = useRootProps(() => ui.value.h1, () => void 0);
+</script>
+
+<template>
+  <h1 :id="id" v-bind="rootProps">
+    <a v-if="id" :href="`#${id}`" v-bind="resolveSlot(ui.headingAnchor, void 0)">
+      <slot />
+    </a>
+    <slot v-else />
+  </h1>
+</template>

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

@@ -0,0 +1,18 @@
+export interface ProseH1Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH1Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH1Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,18 @@
+export interface ProseH2Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH2Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH2Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ProseH2.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { computed } from "vue";
+import { proseTheme } from "../theme/prose";
+import { resolveSlot, useComponentTheme, useRootProps } from "../utils/ui";
+defineOptions({ inheritAttrs: false });
+defineProps({
+  id: { type: String, required: false }
+});
+const theme = useComponentTheme("prose", proseTheme);
+const ui = computed(() => theme.value());
+const rootProps = useRootProps(() => ui.value.h2, () => void 0);
+</script>
+
+<template>
+  <h2 :id="id" v-bind="rootProps">
+    <a v-if="id" :href="`#${id}`" v-bind="resolveSlot(ui.headingAnchor, void 0)">
+      <slot />
+    </a>
+    <slot v-else />
+  </h2>
+</template>

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

@@ -0,0 +1,18 @@
+export interface ProseH2Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH2Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH2Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,18 @@
+export interface ProseH3Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH3Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH3Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ProseH3.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { computed } from "vue";
+import { proseTheme } from "../theme/prose";
+import { resolveSlot, useComponentTheme, useRootProps } from "../utils/ui";
+defineOptions({ inheritAttrs: false });
+defineProps({
+  id: { type: String, required: false }
+});
+const theme = useComponentTheme("prose", proseTheme);
+const ui = computed(() => theme.value());
+const rootProps = useRootProps(() => ui.value.h3, () => void 0);
+</script>
+
+<template>
+  <h3 :id="id" v-bind="rootProps">
+    <a v-if="id" :href="`#${id}`" v-bind="resolveSlot(ui.headingAnchor, void 0)">
+      <slot />
+    </a>
+    <slot v-else />
+  </h3>
+</template>

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

@@ -0,0 +1,18 @@
+export interface ProseH3Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH3Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH3Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,18 @@
+export interface ProseH4Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH4Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH4Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ProseH4.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { computed } from "vue";
+import { proseTheme } from "../theme/prose";
+import { resolveSlot, useComponentTheme, useRootProps } from "../utils/ui";
+defineOptions({ inheritAttrs: false });
+defineProps({
+  id: { type: String, required: false }
+});
+const theme = useComponentTheme("prose", proseTheme);
+const ui = computed(() => theme.value());
+const rootProps = useRootProps(() => ui.value.h4, () => void 0);
+</script>
+
+<template>
+  <h4 :id="id" v-bind="rootProps">
+    <a v-if="id" :href="`#${id}`" v-bind="resolveSlot(ui.headingAnchor, void 0)">
+      <slot />
+    </a>
+    <slot v-else />
+  </h4>
+</template>

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

@@ -0,0 +1,18 @@
+export interface ProseH4Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH4Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH4Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,18 @@
+export interface ProseH5Props {
+    id?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProseH5Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseH5Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ProseH5.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { computed } from "vue";
+import { proseTheme } from "../theme/prose";
+import { resolveSlot, useComponentTheme, useRootProps } from "../utils/ui";
+defineOptions({ inheritAttrs: false });
+defineProps({
+  id: { type: String, required: false }
+});
+const theme = useComponentTheme("prose", proseTheme);
+const ui = computed(() => theme.value());
+const rootProps = useRootProps(() => ui.value.h5, () => void 0);
+</script>
+
+<template>
+  <h5 :id="id" v-bind="rootProps">
+    <a v-if="id" :href="`#${id}`" v-bind="resolveSlot(ui.headingAnchor, void 0)">
+      <slot />
+    </a>
+    <slot v-else />
+  </h5>
+</template>