@johly/bits-ui 2.18.1

package/dist/internal/date-time/placeholders.js

@@ -0,0 +1,129 @@
+// prettier-ignore
+const supportedLocales = [
+    'ach', 'af', 'am', 'an', 'ar', 'ast', 'az', 'be', 'bg', 'bn', 'br', 'bs',
+    'ca', 'cak', 'ckb', 'cs', 'cy', 'da', 'de', 'dsb', 'el', 'en', 'eo', 'es',
+    'et', 'eu', 'fa', 'ff', 'fi', 'fr', 'fy', 'ga', 'gd', 'gl', 'he', 'hr',
+    'hsb', 'hu', 'ia', 'id', 'it', 'ja', 'ka', 'kk', 'kn', 'ko', 'lb', 'lo',
+    'lt', 'lv', 'meh', 'ml', 'ms', 'nl', 'nn', 'no', 'oc', 'pl', 'pt', 'rm',
+    'ro', 'ru', 'sc', 'scn', 'sk', 'sl', 'sr', 'sv', 'szl', 'tg', 'th', 'tr',
+    'uk', 'zh-CN', 'zh-TW',
+];
+const placeholderFields = ["year", "month", "day"];
+const placeholders = {
+    ach: { year: "mwaka", month: "dwe", day: "nino" },
+    af: { year: "jjjj", month: "mm", day: "dd" },
+    am: { year: "ዓዓዓዓ", month: "ሚሜ", day: "ቀቀ" },
+    an: { year: "aaaa", month: "mm", day: "dd" },
+    ar: { year: "سنة", month: "شهر", day: "يوم" },
+    ast: { year: "aaaa", month: "mm", day: "dd" },
+    az: { year: "iiii", month: "aa", day: "gg" },
+    be: { year: "гггг", month: "мм", day: "дд" },
+    bg: { year: "гггг", month: "мм", day: "дд" },
+    bn: { year: "yyyy", month: "মিমি", day: "dd" },
+    br: { year: "bbbb", month: "mm", day: "dd" },
+    bs: { year: "gggg", month: "mm", day: "dd" },
+    ca: { year: "aaaa", month: "mm", day: "dd" },
+    cak: { year: "jjjj", month: "ii", day: "q'q'" },
+    ckb: { year: "ساڵ", month: "مانگ", day: "ڕۆژ" },
+    cs: { year: "rrrr", month: "mm", day: "dd" },
+    cy: { year: "bbbb", month: "mm", day: "dd" },
+    da: { year: "åååå", month: "mm", day: "dd" },
+    de: { year: "jjjj", month: "mm", day: "tt" },
+    dsb: { year: "llll", month: "mm", day: "źź" },
+    el: { year: "εεεε", month: "μμ", day: "ηη" },
+    en: { year: "yyyy", month: "mm", day: "dd" },
+    eo: { year: "jjjj", month: "mm", day: "tt" },
+    es: { year: "aaaa", month: "mm", day: "dd" },
+    et: { year: "aaaa", month: "kk", day: "pp" },
+    eu: { year: "uuuu", month: "hh", day: "ee" },
+    fa: { year: "سال", month: "ماه", day: "روز" },
+    ff: { year: "hhhh", month: "ll", day: "ññ" },
+    fi: { year: "vvvv", month: "kk", day: "pp" },
+    fr: { year: "aaaa", month: "mm", day: "jj" },
+    fy: { year: "jjjj", month: "mm", day: "dd" },
+    ga: { year: "bbbb", month: "mm", day: "ll" },
+    gd: { year: "bbbb", month: "mm", day: "ll" },
+    gl: { year: "aaaa", month: "mm", day: "dd" },
+    he: { year: "שנה", month: "חודש", day: "יום" },
+    hr: { year: "gggg", month: "mm", day: "dd" },
+    hsb: { year: "llll", month: "mm", day: "dd" },
+    hu: { year: "éééé", month: "hh", day: "nn" },
+    ia: { year: "aaaa", month: "mm", day: "dd" },
+    id: { year: "tttt", month: "bb", day: "hh" },
+    it: { year: "aaaa", month: "mm", day: "gg" },
+    ja: { year: " 年 ", month: "月", day: "日" },
+    ka: { year: "წწწწ", month: "თთ", day: "რრ" },
+    kk: { year: "жжжж", month: "аа", day: "кк" },
+    kn: { year: "ವವವವ", month: "ಮಿಮೀ", day: "ದಿದಿ" },
+    ko: { year: "연도", month: "월", day: "일" },
+    lb: { year: "jjjj", month: "mm", day: "dd" },
+    lo: { year: "ປປປປ", month: "ດດ", day: "ວວ" },
+    lt: { year: "mmmm", month: "mm", day: "dd" },
+    lv: { year: "gggg", month: "mm", day: "dd" },
+    meh: { year: "aaaa", month: "mm", day: "dd" },
+    ml: { year: "വർഷം", month: "മാസം", day: "തീയതി" },
+    ms: { year: "tttt", month: "mm", day: "hh" },
+    nl: { year: "jjjj", month: "mm", day: "dd" },
+    nn: { year: "åååå", month: "mm", day: "dd" },
+    no: { year: "åååå", month: "mm", day: "dd" },
+    oc: { year: "aaaa", month: "mm", day: "jj" },
+    pl: { year: "rrrr", month: "mm", day: "dd" },
+    pt: { year: "aaaa", month: "mm", day: "dd" },
+    rm: { year: "oooo", month: "mm", day: "dd" },
+    ro: { year: "aaaa", month: "ll", day: "zz" },
+    ru: { year: "гггг", month: "мм", day: "дд" },
+    sc: { year: "aaaa", month: "mm", day: "dd" },
+    scn: { year: "aaaa", month: "mm", day: "jj" },
+    sk: { year: "rrrr", month: "mm", day: "dd" },
+    sl: { year: "llll", month: "mm", day: "dd" },
+    sr: { year: "гггг", month: "мм", day: "дд" },
+    sv: { year: "åååå", month: "mm", day: "dd" },
+    szl: { year: "rrrr", month: "mm", day: "dd" },
+    tg: { year: "сссс", month: "мм", day: "рр" },
+    th: { year: "ปปปป", month: "ดด", day: "วว" },
+    tr: { year: "yyyy", month: "aa", day: "gg" },
+    uk: { year: "рррр", month: "мм", day: "дд" },
+    "zh-CN": { year: "年", month: "月", day: "日" },
+    "zh-TW": { year: "年", month: "月", day: "日" },
+};
+function getPlaceholderObj(locale) {
+    if (!isSupportedLocale(locale)) {
+        const localeLanguage = getLocaleLanguage(locale);
+        if (!isSupportedLocale(localeLanguage)) {
+            return placeholders.en;
+        }
+        else {
+            return placeholders[localeLanguage];
+        }
+    }
+    else {
+        return placeholders[locale];
+    }
+}
+export function getPlaceholder(field, value, locale) {
+    if (isPlaceholderField(field))
+        return getPlaceholderObj(locale)[field];
+    if (isDefaultField(field))
+        return value;
+    if (isTimeField(field))
+        return "––";
+    return "";
+}
+function isSupportedLocale(locale) {
+    return supportedLocales.includes(locale);
+}
+function isPlaceholderField(field) {
+    return placeholderFields.includes(field);
+}
+function isTimeField(field) {
+    return field === "hour" || field === "minute" || field === "second";
+}
+function isDefaultField(field) {
+    return field === "era" || field === "dayPeriod";
+}
+function getLocaleLanguage(locale) {
+    if (Intl.Locale) {
+        return new Intl.Locale(locale).language;
+    }
+    return locale.split("-")[0];
+}

