@class-kit/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,4688 @@
+'use strict';
+
+function isEmpty(value) {
+    return (value == null ||
+        value === "" ||
+        (Array.isArray(value) && value.length === 0));
+}
+async function runCustomValidator(validate, context) {
+    return validate(context);
+}
+async function validateValue(context, rules) {
+    const errors = [];
+    for (const rule of rules) {
+        if (rule.required && isEmpty(context.value)) {
+            errors.push(rule.message ?? "This field is required.");
+            continue;
+        }
+        if (rule.pattern && !isEmpty(context.value) && !rule.pattern.test(String(context.value))) {
+            errors.push(rule.message ?? "The value does not match the required format.");
+            continue;
+        }
+        if (rule.minLength != null &&
+            !isEmpty(context.value) &&
+            String(context.value).length < rule.minLength) {
+            errors.push(rule.message ?? `Please enter at least ${rule.minLength} characters.`);
+            continue;
+        }
+        if (rule.maxLength != null &&
+            !isEmpty(context.value) &&
+            String(context.value).length > rule.maxLength) {
+            errors.push(rule.message ?? `Please enter no more than ${rule.maxLength} characters.`);
+            continue;
+        }
+        if (rule.validate) {
+            const customError = await runCustomValidator(rule.validate, context);
+            if (customError)
+                errors.push(customError);
+        }
+    }
+    return errors;
+}
+
+class FieldController {
+    constructor(name, options = {}) {
+        this.name = name;
+        this.rules = options.rules ?? [];
+        this.validateOn = options.validateOn ?? ["change", "blur", "submit"];
+        this.state = {
+            name,
+            value: options.initialValue,
+            initialValue: options.initialValue,
+            errors: [],
+            meta: {
+                dirty: false,
+                touched: false,
+                validating: false,
+                submitted: false
+            }
+        };
+    }
+    getState() {
+        return {
+            ...this.state,
+            errors: [...this.state.errors],
+            meta: { ...this.state.meta }
+        };
+    }
+    setValue(value) {
+        this.state = {
+            ...this.state,
+            value,
+            meta: {
+                ...this.state.meta,
+                dirty: !Object.is(value, this.state.initialValue)
+            }
+        };
+    }
+    markTouched() {
+        this.state = {
+            ...this.state,
+            meta: { ...this.state.meta, touched: true }
+        };
+    }
+    markSubmitted() {
+        this.state = {
+            ...this.state,
+            meta: { ...this.state.meta, submitted: true }
+        };
+    }
+    reset(value = this.state.initialValue) {
+        this.state = {
+            name: this.name,
+            value,
+            initialValue: value,
+            errors: [],
+            meta: {
+                dirty: false,
+                touched: false,
+                validating: false,
+                submitted: false
+            }
+        };
+    }
+    shouldValidate(trigger) {
+        return this.validateOn.includes(trigger);
+    }
+    async validate(values) {
+        this.state = {
+            ...this.state,
+            meta: { ...this.state.meta, validating: true }
+        };
+        const errors = await validateValue({ field: this.name, value: this.state.value, values }, this.rules);
+        this.state = {
+            ...this.state,
+            errors,
+            meta: { ...this.state.meta, validating: false }
+        };
+        return errors;
+    }
+}
+
+class StateEmitter {
+    constructor() {
+        this.listeners = new Set();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit(state) {
+        this.listeners.forEach((listener) => listener(state));
+    }
+    clear() {
+        this.listeners.clear();
+    }
+}
+
+const pathPattern = /[^.[\]]+/g;
+function toPath(path) {
+    return path.match(pathPattern) ?? [];
+}
+function getByPath(source, path) {
+    return toPath(path).reduce((current, key) => {
+        if (current == null || typeof current !== "object")
+            return undefined;
+        return current[key];
+    }, source);
+}
+function setByPath(source, path, value) {
+    const keys = toPath(path);
+    if (keys.length === 0)
+        return source;
+    const next = { ...source };
+    let cursor = next;
+    keys.forEach((key, index) => {
+        if (index === keys.length - 1) {
+            cursor[key] = value;
+            return;
+        }
+        const existing = cursor[key];
+        const child = existing != null && typeof existing === "object"
+            ? { ...existing }
+            : {};
+        cursor[key] = child;
+        cursor = child;
+    });
+    return next;
+}
+function cloneValues(values) {
+    if (typeof structuredClone === "function") {
+        try {
+            return structuredClone(values);
+        }
+        catch {
+            return cloneFallback(values);
+        }
+    }
+    return cloneFallback(values);
+}
+function cloneFallback(value, seen = new WeakMap()) {
+    if (value == null || typeof value !== "object")
+        return value;
+    if (value instanceof Date)
+        return new Date(value.getTime());
+    if (value instanceof RegExp)
+        return new RegExp(value.source, value.flags);
+    if (typeof File !== "undefined" && value instanceof File)
+        return value;
+    if (typeof Blob !== "undefined" && value instanceof Blob)
+        return value;
+    const objectValue = value;
+    if (seen.has(objectValue))
+        return seen.get(objectValue);
+    if (Array.isArray(value)) {
+        const next = [];
+        seen.set(objectValue, next);
+        value.forEach((item) => next.push(cloneFallback(item, seen)));
+        return next;
+    }
+    if (value instanceof Map) {
+        const next = new Map();
+        seen.set(objectValue, next);
+        value.forEach((mapValue, mapKey) => next.set(cloneFallback(mapKey, seen), cloneFallback(mapValue, seen)));
+        return next;
+    }
+    if (value instanceof Set) {
+        const next = new Set();
+        seen.set(objectValue, next);
+        value.forEach((item) => next.add(cloneFallback(item, seen)));
+        return next;
+    }
+    const next = {};
+    seen.set(objectValue, next);
+    Object.entries(value).forEach(([key, item]) => {
+        next[key] = cloneFallback(item, seen);
+    });
+    return next;
+}
+
+class FormController {
+    constructor(options = {}) {
+        this.emitter = new StateEmitter();
+        this.fields = new Map();
+        this.submitting = false;
+        this.submitted = false;
+        this.submitCount = 0;
+        this.initialValues = cloneValues(options.initialValues ?? {});
+        this.values = cloneValues(options.initialValues ?? {});
+        this.validateOn = options.validateOn ?? ["submit"];
+        this.onSubmit = options.onSubmit;
+        this.state = this.createState();
+    }
+    registerField(name, options = {}) {
+        const initialValue = options.initialValue !== undefined
+            ? options.initialValue
+            : getByPath(this.values, name);
+        const field = new FieldController(name, {
+            ...options,
+            initialValue,
+            validateOn: options.validateOn ?? this.validateOn,
+        });
+        this.fields.set(name, field);
+        if (initialValue !== undefined) {
+            this.values = setByPath(this.values, name, initialValue);
+        }
+        this.notify();
+        return () => {
+            this.fields.delete(name);
+            this.notify();
+        };
+    }
+    subscribe(listener) {
+        return this.emitter.subscribe(listener);
+    }
+    getState() {
+        return this.state;
+    }
+    getValue(name) {
+        return getByPath(this.values, name);
+    }
+    createState() {
+        const fieldStates = Object.fromEntries(Array.from(this.fields.entries()).map(([name, field]) => [
+            name,
+            field.getState(),
+        ]));
+        const errors = {};
+        Object.entries(fieldStates).forEach(([name, field]) => {
+            if (field.errors.length > 0)
+                errors[name] = field.errors;
+        });
+        const states = Object.values(fieldStates);
+        return {
+            values: cloneValues(this.values),
+            errors,
+            fields: fieldStates,
+            dirty: states.some((field) => field.meta.dirty),
+            touched: states.some((field) => field.meta.touched),
+            validating: states.some((field) => field.meta.validating),
+            submitting: this.submitting,
+            submitted: this.submitted,
+            valid: Object.keys(errors).length === 0,
+            submitCount: this.submitCount,
+        };
+    }
+    async setValue(name, value, trigger = "change") {
+        this.values = setByPath(this.values, name, value);
+        const field = this.fields.get(name);
+        field?.setValue(value);
+        if (field?.shouldValidate(trigger)) {
+            await field.validate(this.values);
+        }
+        this.notify();
+    }
+    async blur(name) {
+        const field = this.fields.get(name);
+        field?.markTouched();
+        if (field?.shouldValidate("blur")) {
+            await field.validate(this.values);
+        }
+        this.notify();
+    }
+    async validate() {
+        const tasks = Array.from(this.fields.values()).map((field) => field.validate(this.values));
+        this.notify();
+        await Promise.all(tasks);
+        this.notify();
+        return this.getState().valid;
+    }
+    async submit() {
+        this.submitting = true;
+        this.submitted = true;
+        this.submitCount += 1;
+        this.fields.forEach((field) => field.markSubmitted());
+        this.notify();
+        const valid = await this.validate();
+        const state = this.getState();
+        try {
+            if (valid && this.onSubmit) {
+                await this.onSubmit(state.values, state);
+            }
+        }
+        finally {
+            this.submitting = false;
+            this.notify();
+        }
+        return this.getState();
+    }
+    reset(values = this.initialValues) {
+        this.values = cloneValues(values);
+        this.submitting = false;
+        this.submitted = false;
+        this.submitCount = 0;
+        this.fields.forEach((field, name) => {
+            const nextValue = getByPath(this.values, name);
+            field.reset(nextValue);
+        });
+        this.notify();
+    }
+    destroy() {
+        this.fields.clear();
+        this.emitter.clear();
+    }
+    notify() {
+        this.state = this.createState();
+        this.emitter.emit(this.state);
+    }
+}
+
+const builtInThemeNames = [
+    "minimal",
+    "violet",
+    "emerald",
+    "sky",
+    "rose",
+    "amber",
+    "liquid-glass",
+];
+const defaultLocale = {
+    backtopLabel: "回到顶部",
+    calendarNextMonth: "下个月",
+    calendarPreviousMonth: "上个月",
+    emptyText: "暂无数据",
+    loadingText: "加载中...",
+    countdownDayUnit: "天",
+    countdownHourUnit: "时",
+    countdownMinuteUnit: "分",
+    countdownSecondUnit: "秒",
+    colorPickerAlphaLabel: "透明度",
+    comicReaderLoadMoreText: "继续下滑加载",
+    comicReaderLoadingText: "加载中...",
+    comicReaderNoMoreText: "已到底部",
+    comicReaderNextLabel: "下一页",
+    comicReaderPreviousLabel: "上一页",
+    datePickerNextMonth: "下个月",
+    datePickerPlaceholder: "请选择日期",
+    datePickerPreviousMonth: "上个月",
+    datePickerWeekLabels: ["日", "一", "二", "三", "四", "五", "六"],
+    dateDayUnit: "日",
+    dateMonthUnit: "月",
+    dateYearUnit: "年",
+    dateRangeClear: "清空",
+    dateRangeEndPlaceholder: "结束日期",
+    dateRangePlaceholder: "请选择日期范围",
+    dateRangeSeparator: "至",
+    dateRangeStartPlaceholder: "开始日期",
+    inputClearLabel: "清空内容",
+    passwordClearLabel: "清空密码",
+    passwordHiddenAlt: "显示密码",
+    passwordHiddenIcon: "显示",
+    passwordToggleHiddenLabel: "显示密码",
+    passwordToggleVisibleLabel: "隐藏密码",
+    passwordVisibleAlt: "隐藏密码",
+    passwordVisibleIcon: "隐藏",
+    popconfirmCancelText: "取消",
+    popconfirmConfirmText: "确认",
+    popconfirmContent: "确认执行该操作？",
+    selectClearLabel: "清空选择",
+    selectEmptyText: "暂无匹配选项",
+    selectPlaceholder: "Select",
+    selectSearchPlaceholder: "搜索选项",
+    selectSelectedIcon: "",
+    signatureClearText: "一键清除",
+    signatureUndoText: "回退",
+    tableColumnSettingsLabel: "列设置",
+    tableEmptyText: "暂无表格数据",
+    tableLoadingText: "表格加载中...",
+    tableSelectAllLabel: "选择全部",
+    tableSelectRowLabel: "选择",
+    tabsEmptyText: "暂无内容",
+    tabsLoadingText: "内容加载中...",
+    uploadButtonText: "选择文件",
+    uploadDragText: "拖拽文件到这里",
+    verificationInputLabel: "验证码",
+    virtualListPullUpLoadingText: "正在加载更多...",
+    virtualListPullUpReadyText: "继续上拉加载",
+    novelReaderEmptyText: "暂无章节内容",
+    novelReaderNextLabel: "下一页",
+    novelReaderPreviousLabel: "上一页",
+    novelReaderTitle: "小说阅读",
+    liveRoomFavoriteLabel: "收藏",
+    liveRoomGiftLabel: "福袋",
+    liveRoomInputPlaceholder: "说点什么...",
+    liveRoomLikeLabel: "点赞",
+    liveRoomMoreLabel: "更多",
+    liveRoomSelfName: "我",
+    liveRoomSendLabel: "发送",
+    liveRoomShareLabel: "分享",
+};
+function cloneLocale(locale) {
+    return {
+        ...locale,
+        datePickerWeekLabels: [...locale.datePickerWeekLabels],
+    };
+}
+let globalConfig = {
+    locale: cloneLocale(defaultLocale),
+    theme: { name: "minimal" },
+};
+function resolveTheme(theme) {
+    const name = typeof theme === "string" ? theme : theme?.name;
+    return {
+        name: builtInThemeNames.includes(name)
+            ? name
+            : "minimal",
+    };
+}
+function configureClassComponents(config = {}) {
+    const nextLocale = {
+        ...globalConfig.locale,
+        ...config.locale,
+    };
+    globalConfig = {
+        locale: cloneLocale(nextLocale),
+        theme: config.theme
+            ? resolveTheme(config.theme)
+            : { ...globalConfig.theme },
+    };
+    return getClassComponentsConfig();
+}
+function getClassComponentsConfig() {
+    return {
+        locale: cloneLocale(globalConfig.locale),
+        theme: { ...globalConfig.theme },
+    };
+}
+function getClassComponentsLocale() {
+    return getClassComponentsConfig().locale;
+}
+function resetClassComponentsConfig() {
+    globalConfig = {
+        locale: cloneLocale(defaultLocale),
+        theme: { name: "minimal" },
+    };
+    return getClassComponentsConfig();
+}
+
+class MultiColumnPickerController {
+    constructor(options) {
+        this.dateSource = options.source;
+        this.sourceColumns = options.columns ?? this.createDateColumns(options.source, options.values);
+        this.cascade = options.cascade ?? false;
+        this.values = options.values ?? [];
+    }
+    updateOptions(options) {
+        if (options.columns) {
+            this.dateSource = undefined;
+            this.sourceColumns = options.columns;
+        }
+        if (options.source) {
+            this.dateSource = options.source;
+            this.sourceColumns = this.createDateColumns(options.source, options.values ?? this.values);
+        }
+        if (options.cascade !== undefined)
+            this.cascade = options.cascade;
+        if (options.values)
+            this.values = options.values;
+        return this.getState();
+    }
+    select(columnIndex, value) {
+        this.values = [...this.values.slice(0, columnIndex), value];
+        return this.getState();
+    }
+    selectByDelta(columnIndex, delta) {
+        const state = this.getState();
+        const column = state.columns[columnIndex] ?? [];
+        if (column.length === 0)
+            return state;
+        const currentIndex = Math.max(0, column.findIndex((item) => item.value === state.values[columnIndex]));
+        const nextStep = Math.trunc(delta);
+        const direction = nextStep >= 0 ? 1 : -1;
+        let nextIndex = Math.min(column.length - 1, Math.max(0, currentIndex + nextStep));
+        while (column[nextIndex]?.disabled && nextIndex > 0 && nextIndex < column.length - 1) {
+            nextIndex += direction;
+        }
+        const next = column[nextIndex];
+        return next && !next.disabled ? this.select(columnIndex, next.value) : state;
+    }
+    getState() {
+        if (this.dateSource)
+            this.sourceColumns = this.createDateColumns(this.dateSource, this.values);
+        const columns = [];
+        const selectedOptions = [];
+        if (!this.cascade) {
+            this.sourceColumns.forEach((column, index) => {
+                columns[index] = column;
+                const selected = column.find((item) => item.value === this.values[index]) ?? column.find((item) => !item.disabled) ?? column[0];
+                if (selected) {
+                    selectedOptions[index] = selected;
+                    this.values[index] = selected.value;
+                }
+            });
+            return { columns, selectedOptions, values: selectedOptions.map((item) => item.value) };
+        }
+        let currentColumn = this.sourceColumns[0] ?? [];
+        let index = 0;
+        while (currentColumn.length > 0) {
+            columns[index] = currentColumn;
+            const selected = currentColumn.find((item) => item.value === this.values[index]) ?? currentColumn.find((item) => !item.disabled) ?? currentColumn[0];
+            if (!selected)
+                break;
+            selectedOptions[index] = selected;
+            this.values[index] = selected.value;
+            currentColumn = selected.children ?? [];
+            index += 1;
+        }
+        return { columns, selectedOptions, values: selectedOptions.map((item) => item.value) };
+    }
+    createDateColumns(source, values = []) {
+        if (!source)
+            return [];
+        const currentYear = new Date().getFullYear();
+        const startYear = source.startYear ?? (source.endYear ? source.endYear - (source.yearCount ?? 100) + 1 : currentYear - 50);
+        const endYear = source.endYear ?? startYear + (source.yearCount ?? 100) - 1;
+        const selectedYear = Number(values[0] ?? startYear);
+        const selectedMonth = Number(values[1] ?? 1);
+        const days = new Date(selectedYear, selectedMonth, 0).getDate();
+        const locale = getClassComponentsLocale();
+        const years = this.range(startYear, endYear).map((year) => ({ label: `${year}${locale.dateYearUnit}`, value: year }));
+        const months = this.range(1, 12).map((month) => ({ label: `${month}${locale.dateMonthUnit}`, value: month }));
+        const dayItems = this.range(1, days).map((day) => ({ label: `${day}${locale.dateDayUnit}`, value: day }));
+        return [years, months, dayItems];
+    }
+    range(start, end) {
+        const result = [];
+        for (let value = start; value <= end; value += 1)
+            result.push(value);
+        return result;
+    }
+}
+
+class VirtualSelectController {
+    constructor(options) {
+        this.multiple = Boolean(options.multiple);
+        this.options = options.options;
+        this.query = normalizeQuery(options.query);
+        this.selectedValues = normalizeSelectedValues(options.value, this.multiple);
+    }
+    update(options) {
+        if (options.multiple !== undefined)
+            this.multiple = Boolean(options.multiple);
+        if (options.options !== undefined)
+            this.options = options.options;
+        if (options.query !== undefined)
+            this.query = normalizeQuery(options.query);
+        if (Object.prototype.hasOwnProperty.call(options, "value")) {
+            this.selectedValues = normalizeSelectedValues(options.value, this.multiple);
+        }
+        return this.getState();
+    }
+    clear() {
+        this.selectedValues = [];
+        return this.getValue();
+    }
+    getState() {
+        const availableValues = new Set(this.options.map((option) => option.value));
+        const selectedValues = this.selectedValues.filter((value) => availableValues.has(value));
+        if (selectedValues.length !== this.selectedValues.length)
+            this.selectedValues = selectedValues;
+        return {
+            filteredOptions: this.getFilteredOptions(),
+            multiple: this.multiple,
+            query: this.query,
+            selectedOptions: this.options.filter((option) => selectedValues.includes(option.value)),
+            selectedValues
+        };
+    }
+    getValue() {
+        if (this.multiple)
+            return [...this.selectedValues];
+        return this.selectedValues[0] ?? "";
+    }
+    isSelected(value) {
+        return this.selectedValues.includes(value);
+    }
+    toggle(option) {
+        if (option.disabled)
+            return this.getValue();
+        if (!this.multiple) {
+            this.selectedValues = [option.value];
+            return option.value;
+        }
+        this.selectedValues = this.isSelected(option.value)
+            ? this.selectedValues.filter((value) => value !== option.value)
+            : [...this.selectedValues, option.value];
+        return this.getValue();
+    }
+    getFilteredOptions() {
+        if (!this.query)
+            return this.options;
+        return this.options.filter((option) => option.label.toLocaleLowerCase().includes(this.query));
+    }
+}
+function normalizeQuery(query) {
+    return String(query ?? "").trim().toLocaleLowerCase();
+}
+function normalizeSelectedValues(value, multiple) {
+    if (Array.isArray(value))
+        return multiple ? [...value] : value.slice(0, 1);
+    if (value === "" || value === undefined)
+        return [];
+    return [value];
+}
+
+function clampChannel(value) {
+    return Math.max(0, Math.min(255, Math.round(Number.isFinite(value) ? value : 0)));
+}
+function clampAlpha(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 1));
+}
+function toHex(value) {
+    return clampChannel(value).toString(16).padStart(2, "0");
+}
+function parseHex(value) {
+    const raw = value.trim();
+    const short = raw.match(/^#([0-9a-f]{3})([0-9a-f])?$/i);
+    if (short) {
+        const rgb = short[1] ?? "000";
+        const alpha = short[2] ?? "f";
+        const red = parseInt(rgb.charAt(0) + rgb.charAt(0), 16);
+        const green = parseInt(rgb.charAt(1) + rgb.charAt(1), 16);
+        const blue = parseInt(rgb.charAt(2) + rgb.charAt(2), 16);
+        return { alpha: parseInt(alpha + alpha, 16) / 255, blue, green, hex: `#${toHex(red)}${toHex(green)}${toHex(blue)}`, red };
+    }
+    const full = raw.match(/^#([0-9a-f]{6})([0-9a-f]{2})?$/i);
+    if (!full)
+        return undefined;
+    const rgb = full[1] ?? "000000";
+    return {
+        alpha: full[2] ? parseInt(full[2], 16) / 255 : 1,
+        blue: parseInt(rgb.slice(4, 6), 16),
+        green: parseInt(rgb.slice(2, 4), 16),
+        hex: `#${rgb.toLowerCase()}`,
+        red: parseInt(rgb.slice(0, 2), 16)
+    };
+}
+function parseRgb(value) {
+    const match = value.trim().match(/^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})(?:\s*,\s*([\d.]+))?\s*\)$/i);
+    if (!match)
+        return undefined;
+    const red = clampChannel(Number(match[1]));
+    const green = clampChannel(Number(match[2]));
+    const blue = clampChannel(Number(match[3]));
+    return { alpha: clampAlpha(Number(match[4] ?? 1)), blue, green, hex: `#${toHex(red)}${toHex(green)}${toHex(blue)}`, red };
+}
+function formatRgba(red, green, blue, alpha) {
+    return `rgba(${clampChannel(red)}, ${clampChannel(green)}, ${clampChannel(blue)}, ${Number(clampAlpha(alpha).toFixed(2))})`;
+}
+function getContrastColor(red, green, blue, alpha) {
+    const opacity = clampAlpha(alpha);
+    const blendedRed = clampChannel(red) * opacity + 255 * (1 - opacity);
+    const blendedGreen = clampChannel(green) * opacity + 255 * (1 - opacity);
+    const blendedBlue = clampChannel(blue) * opacity + 255 * (1 - opacity);
+    const luminance = (0.299 * blendedRed + 0.587 * blendedGreen + 0.114 * blendedBlue) / 255;
+    return luminance > 0.58 ? "#000000" : "#ffffff";
+}
+function rgbToHsv(red, green, blue) {
+    const r = clampChannel(red) / 255;
+    const g = clampChannel(green) / 255;
+    const b = clampChannel(blue) / 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const delta = max - min;
+    let hue = 0;
+    if (delta !== 0) {
+        if (max === r)
+            hue = ((g - b) / delta) % 6;
+        else if (max === g)
+            hue = (b - r) / delta + 2;
+        else
+            hue = (r - g) / delta + 4;
+        hue *= 60;
+        if (hue < 0)
+            hue += 360;
+    }
+    return {
+        brightness: max,
+        hue,
+        saturation: max === 0 ? 0 : delta / max
+    };
+}
+function hsvToRgb(hue, saturation, brightness) {
+    const h = ((Number.isFinite(hue) ? hue : 0) % 360 + 360) % 360;
+    const s = Math.max(0, Math.min(1, Number.isFinite(saturation) ? saturation : 0));
+    const v = Math.max(0, Math.min(1, Number.isFinite(brightness) ? brightness : 0));
+    const c = v * s;
+    const x = c * (1 - Math.abs((h / 60) % 2 - 1));
+    const m = v - c;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    if (h < 60)
+        [r, g, b] = [c, x, 0];
+    else if (h < 120)
+        [r, g, b] = [x, c, 0];
+    else if (h < 180)
+        [r, g, b] = [0, c, x];
+    else if (h < 240)
+        [r, g, b] = [0, x, c];
+    else if (h < 300)
+        [r, g, b] = [x, 0, c];
+    else
+        [r, g, b] = [c, 0, x];
+    return {
+        blue: clampChannel((b + m) * 255),
+        green: clampChannel((g + m) * 255),
+        red: clampChannel((r + m) * 255)
+    };
+}
+class ColorPickerController {
+    constructor(value = "#7c3aed") {
+        this.state = this.parse(value);
+    }
+    parse(value) {
+        const parsed = parseRgb(value) ?? parseHex(value) ?? parseHex("#7c3aed");
+        const hsv = rgbToHsv(parsed.red, parsed.green, parsed.blue);
+        const rgba = formatRgba(parsed.red, parsed.green, parsed.blue, parsed.alpha);
+        return { ...parsed, ...hsv, contrastColor: getContrastColor(parsed.red, parsed.green, parsed.blue, parsed.alpha), rgba, value: rgba };
+    }
+    update(value) {
+        this.state = this.parse(value);
+        return this.getState();
+    }
+    setHex(hex) {
+        const parsed = parseHex(hex) ?? this.state;
+        this.state = this.parse(formatRgba(parsed.red, parsed.green, parsed.blue, this.state.alpha));
+        return this.getState();
+    }
+    setAlpha(alpha) {
+        this.state = this.parse(formatRgba(this.state.red, this.state.green, this.state.blue, alpha));
+        return this.getState();
+    }
+    setHue(hue) {
+        const rgb = hsvToRgb(hue, this.state.saturation, this.state.brightness);
+        this.state = this.parse(formatRgba(rgb.red, rgb.green, rgb.blue, this.state.alpha));
+        return this.getState();
+    }
+    setSaturationBrightness(saturation, brightness) {
+        const rgb = hsvToRgb(this.state.hue, saturation, brightness);
+        this.state = this.parse(formatRgba(rgb.red, rgb.green, rgb.blue, this.state.alpha));
+        return this.getState();
+    }
+    getState() {
+        return { ...this.state };
+    }
+}
+
+function pad$2(value) {
+    return String(value).padStart(2, "0");
+}
+function toDateKey$1(date) {
+    return `${date.getFullYear()}-${pad$2(date.getMonth() + 1)}-${pad$2(date.getDate())}`;
+}
+function parseDate$1(value) {
+    if (!value || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return undefined;
+    const [yearText, monthText, dayText] = value.split("-");
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day))
+        return undefined;
+    const date = new Date(year, month - 1, day);
+    return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day ? date : undefined;
+}
+function compareKey$1(a, b) {
+    return a.localeCompare(b);
+}
+const lunarFormatter = (() => {
+    try {
+        return new Intl.DateTimeFormat("zh-CN-u-ca-chinese", { day: "numeric", month: "long" });
+    }
+    catch {
+        return undefined;
+    }
+})();
+function formatLunar(date) {
+    if (!lunarFormatter)
+        return undefined;
+    try {
+        return lunarFormatter.format(date).replace(/\s/g, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+class DatePickerController {
+    constructor(options = {}) {
+        this.limitDate = parseDate$1(options.limitDate) ? options.limitDate : undefined;
+        this.limitDirection = options.limitDirection === "after" || options.limitDirection === "before" ? options.limitDirection : undefined;
+        this.min = parseDate$1(options.min) ? options.min : undefined;
+        this.max = parseDate$1(options.max) ? options.max : undefined;
+        const base = parseDate$1(options.value) ?? new Date();
+        this.state = this.createState(base.getFullYear(), base.getMonth() + 1, options.value ?? "");
+    }
+    updateOptions(options = {}) {
+        this.limitDate = parseDate$1(options.limitDate) ? options.limitDate : undefined;
+        this.limitDirection = options.limitDirection === "after" || options.limitDirection === "before" ? options.limitDirection : undefined;
+        this.min = parseDate$1(options.min) ? options.min : undefined;
+        this.max = parseDate$1(options.max) ? options.max : undefined;
+        const base = parseDate$1(options.value) ?? new Date(this.state.year, this.state.month - 1, 1);
+        this.state = this.createState(base.getFullYear(), base.getMonth() + 1, options.value ?? "");
+        return this.getState();
+    }
+    moveMonth(delta) {
+        const date = new Date(this.state.year, this.state.month - 1 + delta, 1);
+        this.state = this.createState(date.getFullYear(), date.getMonth() + 1, this.state.value);
+        return this.getState();
+    }
+    select(value) {
+        if (!parseDate$1(value) || this.isDisabled(value))
+            return this.getState();
+        const date = parseDate$1(value);
+        this.state = this.createState(date.getFullYear(), date.getMonth() + 1, value);
+        return this.getState();
+    }
+    createYearOptions(start, end) {
+        const current = new Date().getFullYear();
+        const minYear = start ?? current - 50;
+        const maxYear = end ?? current + 50;
+        return Array.from({ length: Math.max(1, maxYear - minYear + 1) }, (_, index) => minYear + index);
+    }
+    getDaysInMonth(year, month) {
+        return new Date(year, month, 0).getDate();
+    }
+    getState() {
+        return { ...this.state, days: this.state.days.map((day) => ({ ...day })) };
+    }
+    isDisabled(value) {
+        return Boolean((this.min && compareKey$1(value, this.min) < 0) ||
+            (this.max && compareKey$1(value, this.max) > 0) ||
+            (this.limitDate && this.limitDirection === "before" && compareKey$1(value, this.limitDate) < 0) ||
+            (this.limitDate && this.limitDirection === "after" && compareKey$1(value, this.limitDate) > 0));
+    }
+    createState(year, month, value) {
+        const first = new Date(year, month - 1, 1);
+        const start = new Date(year, month - 1, 1 - first.getDay());
+        const today = toDateKey$1(new Date());
+        const days = Array.from({ length: 42 }, (_, index) => {
+            const date = new Date(start.getFullYear(), start.getMonth(), start.getDate() + index);
+            const key = toDateKey$1(date);
+            return {
+                date: key,
+                day: date.getDate(),
+                disabled: this.isDisabled(key),
+                inMonth: date.getMonth() === month - 1,
+                lunar: formatLunar(date),
+                selected: key === value,
+                today: key === today
+            };
+        });
+        return { days, month, value, year };
+    }
+}
+
+function pad$1(value) {
+    return String(value).padStart(2, "0");
+}
+function toDateKey(date) {
+    return `${date.getFullYear()}-${pad$1(date.getMonth() + 1)}-${pad$1(date.getDate())}`;
+}
+function parseDate(value) {
+    if (!value || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return undefined;
+    const [yearText, monthText, dayText] = value.split("-");
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day))
+        return undefined;
+    const date = new Date(year, month - 1, day);
+    return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day ? date : undefined;
+}
+function compareKey(a, b) {
+    if (!a || !b)
+        return 0;
+    return a.localeCompare(b);
+}
+function normalizeRange(value, allowSameDay = true) {
+    const start = parseDate(value?.start) ? value?.start : undefined;
+    const end = parseDate(value?.end) ? value?.end : undefined;
+    if (!allowSameDay && start && end && compareKey(start, end) === 0)
+        return { start, end: undefined };
+    if (start && end && compareKey(start, end) > 0)
+        return { start: end, end: start };
+    return { start, end };
+}
+function addMonths(date, delta) {
+    return new Date(date.getFullYear(), date.getMonth() + delta, 1);
+}
+class DateRangePickerController {
+    constructor(options = {}) {
+        this.allowSameDay = options.allowSameDay ?? true;
+        this.limitDate = parseDate(options.limitDate) ? options.limitDate : undefined;
+        this.limitDirection = options.limitDirection === "after" || options.limitDirection === "before" ? options.limitDirection : undefined;
+        this.min = parseDate(options.min) ? options.min : undefined;
+        this.max = parseDate(options.max) ? options.max : undefined;
+        const value = normalizeRange(options.value, this.allowSameDay);
+        const base = parseDate(value.start) ?? parseDate(value.end) ?? new Date();
+        this.state = this.createState(base.getFullYear(), base.getMonth() + 1, value);
+    }
+    updateOptions(options = {}) {
+        this.allowSameDay = options.allowSameDay ?? this.allowSameDay;
+        this.limitDate = parseDate(options.limitDate) ? options.limitDate : undefined;
+        this.limitDirection = options.limitDirection === "after" || options.limitDirection === "before" ? options.limitDirection : undefined;
+        this.min = parseDate(options.min) ? options.min : undefined;
+        this.max = parseDate(options.max) ? options.max : undefined;
+        const value = normalizeRange(options.value, this.allowSameDay);
+        const base = parseDate(value.start) ?? parseDate(value.end) ?? new Date(this.state.leftYear, this.state.leftMonth - 1, 1);
+        this.state = this.createState(base.getFullYear(), base.getMonth() + 1, value);
+        return this.getState();
+    }
+    moveMonth(delta) {
+        const base = new Date(this.state.leftYear, this.state.leftMonth - 1 + delta, 1);
+        this.state = this.createState(base.getFullYear(), base.getMonth() + 1, { start: this.state.start, end: this.state.end });
+        return this.getState();
+    }
+    hoverDate(value) {
+        this.hover = value && parseDate(value) && !this.isDisabled(value) ? value : undefined;
+        this.state = this.createState(this.state.leftYear, this.state.leftMonth, { start: this.state.start, end: this.state.end });
+        return this.getState();
+    }
+    select(value) {
+        if (!parseDate(value) || this.isDisabled(value))
+            return this.getState();
+        const current = { start: this.state.start, end: this.state.end };
+        let next;
+        if (!current.start || current.end || compareKey(value, current.start) < 0) {
+            next = { start: value, end: undefined };
+        }
+        else if (!this.allowSameDay && compareKey(value, current.start) === 0) {
+            next = { start: current.start, end: undefined };
+        }
+        else {
+            next = normalizeRange({ start: current.start, end: value }, this.allowSameDay);
+            this.hover = undefined;
+        }
+        const base = parseDate(next.start) ?? new Date(this.state.leftYear, this.state.leftMonth - 1, 1);
+        this.state = this.createState(base.getFullYear(), base.getMonth() + 1, next);
+        return this.getState();
+    }
+    clear() {
+        this.hover = undefined;
+        this.state = this.createState(this.state.leftYear, this.state.leftMonth, {});
+        return this.getState();
+    }
+    getValue() {
+        return { start: this.state.start, end: this.state.end };
+    }
+    getState() {
+        return {
+            ...this.state,
+            leftDays: this.state.leftDays.map((day) => ({ ...day })),
+            rightDays: this.state.rightDays.map((day) => ({ ...day }))
+        };
+    }
+    isDisabled(value) {
+        return Boolean((this.min && compareKey(value, this.min) < 0) ||
+            (this.max && compareKey(value, this.max) > 0) ||
+            (this.limitDate && this.limitDirection === "before" && compareKey(value, this.limitDate) < 0) ||
+            (this.limitDate && this.limitDirection === "after" && compareKey(value, this.limitDate) > 0));
+    }
+    createState(year, month, value) {
+        const leftBase = new Date(year, month - 1, 1);
+        const rightBase = addMonths(leftBase, 1);
+        const range = normalizeRange(value, this.allowSameDay);
+        const selecting = range.start && !range.end ? "end" : "start";
+        return {
+            end: range.end,
+            leftDays: this.createMonthDays(leftBase.getFullYear(), leftBase.getMonth() + 1, range),
+            leftMonth: leftBase.getMonth() + 1,
+            leftYear: leftBase.getFullYear(),
+            rightDays: this.createMonthDays(rightBase.getFullYear(), rightBase.getMonth() + 1, range),
+            rightMonth: rightBase.getMonth() + 1,
+            rightYear: rightBase.getFullYear(),
+            selecting,
+            start: range.start
+        };
+    }
+    createMonthDays(year, month, value) {
+        const first = new Date(year, month - 1, 1);
+        const start = new Date(year, month - 1, 1 - first.getDay());
+        const today = toDateKey(new Date());
+        const previewEnd = value.start && !value.end && this.hover ? (compareKey(this.hover, value.start) >= 0 ? this.hover : value.start) : undefined;
+        const previewStart = value.start && !value.end && this.hover ? (compareKey(this.hover, value.start) >= 0 ? value.start : this.hover) : undefined;
+        return Array.from({ length: 42 }, (_, index) => {
+            const date = new Date(start.getFullYear(), start.getMonth(), start.getDate() + index);
+            const key = toDateKey(date);
+            const selectingEndSameDay = !this.allowSameDay && Boolean(value.start && !value.end && key === value.start);
+            const selected = key === value.start || key === value.end;
+            const inRange = Boolean(value.start && value.end && compareKey(key, value.start) >= 0 && compareKey(key, value.end) <= 0);
+            const preview = Boolean(previewStart && previewEnd && compareKey(key, previewStart) >= 0 && compareKey(key, previewEnd) <= 0);
+            return {
+                date: key,
+                day: date.getDate(),
+                disabled: this.isDisabled(key) || selectingEndSameDay,
+                inMonth: date.getMonth() === month - 1,
+                inRange,
+                preview,
+                rangeEnd: key === value.end,
+                rangeStart: key === value.start,
+                selected,
+                today: key === today
+            };
+        });
+    }
+}
+
+class PasswordInputController {
+    constructor(options = {}) {
+        this.visible = options.visible ?? false;
+    }
+    setVisible(visible) {
+        this.visible = visible;
+        return this.getState();
+    }
+    toggle() {
+        this.visible = !this.visible;
+        return this.getState();
+    }
+    getState() {
+        return {
+            inputType: this.visible ? "text" : "password",
+            visible: this.visible
+        };
+    }
+}
+
+const DEFAULT_WIDTH = 320;
+const DEFAULT_HEIGHT = 260;
+const DEFAULT_PIECE_SIZE = 52;
+const DEFAULT_TOLERANCE = 6;
+function finiteNumber(value, fallback) {
+    return Number.isFinite(value) ? Number(value) : fallback;
+}
+function clamp$c(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+class SlideCaptchaController {
+    constructor(options = {}) {
+        this.offsetX = 0;
+        this.offsetY = 0;
+        this.status = "idle";
+        this.width = Math.max(160, finiteNumber(options.width, DEFAULT_WIDTH));
+        this.height = Math.max(160, finiteNumber(options.height, DEFAULT_HEIGHT));
+        this.pieceWidth = Math.max(24, finiteNumber(options.pieceWidth, DEFAULT_PIECE_SIZE));
+        this.pieceHeight = Math.max(24, finiteNumber(options.pieceHeight, DEFAULT_PIECE_SIZE));
+        this.moveAxis = options.moveAxis === "xy" ? "xy" : "x";
+        this.originY = this.normalizeOriginY(options.originY);
+        this.tolerance = Math.max(0, finiteNumber(options.tolerance, DEFAULT_TOLERANCE));
+        this.targetX = this.normalizeTargetX(options.targetX);
+        this.targetY = this.normalizeTargetY(options.targetY);
+        this.value = Boolean(options.value);
+        if (this.value) {
+            this.offsetX = this.targetX;
+            this.offsetY = this.moveAxis === "xy" ? this.targetY - this.originY : 0;
+            this.status = "success";
+        }
+    }
+    updateOptions(options = {}) {
+        if (options.width !== undefined)
+            this.width = Math.max(160, finiteNumber(options.width, DEFAULT_WIDTH));
+        if (options.height !== undefined)
+            this.height = Math.max(160, finiteNumber(options.height, DEFAULT_HEIGHT));
+        if (options.pieceWidth !== undefined)
+            this.pieceWidth = Math.max(24, finiteNumber(options.pieceWidth, DEFAULT_PIECE_SIZE));
+        if (options.pieceHeight !== undefined)
+            this.pieceHeight = Math.max(24, finiteNumber(options.pieceHeight, DEFAULT_PIECE_SIZE));
+        if (options.moveAxis !== undefined)
+            this.moveAxis = options.moveAxis === "xy" ? "xy" : "x";
+        if (options.originY !== undefined || options.height !== undefined || options.pieceHeight !== undefined) {
+            this.originY = this.normalizeOriginY(options.originY ?? this.originY);
+        }
+        if (options.tolerance !== undefined)
+            this.tolerance = Math.max(0, finiteNumber(options.tolerance, DEFAULT_TOLERANCE));
+        if (options.targetX !== undefined || options.width !== undefined || options.pieceWidth !== undefined) {
+            this.targetX = this.normalizeTargetX(options.targetX ?? this.targetX);
+        }
+        if (options.targetY !== undefined || options.originY !== undefined || options.height !== undefined || options.pieceHeight !== undefined) {
+            this.targetY = this.normalizeTargetY(options.targetY ?? this.targetY);
+        }
+        if (options.value !== undefined) {
+            this.value = Boolean(options.value);
+            this.status = this.value ? "success" : "idle";
+            this.offsetX = this.value ? this.targetX : 0;
+            this.offsetY = this.value && this.moveAxis === "xy" ? this.targetY - this.originY : 0;
+        }
+        else {
+            this.offsetX = clamp$c(this.offsetX, 0, this.getMaxOffset());
+            this.offsetY =
+                this.moveAxis === "xy"
+                    ? clamp$c(this.offsetY, this.getMinOffsetY(), this.getMaxOffsetY())
+                    : 0;
+        }
+        return this.getState();
+    }
+    start() {
+        if (this.value)
+            return this.getState();
+        this.status = "dragging";
+        return this.getState();
+    }
+    move(offsetX, offsetY = 0) {
+        if (this.value)
+            return this.getState();
+        this.offsetX = clamp$c(finiteNumber(offsetX, 0), 0, this.getMaxOffset());
+        this.offsetY =
+            this.moveAxis === "xy"
+                ? clamp$c(finiteNumber(offsetY, 0), this.getMinOffsetY(), this.getMaxOffsetY())
+                : 0;
+        this.status = "dragging";
+        return this.getState();
+    }
+    verify() {
+        const success = Math.abs(this.offsetX - this.targetX) <= this.tolerance &&
+            (this.moveAxis === "x" ||
+                Math.abs(this.originY + this.offsetY - this.targetY) <= this.tolerance);
+        this.value = success;
+        this.status = success ? "success" : "failed";
+        if (success) {
+            this.offsetX = this.targetX;
+            this.offsetY = this.moveAxis === "xy" ? this.targetY - this.originY : 0;
+        }
+        return this.getState();
+    }
+    reset() {
+        this.offsetX = 0;
+        this.offsetY = 0;
+        this.status = "idle";
+        this.value = false;
+        return this.getState();
+    }
+    getState() {
+        const maxOffset = this.getMaxOffset();
+        const minOffsetY = this.getMinOffsetY();
+        const maxOffsetY = this.getMaxOffsetY();
+        return {
+            height: this.height,
+            maxOffset,
+            maxOffsetY,
+            minOffsetY,
+            moveAxis: this.moveAxis,
+            offsetX: this.offsetX,
+            offsetY: this.offsetY,
+            originY: this.originY,
+            pieceHeight: this.pieceHeight,
+            pieceWidth: this.pieceWidth,
+            progress: maxOffset > 0 ? this.offsetX / maxOffset : 0,
+            status: this.status,
+            targetX: this.targetX,
+            targetY: this.targetY,
+            tolerance: this.tolerance,
+            value: this.value,
+            width: this.width
+        };
+    }
+    getMaxOffset() {
+        return Math.max(0, this.width - this.pieceWidth);
+    }
+    getMinOffsetY() {
+        return -this.originY;
+    }
+    getMaxOffsetY() {
+        return Math.max(this.getMinOffsetY(), this.height - this.pieceHeight - this.originY);
+    }
+    normalizeOriginY(value) {
+        return clamp$c(finiteNumber(value, 0), 0, Math.max(0, this.height - this.pieceHeight));
+    }
+    normalizeTargetX(value) {
+        return clamp$c(finiteNumber(value, this.width * 0.62), 0, this.getMaxOffset());
+    }
+    normalizeTargetY(value) {
+        return clamp$c(finiteNumber(value, this.originY), 0, Math.max(0, this.height - this.pieceHeight));
+    }
+}
+
+function normalizeLength(length) {
+    return Math.min(12, Math.max(1, Math.floor(length ?? 6)));
+}
+function normalizeValue$1(value, length) {
+    return value.replace(/\s+/g, "").slice(0, length);
+}
+class VerificationCodeController {
+    constructor(options = {}) {
+        this.length = normalizeLength(options.length);
+        this.value = normalizeValue$1(options.value ?? "", this.length);
+    }
+    updateOptions(options = {}) {
+        if (options.length !== undefined)
+            this.length = normalizeLength(options.length);
+        if (options.value !== undefined)
+            this.value = normalizeValue$1(options.value, this.length);
+        else
+            this.value = normalizeValue$1(this.value, this.length);
+        return this.getState();
+    }
+    getNextInputIndex(preferredIndex = 0) {
+        const chars = this.getState().chars;
+        const firstEmpty = chars.findIndex((item) => !item);
+        if (firstEmpty >= 0)
+            return firstEmpty;
+        return Math.min(this.length - 1, Math.max(0, preferredIndex));
+    }
+    input(index, char) {
+        return this.inputAtNextSlot(index, char).state;
+    }
+    inputAtNextSlot(index, char) {
+        const chars = this.getState().chars;
+        const writeIndex = this.getNextInputIndex(index);
+        if (writeIndex < 0 || writeIndex >= this.length) {
+            return { focusIndex: Math.min(this.length - 1, Math.max(0, index)), state: this.getState(), writeIndex };
+        }
+        chars[writeIndex] = char.slice(-1);
+        this.value = normalizeValue$1(chars.join(""), this.length);
+        return {
+            focusIndex: Math.min(this.length - 1, writeIndex + 1),
+            state: this.getState(),
+            writeIndex
+        };
+    }
+    paste(value, startIndex = 0) {
+        const chars = this.getState().chars;
+        normalizeValue$1(value, this.length).split("").forEach((char, offset) => {
+            const index = startIndex + offset;
+            if (index >= 0 && index < this.length)
+                chars[index] = char;
+        });
+        this.value = normalizeValue$1(chars.join(""), this.length);
+        return this.getState();
+    }
+    remove(index) {
+        if (index < 0 || index >= this.length)
+            return this.getState();
+        const chars = this.getState().chars;
+        chars[index] = "";
+        this.value = normalizeValue$1(chars.join(""), this.length);
+        return this.getState();
+    }
+    clear() {
+        this.value = "";
+        return this.getState();
+    }
+    getState() {
+        const chars = Array.from({ length: this.length }, (_, index) => this.value[index] ?? "");
+        return { chars, complete: chars.every(Boolean), length: this.length, value: chars.join("") };
+    }
+}
+
+class ModalController {
+    constructor(open = false) {
+        this.emitter = new StateEmitter();
+        this.openState = open;
+    }
+    isOpen() {
+        return this.openState;
+    }
+    open() {
+        this.setOpen(true);
+    }
+    close() {
+        this.setOpen(false);
+    }
+    toggle() {
+        this.setOpen(!this.openState);
+    }
+    setOpen(open) {
+        if (this.openState === open)
+            return;
+        this.openState = open;
+        this.emitter.emit(this.openState);
+    }
+    subscribe(listener) {
+        listener(this.openState);
+        return this.emitter.subscribe(listener);
+    }
+}
+
+function clamp$b(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+class FloatingBallController {
+    constructor(options = {}) {
+        this.adsorb = options.adsorb ?? true;
+        this.adsorbAxis = options.adsorbAxis ?? "xy";
+        this.boundary = options.boundary;
+        this.gap = Math.max(0, options.gap ?? 16);
+        this.moveAxis = options.moveAxis ?? "xy";
+        this.position = options.initialPosition ?? { x: this.gap, y: this.gap };
+    }
+    updateOptions(options) {
+        if (options.adsorb !== undefined)
+            this.adsorb = options.adsorb;
+        if (options.adsorbAxis !== undefined)
+            this.adsorbAxis = options.adsorbAxis;
+        if (options.boundary !== undefined)
+            this.boundary = options.boundary;
+        if (options.gap !== undefined)
+            this.gap = Math.max(0, options.gap);
+        if (options.moveAxis !== undefined)
+            this.moveAxis = options.moveAxis;
+        return this.getState();
+    }
+    move(position, viewport, size) {
+        this.position = this.clampToViewport({
+            x: this.moveAxis === "y" ? this.position.x : position.x,
+            y: this.moveAxis === "x" ? this.position.y : position.y
+        }, this.boundary ?? viewport, size);
+        this.edge = undefined;
+        return this.getState();
+    }
+    release(viewport, size) {
+        const bounds = this.boundary ?? viewport;
+        if (!this.adsorb) {
+            this.position = this.clampToViewport(this.position, bounds, size);
+            return this.getState();
+        }
+        const distances = {
+            bottom: bounds.height - (this.position.y + size.height),
+            left: this.position.x,
+            right: bounds.width - (this.position.x + size.width),
+            top: this.position.y
+        };
+        const adsorbEdges = this.adsorbAxis === "x"
+            ? ["left", "right"]
+            : this.adsorbAxis === "y"
+                ? ["top", "bottom"]
+                : ["left", "right", "top", "bottom"];
+        this.edge = adsorbEdges.reduce((best, edge) => distances[edge] < distances[best] ? edge : best);
+        const next = { ...this.position };
+        if (this.edge === "left")
+            next.x = this.gap;
+        if (this.edge === "right")
+            next.x = bounds.width - size.width - this.gap;
+        if (this.edge === "top")
+            next.y = this.gap;
+        if (this.edge === "bottom")
+            next.y = bounds.height - size.height - this.gap;
+        this.position = this.clampToViewport(next, bounds, size);
+        return this.getState();
+    }
+    getState() {
+        return {
+            adsorb: this.adsorb,
+            adsorbAxis: this.adsorbAxis,
+            edge: this.edge,
+            gap: this.gap,
+            moveAxis: this.moveAxis,
+            position: { ...this.position }
+        };
+    }
+    clampToViewport(position, viewport, size) {
+        return {
+            x: clamp$b(position.x, this.gap, Math.max(this.gap, viewport.width - size.width - this.gap)),
+            y: clamp$b(position.y, this.gap, Math.max(this.gap, viewport.height - size.height - this.gap))
+        };
+    }
+}
+
+class PopupController {
+    constructor(open = false, placement = "bottom") {
+        this.emitter = new StateEmitter();
+        this.openState = open;
+        this.placementState = placement;
+    }
+    isOpen() {
+        return this.openState;
+    }
+    getPlacement() {
+        return this.placementState;
+    }
+    getState() {
+        return {
+            open: this.openState,
+            placement: this.placementState
+        };
+    }
+    open() {
+        this.setOpen(true);
+    }
+    close() {
+        this.setOpen(false);
+    }
+    toggle() {
+        this.setOpen(!this.openState);
+    }
+    setOpen(open) {
+        if (this.openState === open)
+            return;
+        this.openState = open;
+        this.emit();
+    }
+    setPlacement(placement) {
+        if (this.placementState === placement)
+            return;
+        this.placementState = placement;
+        this.emit();
+    }
+    update(state) {
+        const nextOpen = state.open ?? this.openState;
+        const nextPlacement = state.placement ?? this.placementState;
+        if (nextOpen === this.openState && nextPlacement === this.placementState)
+            return;
+        this.openState = nextOpen;
+        this.placementState = nextPlacement;
+        this.emit();
+    }
+    subscribe(listener) {
+        listener(this.getState());
+        return this.emitter.subscribe(listener);
+    }
+    emit() {
+        this.emitter.emit(this.getState());
+    }
+}
+
+class TooltipController {
+    constructor(open = false) {
+        this.emitter = new StateEmitter();
+        this.openState = open;
+    }
+    isOpen() {
+        return this.openState;
+    }
+    getState() {
+        return { open: this.openState };
+    }
+    subscribe(listener) {
+        listener(this.getState());
+        return this.emitter.subscribe(listener);
+    }
+    setOpen(open) {
+        if (this.openState === open)
+            return;
+        this.openState = open;
+        this.emit();
+    }
+    open() {
+        this.setOpen(true);
+    }
+    close() {
+        this.setOpen(false);
+    }
+    toggle() {
+        this.setOpen(!this.openState);
+    }
+    destroy() {
+        this.emitter.clear();
+    }
+    emit() {
+        this.emitter.emit(this.getState());
+    }
+}
+
+class AffixController {
+    constructor(offsetTop = 0) {
+        this.offsetTop = Math.max(0, Number.isFinite(offsetTop) ? offsetTop : 0);
+    }
+    update(offsetTop = 0) {
+        this.offsetTop = Math.max(0, Number.isFinite(offsetTop) ? offsetTop : 0);
+        return this.resolve(0);
+    }
+    resolve(top) {
+        return { fixed: top <= this.offsetTop, offsetTop: this.offsetTop };
+    }
+}
+
+class BacktopController {
+    constructor(visibilityHeight = 240) {
+        this.visibilityHeight = Math.max(0, Number.isFinite(visibilityHeight) ? visibilityHeight : 240);
+        this.hysteresis = this.resolveHysteresis();
+    }
+    update(visibilityHeight = 240) {
+        this.visibilityHeight = Math.max(0, Number.isFinite(visibilityHeight) ? visibilityHeight : 240);
+        this.hysteresis = this.resolveHysteresis();
+        return this.resolve(0);
+    }
+    resolve(scrollTop, previousVisible = false) {
+        const safeScrollTop = Math.max(0, Number.isFinite(scrollTop) ? scrollTop : 0);
+        const threshold = previousVisible ? Math.max(0, this.visibilityHeight - this.hysteresis) : this.visibilityHeight;
+        return { visible: safeScrollTop >= threshold };
+    }
+    resolveHysteresis() {
+        return Math.min(32, Math.max(8, Math.round(this.visibilityHeight * 0.08)));
+    }
+}
+
+function createId() {
+    return `toast-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+class ToastManager {
+    constructor() {
+        this.emitter = new StateEmitter();
+        this.timers = new Map();
+        this.items = [];
+    }
+    getToasts() {
+        return [...this.items];
+    }
+    show(options) {
+        const toast = {
+            id: options.id ?? createId(),
+            title: options.title,
+            message: options.message,
+            tone: options.tone ?? "info",
+            duration: options.duration ?? 3000,
+            position: options.position ?? "top-right",
+        };
+        this.items = [toast, ...this.items.filter((item) => item.id !== toast.id)];
+        this.scheduleDismiss(toast);
+        this.notify();
+        return toast.id;
+    }
+    dismiss(id) {
+        const timer = this.timers.get(id);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(id);
+        this.items = this.items.filter((item) => item.id !== id);
+        this.notify();
+    }
+    clear() {
+        this.timers.forEach((timer) => clearTimeout(timer));
+        this.timers.clear();
+        this.items = [];
+        this.notify();
+    }
+    subscribe(listener) {
+        listener(this.getToasts());
+        return this.emitter.subscribe(listener);
+    }
+    scheduleDismiss(toast) {
+        const existing = this.timers.get(toast.id);
+        if (existing)
+            clearTimeout(existing);
+        if (toast.duration <= 0)
+            return;
+        this.timers.set(toast.id, setTimeout(() => this.dismiss(toast.id), toast.duration));
+    }
+    notify() {
+        this.emitter.emit(this.getToasts());
+    }
+}
+
+function getSafeTooltipPlacement(triggerRect, tooltipRect, preferred, viewportWidth = window.innerWidth, viewportHeight = window.innerHeight, margin = 8) {
+    const fits = {
+        top: triggerRect.top >= tooltipRect.height + margin,
+        bottom: viewportHeight - triggerRect.bottom >= tooltipRect.height + margin,
+        left: triggerRect.left >= tooltipRect.width + margin,
+        right: viewportWidth - triggerRect.right >= tooltipRect.width + margin
+    };
+    if (preferred.startsWith("top") && fits.top)
+        return preferred;
+    if (preferred.startsWith("bottom") && fits.bottom)
+        return preferred;
+    if (preferred.startsWith("left") && fits.left)
+        return preferred;
+    if (preferred.startsWith("right") && fits.right)
+        return preferred;
+    if (fits.top)
+        return "top";
+    if (fits.bottom)
+        return "bottom";
+    if (fits.right)
+        return "right";
+    if (fits.left)
+        return "left";
+    return preferred;
+}
+
+class TabsController {
+    constructor(tabs, activeId) {
+        this.emitter = new StateEmitter();
+        this.tabs = tabs;
+        this.activeId = activeId ?? tabs.find((tab) => !tab.disabled)?.id ?? tabs[0]?.id ?? "";
+    }
+    getActiveId() {
+        return this.activeId;
+    }
+    setTabs(tabs) {
+        this.tabs = tabs;
+        if (!this.tabs.some((tab) => tab.id === this.activeId && !tab.disabled)) {
+            this.activeId = this.tabs.find((tab) => !tab.disabled)?.id ?? this.tabs[0]?.id ?? "";
+            this.emitter.emit(this.activeId);
+        }
+    }
+    activate(id) {
+        const tab = this.tabs.find((item) => item.id === id);
+        if (!tab || tab.disabled || this.activeId === id)
+            return;
+        this.activeId = id;
+        this.emitter.emit(this.activeId);
+    }
+    subscribe(listener) {
+        listener(this.activeId);
+        return this.emitter.subscribe(listener);
+    }
+}
+
+class BreadcrumbController {
+    constructor(items = []) {
+        this.items = this.normalize(items);
+    }
+    update(items = []) {
+        this.items = this.normalize(items);
+        return this.getState();
+    }
+    getState() {
+        return { items: this.items.map((item) => ({ ...item })) };
+    }
+    normalize(items) {
+        return items.filter((item) => item && String(item.label ?? "").trim()).map((item, index) => ({ ...item, key: item.key ?? index }));
+    }
+}
+
+class PaginationController {
+    constructor(options = {}) {
+        this.state = this.normalize(options);
+    }
+    update(options = {}) {
+        this.state = this.normalize(options);
+        return this.getState();
+    }
+    setCurrent(page) {
+        this.state = this.normalize({ ...this.state, current: page });
+        return this.getState();
+    }
+    getState() {
+        return { ...this.state, pages: [...this.state.pages] };
+    }
+    normalize(options) {
+        const boundaryCount = Math.max(1, Math.floor(Number.isFinite(options.boundaryCount) ? Number(options.boundaryCount) : 1));
+        const siblingCount = Math.max(0, Math.floor(Number.isFinite(options.siblingCount) ? Number(options.siblingCount) : 1));
+        const total = Math.max(0, Math.floor(Number.isFinite(options.total) ? Number(options.total) : 0));
+        const pageSize = Math.max(1, Math.floor(Number.isFinite(options.pageSize) ? Number(options.pageSize) : 10));
+        const pageCount = Math.max(1, Math.ceil(total / pageSize));
+        const current = Math.max(1, Math.min(pageCount, Math.floor(Number.isFinite(options.current) ? Number(options.current) : 1)));
+        const pages = this.createPages(current, pageCount, boundaryCount, siblingCount);
+        return { boundaryCount, current, pageCount, pageSize, pages, siblingCount, total };
+    }
+    createPages(current, pageCount, boundaryCount, siblingCount) {
+        const allCount = boundaryCount * 2 + siblingCount * 2 + 3;
+        if (pageCount <= allCount)
+            return Array.from({ length: pageCount }, (_, index) => index + 1);
+        const pages = [];
+        const addPage = (page) => {
+            if (!pages.includes(page))
+                pages.push(page);
+        };
+        for (let page = 1; page <= Math.min(boundaryCount, pageCount); page += 1)
+            addPage(page);
+        const siblingStart = Math.max(boundaryCount + 1, Math.min(current - siblingCount, pageCount - boundaryCount - siblingCount * 2));
+        const siblingEnd = Math.min(pageCount - boundaryCount, Math.max(current + siblingCount, boundaryCount + 1 + siblingCount * 2));
+        if (siblingStart > boundaryCount + 1)
+            pages.push("ellipsis");
+        for (let page = siblingStart; page <= siblingEnd; page += 1)
+            addPage(page);
+        if (siblingEnd < pageCount - boundaryCount)
+            pages.push("ellipsis");
+        for (let page = Math.max(pageCount - boundaryCount + 1, 1); page <= pageCount; page += 1)
+            addPage(page);
+        return pages;
+    }
+}
+
+class BadgeController {
+    constructor(options = {}) {
+        this.state = this.normalize(options);
+    }
+    update(options = {}) {
+        this.state = this.normalize(options);
+        return this.getState();
+    }
+    getState() {
+        return { ...this.state };
+    }
+    normalize(options) {
+        const max = Number.isFinite(options.max) ? Math.max(1, Number(options.max)) : 99;
+        const value = typeof options.value === "number" && options.value > max ? `${max}+` : String(options.value ?? "");
+        return {
+            displayValue: options.dot ? "" : value,
+            dot: Boolean(options.dot),
+            tone: options.tone ?? "danger"
+        };
+    }
+}
+
+class CalendarController {
+    constructor(options = {}) {
+        this.controller = new DatePickerController(options);
+    }
+    updateOptions(options = {}) {
+        this.controller.updateOptions(options);
+        return this.getState();
+    }
+    moveMonth(delta) {
+        this.controller.moveMonth(delta);
+        return this.getState();
+    }
+    select(value) {
+        this.controller.select(value);
+        return this.getState();
+    }
+    getState() {
+        const state = this.controller.getState();
+        const locale = getClassComponentsLocale();
+        return {
+            days: state.days,
+            month: state.month,
+            title: `${state.year}${locale.dateYearUnit} ${state.month}${locale.dateMonthUnit}`,
+            value: state.value,
+            year: state.year
+        };
+    }
+}
+
+const MIN_NODE_WIDTH = 32;
+const MAX_NODE_WIDTH = 320;
+const DEFAULT_NODE_WIDTH = 160;
+const DEFAULT_NODE_HEIGHT = 64;
+const DEFAULT_GAP_X = 220;
+const MIN_NODE_GAP_Y = 4;
+function clamp$a(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function finiteOr$3(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function estimateNodeWidth(node) {
+    if (node.width !== undefined)
+        return clamp$a(finiteOr$3(node.width, DEFAULT_NODE_WIDTH), MIN_NODE_WIDTH, MAX_NODE_WIDTH);
+    const title = String(node.title || " ");
+    const contentLines = String(node.content ?? "").split(/\r?\n/);
+    const longestContentLine = contentLines.reduce((max, line) => Math.max(max, line.length), 0);
+    const longestLine = Math.max(title.length, longestContentLine);
+    return clamp$a(Math.ceil(longestLine * 7.2 + 24), MIN_NODE_WIDTH, MAX_NODE_WIDTH);
+}
+function estimateNodeHeight(node) {
+    const width = estimateNodeWidth(node);
+    const charsPerLine = Math.max(1, Math.floor((width - 24) / 7.2));
+    const titleLines = Math.max(1, Math.ceil(String(node.title || " ").length / charsPerLine));
+    const content = String(node.content ?? "");
+    const contentLines = content.trim() === ""
+        ? 0
+        : content
+            .split(/\r?\n/)
+            .reduce((total, line) => total + Math.max(1, Math.ceil((line.length || 1) / charsPerLine)), 0);
+    const estimated = 20 + titleLines * 18 + contentLines * 16 + (contentLines > 0 ? 6 : 0);
+    return Math.max(DEFAULT_NODE_HEIGHT, Math.ceil(estimated));
+}
+function createDefaultNodes() {
+    return [
+        { id: "root", title: "项目画布", content: "双模式编辑器初版", x: 0, y: 0, width: 200, height: 92, children: ["doc", "mind"] },
+        { id: "doc", parentId: "root", title: "文档模式", content: "像 Word/幕布一样输入结构化内容。", level: 2, children: ["doc-a"] },
+        { id: "doc-a", parentId: "doc", title: "基础段落", content: "支持标题、正文、层级和只读状态。", level: 3 },
+        { id: "mind", parentId: "root", title: "脑图模式", content: "卡片、拖拽、连线、缩放和平移。", level: 2, children: ["mind-a", "mind-b"] },
+        { id: "mind-a", parentId: "mind", title: "卡片 A", content: "可拖拽节点", level: 3 },
+        { id: "mind-b", parentId: "mind", title: "卡片 B", content: "自动生成连线", level: 3 }
+    ];
+}
+function normalizeViewport(viewport) {
+    return {
+        x: finiteOr$3(viewport?.x, 0),
+        y: finiteOr$3(viewport?.y, 0),
+        zoom: clamp$a(finiteOr$3(viewport?.zoom, 1), 0.35, 2.4)
+    };
+}
+function normalizeMode(mode) {
+    return mode === "mind" ? "mind" : "document";
+}
+function cloneNode(node) {
+    return {
+        ...node,
+        children: node.children ? [...node.children] : undefined
+    };
+}
+function normalizeNodes(nodes) {
+    const source = nodes && nodes.length > 0 ? nodes : createDefaultNodes();
+    const seen = new Set();
+    const normalized = source
+        .filter((node) => {
+        if (!node.id || seen.has(node.id))
+            return false;
+        seen.add(node.id);
+        return true;
+    })
+        .map(cloneNode);
+    return reconcileHierarchy(normalized);
+}
+function reconcileHierarchy(nodes) {
+    const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+    const childIds = new Set();
+    nodes.forEach((node) => {
+        const children = (node.children ?? []).filter((childId) => childId !== node.id && nodeMap.has(childId));
+        if (children.length > 0) {
+            node.children = Array.from(new Set(children));
+            node.children.forEach((childId) => {
+                childIds.add(childId);
+                const child = nodeMap.get(childId);
+                if (child && !child.parentId)
+                    child.parentId = node.id;
+            });
+        }
+        else {
+            delete node.children;
+        }
+    });
+    nodes.forEach((node) => {
+        const parent = node.parentId ? nodeMap.get(node.parentId) : undefined;
+        if (!parent || parent.id === node.id)
+            return;
+        const children = parent.children ?? [];
+        if (!children.includes(node.id))
+            parent.children = [...children, node.id];
+        childIds.add(node.id);
+    });
+    nodes.forEach((node) => {
+        if (!node.parentId && childIds.has(node.id)) {
+            const parent = nodes.find((candidate) => candidate.children?.includes(node.id));
+            if (parent)
+                node.parentId = parent.id;
+        }
+    });
+    return nodes;
+}
+function getRootId(nodes, rootId) {
+    if (rootId && nodes.some((node) => node.id === rootId))
+        return rootId;
+    const explicitRoot = nodes.find((node) => !node.parentId);
+    return explicitRoot?.id ?? nodes[0]?.id ?? "root";
+}
+class CanvasEditorController {
+    constructor(options = {}) {
+        this.idSeed = 0;
+        this.mode = normalizeMode(options.mode);
+        this.nodes = normalizeNodes(options.nodes);
+        this.rootId = getRootId(this.nodes, options.rootId);
+        this.viewport = normalizeViewport(options.viewport);
+        this.disabled = options.disabled ?? false;
+        this.readOnly = options.readOnly ?? false;
+    }
+    updateOptions(options = {}) {
+        if (options.mode)
+            this.mode = normalizeMode(options.mode);
+        if (options.nodes) {
+            this.nodes = normalizeNodes(options.nodes);
+            this.rootId = getRootId(this.nodes, options.rootId ?? this.rootId);
+        }
+        else if (options.rootId) {
+            this.rootId = getRootId(this.nodes, options.rootId);
+        }
+        if (options.viewport)
+            this.viewport = normalizeViewport({ ...this.viewport, ...options.viewport });
+        if (typeof options.disabled === "boolean")
+            this.disabled = options.disabled;
+        if (typeof options.readOnly === "boolean")
+            this.readOnly = options.readOnly;
+        return this.getState();
+    }
+    setMode(mode) {
+        this.mode = normalizeMode(mode);
+        return this.getState();
+    }
+    select(id) {
+        this.selectedId = id && this.nodes.some((node) => node.id === id) ? id : undefined;
+        return this.getState();
+    }
+    updateNode(id, patch) {
+        if (this.disabled || this.readOnly)
+            return this.getState();
+        this.nodes = this.nodes.map((node) => {
+            if (node.id !== id)
+                return node;
+            const nextNode = { ...node, ...patch };
+            return { ...nextNode, height: estimateNodeHeight(nextNode) };
+        });
+        return this.getState();
+    }
+    addNode(input = {}) {
+        if (this.disabled || this.readOnly)
+            return this.getState();
+        const nodeMap = new Map(this.nodes.map((node) => [node.id, node]));
+        const fallbackParentId = this.selectedId && nodeMap.has(this.selectedId) ? this.selectedId : this.rootId;
+        const parentId = input.parentId && nodeMap.has(input.parentId) ? input.parentId : fallbackParentId;
+        const id = this.createNodeId(input.id);
+        const nextNode = {
+            content: input.content ?? "补充节点说明",
+            id,
+            parentId,
+            title: input.title ?? "新节点",
+            ...(input.width !== undefined ? { width: input.width } : {}),
+            ...(input.x !== undefined ? { x: input.x } : {}),
+            ...(input.y !== undefined ? { y: input.y } : {})
+        };
+        nextNode.height = finiteOr$3(input.height, estimateNodeHeight(nextNode));
+        this.nodes = this.nodes
+            .map((node) => node.id === parentId ? { ...node, children: [...(node.children ?? []), id] } : node)
+            .concat(nextNode);
+        this.selectedId = id;
+        return this.getState();
+    }
+    removeNode(id) {
+        if (this.disabled || this.readOnly || id === this.rootId)
+            return this.getState();
+        const nodeMap = new Map(this.nodes.map((node) => [node.id, node]));
+        if (!nodeMap.has(id))
+            return this.getState();
+        const removeIds = new Set();
+        const collect = (nodeId) => {
+            if (removeIds.has(nodeId))
+                return;
+            removeIds.add(nodeId);
+            (nodeMap.get(nodeId)?.children ?? []).forEach(collect);
+        };
+        collect(id);
+        this.nodes = this.nodes
+            .filter((node) => !removeIds.has(node.id))
+            .map((node) => ({
+            ...node,
+            children: node.children?.filter((childId) => !removeIds.has(childId))
+        }));
+        if (this.selectedId && removeIds.has(this.selectedId))
+            this.selectedId = undefined;
+        return this.getState();
+    }
+    moveNode(input) {
+        if (this.disabled || this.readOnly)
+            return this.getState();
+        const zoom = this.viewport.zoom || 1;
+        this.nodes = this.nodes.map((node) => node.id === input.id
+            ? {
+                ...node,
+                x: finiteOr$3(node.x, 0) + input.deltaX / zoom,
+                y: finiteOr$3(node.y, 0) + input.deltaY / zoom
+            }
+            : node);
+        return this.getState();
+    }
+    pan(input) {
+        if (this.disabled)
+            return this.getState();
+        this.viewport = {
+            ...this.viewport,
+            x: this.viewport.x + input.deltaX,
+            y: this.viewport.y + input.deltaY
+        };
+        return this.getState();
+    }
+    zoom(delta) {
+        if (this.disabled)
+            return this.getState();
+        this.viewport = {
+            ...this.viewport,
+            zoom: clamp$a(this.viewport.zoom + delta, 0.35, 2.4)
+        };
+        return this.getState();
+    }
+    resetViewport() {
+        this.viewport = normalizeViewport();
+        return this.getState();
+    }
+    createNodeId(preferredId) {
+        if (preferredId && !this.nodes.some((node) => node.id === preferredId))
+            return preferredId;
+        let id = "";
+        do {
+            this.idSeed += 1;
+            id = `node-${Date.now().toString(36)}-${this.idSeed}`;
+        } while (this.nodes.some((node) => node.id === id));
+        return id;
+    }
+    getState() {
+        const nodes = this.getLayoutNodes();
+        return {
+            disabled: this.disabled,
+            links: this.createLinks(nodes),
+            mode: this.mode,
+            nodes,
+            readOnly: this.readOnly,
+            rootId: this.rootId,
+            selectedId: this.selectedId,
+            viewport: { ...this.viewport }
+        };
+    }
+    getLayoutNodes() {
+        const rawNodes = this.nodes.map(cloneNode);
+        const nodeMap = new Map(rawNodes.map((node) => [node.id, node]));
+        const root = nodeMap.get(this.rootId) ?? rawNodes[0];
+        if (!root)
+            return [];
+        const visited = new Set();
+        const depthById = new Map();
+        const result = [];
+        const walk = (id, depth, siblingIndex, offsetY) => {
+            const node = nodeMap.get(id);
+            if (!node || visited.has(id))
+                return offsetY;
+            visited.add(id);
+            depthById.set(id, depth);
+            const children = (node.children ?? []).filter((childId) => nodeMap.has(childId));
+            const width = estimateNodeWidth(node);
+            const height = Math.max(finiteOr$3(node.height, DEFAULT_NODE_HEIGHT), estimateNodeHeight({ ...node, width }));
+            const startY = offsetY;
+            let nextY = offsetY;
+            children.forEach((childId, index) => {
+                nextY = walk(childId, depth + 1, index, nextY);
+            });
+            const endY = children.length > 0 ? nextY - MIN_NODE_GAP_Y : startY;
+            const fallbackY = children.length > 0 ? (startY + endY) / 2 : startY;
+            const y = finiteOr$3(node.y, children.length > 0 ? fallbackY - height / 2 : siblingIndex === 0 && depth === 0 ? 0 : offsetY);
+            result.push({
+                ...node,
+                height,
+                width,
+                x: depth * DEFAULT_GAP_X,
+                y
+            });
+            return Math.max(children.length > 0 ? nextY : offsetY, y + height + MIN_NODE_GAP_Y);
+        };
+        walk(root.id, 0, 0, 0);
+        rawNodes.forEach((node) => {
+            if (!visited.has(node.id)) {
+                depthById.set(node.id, 0);
+                const width = estimateNodeWidth(node);
+                const height = Math.max(finiteOr$3(node.height, DEFAULT_NODE_HEIGHT), estimateNodeHeight({ ...node, width }));
+                result.push({
+                    ...node,
+                    height,
+                    width,
+                    x: 0,
+                    y: finiteOr$3(node.y, result.length * (height + MIN_NODE_GAP_Y))
+                });
+            }
+        });
+        return this.separateOverlappingNodes(result, depthById);
+    }
+    separateOverlappingNodes(nodes, depthById) {
+        const nextNodes = nodes.map(cloneNode);
+        const groups = new Map();
+        nextNodes.forEach((node) => {
+            const depth = depthById.get(node.id) ?? 0;
+            const group = groups.get(depth) ?? [];
+            group.push(node);
+            groups.set(depth, group);
+        });
+        groups.forEach((group) => {
+            group
+                .sort((a, b) => finiteOr$3(a.y, 0) - finiteOr$3(b.y, 0))
+                .reduce((nextY, node) => {
+                const currentY = finiteOr$3(node.y, nextY);
+                const y = Math.max(currentY, nextY);
+                node.y = y;
+                return y + finiteOr$3(node.height, DEFAULT_NODE_HEIGHT) + MIN_NODE_GAP_Y;
+            }, Number.NEGATIVE_INFINITY);
+        });
+        return nextNodes;
+    }
+    createLinks(nodes) {
+        const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+        const links = [];
+        nodes.forEach((node) => {
+            (node.children ?? []).forEach((childId) => {
+                const child = nodeMap.get(childId);
+                if (!child)
+                    return;
+                const fromX = finiteOr$3(node.x, 0) + finiteOr$3(node.width, DEFAULT_NODE_WIDTH);
+                const fromY = finiteOr$3(node.y, 0) + finiteOr$3(node.height, DEFAULT_NODE_HEIGHT) / 2;
+                const toX = finiteOr$3(child.x, 0);
+                const toY = finiteOr$3(child.y, 0) + finiteOr$3(child.height, DEFAULT_NODE_HEIGHT) / 2;
+                const curve = Math.max(48, Math.abs(toX - fromX) * 0.45);
+                links.push({
+                    d: `M ${fromX} ${fromY} C ${fromX + curve} ${fromY}, ${toX - curve} ${toY}, ${toX} ${toY}`,
+                    from: node.id,
+                    to: child.id
+                });
+            });
+        });
+        return links;
+    }
+}
+
+function finiteOr$2(value, fallback) {
+    return Number.isFinite(value) ? Number(value) : fallback;
+}
+function clamp$9(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function normalizeDpr(value) {
+    return clamp$9(finiteOr$2(value, 1), 1, 4);
+}
+function roundedRect(ctx, x, y, width, height, radius = 0) {
+    const r = clamp$9(radius, 0, Math.min(width, height) / 2);
+    ctx.beginPath();
+    ctx.moveTo(x + r, y);
+    ctx.lineTo(x + width - r, y);
+    ctx.quadraticCurveTo(x + width, y, x + width, y + r);
+    ctx.lineTo(x + width, y + height - r);
+    ctx.quadraticCurveTo(x + width, y + height, x + width - r, y + height);
+    ctx.lineTo(x + r, y + height);
+    ctx.quadraticCurveTo(x, y + height, x, y + height - r);
+    ctx.lineTo(x, y + r);
+    ctx.quadraticCurveTo(x, y, x + r, y);
+    ctx.closePath();
+}
+function createFont(layer) {
+    const style = layer.fontStyle ?? "normal";
+    const weight = layer.fontWeight ?? 500;
+    const size = finiteOr$2(layer.fontSize, 16);
+    const family = layer.fontFamily ?? "Inter, system-ui, -apple-system, BlinkMacSystemFont, sans-serif";
+    return `${style} ${weight} ${size}px ${family}`;
+}
+function wrapText(ctx, text, maxWidth, maxLines = Number.MAX_SAFE_INTEGER) {
+    const characters = Array.from(text);
+    const lines = [];
+    let line = "";
+    for (const char of characters) {
+        const next = `${line}${char}`;
+        if (line && ctx.measureText(next).width > maxWidth) {
+            lines.push(line);
+            line = char;
+            if (lines.length >= maxLines)
+                break;
+        }
+        else {
+            line = next;
+        }
+    }
+    if (line && lines.length < maxLines)
+        lines.push(line);
+    if (lines.length === maxLines && characters.join("").length > lines.join("").length) {
+        const last = lines[lines.length - 1] ?? "";
+        let trimmed = last;
+        while (trimmed && ctx.measureText(`${trimmed}...`).width > maxWidth)
+            trimmed = trimmed.slice(0, -1);
+        lines[lines.length - 1] = `${trimmed}...`;
+    }
+    return lines;
+}
+function loadImage(src) {
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.crossOrigin = "anonymous";
+        image.onload = () => resolve(image);
+        image.onerror = () => reject(new Error(`Failed to load image: ${src}`));
+        image.src = src;
+    });
+}
+class CanvasImageController {
+    constructor(options) {
+        this.options = { ...options, layers: [...(options.layers ?? [])] };
+    }
+    updateOptions(options) {
+        this.options = { ...this.options, ...options, layers: options.layers ? [...options.layers] : this.options.layers };
+        return this.getState();
+    }
+    getState() {
+        return {
+            background: this.options.background ?? "transparent",
+            dpr: normalizeDpr(this.options.dpr),
+            height: Math.max(1, finiteOr$2(this.options.height, 1)),
+            layerCount: this.options.layers?.length ?? 0,
+            width: Math.max(1, finiteOr$2(this.options.width, 1))
+        };
+    }
+    async draw(canvas) {
+        const state = this.getState();
+        const ctx = canvas.getContext("2d");
+        if (!ctx)
+            return state;
+        canvas.width = Math.round(state.width * state.dpr);
+        canvas.height = Math.round(state.height * state.dpr);
+        canvas.style.width = `${state.width}px`;
+        canvas.style.height = `${state.height}px`;
+        ctx.setTransform(state.dpr, 0, 0, state.dpr, 0, 0);
+        ctx.clearRect(0, 0, state.width, state.height);
+        if (state.background !== "transparent") {
+            ctx.fillStyle = state.background;
+            ctx.fillRect(0, 0, state.width, state.height);
+        }
+        for (const layer of this.options.layers ?? []) {
+            await this.drawLayer(ctx, layer);
+        }
+        return state;
+    }
+    async drawLayer(ctx, layer) {
+        ctx.save();
+        ctx.globalAlpha = clamp$9(layer.opacity ?? 1, 0, 1);
+        if (layer.rotate) {
+            ctx.translate(layer.x, layer.y);
+            ctx.rotate((layer.rotate * Math.PI) / 180);
+            ctx.translate(-layer.x, -layer.y);
+        }
+        if (layer.type === "rect") {
+            roundedRect(ctx, layer.x, layer.y, layer.width, layer.height, layer.radius);
+            if (layer.fill) {
+                ctx.fillStyle = layer.fill;
+                ctx.fill();
+            }
+            if (layer.stroke && layer.strokeWidth) {
+                ctx.strokeStyle = layer.stroke;
+                ctx.lineWidth = layer.strokeWidth;
+                ctx.stroke();
+            }
+        }
+        if (layer.type === "text") {
+            ctx.font = createFont(layer);
+            ctx.fillStyle = layer.color ?? "#111827";
+            ctx.textAlign = layer.textAlign ?? "left";
+            ctx.textBaseline = layer.textBaseline ?? "top";
+            const lineHeight = finiteOr$2(layer.lineHeight, finiteOr$2(layer.fontSize, 16) * 1.4);
+            const lines = layer.wrap && layer.maxWidth
+                ? wrapText(ctx, layer.text, layer.maxWidth, layer.maxLines)
+                : layer.text.split("\n").slice(0, layer.maxLines ?? Number.MAX_SAFE_INTEGER);
+            lines.forEach((line, index) => {
+                if (!layer.letterSpacing) {
+                    ctx.fillText(line, layer.x, layer.y + index * lineHeight, layer.maxWidth);
+                    return;
+                }
+                let offset = 0;
+                Array.from(line).forEach((char) => {
+                    ctx.fillText(char, layer.x + offset, layer.y + index * lineHeight);
+                    offset += ctx.measureText(char).width + (layer.letterSpacing ?? 0);
+                });
+            });
+        }
+        if (layer.type === "image") {
+            const image = await loadImage(layer.src);
+            const sourceRatio = image.width / image.height;
+            const targetRatio = layer.width / layer.height;
+            let sx = 0;
+            let sy = 0;
+            let sw = image.width;
+            let sh = image.height;
+            let dx = layer.x;
+            let dy = layer.y;
+            let dw = layer.width;
+            let dh = layer.height;
+            if (layer.fit === "cover") {
+                if (sourceRatio > targetRatio) {
+                    sw = image.height * targetRatio;
+                    sx = (image.width - sw) / 2;
+                }
+                else {
+                    sh = image.width / targetRatio;
+                    sy = (image.height - sh) / 2;
+                }
+            }
+            else if (layer.fit === "contain") {
+                if (sourceRatio > targetRatio) {
+                    dh = layer.width / sourceRatio;
+                    dy = layer.y + (layer.height - dh) / 2;
+                }
+                else {
+                    dw = layer.height * sourceRatio;
+                    dx = layer.x + (layer.width - dw) / 2;
+                }
+            }
+            if (layer.radius) {
+                roundedRect(ctx, layer.x, layer.y, layer.width, layer.height, layer.radius);
+                ctx.clip();
+            }
+            ctx.drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh);
+        }
+        ctx.restore();
+    }
+}
+
+function toTimestamp(value) {
+    if (value instanceof Date)
+        return value.getTime();
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : Date.now();
+    if (typeof value === "string") {
+        const time = new Date(value).getTime();
+        return Number.isFinite(time) ? time : Date.now();
+    }
+    return Date.now();
+}
+function toDuration(value, unit = 1) {
+    if (value === undefined)
+        return undefined;
+    const normalized = Number(value);
+    if (!Number.isFinite(normalized))
+        return undefined;
+    return Math.max(0, normalized * unit);
+}
+function resolveTarget(options = {}) {
+    if (options.target !== undefined)
+        return toTimestamp(options.target);
+    const now = Number.isFinite(options.now ?? NaN) ? Number(options.now) : Date.now();
+    const duration = toDuration(options.duration) ??
+        toDuration(options.minutes, 60000) ??
+        toDuration(options.seconds, 1000);
+    return now + (duration ?? 0);
+}
+function pad(value) {
+    return String(value).padStart(2, "0");
+}
+class CountdownController {
+    constructor(options = {}) {
+        this.autoStart = options.autoStart ?? true;
+        this.format = options.format ?? "unit";
+        this.running = this.autoStart;
+        this.sourceMode = options.minutes !== undefined ? "minutes" : options.seconds !== undefined ? "seconds" : "default";
+        this.target = resolveTarget(options);
+    }
+    updateOptions(options = {}) {
+        if (options.autoStart !== undefined)
+            this.autoStart = options.autoStart;
+        if (options.format)
+            this.format = options.format;
+        if (options.target !== undefined ||
+            options.duration !== undefined ||
+            options.minutes !== undefined ||
+            options.seconds !== undefined) {
+            this.sourceMode = options.minutes !== undefined ? "minutes" : options.seconds !== undefined ? "seconds" : "default";
+            this.target = resolveTarget(options);
+        }
+        if (options.autoStart !== undefined)
+            this.running = options.autoStart;
+        return this.getState(options.now);
+    }
+    start(now) {
+        this.running = true;
+        return this.getState(now);
+    }
+    pause(now) {
+        this.running = false;
+        return this.getState(now);
+    }
+    reset(target, now) {
+        if (target !== undefined)
+            this.target = toTimestamp(target);
+        this.running = this.autoStart;
+        return this.getState(now);
+    }
+    getState(now = Date.now()) {
+        const parts = this.createParts(Math.max(0, this.target - now));
+        const done = parts.total <= 0;
+        if (done)
+            this.running = false;
+        return {
+            ...parts,
+            display: this.formatParts(parts),
+            done,
+            running: this.running && !done
+        };
+    }
+    createParts(total) {
+        const secondsTotal = Math.floor(total / 1000);
+        const days = Math.floor(secondsTotal / 86400);
+        const hours = Math.floor((secondsTotal % 86400) / 3600);
+        const minutes = Math.floor((secondsTotal % 3600) / 60);
+        const seconds = secondsTotal % 60;
+        return { days, hours, milliseconds: total % 1000, minutes, seconds, total };
+    }
+    formatParts(parts) {
+        if (this.sourceMode === "minutes") {
+            const totalMinutes = Math.floor(Math.floor(parts.total / 1000) / 60);
+            return `${pad(totalMinutes)}:${pad(parts.seconds)}`;
+        }
+        if (this.sourceMode === "seconds")
+            return pad(Math.floor(parts.total / 1000));
+        if (this.format === "compact")
+            return `${parts.days > 0 ? `${parts.days}d ` : ""}${pad(parts.hours)}:${pad(parts.minutes)}:${pad(parts.seconds)}`;
+        if (this.format === "clock")
+            return `${pad(parts.days * 24 + parts.hours)}:${pad(parts.minutes)}:${pad(parts.seconds)}`;
+        const locale = getClassComponentsLocale();
+        return `${parts.days}${locale.countdownDayUnit} ${pad(parts.hours)}${locale.countdownHourUnit} ${pad(parts.minutes)}${locale.countdownMinuteUnit} ${pad(parts.seconds)}${locale.countdownSecondUnit}`;
+    }
+}
+
+class SkeletonController {
+    constructor(options = {}) {
+        this.state = this.normalize(options);
+    }
+    update(options = {}) {
+        this.state = this.normalize(options);
+        return this.getState();
+    }
+    getState() {
+        return { ...this.state, rows: [...this.state.rows] };
+    }
+    normalize(options) {
+        const count = Math.max(1, Math.min(20, Math.floor(Number.isFinite(options.count) ? Number(options.count) : 3)));
+        return { animated: options.animated ?? true, rows: Array.from({ length: count }, (_, index) => index) };
+    }
+}
+
+class TagController {
+    constructor(options = {}) {
+        this.state = this.normalize(options);
+    }
+    update(options = {}) {
+        this.state = this.normalize(options);
+        return this.getState();
+    }
+    getState() {
+        return { ...this.state };
+    }
+    normalize(options) {
+        return {
+            checkable: Boolean(options.checkable),
+            checked: Boolean(options.checked),
+            closable: Boolean(options.closable),
+            disabled: Boolean(options.disabled),
+            tone: options.tone ?? "neutral"
+        };
+    }
+}
+
+function normalizeValue(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.floor(value));
+}
+function toDigits(value, minDigits) {
+    const normalized = normalizeValue(value);
+    const chars = String(normalized).padStart(minDigits, "0").split("");
+    return chars.map((char) => Number(char));
+}
+class RollingNumberController {
+    constructor(value = 0, options = {}) {
+        this.minDigits = Math.max(1, options.minDigits ?? 1);
+        this.previousValue = normalizeValue(value);
+        this.previousDigits = toDigits(this.previousValue, this.minDigits);
+    }
+    getStableColumns(value = this.previousValue) {
+        const digits = toDigits(value, this.minDigits);
+        return digits.map((digit, index) => ({
+            key: `${digits.length - index - 1}`,
+            digit,
+            offset: digit
+        }));
+    }
+    update(value) {
+        const nextValue = normalizeValue(value);
+        const nextDigits = toDigits(nextValue, this.minDigits);
+        const previousDigits = this.alignPreviousDigits(nextDigits.length);
+        const increasing = nextValue >= this.previousValue;
+        const columns = nextDigits.map((digit, index) => {
+            const previousDigit = previousDigits[index] ?? 0;
+            const offset = increasing && previousDigit === 9 && digit === 0 ? 10 : digit;
+            return {
+                key: `${nextDigits.length - index - 1}`,
+                digit,
+                offset
+            };
+        });
+        this.previousValue = nextValue;
+        this.previousDigits = nextDigits;
+        return columns;
+    }
+    alignPreviousDigits(length) {
+        const padding = Array.from({ length: Math.max(0, length - this.previousDigits.length) }, () => 0);
+        return [...padding, ...this.previousDigits].slice(-length);
+    }
+}
+
+const DEFAULT_ROOT_MARGIN = "200px";
+function normalizeRootMargin(rootMargin) {
+    return typeof rootMargin === "string" && rootMargin.trim() ? rootMargin : DEFAULT_ROOT_MARGIN;
+}
+function normalizeThreshold(threshold) {
+    if (typeof threshold !== "number" || !Number.isFinite(threshold))
+        return 0;
+    return Math.min(1, Math.max(0, threshold));
+}
+function normalizeSrc(src) {
+    return typeof src === "string" ? src.trim() : "";
+}
+class LazyImageController {
+    constructor(options) {
+        this.state = {
+            currentSrc: options.eager ? normalizeSrc(options.src) : undefined,
+            eager: Boolean(options.eager),
+            fallbackSrc: normalizeSrc(options.fallbackSrc) || undefined,
+            placeholderSrc: normalizeSrc(options.placeholderSrc) || undefined,
+            rootMargin: normalizeRootMargin(options.rootMargin),
+            src: normalizeSrc(options.src),
+            status: options.eager ? "loading" : "idle",
+            threshold: normalizeThreshold(options.threshold)
+        };
+    }
+    updateOptions(options) {
+        const nextSrc = options.src === undefined ? this.state.src : normalizeSrc(options.src);
+        const srcChanged = nextSrc !== this.state.src;
+        const eager = options.eager ?? this.state.eager;
+        this.state = {
+            ...this.state,
+            eager,
+            fallbackSrc: options.fallbackSrc === undefined
+                ? this.state.fallbackSrc
+                : normalizeSrc(options.fallbackSrc) || undefined,
+            placeholderSrc: options.placeholderSrc === undefined
+                ? this.state.placeholderSrc
+                : normalizeSrc(options.placeholderSrc) || undefined,
+            rootMargin: normalizeRootMargin(options.rootMargin ?? this.state.rootMargin),
+            src: nextSrc,
+            threshold: normalizeThreshold(options.threshold ?? this.state.threshold)
+        };
+        if (srcChanged) {
+            this.state.status = eager ? "loading" : "idle";
+            this.state.currentSrc = eager ? nextSrc : undefined;
+        }
+        else if (eager && this.state.status === "idle") {
+            this.startLoading();
+        }
+        return this.getState();
+    }
+    startLoading() {
+        if (!this.state.src) {
+            this.state = { ...this.state, currentSrc: undefined, status: "error" };
+            return this.getState();
+        }
+        if (this.state.status === "loaded" && this.state.currentSrc === this.state.src) {
+            return this.getState();
+        }
+        this.state = { ...this.state, currentSrc: this.state.src, status: "loading" };
+        return this.getState();
+    }
+    markLoaded() {
+        this.state = { ...this.state, status: "loaded" };
+        return this.getState();
+    }
+    markError() {
+        if (this.state.fallbackSrc && this.state.currentSrc !== this.state.fallbackSrc) {
+            this.state = { ...this.state, currentSrc: this.state.fallbackSrc, status: "loading" };
+            return this.getState();
+        }
+        this.state = { ...this.state, status: "error" };
+        return this.getState();
+    }
+    getState() {
+        return { ...this.state };
+    }
+}
+
+const DEFAULT_DURATION = 18000;
+const DEFAULT_GAP$1 = "32px";
+const DEFAULT_ITEM_HEIGHT = "28px";
+const DEFAULT_STEP_ANIMATION_DURATION = 420;
+function normalizeDirection$1(direction) {
+    return direction === "vertical" ? "vertical" : "horizontal";
+}
+function normalizeDuration$1(duration) {
+    if (typeof duration !== "number" || !Number.isFinite(duration))
+        return DEFAULT_DURATION;
+    return Math.max(1000, Math.floor(duration));
+}
+function normalizeGap(gap) {
+    if (typeof gap === "number")
+        return `${Math.max(0, gap)}px`;
+    if (typeof gap === "string" && gap.trim())
+        return gap;
+    return DEFAULT_GAP$1;
+}
+function normalizeItemHeight(itemHeight) {
+    if (typeof itemHeight === "number")
+        return `${Math.max(1, itemHeight)}px`;
+    if (typeof itemHeight === "string" && itemHeight.trim())
+        return itemHeight;
+    return DEFAULT_ITEM_HEIGHT;
+}
+function normalizeVerticalMode(verticalMode) {
+    return verticalMode === "step" ? "step" : "continuous";
+}
+function normalizeStepAnimation(stepAnimation) {
+    if (stepAnimation === null)
+        return null;
+    return stepAnimation === "fade" || stepAnimation === "flip" ? stepAnimation : "slide";
+}
+function normalizeStepAnimationDuration(duration) {
+    if (typeof duration !== "number" || !Number.isFinite(duration))
+        return DEFAULT_STEP_ANIMATION_DURATION;
+    return Math.max(0, Math.floor(duration));
+}
+function normalizeItems(items) {
+    return items
+        .map((item, index) => {
+        if (typeof item === "object" && item !== null) {
+            const text = String(item.text).trim();
+            return {
+                key: item.key?.trim() || `${index}-${text}`,
+                text,
+                value: item.value
+            };
+        }
+        const text = String(item).trim();
+        return {
+            key: `${index}-${text}`,
+            text
+        };
+    })
+        .filter((item) => item.text.length > 0);
+}
+class MarqueeController {
+    constructor(items = [], options = {}) {
+        this.items = normalizeItems(items);
+        this.direction = normalizeDirection$1(options.direction);
+        this.duration = normalizeDuration$1(options.duration);
+        this.gap = normalizeGap(options.gap);
+        this.itemHeight = normalizeItemHeight(options.itemHeight);
+        this.pauseOnHover = options.pauseOnHover ?? true;
+        this.reverse = Boolean(options.reverse);
+        this.stepAnimation = normalizeStepAnimation(options.stepAnimation);
+        this.stepAnimationDuration = normalizeStepAnimationDuration(options.stepAnimationDuration);
+        this.verticalMode = normalizeVerticalMode(options.verticalMode);
+    }
+    update(items, options = {}) {
+        this.items = normalizeItems(items);
+        this.direction = normalizeDirection$1(options.direction ?? this.direction);
+        this.duration = normalizeDuration$1(options.duration ?? this.duration);
+        this.gap = normalizeGap(options.gap ?? this.gap);
+        this.itemHeight = normalizeItemHeight(options.itemHeight ?? this.itemHeight);
+        this.pauseOnHover = options.pauseOnHover ?? this.pauseOnHover;
+        this.reverse = options.reverse ?? this.reverse;
+        this.stepAnimation = normalizeStepAnimation(Object.prototype.hasOwnProperty.call(options, "stepAnimation")
+            ? options.stepAnimation
+            : this.stepAnimation);
+        this.stepAnimationDuration = normalizeStepAnimationDuration(options.stepAnimationDuration ?? this.stepAnimationDuration);
+        this.verticalMode = normalizeVerticalMode(options.verticalMode ?? this.verticalMode);
+        return this.getState();
+    }
+    getState() {
+        return {
+            direction: this.direction,
+            duration: this.duration,
+            gap: this.gap,
+            itemHeight: this.itemHeight,
+            items: this.items,
+            pauseOnHover: this.pauseOnHover,
+            reverse: this.reverse,
+            shouldAnimate: this.items.length > 1,
+            stepAnimation: this.stepAnimation,
+            stepAnimationDuration: this.stepAnimationDuration,
+            verticalMode: this.verticalMode
+        };
+    }
+}
+
+function clamp$8(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function finiteOr$1(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function normalizeOptions$2(options = {}) {
+    return {
+        disabled: options.disabled ?? false,
+        enterTransitionDuration: clamp$8(finiteOr$1(options.enterTransitionDuration, 180), 0, 600),
+        glare: options.glare ?? true,
+        maxTilt: clamp$8(finiteOr$1(options.maxTilt, 12), 0, 45),
+        moveTransitionDuration: clamp$8(finiteOr$1(options.moveTransitionDuration, 80), 0, 300),
+        perspective: clamp$8(finiteOr$1(options.perspective, 900), 240, 2400),
+        scale: clamp$8(finiteOr$1(options.scale, 1.02), 1, 1.18),
+        transitionEasing: options.transitionEasing ?? "cubic-bezier(0.2, 0.8, 0.2, 1)",
+        transitionDuration: clamp$8(finiteOr$1(options.transitionDuration, 180), 0, 1200)
+    };
+}
+function createTransform(rotateX, rotateY, scale, perspective) {
+    return `perspective(${perspective}px) rotateX(${rotateX.toFixed(3)}deg) rotateY(${rotateY.toFixed(3)}deg) scale(${scale.toFixed(3)})`;
+}
+class TiltCardController {
+    constructor(options = {}) {
+        this.options = normalizeOptions$2(options);
+    }
+    updateOptions(options = {}) {
+        this.options = normalizeOptions$2({ ...this.options, ...options });
+        return this.reset();
+    }
+    move(input) {
+        const width = Math.max(1, finiteOr$1(input.width, 1));
+        const height = Math.max(1, finiteOr$1(input.height, 1));
+        if (this.options.disabled) {
+            return this.reset();
+        }
+        const x = clamp$8(input.pointerX / width, 0, 1);
+        const y = clamp$8(input.pointerY / height, 0, 1);
+        const rotateY = (x - 0.5) * this.options.maxTilt * 2;
+        const rotateX = (0.5 - y) * this.options.maxTilt * 2;
+        return {
+            glare: this.options.glare,
+            glareOpacity: this.options.glare ? clamp$8(Math.abs(x - 0.5) + Math.abs(y - 0.5), 0.16, 0.58) : 0,
+            glareX: x * 100,
+            glareY: y * 100,
+            isActive: true,
+            rotateX,
+            rotateY,
+            scale: this.options.scale,
+            transform: createTransform(rotateX, rotateY, this.options.scale, this.options.perspective),
+            transitionDuration: input.phase === "enter" ? this.options.enterTransitionDuration : this.options.moveTransitionDuration,
+            transitionEasing: this.options.transitionEasing
+        };
+    }
+    reset() {
+        return {
+            glare: this.options.glare,
+            glareOpacity: 0,
+            glareX: 50,
+            glareY: 50,
+            isActive: false,
+            rotateX: 0,
+            rotateY: 0,
+            scale: 1,
+            transform: createTransform(0, 0, 1, this.options.perspective),
+            transitionDuration: this.options.transitionDuration,
+            transitionEasing: this.options.transitionEasing
+        };
+    }
+    getOptions() {
+        return { ...this.options };
+    }
+}
+
+function finiteOr(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function clamp$7(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function normalizeOptions$1(options = {}) {
+    return {
+        cursor: options.cursor ?? true,
+        delay: clamp$7(finiteOr(options.delay, 0), 0, 60000),
+        disabled: options.disabled ?? false,
+        loading: options.loading ?? false,
+        loop: options.loop ?? false,
+        speed: clamp$7(finiteOr(options.speed, 36), 1, 5000),
+        startOnMount: options.startOnMount ?? true,
+        text: options.text ?? ""
+    };
+}
+class TypewriterTextController {
+    constructor(options = {}) {
+        this.options = normalizeOptions$1(options);
+        this.index = this.options.disabled ? this.options.text.length : 0;
+        this.running = !this.options.disabled && this.options.startOnMount && this.options.text.length > 0;
+    }
+    updateOptions(options = {}) {
+        const previousText = this.options.text;
+        this.options = normalizeOptions$1({ ...this.options, ...options });
+        if (this.options.disabled) {
+            this.index = this.options.text.length;
+            this.running = false;
+            return this.getState();
+        }
+        if (previousText !== this.options.text) {
+            this.index = 0;
+            this.running = this.options.startOnMount && this.options.text.length > 0;
+        }
+        else {
+            this.index = clamp$7(this.index, 0, this.options.text.length);
+            if (this.index >= this.options.text.length)
+                this.running = false;
+        }
+        return this.getState();
+    }
+    start() {
+        if (!this.options.disabled && this.index < this.options.text.length)
+            this.running = true;
+        return this.getState();
+    }
+    pause() {
+        this.running = false;
+        return this.getState();
+    }
+    reset() {
+        this.index = this.options.disabled ? this.options.text.length : 0;
+        this.running = !this.options.disabled && this.options.startOnMount && this.options.text.length > 0;
+        return this.getState();
+    }
+    finish() {
+        this.index = this.options.text.length;
+        this.running = false;
+        return this.getState();
+    }
+    tick() {
+        if (!this.running || this.options.disabled)
+            return this.getState();
+        if (this.index < this.options.text.length)
+            this.index += 1;
+        if (this.index >= this.options.text.length) {
+            if (this.options.loop && this.options.text.length > 0) {
+                this.index = 0;
+                this.running = true;
+            }
+            else {
+                this.running = false;
+            }
+        }
+        return this.getState();
+    }
+    getDelay() {
+        return this.options.delay;
+    }
+    getSpeed() {
+        return this.options.speed;
+    }
+    getState() {
+        return {
+            cursor: this.options.cursor,
+            displayedText: this.options.text.slice(0, this.index),
+            done: !this.running && this.index >= this.options.text.length,
+            index: this.index,
+            loading: this.options.loading && this.running,
+            running: this.running,
+            text: this.options.text
+        };
+    }
+}
+
+const defaultColors = ["#7c3aed", "#ec4899", "#22d3ee"];
+const cssColorPattern$1 = /^(#|rgb\(|rgba\(|hsl\(|hsla\(|color\(|color-mix\(|var\(|[a-zA-Z])/;
+function normalizeColors$1(colors) {
+    const next = (colors ?? [])
+        .map((color) => String(color).trim())
+        .filter((color) => color.length > 0 && cssColorPattern$1.test(color));
+    return next.length >= 2 ? next : [...defaultColors];
+}
+function normalizeDirection(direction) {
+    if (typeof direction === "number" && Number.isFinite(direction))
+        return `${direction}deg`;
+    const next = String(direction ?? "90deg").trim();
+    return next.length > 0 ? next : "90deg";
+}
+function normalizeDuration(duration) {
+    return Math.max(600, Number.isFinite(duration) ? Number(duration) : 3600);
+}
+function normalizeText(text) {
+    return String(text ?? "");
+}
+function normalizeOptions(options = {}) {
+    const colors = normalizeColors$1(options.colors);
+    const direction = normalizeDirection(options.direction);
+    return {
+        animated: options.animated ?? false,
+        backgroundImage: `linear-gradient(${direction}, ${colors.join(", ")})`,
+        backgroundSize: String(options.backgroundSize ?? "200% 100%"),
+        colors,
+        direction,
+        duration: normalizeDuration(options.duration),
+        easing: String(options.easing ?? "cubic-bezier(0.22, 0.8, 0.28, 1)"),
+        fontWeight: options.fontWeight ?? 700,
+        text: normalizeText(options.text)
+    };
+}
+class GradientTextController {
+    constructor(options = {}) {
+        this.state = normalizeOptions(options);
+    }
+    updateOptions(options = {}) {
+        this.state = normalizeOptions(options);
+        return this.getState();
+    }
+    getState() {
+        return { ...this.state, colors: [...this.state.colors] };
+    }
+}
+
+const presetSet = new Set([
+    "aurora",
+    "border-glow",
+    "frosted",
+    "glass",
+    "gradient",
+    "holographic",
+    "mesh",
+    "neon",
+    "noise",
+    "scanline",
+    "soft-grid",
+    "spotlight"
+]);
+const toneSet = new Set(["accent", "cool", "danger", "neutral", "success", "warm"]);
+const toneColors = {
+    accent: ["#7c3aed", "#ec4899", "#22d3ee"],
+    cool: ["#0ea5e9", "#22d3ee", "#14b8a6"],
+    danger: ["#ef4444", "#f97316", "#facc15"],
+    neutral: ["#334155", "#94a3b8", "#e2e8f0"],
+    success: ["#16a34a", "#22c55e", "#84cc16"],
+    warm: ["#f59e0b", "#f97316", "#fb7185"]
+};
+const cssColorPattern = /^(#|rgb\(|rgba\(|hsl\(|hsla\(|color\(|color-mix\(|var\(|[a-zA-Z])/;
+function clamp$6(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function normalizePreset(preset) {
+    return presetSet.has(preset) ? preset : "glass";
+}
+function normalizeTone(tone) {
+    return toneSet.has(tone) ? tone : "accent";
+}
+function normalizeRadius(radius) {
+    if (typeof radius === "number" && Number.isFinite(radius))
+        return `${Math.max(0, radius)}px`;
+    const next = String(radius ?? "var(--cc-radius-lg)").trim();
+    return next.length > 0 ? next : "var(--cc-radius-lg)";
+}
+function normalizeColors(colors, tone) {
+    const next = (colors ?? [])
+        .map((color) => String(color).trim())
+        .filter((color) => color.length > 0 && cssColorPattern.test(color));
+    return next.length >= 2 ? next : [...toneColors[tone]];
+}
+function normalizeIntensity(intensity) {
+    return clamp$6(Number.isFinite(intensity) ? Number(intensity) : 0.72, 0, 1);
+}
+class DesignEffectController {
+    constructor(options = {}) {
+        this.state = this.normalize(options);
+    }
+    updateOptions(options = {}) {
+        this.state = this.normalize(options);
+        return this.getState();
+    }
+    getState() {
+        return {
+            ...this.state,
+            colors: [...this.state.colors],
+            styleVars: { ...this.state.styleVars }
+        };
+    }
+    normalize(options) {
+        const preset = normalizePreset(options.preset);
+        const tone = normalizeTone(options.tone);
+        const colors = normalizeColors(options.colors, tone);
+        const intensity = normalizeIntensity(options.intensity);
+        const radius = normalizeRadius(options.radius);
+        const animated = options.animated ?? ["aurora", "gradient", "holographic", "scanline"].includes(preset);
+        return {
+            animated,
+            className: `cc-design-effect cc-design-effect--${preset}`,
+            colors,
+            disabled: options.disabled ?? false,
+            intensity,
+            interactive: options.interactive ?? ["border-glow", "glass", "spotlight"].includes(preset),
+            overlay: !["border-glow", "noise", "soft-grid"].includes(preset),
+            preset,
+            radius,
+            styleVars: {
+                "--cc-design-effect-alpha": intensity.toFixed(3),
+                "--cc-design-effect-color-1": colors[0],
+                "--cc-design-effect-color-2": colors[1],
+                "--cc-design-effect-color-3": colors[2] ?? colors[0],
+                "--cc-design-effect-radius": radius
+            },
+            tone
+        };
+    }
+}
+
+function clamp$5(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+class SwiperController {
+    constructor(options) {
+        this.count = Math.max(0, Math.floor(options.count));
+        this.current = clamp$5(Math.floor(options.current ?? 0), 0, Math.max(0, this.count - 1));
+        this.loop = options.loop ?? false;
+        this.threshold = Math.max(1, options.threshold ?? 48);
+    }
+    updateOptions(options) {
+        if (options.count !== undefined)
+            this.count = Math.max(0, Math.floor(options.count));
+        if (options.loop !== undefined)
+            this.loop = options.loop;
+        if (options.threshold !== undefined)
+            this.threshold = Math.max(1, options.threshold);
+        if (options.current !== undefined)
+            this.current = clamp$5(Math.floor(options.current), 0, Math.max(0, this.count - 1));
+        else
+            this.current = clamp$5(this.current, 0, Math.max(0, this.count - 1));
+        return this.getState();
+    }
+    next() {
+        if (this.count <= 0)
+            return this.getState();
+        this.current = this.current >= this.count - 1 ? (this.loop ? 0 : this.count - 1) : this.current + 1;
+        return this.getState();
+    }
+    previous() {
+        if (this.count <= 0)
+            return this.getState();
+        this.current = this.current <= 0 ? (this.loop ? this.count - 1 : 0) : this.current - 1;
+        return this.getState();
+    }
+    resolveSwipe(deltaX, velocityX = 0) {
+        if (Math.abs(deltaX) < this.threshold && Math.abs(velocityX) < 360)
+            return this.getState();
+        return deltaX < 0 || velocityX < -360 ? this.next() : this.previous();
+    }
+    setCurrent(index) {
+        this.current = clamp$5(index, 0, Math.max(0, this.count - 1));
+        return this.getState();
+    }
+    getState() {
+        return {
+            count: this.count,
+            current: this.current,
+            loop: this.loop
+        };
+    }
+}
+
+function clamp$4(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+class ImagePreviewController {
+    constructor(items = [], activeIndex = 0, open = false) {
+        this.loading = false;
+        this.items = items.filter((item) => item.src);
+        this.activeIndex = clamp$4(activeIndex, 0, Math.max(0, this.items.length - 1));
+        this.openState = open;
+    }
+    updateItems(items, activeIndex = this.activeIndex) {
+        this.items = items.filter((item) => item.src);
+        this.activeIndex = clamp$4(activeIndex, 0, Math.max(0, this.items.length - 1));
+        this.loading = false;
+        return this.getState();
+    }
+    open(index = this.activeIndex) {
+        this.openState = true;
+        this.activeIndex = clamp$4(index, 0, Math.max(0, this.items.length - 1));
+        return this.getState();
+    }
+    close() {
+        this.openState = false;
+        return this.getState();
+    }
+    next() {
+        if (this.items.length > 0)
+            this.activeIndex = (this.activeIndex + 1) % this.items.length;
+        this.loading = true;
+        return this.getState();
+    }
+    previous() {
+        if (this.items.length > 0)
+            this.activeIndex = (this.activeIndex - 1 + this.items.length) % this.items.length;
+        this.loading = true;
+        return this.getState();
+    }
+    setActiveIndex(index) {
+        this.activeIndex = clamp$4(index, 0, Math.max(0, this.items.length - 1));
+        this.loading = true;
+        return this.getState();
+    }
+    setLoading(loading) {
+        this.loading = loading;
+        return this.getState();
+    }
+    getState() {
+        return {
+            activeIndex: this.activeIndex,
+            activeItem: this.items[this.activeIndex],
+            count: this.items.length,
+            items: this.items,
+            loading: this.loading,
+            open: this.openState
+        };
+    }
+}
+
+class TimelineController {
+    constructor(options) {
+        this.items = options.items;
+        this.direction = options.direction ?? "vertical";
+    }
+    updateOptions(options) {
+        if (options.items)
+            this.items = options.items;
+        if (options.direction)
+            this.direction = options.direction;
+        return this.getState();
+    }
+    getState() {
+        return { direction: this.direction, items: this.items };
+    }
+}
+
+function normalizeSources(input) {
+    const list = Array.isArray(input) ? input : [input];
+    return list
+        .map((source) => (typeof source === "string" ? { src: source } : source))
+        .filter((source) => Boolean(source.src));
+}
+class VideoPlayerController {
+    constructor(options) {
+        this.state = this.normalize(options);
+    }
+    updateOptions(options) {
+        this.state = this.normalize({ ...this.state, ...options, sources: options.sources ?? this.state.sources });
+        return this.getState();
+    }
+    getState() {
+        return { ...this.state, sources: [...this.state.sources] };
+    }
+    normalize(options) {
+        return {
+            autoplay: options.autoplay ?? false,
+            controls: options.controls ?? true,
+            loop: options.loop ?? false,
+            muted: options.muted ?? false,
+            poster: options.poster,
+            preload: options.preload ?? "metadata",
+            sources: normalizeSources(options.sources)
+        };
+    }
+}
+
+function cloneItem(item) {
+    return {
+        ...item,
+        sources: Array.isArray(item.sources) ? [...item.sources] : item.sources
+    };
+}
+function normalizeRect(rect) {
+    if (!rect)
+        return undefined;
+    return {
+        height: Math.max(1, rect.height),
+        left: Number.isFinite(rect.left) ? rect.left : 0,
+        top: Number.isFinite(rect.top) ? rect.top : 0,
+        width: Math.max(1, rect.width)
+    };
+}
+class VideoDetailTransitionController {
+    constructor(options) {
+        this.state = this.normalize(options);
+    }
+    updateOptions(options) {
+        this.state = this.normalize({ ...this.state, ...options, items: options.items ?? this.state.items });
+        return this.getState();
+    }
+    open(id, sourceRect) {
+        const activeItem = this.state.items.find((item) => item.id === id);
+        this.state = {
+            ...this.state,
+            activeId: activeItem?.id,
+            activeItem,
+            phase: activeItem ? "entering" : "closed",
+            sourceRect: normalizeRect(sourceRect)
+        };
+        return this.getState();
+    }
+    entered() {
+        if (!this.state.activeItem)
+            return this.closeNow();
+        this.state = { ...this.state, phase: "open" };
+        return this.getState();
+    }
+    close() {
+        if (!this.state.activeItem)
+            return this.closeNow();
+        this.state = { ...this.state, phase: "leaving" };
+        return this.getState();
+    }
+    closeNow() {
+        this.state = { ...this.state, activeId: undefined, activeItem: undefined, phase: "closed", sourceRect: undefined };
+        return this.getState();
+    }
+    getState() {
+        return {
+            ...this.state,
+            activeItem: this.state.activeItem ? cloneItem(this.state.activeItem) : undefined,
+            items: this.state.items.map(cloneItem),
+            sourceRect: this.state.sourceRect ? { ...this.state.sourceRect } : undefined
+        };
+    }
+    normalize(options) {
+        const items = options.items.map(cloneItem);
+        const activeItem = options.activeId ? items.find((item) => item.id === options.activeId) : undefined;
+        return {
+            activeId: activeItem?.id,
+            activeItem,
+            animationDuration: Math.max(120, Math.min(900, options.animationDuration ?? 420)),
+            backdropColor: options.backdropColor ?? "rgba(0, 0, 0, 0.96)",
+            items,
+            phase: activeItem ? options.phase ?? "open" : "closed",
+            sourceRect: normalizeRect(options.sourceRect)
+        };
+    }
+}
+
+const WORD_EXTENSIONS = new Set(["doc", "docx", "rtf"]);
+const EXCEL_EXTENSIONS = new Set(["csv", "xls", "xlsx"]);
+const PPT_EXTENSIONS = new Set(["ppt", "pptx"]);
+const DEFAULT_OFFICE_VIEWER = "https://view.officeapps.live.com/op/embed.aspx?src=";
+function clamp$3(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function getExtension(value) {
+    const clean = value.split("?")[0]?.split("#")[0] ?? value;
+    const filename = clean.split("/").pop() ?? clean;
+    const extension = filename.includes(".") ? filename.split(".").pop() ?? "" : "";
+    return extension.toLowerCase();
+}
+function inferType(src, fileName) {
+    const extension = getExtension(fileName || src);
+    if (extension === "pdf")
+        return "pdf";
+    if (WORD_EXTENSIONS.has(extension))
+        return "word";
+    if (EXCEL_EXTENSIONS.has(extension))
+        return "excel";
+    if (PPT_EXTENSIONS.has(extension))
+        return "ppt";
+    return "unknown";
+}
+function inferFileName(src, fileName) {
+    if (fileName)
+        return fileName;
+    try {
+        const url = new URL(src, "https://class-kit.local");
+        const last = url.pathname.split("/").filter(Boolean).pop();
+        return last ? decodeURIComponent(last) : "Document";
+    }
+    catch {
+        const last = src.split("?")[0]?.split("#")[0]?.split("/").filter(Boolean).pop();
+        return last ? decodeURIComponent(last) : "Document";
+    }
+}
+function buildPdfUrl(src, page) {
+    const clean = src.split("#")[0] ?? src;
+    return `${clean}#page=${page}`;
+}
+function buildOfficeUrl(src, viewerBaseUrl) {
+    const base = viewerBaseUrl || DEFAULT_OFFICE_VIEWER;
+    return `${base}${encodeURIComponent(src)}`;
+}
+class FilePreviewController {
+    constructor(options) {
+        this.options = { ...options };
+    }
+    updateOptions(options) {
+        this.options = { ...this.options, ...options };
+        return this.getState();
+    }
+    goTo(page) {
+        this.options.currentPage = page;
+        return this.getState();
+    }
+    next() {
+        return this.goTo(this.getState().currentPage + 1);
+    }
+    previous() {
+        return this.goTo(this.getState().currentPage - 1);
+    }
+    getState() {
+        const fileName = inferFileName(this.options.src, this.options.fileName);
+        const type = this.options.type && this.options.type !== "unknown" ? this.options.type : inferType(this.options.src, fileName);
+        const pageCount = this.options.pageCount && this.options.pageCount > 0 ? Math.floor(this.options.pageCount) : undefined;
+        const currentPage = clamp$3(Math.floor(this.options.currentPage ?? 1), 1, pageCount ?? Number.MAX_SAFE_INTEGER);
+        const mode = type === "pdf" ? "pdf" : type === "word" || type === "excel" || type === "ppt" ? "office" : "unsupported";
+        const previewUrl = mode === "pdf"
+            ? buildPdfUrl(this.options.src, currentPage)
+            : mode === "office"
+                ? buildOfficeUrl(this.options.src, this.options.viewerBaseUrl)
+                : "";
+        return {
+            currentPage,
+            fileName,
+            mode,
+            pageCount,
+            previewUrl,
+            src: this.options.src,
+            title: fileName,
+            type
+        };
+    }
+}
+
+function clamp$2(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+class ProgressController {
+    constructor(options = {}) {
+        this.min = options.min ?? 0;
+        this.max = Math.max(this.min, options.max ?? 100);
+        this.step = Math.max(0, options.step ?? 1);
+        this.disabled = options.disabled ?? false;
+        this.value = this.normalizeValue(options.value ?? this.min);
+    }
+    updateOptions(options) {
+        if (options.min !== undefined)
+            this.min = options.min;
+        if (options.max !== undefined)
+            this.max = Math.max(this.min, options.max);
+        if (options.step !== undefined)
+            this.step = Math.max(0, options.step);
+        if (options.disabled !== undefined)
+            this.disabled = options.disabled;
+        if (options.value !== undefined)
+            this.value = this.normalizeValue(options.value);
+        return this.getState();
+    }
+    setValue(value) {
+        if (!this.disabled)
+            this.value = this.normalizeValue(value);
+        return this.getState();
+    }
+    valueFromRatio(ratio) {
+        return this.setValue(this.min + clamp$2(ratio, 0, 1) * (this.max - this.min));
+    }
+    valueFromClientX(clientX, rect, thumbWidth = 0) {
+        if (rect.width <= 0)
+            return this.getState();
+        const travelWidth = Math.max(1, rect.width - Math.max(0, thumbWidth));
+        const offset = clientX - rect.left - Math.max(0, thumbWidth) / 2;
+        return this.valueFromRatio(offset / travelWidth);
+    }
+    getState() {
+        const range = this.max - this.min;
+        return {
+            disabled: this.disabled,
+            max: this.max,
+            min: this.min,
+            percent: range <= 0 ? 0 : ((this.value - this.min) / range) * 100,
+            step: this.step,
+            value: this.value
+        };
+    }
+    normalizeValue(value) {
+        const clamped = clamp$2(Number.isFinite(value) ? value : this.min, this.min, this.max);
+        if (this.step <= 0)
+            return clamped;
+        const precision = Math.max(0, String(this.step).split(".")[1]?.length ?? 0);
+        return Number((Math.round((clamped - this.min) / this.step) * this.step + this.min).toFixed(precision));
+    }
+}
+
+function clamp$1(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function normalizeLineWidth(value) {
+    return clamp$1(Number.isFinite(value ?? NaN) ? Number(value) : 3, 0.5, 24);
+}
+function normalizePoint(x, y, size, pressure = 0.5) {
+    const width = Math.max(1, size.width);
+    const height = Math.max(1, size.height);
+    return {
+        pressure: clamp$1(Number.isFinite(pressure) ? pressure : 0.5, 0, 1),
+        time: Date.now(),
+        x: clamp$1(x / width, 0, 1),
+        y: clamp$1(y / height, 0, 1)
+    };
+}
+class SignatureController {
+    constructor(options = {}) {
+        this.isDrawing = false;
+        this.strokes = [];
+        this.disabled = options.disabled ?? false;
+        this.lineWidth = normalizeLineWidth(options.lineWidth);
+        this.penColor = options.penColor ?? "#111827";
+        this.readOnly = options.readOnly ?? false;
+    }
+    updateOptions(options = {}) {
+        if (options.disabled !== undefined)
+            this.disabled = options.disabled;
+        if (options.lineWidth !== undefined)
+            this.lineWidth = normalizeLineWidth(options.lineWidth);
+        if (options.penColor !== undefined)
+            this.penColor = options.penColor;
+        if (options.readOnly !== undefined)
+            this.readOnly = options.readOnly;
+        return this.getState();
+    }
+    beginStroke(x, y, size, pressure = 0.5) {
+        if (this.disabled || this.readOnly)
+            return this.getState();
+        this.isDrawing = true;
+        this.strokes.push({
+            color: this.penColor,
+            lineWidth: this.lineWidth,
+            points: [normalizePoint(x, y, size, pressure)]
+        });
+        return this.getState();
+    }
+    addPoint(x, y, size, pressure = 0.5) {
+        if (!this.isDrawing || this.disabled || this.readOnly)
+            return this.getState();
+        const stroke = this.strokes[this.strokes.length - 1];
+        if (!stroke)
+            return this.getState();
+        stroke.points.push(normalizePoint(x, y, size, pressure));
+        return this.getState();
+    }
+    endStroke() {
+        this.isDrawing = false;
+        const stroke = this.strokes[this.strokes.length - 1];
+        if (stroke && stroke.points.length === 0)
+            this.strokes.pop();
+        return this.getState();
+    }
+    clear() {
+        this.isDrawing = false;
+        this.strokes = [];
+        return this.getState();
+    }
+    undo() {
+        if (!this.disabled && !this.readOnly)
+            this.strokes.pop();
+        return this.getState();
+    }
+    replaceStrokes(strokes = []) {
+        this.strokes = strokes.map((stroke) => ({
+            color: stroke.color,
+            lineWidth: normalizeLineWidth(stroke.lineWidth),
+            points: stroke.points.map((point) => ({
+                pressure: clamp$1(point.pressure, 0, 1),
+                time: point.time,
+                x: clamp$1(point.x, 0, 1),
+                y: clamp$1(point.y, 0, 1)
+            }))
+        }));
+        this.isDrawing = false;
+        return this.getState();
+    }
+    getState() {
+        return {
+            disabled: this.disabled,
+            isDrawing: this.isDrawing,
+            isEmpty: this.strokes.length === 0,
+            lineWidth: this.lineWidth,
+            penColor: this.penColor,
+            readOnly: this.readOnly,
+            strokeCount: this.strokes.length,
+            strokes: this.strokes.map((stroke) => ({
+                color: stroke.color,
+                lineWidth: stroke.lineWidth,
+                points: stroke.points.map((point) => ({ ...point }))
+            }))
+        };
+    }
+}
+
+const DEFAULT_MIN_WIDTH = 32;
+const DEFAULT_MAX_WIDTH = 1000;
+function normalizeMinWidth(width) {
+    return Math.max(DEFAULT_MIN_WIDTH, Math.floor(Number.isFinite(width) ? Number(width) : DEFAULT_MIN_WIDTH));
+}
+function normalizeMaxWidth(width, minWidth = DEFAULT_MIN_WIDTH) {
+    return Math.max(minWidth, Math.min(DEFAULT_MAX_WIDTH, Math.floor(Number.isFinite(width) ? Number(width) : DEFAULT_MAX_WIDTH)));
+}
+function clampWidth(width, minWidth, maxWidth, fallback = minWidth) {
+    const next = Number.isFinite(width) ? Number(width) : fallback;
+    return Math.max(minWidth, Math.min(maxWidth, Math.round(next)));
+}
+class TableController {
+    constructor(options = {}) {
+        this.options = this.normalize(options);
+    }
+    update(options = {}) {
+        this.options = this.normalize({ ...this.options, ...options });
+        return this.getState();
+    }
+    resizeColumn(key, delta, containerWidth = this.options.containerWidth) {
+        if (!Number.isFinite(delta) || delta === 0)
+            return this.getState();
+        const columns = this.getNormalizedColumns();
+        const availableContainerWidth = this.getColumnContainerWidth(containerWidth);
+        const visibleIndexes = columns.map((column, index) => column.hidden ? -1 : index).filter((index) => index >= 0);
+        const targetIndex = columns.findIndex((column) => column.key === key && !column.hidden);
+        if (targetIndex < 0)
+            return this.getState();
+        const target = columns[targetIndex];
+        if (!target)
+            return this.getState();
+        const currentTotal = visibleIndexes.reduce((sum, index) => sum + (columns[index]?.width ?? 0), 0);
+        let desired = delta;
+        if (desired > 0) {
+            const targetGrow = target.maxWidth - target.width;
+            const fillGap = Math.max(0, availableContainerWidth - currentTotal);
+            const growWithoutShrink = Math.min(desired, targetGrow, fillGap);
+            target.width += growWithoutShrink;
+            desired -= growWithoutShrink;
+            if (desired > 0) {
+                const shrinkableIndexes = visibleIndexes.filter((index) => index !== targetIndex && index > targetIndex);
+                const fallbackIndexes = visibleIndexes.filter((index) => index !== targetIndex && index < targetIndex).reverse();
+                const shrinkable = [...shrinkableIndexes, ...fallbackIndexes];
+                let shrinkNeed = Math.min(desired, target.maxWidth - target.width);
+                for (const index of shrinkable) {
+                    if (shrinkNeed <= 0)
+                        break;
+                    const column = columns[index];
+                    if (!column)
+                        continue;
+                    const amount = Math.min(shrinkNeed, column.width - column.minWidth);
+                    column.width -= amount;
+                    shrinkNeed -= amount;
+                    target.width += amount;
+                }
+            }
+        }
+        else {
+            const shrink = Math.min(Math.abs(desired), target.width - target.minWidth);
+            target.width -= shrink;
+        }
+        target.autoWidth = false;
+        this.options.columns = columns;
+        return this.getState();
+    }
+    toggleColumn(key, visible, containerWidth = this.options.containerWidth) {
+        const columns = this.options.columns;
+        const target = columns.find((column) => column.key === key);
+        if (!target)
+            return this.getState();
+        const nextHidden = visible === undefined ? !target.hidden : !visible;
+        const visibleCount = columns.filter((column) => !column.hidden).length;
+        if (nextHidden && !target.hidden && visibleCount <= 1)
+            return this.getState();
+        this.options.containerWidth = this.getColumnContainerWidth(containerWidth);
+        this.options.columns = columns.map((column) => column.key === key ? { ...column, hidden: nextHidden } : column);
+        return this.getState();
+    }
+    toggleRow(key, checked) {
+        const set = new Set(this.options.selectedKeys);
+        const nextChecked = checked ?? !set.has(key);
+        if (nextChecked)
+            set.add(key);
+        else
+            set.delete(key);
+        this.options.selectedKeys = Array.from(set);
+        return this.getState();
+    }
+    toggleAllRows(checked) {
+        const keys = this.options.rows.map((row, index) => this.getRowKey(row, index));
+        const selected = new Set(this.options.selectedKeys);
+        const nextChecked = checked ?? this.getSelectionStatus(keys) !== "all";
+        keys.forEach((key) => {
+            if (nextChecked)
+                selected.add(key);
+            else
+                selected.delete(key);
+        });
+        this.options.selectedKeys = Array.from(selected);
+        return this.getState();
+    }
+    getRowKey(row, index) {
+        return this.options.getRowKey(row, index);
+    }
+    getState() {
+        const allColumns = this.getNormalizedColumns();
+        const columns = allColumns.filter((column) => !column.hidden);
+        const rowKeys = this.options.rows.map((row, index) => this.getRowKey(row, index));
+        return {
+            allColumns: allColumns.map((column) => this.toPublicColumn(column)),
+            columns: columns.map((column) => this.toPublicColumn(column)),
+            rows: [...this.options.rows],
+            selectionStatus: this.getSelectionStatus(rowKeys),
+            selectedKeys: [...this.options.selectedKeys],
+            tableWidth: columns.reduce((sum, column) => sum + column.width, 0)
+        };
+    }
+    normalize(options) {
+        return {
+            columns: (options.columns ?? []).map((column) => this.normalizeColumn(column)),
+            containerWidth: Math.max(0, Number.isFinite(options.containerWidth) ? Number(options.containerWidth) : 0),
+            getRowKey: options.getRowKey ?? ((_, index) => index),
+            rows: [...(options.rows ?? [])],
+            selectedKeys: [...(options.selectedKeys ?? [])]
+        };
+    }
+    normalizeColumn(column) {
+        const minWidth = normalizeMinWidth(column.minWidth);
+        const maxWidth = normalizeMaxWidth(column.maxWidth, minWidth);
+        const explicitWidth = Number.isFinite(column.width) || Number.isFinite(column.defaultWidth);
+        return {
+            ...column,
+            autoWidth: "autoWidth" in column ? Boolean(column.autoWidth) : !explicitWidth,
+            fixed: column.fixed === "left" || column.fixed === "right" ? column.fixed : undefined,
+            hidden: Boolean(column.hidden),
+            maxWidth,
+            minWidth,
+            width: clampWidth(column.width ?? column.defaultWidth, minWidth, maxWidth)
+        };
+    }
+    getNormalizedColumns() {
+        const columns = this.options.columns.map((column) => this.normalizeColumn(column));
+        const visibleCount = columns.filter((column) => !column.hidden).length;
+        const safeColumns = visibleCount > 0 && columns.length > 0
+            ? columns
+            : columns.map((column, index) => index === 0 ? { ...column, hidden: false } : column);
+        return this.distributeDefaultWidths(safeColumns);
+    }
+    distributeDefaultWidths(columns) {
+        const containerWidth = this.getColumnContainerWidth();
+        if (containerWidth <= 0)
+            return columns;
+        const visible = columns.filter((column) => !column.hidden);
+        const flexible = visible.filter((column) => column.autoWidth);
+        if (flexible.length === 0)
+            return this.ensureContainerFill(this.fillContainerGap(columns, containerWidth), containerWidth);
+        const fixedTotal = visible
+            .filter((column) => !flexible.includes(column))
+            .reduce((sum, column) => sum + column.width, 0);
+        const remaining = Math.max(0, containerWidth - fixedTotal);
+        const base = remaining / flexible.length;
+        let used = 0;
+        const next = columns.map((column) => {
+            if (column.hidden || !flexible.some((item) => item.key === column.key))
+                return column;
+            const width = clampWidth(base, column.minWidth, column.maxWidth, column.minWidth);
+            used += width;
+            return { ...column, width };
+        });
+        return this.ensureContainerFill(this.fillContainerGap(next, containerWidth, fixedTotal + used), containerWidth);
+    }
+    fillContainerGap(columns, containerWidth, knownTotal) {
+        const next = columns.map((column) => ({ ...column }));
+        const total = knownTotal ?? next.filter((column) => !column.hidden).reduce((sum, column) => sum + column.width, 0);
+        let gap = containerWidth - total;
+        if (gap === 0)
+            return next;
+        const visibleIndexes = next
+            .map((column, index) => column.hidden ? -1 : index)
+            .filter((index) => index >= 0)
+            .reverse();
+        if (gap > 0 && visibleIndexes.length > 0) {
+            const base = Math.floor(gap / visibleIndexes.length);
+            let remainder = gap - base * visibleIndexes.length;
+            for (const index of visibleIndexes) {
+                const column = next[index];
+                if (!column)
+                    continue;
+                const extra = base + (remainder > 0 ? 1 : 0);
+                column.width += extra;
+                remainder -= remainder > 0 ? 1 : 0;
+            }
+            return next;
+        }
+        for (const index of visibleIndexes) {
+            if (gap === 0)
+                break;
+            const column = next[index];
+            if (!column)
+                continue;
+            const delta = Math.min(Math.abs(gap), column.width - column.minWidth);
+            column.width -= delta;
+            gap += delta;
+        }
+        return next;
+    }
+    ensureContainerFill(columns, containerWidth) {
+        if (containerWidth <= 0)
+            return columns;
+        const visibleIndexes = columns.map((column, index) => column.hidden ? -1 : index).filter((index) => index >= 0);
+        if (visibleIndexes.length === 0)
+            return columns;
+        const total = visibleIndexes.reduce((sum, index) => sum + (columns[index]?.width ?? 0), 0);
+        const gap = Math.ceil(containerWidth - total);
+        if (gap <= 0)
+            return columns;
+        const next = columns.map((column) => ({ ...column }));
+        const base = Math.floor(gap / visibleIndexes.length);
+        let remainder = gap - base * visibleIndexes.length;
+        for (const index of visibleIndexes) {
+            const column = next[index];
+            if (!column)
+                continue;
+            const extra = base + (remainder > 0 ? 1 : 0);
+            column.width += extra;
+            remainder -= remainder > 0 ? 1 : 0;
+        }
+        return next;
+    }
+    getColumnContainerWidth(containerWidth = this.options.containerWidth) {
+        return Math.max(0, containerWidth);
+    }
+    toPublicColumn(column) {
+        const publicColumn = { ...column };
+        delete publicColumn.autoWidth;
+        return publicColumn;
+    }
+    getSelectionStatus(keys) {
+        if (keys.length === 0)
+            return "none";
+        const selected = new Set(this.options.selectedKeys);
+        const selectedCount = keys.filter((key) => selected.has(key)).length;
+        if (selectedCount === 0)
+            return "none";
+        if (selectedCount === keys.length)
+            return "all";
+        return "partial";
+    }
+}
+
+class UploadController {
+    constructor(options = {}) {
+        this.files = [];
+        this.options = options;
+    }
+    updateOptions(options = {}) {
+        this.options = options;
+        return this.getState();
+    }
+    addFiles(files) {
+        const next = files
+            .filter((file) => !this.options.maxSize || file.size <= this.options.maxSize)
+            .map((file) => ({ file, id: `${file.name}-${file.size}-${file.lastModified}-${Math.random().toString(36).slice(2)}`, name: file.name, size: file.size, status: "ready" }));
+        this.files = this.options.multiple ? [...this.files, ...next] : next.slice(0, 1);
+        return this.getState();
+    }
+    remove(id) {
+        this.files = this.files.filter((file) => file.id !== id);
+        return this.getState();
+    }
+    replaceFiles(files = []) {
+        this.files = this.options.multiple ? files.map((file) => ({ ...file })) : files.slice(0, 1).map((file) => ({ ...file }));
+        return this.getState();
+    }
+    clear() {
+        this.files = [];
+        return this.getState();
+    }
+    getState() {
+        return { files: this.files.map((file) => ({ ...file })) };
+    }
+}
+
+function now() {
+    return Date.now();
+}
+function resolveDirection(deltaX, deltaY, threshold) {
+    if (Math.abs(deltaX) < threshold && Math.abs(deltaY) < threshold)
+        return "none";
+    if (Math.abs(deltaX) > Math.abs(deltaY))
+        return deltaX > 0 ? "right" : "left";
+    return deltaY > 0 ? "down" : "up";
+}
+class GestureController {
+    constructor(options = {}) {
+        this.current = { x: 0, y: 0, time: 0 };
+        this.previous = { x: 0, y: 0, time: 0 };
+        this.startPoint = { x: 0, y: 0, time: 0 };
+        this.active = false;
+        this.threshold = Math.max(0, options.threshold ?? 4);
+    }
+    start(point) {
+        const time = point.time ?? now();
+        this.active = true;
+        this.startPoint = { ...point, time };
+        this.previous = this.startPoint;
+        this.current = this.startPoint;
+        return this.getState();
+    }
+    move(point) {
+        if (!this.active)
+            return this.getState();
+        this.previous = this.current;
+        this.current = { ...point, time: point.time ?? now() };
+        return this.getState();
+    }
+    end(point) {
+        if (point)
+            this.move(point);
+        const state = this.getState();
+        this.active = false;
+        return { ...state, active: false };
+    }
+    getState() {
+        const deltaX = this.current.x - this.startPoint.x;
+        const deltaY = this.current.y - this.startPoint.y;
+        const frameTime = Math.max(1, (this.current.time ?? 0) - (this.previous.time ?? 0));
+        return {
+            active: this.active,
+            direction: resolveDirection(deltaX, deltaY, this.threshold),
+            distance: Math.hypot(deltaX, deltaY),
+            duration: Math.max(0, (this.current.time ?? 0) - (this.startPoint.time ?? 0)),
+            startX: this.startPoint.x,
+            startY: this.startPoint.y,
+            velocityX: ((this.current.x - this.previous.x) / frameTime) * 1000,
+            velocityY: ((this.current.y - this.previous.y) / frameTime) * 1000,
+            x: deltaX,
+            y: deltaY
+        };
+    }
+}
+
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+class DragController {
+    constructor(options = {}) {
+        this.dragOffset = { x: 0, y: 0 };
+        this.axis = options.axis ?? "xy";
+        this.bounds = options.bounds;
+        this.disabled = options.disabled ?? false;
+        this.position = options.initialPosition ?? { x: 0, y: 0 };
+        this.restrictToBounds = options.restrictToBounds ?? true;
+        this.gesture = new GestureController({ threshold: options.threshold ?? 2 });
+    }
+    updateOptions(options) {
+        if (options.axis !== undefined)
+            this.axis = options.axis;
+        if (options.bounds !== undefined)
+            this.bounds = options.bounds;
+        if (options.disabled !== undefined)
+            this.disabled = options.disabled;
+        if (options.initialPosition !== undefined && !this.getState().dragging)
+            this.position = options.initialPosition;
+        if (options.restrictToBounds !== undefined)
+            this.restrictToBounds = options.restrictToBounds;
+        return this.getState();
+    }
+    start(point, elementPosition = this.position) {
+        if (this.disabled)
+            return this.getState();
+        this.position = this.clampPosition(elementPosition);
+        this.dragOffset = { x: point.x - this.position.x, y: point.y - this.position.y };
+        this.gesture.start(point);
+        return this.getState();
+    }
+    move(point) {
+        if (!this.gesture.getState().active || this.disabled)
+            return this.getState();
+        this.gesture.move(point);
+        const nextPosition = {
+            x: this.axis === "y" ? this.position.x : point.x - this.dragOffset.x,
+            y: this.axis === "x" ? this.position.y : point.y - this.dragOffset.y
+        };
+        this.position = this.clampPosition(nextPosition);
+        return this.getState();
+    }
+    end(point) {
+        if (point)
+            this.move(point);
+        this.gesture.end();
+        return this.getState();
+    }
+    setPosition(position) {
+        this.position = this.clampPosition(position);
+        return this.getState();
+    }
+    isOverTarget(source, target) {
+        if (!target)
+            return false;
+        return source.x < target.x + target.width
+            && source.x + source.width > target.x
+            && source.y < target.y + target.height
+            && source.y + source.height > target.y;
+    }
+    getState() {
+        return {
+            dragging: this.gesture.getState().active,
+            gesture: this.gesture.getState(),
+            position: this.position
+        };
+    }
+    clampPosition(position) {
+        if (!this.bounds || !this.restrictToBounds)
+            return position;
+        return {
+            x: clamp(position.x, 0, Math.max(0, this.bounds.width)),
+            y: clamp(position.y, 0, Math.max(0, this.bounds.height))
+        };
+    }
+}
+
+class DropController {
+    constructor(items = []) {
+        this.items = items;
+    }
+    updateItems(items) {
+        this.items = items;
+        return this.getState();
+    }
+    start(id) {
+        const item = this.items.find((entry) => entry.id === id);
+        if (!item || item.disabled)
+            return this.getState();
+        this.draggingId = id;
+        this.overIndex = this.items.findIndex((entry) => entry.id === id);
+        return this.getState();
+    }
+    moveToIndex(index) {
+        if (!this.draggingId)
+            return this.getState();
+        this.overIndex = Math.max(0, Math.min(index, this.items.length - 1));
+        return this.getState();
+    }
+    end() {
+        if (!this.draggingId || this.overIndex === undefined) {
+            this.draggingId = undefined;
+            this.overIndex = undefined;
+            return this.getState();
+        }
+        const fromIndex = this.items.findIndex((item) => item.id === this.draggingId);
+        const toIndex = this.overIndex;
+        if (fromIndex >= 0 && toIndex >= 0 && fromIndex !== toIndex) {
+            const next = [...this.items];
+            const [moving] = next.splice(fromIndex, 1);
+            if (moving)
+                next.splice(toIndex, 0, moving);
+            this.items = next;
+        }
+        this.draggingId = undefined;
+        this.overIndex = undefined;
+        return this.getState();
+    }
+    cancel() {
+        this.draggingId = undefined;
+        this.overIndex = undefined;
+        return this.getState();
+    }
+    getState() {
+        return {
+            draggingId: this.draggingId,
+            items: this.items,
+            overIndex: this.overIndex
+        };
+    }
+}
+
+class ComicReaderController {
+    constructor(options) {
+        this.pages = [...options.pages];
+        this.current = this.clamp(options.current ?? 0);
+        this.hasMore = options.hasMore ?? false;
+        this.loading = options.loading ?? false;
+    }
+    update(options) {
+        if (options.pages)
+            this.pages = [...options.pages];
+        if (typeof options.current === "number")
+            this.current = this.clamp(options.current);
+        else
+            this.current = this.clamp(this.current);
+        if (typeof options.hasMore === "boolean")
+            this.hasMore = options.hasMore;
+        if (typeof options.loading === "boolean")
+            this.loading = options.loading;
+        return this.getState();
+    }
+    append(pages, hasMore = this.hasMore) {
+        const existed = new Set(this.pages.map((item) => item.id));
+        this.pages = [...this.pages, ...pages.filter((item) => !existed.has(item.id))];
+        this.hasMore = hasMore;
+        this.loading = false;
+        return this.getState();
+    }
+    setLoading(loading) {
+        this.loading = loading;
+        return this.getState();
+    }
+    next() {
+        this.current = this.clamp(this.current + 1);
+        return this.getState();
+    }
+    previous() {
+        this.current = this.clamp(this.current - 1);
+        return this.getState();
+    }
+    goTo(index) {
+        this.current = this.clamp(index);
+        return this.getState();
+    }
+    getState() {
+        const total = this.pages.length;
+        return {
+            canNext: this.current < total - 1,
+            canPrevious: this.current > 0,
+            current: this.current,
+            hasMore: this.hasMore,
+            loading: this.loading,
+            page: this.pages[this.current] ?? null,
+            pages: [...this.pages],
+            total
+        };
+    }
+    clamp(index) {
+        if (this.pages.length === 0)
+            return 0;
+        return Math.min(Math.max(0, Math.trunc(index)), this.pages.length - 1);
+    }
+}
+
+class DanmakuController {
+    constructor(items = [], options = {}) {
+        this.trackCursor = 0;
+        this.maxTracks = Math.max(1, Math.trunc(options.maxTracks ?? 6));
+        this.defaultDuration = Math.max(1000, options.defaultDuration ?? 7600);
+        this.defaultSpeed = this.normalizeSpeed(options.speed);
+        this.defaultColor = options.color ?? "#ffffff";
+        this.enabled = options.enabled ?? true;
+        this.items = items.map((item) => this.normalize(item));
+    }
+    update(items, options = {}) {
+        this.maxTracks = Math.max(1, Math.trunc(options.maxTracks ?? this.maxTracks));
+        this.defaultDuration = Math.max(1000, options.defaultDuration ?? this.defaultDuration);
+        this.defaultSpeed = typeof options.speed === "number" ? this.normalizeSpeed(options.speed) : this.defaultSpeed;
+        this.defaultColor = options.color ?? this.defaultColor;
+        this.enabled = options.enabled ?? this.enabled;
+        this.items = items.map((item) => this.normalize(item));
+        return this.getState();
+    }
+    add(item) {
+        this.items = [...this.items, this.normalize({ ...item, id: item.id ?? `danmaku-${Date.now()}-${this.items.length}` })];
+        return this.getState();
+    }
+    remove(id) {
+        this.items = this.items.filter((item) => item.id !== id);
+        return this.getState();
+    }
+    getState() {
+        return { enabled: this.enabled, items: this.enabled ? [...this.items] : [], maxTracks: this.maxTracks };
+    }
+    normalize(item) {
+        const track = item.track ?? this.trackCursor;
+        this.trackCursor = (track + 1) % this.maxTracks;
+        return {
+            ...item,
+            color: item.color ?? this.defaultColor,
+            duration: this.resolveDuration(item),
+            track: Math.min(Math.max(0, track), this.maxTracks - 1),
+            type: item.type ?? (item.imageSrc ? "image" : item.icon ? "icon" : "text")
+        };
+    }
+    normalizeSpeed(speed) {
+        if (typeof speed !== "number" || !Number.isFinite(speed))
+            return undefined;
+        return Math.min(Math.max(speed, 24), 800);
+    }
+    resolveDuration(item) {
+        if (typeof item.duration === "number" && Number.isFinite(item.duration))
+            return Math.max(1000, item.duration);
+        const speed = this.normalizeSpeed(item.speed) ?? this.defaultSpeed;
+        if (!speed)
+            return this.defaultDuration;
+        return Math.round(Math.min(Math.max(900000 / speed, 1000), 30000));
+    }
+}
+
+class LiveRoomController {
+    constructor(options) {
+        this.state = {
+            chats: [...(options.chats ?? [])],
+            danmaku: [...(options.danmaku ?? [])],
+            favorited: options.favorited ?? false,
+            host: options.host,
+            liked: options.liked ?? false,
+            likeCount: Math.max(0, options.likeCount ?? 0)
+        };
+    }
+    update(options) {
+        this.state = {
+            chats: options.chats ? [...options.chats] : this.state.chats,
+            danmaku: options.danmaku ? [...options.danmaku] : this.state.danmaku,
+            favorited: options.favorited ?? this.state.favorited,
+            host: options.host ?? this.state.host,
+            liked: options.liked ?? this.state.liked,
+            likeCount: Math.max(0, options.likeCount ?? this.state.likeCount)
+        };
+        return this.getState();
+    }
+    addChat(message) {
+        this.state = { ...this.state, chats: [...this.state.chats, message] };
+        return this.getState();
+    }
+    addDanmaku(item) {
+        this.state = { ...this.state, danmaku: [...this.state.danmaku, item] };
+        return this.getState();
+    }
+    toggleFavorite() {
+        this.state = { ...this.state, favorited: !this.state.favorited };
+        return this.getState();
+    }
+    toggleLike() {
+        const liked = !this.state.liked;
+        this.state = { ...this.state, liked, likeCount: Math.max(0, this.state.likeCount + (liked ? 1 : -1)) };
+        return this.getState();
+    }
+    getState() {
+        return {
+            ...this.state,
+            chats: [...this.state.chats],
+            danmaku: [...this.state.danmaku],
+            host: { ...this.state.host }
+        };
+    }
+}
+
+class NovelReaderController {
+    constructor(options) {
+        this.pages = [...options.pages];
+        this.loop = options.loop ?? false;
+        this.current = this.clamp(options.current ?? 0);
+    }
+    update(options) {
+        if (options.pages)
+            this.pages = [...options.pages];
+        if (typeof options.loop === "boolean")
+            this.loop = options.loop;
+        if (typeof options.current === "number")
+            this.current = this.clamp(options.current);
+        else
+            this.current = this.clamp(this.current);
+        return this.getState();
+    }
+    next() {
+        this.current = this.loop && this.current >= this.pages.length - 1 ? 0 : this.clamp(this.current + 1);
+        return this.getState();
+    }
+    previous() {
+        this.current = this.loop && this.current <= 0 ? this.pages.length - 1 : this.clamp(this.current - 1);
+        return this.getState();
+    }
+    goTo(index) {
+        this.current = this.clamp(index);
+        return this.getState();
+    }
+    getTurnMetrics(input) {
+        const width = Math.max(1, input.width);
+        const deltaX = Number.isFinite(input.deltaX)
+            ? input.deltaX
+            : input.pointerX != null && input.startX != null
+                ? input.pointerX - input.startX
+                : 0;
+        const direction = deltaX < 0 ? "next" : "previous";
+        const distance = Math.abs(deltaX);
+        const raw = distance / (width * 0.74);
+        const progress = input.canTurn
+            ? Math.min(0.995, this.easeOutCubic(raw))
+            : Math.min(0.2, raw * 0.28);
+        const signed = direction === "previous" ? 1 : -1;
+        const curl = Math.sin(progress * Math.PI);
+        const softness = Math.sin(Math.min(1, progress) * Math.PI * 0.72);
+        const angle = signed * (2 + progress * 162 - curl * 10);
+        const foldTranslate = 58 - progress * 92;
+        const shadowTranslate = 22 - progress * 22;
+        return {
+            angle,
+            canTurn: input.canTurn,
+            clipEnd: 4 + progress * 13,
+            clipStart: progress * 12,
+            curl,
+            direction,
+            dragX: signed * Math.min(18, distance * 0.035),
+            foldOpacity: Math.min(0.96, 0.16 + progress * 0.76 + curl * 0.12),
+            foldScale: 0.36 + progress * 0.98 + softness * 0.08,
+            foldSkew: signed * (8 + progress * 16 + curl * 5),
+            foldTranslate,
+            nextOpacity: Math.min(1, 0.42 + progress * 0.58),
+            pageOpacity: Math.max(0.3, 1 - progress * 0.28),
+            progress,
+            release: input.canTurn && progress >= NovelReaderController.releaseThreshold,
+            shadowOpacity: Math.min(0.62, 0.1 + progress * 0.38 + curl * 0.18),
+            shadowScale: 0.76 + progress * 0.48,
+            shadowTranslate,
+            skew: signed * (progress * 3.2 + curl * 3.8),
+            translate: signed * (progress * 8 + curl * 3)
+        };
+    }
+    getState() {
+        const total = this.pages.length;
+        return {
+            canNext: this.loop ? total > 1 : this.current < total - 1,
+            canPrevious: this.loop ? total > 1 : this.current > 0,
+            current: this.current,
+            page: this.pages[this.current] ?? null,
+            total
+        };
+    }
+    clamp(index) {
+        if (this.pages.length === 0)
+            return 0;
+        return Math.min(Math.max(0, Math.trunc(index)), this.pages.length - 1);
+    }
+    easeOutCubic(value) {
+        const clamped = Math.min(Math.max(value, 0), 1);
+        return 1 - Math.pow(1 - clamped, 3);
+    }
+}
+NovelReaderController.releaseThreshold = 0.32;
+
+const DEFAULT_OVERSCAN$1 = 4;
+class VirtualListController {
+    constructor(options) {
+        this.measuredSizes = new Map();
+        this.offsets = [];
+        this.totalSize = 0;
+        this.count = Math.max(0, Math.floor(options.count));
+        this.estimateSize = options.estimateSize;
+        this.overscanBefore = Math.max(0, Math.floor(options.overscanBefore ?? options.overscan ?? DEFAULT_OVERSCAN$1));
+        this.overscanAfter = Math.max(0, Math.floor(options.overscanAfter ?? options.overscan ?? DEFAULT_OVERSCAN$1));
+        this.pullUpThreshold = Math.max(0, Math.floor(options.pullUpThreshold ?? 48));
+        this.recalculate();
+    }
+    updateOptions(options) {
+        if (options.count !== undefined) {
+            const nextCount = Math.max(0, Math.floor(options.count));
+            if (nextCount < this.count) {
+                Array.from(this.measuredSizes.keys()).forEach((index) => {
+                    if (index >= nextCount)
+                        this.measuredSizes.delete(index);
+                });
+            }
+            this.count = nextCount;
+        }
+        if (options.estimateSize !== undefined) {
+            this.estimateSize = options.estimateSize;
+        }
+        if (options.overscan !== undefined || options.overscanBefore !== undefined) {
+            this.overscanBefore = Math.max(0, Math.floor(options.overscanBefore ?? options.overscan ?? this.overscanBefore));
+        }
+        if (options.overscan !== undefined || options.overscanAfter !== undefined) {
+            this.overscanAfter = Math.max(0, Math.floor(options.overscanAfter ?? options.overscan ?? this.overscanAfter));
+        }
+        if (options.pullUpThreshold !== undefined) {
+            this.pullUpThreshold = Math.max(0, Math.floor(options.pullUpThreshold));
+        }
+        this.recalculate();
+    }
+    getState() {
+        return {
+            count: this.count,
+            estimateSize: this.estimateSize,
+            measuredCount: this.measuredSizes.size,
+            overscan: Math.max(this.overscanBefore, this.overscanAfter),
+            pullUpThreshold: this.pullUpThreshold
+        };
+    }
+    getTotalSize() {
+        return this.totalSize;
+    }
+    shouldTriggerPullUp(scrollOffset, viewportSize) {
+        return scrollOffset + Math.max(0, viewportSize) >= this.totalSize - this.pullUpThreshold;
+    }
+    getItem(index) {
+        const safeIndex = this.clampIndex(index);
+        const start = this.offsets[safeIndex] ?? 0;
+        const size = this.getSize(safeIndex);
+        return {
+            end: start + size,
+            index: safeIndex,
+            key: String(safeIndex),
+            size,
+            start
+        };
+    }
+    getRange(scrollOffset, viewportSize) {
+        if (this.count === 0) {
+            return {
+                endIndex: -1,
+                items: [],
+                offsetAfter: 0,
+                offsetBefore: 0,
+                startIndex: 0,
+                totalSize: 0
+            };
+        }
+        const safeViewportSize = Math.max(0, viewportSize);
+        const maxScrollOffset = Math.max(0, this.totalSize - safeViewportSize);
+        const safeScrollOffset = Math.min(Math.max(0, scrollOffset), maxScrollOffset);
+        const visibleStart = this.findNearestIndex(safeScrollOffset);
+        const visibleEnd = this.findNearestIndex(safeScrollOffset + safeViewportSize);
+        const startIndex = Math.max(0, visibleStart - this.overscanBefore);
+        const endIndex = Math.min(this.count - 1, visibleEnd + this.overscanAfter);
+        const items = this.getItems(startIndex, endIndex);
+        const offsetBefore = this.offsets[startIndex] ?? 0;
+        const lastItem = items[items.length - 1];
+        const offsetAfter = Math.max(0, this.totalSize - (lastItem?.end ?? 0));
+        return {
+            endIndex,
+            items,
+            offsetAfter,
+            offsetBefore,
+            startIndex,
+            totalSize: this.totalSize
+        };
+    }
+    measure(index, size) {
+        if (index < 0 || index >= this.count || !Number.isFinite(size) || size <= 0)
+            return false;
+        const normalizedSize = Math.round(size);
+        if (this.measuredSizes.get(index) === normalizedSize)
+            return false;
+        this.measuredSizes.set(index, normalizedSize);
+        this.recalculate();
+        return true;
+    }
+    resetMeasurements() {
+        this.measuredSizes.clear();
+        this.recalculate();
+    }
+    shiftMeasurements(offset) {
+        if (offset === 0 || this.measuredSizes.size === 0)
+            return;
+        const nextMeasurements = new Map();
+        this.measuredSizes.forEach((size, index) => {
+            const nextIndex = index + offset;
+            if (nextIndex >= 0 && nextIndex < this.count)
+                nextMeasurements.set(nextIndex, size);
+        });
+        this.measuredSizes = nextMeasurements;
+        this.recalculate();
+    }
+    scrollToIndex(index, align = "start", viewportSize = 0) {
+        if (this.count === 0)
+            return 0;
+        const item = this.getItem(index);
+        if (align === "center")
+            return Math.max(0, item.start - viewportSize / 2 + item.size / 2);
+        if (align === "end")
+            return Math.max(0, item.end - viewportSize);
+        return item.start;
+    }
+    getItems(startIndex, endIndex) {
+        const items = [];
+        for (let index = startIndex; index <= endIndex; index += 1) {
+            items.push(this.getItem(index));
+        }
+        return items;
+    }
+    getSize(index) {
+        return this.measuredSizes.get(index) ?? this.getEstimatedSize(index);
+    }
+    getEstimatedSize(index) {
+        const size = typeof this.estimateSize === "function" ? this.estimateSize(index) : this.estimateSize;
+        return Math.max(1, Number.isFinite(size) ? Math.round(size) : 1);
+    }
+    recalculate() {
+        this.offsets = new Array(this.count);
+        let offset = 0;
+        for (let index = 0; index < this.count; index += 1) {
+            this.offsets[index] = offset;
+            offset += this.getSize(index);
+        }
+        this.totalSize = offset;
+    }
+    findNearestIndex(offset) {
+        if (offset <= 0)
+            return 0;
+        if (offset >= this.totalSize)
+            return Math.max(0, this.count - 1);
+        let low = 0;
+        let high = this.count - 1;
+        let nearest = this.count - 1;
+        while (low <= high) {
+            const middle = Math.floor((low + high) / 2);
+            const start = this.offsets[middle] ?? 0;
+            const end = start + this.getSize(middle);
+            if (offset >= end) {
+                low = middle + 1;
+            }
+            else {
+                nearest = middle;
+                high = middle - 1;
+            }
+        }
+        return this.clampIndex(nearest);
+    }
+    clampIndex(index) {
+        return Math.min(Math.max(0, Math.floor(index)), Math.max(0, this.count - 1));
+    }
+}
+
+class ChatVirtualListController {
+    constructor(options = {}) {
+        this.bottomThreshold = Math.max(0, options.bottomThreshold ?? 48);
+        this.topThreshold = Math.max(0, options.topThreshold ?? 80);
+    }
+    updateOptions(options) {
+        if (options.bottomThreshold !== undefined) {
+            this.bottomThreshold = Math.max(0, options.bottomThreshold);
+        }
+        if (options.topThreshold !== undefined) {
+            this.topThreshold = Math.max(0, options.topThreshold);
+        }
+    }
+    isNearBottom(scrollTop, viewportHeight, totalSize, scrollHeight = totalSize) {
+        return (Math.max(totalSize, scrollHeight) - scrollTop - viewportHeight <=
+            this.bottomThreshold);
+    }
+    isNearTop(scrollTop) {
+        return scrollTop <= this.topThreshold;
+    }
+    getBottomScrollTop(totalSize, viewportHeight, scrollHeight = totalSize) {
+        return Math.max(0, totalSize - viewportHeight, scrollHeight - viewportHeight);
+    }
+    getPrependCompensatedScrollTop(previousScrollTop, previousTotalSize, nextTotalSize) {
+        return Math.max(0, previousScrollTop + Math.max(0, nextTotalSize - previousTotalSize));
+    }
+    detectPrependCount(previousKeys, nextKeys) {
+        if (previousKeys.length === 0 || nextKeys.length === 0)
+            return 0;
+        const firstPreviousKey = previousKeys[0];
+        const index = nextKeys.findIndex((key) => Object.is(key, firstPreviousKey));
+        return index > 0 ? index : 0;
+    }
+    detectAppendCount(previousKeys, nextKeys) {
+        if (previousKeys.length === 0 || nextKeys.length <= previousKeys.length)
+            return 0;
+        const previousKeysStillPrefix = previousKeys.every((key, index) => Object.is(key, nextKeys[index]));
+        return previousKeysStillPrefix ? nextKeys.length - previousKeys.length : 0;
+    }
+}
+
+const DEFAULT_GAP = 16;
+const DEFAULT_MIN_COLUMN_WIDTH = 220;
+const DEFAULT_OVERSCAN = 320;
+class MasonryVirtualListController {
+    constructor(options) {
+        this.measuredSizes = new Map();
+        this.items = [];
+        this.totalSize = 0;
+        this.resolvedColumns = 1;
+        this.columnWidth = 0;
+        this.columns = this.normalizeOptionalCount(options.columns);
+        this.containerWidth = Math.max(0, options.containerWidth);
+        this.count = Math.max(0, Math.floor(options.count));
+        this.estimateSize = options.estimateSize;
+        this.gap = Math.max(0, options.gap ?? DEFAULT_GAP);
+        this.minColumnWidth = Math.max(1, options.minColumnWidth ?? DEFAULT_MIN_COLUMN_WIDTH);
+        this.overscan = Math.max(0, options.overscan ?? DEFAULT_OVERSCAN);
+        this.recalculate();
+    }
+    updateOptions(options) {
+        if (options.columns !== undefined) {
+            this.columns = this.normalizeOptionalCount(options.columns);
+        }
+        if (options.containerWidth !== undefined) {
+            this.containerWidth = Math.max(0, options.containerWidth);
+        }
+        if (options.count !== undefined) {
+            const nextCount = Math.max(0, Math.floor(options.count));
+            if (nextCount < this.count) {
+                Array.from(this.measuredSizes.keys()).forEach((index) => {
+                    if (index >= nextCount)
+                        this.measuredSizes.delete(index);
+                });
+            }
+            this.count = nextCount;
+        }
+        if (options.estimateSize !== undefined) {
+            this.estimateSize = options.estimateSize;
+        }
+        if (options.gap !== undefined) {
+            this.gap = Math.max(0, options.gap);
+        }
+        if (options.minColumnWidth !== undefined) {
+            this.minColumnWidth = Math.max(1, options.minColumnWidth);
+        }
+        if (options.overscan !== undefined) {
+            this.overscan = Math.max(0, options.overscan);
+        }
+        this.recalculate();
+    }
+    getState() {
+        return {
+            columnWidth: this.columnWidth,
+            columns: this.resolvedColumns,
+            count: this.count,
+            gap: this.gap,
+            measuredCount: this.measuredSizes.size,
+            overscan: this.overscan
+        };
+    }
+    getTotalSize() {
+        return this.totalSize;
+    }
+    getItem(index) {
+        const safeIndex = this.clampIndex(index);
+        return this.items[safeIndex] ?? this.createFallbackItem(safeIndex);
+    }
+    getRange(scrollOffset, viewportSize) {
+        if (this.count === 0) {
+            return {
+                columnWidth: this.columnWidth,
+                columns: this.resolvedColumns,
+                endIndex: -1,
+                items: [],
+                startIndex: 0,
+                totalSize: 0
+            };
+        }
+        const safeViewportSize = Math.max(0, viewportSize);
+        const maxScrollOffset = Math.max(0, this.totalSize - safeViewportSize);
+        const safeScrollOffset = Math.min(Math.max(0, scrollOffset), maxScrollOffset);
+        const rangeStart = Math.max(0, safeScrollOffset - this.overscan);
+        const rangeEnd = safeScrollOffset + safeViewportSize + this.overscan;
+        const items = this.items.filter((item) => item.end >= rangeStart && item.start <= rangeEnd);
+        return {
+            columnWidth: this.columnWidth,
+            columns: this.resolvedColumns,
+            endIndex: items[items.length - 1]?.index ?? -1,
+            items,
+            startIndex: items[0]?.index ?? 0,
+            totalSize: this.totalSize
+        };
+    }
+    measure(index, size) {
+        if (index < 0 || index >= this.count || !Number.isFinite(size) || size <= 0)
+            return false;
+        const normalizedSize = Math.round(size);
+        if (this.measuredSizes.get(index) === normalizedSize)
+            return false;
+        this.measuredSizes.set(index, normalizedSize);
+        this.recalculate();
+        return true;
+    }
+    resetMeasurements() {
+        this.measuredSizes.clear();
+        this.recalculate();
+    }
+    recalculate() {
+        this.resolvedColumns = this.resolveColumns();
+        this.columnWidth =
+            this.resolvedColumns <= 1
+                ? Math.max(0, this.containerWidth)
+                : Math.max(1, (this.containerWidth - this.gap * (this.resolvedColumns - 1)) / this.resolvedColumns);
+        const columnHeights = new Array(this.resolvedColumns).fill(0);
+        this.items = new Array(this.count);
+        for (let index = 0; index < this.count; index += 1) {
+            const column = this.findShortestColumn(columnHeights);
+            const x = column * (this.columnWidth + this.gap);
+            const y = columnHeights[column] ?? 0;
+            const height = this.getSize(index);
+            this.items[index] = {
+                column,
+                end: y + height,
+                height,
+                index,
+                key: String(index),
+                start: y,
+                width: this.columnWidth,
+                x,
+                y
+            };
+            columnHeights[column] = y + height + this.gap;
+        }
+        this.totalSize = Math.max(0, ...columnHeights.map((height) => Math.max(0, height - this.gap)));
+    }
+    resolveColumns() {
+        if (this.columns !== undefined)
+            return Math.max(1, this.columns);
+        if (this.containerWidth <= 0)
+            return 1;
+        return Math.max(1, Math.floor((this.containerWidth + this.gap) / (this.minColumnWidth + this.gap)));
+    }
+    getSize(index) {
+        return this.measuredSizes.get(index) ?? this.getEstimatedSize(index);
+    }
+    getEstimatedSize(index) {
+        const size = typeof this.estimateSize === "function"
+            ? this.estimateSize(index, this.columnWidth)
+            : this.estimateSize;
+        return Math.max(1, Number.isFinite(size) ? Math.round(size) : 1);
+    }
+    findShortestColumn(columnHeights) {
+        let column = 0;
+        let minHeight = columnHeights[0] ?? 0;
+        for (let index = 1; index < columnHeights.length; index += 1) {
+            const height = columnHeights[index] ?? 0;
+            if (height < minHeight) {
+                column = index;
+                minHeight = height;
+            }
+        }
+        return column;
+    }
+    createFallbackItem(index) {
+        return {
+            column: 0,
+            end: 0,
+            height: 0,
+            index,
+            key: String(index),
+            start: 0,
+            width: this.columnWidth,
+            x: 0,
+            y: 0
+        };
+    }
+    normalizeOptionalCount(value) {
+        if (value === undefined)
+            return undefined;
+        return Math.max(1, Math.floor(value));
+    }
+    clampIndex(index) {
+        return Math.min(Math.max(0, Math.floor(index)), Math.max(0, this.count - 1));
+    }
+}
+
+exports.AffixController = AffixController;
+exports.BacktopController = BacktopController;
+exports.BadgeController = BadgeController;
+exports.BreadcrumbController = BreadcrumbController;
+exports.CalendarController = CalendarController;
+exports.CanvasEditorController = CanvasEditorController;
+exports.CanvasImageController = CanvasImageController;
+exports.ChatVirtualListController = ChatVirtualListController;
+exports.ColorPickerController = ColorPickerController;
+exports.ComicReaderController = ComicReaderController;
+exports.CountdownController = CountdownController;
+exports.DanmakuController = DanmakuController;
+exports.DatePickerController = DatePickerController;
+exports.DateRangePickerController = DateRangePickerController;
+exports.DesignEffectController = DesignEffectController;
+exports.DragController = DragController;
+exports.DropController = DropController;
+exports.FieldController = FieldController;
+exports.FilePreviewController = FilePreviewController;
+exports.FloatingBallController = FloatingBallController;
+exports.FormController = FormController;
+exports.GestureController = GestureController;
+exports.GradientTextController = GradientTextController;
+exports.ImagePreviewController = ImagePreviewController;
+exports.LazyImageController = LazyImageController;
+exports.LiveRoomController = LiveRoomController;
+exports.MarqueeController = MarqueeController;
+exports.MasonryVirtualListController = MasonryVirtualListController;
+exports.ModalController = ModalController;
+exports.MultiColumnPickerController = MultiColumnPickerController;
+exports.NovelReaderController = NovelReaderController;
+exports.PaginationController = PaginationController;
+exports.PasswordInputController = PasswordInputController;
+exports.PopupController = PopupController;
+exports.ProgressController = ProgressController;
+exports.RollingNumberController = RollingNumberController;
+exports.SignatureController = SignatureController;
+exports.SkeletonController = SkeletonController;
+exports.SlideCaptchaController = SlideCaptchaController;
+exports.StateEmitter = StateEmitter;
+exports.SwiperController = SwiperController;
+exports.TableController = TableController;
+exports.TabsController = TabsController;
+exports.TagController = TagController;
+exports.TiltCardController = TiltCardController;
+exports.TimelineController = TimelineController;
+exports.ToastManager = ToastManager;
+exports.TooltipController = TooltipController;
+exports.TypewriterTextController = TypewriterTextController;
+exports.UploadController = UploadController;
+exports.VerificationCodeController = VerificationCodeController;
+exports.VideoDetailTransitionController = VideoDetailTransitionController;
+exports.VideoPlayerController = VideoPlayerController;
+exports.VirtualListController = VirtualListController;
+exports.VirtualSelectController = VirtualSelectController;
+exports.cloneValues = cloneValues;
+exports.configureClassComponents = configureClassComponents;
+exports.getByPath = getByPath;
+exports.getClassComponentsConfig = getClassComponentsConfig;
+exports.getClassComponentsLocale = getClassComponentsLocale;
+exports.getSafeTooltipPlacement = getSafeTooltipPlacement;
+exports.resetClassComponentsConfig = resetClassComponentsConfig;
+exports.setByPath = setByPath;
+//# sourceMappingURL=index.cjs.map