@geektech/one 0.0.1 → 0.1.0

package/dist/index.js

@@ -7,6 +7,10 @@ var ONE_THEME_DEFAULTS = {
   colorPrimaryHover: "#4bc944",
   colorDanger: "#b83232",
   colorDangerHover: "#9f2d2d",
+  colorInfo: "#2563eb",
+  colorSuccess: "#2f7c39",
+  colorWarning: "#9a6700",
+  colorOverlay: "rgba(22, 32, 24, 0.48)",
   colorSurface: "#ffffff",
   colorText: "#162018",
   colorMuted: "#647268",
@@ -22,8 +26,19 @@ var ONE_THEME_DEFAULTS = {
   fontSizeMd: "14px",
   fontSizeLg: "16px",
   shadowCard: "0 12px 30px rgba(32, 74, 38, 0.1)",
+  shadowOverlay: "0 18px 48px rgba(22, 32, 24, 0.2)",
+  zIndexDialog: "1000",
+  zIndexMessage: "1100",
+  zIndexTooltip: "1200",
   fontFamily: "Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif"
 };
+var ONE_THEME_TYPOGRAPHY_PROPERTIES = Object.freeze({
+  fontFamily: `var(--one-font-family, ${ONE_THEME_DEFAULTS.fontFamily})`,
+  lineHeight: "var(--one-line-height, 1.5)"
+});
+function oneThemeBorder(color = `var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder})`) {
+  return `var(--one-border-width, 1px) var(--one-border-style, solid) ${color}`;
+}
 var ONE_SIZES = ["sm", "md", "lg"];
 function normalizeOneSize(value) {
   return ONE_SIZES.includes(value) ? value : "md";
@@ -45,15 +60,14 @@ var ONE_BUTTON_STYLES = [
     name: "one-button-base",
     selector: ".one-button",
     properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
       display: "inline-flex",
       alignItems: "center",
       justifyContent: "center",
       gap: `var(--one-button-gap, var(--one-space-sm, ${ONE_THEME_DEFAULTS.spaceSm}))`,
-      border: "1px solid transparent",
+      border: oneThemeBorder("transparent"),
       borderRadius: `var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd})`,
-      fontFamily: `var(--one-font-family, ${ONE_THEME_DEFAULTS.fontFamily})`,
       fontWeight: "500",
-      lineHeight: "1.5",
       cursor: "pointer",
       transition: "150ms ease"
     }
@@ -209,14 +223,13 @@ var ONE_INPUT_STYLES = [
     name: "one-input-base",
     selector: ".one-input",
     properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
       boxSizing: "border-box",
       width: "100%",
-      border: `1px solid var(--one-input-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`,
+      border: oneThemeBorder(`var(--one-input-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`),
       borderRadius: `var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd})`,
       color: `var(--one-input-color, var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText}))`,
       backgroundColor: `var(--one-input-background, var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface}))`,
-      fontFamily: `var(--one-font-family, ${ONE_THEME_DEFAULTS.fontFamily})`,
-      lineHeight: "1.5",
       transition: "150ms ease"
     }
   },
@@ -516,6 +529,7 @@ var ONE_FORM_STYLES = [
     name: "one-form-base",
     selector: ".one-form",
     properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
       display: "grid",
       gap: "16px"
     }
@@ -578,6 +592,7 @@ var ONE_FORM_ITEM_STYLES = [
     name: "one-form-item-base",
     selector: ".one-form-item",
     properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
       display: "grid",
       gap: "6px"
     }
@@ -723,6 +738,7 @@ var ONE_CHECKBOX_STYLES = [
     name: "one-checkbox-base",
     selector: ".one-checkbox",
     properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
       display: "inline-flex",
       gap: "8px",
       alignItems: "center",
@@ -839,13 +855,25 @@ class OneCheckbox extends Component5 {
 }
 // lib/checkbox/OneCheckboxGroup.ts
 import { Component as Component6 } from "@geektech/tsone";
+var ONE_CHECKBOX_GROUP_STYLES = [
+  {
+    name: "one-checkbox-group-base",
+    selector: ".one-checkbox-group",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES
+    }
+  }
+];
+
 class OneCheckboxGroup extends Component6 {
   fieldContext;
   unsubscribe;
   initState() {
     return { internalValue: [...this.props.defaultValue ?? []], revision: 0 };
   }
-  initStyles() {}
+  initStyles() {
+    ONE_CHECKBOX_GROUP_STYLES.forEach(({ name, ...style }) => this.styleManager.addStyle(name, style));
+  }
   beforeMount() {
     this.fieldContext = this.inject(ONE_FORM_FIELD_KEY);
     this.fieldContext?.model.ensureValue(this.fieldContext.name, this.props.value ?? this.props.defaultValue ?? []);
@@ -924,6 +952,7 @@ var ONE_SWITCH_STYLES = [
     name: "one-switch-base",
     selector: ".one-switch",
     properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
       display: "inline-flex",
       alignItems: "center",
       position: "relative",
@@ -1095,7 +1124,11 @@ var ONE_SELECT_STYLES = [
   {
     name: "one-select-base",
     selector: ".one-select",
-    properties: { position: "relative", width: "100%" }
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      position: "relative",
+      width: "100%"
+    }
   },
   {
     name: "one-select-trigger",
@@ -1104,7 +1137,7 @@ var ONE_SELECT_STYLES = [
       width: "100%",
       minHeight: "40px",
       textAlign: "left",
-      border: `1px solid var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder})`,
+      border: oneThemeBorder(),
       borderRadius: `var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd})`,
       backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`
     }
@@ -1118,7 +1151,7 @@ var ONE_SELECT_STYLES = [
       width: "100%",
       marginTop: "4px",
       padding: "4px",
-      border: `1px solid var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder})`,
+      border: oneThemeBorder(),
       borderRadius: `var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd})`,
       backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`
     }
@@ -1349,128 +1382,3680 @@ class OneSelect extends Component8 {
     }
   }
 }
-// lib/categories.ts
-var ONE_COMPONENT_CATEGORIES = [
-  { id: "basic", label: "基础", components: ["OneButton", "OneInput"] },
+// lib/tabs/OneTabs.ts
+import { Component as Component9, slot as slot4 } from "@geektech/tsone";
+var tabsInstanceId = 0;
+function createTabsId() {
+  tabsInstanceId += 1;
+  return `one-tabs-${tabsInstanceId}`;
+}
+function normalizeId(value) {
+  return typeof value === "string" && /^[A-Za-z_][A-Za-z0-9_-]*$/.test(value) ? value : createTabsId();
+}
+var ONE_TABS_STYLES = [
   {
-    id: "form",
-    label: "表单",
-    components: [
-      "OneForm",
-      "OneFormItem",
-      "OneSelect",
-      "OneCheckbox",
-      "OneCheckboxGroup",
-      "OneSwitch"
-    ]
+    name: "one-tabs-base",
+    selector: ".one-tabs",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      color: `var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText})`
+    }
   },
-  { id: "data-display", label: "数据展示", components: ["OneCard"] },
-  { id: "feedback", label: "反馈与浮层", components: [] }
-];
-// lib/card/OneCard.ts
-import { Component as Component9, slot as slot4 } from "@geektech/tsone";
-var ONE_CARD_STYLES = [
   {
-    name: "one-card-base",
-    selector: ".one-card",
+    name: "one-tabs-list",
+    selector: ".one-tabs__list",
     properties: {
-      overflow: "hidden",
-      color: `var(--one-card-color, var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText}))`,
-      backgroundColor: `var(--one-card-background, var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface}))`,
-      border: `1px solid var(--one-card-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`,
-      borderRadius: `var(--one-card-radius, var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd}))`,
-      boxShadow: `var(--one-card-shadow, var(--one-shadow-card, ${ONE_THEME_DEFAULTS.shadowCard}))`
+      display: "flex",
+      overflowX: "auto",
+      borderBottom: oneThemeBorder()
     }
   },
   {
-    name: "one-card-header",
-    selector: ".one-card__header",
+    name: "one-tabs-tab",
+    selector: ".one-tabs__tab",
     properties: {
-      padding: `var(--one-card-header-padding, var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg}))`,
-      borderBottom: `1px solid var(--one-card-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`,
-      fontWeight: "500"
+      position: "relative",
+      flex: "0 0 auto",
+      padding: `${ONE_THEME_DEFAULTS.spaceSm} ${ONE_THEME_DEFAULTS.spaceMd}`,
+      color: "inherit",
+      backgroundColor: "transparent",
+      border: "0",
+      cursor: "pointer",
+      font: "inherit"
+    },
+    hover: {
+      color: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`
     }
   },
   {
-    name: "one-card-body",
-    selector: ".one-card__body",
+    name: "one-tabs-tab-selected",
+    selector: '.one-tabs__tab[aria-selected="true"]',
     properties: {
-      padding: `var(--one-card-body-padding, var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg}))`
+      color: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`
     }
   },
   {
-    name: "one-card-footer",
-    selector: ".one-card__footer",
+    name: "one-tabs-tab-selected-indicator",
+    selector: '.one-tabs__tab[aria-selected="true"]::after',
     properties: {
-      padding: `var(--one-card-footer-padding, var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg}))`,
-      borderTop: `1px solid var(--one-card-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`
+      position: "absolute",
+      right: "0",
+      bottom: "-1px",
+      left: "0",
+      height: "2px",
+      backgroundColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`,
+      content: '""'
+    }
+  },
+  {
+    name: "one-tabs-tab-disabled",
+    selector: ".one-tabs__tab:disabled",
+    properties: {
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`,
+      cursor: "not-allowed"
+    }
+  },
+  {
+    name: "one-tabs-tab-focus-visible",
+    selector: ".one-tabs__tab:focus-visible",
+    properties: {
+      outline: `2px solid var(--one-color-focus, ${ONE_THEME_DEFAULTS.colorFocus})`,
+      outlineOffset: "-2px"
+    }
+  },
+  {
+    name: "one-tabs-panel",
+    selector: ".one-tabs__panel",
+    properties: {
+      padding: `${ONE_THEME_DEFAULTS.spaceLg} 0`
     }
   }
 ];
-function hasNamedSlot(children, name) {
-  return children.some((child) => typeof child !== "string" && child.slot === name);
-}
 