package/dist/internal/date-time/utils.d.ts

@@ -0,0 +1,76 @@
+import { CalendarDateTime, type DateValue, ZonedDateTime } from "@internationalized/date";
+import type { DateMatcher, Granularity, TimeGranularity, TimeValue } from "../../shared/date/types.js";
+type GetDefaultDateProps = {
+    defaultValue?: DateValue | DateValue[] | undefined;
+    minValue?: DateValue;
+    maxValue?: DateValue;
+    granularity?: Granularity;
+};
+type GetDefaultTimeProps = {
+    defaultValue?: TimeValue | undefined;
+    granularity?: TimeGranularity;
+};
+/**
+ * A helper function used throughout the various date builders
+ * to generate a default `DateValue` using the `defaultValue`,
+ * `defaultPlaceholder`, `minValue`, `maxValue`, and `granularity` props.
+ *
+ * It's important to match the `DateValue` type being used
+ * elsewhere in the builder, so they behave according to the
+ * behavior the user expects based on the props they've provided.
+ *
+ */
+export declare function getDefaultDate(opts: GetDefaultDateProps): DateValue;
+export declare function getDefaultTime(opts: GetDefaultTimeProps): TimeValue;
+/**
+ * Given a date string and a reference `DateValue` object, parse the
+ * string to the same type as the reference object.
+ *
+ * Useful for parsing strings from data attributes, which are always
+ * strings, to the same type being used by the date component.
+ */
+export declare function parseStringToDateValue(dateStr: string, referenceVal: DateValue): DateValue;
+/**
+ * Given a `DateValue` object, convert it to a native `Date` object.
+ * If a timezone is provided, the date will be converted to that timezone.
+ * If no timezone is provided, the date will be converted to the local timezone.
+ */
+export declare function toDate(dateValue: DateValue, tz?: string): Date;
+export declare function getDateValueType(date: DateValue): string;
+export declare function parseAnyDateValue(value: string, type: string): DateValue;
+export declare function isZonedDateTime(dateValue: DateValue | TimeValue): dateValue is ZonedDateTime;
+export declare function hasTime(dateValue: DateValue): dateValue is CalendarDateTime | ZonedDateTime;
+/**
+ * Given a date, return the number of days in the month.
+ */
+export declare function getDaysInMonth(date: Date | DateValue): number;
+/**
+ * Determine if a date is before the reference date.
+ * @param dateToCompare - is this date before the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` before this date
+ *
+ * @see {@link isBeforeOrSame} for inclusive
+ */
+export declare function isBefore(dateToCompare: DateValue, referenceDate: DateValue): boolean;
+/**
+ * Determine if a date is after the reference date.
+ * @param dateToCompare - is this date after the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` after this date
+ *
+ * @see {@link isAfterOrSame} for inclusive
+ */
+export declare function isAfter(dateToCompare: DateValue, referenceDate: DateValue): boolean;
+/**
+ * Determine if a date is inclusively between a start and end reference date.
+ *
+ * @param date - is this date inclusively between the `start` and `end` dates
+ * @param start - the start reference date to make the comparison against
+ * @param end - the end reference date to make the comparison against
+ *
+ * @see {@link isBetween} for non-inclusive
+ */
+export declare function isBetweenInclusive(date: DateValue, start: DateValue, end: DateValue): boolean;
+export declare function getLastFirstDayOfWeek<T extends DateValue = DateValue>(date: T, firstDayOfWeek: number, locale: string): T;
+export declare function getNextLastDayOfWeek<T extends DateValue = DateValue>(date: T, firstDayOfWeek: number, locale: string): T;
+export declare function areAllDaysBetweenValid(start: DateValue, end: DateValue, isUnavailable: DateMatcher | undefined, isDisabled: DateMatcher | undefined): boolean;
+export {};

