@kdcloudjs/shoelace 1.0.30 → 1.0.32

package/cdn/chunks/chunk.T5FW3CT4.js

@@ -0,0 +1,605 @@
+import {
+  SlNavGroup
+} from "./chunk.HDWZ3ZDL.js";
+import {
+  SlNavItem
+} from "./chunk.U3TQU7XC.js";
+import {
+  SlNavSubmenu
+} from "./chunk.XGV2E6U3.js";
+import {
+  nav_styles_default
+} from "./chunk.ZZORTNQU.js";
+import {
+  SlDivider
+} from "./chunk.NO3TLBS6.js";
+import {
+  e
+} from "./chunk.ZLKEMKLZ.js";
+import {
+  component_styles_default
+} from "./chunk.WT5BNBAS.js";
+import {
+  ShoelaceElement,
+  e as e2,
+  n,
+  r
+} from "./chunk.UBXVJ5DT.js";
+import {
+  A,
+  b
+} from "./chunk.7Z2GKZ7U.js";
+import {
+  __decorateClass,
+  __spreadProps,
+  __spreadValues
+} from "./chunk.CZCSAYQZ.js";
+
+// src/components/nav/nav.component.ts
+function isDividerItemType(item) {
+  return item.type === "divider";
+}
+function isGroupItemType(item) {
+  return item.type === "group";
+}
+function isSubmenuItemType(item) {
+  return !isDividerItemType(item) && !isGroupItemType(item) && Array.isArray(item.children);
+}
+var SlNav = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.hasInitializedState = false;
+    this.hasControlledOpenKeys = false;
+    this.hasControlledSelectedKeys = false;
+    this.isSyncingOpenState = false;
+    this.items = [];
+    this.defaultSelectedKeys = [];
+    this.defaultOpenKeys = [];
+    this.mode = "inline";
+    this.multiple = false;
+    this.selectable = true;
+    this.inlineCollapsed = false;
+    this.inlineIndent = 16;
+    this.subMenuOpenDelay = 0;
+    this.subMenuCloseDelay = 0.1;
+    this.triggerSubMenuAction = "hover";
+    this.theme = "light";
+    this.forceSubMenuRender = false;
+    this.disabledOverflow = false;
+    this.localOpenKeys = [];
+    this.localSelectedKeys = [];
+    this.handleNavSelect = (event) => {
+      var _a;
+      const { item, domEvent } = event.detail;
+      const key = this.getItemKey(item);
+      if (!key) {
+        return;
+      }
+      const clickInfo = this.createClickInfo(item, domEvent);
+      (_a = this.onClick) == null ? void 0 : _a.call(this, clickInfo);
+      if (!this.selectable) {
+        return;
+      }
+      const currentSelectedKeys = this.getNormalizedSelectedKeys(this.selectedKeys);
+      const isSelected = currentSelectedKeys.includes(key);
+      let nextSelectedKeys = currentSelectedKeys;
+      if (this.multiple) {
+        nextSelectedKeys = isSelected ? currentSelectedKeys.filter((selectedKey) => selectedKey !== key) : [...currentSelectedKeys, key];
+      } else if (!isSelected || currentSelectedKeys.length !== 1) {
+        nextSelectedKeys = [key];
+      }
+      nextSelectedKeys = this.getNormalizedSelectedKeys(nextSelectedKeys);
+      const keysChanged = !this.areKeysEqual(currentSelectedKeys, nextSelectedKeys);
+      if (!keysChanged && !this.multiple) {
+        return;
+      }
+      if (!this.hasControlledSelectedKeys) {
+        this.localSelectedKeys = nextSelectedKeys;
+      }
+      if (this.getInternalMode() === "inline") {
+        const ancestorOpenKeys = this.getAncestorSubmenuKeys(item);
+        if (ancestorOpenKeys.length > 0) {
+          this.applyOpenKeysFromInteraction(this.mergeKeys(this.openKeys, ancestorOpenKeys));
+        }
+      }
+      const selectionInfo = __spreadProps(__spreadValues({}, clickInfo), {
+        selectedKeys: nextSelectedKeys
+      });
+      this.dispatchSelectionCallbacks(
+        isSelected && this.multiple ? "deselect" : "select",
+        selectionInfo,
+        nextSelectedKeys
+      );
+    };
+    this.handleSubmenuShow = (event) => {
+      this.handleSubmenuOpenChange(event, true);
+    };
+    this.handleSubmenuHide = (event) => {
+      this.handleSubmenuOpenChange(event, false);
+    };
+    this.handleSlotChange = () => {
+      this.updateMode();
+      this.syncStateToDescendants();
+    };
+  }
+  set selectedKeys(value) {
+    const oldValue = this._selectedKeys;
+    this.hasControlledSelectedKeys = value !== void 0;
+    this._selectedKeys = Array.isArray(value) ? [...value] : void 0;
+    this.requestUpdate("selectedKeys", oldValue);
+  }
+  get selectedKeys() {
+    var _a;
+    return this.hasControlledSelectedKeys ? (_a = this._selectedKeys) != null ? _a : [] : this.localSelectedKeys;
+  }
+  set openKeys(value) {
+    const oldValue = this._openKeys;
+    this.hasControlledOpenKeys = value !== void 0;
+    this._openKeys = Array.isArray(value) ? [...value] : void 0;
+    this.requestUpdate("openKeys", oldValue);
+  }
+  get openKeys() {
+    var _a;
+    return this.hasControlledOpenKeys ? (_a = this._openKeys) != null ? _a : [] : this.localOpenKeys;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.addEventListener("sl-nav-select", this.handleNavSelect);
+    this.addEventListener("sl-show", this.handleSubmenuShow);
+    this.addEventListener("sl-hide", this.handleSubmenuHide);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.removeEventListener("sl-nav-select", this.handleNavSelect);
+    this.removeEventListener("sl-show", this.handleSubmenuShow);
+    this.removeEventListener("sl-hide", this.handleSubmenuHide);
+  }
+  willUpdate(changedProperties) {
+    var _a, _b, _c;
+    super.willUpdate(changedProperties);
+    if (!this.hasInitializedState) {
+      this.localSelectedKeys = [...this.defaultSelectedKeys];
+      this.localOpenKeys = [...this.defaultOpenKeys];
+      this.hasInitializedState = true;
+    }
+    if (changedProperties.has("selectedKeys") && this.hasControlledSelectedKeys) {
+      this.localSelectedKeys = [...(_a = this._selectedKeys) != null ? _a : []];
+    }
+    if (changedProperties.has("openKeys") && this.hasControlledOpenKeys) {
+      this.localOpenKeys = [...(_b = this._openKeys) != null ? _b : []];
+    }
+    if (changedProperties.has("multiple") && !this.hasControlledSelectedKeys) {
+      this.localSelectedKeys = this.getNormalizedSelectedKeys(this.localSelectedKeys);
+    }
+    if (changedProperties.has("selectable") && !this.selectable && !this.hasControlledSelectedKeys) {
+      this.localSelectedKeys = [];
+    }
+    if ((changedProperties.has("inlineCollapsed") || changedProperties.has("mode")) && this.hasInitializedState) {
+      if (!this.hasControlledOpenKeys) {
+        this.localOpenKeys = [];
+      } else {
+        (_c = this.onOpenChange) == null ? void 0 : _c.call(this, []);
+        this.emit("sl-nav-open-change", { detail: { openKeys: [] } });
+      }
+      this.getSubmenus().forEach((submenu) => {
+        var _a2;
+        (_a2 = submenu.clearTimers) == null ? void 0 : _a2.call(submenu);
+        submenu.open = false;
+      });
+    }
+  }
+  updated(changedProperties) {
+    if (changedProperties.has("inlineIndent")) {
+      this.style.setProperty("--sl-nav-item-indent-step", `${this.inlineIndent}px`);
+    }
+    if (changedProperties.has("mode") || changedProperties.has("inlineCollapsed") || changedProperties.has("items")) {
+      this.updateMode();
+    }
+    if (changedProperties.has("mode") || changedProperties.has("inlineCollapsed") || changedProperties.has("selectedKeys") || changedProperties.has("localSelectedKeys") || changedProperties.has("openKeys") || changedProperties.has("localOpenKeys") || changedProperties.has("items") || changedProperties.has("multiple") || changedProperties.has("selectable")) {
+      this.syncStateToDescendants();
+    }
+  }
+  firstUpdated() {
+    this.style.setProperty("--sl-nav-item-indent-step", `${this.inlineIndent}px`);
+    if (!this.hasControlledOpenKeys && this.localOpenKeys.length === 0 && this.defaultOpenKeys.length === 0 && this.getInternalMode() === "inline") {
+      const ancestorOpenKeys = this.normalizeKeys(
+        this.getSelectedItems().flatMap((item) => this.getAncestorSubmenuKeys(item))
+      );
+      if (ancestorOpenKeys.length > 0) {
+        this.localOpenKeys = ancestorOpenKeys;
+        this.syncStateToDescendants();
+      }
+    }
+  }
+  getInternalMode() {
+    if (this.mode === "horizontal") {
+      return "horizontal";
+    }
+    if (this.mode === "inline") {
+      return this.inlineCollapsed ? "vertical" : "inline";
+    }
+    return "vertical";
+  }
+  getManagedElements(selector) {
+    return [
+      .../* @__PURE__ */ new Set([
+        ...Array.from(this.querySelectorAll(selector)),
+        ...Array.from(this.renderRoot.querySelectorAll(selector))
+      ])
+    ];
+  }
+  getParentElement(element) {
+    if (element.parentElement) {
+      return element.parentElement;
+    }
+    const root = element.getRootNode();
+    return root instanceof ShadowRoot ? root.host : null;
+  }
+  belongsToThisNav(element) {
+    let current = element;
+    while (current) {
+      if (current === this) {
+        return true;
+      }
+      current = this.getParentElement(current);
+    }
+    return false;
+  }
+  findClosestAncestorTag(element, tagName) {
+    let current = this.getParentElement(element);
+    while (current && current !== this) {
+      if (current.tagName.toLowerCase() === tagName) {
+        return current;
+      }
+      current = this.getParentElement(current);
+    }
+    return void 0;
+  }
+  getItems() {
+    return this.getManagedElements("sl-nav-item");
+  }
+  getGroups() {
+    return this.getManagedElements("sl-nav-group");
+  }
+  getSubmenus() {
+    return this.getManagedElements("sl-nav-submenu");
+  }
+  getItemKey(item) {
+    return item.key || item.itemKey;
+  }
+  getSubmenuKey(submenu) {
+    return submenu.key || submenu.itemKey;
+  }
+  normalizeKeys(keys) {
+    return [...new Set(keys.filter((key) => typeof key === "string" && key !== ""))];
+  }
+  getNormalizedSelectedKeys(keys) {
+    if (!this.selectable) {
+      return [];
+    }
+    const normalized = this.normalizeKeys(keys);
+    return this.multiple ? normalized : normalized.slice(0, 1);
+  }
+  mergeKeys(...collections) {
+    return this.normalizeKeys(collections.flat());
+  }
+  areKeysEqual(current, next) {
+    if (current.length !== next.length) {
+      return false;
+    }
+    return current.every((key, index) => key === next[index]);
+  }
+  getAncestorSubmenus(item) {
+    const submenus = [];
+    let current = this.getParentElement(item);
+    while (current && current !== this) {
+      if (current.tagName.toLowerCase() === "sl-nav-submenu") {
+        submenus.push(current);
+      }
+      current = this.getParentElement(current);
+    }
+    return submenus;
+  }
+  getAncestorSubmenuKeys(item) {
+    return this.normalizeKeys(this.getAncestorSubmenus(item).map((submenu) => this.getSubmenuKey(submenu)));
+  }
+  getSelectedItems() {
+    const items = this.getItems();
+    const selectedKeySet = new Set(this.getNormalizedSelectedKeys(this.selectedKeys));
+    return items.filter((item) => selectedKeySet.has(this.getItemKey(item)));
+  }
+  createClickInfo(item, domEvent) {
+    const key = this.getItemKey(item);
+    return {
+      domEvent,
+      item,
+      key,
+      keyPath: [key, ...this.getAncestorSubmenuKeys(item)]
+    };
+  }
+  dispatchSelectionCallbacks(type, info, nextSelectedKeys) {
+    var _a, _b;
+    if (type === "select") {
+      (_a = this.onSelect) == null ? void 0 : _a.call(this, info);
+    } else {
+      (_b = this.onDeselect) == null ? void 0 : _b.call(this, info);
+    }
+    this.emit("sl-change", {
+      detail: {
+        item: info.item,
+        selectedKeys: nextSelectedKeys
+      }
+    });
+  }
+  updateMode() {
+    const internalMode = this.getInternalMode();
+    const elements = [...this.getItems(), ...this.getGroups(), ...this.getSubmenus()];
+    elements.forEach((element) => {
+      const closestSubmenu = this.findClosestAncestorTag(element, "sl-nav-submenu");
+      if (closestSubmenu && closestSubmenu !== element) {
+        element.mode = internalMode === "inline" ? "inline" : "vertical";
+      } else {
+        element.mode = internalMode;
+      }
+    });
+  }
+  syncStateToDescendants() {
+    const items = this.getItems();
+    const groups = this.getGroups();
+    const submenus = this.getSubmenus();
+    const selectedKeySet = new Set(this.getNormalizedSelectedKeys(this.selectedKeys));
+    const openKeySet = new Set(this.normalizeKeys(this.openKeys));
+    const selectedItems = items.filter((item) => selectedKeySet.has(this.getItemKey(item)));
+    const isCollapsed = this.inlineCollapsed && this.mode === "inline";
+    items.forEach((item) => {
+      const isTopLevelItem = !this.findClosestAncestorTag(item, "sl-nav-submenu");
+      item.active = selectedKeySet.has(this.getItemKey(item));
+      item.collapsed = isCollapsed && isTopLevelItem;
+    });
+    [...groups, ...submenus].forEach((element) => {
+      element.active = false;
+    });
+    submenus.forEach((submenu) => {
+      const isTopLevelSubmenu = !this.findClosestAncestorTag(submenu, "sl-nav-submenu");
+      submenu.collapsed = isCollapsed && isTopLevelSubmenu;
+    });
+    selectedItems.forEach((item) => {
+      let current = this.getParentElement(item);
+      while (current && current !== this) {
+        const tagName = current.tagName.toLowerCase();
+        if (tagName === "sl-nav-group" || tagName === "sl-nav-submenu") {
+          current.active = true;
+        }
+        current = this.getParentElement(current);
+      }
+    });
+    this.isSyncingOpenState = true;
+    submenus.forEach((submenu) => {
+      submenu.setOpenFromNav(openKeySet.has(this.getSubmenuKey(submenu)));
+    });
+    this.isSyncingOpenState = false;
+  }
+  applyOpenKeysFromInteraction(nextOpenKeys) {
+    var _a, _b;
+    const normalizedOpenKeys = this.normalizeKeys(nextOpenKeys);
+    if (this.hasControlledOpenKeys) {
+      (_a = this.onOpenChange) == null ? void 0 : _a.call(this, normalizedOpenKeys);
+      this.emit("sl-nav-open-change", {
+        detail: {
+          openKeys: normalizedOpenKeys
+        }
+      });
+      return;
+    }
+    if (!this.areKeysEqual(this.localOpenKeys, normalizedOpenKeys)) {
+      this.localOpenKeys = normalizedOpenKeys;
+      (_b = this.onOpenChange) == null ? void 0 : _b.call(this, normalizedOpenKeys);
+      this.emit("sl-nav-open-change", {
+        detail: {
+          openKeys: normalizedOpenKeys
+        }
+      });
+    }
+  }
+  handleSubmenuOpenChange(event, open) {
+    var _a;
+    if (this.isSyncingOpenState) {
+      return;
+    }
+    const submenu = event.target;
+    if (!(submenu instanceof HTMLElement) || submenu.tagName.toLowerCase() !== "sl-nav-submenu" || !this.belongsToThisNav(submenu)) {
+      return;
+    }
+    if (((_a = submenu.getOpenChangeSource) == null ? void 0 : _a.call(submenu)) === "nav") {
+      return;
+    }
+    const submenuKey = this.getSubmenuKey(submenu);
+    if (!submenuKey) {
+      return;
+    }
+    let nextOpenKeys;
+    if (!open) {
+      nextOpenKeys = this.openKeys.filter((key) => key !== submenuKey);
+    } else {
+      const internalMode = this.getInternalMode();
+      if (internalMode === "vertical" || internalMode === "horizontal") {
+        const submenuParent = this.getParentElement(submenu);
+        const allSubmenus = this.getSubmenus();
+        const siblingOpenKeys = allSubmenus.filter((s) => {
+          if (s === submenu) return false;
+          const sParent = this.getParentElement(s);
+          return sParent === submenuParent && this.openKeys.includes(this.getSubmenuKey(s));
+        }).map((s) => this.getSubmenuKey(s));
+        siblingOpenKeys.forEach((key) => {
+          var _a2;
+          const sibling = allSubmenus.find((s) => this.getSubmenuKey(s) === key);
+          if (sibling) {
+            (_a2 = sibling.clearTimers) == null ? void 0 : _a2.call(sibling);
+            sibling.open = false;
+          }
+        });
+        nextOpenKeys = this.mergeKeys(
+          this.openKeys.filter((key) => !siblingOpenKeys.includes(key)),
+          [submenuKey]
+        );
+      } else {
+        nextOpenKeys = this.mergeKeys(this.openKeys, [submenuKey]);
+      }
+    }
+    if (this.hasControlledOpenKeys) {
+      event.preventDefault();
+    }
+    this.applyOpenKeysFromInteraction(nextOpenKeys);
+  }
+  renderItemType(item, index) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (isDividerItemType(item)) {
+      return b`<sl-divider data-menu-index=${index}></sl-divider>`;
+    }
+    if (isGroupItemType(item)) {
+      return b`
+        <sl-nav-group .label=${item.label}>
+          ${item.children.map((child, childIndex) => this.renderItemType(child, childIndex))}
+        </sl-nav-group>
+      `;
+    }
+    if (isSubmenuItemType(item)) {
+      return b`
+        <sl-nav-submenu
+          .key=${item.key}
+          .label=${item.label}
+          .icon=${item.icon}
+          .onTitleClick=${item.onTitleClick}
+          .popupClassName=${(_a = item.popupClassName) != null ? _a : ""}
+          .popupOffset=${item.popupOffset}
+          .theme=${(_b = item.theme) != null ? _b : this.theme}
+          ?disabled=${(_c = item.disabled) != null ? _c : false}
+        >
+          ${item.children.map((child, childIndex) => this.renderItemType(child, childIndex))}
+        </sl-nav-submenu>
+      `;
+    }
+    return b`
+      <sl-nav-item
+        .key=${item.key}
+        .label=${item.label}
+        .icon=${item.icon}
+        .extra=${item.extra}
+        .title=${(_d = item.title) != null ? _d : ""}
+        .href=${(_e = item.href) != null ? _e : ""}
+        .target=${item.target}
+        .download=${item.download}
+        .rel=${(_f = item.rel) != null ? _f : "noreferrer noopener"}
+        ?disabled=${(_g = item.disabled) != null ? _g : false}
+        ?danger=${(_h = item.danger) != null ? _h : false}
+      ></sl-nav-item>
+    `;
+  }
+  renderItems() {
+    if (this.items.length === 0) {
+      return b`<slot @slotchange=${this.handleSlotChange}></slot>`;
+    }
+    return b`${this.items.map((item, index) => this.renderItemType(item, index))}`;
+  }
+  render() {
+    const internalMode = this.getInternalMode();
+    return b`
+      <nav
+        part="base"
+        class=${e({
+      nav: true,
+      "nav--horizontal": internalMode === "horizontal",
+      "nav--vertical": internalMode === "inline" || internalMode === "vertical"
+    })}
+      >
+        ${this.renderItems() || A}
+      </nav>
+    `;
+  }
+};
+SlNav.styles = [component_styles_default, nav_styles_default];
+SlNav.dependencies = {
+  "sl-divider": SlDivider,
+  "sl-nav-group": SlNavGroup,
+  "sl-nav-item": SlNavItem,
+  "sl-nav-submenu": SlNavSubmenu
+};
+__decorateClass([
+  e2("slot")
+], SlNav.prototype, "defaultSlot", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "items", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "selectedKeys", 1);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "defaultSelectedKeys", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "openKeys", 1);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "defaultOpenKeys", 2);
+__decorateClass([
+  n({ reflect: true })
+], SlNav.prototype, "mode", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], SlNav.prototype, "multiple", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], SlNav.prototype, "selectable", 2);
+__decorateClass([
+  n({ attribute: "inline-collapsed", type: Boolean, reflect: true })
+], SlNav.prototype, "inlineCollapsed", 2);
+__decorateClass([
+  n({ attribute: "inline-indent", type: Number })
+], SlNav.prototype, "inlineIndent", 2);
+__decorateClass([
+  n({ attribute: "sub-menu-open-delay", type: Number })
+], SlNav.prototype, "subMenuOpenDelay", 2);
+__decorateClass([
+  n({ attribute: "sub-menu-close-delay", type: Number })
+], SlNav.prototype, "subMenuCloseDelay", 2);
+__decorateClass([
+  n({ attribute: "trigger-sub-menu-action" })
+], SlNav.prototype, "triggerSubMenuAction", 2);
+__decorateClass([
+  n({ reflect: true })
+], SlNav.prototype, "theme", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "expandIcon", 2);
+__decorateClass([
+  n({ attribute: "force-sub-menu-render", type: Boolean, reflect: true })
+], SlNav.prototype, "forceSubMenuRender", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "overflowedIndicator", 2);
+__decorateClass([
+  n({ attribute: "disabled-overflow", type: Boolean, reflect: true })
+], SlNav.prototype, "disabledOverflow", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "onClick", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "onSelect", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "onDeselect", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlNav.prototype, "onOpenChange", 2);
+__decorateClass([
+  r()
+], SlNav.prototype, "localOpenKeys", 2);
+__decorateClass([
+  r()
+], SlNav.prototype, "localSelectedKeys", 2);
+
+export {
+  SlNav
+};