-class OneCard extends Component9 {
+class OneTabs extends Component9 {
+  idPrefix = normalizeId(this.props.id);
   initState() {
-    return {};
+    return { internalValue: this.props.defaultValue };
   }
   initStyles() {
-    ONE_CARD_STYLES.forEach(({ name, ...style }) => {
+    ONE_TABS_STYLES.forEach(({ name, ...style }) => {
       this.styleManager.addStyle(name, style);
     });
   }
   render() {
-    const children = this.props.children ?? [];
-    const hasHeaderSlot = hasNamedSlot(children, "header");
-    const hasFooterSlot = hasNamedSlot(children, "footer");
-    const headerChildren = hasHeaderSlot ? [slot4("header")] : this.props.title ? [this.props.title] : [];
+    const items = this.normalizedItems();
+    const value = this.effectiveValue(items);
     return {
       tag: "section",
-      props: { className: "one-card" },
+      props: { className: "one-tabs" },
       children: [
-        ...headerChildren.length > 0 ? [
-          {
-            tag: "header",
-            props: { className: "one-card__header" },
-            children: headerChildren
-          }
-        ] : [],
         {
           tag: "div",
-          props: { className: "one-card__body" },
-          children: [slot4("default")]
+          props: {
+            className: "one-tabs__list",
+            role: "tablist",
+            "aria-label": this.props.ariaLabel,
+            "aria-orientation": "horizontal"
+          },
+          children: items.map((item, index) => {
+            const selected = item.value === value;
+            return {
+              tag: "button",
+              props: {
+                className: "one-tabs__tab",
+                type: "button",
+                id: `${this.idPrefix}-tab-${index}`,
+                role: "tab",
+                disabled: item.disabled === true,
+                tabindex: selected ? 0 : -1,
+                "aria-selected": selected ? "true" : "false",
+                "aria-controls": `${this.idPrefix}-panel-${index}`
+              },
+              listeners: {
+                click: (event) => this.activate(item, index, event),
+                keydown: (event) => this.handleKeydown(event, index)
+              },
+              children: [item.label]
+            };
+          })
         },
-        ...hasFooterSlot ? [
-          {
-            tag: "footer",
-            props: { className: "one-card__footer" },
-            children: [slot4("footer")]
-          }
-        ] : []
+        ...items.map((item, index) => ({
+          tag: "div",
+          props: {
+            className: "one-tabs__panel",
+            id: `${this.idPrefix}-panel-${index}`,
+            role: "tabpanel",
+            hidden: item.value === value ? undefined : true,
+            tabindex: 0,
+            "aria-labelledby": `${this.idPrefix}-tab-${index}`
+          },
+          children: [slot4(item.value)]
+        }))
+      ]
+    };
+  }
+  normalizedItems() {
+    const items = Array.isArray(this.props.items) ? this.props.items : [];
+    const values = new Set;
+    return items.flatMap((item) => {
+      if (!item || typeof item.value !== "string" || typeof item.label !== "string" || values.has(item.value)) {
+        return [];
+      }
+      values.add(item.value);
+      return [{ ...item, disabled: item.disabled === true }];
+    });
+  }
+  effectiveValue(items) {
+    const candidate = this.props.value ?? this.state.internalValue;
+    const selected = items.find((item) => item.value === candidate && !item.disabled);
+    return selected?.value ?? items.find((item) => !item.disabled)?.value;
+  }
+  activate(item, index, event) {
+    if (item.disabled) {
+      return;
+    }
+    this.focusTab(index);
+    if (item.value === this.effectiveValue(this.normalizedItems())) {
+      return;
+    }
+    if (this.props.value === undefined) {
+      this.state.internalValue = item.value;
+    }
+    this.emit("change", {
+      value: item.value,
+      originalEvent: event
+    });
+  }
+  handleKeydown(event, currentIndex) {
+    if (!(event instanceof KeyboardEvent)) {
+      return;
+    }
+    if (!["ArrowLeft", "ArrowRight", "Home", "End"].includes(event.key)) {
+      return;
+    }
+    const items = this.normalizedItems();
+    const enabled = this.enabledIndices(items);
+    if (enabled.length === 0) {
+      return;
+    }
+    event.preventDefault();
+    const currentPosition = Math.max(0, enabled.indexOf(currentIndex));
+    const nextPosition = event.key === "Home" ? 0 : event.key === "End" ? enabled.length - 1 : event.key === "ArrowRight" ? (currentPosition + 1) % enabled.length : (currentPosition - 1 + enabled.length) % enabled.length;
+    const nextIndex = enabled[nextPosition];
+    this.focusTab(nextIndex);
+    this.activate(items[nextIndex], nextIndex, event);
+  }
+  enabledIndices(items) {
+    return items.flatMap((item, index) => item.disabled ? [] : [index]);
+  }
+  focusTab(index) {
+    const element = this.getElement();
+    if (!(element instanceof HTMLElement)) {
+      return;
+    }
+    const tab = element.querySelectorAll('[role="tab"]')[index];
+    tab?.focus();
+  }
+}
+// lib/breadcrumb/OneBreadcrumb.ts
+import { Component as Component10, slot as slot5 } from "@geektech/tsone";
+
+// lib/navigation/normalize.ts
+function normalizeNonNegativeInteger(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : Math.max(0, Math.floor(fallback));
+}
+function normalizePositiveInteger(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : Math.max(1, Math.floor(fallback));
+}
+function normalizePositiveIntegerList(values, fallback) {
+  const source = Array.isArray(values) ? values : fallback;
+  return [
+    ...new Set(source.filter((value) => typeof value === "number" && Number.isFinite(value) && value > 0).map(Math.floor))
+  ];
+}
+// lib/breadcrumb/OneBreadcrumb.ts
+var ONE_BREADCRUMB_STYLES = [
+  {
+    name: "one-breadcrumb-base",
+    selector: ".one-breadcrumb",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      color: `var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText})`
+    }
+  },
+  {
+    name: "one-breadcrumb-list",
+    selector: ".one-breadcrumb__list",
+    properties: {
+      display: "flex",
+      flexWrap: "wrap",
+      gap: ONE_THEME_DEFAULTS.spaceXs,
+      alignItems: "center",
+      margin: "0",
+      padding: "0",
+      listStyle: "none"
+    }
+  },
+  {
+    name: "one-breadcrumb-token",
+    selector: ".one-breadcrumb__item, .one-breadcrumb__collapse",
+    properties: {
+      display: "inline-flex",
+      gap: ONE_THEME_DEFAULTS.spaceXs,
+      alignItems: "center"
+    }
+  },
+  {
+    name: "one-breadcrumb-link",
+    selector: ".one-breadcrumb__link",
+    properties: {
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`,
+      textDecoration: "none"
+    },
+    hover: {
+      color: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`
+    }
+  },
+  {
+    name: "one-breadcrumb-link-focus-visible",
+    selector: ".one-breadcrumb__link:focus-visible",
+    properties: {
+      outline: `2px solid var(--one-color-focus, ${ONE_THEME_DEFAULTS.colorFocus})`,
+      outlineOffset: "2px"
+    }
+  },
+  {
+    name: "one-breadcrumb-current",
+    selector: ".one-breadcrumb__current",
+    properties: { fontWeight: "600" }
+  },
+  {
+    name: "one-breadcrumb-separator",
+    selector: ".one-breadcrumb__separator",
+    properties: {
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`,
+      userSelect: "none"
+    }
+  },
+  {
+    name: "one-breadcrumb-ellipsis",
+    selector: ".one-breadcrumb__ellipsis",
+    properties: {
+      padding: `0 ${ONE_THEME_DEFAULTS.spaceXs}`,
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`,
+      backgroundColor: "transparent",
+      border: "0",
+      cursor: "pointer",
+      font: "inherit"
+    }
+  },
+  {
+    name: "one-breadcrumb-ellipsis-focus-visible",
+    selector: ".one-breadcrumb__ellipsis:focus-visible",
+    properties: {
+      outline: `2px solid var(--one-color-focus, ${ONE_THEME_DEFAULTS.colorFocus})`,
+      outlineOffset: "2px"
+    }
+  }
+];
+
+class OneBreadcrumb extends Component10 {
+  initState() {
+    return { expanded: false };
+  }
+  initStyles() {
+    ONE_BREADCRUMB_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  render() {
+    const items = this.normalizedItems();
+    const currentIndex = this.currentIndex(items);
+    const tokens = this.tokens(items, currentIndex);
+    return {
+      tag: "nav",
+      props: {
+        className: "one-breadcrumb",
+        "aria-label": this.props.ariaLabel ?? "面包屑"
+      },
+      children: [
+        {
+          tag: "ol",
+          props: { className: "one-breadcrumb__list" },
+          children: tokens.map((token, tokenIndex) => this.renderToken(token, tokenIndex < tokens.length - 1, currentIndex))
+        }
+      ]
+    };
+  }
+  normalizedItems() {
+    const items = Array.isArray(this.props.items) ? this.props.items : [];
+    return items.flatMap((item) => item && typeof item.label === "string" ? [{ ...item }] : []);
+  }
+  currentIndex(items) {
+    const explicit = items.findIndex((item) => item.current === true);
+    return explicit >= 0 ? explicit : items.length - 1;
+  }
+  tokens(items, currentIndex) {
+    const limit = Math.max(3, normalizePositiveInteger(this.props.maxItems, items.length || 3));
+    if (this.state.expanded || items.length <= limit) {
+      return items.map((item, index) => ({ type: "item", item, index }));
+    }
+    const visible = new Set([0, currentIndex, items.length - 1]);
+    const candidates = items.map((_, index) => index).filter((index) => !visible.has(index)).sort((left, right) => Math.abs(left - currentIndex) - Math.abs(right - currentIndex) || left - right);
+    candidates.slice(0, Math.max(0, limit - visible.size)).forEach((index) => {
+      visible.add(index);
+    });
+    const result = [];
+    let hiddenStart = -1;
+    items.forEach((item, index) => {
+      if (!visible.has(index)) {
+        if (hiddenStart < 0)
+          hiddenStart = index;
+        return;
+      }
+      if (hiddenStart >= 0) {
+        result.push({ type: "collapse", key: `${hiddenStart}-${index - 1}` });
+        hiddenStart = -1;
+      }
+      result.push({ type: "item", item, index });
+    });
+    if (hiddenStart >= 0) {
+      result.push({
+        type: "collapse",
+        key: `${hiddenStart}-${items.length - 1}`
+      });
+    }
+    return result;
+  }
+  renderToken(token, hasSeparator, currentIndex) {
+    const content = token.type === "collapse" ? this.renderCollapse() : this.renderItem(token.item, token.index, token.index === currentIndex);
+    return {
+      tag: "li",
+      props: {
+        className: token.type === "item" ? "one-breadcrumb__item" : "one-breadcrumb__collapse"
+      },
+      children: [content, ...hasSeparator ? [this.renderSeparator()] : []]
+    };
+  }
+  renderItem(item, index, current) {
+    if (current || !item.href) {
+      return {
+        tag: "span",
+        props: {
+          className: current ? "one-breadcrumb__current" : "one-breadcrumb__label",
+          "aria-current": current ? "page" : undefined
+        },
+        children: [item.label]
+      };
+    }
+    return {
+      tag: "a",
+      props: { className: "one-breadcrumb__link", href: item.href },
+      listeners: { click: (event) => this.handleItemClick(event, item, index) },
+      children: [item.label]
+    };
+  }
+  renderCollapse() {
+    return {
+      tag: "button",
+      props: {
+        className: "one-breadcrumb__ellipsis",
+        type: "button",
+        "aria-label": "展开面包屑",
+        "aria-expanded": "false"
+      },
+      listeners: { click: () => this.state.expanded = true },
+      children: ["…"]
+    };
+  }
+  renderSeparator() {
+    return {
+      tag: "span",
+      props: { className: "one-breadcrumb__separator", "aria-hidden": "true" },
+      children: [
+        this.hasSlot("separator") ? slot5("separator") : this.props.separator ?? "/"
       ]
     };
   }
+  handleItemClick(event, item, index) {
+    if (!(event instanceof MouseEvent))
+      return;
+    this.emit("itemClick", {
+      item,
+      index,
+      originalEvent: event
+    });
+  }
+  hasSlot(name) {
+    return this.props.children?.some((child) => typeof child !== "string" && child.slot === name) ?? false;
+  }
+}
+// lib/pagination/OnePagination.ts
+import { Component as Component11 } from "@geektech/tsone";
+
+// lib/pagination/tokens.ts
+function createOnePaginationTokens(pageCount, page, siblingCount) {
+  const normalizedCount = normalizePositiveInteger(pageCount, 1);
+  const normalizedPage = Math.min(normalizedCount, normalizePositiveInteger(page, 1));
+  const normalizedSiblings = normalizeNonNegativeInteger(siblingCount, 1);
+  const pages = new Set([1, normalizedCount]);
+  for (let candidate = Math.max(1, normalizedPage - normalizedSiblings);candidate <= Math.min(normalizedCount, normalizedPage + normalizedSiblings); candidate += 1) {
+    pages.add(candidate);
+  }
+  const sorted = [...pages].sort((left, right) => left - right);
+  return sorted.flatMap((value, index) => {
+    if (index === 0)
+      return [value];
+    const previous = sorted[index - 1];
+    const gap = value - previous;
+    if (gap === 2)
+      return [previous + 1, value];
+    if (gap > 2) {
+      return [previous === 1 ? "ellipsis-start" : "ellipsis-end", value];
+    }
+    return [value];
+  });
+}
+
+// lib/pagination/OnePagination.ts
+var DEFAULT_PAGE_SIZE_OPTIONS = [10, 20, 50, 100];
+var ONE_PAGINATION_STYLES = [
+  {
+    name: "one-pagination-base",
+    selector: ".one-pagination",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      display: "flex",
+      flexWrap: "wrap",
+      gap: ONE_THEME_DEFAULTS.spaceSm,
+      alignItems: "center",
+      color: `var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText})`
+    }
+  },
+  {
+    name: "one-pagination-pages",
+    selector: ".one-pagination__pages",
+    properties: {
+      display: "flex",
+      flexWrap: "wrap",
+      gap: ONE_THEME_DEFAULTS.spaceXs,
+      alignItems: "center"
+    }
+  },
+  {
+    name: "one-pagination-button",
+    selector: ".one-pagination__button",
+    properties: {
+      minWidth: "32px",
+      height: "32px",
+      padding: `0 ${ONE_THEME_DEFAULTS.spaceSm}`,
+      color: "inherit",
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      border: oneThemeBorder(),
+      borderRadius: `var(--one-radius-sm, ${ONE_THEME_DEFAULTS.radiusSm})`,
+      cursor: "pointer",
+      font: "inherit"
+    },
+    hover: {
+      color: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`,
+      borderColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`
+    }
+  },
+  {
+    name: "one-pagination-button-current",
+    selector: '.one-pagination__button[aria-current="page"]',
+    properties: {
+      color: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      backgroundColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`,
+      borderColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`
+    }
+  },
+  {
+    name: "one-pagination-button-disabled",
+    selector: ".one-pagination__button:disabled",
+    properties: {
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`,
+      cursor: "not-allowed",
+      opacity: "0.55"
+    }
+  },
+  {
+    name: "one-pagination-button-focus-visible",
+    selector: ".one-pagination__button:focus-visible",
+    properties: {
+      outline: `2px solid var(--one-color-focus, ${ONE_THEME_DEFAULTS.colorFocus})`,
+      outlineOffset: "2px"
+    }
+  },
+  {
+    name: "one-pagination-ellipsis",
+    selector: ".one-pagination__ellipsis",
+    properties: {
+      minWidth: "24px",
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`,
+      textAlign: "center"
+    }
+  },
+  {
+    name: "one-pagination-control",
+    selector: ".one-pagination__size, .one-pagination__jumper",
+    properties: {
+      height: "32px",
+      padding: `0 ${ONE_THEME_DEFAULTS.spaceSm}`,
+      color: "inherit",
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      border: oneThemeBorder(),
+      borderRadius: `var(--one-radius-sm, ${ONE_THEME_DEFAULTS.radiusSm})`,
+      font: "inherit"
+    }
+  },
+  {
+    name: "one-pagination-control-focus-visible",
+    selector: ".one-pagination__size:focus-visible, .one-pagination__jumper:focus-visible",
+    properties: {
+      outline: `2px solid var(--one-color-focus, ${ONE_THEME_DEFAULTS.colorFocus})`,
+      outlineOffset: "2px"
+    }
+  },
+  {
+    name: "one-pagination-jumper",
+    selector: ".one-pagination__jumper",
+    properties: { width: "80px" }
+  }
+];
+
+class OnePagination extends Component11 {
+  initState() {
+    return {
+      internalPage: normalizePositiveInteger(this.props.defaultPage, 1),
+      internalPageSize: normalizePositiveInteger(this.props.defaultPageSize, 10),
+      jumpValue: ""
+    };
+  }
+  initStyles() {
+    ONE_PAGINATION_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  render() {
+    const pageSize = this.effectivePageSize();
+    const pageCount = this.pageCount(pageSize);
+    const page = this.effectivePage(pageSize);
+    const disabled = this.props.disabled === true;
+    const siblingCount = normalizeNonNegativeInteger(this.props.siblingCount, 1);
+    return {
+      tag: "nav",
+      props: {
+        className: "one-pagination",
+        "aria-label": this.props.ariaLabel ?? "分页"
+      },
+      children: [
+        {
+          tag: "div",
+          props: { className: "one-pagination__pages" },
+          children: [
+            this.renderPageButton("上一页", "‹", page - 1, page <= 1),
+            ...createOnePaginationTokens(pageCount, page, siblingCount).map((token) => typeof token === "number" ? this.renderPageButton(`第 ${token} 页`, String(token), token, false, token === page) : this.renderEllipsis(token)),
+            this.renderPageButton("下一页", "›", page + 1, page >= pageCount)
+          ]
+        },
+        {
+          tag: "select",
+          props: {
+            className: "one-pagination__size",
+            value: String(pageSize),
+            disabled,
+            "aria-label": "每页条数"
+          },
+          listeners: { change: (event) => this.handleSizeChange(event) },
+          children: this.sizeOptions().map((option) => ({
+            tag: "option",
+            props: {
+              value: String(option),
+              selected: option === pageSize
+            },
+            children: [`${option} 条/页`]
+          }))
+        },
+        ...this.props.showQuickJumper ? [
+          {
+            tag: "input",
+            props: {
+              className: "one-pagination__jumper",
+              type: "text",
+              inputmode: "numeric",
+              value: this.state.jumpValue,
+              disabled,
+              "aria-label": "快速跳转页码",
+              placeholder: "跳至页码"
+            },
+            listeners: {
+              input: (event) => this.handleJumpInput(event),
+              keydown: (event) => this.handleJumpKeydown(event),
+              blur: (event) => this.submitJump(event)
+            }
+          }
+        ] : []
+      ]
+    };
+  }
+  effectivePageSize() {
+    return normalizePositiveInteger(this.props.pageSize ?? this.state.internalPageSize, 10);
+  }
+  pageCount(pageSize = this.effectivePageSize()) {
+    const total = normalizeNonNegativeInteger(this.props.total, 0);
+    return Math.max(1, Math.ceil(total / pageSize));
+  }
+  effectivePage(pageSize = this.effectivePageSize()) {
+    const candidate = normalizePositiveInteger(this.props.page ?? this.state.internalPage, 1);
+    return Math.min(this.pageCount(pageSize), candidate);
+  }
+  sizeOptions() {
+    const active = this.effectivePageSize();
+    const options = normalizePositiveIntegerList(this.props.pageSizeOptions, DEFAULT_PAGE_SIZE_OPTIONS);
+    if (!options.includes(active))
+      options.push(active);
+    return options;
+  }
+  renderPageButton(ariaLabel, label, targetPage, boundaryDisabled, current = false) {
+    const disabled = this.props.disabled === true || boundaryDisabled;
+    return {
+      tag: "button",
+      props: {
+        className: "one-pagination__button",
+        type: "button",
+        disabled,
+        "aria-label": ariaLabel,
+        "aria-current": current ? "page" : undefined
+      },
+      listeners: {
+        click: (event) => this.requestChange(targetPage, this.effectivePageSize(), event)
+      },
+      children: [label]
+    };
+  }
+  renderEllipsis(token) {
+    return {
+      tag: "span",
+      props: {
+        className: "one-pagination__ellipsis",
+        "aria-hidden": "true",
+        "data-token": token
+      },
+      children: ["…"]
+    };
+  }
+  handleSizeChange(event) {
+    const select = event.currentTarget;
+    if (!(select instanceof HTMLSelectElement) || this.props.disabled)
+      return;
+    const pageSize = normalizePositiveInteger(Number(select.value), 10);
+    this.requestChange(this.effectivePage(), pageSize, event);
+  }
+  handleJumpInput(event) {
+    const input = event.currentTarget;
+    if (!(input instanceof HTMLInputElement) || this.props.disabled)
+      return;
+    this.state.jumpValue = input.value;
+  }
+  handleJumpKeydown(event) {
+    if (!(event instanceof KeyboardEvent) || event.key !== "Enter")
+      return;
+    event.preventDefault();
+    this.submitJump(event);
+  }
+  requestChange(page, pageSize, event) {
+    if (this.props.disabled)
+      return;
+    const nextPageSize = normalizePositiveInteger(pageSize, 10);
+    const nextPage = Math.min(this.pageCount(nextPageSize), normalizePositiveInteger(page, 1));
+    const currentPage = this.effectivePage();
+    const currentPageSize = this.effectivePageSize();
+    if (nextPage === currentPage && nextPageSize === currentPageSize)
+      return;
+    if (this.props.pageSize === undefined) {
+      this.state.internalPageSize = nextPageSize;
+    }
+    if (this.props.page === undefined) {
+      this.state.internalPage = nextPage;
+    }
+    this.emit("change", {
+      page: nextPage,
+      pageSize: nextPageSize,
+      originalEvent: event
+    });
+  }
+  submitJump(event) {
+    if (this.props.disabled)
+      return;
+    const value = this.state.jumpValue.trim();
+    if (!value)
+      return;
+    const page = Number(value);
+    this.state.jumpValue = "";
+    if (event.currentTarget instanceof HTMLInputElement) {
+      event.currentTarget.value = "";
+    }
+    if (!Number.isFinite(page))
+      return;
+    this.requestChange(page, this.effectivePageSize(), event);
+  }
+}
+// lib/categories.ts
+var ONE_COMPONENT_CATEGORIES = [
+  { id: "basic", label: "基础", components: ["OneButton", "OneInput"] },
+  {
+    id: "form",
+    label: "表单",
+    components: [
+      "OneForm",
+      "OneFormItem",
+      "OneSelect",
+      "OneCheckbox",
+      "OneCheckboxGroup",
+      "OneSwitch"
+    ]
+  },
+  {
+    id: "navigation",
+    label: "导航",
+    components: ["OneTabs", "OneBreadcrumb", "OnePagination"]
+  },
+  {
+    id: "data-display",
+    label: "数据展示",
+    components: ["OneCard", "OneTag", "OneBadge", "OneEmpty"]
+  },
+  {
+    id: "feedback",
+    label: "反馈与浮层",
+    components: ["OneAlert", "OneMessage", "OneDialog", "OneTooltip"]
+  }
+];
+// lib/card/OneCard.ts
+import { Component as Component12, slot as slot6 } from "@geektech/tsone";
+var ONE_CARD_STYLES = [
+  {
+    name: "one-card-base",
+    selector: ".one-card",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      overflow: "hidden",
+      color: `var(--one-card-color, var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText}))`,
+      backgroundColor: `var(--one-card-background, var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface}))`,
+      border: oneThemeBorder(`var(--one-card-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`),
+      borderRadius: `var(--one-card-radius, var(--one-radius-lg, ${ONE_THEME_DEFAULTS.radiusMd}))`,
+      boxShadow: `var(--one-card-shadow, var(--one-shadow-card, ${ONE_THEME_DEFAULTS.shadowCard}))`
+    }
+  },
+  {
+    name: "one-card-header",
+    selector: ".one-card__header",
+    properties: {
+      padding: `var(--one-card-header-padding, var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg}))`,
+      borderBottom: oneThemeBorder(`var(--one-card-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`),
+      fontWeight: "500"
+    }
+  },
+  {
+    name: "one-card-body",
+    selector: ".one-card__body",
+    properties: {
+      padding: `var(--one-card-body-padding, var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg}))`
+    }
+  },
+  {
+    name: "one-card-footer",
+    selector: ".one-card__footer",
+    properties: {
+      padding: `var(--one-card-footer-padding, var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg}))`,
+      borderTop: oneThemeBorder(`var(--one-card-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`)
+    }
+  }
+];
+function hasNamedSlot(children, name) {
+  return children.some((child) => typeof child !== "string" && child.slot === name);
+}
+
+class OneCard extends Component12 {
+  initState() {
+    return {};
+  }
+  initStyles() {
+    ONE_CARD_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  render() {
+    const children = this.props.children ?? [];
+    const hasHeaderSlot = hasNamedSlot(children, "header");
+    const hasFooterSlot = hasNamedSlot(children, "footer");
+    const headerChildren = hasHeaderSlot ? [slot6("header")] : this.props.title ? [this.props.title] : [];
+    return {
+      tag: "section",
+      props: { className: "one-card" },
+      children: [
+        ...headerChildren.length > 0 ? [
+          {
+            tag: "header",
+            props: { className: "one-card__header" },
+            children: headerChildren
+          }
+        ] : [],
+        {
+          tag: "div",
+          props: { className: "one-card__body" },
+          children: [slot6("default")]
+        },
+        ...hasFooterSlot ? [
+          {
+            tag: "footer",
+            props: { className: "one-card__footer" },
+            children: [slot6("footer")]
+          }
+        ] : []
+      ]
+    };
+  }
+}
+// lib/tag/OneTag.ts
+import { Component as Component13 } from "@geektech/tsone";
+
+// lib/data-display/types.ts
+var VARIANTS = [
+  "neutral",
+  "primary",
+  "success",
+  "warning",
+  "error"
+];
+function normalizeOneDataDisplayVariant(value, fallback = "neutral") {
+  return VARIANTS.includes(value) ? value : fallback;
+}
+// lib/tag/OneTag.ts
+var ONE_TAG_STYLES = [
+  {
+    name: "one-tag-base",
+    selector: ".one-tag",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      display: "inline-flex",
+      alignItems: "center",
+      gap: ONE_THEME_DEFAULTS.spaceXs,
+      border: oneThemeBorder(),
+      borderRadius: `var(--one-radius-sm, ${ONE_THEME_DEFAULTS.radiusSm})`
+    }
+  },
+  {
+    name: "one-tag-neutral",
+    selector: ".one-tag--neutral",
+    properties: {
+      color: `var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText})`,
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      borderColor: `var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder})`
+    }
+  },
+  {
+    name: "one-tag-primary",
+    selector: ".one-tag--primary",
+    properties: {
+      color: `var(--one-color-primary-contrast, ${ONE_THEME_DEFAULTS.colorText})`,
+      backgroundColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`,
+      borderColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`
+    }
+  },
+  {
+    name: "one-tag-success",
+    selector: ".one-tag--success",
+    properties: {
+      color: `var(--one-color-success, ${ONE_THEME_DEFAULTS.colorSuccess})`,
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      borderColor: `var(--one-color-success, ${ONE_THEME_DEFAULTS.colorSuccess})`
+    }
+  },
+  {
+    name: "one-tag-warning",
+    selector: ".one-tag--warning",
+    properties: {
+      color: `var(--one-color-warning, ${ONE_THEME_DEFAULTS.colorWarning})`,
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      borderColor: `var(--one-color-warning, ${ONE_THEME_DEFAULTS.colorWarning})`
+    }
+  },
+  {
+    name: "one-tag-error",
+    selector: ".one-tag--error",
+    properties: {
+      color: `var(--one-color-danger, ${ONE_THEME_DEFAULTS.colorDanger})`,
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      borderColor: `var(--one-color-danger, ${ONE_THEME_DEFAULTS.colorDanger})`
+    }
+  },
+  {
+    name: "one-tag-sm",
+    selector: ".one-tag--sm",
+    properties: {
+      padding: "2px 6px",
+      fontSize: `var(--one-font-size-sm, ${ONE_THEME_DEFAULTS.fontSizeSm})`
+    }
+  },
+  {
+    name: "one-tag-md",
+    selector: ".one-tag--md",
+    properties: {
+      padding: "4px 8px",
+      fontSize: `var(--one-font-size-md, ${ONE_THEME_DEFAULTS.fontSizeMd})`
+    }
+  },
+  {
+    name: "one-tag-lg",
+    selector: ".one-tag--lg",
+    properties: {
+      padding: "6px 10px",
+      fontSize: `var(--one-font-size-lg, ${ONE_THEME_DEFAULTS.fontSizeLg})`
+    }
+  },
+  {
+    name: "one-tag-close",
+    selector: ".one-tag__close",
+    properties: {
+      display: "inline-grid",
+      placeItems: "center",
+      padding: "0",
+      color: "inherit",
+      backgroundColor: "transparent",
+      border: "0",
+      cursor: "pointer",
+      font: "inherit",
+      lineHeight: "1"
+    }
+  },
+  {
+    name: "one-tag-close-focus-visible",
+    selector: ".one-tag__close:focus-visible",
+    properties: {
+      outline: `2px solid var(--one-color-focus, ${ONE_THEME_DEFAULTS.colorFocus})`,
+      outlineOffset: "2px"
+    }
+  }
+];
+
+class OneTag extends Component13 {
+  initState() {
+    return { visible: true };
+  }
+  initStyles() {
+    ONE_TAG_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  render() {
+    if (!this.state.visible) {
+      return {
+        tag: "span",
+        props: { hidden: true, "data-one-tag-anchor": "" }
+      };
+    }
+    const variant = normalizeOneDataDisplayVariant(this.props.variant);
+    const size = normalizeOneSize(this.props.size);
+    return {
+      tag: "span",
+      props: {
+        className: `one-tag one-tag--${variant} one-tag--${size}`
+      },
+      children: [
+        ...this.props.children ?? [],
+        ...this.props.closable ? [
+          {
+            tag: "button",
+            props: {
+              className: "one-tag__close",
+              type: "button",
+              "aria-label": "关闭标签"
+            },
+            listeners: { click: () => this.close() },
+            children: ["×"]
+          }
+        ] : []
+      ]
+    };
+  }
+  close() {
+    if (!this.state.visible) {
+      return;
+    }
+    this.emit("close");
+    this.state.visible = false;
+  }
+}
+// lib/badge/OneBadge.ts
+import { Component as Component14 } from "@geektech/tsone";
+var ONE_BADGE_STYLES = [
+  {
+    name: "one-badge-base",
+    selector: ".one-badge",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      position: "relative",
+      display: "inline-flex",
+      verticalAlign: "middle"
+    }
+  },
+  {
+    name: "one-badge-content",
+    selector: ".one-badge__content",
+    properties: {
+      position: "absolute",
+      top: "0",
+      right: "0",
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      boxSizing: "border-box",
+      minWidth: "18px",
+      height: "18px",
+      padding: "0 5px",
+      borderRadius: "999px",
+      fontFamily: `var(--one-font-family, ${ONE_THEME_DEFAULTS.fontFamily})`,
+      fontSize: `var(--one-font-size-sm, ${ONE_THEME_DEFAULTS.fontSizeSm})`,
+      lineHeight: "1",
+      transform: "translate(50%, -50%)"
+    }
+  },
+  {
+    name: "one-badge-standalone-content",
+    selector: ".one-badge--standalone .one-badge__content",
+    properties: {
+      position: "static",
+      transform: "none"
+    }
+  },
+  {
+    name: "one-badge-dot",
+    selector: ".one-badge__content--dot",
+    properties: {
+      width: "8px",
+      minWidth: "8px",
+      height: "8px",
+      padding: "0"
+    }
+  },
+  {
+    name: "one-badge-neutral",
+    selector: ".one-badge--neutral .one-badge__content",
+    properties: {
+      color: `var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText})`,
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      border: oneThemeBorder()
+    }
+  },
+  {
+    name: "one-badge-primary",
+    selector: ".one-badge--primary .one-badge__content",
+    properties: {
+      color: `var(--one-color-primary-contrast, ${ONE_THEME_DEFAULTS.colorText})`,
+      backgroundColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`
+    }
+  },
+  {
+    name: "one-badge-success",
+    selector: ".one-badge--success .one-badge__content",
+    properties: {
+      color: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      backgroundColor: `var(--one-color-success, ${ONE_THEME_DEFAULTS.colorSuccess})`
+    }
+  },
+  {
+    name: "one-badge-warning",
+    selector: ".one-badge--warning .one-badge__content",
+    properties: {
+      color: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      backgroundColor: `var(--one-color-warning, ${ONE_THEME_DEFAULTS.colorWarning})`
+    }
+  },
+  {
+    name: "one-badge-error",
+    selector: ".one-badge--error .one-badge__content",
+    properties: {
+      color: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      backgroundColor: `var(--one-color-danger, ${ONE_THEME_DEFAULTS.colorDanger})`
+    }
+  }
+];
+function normalizeMax(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 99;
+}
+function displayValue(props) {
+  if (props.dot) {
+    return "";
+  }
+  if (props.value === undefined || props.value === "") {
+    return;
+  }
+  if (props.value === 0 && props.showZero !== true) {
+    return;
+  }
+  if (typeof props.value === "number" && !Number.isFinite(props.value)) {
+    return;
+  }
+  if (typeof props.value === "number") {
+    const max = normalizeMax(props.max);
+    return props.value > max ? `${max}+` : String(props.value);
+  }
+  return props.value;
+}
+
+class OneBadge extends Component14 {
+  initState() {
+    return {};
+  }
+  initStyles() {
+    ONE_BADGE_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  render() {
+    const children = this.props.children ?? [];
+    const standalone = children.length === 0;
+    const variant = normalizeOneDataDisplayVariant(this.props.variant, "primary");
+    const value = displayValue(this.props);
+    const showContent = this.props.dot === true || value !== undefined;
+    return {
+      tag: "span",
+      props: {
+        className: [
+          "one-badge",
+          `one-badge--${variant}`,
+          ...standalone ? ["one-badge--standalone"] : []
+        ].join(" ")
+      },
+      children: [
+        ...children,
+        ...showContent ? [
+          {
+            tag: "span",
+            props: {
+              className: [
+                "one-badge__content",
+                ...this.props.dot ? ["one-badge__content--dot"] : []
+              ].join(" "),
+              "aria-label": this.props.ariaLabel,
+              "aria-hidden": this.props.dot && !this.props.ariaLabel ? "true" : undefined
+            },
+            children: value ? [value] : []
+          }
+        ] : []
+      ]
+    };
+  }
+}
+// lib/empty/OneEmpty.ts
+import { Component as Component15, slot as slot7 } from "@geektech/tsone";
+var ONE_EMPTY_STYLES = [
+  {
+    name: "one-empty-base",
+    selector: ".one-empty",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      display: "grid",
+      justifyItems: "center",
+      gap: ONE_THEME_DEFAULTS.spaceMd,
+      padding: "24px",
+      color: `var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText})`,
+      textAlign: "center"
+    }
+  },
+  {
+    name: "one-empty-image",
+    selector: ".one-empty__image",
+    properties: {
+      display: "grid",
+      placeItems: "center",
+      minHeight: "56px"
+    }
+  },
+  {
+    name: "one-empty-illustration",
+    selector: ".one-empty__illustration",
+    properties: {
+      display: "block",
+      width: "48px",
+      height: "36px",
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      border: `2px solid var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder})`,
+      borderRadius: `var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd})`
+    }
+  },
+  {
+    name: "one-empty-description",
+    selector: ".one-empty__description",
+    properties: {
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`,
+      fontSize: `var(--one-font-size-md, ${ONE_THEME_DEFAULTS.fontSizeMd})`
+    }
+  },
+  {
+    name: "one-empty-actions",
+    selector: ".one-empty__actions",
+    properties: {
+      display: "flex",
+      flexWrap: "wrap",
+      justifyContent: "center",
+      gap: ONE_THEME_DEFAULTS.spaceSm
+    }
+  }
+];
+function hasNamedSlot2(children, name) {
+  return children.some((child) => typeof child !== "string" && child.slot === name);
+}
+function hasDefaultSlot(children) {
+  return children.some((child) => typeof child === "string" || child.slot === undefined);
+}
+
+class OneEmpty extends Component15 {
+  initState() {
+    return {};
+  }
+  initStyles() {
+    ONE_EMPTY_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  render() {
+    const children = this.props.children ?? [];
+    const customImage = hasNamedSlot2(children, "image");
+    const customDescription = hasDefaultSlot(children);
+    const customActions = hasNamedSlot2(children, "actions");
+    return {
+      tag: "section",
+      props: { className: "one-empty" },
+      children: [
+        {
+          tag: "div",
+          props: {
+            className: "one-empty__image",
+            "aria-hidden": customImage ? undefined : "true"
+          },
+          children: customImage ? [slot7("image")] : [
+            {
+              tag: "span",
+              props: { className: "one-empty__illustration" }
+            }
+          ]
+        },
+        {
+          tag: "div",
+          props: { className: "one-empty__description" },
+          children: customDescription ? [slot7("default")] : [this.props.description ?? "暂无数据"]
+        },
+        ...customActions ? [
+          {
+            tag: "div",
+            props: { className: "one-empty__actions" },
+            children: [slot7("actions")]
+          }
+        ] : []
+      ]
+    };
+  }
+}
+// lib/theme/default-theme.ts
+var ONE_DEFAULT_THEME = Object.freeze({
+  colors: Object.freeze({
+    primary: ONE_THEME_DEFAULTS.colorPrimary,
+    primaryHover: ONE_THEME_DEFAULTS.colorPrimaryHover,
+    primaryContrast: ONE_THEME_DEFAULTS.colorText,
+    secondary: ONE_THEME_DEFAULTS.colorSurface,
+    secondaryHover: ONE_THEME_DEFAULTS.colorBorder,
+    secondaryContrast: ONE_THEME_DEFAULTS.colorText,
+    danger: ONE_THEME_DEFAULTS.colorDanger,
+    dangerHover: ONE_THEME_DEFAULTS.colorDangerHover,
+    dangerContrast: ONE_THEME_DEFAULTS.colorSurface,
+    info: ONE_THEME_DEFAULTS.colorInfo,
+    success: ONE_THEME_DEFAULTS.colorSuccess,
+    warning: ONE_THEME_DEFAULTS.colorWarning,
+    overlay: ONE_THEME_DEFAULTS.colorOverlay,
+    surface: ONE_THEME_DEFAULTS.colorSurface,
+    text: ONE_THEME_DEFAULTS.colorText,
+    muted: ONE_THEME_DEFAULTS.colorMuted,
+    focus: ONE_THEME_DEFAULTS.colorFocus
+  }),
+  typography: Object.freeze({
+    fontFamily: ONE_THEME_DEFAULTS.fontFamily,
+    fontSizeSm: ONE_THEME_DEFAULTS.fontSizeSm,
+    fontSizeMd: ONE_THEME_DEFAULTS.fontSizeMd,
+    fontSizeLg: ONE_THEME_DEFAULTS.fontSizeLg,
+    lineHeight: "1.5"
+  }),
+  border: Object.freeze({
+    color: ONE_THEME_DEFAULTS.colorBorder,
+    width: "1px",
+    style: "solid"
+  }),
+  radius: Object.freeze({
+    sm: ONE_THEME_DEFAULTS.radiusSm,
+    md: ONE_THEME_DEFAULTS.radiusMd,
+    lg: ONE_THEME_DEFAULTS.radiusMd
+  })
+});
+// lib/theme/errors.ts
+class OneThemeConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OneThemeConfigError";
+  }
+}
+
+class OneThemeNotFoundError extends Error {
+  constructor(themeName) {
+    super(`One UI theme "${themeName}" is not registered.`);
+    this.name = "OneThemeNotFoundError";
+  }
+}
+
+class OneThemeEnvironmentError extends Error {
+  constructor() {
+    super("One UI themes require a browser document root.");
+    this.name = "OneThemeEnvironmentError";
+  }
+}
+// lib/theme/normalize.ts
+var OPTION_KEYS = ["themes", "defaultTheme"];
+var DEFINITION_KEYS = ["colors", "typography", "border", "radius"];
+var COLOR_KEYS = [
+  "primary",
+  "primaryHover",
+  "primaryContrast",
+  "secondary",
+  "secondaryHover",
+  "secondaryContrast",
+  "danger",
+  "dangerHover",
+  "dangerContrast",
+  "info",
+  "success",
+  "warning",
+  "overlay",
+  "surface",
+  "text",
+  "muted",
+  "focus"
+];
+var TYPOGRAPHY_KEYS = [
+  "fontFamily",
+  "fontSizeSm",
+  "fontSizeMd",
+  "fontSizeLg",
+  "lineHeight"
+];
+var BORDER_KEYS = ["color", "width", "style"];
+var RADIUS_KEYS = ["sm", "md", "lg"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertRecord(value, path) {
+  if (!isRecord(value)) {
+    throw new OneThemeConfigError(`${path} must be an object.`);
+  }
+}
+function assertKnownKeys(value, allowedKeys, path) {
+  const unknownKey = Object.keys(value).find((key) => !allowedKeys.includes(key));
+  if (unknownKey) {
+    throw new OneThemeConfigError(`${path}.${unknownKey} is not supported.`);
+  }
+}
+function normalizeStringGroup(value, fallback, allowedKeys, path) {
+  if (value === undefined) {
+    return fallback;
+  }
+  assertRecord(value, path);
+  assertKnownKeys(value, allowedKeys, path);
+  const resolved = { ...fallback };
+  for (const key of allowedKeys) {
+    const candidate = value[key];
+    if (candidate === undefined) {
+      continue;
+    }
+    if (typeof candidate !== "string" || candidate.trim().length === 0) {
+      throw new OneThemeConfigError(`${path}.${key} must be a non-empty string.`);
+    }
+    resolved[key] = candidate;
+  }
+  return Object.freeze(resolved);
+}
+function normalizeTheme(value, path) {
+  assertRecord(value, path);
+  assertKnownKeys(value, DEFINITION_KEYS, path);
+  const definition = value;
+  return Object.freeze({
+    colors: normalizeStringGroup(definition.colors, ONE_DEFAULT_THEME.colors, COLOR_KEYS, `${path}.colors`),
+    typography: normalizeStringGroup(definition.typography, ONE_DEFAULT_THEME.typography, TYPOGRAPHY_KEYS, `${path}.typography`),
+    border: normalizeStringGroup(definition.border, ONE_DEFAULT_THEME.border, BORDER_KEYS, `${path}.border`),
+    radius: normalizeStringGroup(definition.radius, ONE_DEFAULT_THEME.radius, RADIUS_KEYS, `${path}.radius`)
+  });
+}
+function assertThemeName(name, path) {
+  if (name.length === 0 || name.trim() !== name || /\s/.test(name)) {
+    throw new OneThemeConfigError(`${path} must be a non-empty name without whitespace.`);
+  }
+}
+function normalizeOneThemeOptions(options = {}) {
+  assertRecord(options, "options");
+  assertKnownKeys(options, OPTION_KEYS, "options");
+  const themes = Object.create(null);
+  themes.default = ONE_DEFAULT_THEME;
+  if (options.themes !== undefined) {
+    assertRecord(options.themes, "options.themes");
+    for (const [name, definition] of Object.entries(options.themes)) {
+      assertThemeName(name, `options.themes.${name || "<empty>"}`);
+      if (name === "default") {
+        throw new OneThemeConfigError("options.themes.default is reserved by One UI.");
+      }
+      themes[name] = normalizeTheme(definition, `options.themes.${name}`);
+    }
+  }
+  const defaultTheme = options.defaultTheme ?? "default";
+  if (typeof defaultTheme !== "string") {
+    throw new OneThemeConfigError("options.defaultTheme must be a string.");
+  }
+  assertThemeName(defaultTheme, "options.defaultTheme");
+  if (!(defaultTheme in themes)) {
+    throw new OneThemeConfigError(`options.defaultTheme references unknown theme "${defaultTheme}".`);
+  }
+  return Object.freeze({
+    themes: Object.freeze(themes),
+    defaultTheme
+  });
+}
+
+// lib/theme/variables.ts
+var THEME_VARIABLES = [
+  ["--one-color-primary", (theme) => theme.colors.primary],
+  ["--one-color-primary-hover", (theme) => theme.colors.primaryHover],
+  ["--one-color-primary-contrast", (theme) => theme.colors.primaryContrast],
+  ["--one-color-secondary", (theme) => theme.colors.secondary],
+  ["--one-color-secondary-hover", (theme) => theme.colors.secondaryHover],
+  ["--one-color-secondary-contrast", (theme) => theme.colors.secondaryContrast],
+  ["--one-color-danger", (theme) => theme.colors.danger],
+  ["--one-color-danger-hover", (theme) => theme.colors.dangerHover],
+  ["--one-color-danger-contrast", (theme) => theme.colors.dangerContrast],
+  ["--one-color-info", (theme) => theme.colors.info],
+  ["--one-color-success", (theme) => theme.colors.success],
+  ["--one-color-warning", (theme) => theme.colors.warning],
+  ["--one-color-overlay", (theme) => theme.colors.overlay],
+  ["--one-color-surface", (theme) => theme.colors.surface],
+  ["--one-color-text", (theme) => theme.colors.text],
+  ["--one-color-muted", (theme) => theme.colors.muted],
+  ["--one-color-focus", (theme) => theme.colors.focus],
+  ["--one-color-border", (theme) => theme.border.color],
+  ["--one-font-family", (theme) => theme.typography.fontFamily],
+  ["--one-font-size-sm", (theme) => theme.typography.fontSizeSm],
+  ["--one-font-size-md", (theme) => theme.typography.fontSizeMd],
+  ["--one-font-size-lg", (theme) => theme.typography.fontSizeLg],
+  ["--one-line-height", (theme) => theme.typography.lineHeight],
+  ["--one-border-width", (theme) => theme.border.width],
+  ["--one-border-style", (theme) => theme.border.style],
+  ["--one-radius-sm", (theme) => theme.radius.sm],
+  ["--one-radius-md", (theme) => theme.radius.md],
+  ["--one-radius-lg", (theme) => theme.radius.lg]
+];
+var ONE_THEME_VARIABLES = Object.freeze(THEME_VARIABLES);
+function oneThemeToVariables(theme) {
+  return ONE_THEME_VARIABLES.map(([name, readValue]) => [
+    name,
+    readValue(theme)
+  ]);
+}
+
+// lib/theme/OneThemeService.ts
+var DEFAULT_REGISTRY = Object.freeze({ default: ONE_DEFAULT_THEME });
+function assertSwitchName(name) {
+  if (typeof name !== "string" || name.length === 0 || name.trim() !== name || /\s/.test(name)) {
+    throw new OneThemeConfigError("Theme name must be a non-empty string without whitespace.");
+  }
+}
+function snapshotRoot(root) {
+  return {
+    styles: ONE_THEME_VARIABLES.map(([name]) => ({
+      name,
+      value: root.style.getPropertyValue(name),
+      priority: root.style.getPropertyPriority(name)
+    })),
+    dataTheme: root.getAttribute("data-one-theme")
+  };
+}
+function restoreRoot(root, snapshot) {
+  snapshot.styles.forEach(({ name, value, priority }) => {
+    if (value.length === 0) {
+      root.style.removeProperty(name);
+      return;
+    }
+    root.style.setProperty(name, value, priority);
+  });
+  if (snapshot.dataTheme === null) {
+    root.removeAttribute("data-one-theme");
+  } else {
+    root.setAttribute("data-one-theme", snapshot.dataTheme);
+  }
+}
+function applyTheme(root, name, theme) {
+  const snapshot = snapshotRoot(root);
+  try {
+    oneThemeToVariables(theme).forEach(([property, value]) => {
+      root.style.setProperty(property, value);
+    });
+    root.setAttribute("data-one-theme", name);
+  } catch (error) {
+    restoreRoot(root, snapshot);
+    throw error;
+  }
+}
+
+class DomOneThemeService {
+  resolveRoot;
+  themes = DEFAULT_REGISTRY;
+  activeTheme = "default";
+  constructor(resolveRoot) {
+    this.resolveRoot = resolveRoot;
+  }
+  get currentTheme() {
+    return this.activeTheme;
+  }
+  init(options) {
+    const normalized = normalizeOneThemeOptions(options);
+    const root = this.requireRoot();
+    const theme = normalized.themes[normalized.defaultTheme];
+    applyTheme(root, normalized.defaultTheme, theme);
+    this.themes = normalized.themes;
+    this.activeTheme = normalized.defaultTheme;
+  }
+  switch(name) {
+    assertSwitchName(name);
+    if (!Object.prototype.hasOwnProperty.call(this.themes, name)) {
+      throw new OneThemeNotFoundError(name);
+    }
+    const root = this.requireRoot();
+    applyTheme(root, name, this.themes[name]);
+    this.activeTheme = name;
+  }
+  requireRoot() {
+    const root = this.resolveRoot();
+    if (!root) {
+      throw new OneThemeEnvironmentError;
+    }
+    return root;
+  }
+}
+function resolveDocumentRoot() {
+  return typeof document === "undefined" ? undefined : document.documentElement;
+}
+var oneTheme = new DomOneThemeService(resolveDocumentRoot);
+// lib/overlay/errors.ts
+class OneOverlayEnvironmentError extends Error {
+  constructor(message = "One overlay requires a browser document") {
+    super(message);
+    this.name = "OneOverlayEnvironmentError";
+  }
+}
+
+class OneOverlayContainerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OneOverlayContainerError";
+  }
+}
+
+class OneTooltipTriggerError extends Error {
+  constructor(message = "OneTooltip requires one HTMLElement trigger child") {
+    super(message);
+    this.name = "OneTooltipTriggerError";
+  }
+}
+
+// lib/overlay/container.ts
+function globalDocument() {
+  return typeof document === "undefined" ? null : document;
+}
+function resolveOneOverlayContainer(container, targetDocument = globalDocument()) {
+  if (!targetDocument) {
+    throw new OneOverlayEnvironmentError;
+  }
+  const resolved = typeof container === "function" ? container() : container ?? targetDocument.body;
+  if (!resolved) {
+    throw new OneOverlayContainerError("One overlay container was not found");
+  }
+  if (resolved.ownerDocument !== targetDocument) {
+    throw new OneOverlayContainerError("One overlay container must belong to the current document");
+  }
+  if (!resolved.isConnected) {
+    throw new OneOverlayContainerError("One overlay container must be connected");
+  }
+  if (resolved !== targetDocument.body) {
+    const bounds = resolved.getBoundingClientRect();
+    if (bounds.width <= 0 || bounds.height <= 0) {
+      throw new OneOverlayContainerError("One overlay container must have measurable layout");
+    }
+  }
+  return resolved;
+}
+// lib/overlay/host.ts
+class DomOneOverlayHost {
+  targetDocument;
+  entries = new Map;
+  records = new Map;
+  sequence = 0;
+  constructor(targetDocument) {
+    this.targetDocument = targetDocument;
+  }
+  open(request) {
+    const container = resolveOneOverlayContainer(request.container, this.targetDocument);
+    const entry = this.getOrCreateEntry(container);
+    const groupKey = request.group ? `${request.kind}:${request.group}` : undefined;
+    const parent = groupKey ? this.getOrCreateGroup(entry, groupKey, request.kind, request.group) : entry.element;
+    const id = `one-${request.kind}-${++this.sequence}`;
+    const slot8 = this.targetDocument.createElement("div");
+    slot8.dataset.oneOverlayId = id;
+    slot8.dataset.oneOverlayKind = request.kind;
+    parent.appendChild(slot8);
+    const record = {
+      id,
+      kind: request.kind,
+      container,
+      groupKey,
+      slot: slot8,
+      closed: false
+    };
+    this.records.set(id, record);
+    try {
+      record.managed = request.factory({
+        id,
+        slot: slot8,
+        requestClose: () => this.close(id),
+        isTop: () => this.isTop(id)
+      });
+    } catch (error) {
+      this.removeRecord(record, false);
+      throw error;
+    }
+    return {
+      id,
+      update: (options) => {
+        const current = this.records.get(id);
+        if (!current || current.closed) {
+          return;
+        }
+        current.managed?.update(options);
+      },
+      close: () => this.close(id)
+    };
+  }
+  close(id) {
+    const record = this.records.get(id);
+    if (!record || record.closed) {
+      return;
+    }
+    this.removeRecord(record, true);
+  }
+  closeAll(kind) {
+    [...this.records.values()].forEach((record) => {
+      if (!kind || record.kind === kind) {
+        this.close(record.id);
+      }
+    });
+  }
+  isTop(id) {
+    const record = this.records.get(id);
+    if (!record || record.closed) {
+      return false;
+    }
+    const matching = [...this.records.values()].filter((candidate) => !candidate.closed && candidate.kind === record.kind && candidate.container === record.container);
+    return matching[matching.length - 1]?.id === id;
+  }
+  getOrCreateEntry(container) {
+    const existing = this.entries.get(container);
+    if (existing) {
+      return existing;
+    }
+    const element = this.targetDocument.createElement("div");
+    element.dataset.oneOverlayHost = "";
+    container.appendChild(element);
+    const entry = { element, groups: new Map };
+    this.entries.set(container, entry);
+    return entry;
+  }
+  getOrCreateGroup(entry, key, kind, group) {
+    const existing = entry.groups.get(key);
+    if (existing) {
+      return existing;
+    }
+    const element = this.targetDocument.createElement("div");
+    element.dataset.oneOverlayGroup = group;
+    element.dataset.oneOverlayKind = kind;
+    entry.element.appendChild(element);
+    entry.groups.set(key, element);
+    return element;
+  }
+  removeRecord(record, destroy) {
+    record.closed = true;
+    this.records.delete(record.id);
+    if (destroy) {
+      record.managed?.destroy();
+    }
+    record.slot.remove();
+    const entry = this.entries.get(record.container);
+    if (!entry) {
+      return;
+    }
+    if (record.groupKey) {
+      const group = entry.groups.get(record.groupKey);
+      if (group && group.childElementCount === 0) {
+        group.remove();
+        entry.groups.delete(record.groupKey);
+      }
+    }
+    if (entry.element.childElementCount === 0) {
+      entry.element.remove();
+      this.entries.delete(record.container);
+    }
+  }
+}
+var defaultHosts = new WeakMap;
+function getDefaultOneOverlayHost(targetDocument) {
+  const resolved = targetDocument ?? (typeof document === "undefined" ? null : document);
+  if (!resolved) {
+    throw new OneOverlayEnvironmentError;
+  }
+  const existing = defaultHosts.get(resolved);
+  if (existing) {
+    return existing;
+  }
+  const host = new DomOneOverlayHost(resolved);
+  defaultHosts.set(resolved, host);
+  return host;
+}
+// lib/overlay/mount-controller.ts
+class OneOverlayMountController {
+  host;
+  kind;
+  factory;
+  group;
+  handle;
+  constructor(host, kind, factory, group) {
+    this.host = host;
+    this.kind = kind;
+    this.factory = factory;
+    this.group = group;
+  }
+  open(container) {
+    if (this.handle) {
+      return;
+    }
+    this.handle = this.host.open({
+      kind: this.kind,
+      group: this.group,
+      container,
+      factory: this.factory
+    });
+  }
+  update(options) {
+    this.handle?.update(options);
+  }
+  close() {
+    this.handle?.close();
+    this.handle = undefined;
+  }
+  isOpen() {
+    return this.handle !== undefined;
+  }
+}
+// lib/overlay/positioner.ts
+var OPPOSITE = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+};
+var CLOCKWISE = {
+  top: "right",
+  right: "bottom",
+  bottom: "left",
+  left: "top"
+};
+var COUNTER_CLOCKWISE = {
+  top: "left",
+  right: "top",
+  bottom: "right",
+  left: "bottom"
+};
+function parsePlacement(placement) {
+  const [side, alignment = "center"] = placement.split("-");
+  return { side, alignment };
+}
+function formatPlacement(side, alignment) {
+  return alignment === "center" ? side : `${side}-${alignment}`;
+}
+function clamp(value, minimum, maximum) {
+  if (maximum < minimum) {
+    return minimum;
+  }
+  return Math.min(Math.max(value, minimum), maximum);
+}
+function coordinates(reference, floating, side, alignment, offset) {
+  let x = reference.left + (reference.width - floating.width) / 2;
+  let y = reference.top + (reference.height - floating.height) / 2;
+  if (side === "top") {
+    y = reference.top - floating.height - offset;
+  } else if (side === "bottom") {
+    y = reference.bottom + offset;
+  } else if (side === "left") {
+    x = reference.left - floating.width - offset;
+  } else {
+    x = reference.right + offset;
+  }
+  if (side === "top" || side === "bottom") {
+    if (alignment === "start") {
+      x = reference.left;
+    } else if (alignment === "end") {
+      x = reference.right - floating.width;
+    }
+  } else if (alignment === "start") {
+    y = reference.top;
+  } else if (alignment === "end") {
+    y = reference.bottom - floating.height;
+  }
+  return { x, y };
+}
+function fits(point, floating, boundary, padding) {
+  return point.x >= boundary.left + padding && point.y >= boundary.top + padding && point.x + floating.width <= boundary.right - padding && point.y + floating.height <= boundary.bottom - padding;
+}
+function visibleArea(point, floating, boundary, padding) {
+  const left = Math.max(point.x, boundary.left + padding);
+  const top = Math.max(point.y, boundary.top + padding);
+  const right = Math.min(point.x + floating.width, boundary.right - padding);
+  const bottom = Math.min(point.y + floating.height, boundary.bottom - padding);
+  return Math.max(0, right - left) * Math.max(0, bottom - top);
+}
+function scrollAncestors(element) {
+  const targets = new Set;
+  const view = element.ownerDocument.defaultView;
+  let current = element.parentElement;
+  while (current) {
+    const style = view?.getComputedStyle(current);
+    if (style && /(auto|scroll|overlay)/.test(style.overflow + style.overflowX + style.overflowY)) {
+      targets.add(current);
+    }
+    current = current.parentElement;
+  }
+  if (view) {
+    targets.add(view);
+  }
+  return [...targets];
+}
+
+class OneFloatingPositioner {
+  compute(request) {
+    const preferred = parsePlacement(request.placement);
+    const sides = [
+      preferred.side,
+      OPPOSITE[preferred.side],
+      CLOCKWISE[preferred.side],
+      COUNTER_CLOCKWISE[preferred.side]
+    ];
+    const candidates = sides.map((side) => ({
+      placement: formatPlacement(side, preferred.alignment),
+      side,
+      point: coordinates(request.reference, request.floating, side, preferred.alignment, request.offset)
+    }));
+    const selected = candidates.find((candidate) => fits(candidate.point, request.floating, request.boundary, request.padding)) ?? candidates.reduce((best, candidate) => visibleArea(candidate.point, request.floating, request.boundary, request.padding) > visibleArea(best.point, request.floating, request.boundary, request.padding) ? candidate : best);
+    const x = clamp(selected.point.x, request.boundary.left + request.padding, request.boundary.right - request.padding - request.floating.width);
+    const y = clamp(selected.point.y, request.boundary.top + request.padding, request.boundary.bottom - request.padding - request.floating.height);
+    const centerX = request.reference.left + request.reference.width / 2;
+    const centerY = request.reference.top + request.reference.height / 2;
+    const arrow = selected.side === "top" || selected.side === "bottom" ? {
+      x: clamp(centerX - x, 8, Math.max(8, request.floating.width - 8))
+    } : {
+      y: clamp(centerY - y, 8, Math.max(8, request.floating.height - 8))
+    };
+    return { x, y, placement: selected.placement, arrow };
+  }
+  autoUpdate(reference, floating, update) {
+    const view = reference.ownerDocument.defaultView;
+    if (!view) {
+      return () => {};
+    }
+    let disposed = false;
+    let frame;
+    const schedule = () => {
+      if (disposed || frame !== undefined) {
+        return;
+      }
+      frame = view.requestAnimationFrame(() => {
+        frame = undefined;
+        if (!disposed) {
+          update();
+        }
+      });
+    };
+    const targets = new Set([
+      ...scrollAncestors(reference),
+      ...scrollAncestors(floating)
+    ]);
+    targets.forEach((target) => target.addEventListener("scroll", schedule));
+    view.addEventListener("resize", schedule);
+    const observer = view.ResizeObserver ? new view.ResizeObserver(schedule) : undefined;
+    observer?.observe(reference);
+    observer?.observe(floating);
+    return () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      if (frame !== undefined) {
+        view.cancelAnimationFrame(frame);
+        frame = undefined;
+      }
+      observer?.disconnect();
+      targets.forEach((target) => target.removeEventListener("scroll", schedule));
+      view.removeEventListener("resize", schedule);
+    };
+  }
+}
+// lib/alert/OneAlert.ts
+import { Component as Component16, slot as slot8 } from "@geektech/tsone";
+var VARIANTS2 = [
+  "info",
+  "success",
+  "warning",
+  "error"
+];
+var DEFAULT_ICONS = {
+  info: "i",
+  success: "✓",
+  warning: "!",
+  error: "×"
+};
+var ONE_ALERT_STYLES = [
+  {
+    name: "one-alert-base",
+    selector: ".one-alert",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      display: "grid",
+      gridTemplateColumns: "auto minmax(0, 1fr) auto",
+      gap: `var(--one-alert-gap, var(--one-space-sm, ${ONE_THEME_DEFAULTS.spaceSm}))`,
+      alignItems: "start",
+      padding: `var(--one-alert-padding, var(--one-space-md, ${ONE_THEME_DEFAULTS.spaceMd}))`,
+      color: `var(--one-alert-color, var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText}))`,
+      backgroundColor: `var(--one-alert-background, var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface}))`,
+      border: oneThemeBorder(`var(--one-alert-border-color, var(--one-color-border, ${ONE_THEME_DEFAULTS.colorBorder}))`),
+      borderRadius: `var(--one-alert-radius, var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd}))`
+    }
+  },
+  {
+    name: "one-alert-info",
+    selector: ".one-alert--info",
+    properties: {
+      borderColor: `var(--one-color-info, ${ONE_THEME_DEFAULTS.colorInfo})`
+    }
+  },
+  {
+    name: "one-alert-success",
+    selector: ".one-alert--success",
+    properties: {
+      borderColor: `var(--one-color-success, ${ONE_THEME_DEFAULTS.colorSuccess})`
+    }
+  },
+  {
+    name: "one-alert-warning",
+    selector: ".one-alert--warning",
+    properties: {
+      borderColor: `var(--one-color-warning, ${ONE_THEME_DEFAULTS.colorWarning})`
+    }
+  },
+  {
+    name: "one-alert-error",
+    selector: ".one-alert--error",
+    properties: {
+      borderColor: `var(--one-color-danger, ${ONE_THEME_DEFAULTS.colorDanger})`
+    }
+  },
+  {
+    name: "one-alert-icon",
+    selector: ".one-alert__icon",
+    properties: {
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      minWidth: "20px",
+      fontWeight: "700"
+    }
+  },
+  {
+    name: "one-alert-title",
+    selector: ".one-alert__title",
+    properties: { fontWeight: "600" }
+  },
+  {
+    name: "one-alert-description",
+    selector: ".one-alert__description",
+    properties: {
+      marginTop: `var(--one-space-xs, ${ONE_THEME_DEFAULTS.spaceXs})`,
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`
+    }
+  },
+  {
+    name: "one-alert-actions",
+    selector: ".one-alert__actions",
+    properties: { alignSelf: "center" }
+  },
+  {
+    name: "one-alert-controls",
+    selector: ".one-alert__controls",
+    properties: {
+      display: "inline-flex",
+      gap: `var(--one-space-sm, ${ONE_THEME_DEFAULTS.spaceSm})`,
+      alignItems: "center"
+    }
+  },
+  {
+    name: "one-alert-close",
+    selector: ".one-alert__close",
+    properties: {
+      padding: "2px",
+      color: "inherit",
+      backgroundColor: "transparent",
+      border: "0",
+      cursor: "pointer"
+    }
+  }
+];
+function normalizeVariant(value) {
+  return VARIANTS2.includes(value) ? value : "info";
+}
+function hasNamedSlot3(children, name) {
+  return children.some((child) => typeof child !== "string" && child.slot === name);
+}
+function hasDefaultSlot2(children) {
+  return children.some((child) => typeof child === "string" || child.slot === undefined);
+}
+
+class OneAlert extends Component16 {
+  initState() {
+    return { visible: true };
+  }
+  initStyles() {
+    ONE_ALERT_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  render() {
+    if (!this.state.visible) {
+      return {
+        tag: "span",
+        props: { hidden: true, "data-one-alert-anchor": "" }
+      };
+    }
+    const variant = normalizeVariant(this.props.variant);
+    const children = this.props.children ?? [];
+    const customIcon = hasNamedSlot3(children, "icon");
+    const customActions = hasNamedSlot3(children, "actions");
+    const customDescription = hasDefaultSlot2(children);
+    return {
+      tag: "section",
+      props: {
+        className: `one-alert one-alert--${variant}`,
+        role: variant === "warning" || variant === "error" ? "alert" : "status"
+      },
+      children: [
+        {
+          tag: "div",
+          props: { className: "one-alert__icon", "aria-hidden": "true" },
+          children: customIcon ? [slot8("icon")] : [DEFAULT_ICONS[variant]]
+        },
+        {
+          tag: "div",
+          props: { className: "one-alert__content" },
+          children: [
+            ...this.props.title ? [
+              {
+                tag: "div",
+                props: { className: "one-alert__title" },
+                children: [this.props.title]
+              }
+            ] : [],
+            ...customDescription || this.props.description ? [
+              {
+                tag: "div",
+                props: { className: "one-alert__description" },
+                children: customDescription ? [slot8("default")] : [this.props.description ?? ""]
+              }
+            ] : []
+          ]
+        },
+        ...customActions || this.props.closable ? [
+          {
+            tag: "div",
+            props: { className: "one-alert__controls" },
+            children: [
+              ...customActions ? [
+                {
+                  tag: "div",
+                  props: { className: "one-alert__actions" },
+                  children: [slot8("actions")]
+                }
+              ] : [],
+              ...this.props.closable ? [
+                {
+                  tag: "button",
+                  props: {
+                    type: "button",
+                    className: "one-alert__close",
+                    "aria-label": "关闭提示"
+                  },
+                  children: ["×"],
+                  listeners: { click: () => this.close() }
+                }
+              ] : []
+            ]
+          }
+        ] : []
+      ]
+    };
+  }
+  close() {
+    if (!this.state.visible) {
+      return;
+    }
+    this.emit("close");
+    this.state.visible = false;
+  }
+}
+// lib/message/MessageOverlay.ts
+import { Component as Component17 } from "@geektech/tsone";
+
+// lib/message/timer.ts
+var DEFAULT_SCHEDULER = {
+  now: () => typeof performance === "undefined" ? Date.now() : performance.now(),
+  set: (callback, delay) => globalThis.setTimeout(callback, delay),
+  clear: (handle) => globalThis.clearTimeout(handle)
+};
+
+class OneMessageTimer {
+  scheduler;
+  onElapsed;
+  handle;
+  remaining = 0;
+  startedAt = 0;
+  paused = false;
+  disposed = false;
+  constructor(duration, scheduler = DEFAULT_SCHEDULER, onElapsed) {
+    this.scheduler = scheduler;
+    this.onElapsed = onElapsed;
+    this.reset(duration);
+  }
+  pause() {
+    if (this.disposed || this.paused || this.handle === undefined) {
+      return;
+    }
+    this.remaining = Math.max(0, this.remaining - (this.scheduler.now() - this.startedAt));
+    this.clear();
+    this.paused = true;
+  }
+  resume() {
+    if (this.disposed || !this.paused) {
+      return;
+    }
+    this.paused = false;
+    this.schedule();
+  }
+  reset(duration) {
+    if (this.disposed) {
+      return;
+    }
+    this.clear();
+    this.remaining = normalizeDuration(duration);
+    this.paused = false;
+    this.schedule();
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.clear();
+  }
+  schedule() {
+    if (this.remaining <= 0) {
+      return;
+    }
+    this.startedAt = this.scheduler.now();
+    this.handle = this.scheduler.set(() => {
+      this.handle = undefined;
+      this.remaining = 0;
+      if (!this.disposed) {
+        this.onElapsed();
+      }
+    }, this.remaining);
+  }
+  clear() {
+    if (this.handle === undefined) {
+      return;
+    }
+    this.scheduler.clear(this.handle);
+    this.handle = undefined;
+  }
+}
+function normalizeDuration(duration) {
+  return Number.isFinite(duration) && duration > 0 ? duration : 0;
+}
+
+// lib/message/MessageOverlay.ts
+var ONE_MESSAGE_STYLES = [
+  {
+    name: "one-message-group",
+    selector: ".one-overlay-group--message",
+    properties: {
+      position: "fixed",
+      zIndex: `var(--one-z-index-message, ${ONE_THEME_DEFAULTS.zIndexMessage})`,
+      display: "flex",
+      flexDirection: "column",
+      gap: `var(--one-space-sm, ${ONE_THEME_DEFAULTS.spaceSm})`,
+      width: "min(420px, calc(100vw - 32px))",
+      pointerEvents: "none"
+    }
+  },
+  {
+    name: "one-message-group-top",
+    selector: '.one-overlay-group--message[data-one-message-placement^="top"]',
+    properties: { top: "16px" }
+  },
+  {
+    name: "one-message-group-bottom",
+    selector: '.one-overlay-group--message[data-one-message-placement^="bottom"]',
+    properties: { bottom: "16px", flexDirection: "column-reverse" }
+  },
+  {
+    name: "one-message-group-center",
+    selector: '.one-overlay-group--message[data-one-message-placement="top"], .one-overlay-group--message[data-one-message-placement="bottom"]',
+    properties: { left: "50%", transform: "translateX(-50%)" }
+  },
+  {
+    name: "one-message-group-start",
+    selector: '.one-overlay-group--message[data-one-message-placement$="start"]',
+    properties: { left: "16px" }
+  },
+  {
+    name: "one-message-group-end",
+    selector: '.one-overlay-group--message[data-one-message-placement$="end"]',
+    properties: { right: "16px" }
+  },
+  {
+    name: "one-message-base",
+    selector: ".one-message",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      display: "grid",
+      gridTemplateColumns: "minmax(0, 1fr) auto",
+      alignItems: "center",
+      gap: `var(--one-space-sm, ${ONE_THEME_DEFAULTS.spaceSm})`,
+      boxSizing: "border-box",
+      padding: `var(--one-space-md, ${ONE_THEME_DEFAULTS.spaceMd}) var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg})`,
+      color: `var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText})`,
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      border: oneThemeBorder(),
+      borderRadius: `var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd})`,
+      boxShadow: `var(--one-shadow-overlay, ${ONE_THEME_DEFAULTS.shadowOverlay})`,
+      pointerEvents: "auto"
+    }
+  },
+  {
+    name: "one-message-info",
+    selector: ".one-message--info",
+    properties: {
+      borderColor: `var(--one-color-info, ${ONE_THEME_DEFAULTS.colorInfo})`
+    }
+  },
+  {
+    name: "one-message-success",
+    selector: ".one-message--success",
+    properties: {
+      borderColor: `var(--one-color-success, ${ONE_THEME_DEFAULTS.colorSuccess})`
+    }
+  },
+  {
+    name: "one-message-warning",
+    selector: ".one-message--warning",
+    properties: {
+      borderColor: `var(--one-color-warning, ${ONE_THEME_DEFAULTS.colorWarning})`
+    }
+  },
+  {
+    name: "one-message-error",
+    selector: ".one-message--error",
+    properties: {
+      borderColor: `var(--one-color-danger, ${ONE_THEME_DEFAULTS.colorDanger})`
+    }
+  },
+  {
+    name: "one-message-close",
+    selector: ".one-message__close",
+    properties: {
+      padding: "2px",
+      color: "inherit",
+      backgroundColor: "transparent",
+      border: "0",
+      cursor: "pointer"
+    }
+  }
+];
+
+class MessageOverlay extends Component17 {
+  timer;
+  mount(container) {
+    super.mount(container);
+    this.decorateGroup();
+  }
+  initState() {
+    return {};
+  }
+  initStyles() {
+    ONE_MESSAGE_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  onMounted() {
+    this.timer = new OneMessageTimer(this.props.duration, undefined, () => {
+      this.props.requestClose();
+    });
+  }
+  onUnmounted() {
+    this.timer?.dispose();
+    this.timer = undefined;
+  }
+  setProps(props) {
+    const durationChanged = props.duration !== undefined && props.duration !== this.props.duration;
+    super.setProps(props);
+    if (durationChanged) {
+      this.timer?.reset(this.props.duration);
+    }
+  }
+  render() {
+    const urgent = this.props.variant === "warning" || this.props.variant === "error";
+    return {
+      tag: "div",
+      props: {
+        className: `one-message one-message--${this.props.variant}`,
+        role: urgent ? "alert" : "status",
+        "data-one-message-placement": this.props.placement
+      },
+      children: [
+        {
+          tag: "div",
+          props: { className: "one-message__content" },
+          children: [this.props.content]
+        },
+        ...this.props.closable ? [
+          {
+            tag: "button",
+            props: {
+              type: "button",
+              className: "one-message__close",
+              "aria-label": "关闭消息"
+            },
+            children: ["×"],
+            listeners: { click: () => this.props.requestClose() }
+          }
+        ] : []
+      ],
+      listeners: {
+        mouseenter: () => this.timer?.pause(),
+        mouseleave: () => this.timer?.resume()
+      }
+    };
+  }
+  decorateGroup() {
+    const element = this.getElement();
+    if (!(element instanceof HTMLElement)) {
+      return;
+    }
+    const group = element.parentElement?.parentElement;
+    if (group?.dataset.oneOverlayKind !== "message") {
+      return;
+    }
+    group.classList.add("one-overlay-group", "one-overlay-group--message");
+    group.dataset.oneMessagePlacement = this.props.placement;
+  }
+}
+// lib/message/OneMessage.ts
+import { Component as Component18 } from "@geektech/tsone";
+
+// lib/message/normalize.ts
+var VARIANTS3 = [
+  "info",
+  "success",
+  "warning",
+  "error"
+];
+var PLACEMENTS = [
+  "top-start",
+  "top",
+  "top-end",
+  "bottom-start",
+  "bottom",
+  "bottom-end"
+];
+function normalizeOneMessageOptions(options) {
+  return {
+    ...options,
+    variant: VARIANTS3.includes(options.variant) ? options.variant : "info",
+    duration: typeof options.duration === "number" && Number.isFinite(options.duration) && options.duration >= 0 ? options.duration : 3000,
+    placement: PLACEMENTS.includes(options.placement) ? options.placement : "top"
+  };
+}
+
+// lib/message/OneMessage.ts
+class OneMessage extends Component18 {
+  controller;
+  viewMounted = false;
+  initState() {
+    return { internalOpen: this.props.defaultOpen === true };
+  }
+  initStyles() {}
+  onMounted() {
+    const options = normalizeOneMessageOptions(this.props);
+    this.controller = new OneOverlayMountController(getDefaultOneOverlayHost(), "message", (context) => this.createOverlay(context), options.placement);
+    this.synchronizeOverlay();
+  }
+  beforeUpdate() {
+    this.synchronizeOverlay();
+  }
+  beforeUnmount() {
+    this.controller?.close();
+    this.controller = undefined;
+  }
+  render() {
+    return {
+      tag: "span",
+      props: { hidden: true, "data-one-message-anchor": "" }
+    };
+  }
+  createOverlay(context) {
+    const options = normalizeOneMessageOptions(this.props);
+    const overlay = new MessageOverlay({
+      ...options,
+      requestClose: () => this.requestClose()
+    });
+    overlay.mount(context.slot);
+    this.viewMounted = true;
+    return {
+      update: (next) => {
+        const normalized = normalizeOneMessageOptions({
+          ...options,
+          ...next
+        });
+        overlay.setProps({ ...normalized });
+      },
+      destroy: () => {
+        overlay.unmount();
+        if (this.viewMounted) {
+          this.viewMounted = false;
+          this.emit("afterClose");
+        }
+      }
+    };
+  }
+  synchronizeOverlay() {
+    if (!this.controller) {
+      return;
+    }
+    const open = this.props.open === undefined ? this.state.internalOpen : this.props.open === true;
+    if (!open) {
+      this.controller.close();
+      return;
+    }
+    const options = normalizeOneMessageOptions(this.props);
+    this.controller.open(options.container);
+    this.controller.update(options);
+  }
+  requestClose() {
+    this.emit("openChange", false);
+    this.emit("close");
+    if (this.props.open !== undefined) {
+      return;
+    }
+    this.state.internalOpen = false;
+    this.controller?.close();
+  }
+}
+// lib/message/service.ts
+class OneMessageService {
+  suppliedHost;
+  constructor(suppliedHost) {
+    this.suppliedHost = suppliedHost;
+  }
+  open(options) {
+    const host = this.suppliedHost ?? getDefaultOneOverlayHost();
+    let current = normalizeOneMessageOptions(options);
+    const hostHandle = host.open({
+      kind: "message",
+      group: current.placement,
+      container: current.container,
+      factory: ({ slot: slot9, requestClose }) => {
+        const overlay = new MessageOverlay({
+          ...current,
+          requestClose
+        });
+        overlay.mount(slot9);
+        return {
+          update: (next) => {
+            current = normalizeOneMessageOptions({ ...current, ...next });
+            overlay.setProps({ ...current });
+          },
+          destroy: () => overlay.unmount()
+        };
+      }
+    });
+    return {
+      id: hostHandle.id,
+      update: (next) => hostHandle.update(next),
+      close: () => hostHandle.close()
+    };
+  }
+  info(content, options = {}) {
+    return this.open({ ...options, content, variant: "info" });
+  }
+  success(content, options = {}) {
+    return this.open({ ...options, content, variant: "success" });
+  }
+  warning(content, options = {}) {
+    return this.open({ ...options, content, variant: "warning" });
+  }
+  error(content, options = {}) {
+    return this.open({ ...options, content, variant: "error" });
+  }
+  close(id) {
+    (this.suppliedHost ?? getDefaultOneOverlayHost()).close(id);
+  }
+  closeAll() {
+    (this.suppliedHost ?? getDefaultOneOverlayHost()).closeAll("message");
+  }
+}
+function createOneMessageService(host) {
+  return new OneMessageService(host);
+}
+var oneMessage = createOneMessageService();
+// lib/dialog/DialogOverlay.ts
+import { Component as Component19, slot as slot9 } from "@geektech/tsone";
+
+// lib/dialog/focus-manager.ts
+var FOCUSABLE_SELECTOR = [
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "a[href]",
+  '[tabindex]:not([tabindex="-1"])'
+].join(",");
+
+class OneDialogFocusManager {
+  dialog;
+  previousFocus;
+  isTop = () => true;
+  targetDocument;
+  activate(dialog, isTop = () => true) {
+    this.deactivate(false);
+    this.dialog = dialog;
+    this.targetDocument = dialog.ownerDocument;
+    this.isTop = isTop;
+    const active = this.targetDocument.activeElement;
+    this.previousFocus = active instanceof HTMLElement ? active : undefined;
+    this.targetDocument.addEventListener("keydown", this.handleKeydown);
+    (this.focusableElements()[0] ?? dialog).focus();
+  }
+  deactivate(restoreFocus = true) {
+    this.targetDocument?.removeEventListener("keydown", this.handleKeydown);
+    if (restoreFocus && this.previousFocus?.isConnected) {
+      this.previousFocus.focus();
+    }
+    this.dialog = undefined;
+    this.previousFocus = undefined;
+    this.targetDocument = undefined;
+    this.isTop = () => true;
+  }
+  handleKeydown = (event) => {
+    if (event.key !== "Tab" || !this.dialog || !this.isTop()) {
+      return;
+    }
+    const focusable = this.focusableElements();
+    if (focusable.length === 0) {
+      event.preventDefault();
+      this.dialog.focus();
+      return;
+    }
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = this.targetDocument?.activeElement ?? null;
+    if (event.shiftKey && (active === first || !this.dialog.contains(active))) {
+      event.preventDefault();
+      last.focus();
+    } else if (!event.shiftKey && active === last) {
+      event.preventDefault();
+      first.focus();
+    }
+  };
+  focusableElements() {
+    if (!this.dialog) {
+      return [];
+    }
+    return [
+      ...this.dialog.querySelectorAll(FOCUSABLE_SELECTOR)
+    ].filter((element) => element.getAttribute("aria-hidden") !== "true" && !element.hasAttribute("hidden"));
+  }
+}
+
+// lib/dialog/scroll-lock.ts
+var scrollLocks = new WeakMap;
+function lockOneDialogBody(targetDocument) {
+  const existing = scrollLocks.get(targetDocument);
+  if (existing) {
+    existing.count += 1;
+  } else {
+    scrollLocks.set(targetDocument, {
+      count: 1,
+      previousOverflow: targetDocument.body.style.overflow
+    });
+    targetDocument.body.style.overflow = "hidden";
+  }
+  let released = false;
+  return () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    unlockOneDialogBody(targetDocument);
+  };
+}
+function unlockOneDialogBody(targetDocument) {
+  const record = scrollLocks.get(targetDocument);
+  if (!record) {
+    return;
+  }
+  record.count -= 1;
+  if (record.count > 0) {
+    return;
+  }
+  targetDocument.body.style.overflow = record.previousOverflow;
+  scrollLocks.delete(targetDocument);
+}
+
+// lib/dialog/DialogOverlay.ts
+var ONE_DIALOG_STYLES = [
+  {
+    name: "one-dialog-backdrop",
+    selector: ".one-dialog__backdrop",
+    properties: {
+      position: "fixed",
+      inset: "0",
+      zIndex: `var(--one-z-index-dialog, ${ONE_THEME_DEFAULTS.zIndexDialog})`,
+      display: "grid",
+      placeItems: "center",
+      boxSizing: "border-box",
+      padding: `var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg})`,
+      backgroundColor: `var(--one-color-overlay, ${ONE_THEME_DEFAULTS.colorOverlay})`
+    }
+  },
+  {
+    name: "one-dialog-backdrop-contained",
+    selector: ".one-dialog__backdrop--contained",
+    properties: { position: "absolute" }
+  },
+  {
+    name: "one-dialog-panel",
+    selector: ".one-dialog",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      width: "min(520px, 100%)",
+      maxHeight: "calc(100vh - 32px)",
+      overflow: "auto",
+      color: `var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText})`,
+      backgroundColor: `var(--one-color-surface, ${ONE_THEME_DEFAULTS.colorSurface})`,
+      border: oneThemeBorder(),
+      borderRadius: `var(--one-radius-lg, ${ONE_THEME_DEFAULTS.radiusMd})`,
+      boxShadow: `var(--one-shadow-overlay, ${ONE_THEME_DEFAULTS.shadowOverlay})`
+    }
+  },
+  {
+    name: "one-dialog-header",
+    selector: ".one-dialog__header",
+    properties: {
+      padding: `var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg})`,
+      fontSize: "18px",
+      fontWeight: "600",
+      borderBottom: oneThemeBorder()
+    }
+  },
+  {
+    name: "one-dialog-body",
+    selector: ".one-dialog__body",
+    properties: {
+      padding: `var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg})`,
+      color: `var(--one-color-muted, ${ONE_THEME_DEFAULTS.colorMuted})`
+    }
+  },
+  {
+    name: "one-dialog-footer",
+    selector: ".one-dialog__footer",
+    properties: {
+      display: "flex",
+      justifyContent: "flex-end",
+      gap: `var(--one-space-sm, ${ONE_THEME_DEFAULTS.spaceSm})`,
+      padding: `var(--one-space-md, ${ONE_THEME_DEFAULTS.spaceMd}) var(--one-space-lg, ${ONE_THEME_DEFAULTS.spaceLg})`,
+      borderTop: oneThemeBorder()
+    }
+  },
+  {
+    name: "one-dialog-button",
+    selector: ".one-dialog__cancel, .one-dialog__confirm",
+    properties: {
+      minHeight: "36px",
+      padding: "0 14px",
+      border: oneThemeBorder(),
+      borderRadius: `var(--one-radius-md, ${ONE_THEME_DEFAULTS.radiusMd})`,
+      cursor: "pointer"
+    }
+  },
+  {
+    name: "one-dialog-confirm",
+    selector: ".one-dialog__confirm",
+    properties: {
+      color: "#ffffff",
+      backgroundColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`,
+      borderColor: `var(--one-color-primary, ${ONE_THEME_DEFAULTS.colorPrimary})`
+    }
+  }
+];
+function hasSlot(children, name) {
+  return children.some((child) => {
+    if (typeof child === "string") {
+      return name === "default";
+    }
+    return (child.slot ?? "default") === name;
+  });
+}
+
+class DialogOverlay extends Component19 {
+  focusManager = new OneDialogFocusManager;
+  releaseScrollLock;
+  targetDocument;
+  mount(container) {
+    super.mount(container);
+    const panel = this.getPanel();
+    if (panel) {
+      this.focusManager.activate(panel, this.props.isTop);
+    }
+  }
+  initState() {
+    return {};
+  }
+  initStyles() {
+    ONE_DIALOG_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  onMounted() {
+    const panel = this.getPanel();
+    const targetDocument = panel?.ownerDocument;
+    if (!panel || !targetDocument) {
+      return;
+    }
+    this.targetDocument = targetDocument;
+    if (this.props.lockBody) {
+      this.releaseScrollLock = lockOneDialogBody(targetDocument);
+    }
+    targetDocument.addEventListener("keydown", this.handleEscape);
+  }
+  onUnmounted() {
+    this.targetDocument?.removeEventListener("keydown", this.handleEscape);
+    this.focusManager.deactivate();
+    this.releaseScrollLock?.();
+    this.releaseScrollLock = undefined;
+    this.targetDocument = undefined;
+  }
+  render() {
+    const children = this.props.children ?? [];
+    const customHeader = hasSlot(children, "header");
+    const customBody = hasSlot(children, "default");
+    const customFooter = hasSlot(children, "footer");
+    const titleId = `${this.props.id}-title`;
+    const descriptionId = `${this.props.id}-description`;
+    const hasHeader = customHeader || Boolean(this.props.title);
+    const hasBody = customBody || this.props.content !== undefined || Boolean(this.props.description);
+    return {
+      tag: "div",
+      props: {
+        className: [
+          "one-dialog__backdrop",
+          ...!this.props.lockBody ? ["one-dialog__backdrop--contained"] : []
+        ].join(" ")
+      },
+      children: [
+        {
+          tag: "section",
+          props: {
+            className: "one-dialog",
+            role: "dialog",
+            tabindex: "-1",
+            "aria-modal": "true",
+            "aria-labelledby": hasHeader ? titleId : undefined,
+            "aria-describedby": hasBody ? descriptionId : undefined
+          },
+          children: [
+            ...hasHeader ? [
+              {
+                tag: "header",
+                props: { className: "one-dialog__header", id: titleId },
+                children: customHeader ? [slot9("header")] : [this.props.title ?? ""]
+              }
+            ] : [],
+            ...hasBody ? [
+              {
+                tag: "div",
+                props: { className: "one-dialog__body", id: descriptionId },
+                children: customBody ? [slot9("default")] : [this.props.content ?? this.props.description ?? ""]
+              }
+            ] : [],
+            {
+              tag: "footer",
+              props: { className: "one-dialog__footer" },
+              children: customFooter ? [slot9("footer")] : [
+                {
+                  tag: "button",
+                  props: {
+                    type: "button",
+                    className: "one-dialog__cancel",
+                    disabled: this.props.confirmLoading === true
+                  },
+                  children: [this.props.cancelText ?? "取消"],
+                  listeners: {
+                    click: () => this.requestClose("cancel")
+                  }
+                },
+                {
+                  tag: "button",
+                  props: {
+                    type: "button",
+                    className: "one-dialog__confirm",
+                    disabled: this.props.confirmLoading === true,
+                    "aria-busy": this.props.confirmLoading ? "true" : undefined
+                  },
+                  children: [
+                    this.props.confirmLoading ? "处理中…" : this.props.confirmText ?? "确认"
+                  ],
+                  listeners: {
+                    click: () => this.requestClose("confirm")
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      listeners: {
+        click: (event) => {
+          if (event.target === event.currentTarget) {
+            this.requestClose("overlay");
+          }
+        }
+      }
+    };
+  }
+  handleEscape = (event) => {
+    if (event.key === "Escape") {
+      this.requestClose("escape");
+    }
+  };
+  requestClose(reason) {
+    if (!this.props.isTop() || this.props.confirmLoading) {
+      return;
+    }
+    if (reason === "overlay" && this.props.closeOnOverlay === false) {
+      return;
+    }
+    if (reason === "escape" && this.props.closeOnEscape === false) {
+      return;
+    }
+    this.props.requestClose(reason);
+  }
+  getPanel() {
+    const element = this.getElement();
+    return element instanceof HTMLElement ? element.querySelector(".one-dialog") : null;
+  }
+}
+// lib/dialog/OneDialog.ts
+import { Component as Component20 } from "@geektech/tsone";
+class OneDialog extends Component20 {
+  controller;
+  lockBody = true;
+  viewMounted = false;
+  initState() {
+    return { internalOpen: this.props.defaultOpen === true };
+  }
+  initStyles() {}
+  onMounted() {
+    this.controller = new OneOverlayMountController(getDefaultOneOverlayHost(), "dialog", (context) => this.createOverlay(context));
+    this.synchronizeOverlay();
+  }
+  beforeUpdate() {
+    this.synchronizeOverlay();
+  }
+  beforeUnmount() {
+    this.controller?.close();
+    this.controller = undefined;
+  }
+  render() {
+    return {
+      tag: "span",
+      props: { hidden: true, "data-one-dialog-anchor": "" }
+    };
+  }
+  createOverlay(context) {
+    const overlay = new DialogOverlay({
+      ...this.props,
+      id: context.id,
+      lockBody: this.lockBody,
+      isTop: context.isTop,
+      requestClose: (reason) => this.requestClose(reason)
+    });
+    overlay.mount(context.slot);
+    this.viewMounted = true;
+    return {
+      update: (next) => overlay.setProps(next),
+      destroy: () => {
+        overlay.unmount();
+        if (this.viewMounted) {
+          this.viewMounted = false;
+          this.emit("afterClose");
+        }
+      }
+    };
+  }
+  synchronizeOverlay() {
+    if (!this.controller) {
+      return;
+    }
+    const open = this.props.open === undefined ? this.state.internalOpen : this.props.open === true;
+    if (!open) {
+      this.controller.close();
+      return;
+    }
+    const resolved = resolveOneOverlayContainer(this.props.container);
+    this.lockBody = resolved === resolved.ownerDocument.body;
+    this.controller.open(resolved);
+    this.controller.update(this.props);
+  }
+  requestClose(reason) {
+    if (reason === "confirm") {
+      this.emit("confirm");
+    } else {
+      this.emit("cancel", reason);
+    }
+    this.emit("openChange", false);
+    if (this.props.open !== undefined) {
+      return;
+    }
+    this.state.internalOpen = false;
+    this.controller?.close();
+  }
+}
+// lib/dialog/service.ts
+class OneDialogService {
+  suppliedHost;
+  constructor(suppliedHost) {
+    this.suppliedHost = suppliedHost;
+  }
+  open(options) {
+    return this.openInternal(options);
+  }
+  confirm(options) {
+    return new Promise((resolve) => {
+      this.openInternal(options, resolve);
+    });
+  }
+  close(id) {
+    (this.suppliedHost ?? getDefaultOneOverlayHost()).close(id);
+  }
+  closeAll() {
+    (this.suppliedHost ?? getDefaultOneOverlayHost()).closeAll("dialog");
+  }
+  openInternal(options, settle) {
+    const host = this.suppliedHost ?? getDefaultOneOverlayHost();
+    let current = { ...options };
+    let pending = false;
+    let settled = false;
+    const hostHandle = host.open({
+      kind: "dialog",
+      container: current.container,
+      factory: ({ id, slot: slot10, requestClose, isTop }) => {
+        const hostContainer = slot10.parentElement?.parentElement;
+        const overlay = new DialogOverlay({
+          ...current,
+          id,
+          lockBody: hostContainer === slot10.ownerDocument.body,
+          isTop,
+          requestClose: (reason) => {
+            handleClose(reason);
+          }
+        });
+        const updateOverlay = () => {
+          overlay.setProps({
+            ...current,
+            confirmLoading: pending || current.confirmLoading === true
+          });
+        };
+        const finish = (result) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          requestClose();
+          settle?.(result);
+        };
+        const handleClose = async (reason) => {
+          if (settled || pending) {
+            return;
+          }
+          if (reason !== "confirm") {
+            try {
+              current.onCancel?.();
+            } catch (error) {
+              current.onError?.(error);
+            }
+            if (settle) {
+              finish(false);
+            } else {
+              requestClose();
+            }
+            return;
+          }
+          pending = true;
+          updateOverlay();
+          try {
+            const result = await current.onConfirm?.();
+            if (result === false) {
+              pending = false;
+              updateOverlay();
+              return;
+            }
+            if (settle) {
+              finish(true);
+            } else {
+              requestClose();
+            }
+          } catch (error) {
+            pending = false;
+            updateOverlay();
+            current.onError?.(error);
+          }
+        };
+        overlay.mount(slot10);
+        return {
+          update: (next) => {
+            current = { ...current, ...next };
+            updateOverlay();
+          },
+          destroy: () => {
+            overlay.unmount();
+            if (settle && !settled) {
+              settled = true;
+              settle(false);
+            }
+          }
+        };
+      }
+    });
+    return {
+      id: hostHandle.id,
+      update: (next) => hostHandle.update(next),
+      close: () => hostHandle.close()
+    };
+  }
+}
+function createOneDialogService(host) {
+  return new OneDialogService(host);
+}
+var oneDialog = createOneDialogService();
+// lib/tooltip/OneTooltip.ts
+import { Component as Component22 } from "@geektech/tsone";
+
+// lib/tooltip/TooltipBubble.ts
+import { Component as Component21 } from "@geektech/tsone";
+var ONE_TOOLTIP_STYLES = [
+  {
+    name: "one-tooltip-bubble",
+    selector: ".one-tooltip__bubble",
+    properties: {
+      ...ONE_THEME_TYPOGRAPHY_PROPERTIES,
+      position: "fixed",
+      zIndex: `var(--one-z-index-tooltip, ${ONE_THEME_DEFAULTS.zIndexTooltip})`,
+      boxSizing: "border-box",
+      maxWidth: "280px",
+      padding: `var(--one-space-sm, ${ONE_THEME_DEFAULTS.spaceSm}) var(--one-space-md, ${ONE_THEME_DEFAULTS.spaceMd})`,
+      color: "#ffffff",
+      fontSize: `var(--one-font-size-sm, ${ONE_THEME_DEFAULTS.fontSizeSm})`,
+      backgroundColor: `var(--one-tooltip-background, var(--one-color-text, ${ONE_THEME_DEFAULTS.colorText}))`,
+      borderRadius: `var(--one-radius-sm, ${ONE_THEME_DEFAULTS.radiusSm})`,
+      boxShadow: `var(--one-shadow-overlay, ${ONE_THEME_DEFAULTS.shadowOverlay})`,
+      pointerEvents: "none"
+    }
+  },
+  {
+    name: "one-tooltip-bubble-contained",
+    selector: ".one-tooltip__bubble--contained",
+    properties: { position: "absolute" }
+  },
+  {
+    name: "one-tooltip-arrow",
+    selector: ".one-tooltip__arrow",
+    properties: {
+      position: "absolute",
+      width: "8px",
+      height: "8px",
+      backgroundColor: "inherit",
+      transform: "rotate(45deg)"
+    }
+  },
+  {
+    name: "one-tooltip-arrow-vertical",
+    selector: '.one-tooltip__bubble[data-placement^="top"] .one-tooltip__arrow, .one-tooltip__bubble[data-placement^="bottom"] .one-tooltip__arrow',
+    properties: {
+      left: "var(--one-tooltip-arrow-x, 50%)",
+      marginLeft: "-4px"
+    }
+  },
+  {
+    name: "one-tooltip-arrow-horizontal",
+    selector: '.one-tooltip__bubble[data-placement^="left"] .one-tooltip__arrow, .one-tooltip__bubble[data-placement^="right"] .one-tooltip__arrow',
+    properties: {
+      top: "var(--one-tooltip-arrow-y, 50%)",
+      marginTop: "-4px"
+    }
+  },
+  {
+    name: "one-tooltip-arrow-top",
+    selector: '.one-tooltip__bubble[data-placement^="top"] .one-tooltip__arrow',
+    properties: { bottom: "-4px" }
+  },
+  {
+    name: "one-tooltip-arrow-bottom",
+    selector: '.one-tooltip__bubble[data-placement^="bottom"] .one-tooltip__arrow',
+    properties: { top: "-4px" }
+  },
+  {
+    name: "one-tooltip-arrow-left",
+    selector: '.one-tooltip__bubble[data-placement^="left"] .one-tooltip__arrow',
+    properties: { right: "-4px" }
+  },
+  {
+    name: "one-tooltip-arrow-right",
+    selector: '.one-tooltip__bubble[data-placement^="right"] .one-tooltip__arrow',
+    properties: { left: "-4px" }
+  }
+];
+
+class TooltipBubble extends Component21 {
+  stopAutoUpdate;
+  mount(container) {
+    super.mount(container);
+    this.updatePosition();
+    const element = this.getElement();
+    if (element instanceof HTMLElement) {
+      this.stopAutoUpdate = this.props.positioner.autoUpdate(this.props.reference, element, () => this.updatePosition());
+    }
+  }
+  setProps(props) {
+    super.setProps(props);
+    this.updatePosition();
+  }
+  initState() {
+    return {};
+  }
+  initStyles() {
+    ONE_TOOLTIP_STYLES.forEach(({ name, ...style }) => {
+      this.styleManager.addStyle(name, style);
+    });
+  }
+  onUnmounted() {
+    this.stopAutoUpdate?.();
+    this.stopAutoUpdate = undefined;
+  }
+  render() {
+    const contained = this.props.container !== this.props.container.ownerDocument.body;
+    return {
+      tag: "div",
+      props: {
+        id: this.props.id,
+        className: [
+          "one-tooltip__bubble",
+          ...contained ? ["one-tooltip__bubble--contained"] : []
+        ].join(" "),
+        role: "tooltip",
+        "data-placement": this.props.placement
+      },
+      children: [
+        this.props.content,
+        ...this.props.arrow ? [
+          {
+            tag: "span",
+            props: {
+              className: "one-tooltip__arrow",
+              "aria-hidden": "true"
+            }
+          }
+        ] : []
+      ]
+    };
+  }
+  updatePosition() {
+    const element = this.getElement();
+    if (!(element instanceof HTMLElement) || !element.isConnected) {
+      return;
+    }
+    const boundary = this.boundaryRect();
+    const result = this.props.positioner.compute({
+      reference: toOverlayRect(this.props.reference.getBoundingClientRect()),
+      floating: toOverlayRect(element.getBoundingClientRect()),
+      boundary,
+      placement: this.props.placement,
+      offset: this.props.offset,
+      padding: this.props.boundaryPadding
+    });
+    const contained = this.props.container !== this.props.container.ownerDocument.body;
+    element.style.left = `${result.x - (contained ? boundary.left : 0)}px`;
+    element.style.top = `${result.y - (contained ? boundary.top : 0)}px`;
+    element.dataset.placement = result.placement;
+    element.style.removeProperty("--one-tooltip-arrow-x");
+    element.style.removeProperty("--one-tooltip-arrow-y");
+    if (result.arrow.x !== undefined) {
+      element.style.setProperty("--one-tooltip-arrow-x", `${result.arrow.x}px`);
+    }
+    if (result.arrow.y !== undefined) {
+      element.style.setProperty("--one-tooltip-arrow-y", `${result.arrow.y}px`);
+    }
+  }
+  boundaryRect() {
+    const targetDocument = this.props.container.ownerDocument;
+    if (this.props.container !== targetDocument.body) {
+      return toOverlayRect(this.props.container.getBoundingClientRect());
+    }
+    const view = targetDocument.defaultView;
+    const width = view?.innerWidth ?? targetDocument.documentElement.clientWidth;
+    const height = view?.innerHeight ?? targetDocument.documentElement.clientHeight;
+    return {
+      x: 0,
+      y: 0,
+      top: 0,
+      left: 0,
+      width,
+      height,
+      right: width,
+      bottom: height
+    };
+  }
+}
+function toOverlayRect(rect) {
+  return {
+    x: rect.x,
+    y: rect.y,
+    width: rect.width,
+    height: rect.height,
+    top: rect.top,
+    right: rect.right,
+    bottom: rect.bottom,
+    left: rect.left
+  };
+}
+
+// lib/tooltip/OneTooltip.ts
+var PLACEMENTS2 = [
+  "top-start",
+  "top",
+  "top-end",
+  "right-start",
+  "right",
+  "right-end",
+  "bottom-start",
+  "bottom",
+  "bottom-end",
+  "left-start",
+  "left",
+  "left-end"
+];
+var TRIGGERS = [
+  "hover-focus",
+  "click",
+  "manual"
+];
+
+class OneTooltip extends Component22 {
+  positioner = new OneFloatingPositioner;
+  controller;
+  triggerElement;
+  targetDocument;
+  previousDescribedBy = null;
+  describedBySaved = false;
+  tooltipId;
+  hovered = false;
+  focused = false;
+  openTimer;
+  closeTimer;
+  initState() {
+    return { internalOpen: this.props.defaultOpen === true };
+  }
+  initStyles() {}
+  onMounted() {
+    const wrapper = this.getElement();
+    const trigger = wrapper instanceof HTMLElement ? wrapper.firstElementChild : null;
+    if (!(trigger instanceof HTMLElement)) {
+      throw new OneTooltipTriggerError;
+    }
+    this.triggerElement = trigger;
+    this.targetDocument = trigger.ownerDocument;
+    this.targetDocument.addEventListener("click", this.handleDocumentClick);
+    this.targetDocument.addEventListener("keydown", this.handleDocumentKeydown);
+    this.controller = new OneOverlayMountController(getDefaultOneOverlayHost(this.targetDocument), "tooltip", (context) => this.createBubble(context));
+    this.synchronizeOverlay();
+  }
+  beforeUpdate() {
+    this.synchronizeOverlay();
+  }
+  beforeUnmount() {
+    this.clearTimers();
+    this.targetDocument?.removeEventListener("click", this.handleDocumentClick);
+    this.targetDocument?.removeEventListener("keydown", this.handleDocumentKeydown);
+    this.controller?.close();
+    this.restoreDescribedBy();
+    this.controller = undefined;
+    this.triggerElement = undefined;
+    this.targetDocument = undefined;
+  }
+  render() {
+    return {
+      tag: "span",
+      props: { className: "one-tooltip__trigger" },
+      children: defaultChildren(this.props.children ?? []),
+      listeners: {
+        mouseenter: () => this.handleMouseEnter(),
+        mouseleave: () => this.handleMouseLeave(),
+        focusin: () => this.handleFocusIn(),
+        focusout: (event) => this.handleFocusOut(event),
+        click: () => this.handleTriggerClick()
+      }
+    };
+  }
+  createBubble(context) {
+    this.tooltipId = context.id;
+    const options = this.bubbleOptions(context.id);
+    this.applyDescribedBy(context.id);
+    const bubble = new TooltipBubble(options);
+    bubble.mount(context.slot);
+    return {
+      update: (next) => bubble.setProps(next),
+      destroy: () => {
+        bubble.unmount();
+        this.restoreDescribedBy();
+        this.tooltipId = undefined;
+      }
+    };
+  }
+  synchronizeOverlay() {
+    if (!this.controller || !this.triggerElement || !this.targetDocument) {
+      return;
+    }
+    const shouldOpen = !this.props.disabled && this.requestedOpen();
+    if (!shouldOpen) {
+      this.controller.close();
+      return;
+    }
+    const container = resolveOneOverlayContainer(this.props.container, this.targetDocument);
+    this.controller.open(container);
+    this.controller.update(this.bubbleOptions());
+  }
+  bubbleOptions(id = this.tooltipId ?? "") {
+    const targetDocument = this.targetDocument;
+    if (!this.triggerElement || !targetDocument) {
+      throw new OneTooltipTriggerError;
+    }
+    return {
+      id,
+      content: this.props.content,
+      reference: this.triggerElement,
+      placement: normalizePlacement(this.props.placement),
+      offset: normalizeDelay(this.props.offset, 8),
+      boundaryPadding: 8,
+      arrow: this.props.arrow !== false,
+      container: resolveOneOverlayContainer(this.props.container, targetDocument),
+      positioner: this.positioner
+    };
+  }
+  requestedOpen() {
+    return this.props.open === undefined ? this.state.internalOpen : this.props.open === true;
+  }
+  requestOpen(open) {
+    if (this.props.disabled || open === this.requestedOpen()) {
+      return;
+    }
+    this.emit("openChange", open);
+    if (this.props.open !== undefined) {
+      return;
+    }
+    this.state.internalOpen = open;
+    this.synchronizeOverlay();
+  }
+  handleMouseEnter() {
+    if (this.normalizedTrigger() !== "hover-focus") {
+      return;
+    }
+    this.hovered = true;
+    this.cancelCloseTimer();
+    this.scheduleOpen();
+  }
+  handleMouseLeave() {
+    if (this.normalizedTrigger() !== "hover-focus") {
+      return;
+    }
+    this.hovered = false;
+    if (!this.focused) {
+      this.scheduleClose();
+    }
+  }
+  handleFocusIn() {
+    if (this.normalizedTrigger() !== "hover-focus") {
+      return;
+    }
+    this.focused = true;
+    this.cancelCloseTimer();
+    this.scheduleOpen();
+  }
+  handleFocusOut(event) {
+    if (this.normalizedTrigger() !== "hover-focus") {
+      return;
+    }
+    const wrapper = this.getElement();
+    const next = event.relatedTarget;
+    if (wrapper instanceof HTMLElement && next instanceof Node) {
+      if (wrapper.contains(next)) {
+        return;
+      }
+    }
+    this.focused = false;
+    if (!this.hovered) {
+      this.scheduleClose();
+    }
+  }
+  handleTriggerClick() {
+    if (this.normalizedTrigger() === "click") {
+      this.requestOpen(!this.requestedOpen());
+    }
+  }
+  handleDocumentClick = (event) => {
+    if (this.normalizedTrigger() !== "click" || !this.requestedOpen() || event.target instanceof Node && this.getElement()?.contains(event.target)) {
+      return;
+    }
+    this.requestOpen(false);
+  };
+  handleDocumentKeydown = (event) => {
+    if (event.key === "Escape" && this.requestedOpen()) {
+      this.requestOpen(false);
+    }
+  };
+  scheduleOpen() {
+    this.cancelCloseTimer();
+    if (this.openTimer !== undefined || this.requestedOpen()) {
+      return;
+    }
+    const delay = normalizeDelay(this.props.openDelay, 100);
+    if (delay === 0) {
+      this.requestOpen(true);
+      return;
+    }
+    this.openTimer = this.targetDocument?.defaultView?.setTimeout(() => {
+      this.openTimer = undefined;
+      if (this.hovered || this.focused) {
+        this.requestOpen(true);
+      }
+    }, delay);
+  }
+  scheduleClose() {
+    this.cancelOpenTimer();
+    if (this.closeTimer !== undefined || !this.requestedOpen()) {
+      return;
+    }
+    const delay = normalizeDelay(this.props.closeDelay, 100);
+    if (delay === 0) {
+      this.requestOpen(false);
+      return;
+    }
+    this.closeTimer = this.targetDocument?.defaultView?.setTimeout(() => {
+      this.closeTimer = undefined;
+      if (!this.hovered && !this.focused) {
+        this.requestOpen(false);
+      }
+    }, delay);
+  }
+  clearTimers() {
+    this.cancelOpenTimer();
+    this.cancelCloseTimer();
+  }
+  cancelOpenTimer() {
+    if (this.openTimer !== undefined) {
+      this.targetDocument?.defaultView?.clearTimeout(this.openTimer);
+      this.openTimer = undefined;
+    }
+  }
+  cancelCloseTimer() {
+    if (this.closeTimer !== undefined) {
+      this.targetDocument?.defaultView?.clearTimeout(this.closeTimer);
+      this.closeTimer = undefined;
+    }
+  }
+  applyDescribedBy(id) {
+    if (!this.triggerElement) {
+      return;
+    }
+    if (!this.describedBySaved) {
+      this.previousDescribedBy = this.triggerElement.getAttribute("aria-describedby");
+      this.describedBySaved = true;
+    }
+    const tokens = (this.previousDescribedBy ?? "").split(/\s+/).filter(Boolean);
+    if (!tokens.includes(id)) {
+      tokens.push(id);
+    }
+    this.triggerElement.setAttribute("aria-describedby", tokens.join(" "));
+  }
+  restoreDescribedBy() {
+    if (!this.triggerElement || !this.describedBySaved) {
+      return;
+    }
+    if (this.previousDescribedBy === null) {
+      this.triggerElement.removeAttribute("aria-describedby");
+    } else {
+      this.triggerElement.setAttribute("aria-describedby", this.previousDescribedBy);
+    }
+    this.previousDescribedBy = null;
+    this.describedBySaved = false;
+  }
+  normalizedTrigger() {
+    return TRIGGERS.includes(this.props.trigger) ? this.props.trigger : "hover-focus";
+  }
+}
+function normalizePlacement(value) {
+  return PLACEMENTS2.includes(value) ? value : "top";
+}
+function defaultChildren(children) {
+  const result = [];
+  children.forEach((child) => {
+    if (typeof child === "string") {
+      result.push(child);
+      return;
+    }
+    if (child.slot !== undefined && child.slot !== "default") {
+      return;
+    }
+    const normalized = { ...child };
+    delete normalized.slot;
+    result.push(normalized);
+  });
+  return result;
+}
+function normalizeDelay(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
 }
 // lib/index.ts
 var ONE_NAME = "@geektech/one";
 var ONE_VERSION = "0.0.1";
 export {
+  oneTheme,
+  oneMessage,
+  oneDialog,
+  createOnePaginationTokens,
+  createOneMessageService,
+  createOneDialogService,
+  OneTooltipTriggerError,
+  OneTooltip,
+  OneThemeNotFoundError,
+  OneThemeEnvironmentError,
+  OneThemeConfigError,
+  OneTag,
+  OneTabs,
   OneSwitch,
   OneSelect,
+  OnePagination,
+  OneOverlayEnvironmentError,
+  OneOverlayContainerError,
+  OneMessageService,
+  OneMessage,
   OneInput,
   OneFormModel,
   OneFormItem,
   OneForm,
+  OneFloatingPositioner,
+  OneEmpty,
+  OneDialogService,
+  OneDialog,
   OneCheckboxGroup,
   OneCheckbox,
   OneCard,
   OneButton,
+  OneBreadcrumb,
+  OneBadge,
+  OneAlert,
   ONE_VERSION,
   ONE_THEME_DEFAULTS,
   ONE_NAME,
-  ONE_COMPONENT_CATEGORIES
+  ONE_DEFAULT_THEME,
+  ONE_COMPONENT_CATEGORIES,
+  DomOneOverlayHost
 };
 
-//# debugId=789C7C07D840D57764756E2164756E21
+//# debugId=8EB578A618FDC3A064756E2164756E21
 //# sourceMappingURL=index.js.map