package/dist/internal/date-time/utils.js

@@ -0,0 +1,232 @@
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime, getDayOfWeek, getLocalTimeZone, parseDate, parseDateTime, parseZonedDateTime, toCalendar, } from "@internationalized/date";
+const defaultDateDefaults = {
+    defaultValue: undefined,
+    granularity: "day",
+};
+const defaultTimeDefaults = {
+    defaultValue: undefined,
+    granularity: "minute",
+};
+/**
+ * A helper function used throughout the various date builders
+ * to generate a default `DateValue` using the `defaultValue`,
+ * `defaultPlaceholder`, `minValue`, `maxValue`, and `granularity` props.
+ *
+ * It's important to match the `DateValue` type being used
+ * elsewhere in the builder, so they behave according to the
+ * behavior the user expects based on the props they've provided.
+ *
+ */
+export function getDefaultDate(opts) {
+    const withDefaults = { ...defaultDateDefaults, ...opts };
+    const { defaultValue, granularity, minValue, maxValue } = withDefaults;
+    if (Array.isArray(defaultValue) && defaultValue.length) {
+        return defaultValue[defaultValue.length - 1];
+    }
+    if (defaultValue && !Array.isArray(defaultValue)) {
+        return defaultValue;
+    }
+    else {
+        let date = new Date();
+        if (minValue && date < minValue.toDate(getLocalTimeZone())) {
+            date = minValue.toDate(getLocalTimeZone());
+        }
+        else if (maxValue && date > maxValue.toDate(getLocalTimeZone())) {
+            date = maxValue.toDate(getLocalTimeZone());
+        }
+        const year = date.getFullYear();
+        const month = date.getMonth() + 1;
+        const day = date.getDate();
+        const calendarDateTimeGranularities = ["hour", "minute", "second"];
+        if (calendarDateTimeGranularities.includes(granularity ?? "day")) {
+            return new CalendarDateTime(year, month, day, 0, 0, 0);
+        }
+        return new CalendarDate(year, month, day);
+    }
+}
+export function getDefaultTime(opts) {
+    const withDefaults = { ...defaultTimeDefaults, ...opts };
+    const { defaultValue } = withDefaults;
+    if (defaultValue) {
+        return defaultValue;
+    }
+    else {
+        return new Time(0, 0, 0);
+    }
+}
+/**
+ * Given a date string and a reference `DateValue` object, parse the
+ * string to the same type as the reference object.
+ *
+ * Useful for parsing strings from data attributes, which are always
+ * strings, to the same type being used by the date component.
+ */
+export function parseStringToDateValue(dateStr, referenceVal) {
+    let dateValue;
+    if (referenceVal instanceof ZonedDateTime) {
+        dateValue = parseZonedDateTime(dateStr);
+    }
+    else if (referenceVal instanceof CalendarDateTime) {
+        dateValue = parseDateTime(dateStr);
+    }
+    else {
+        dateValue = parseDate(dateStr);
+    }
+    // ensure the parsed date is in the same calendar as the reference date set by the user.
+    return dateValue.calendar !== referenceVal.calendar
+        ? toCalendar(dateValue, referenceVal.calendar)
+        : dateValue;
+}
+/**
+ * Given a `DateValue` object, convert it to a native `Date` object.
+ * If a timezone is provided, the date will be converted to that timezone.
+ * If no timezone is provided, the date will be converted to the local timezone.
+ */
+export function toDate(dateValue, tz = getLocalTimeZone()) {
+    if (dateValue instanceof ZonedDateTime) {
+        return dateValue.toDate();
+    }
+    else {
+        return dateValue.toDate(tz);
+    }
+}
+export function getDateValueType(date) {
+    if (date instanceof CalendarDate)
+        return "date";
+    if (date instanceof CalendarDateTime)
+        return "datetime";
+    if (date instanceof ZonedDateTime)
+        return "zoneddatetime";
+    throw new Error("Unknown date type");
+}
+export function parseAnyDateValue(value, type) {
+    switch (type) {
+        case "date":
+            return parseDate(value);
+        case "datetime":
+            return parseDateTime(value);
+        case "zoneddatetime":
+            return parseZonedDateTime(value);
+        default:
+            throw new Error(`Unknown date type: ${type}`);
+    }
+}
+function isCalendarDateTime(dateValue) {
+    return dateValue instanceof CalendarDateTime;
+}
+export function isZonedDateTime(dateValue) {
+    return dateValue instanceof ZonedDateTime;
+}
+export function hasTime(dateValue) {
+    return isCalendarDateTime(dateValue) || isZonedDateTime(dateValue);
+}
+/**
+ * Given a date, return the number of days in the month.
+ */
+export function getDaysInMonth(date) {
+    if (date instanceof Date) {
+        const year = date.getFullYear();
+        const month = date.getMonth() + 1;
+        /**
+         * By using zero as the day, we get the
+         * last day of the previous month, which
+         * is the month we originally passed in.
+         */
+        return new Date(year, month, 0).getDate();
+    }
+    else {
+        return date.set({ day: 100 }).day;
+    }
+}
+/**
+ * Determine if a date is before the reference date.
+ * @param dateToCompare - is this date before the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` before this date
+ *
+ * @see {@link isBeforeOrSame} for inclusive
+ */
+export function isBefore(dateToCompare, referenceDate) {
+    return dateToCompare.compare(referenceDate) < 0;
+}
+/**
+ * Determine if a date is after the reference date.
+ * @param dateToCompare - is this date after the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` after this date
+ *
+ * @see {@link isAfterOrSame} for inclusive
+ */
+export function isAfter(dateToCompare, referenceDate) {
+    return dateToCompare.compare(referenceDate) > 0;
+}
+/**
+ * Determine if a date is before or the same as the reference date.
+ *
+ * @param dateToCompare - the date to compare
+ * @param referenceDate - the reference date to make the comparison against
+ *
+ * @see {@link isBefore} for non-inclusive
+ */
+function isBeforeOrSame(dateToCompare, referenceDate) {
+    return dateToCompare.compare(referenceDate) <= 0;
+}
+/**
+ * Determine if a date is after or the same as the reference date.
+ *
+ * @param dateToCompare - is this date after or the same as the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` after or the same as this date
+ *
+ * @see {@link isAfter} for non-inclusive
+ */
+function isAfterOrSame(dateToCompare, referenceDate) {
+    return dateToCompare.compare(referenceDate) >= 0;
+}
+/**
+ * Determine if a date is inclusively between a start and end reference date.
+ *
+ * @param date - is this date inclusively between the `start` and `end` dates
+ * @param start - the start reference date to make the comparison against
+ * @param end - the end reference date to make the comparison against
+ *
+ * @see {@link isBetween} for non-inclusive
+ */
+export function isBetweenInclusive(date, start, end) {
+    return isAfterOrSame(date, start) && isBeforeOrSame(date, end);
+}
+export function getLastFirstDayOfWeek(date, firstDayOfWeek, locale) {
+    const day = getDayOfWeek(date, locale);
+    if (firstDayOfWeek > day) {
+        return date.subtract({ days: day + 7 - firstDayOfWeek });
+    }
+    if (firstDayOfWeek === day) {
+        return date;
+    }
+    return date.subtract({ days: day - firstDayOfWeek });
+}
+export function getNextLastDayOfWeek(date, firstDayOfWeek, locale) {
+    const day = getDayOfWeek(date, locale);
+    const lastDayOfWeek = firstDayOfWeek === 0 ? 6 : firstDayOfWeek - 1;
+    if (day === lastDayOfWeek) {
+        return date;
+    }
+    if (day > lastDayOfWeek) {
+        return date.add({ days: 7 - day + lastDayOfWeek });
+    }
+    return date.add({ days: lastDayOfWeek - day });
+}
+export function areAllDaysBetweenValid(start, end, isUnavailable, isDisabled) {
+    if (isUnavailable === undefined && isDisabled === undefined) {
+        return true;
+    }
+    let dCurrent = start.add({ days: 1 });
+    if (isDisabled?.(dCurrent) || isUnavailable?.(dCurrent)) {
+        return false;
+    }
+    const dEnd = end;
+    while (dCurrent.compare(dEnd) < 0) {
+        dCurrent = dCurrent.add({ days: 1 });
+        if (isDisabled?.(dCurrent) || isUnavailable?.(dCurrent)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/internal/debounce.d.ts

@@ -0,0 +1,4 @@
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, wait?: number): {
+    (...args: Parameters<T>): void;
+    destroy(): void;
+};

package/dist/internal/debounce.js

@@ -0,0 +1,19 @@
+// oxlint-disable-next-line no-explicit-any
+export function debounce(fn, wait = 500) {
+    let timeout = null;
+    const debounced = (...args) => {
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(() => {
+            fn(...args);
+        }, wait);
+    };
+    debounced.destroy = () => {
+        if (timeout !== null) {
+            clearTimeout(timeout);
+            timeout = null;
+        }
+    };
+    return debounced;
+}

package/dist/internal/dom-typeahead.svelte.d.ts

@@ -0,0 +1,14 @@
+type DOMTypeaheadOptions = {
+    onMatch?: (item: HTMLElement) => void;
+    getCurrentItem?: () => HTMLElement | null;
+    getActiveElement: () => HTMLElement | null;
+    getWindow: () => Window & typeof globalThis;
+};
+export declare class DOMTypeahead {
+    #private;
+    constructor(opts: DOMTypeaheadOptions);
+    handleTypeaheadSearch(key: string, candidates: HTMLElement[]): HTMLElement | undefined;
+    resetTypeahead(): void;
+    get search(): string;
+}
+export {};

package/dist/internal/dom-typeahead.svelte.js

@@ -0,0 +1,44 @@
+import { getNextMatch } from "./arrays.js";
+import { boxAutoReset } from "./box-auto-reset.svelte.js";
+export class DOMTypeahead {
+    #opts;
+    #search;
+    #onMatch = $derived.by(() => {
+        if (this.#opts.onMatch)
+            return this.#opts.onMatch;
+        return (node) => node.focus();
+    });
+    #getCurrentItem = $derived.by(() => {
+        if (this.#opts.getCurrentItem)
+            return this.#opts.getCurrentItem;
+        return this.#opts.getActiveElement;
+    });
+    constructor(opts) {
+        this.#opts = opts;
+        this.#search = boxAutoReset("", {
+            afterMs: 1000,
+            getWindow: opts.getWindow,
+        });
+        this.handleTypeaheadSearch = this.handleTypeaheadSearch.bind(this);
+        this.resetTypeahead = this.resetTypeahead.bind(this);
+    }
+    handleTypeaheadSearch(key, candidates) {
+        if (!candidates.length)
+            return;
+        this.#search.current = this.#search.current + key;
+        const currentItem = this.#getCurrentItem();
+        const currentMatch = candidates.find((item) => item === currentItem)?.textContent?.trim() ?? "";
+        const values = candidates.map((item) => item.textContent?.trim() ?? "");
+        const nextMatch = getNextMatch(values, this.#search.current, currentMatch);
+        const newItem = candidates.find((item) => item.textContent?.trim() === nextMatch);
+        if (newItem)
+            this.#onMatch(newItem);
+        return newItem;
+    }
+    resetTypeahead() {
+        this.#search.current = "";
+    }
+    get search() {
+        return this.#search.current;
+    }
+}