package/cdn/chunks/chunk.T5H3S4HI.js

@@ -0,0 +1,27 @@
+import {
+  SlDatePanel
+} from "./chunk.3CYEJIVZ.js";
+
+// src/react/date-panel/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-date-panel";
+SlDatePanel.define("sl-date-panel");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlDatePanel,
+  react: React,
+  events: {
+    onSlCancel: "sl-cancel",
+    onSlClear: "sl-clear",
+    onSlConfirm: "sl-confirm",
+    onSlDateChange: "sl-date-change"
+  },
+  displayName: "SlDatePanel"
+});
+var date_panel_default = reactWrapper;
+
+export {
+  date_panel_default
+};

package/cdn/chunks/chunk.T7KOZRIJ.js

@@ -0,0 +1,24 @@
+import {
+  SlTag
+} from "./chunk.22GJIWXX.js";
+
+// src/react/tag/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-tag";
+SlTag.define("sl-tag");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlTag,
+  react: React,
+  events: {
+    onSlRemove: "sl-remove"
+  },
+  displayName: "SlTag"
+});
+var tag_default = reactWrapper;
+
+export {
+  tag_default
+};

package/cdn/chunks/chunk.TCSFI34V.js

@@ -0,0 +1,25 @@
+import {
+  SlCopyButton
+} from "./chunk.4MZ2UHIL.js";
+
+// src/react/copy-button/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-copy-button";
+SlCopyButton.define("sl-copy-button");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlCopyButton,
+  react: React,
+  events: {
+    onSlCopy: "sl-copy",
+    onSlError: "sl-error"
+  },
+  displayName: "SlCopyButton"
+});
+var copy_button_default = reactWrapper;
+
+export {
+  copy_button_default
+};