@kdcloudjs/shoelace 1.0.46 → 1.0.47

package/cdn/chunks/chunk.NMGQXDFW.js

@@ -0,0 +1,320 @@
+import {
+  SlTreeItem
+} from "./chunk.7XEIPCBX.js";
+import {
+  tree_styles_default
+} from "./chunk.U5YC4257.js";
+import {
+  clamp
+} from "./chunk.HF7GESMZ.js";
+import {
+  LocalizeController
+} from "./chunk.VBONVBBW.js";
+import {
+  watch
+} from "./chunk.WID3TCT6.js";
+import {
+  component_styles_default
+} from "./chunk.N6N54SAA.js";
+import {
+  ShoelaceElement,
+  e,
+  n
+} from "./chunk.KKR53ZFE.js";
+import {
+  b
+} from "./chunk.OLIQR3OU.js";
+import {
+  __decorateClass
+} from "./chunk.CZCSAYQZ.js";
+
+// src/components/tree/tree.component.ts
+function syncCheckboxes(changedTreeItem, initialSync = false) {
+  function syncParentItem(treeItem) {
+    const children = treeItem.getChildrenItems({ includeDisabled: false });
+    if (children.length) {
+      const allChecked = children.every((item) => item.selected);
+      const allUnchecked = children.every((item) => !item.selected && !item.indeterminate);
+      treeItem.selected = allChecked;
+      treeItem.indeterminate = !allChecked && !allUnchecked;
+    }
+  }
+  function syncAncestors(treeItem) {
+    const parentItem = treeItem.parentElement;
+    if (SlTreeItem.isTreeItem(parentItem)) {
+      syncParentItem(parentItem);
+      syncAncestors(parentItem);
+    }
+  }
+  function syncDescendants(treeItem) {
+    for (const childItem of treeItem.getChildrenItems()) {
+      childItem.selected = initialSync ? treeItem.selected || childItem.selected : !childItem.disabled && treeItem.selected;
+      syncDescendants(childItem);
+    }
+    if (initialSync) {
+      syncParentItem(treeItem);
+    }
+  }
+  syncDescendants(changedTreeItem);
+  syncAncestors(changedTreeItem);
+}
+var SlTree = class extends ShoelaceElement {
+  constructor() {
+    super();
+    this.selection = "single";
+    this.showLine = false;
+    this.clickTarget = null;
+    this.localize = new LocalizeController(this);
+    // Initializes new items by setting the `selectable` property and the expanded/collapsed icons if any
+    this.initTreeItem = (item) => {
+      item.selectable = this.selection === "multiple";
+      ["expand", "collapse"].filter((status) => !!this.querySelector(`[slot="${status}-icon"]`)).forEach((status) => {
+        const existingIcon = item.querySelector(`[slot="${status}-icon"]`);
+        const expandButtonIcon = this.getExpandButtonIcon(status);
+        if (!expandButtonIcon) return;
+        if (existingIcon === null) {
+          item.append(expandButtonIcon);
+        } else if (existingIcon.hasAttribute("data-default")) {
+          existingIcon.replaceWith(expandButtonIcon);
+        } else {
+        }
+      });
+    };
+    this.handleTreeChanged = (mutations) => {
+      for (const mutation of mutations) {
+        const addedNodes = [...mutation.addedNodes].filter(SlTreeItem.isTreeItem);
+        const removedNodes = [...mutation.removedNodes].filter(SlTreeItem.isTreeItem);
+        addedNodes.forEach(this.initTreeItem);
+        if (this.lastFocusedItem && removedNodes.includes(this.lastFocusedItem)) {
+          this.lastFocusedItem = null;
+        }
+      }
+    };
+    this.handleFocusOut = (event) => {
+      const relatedTarget = event.relatedTarget;
+      if (!relatedTarget || !this.contains(relatedTarget)) {
+        this.tabIndex = 0;
+      }
+    };
+    this.handleFocusIn = (event) => {
+      const target = event.target;
+      if (event.target === this) {
+        this.focusItem(this.lastFocusedItem || this.getAllTreeItems()[0]);
+      }
+      if (SlTreeItem.isTreeItem(target) && !target.disabled) {
+        if (this.lastFocusedItem) {
+          this.lastFocusedItem.tabIndex = -1;
+        }
+        this.lastFocusedItem = target;
+        this.tabIndex = -1;
+        target.tabIndex = 0;
+      }
+    };
+    this.addEventListener("focusin", this.handleFocusIn);
+    this.addEventListener("focusout", this.handleFocusOut);
+    this.addEventListener("sl-lazy-change", this.handleSlotChange);
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    this.setAttribute("role", "tree");
+    this.setAttribute("tabindex", "0");
+    await this.updateComplete;
+    this.mutationObserver = new MutationObserver(this.handleTreeChanged);
+    this.mutationObserver.observe(this, { childList: true, subtree: true });
+  }
+  disconnectedCallback() {
+    var _a;
+    super.disconnectedCallback();
+    (_a = this.mutationObserver) == null ? void 0 : _a.disconnect();
+  }
+  // Generates a clone of the expand icon element to use for each tree item
+  getExpandButtonIcon(status) {
+    const slot = status === "expand" ? this.expandedIconSlot : this.collapsedIconSlot;
+    const icon = slot.assignedElements({ flatten: true })[0];
+    if (icon) {
+      const clone = icon.cloneNode(true);
+      [clone, ...clone.querySelectorAll("[id]")].forEach((el) => el.removeAttribute("id"));
+      clone.setAttribute("data-default", "");
+      clone.slot = `${status}-icon`;
+      return clone;
+    }
+    return null;
+  }
+  selectItem(selectedItem) {
+    const previousSelection = [...this.selectedItems];
+    if (this.selection === "multiple") {
+      selectedItem.selected = !selectedItem.selected;
+      if (selectedItem.lazy) {
+        selectedItem.expanded = true;
+      }
+      syncCheckboxes(selectedItem);
+    } else if (this.selection === "single" || selectedItem.isLeaf) {
+      const items = this.getAllTreeItems();
+      for (const item of items) {
+        item.selected = item === selectedItem;
+      }
+    } else if (this.selection === "leaf") {
+      selectedItem.expanded = !selectedItem.expanded;
+    }
+    const nextSelection = this.selectedItems;
+    if (previousSelection.length !== nextSelection.length || nextSelection.some((item) => !previousSelection.includes(item))) {
+      Promise.all(nextSelection.map((el) => el.updateComplete)).then(() => {
+        this.emit("sl-selection-change", { detail: { selection: nextSelection } });
+      });
+    }
+  }
+  getAllTreeItems() {
+    return [...this.querySelectorAll("sl-tree-item")];
+  }
+  focusItem(item) {
+    item == null ? void 0 : item.focus();
+  }
+  handleKeyDown(event) {
+    if (!["ArrowDown", "ArrowUp", "ArrowRight", "ArrowLeft", "Home", "End", "Enter", " "].includes(event.key)) {
+      return;
+    }
+    if (event.composedPath().some((el) => {
+      var _a;
+      return ["input", "textarea"].includes((_a = el == null ? void 0 : el.tagName) == null ? void 0 : _a.toLowerCase());
+    })) {
+      return;
+    }
+    const items = this.getFocusableItems();
+    const isLtr = this.localize.dir() === "ltr";
+    const isRtl = this.localize.dir() === "rtl";
+    if (items.length > 0) {
+      event.preventDefault();
+      const activeItemIndex = items.findIndex((item) => item.matches(":focus"));
+      const activeItem = items[activeItemIndex];
+      const focusItemAt = (index) => {
+        const item = items[clamp(index, 0, items.length - 1)];
+        this.focusItem(item);
+      };
+      const toggleExpand = (expanded) => {
+        activeItem.expanded = expanded;
+      };
+      if (event.key === "ArrowDown") {
+        focusItemAt(activeItemIndex + 1);
+      } else if (event.key === "ArrowUp") {
+        focusItemAt(activeItemIndex - 1);
+      } else if (isLtr && event.key === "ArrowRight" || isRtl && event.key === "ArrowLeft") {
+        if (!activeItem || activeItem.disabled || activeItem.expanded || activeItem.isLeaf && !activeItem.lazy) {
+          focusItemAt(activeItemIndex + 1);
+        } else {
+          toggleExpand(true);
+        }
+      } else if (isLtr && event.key === "ArrowLeft" || isRtl && event.key === "ArrowRight") {
+        if (!activeItem || activeItem.disabled || activeItem.isLeaf || !activeItem.expanded) {
+          focusItemAt(activeItemIndex - 1);
+        } else {
+          toggleExpand(false);
+        }
+      } else if (event.key === "Home") {
+        focusItemAt(0);
+      } else if (event.key === "End") {
+        focusItemAt(items.length - 1);
+      } else if (event.key === "Enter" || event.key === " ") {
+        if (!activeItem.disabled) {
+          this.selectItem(activeItem);
+        }
+      }
+    }
+  }
+  handleClick(event) {
+    const target = event.target;
+    const treeItem = target.closest("sl-tree-item");
+    const isExpandButton = event.composedPath().some(
+      (el) => {
+        var _a, _b;
+        return ((_a = el == null ? void 0 : el.classList) == null ? void 0 : _a.contains("tree-item__expand-button")) && ((_b = el == null ? void 0 : el.classList) == null ? void 0 : _b.contains("tree-item__expand-button--visible"));
+      }
+    );
+    if (!treeItem || treeItem.disabled || target !== this.clickTarget) {
+      return;
+    }
+    if (isExpandButton) {
+      treeItem.expanded = !treeItem.expanded;
+    } else {
+      this.selectItem(treeItem);
+    }
+  }
+  handleMouseDown(event) {
+    this.clickTarget = event.target;
+  }
+  handleSlotChange() {
+    const items = this.getAllTreeItems();
+    items.forEach(this.initTreeItem);
+  }
+  async handleSelectionChange() {
+    const isSelectionMultiple = this.selection === "multiple";
+    const items = this.getAllTreeItems();
+    this.setAttribute("aria-multiselectable", isSelectionMultiple ? "true" : "false");
+    for (const item of items) {
+      item.selectable = isSelectionMultiple;
+    }
+    if (isSelectionMultiple) {
+      await this.updateComplete;
+      [...this.querySelectorAll(":scope > sl-tree-item")].forEach(
+        (treeItem) => syncCheckboxes(treeItem, true)
+      );
+    }
+  }
+  /** @internal Returns the list of tree items that are selected in the tree. */
+  get selectedItems() {
+    const items = this.getAllTreeItems();
+    const isSelected = (item) => item.selected;
+    return items.filter(isSelected);
+  }
+  /** @internal Gets focusable tree items in the tree. */
+  getFocusableItems() {
+    const items = this.getAllTreeItems();
+    const collapsedItems = /* @__PURE__ */ new Set();
+    return items.filter((item) => {
+      var _a;
+      if (item.disabled) return false;
+      const parent = (_a = item.parentElement) == null ? void 0 : _a.closest("[role=treeitem]");
+      if (parent && (!parent.expanded || parent.loading || collapsedItems.has(parent))) {
+        collapsedItems.add(item);
+      }
+      return !collapsedItems.has(item);
+    });
+  }
+  render() {
+    return b`
+      <div
+        part="base"
+        class="tree"
+        @click=${this.handleClick}
+        @keydown=${this.handleKeyDown}
+        @mousedown=${this.handleMouseDown}
+      >
+        <slot @slotchange=${this.handleSlotChange}></slot>
+        <span hidden aria-hidden="true"><slot name="expand-icon"></slot></span>
+        <span hidden aria-hidden="true"><slot name="collapse-icon"></slot></span>
+      </div>
+    `;
+  }
+};
+SlTree.styles = [component_styles_default, tree_styles_default];
+__decorateClass([
+  e("slot:not([name])")
+], SlTree.prototype, "defaultSlot", 2);
+__decorateClass([
+  e("slot[name=expand-icon]")
+], SlTree.prototype, "expandedIconSlot", 2);
+__decorateClass([
+  e("slot[name=collapse-icon]")
+], SlTree.prototype, "collapsedIconSlot", 2);
+__decorateClass([
+  n()
+], SlTree.prototype, "selection", 2);
+__decorateClass([
+  n({ type: Boolean, attribute: "show-line", reflect: true })
+], SlTree.prototype, "showLine", 2);
+__decorateClass([
+  watch("selection")
+], SlTree.prototype, "handleSelectionChange", 1);
+
+export {
+  SlTree
+};