package/dist/internal/dom.d.ts

@@ -0,0 +1,7 @@
+export declare function getFirstNonCommentChild(element: HTMLElement | null): ChildNode | null;
+/**
+ * Determines if the click event truly occurred outside the content node.
+ * This was added to handle password managers and other elements that may be injected
+ * into the DOM but visually appear inside the content.
+ */
+export declare function isClickTrulyOutside(event: PointerEvent, contentNode: HTMLElement): boolean;

package/dist/internal/dom.js

@@ -0,0 +1,20 @@
+export function getFirstNonCommentChild(element) {
+    if (!element)
+        return null;
+    for (const child of element.childNodes) {
+        if (child.nodeType !== Node.COMMENT_NODE) {
+            return child;
+        }
+    }
+    return null;
+}
+/**
+ * Determines if the click event truly occurred outside the content node.
+ * This was added to handle password managers and other elements that may be injected
+ * into the DOM but visually appear inside the content.
+ */
+export function isClickTrulyOutside(event, contentNode) {
+    const { clientX, clientY } = event;
+    const rect = contentNode.getBoundingClientRect();
+    return (clientX < rect.left || clientX > rect.right || clientY < rect.top || clientY > rect.bottom);
+}

package/dist/internal/elements.d.ts

@@ -0,0 +1,2 @@
+export declare function isOrContainsTarget(node: HTMLElement, target: Element): boolean;
+export declare function getOwnerDocument(el: Element | null | undefined): Document;

package/dist/internal/elements.js

@@ -0,0 +1,6 @@
+export function isOrContainsTarget(node, target) {
+    return node === target || node.contains(target);
+}
+export function getOwnerDocument(el) {
+    return el?.ownerDocument ?? document;
+}

package/dist/internal/events.d.ts

@@ -0,0 +1,15 @@
+export type EventCallback<E extends Event = Event> = (event: E) => void;
+/**
+ * Creates a typed event dispatcher and listener pair for custom events
+ * @template T - The type of data that will be passed in the event detail
+ * @param eventName - The name of the custom event
+ * @param options - CustomEvent options (bubbles, cancelable, etc.)
+ */
+export declare class CustomEventDispatcher<T = unknown> {
+    readonly eventName: string;
+    readonly options: Omit<CustomEventInit<T>, "detail">;
+    constructor(eventName: string, options?: Omit<CustomEventInit<T>, "detail">);
+    createEvent(detail?: T): CustomEvent<T>;
+    dispatch(element: EventTarget, detail?: T): CustomEvent<T>;
+    listen(element: EventTarget, callback: (event: CustomEvent<T>) => void, options?: AddEventListenerOptions): () => void;
+}

package/dist/internal/events.js

@@ -0,0 +1,32 @@
+import { on } from "svelte/events";
+/**
+ * Creates a typed event dispatcher and listener pair for custom events
+ * @template T - The type of data that will be passed in the event detail
+ * @param eventName - The name of the custom event
+ * @param options - CustomEvent options (bubbles, cancelable, etc.)
+ */
+export class CustomEventDispatcher {
+    eventName;
+    options;
+    constructor(eventName, options = { bubbles: true, cancelable: true }) {
+        this.eventName = eventName;
+        this.options = options;
+    }
+    createEvent(detail) {
+        return new CustomEvent(this.eventName, {
+            ...this.options,
+            detail,
+        });
+    }
+    dispatch(element, detail) {
+        const event = this.createEvent(detail);
+        element.dispatchEvent(event);
+        return event;
+    }
+    listen(element, callback, options) {
+        const handler = (event) => {
+            callback(event);
+        };
+        return on(element, this.eventName, handler, options);
+    }
+}