package/cdn/chunks/chunk.NQ2Q4AYG.js

@@ -0,0 +1,368 @@
+import {
+  steps_styles_default
+} from "./chunk.2FB7J42X.js";
+import {
+  SlIcon
+} from "./chunk.MGETPUIX.js";
+import {
+  component_styles_default
+} from "./chunk.N6N54SAA.js";
+import {
+  ShoelaceElement,
+  n,
+  r
+} from "./chunk.KKR53ZFE.js";
+import {
+  b
+} from "./chunk.OLIQR3OU.js";
+import {
+  __decorateClass
+} from "./chunk.CZCSAYQZ.js";
+
+// src/components/steps/steps.component.ts
+var SlSteps = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.items = [];
+    this.current = 0;
+    this.status = "process";
+    this.initial = 0;
+    this.percent = void 0;
+    this.size = "default";
+    this.type = "default";
+    this.variant = "filled";
+    this.orientation = "horizontal";
+    this.responsive = false;
+    this.titlePlacement = "horizontal";
+    this._isVertical = false;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (this.responsive) {
+      this._resizeObserver = new ResizeObserver((entries) => {
+        var _a, _b;
+        const width = (_b = (_a = entries[0]) == null ? void 0 : _a.contentRect.width) != null ? _b : 0;
+        this._isVertical = width < 532;
+      });
+      this._resizeObserver.observe(this);
+    }
+  }
+  disconnectedCallback() {
+    var _a;
+    super.disconnectedCallback();
+    (_a = this._resizeObserver) == null ? void 0 : _a.disconnect();
+    this._resizeObserver = void 0;
+  }
+  updated(changed) {
+    var _a;
+    if (changed.has("responsive")) {
+      (_a = this._resizeObserver) == null ? void 0 : _a.disconnect();
+      if (this.responsive) {
+        this._resizeObserver = new ResizeObserver((entries) => {
+          var _a2, _b;
+          const width = (_b = (_a2 = entries[0]) == null ? void 0 : _a2.contentRect.width) != null ? _b : 0;
+          this._isVertical = width < 532;
+        });
+        this._resizeObserver.observe(this);
+      } else {
+        this._isVertical = false;
+      }
+    }
+    this._updateOutlinedPanelArrows();
+  }
+  /** 动态设置 outlined panel 箭头高度 */
+  _updateOutlinedPanelArrows() {
+    var _a;
+    if (this.type !== "panel" || this.variant !== "outlined") return;
+    const steps = (_a = this.shadowRoot) == null ? void 0 : _a.querySelectorAll(".steps-panel .step");
+    if (!steps) return;
+    steps.forEach((step) => {
+      const h = step.offsetHeight;
+      if (h) {
+        step.style.setProperty("--_step-half-h", `${h / 2}px`);
+      }
+    });
+  }
+  get effectiveOrientation() {
+    if (this.type !== "default" && this.type !== "dot") return "horizontal";
+    if (this.responsive && this._isVertical) return "vertical";
+    return this.orientation;
+  }
+  get clickable() {
+    return typeof this.onChange === "function";
+  }
+  handleStepClick(index) {
+    if (!this.clickable) return;
+    const item = this.items[index];
+    if (item == null ? void 0 : item.disabled) return;
+    this.onChange(index);
+  }
+  getStepStatus(index) {
+    const item = this.items[index];
+    if (item.status) return item.status;
+    if (index < this.current) return "finish";
+    if (index === this.current) return this.status;
+    return "wait";
+  }
+  getNextStepStatus(index) {
+    if (index >= this.items.length - 1) return null;
+    const nextIndex = index + 1;
+    const status = this.getStepStatus(nextIndex);
+    if (status === "error" && nextIndex > this.current) return "wait";
+    return status;
+  }
+  renderIcon(index, stepStatus) {
+    const item = this.items[index];
+    if (item.icon) {
+      return b`<sl-icon name=${item.icon}></sl-icon>`;
+    }
+    if (stepStatus === "finish") {
+      return b`<sl-icon name="check-lg"></sl-icon>`;
+    }
+    if (stepStatus === "error") {
+      return b`<sl-icon name="x-lg"></sl-icon>`;
+    }
+    if (stepStatus === "process" && this.percent !== void 0) {
+      const size = this.size === "small" ? 30 : 38;
+      const stroke = this.size === "small" ? 1.5 : 2;
+      const r2 = (size - stroke) / 2;
+      const cx = size / 2;
+      const circumference = 2 * Math.PI * r2;
+      const offset = circumference - Math.min(100, Math.max(0, this.percent)) / 100 * circumference;
+      return b`
+        <svg class="progress-ring" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}">
+          <circle class="progress-ring-bg" cx="${cx}" cy="${cx}" r="${r2}" stroke-width="${stroke}" />
+          <circle
+            class="progress-ring-fg"
+            cx="${cx}"
+            cy="${cx}"
+            r="${r2}"
+            stroke-width="${stroke}"
+            stroke-dasharray="${circumference}"
+            stroke-dashoffset="${offset}"
+          />
+        </svg>
+        <span>${this.initial + index + 1}</span>
+      `;
+    }
+    return b`<span>${this.initial + index + 1}</span>`;
+  }
+  renderDot(item, index) {
+    const stepStatus = this.getStepStatus(index);
+    const posStatus = this.getPositionStatus(index);
+    const nextStatus = this.getNextStepStatus(index);
+    const nextCls = nextStatus ? `step-next-${nextStatus}` : "";
+    return b`
+      <div
+        class="step step-${stepStatus} step-pos-${posStatus} ${nextCls} ${item.disabled ? "step-disabled" : ""}"
+        role="listitem"
+      >
+        <div class="step-dot-track">
+          <div class="step-dot-indicator"></div>
+        </div>
+        <div class="step-dot-text">
+          <span class="step-title">${item.title}</span>
+          ${item.subTitle ? b`<span class="step-subtitle">${item.subTitle}</span>` : ""}
+          ${item.content ? b`<div class="step-description">${item.content}</div>` : ""}
+        </div>
+      </div>
+    `;
+  }
+  renderDefault(item, index) {
+    const stepStatus = this.getStepStatus(index);
+    const posStatus = this.getPositionStatus(index);
+    const nextStatus = this.getNextStepStatus(index);
+    const nextCls = nextStatus ? `step-next-${nextStatus}` : "";
+    const hasCustomIcon = !!item.icon;
+    return b`
+      <div
+        class="step step-${stepStatus} step-pos-${posStatus} ${nextCls} ${item.disabled ? "step-disabled" : ""}"
+        role="listitem"
+      >
+        <div class="step-icon ${hasCustomIcon ? "step-icon-custom" : ""}">${this.renderIcon(index, stepStatus)}</div>
+        <div class="step-main">
+          <div class="step-title-row">
+            <span class="step-title">${item.title}</span>
+            ${item.subTitle ? b`<span class="step-subtitle">${item.subTitle}</span>` : ""}
+            <div class="step-tail"></div>
+          </div>
+          ${item.content ? b`<div class="step-description">${item.content}</div>` : ""}
+        </div>
+      </div>
+    `;
+  }
+  renderNavigation(item, index) {
+    const stepStatus = this.getStepStatus(index);
+    const posStatus = this.getPositionStatus(index);
+    const nextStatus = this.getNextStepStatus(index);
+    const nextCls = nextStatus ? `step-next-${nextStatus}` : "";
+    const hasCustomIcon = !!item.icon;
+    const isLast = index === this.items.length - 1;
+    return b`
+      <div
+        class="step step-${stepStatus} step-pos-${posStatus} ${nextCls} ${item.disabled ? "step-disabled" : ""}"
+        role="listitem"
+      >
+        <div class="step-icon ${hasCustomIcon ? "step-icon-custom" : ""}">${this.renderIcon(index, stepStatus)}</div>
+        <div class="step-main">
+          <div class="step-title-row">
+            <span class="step-title">${item.title}</span>
+            ${item.subTitle ? b`<span class="step-subtitle">${item.subTitle}</span>` : ""}
+          </div>
+          ${item.content ? b`<div class="step-description">${item.content}</div>` : ""}
+        </div>
+        ${!isLast ? b`<div class="step-nav-arrow"></div>` : ""}
+      </div>
+    `;
+  }
+  /** 获取步骤的位置状态（不受 item.status 覆盖） */
+  getPositionStatus(index) {
+    if (index < this.current) return "finish";
+    if (index === this.current) return "process";
+    return "wait";
+  }
+  renderPanel(item, index) {
+    const stepStatus = this.getStepStatus(index);
+    const posStatus = this.getPositionStatus(index);
+    const isLast = index === this.items.length - 1;
+    const isOutlined = this.variant === "outlined";
+    if (isOutlined) {
+      const nextStatus = !isLast ? this.getStepStatus(index + 1) : null;
+      const arrowClass = nextStatus ? `step-arrow-${nextStatus}` : "";
+      return b`
+        <div
+          class="step step-${stepStatus} step-pos-${posStatus} ${item.disabled ? "step-disabled" : ""}"
+          role="listitem"
+        >
+          <div class="step-panel-content">
+            <div class="step-panel-text">
+              <div class="step-panel-title-row">
+                <span class="step-title">${item.title}</span>
+                ${item.subTitle ? b`<span class="step-subtitle">${item.subTitle}</span>` : ""}
+              </div>
+              ${item.content ? b`<div class="step-description">${item.content}</div>` : ""}
+            </div>
+          </div>
+          ${!isLast ? b`<div class="step-panel-arrow ${arrowClass}">
+                <div class="step-panel-arrow-outer"></div>
+                <div class="step-panel-arrow-inner"></div>
+              </div>` : ""}
+        </div>
+      `;
+    }
+    return b`
+      <div
+        class="step step-${stepStatus} step-pos-${posStatus} ${item.disabled ? "step-disabled" : ""}"
+        role="listitem"
+      >
+        <div class="step-panel-content">
+          <div class="step-panel-text">
+            <div class="step-panel-title-row">
+              <span class="step-title">${item.title}</span>
+              ${item.subTitle ? b`<span class="step-subtitle">${item.subTitle}</span>` : ""}
+            </div>
+            ${item.content ? b`<div class="step-description">${item.content}</div>` : ""}
+          </div>
+        </div>
+      </div>
+    `;
+  }
+  renderInline(item, index) {
+    const stepStatus = this.getStepStatus(index);
+    const posStatus = this.getPositionStatus(index);
+    const nextStatus = this.getNextStepStatus(index);
+    const nextCls = nextStatus ? `step-next-${nextStatus}` : "";
+    return b`
+      <div
+        class="step step-${stepStatus} step-pos-${posStatus} ${nextCls} ${item.disabled ? "step-disabled" : ""}"
+        role="listitem"
+      >
+        <div class="step-inline-indicator">
+          <div class="step-inline-dot"></div>
+        </div>
+        <span class="step-title">${item.title}</span>
+      </div>
+    `;
+  }
+  render() {
+    let renderStep;
+    switch (this.type) {
+      case "dot":
+        renderStep = this.renderDot;
+        break;
+      case "navigation":
+        renderStep = this.renderNavigation;
+        break;
+      case "panel":
+        renderStep = this.renderPanel;
+        break;
+      case "inline":
+        renderStep = this.renderInline;
+        break;
+      default:
+        renderStep = this.renderDefault;
+    }
+    return b`
+      <div
+        class="steps steps-${this.size} steps-${this.type} steps-${this.variant} steps-${this.effectiveOrientation} steps-title-${this.titlePlacement} ${this.clickable ? "steps-clickable" : ""}"
+        role="list"
+        @click=${(e) => {
+      if (!this.clickable) return;
+      const stepEl = e.target.closest(".step");
+      if (!stepEl) return;
+      const stepsEl = stepEl.parentElement;
+      if (!stepsEl) return;
+      const index = Array.from(stepsEl.querySelectorAll(":scope > .step")).indexOf(stepEl);
+      if (index >= 0) this.handleStepClick(index);
+    }}
+      >
+        ${this.items.map((item, index) => renderStep.call(this, item, index))}
+      </div>
+    `;
+  }
+};
+SlSteps.styles = [component_styles_default, steps_styles_default];
+SlSteps.dependencies = { "sl-icon": SlIcon };
+__decorateClass([
+  n({ type: Array })
+], SlSteps.prototype, "items", 2);
+__decorateClass([
+  n({ type: Number })
+], SlSteps.prototype, "current", 2);
+__decorateClass([
+  n({ type: String })
+], SlSteps.prototype, "status", 2);
+__decorateClass([
+  n({ type: Number })
+], SlSteps.prototype, "initial", 2);
+__decorateClass([
+  n({ type: Number })
+], SlSteps.prototype, "percent", 2);
+__decorateClass([
+  n({ type: String })
+], SlSteps.prototype, "size", 2);
+__decorateClass([
+  n({ type: String })
+], SlSteps.prototype, "type", 2);
+__decorateClass([
+  n({ type: String })
+], SlSteps.prototype, "variant", 2);
+__decorateClass([
+  n({ type: String })
+], SlSteps.prototype, "orientation", 2);
+__decorateClass([
+  n({ type: Boolean })
+], SlSteps.prototype, "responsive", 2);
+__decorateClass([
+  n({ type: String })
+], SlSteps.prototype, "titlePlacement", 2);
+__decorateClass([
+  n({ attribute: false })
+], SlSteps.prototype, "onChange", 2);
+__decorateClass([
+  r()
+], SlSteps.prototype, "_isVertical", 2);
+
+export {
+  SlSteps
+};

package/cdn/chunks/chunk.NSY3WPN7.js

@@ -0,0 +1,11 @@
+import {
+  SlSender
+} from "./chunk.RJICTQBC.js";
+
+// src/components/sender/sender.ts
+var sender_default = SlSender;
+SlSender.define("sl-sender");
+
+export {
+  sender_default
+};