package/dist/internal/floating-svelte/floating-utils.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { MaybeGetter } from "svelte-toolbelt";
+export declare function get<T>(valueOrGetValue: MaybeGetter<T>): T;
+export declare function getDPR(element: Element): number;
+export declare function roundByDPR(element: Element, value: number): number;
+export declare function getFloatingContentCSSVars(name: string): {
+    [x: string]: string;
+};

package/dist/internal/floating-svelte/floating-utils.svelte.js

@@ -0,0 +1,24 @@
+export function get(valueOrGetValue) {
+    return typeof valueOrGetValue === "function"
+        ? valueOrGetValue()
+        : valueOrGetValue;
+}
+export function getDPR(element) {
+    if (typeof window === "undefined")
+        return 1;
+    const win = element.ownerDocument.defaultView || window;
+    return win.devicePixelRatio || 1;
+}
+export function roundByDPR(element, value) {
+    const dpr = getDPR(element);
+    return Math.round(value * dpr) / dpr;
+}
+export function getFloatingContentCSSVars(name) {
+    return {
+        [`--bits-${name}-content-transform-origin`]: `var(--bits-floating-transform-origin)`,
+        [`--bits-${name}-content-available-width`]: `var(--bits-floating-available-width)`,
+        [`--bits-${name}-content-available-height`]: `var(--bits-floating-available-height)`,
+        [`--bits-${name}-anchor-width`]: `var(--bits-floating-anchor-width)`,
+        [`--bits-${name}-anchor-height`]: `var(--bits-floating-anchor-height)`,
+    };
+}