@kdcloudjs/shoelace 0.0.1

package/cdn/chunks/chunk.S3MDVLAR.js

@@ -0,0 +1,75 @@
+import {
+  i
+} from "./chunk.OOP2EFQH.js";
+
+// src/components/card/card.styles.ts
+var card_styles_default = i`
+  :host {
+    --border-color: var(--sl-color-neutral-200);
+    --border-radius: var(--sl-border-radius-medium);
+    --border-width: 1px;
+    --padding: var(--sl-spacing-large);
+
+    display: inline-block;
+  }
+
+  .card {
+    display: flex;
+    flex-direction: column;
+    background-color: var(--sl-panel-background-color);
+    box-shadow: var(--sl-shadow-x-small);
+    border: solid var(--border-width) var(--border-color);
+    border-radius: var(--border-radius);
+  }
+
+  .card__image {
+    display: flex;
+    border-top-left-radius: var(--border-radius);
+    border-top-right-radius: var(--border-radius);
+    margin: calc(-1 * var(--border-width));
+    overflow: hidden;
+  }
+
+  .card__image::slotted(img) {
+    display: block;
+    width: 100%;
+  }
+
+  .card:not(.card--has-image) .card__image {
+    display: none;
+  }
+
+  .card__header {
+    display: block;
+    border-bottom: solid var(--border-width) var(--border-color);
+    padding: calc(var(--padding) / 2) var(--padding);
+  }
+
+  .card:not(.card--has-header) .card__header {
+    display: none;
+  }
+
+  .card:not(.card--has-image) .card__header {
+    border-top-left-radius: var(--border-radius);
+    border-top-right-radius: var(--border-radius);
+  }
+
+  .card__body {
+    display: block;
+    padding: var(--padding);
+  }
+
+  .card--has-footer .card__footer {
+    display: block;
+    border-top: solid var(--border-width) var(--border-color);
+    padding: var(--padding);
+  }
+
+  .card:not(.card--has-footer) .card__footer {
+    display: none;
+  }
+`;
+
+export {
+  card_styles_default
+};

package/cdn/chunks/chunk.SERSJOYJ.js

@@ -0,0 +1,11 @@
+import {
+  SlTag
+} from "./chunk.BBGFE6CH.js";
+
+// src/components/tag/tag.ts
+var tag_default = SlTag;
+SlTag.define("sl-tag");
+
+export {
+  tag_default
+};

package/cdn/chunks/chunk.SGWIMVG4.js

@@ -0,0 +1,42 @@
+import {
+  registerTranslation
+} from "./chunk.TDEXDIPB.js";
+
+// src/translations/de.ts
+var translation = {
+  $code: "de",
+  $name: "Deutsch",
+  $dir: "ltr",
+  carousel: "Karussell",
+  clearEntry: "Eingabe l\xF6schen",
+  close: "Schlie\xDFen",
+  copied: "Kopiert",
+  copy: "Kopieren",
+  currentValue: "Aktueller Wert",
+  error: "Fehler",
+  goToSlide: (slide, count) => `Zu Folie ${slide} von ${count} gehen`,
+  hidePassword: "Passwort verbergen",
+  loading: "Wird geladen",
+  nextSlide: "N\xE4chste Folie",
+  numOptionsSelected: (num) => {
+    if (num === 0) return "Keine Optionen ausgew\xE4hlt";
+    if (num === 1) return "1 Option ausgew\xE4hlt";
+    return `${num} Optionen ausgew\xE4hlt`;
+  },
+  previousSlide: "Vorherige Folie",
+  progress: "Fortschritt",
+  remove: "Entfernen",
+  resize: "Gr\xF6\xDFe \xE4ndern",
+  scrollToEnd: "Zum Ende scrollen",
+  scrollToStart: "Zum Anfang scrollen",
+  selectAColorFromTheScreen: "Farbe vom Bildschirm ausw\xE4hlen",
+  showPassword: "Passwort anzeigen",
+  slideNum: (slide) => `Folie ${slide}`,
+  toggleColorFormat: "Farbformat umschalten"
+};
+registerTranslation(translation);
+var de_default = translation;
+
+export {
+  de_default
+};

package/cdn/chunks/chunk.SJGQJLXX.js

@@ -0,0 +1,11 @@
+import {
+  SlMenuLabel
+} from "./chunk.LLUFLSKF.js";
+
+// src/components/menu-label/menu-label.ts
+var menu_label_default = SlMenuLabel;
+SlMenuLabel.define("sl-menu-label");
+
+export {
+  menu_label_default
+};

package/cdn/chunks/chunk.SRECDZMQ.js

@@ -0,0 +1,55 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk.W27M6RDR.js";
+
+// src/internal/animate.ts
+function animateTo(el, keyframes, options) {
+  return new Promise((resolve) => {
+    if ((options == null ? void 0 : options.duration) === Infinity) {
+      throw new Error("Promise-based animations must be finite.");
+    }
+    const animation = el.animate(keyframes, __spreadProps(__spreadValues({}, options), {
+      duration: prefersReducedMotion() ? 0 : options.duration
+    }));
+    animation.addEventListener("cancel", resolve, { once: true });
+    animation.addEventListener("finish", resolve, { once: true });
+  });
+}
+function parseDuration(delay) {
+  delay = delay.toString().toLowerCase();
+  if (delay.indexOf("ms") > -1) {
+    return parseFloat(delay);
+  }
+  if (delay.indexOf("s") > -1) {
+    return parseFloat(delay) * 1e3;
+  }
+  return parseFloat(delay);
+}
+function prefersReducedMotion() {
+  const query = window.matchMedia("(prefers-reduced-motion: reduce)");
+  return query.matches;
+}
+function stopAnimations(el) {
+  return Promise.all(
+    el.getAnimations().map((animation) => {
+      return new Promise((resolve) => {
+        animation.cancel();
+        requestAnimationFrame(resolve);
+      });
+    })
+  );
+}
+function shimKeyframesHeightAuto(keyframes, calculatedHeight) {
+  return keyframes.map((keyframe) => __spreadProps(__spreadValues({}, keyframe), {
+    height: keyframe.height === "auto" ? `${calculatedHeight}px` : keyframe.height
+  }));
+}
+
+export {
+  animateTo,
+  parseDuration,
+  prefersReducedMotion,
+  stopAnimations,
+  shimKeyframesHeightAuto
+};

package/cdn/chunks/chunk.T2KBZPV4.js

@@ -0,0 +1,28 @@
+import {
+  SlRange
+} from "./chunk.7LLV4XX3.js";
+
+// src/react/range/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-range";
+SlRange.define("sl-range");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlRange,
+  react: React,
+  events: {
+    onSlBlur: "sl-blur",
+    onSlChange: "sl-change",
+    onSlFocus: "sl-focus",
+    onSlInput: "sl-input",
+    onSlInvalid: "sl-invalid"
+  },
+  displayName: "SlRange"
+});
+var range_default = reactWrapper;
+
+export {
+  range_default
+};

package/cdn/chunks/chunk.T33TOUU7.js

@@ -0,0 +1,37 @@
+import {
+  button_styles_default
+} from "./chunk.KINKNNIL.js";
+import {
+  i
+} from "./chunk.OOP2EFQH.js";
+
+// src/components/radio-button/radio-button.styles.ts
+var radio_button_styles_default = i`
+  ${button_styles_default}
+
+  .button__prefix,
+  .button__suffix,
+  .button__label {
+    display: inline-flex;
+    position: relative;
+    align-items: center;
+  }
+
+  /* We use a hidden input so constraint validation errors work, since they don't appear to show when used with buttons.
+    We can't actually hide it, though, otherwise the messages will be suppressed by the browser. */
+  .hidden-input {
+    all: unset;
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    right: 0;
+    outline: dotted 1px red;
+    opacity: 0;
+    z-index: -1;
+  }
+`;
+
+export {
+  radio_button_styles_default
+};

package/cdn/chunks/chunk.T4HYSBAS.js

@@ -0,0 +1,135 @@
+import {
+  icon_button_styles_default
+} from "./chunk.VMDRFYXT.js";
+import {
+  i,
+  u
+} from "./chunk.UBADX4L7.js";
+import {
+  o
+} from "./chunk.ZTHCIXLL.js";
+import {
+  e
+} from "./chunk.3RBSSBZT.js";
+import {
+  SlIcon
+} from "./chunk.BTNTELW5.js";
+import {
+  component_styles_default
+} from "./chunk.INZSKSLC.js";
+import {
+  ShoelaceElement,
+  e as e2,
+  n,
+  r
+} from "./chunk.5YQYSVGD.js";
+import {
+  __decorateClass
+} from "./chunk.W27M6RDR.js";
+
+// src/components/icon-button/icon-button.component.ts
+var SlIconButton = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.hasFocus = false;
+    this.label = "";
+    this.disabled = false;
+  }
+  handleBlur() {
+    this.hasFocus = false;
+    this.emit("sl-blur");
+  }
+  handleFocus() {
+    this.hasFocus = true;
+    this.emit("sl-focus");
+  }
+  handleClick(event) {
+    if (this.disabled) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+  }
+  /** Simulates a click on the icon button. */
+  click() {
+    this.button.click();
+  }
+  /** Sets focus on the icon button. */
+  focus(options) {
+    this.button.focus(options);
+  }
+  /** Removes focus from the icon button. */
+  blur() {
+    this.button.blur();
+  }
+  render() {
+    const isLink = this.href ? true : false;
+    const tag = isLink ? i`a` : i`button`;
+    return u`
+      <${tag}
+        part="base"
+        class=${e({
+      "icon-button": true,
+      "icon-button--disabled": !isLink && this.disabled,
+      "icon-button--focused": this.hasFocus
+    })}
+        ?disabled=${o(isLink ? void 0 : this.disabled)}
+        type=${o(isLink ? void 0 : "button")}
+        href=${o(isLink ? this.href : void 0)}
+        target=${o(isLink ? this.target : void 0)}
+        download=${o(isLink ? this.download : void 0)}
+        rel=${o(isLink && this.target ? "noreferrer noopener" : void 0)}
+        role=${o(isLink ? void 0 : "button")}
+        aria-disabled=${this.disabled ? "true" : "false"}
+        aria-label="${this.label}"
+        tabindex=${this.disabled ? "-1" : "0"}
+        @blur=${this.handleBlur}
+        @focus=${this.handleFocus}
+        @click=${this.handleClick}
+      >
+        <sl-icon
+          class="icon-button__icon"
+          name=${o(this.name)}
+          library=${o(this.library)}
+          src=${o(this.src)}
+          aria-hidden="true"
+        ></sl-icon>
+      </${tag}>
+    `;
+  }
+};
+SlIconButton.styles = [component_styles_default, icon_button_styles_default];
+SlIconButton.dependencies = { "sl-icon": SlIcon };
+__decorateClass([
+  e2(".icon-button")
+], SlIconButton.prototype, "button", 2);
+__decorateClass([
+  r()
+], SlIconButton.prototype, "hasFocus", 2);
+__decorateClass([
+  n()
+], SlIconButton.prototype, "name", 2);
+__decorateClass([
+  n()
+], SlIconButton.prototype, "library", 2);
+__decorateClass([
+  n()
+], SlIconButton.prototype, "src", 2);
+__decorateClass([
+  n()
+], SlIconButton.prototype, "href", 2);
+__decorateClass([
+  n()
+], SlIconButton.prototype, "target", 2);
+__decorateClass([
+  n()
+], SlIconButton.prototype, "download", 2);
+__decorateClass([
+  n()
+], SlIconButton.prototype, "label", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], SlIconButton.prototype, "disabled", 2);
+
+export {
+  SlIconButton
+};

package/cdn/chunks/chunk.T4J3JBLF.js

@@ -0,0 +1,24 @@
+import {
+  SlImageComparer
+} from "./chunk.6X6GEZV7.js";
+
+// src/react/image-comparer/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-image-comparer";
+SlImageComparer.define("sl-image-comparer");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlImageComparer,
+  react: React,
+  events: {
+    onSlChange: "sl-change"
+  },
+  displayName: "SlImageComparer"
+});
+var image_comparer_default = reactWrapper;
+
+export {
+  image_comparer_default
+};

package/cdn/chunks/chunk.T5Q3S2PG.js

@@ -0,0 +1,11 @@
+import {
+  SlDivider
+} from "./chunk.XIULUDCA.js";
+
+// src/components/divider/divider.ts
+var divider_default = SlDivider;
+SlDivider.define("sl-divider");
+
+export {
+  divider_default
+};

package/cdn/chunks/chunk.TC2QSLMZ.js

@@ -0,0 +1,119 @@
+import {
+  activeElements,
+  getDeepestActiveElement,
+  getTabbableElements
+} from "./chunk.V4KCW2CR.js";
+
+// src/internal/modal.ts
+var activeModals = [];
+var Modal = class {
+  constructor(element) {
+    this.tabDirection = "forward";
+    this.handleFocusIn = () => {
+      if (!this.isActive()) return;
+      this.checkFocus();
+    };
+    this.handleKeyDown = (event) => {
+      var _a;
+      if (event.key !== "Tab" || this.isExternalActivated) return;
+      if (!this.isActive()) return;
+      const currentActiveElement = getDeepestActiveElement();
+      this.previousFocus = currentActiveElement;
+      if (this.previousFocus && this.possiblyHasTabbableChildren(this.previousFocus)) {
+        return;
+      }
+      if (event.shiftKey) {
+        this.tabDirection = "backward";
+      } else {
+        this.tabDirection = "forward";
+      }
+      const tabbableElements = getTabbableElements(this.element);
+      let currentFocusIndex = tabbableElements.findIndex((el) => el === currentActiveElement);
+      this.previousFocus = this.currentFocus;
+      const addition = this.tabDirection === "forward" ? 1 : -1;
+      while (true) {
+        if (currentFocusIndex + addition >= tabbableElements.length) {
+          currentFocusIndex = 0;
+        } else if (currentFocusIndex + addition < 0) {
+          currentFocusIndex = tabbableElements.length - 1;
+        } else {
+          currentFocusIndex += addition;
+        }
+        this.previousFocus = this.currentFocus;
+        const nextFocus = (
+          /** @type {HTMLElement} */
+          tabbableElements[currentFocusIndex]
+        );
+        if (this.tabDirection === "backward") {
+          if (this.previousFocus && this.possiblyHasTabbableChildren(this.previousFocus)) {
+            return;
+          }
+        }
+        if (nextFocus && this.possiblyHasTabbableChildren(nextFocus)) {
+          return;
+        }
+        event.preventDefault();
+        this.currentFocus = nextFocus;
+        (_a = this.currentFocus) == null ? void 0 : _a.focus({ preventScroll: false });
+        const allActiveElements = [...activeElements()];
+        if (allActiveElements.includes(this.currentFocus) || !allActiveElements.includes(this.previousFocus)) {
+          break;
+        }
+      }
+      setTimeout(() => this.checkFocus());
+    };
+    this.handleKeyUp = () => {
+      this.tabDirection = "forward";
+    };
+    this.element = element;
+    this.elementsWithTabbableControls = ["iframe"];
+  }
+  /** Activates focus trapping. */
+  activate() {
+    activeModals.push(this.element);
+    document.addEventListener("focusin", this.handleFocusIn);
+    document.addEventListener("keydown", this.handleKeyDown);
+    document.addEventListener("keyup", this.handleKeyUp);
+  }
+  /** Deactivates focus trapping. */
+  deactivate() {
+    activeModals = activeModals.filter((modal) => modal !== this.element);
+    this.currentFocus = null;
+    document.removeEventListener("focusin", this.handleFocusIn);
+    document.removeEventListener("keydown", this.handleKeyDown);
+    document.removeEventListener("keyup", this.handleKeyUp);
+  }
+  /** Determines if this modal element is currently active or not. */
+  isActive() {
+    return activeModals[activeModals.length - 1] === this.element;
+  }
+  /** Activates external modal behavior and temporarily disables focus trapping. */
+  activateExternal() {
+    this.isExternalActivated = true;
+  }
+  /** Deactivates external modal behavior and re-enables focus trapping. */
+  deactivateExternal() {
+    this.isExternalActivated = false;
+  }
+  checkFocus() {
+    if (this.isActive() && !this.isExternalActivated) {
+      const tabbableElements = getTabbableElements(this.element);
+      if (!this.element.matches(":focus-within")) {
+        const start = tabbableElements[0];
+        const end = tabbableElements[tabbableElements.length - 1];
+        const target = this.tabDirection === "forward" ? start : end;
+        if (typeof (target == null ? void 0 : target.focus) === "function") {
+          this.currentFocus = target;
+          target.focus({ preventScroll: false });
+        }
+      }
+    }
+  }
+  possiblyHasTabbableChildren(element) {
+    return this.elementsWithTabbableControls.includes(element.tagName.toLowerCase()) || element.hasAttribute("controls");
+  }
+};
+
+export {
+  Modal
+};

package/cdn/chunks/chunk.TDEXDIPB.js

@@ -0,0 +1,111 @@
+// node_modules/@shoelace-style/localize/dist/index.js
+var connectedElements = /* @__PURE__ */ new Set();
+var translations = /* @__PURE__ */ new Map();
+var fallback;
+var documentDirection = "ltr";
+var documentLanguage = "en";
+var isClient = typeof MutationObserver !== "undefined" && typeof document !== "undefined" && typeof document.documentElement !== "undefined";
+if (isClient) {
+  const documentElementObserver = new MutationObserver(update);
+  documentDirection = document.documentElement.dir || "ltr";
+  documentLanguage = document.documentElement.lang || navigator.language;
+  documentElementObserver.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: ["dir", "lang"]
+  });
+}
+function registerTranslation(...translation) {
+  translation.map((t) => {
+    const code = t.$code.toLowerCase();
+    if (translations.has(code)) {
+      translations.set(code, Object.assign(Object.assign({}, translations.get(code)), t));
+    } else {
+      translations.set(code, t);
+    }
+    if (!fallback) {
+      fallback = t;
+    }
+  });
+  update();
+}
+function update() {
+  if (isClient) {
+    documentDirection = document.documentElement.dir || "ltr";
+    documentLanguage = document.documentElement.lang || navigator.language;
+  }
+  [...connectedElements.keys()].map((el) => {
+    if (typeof el.requestUpdate === "function") {
+      el.requestUpdate();
+    }
+  });
+}
+var LocalizeController = class {
+  constructor(host) {
+    this.host = host;
+    this.host.addController(this);
+  }
+  hostConnected() {
+    connectedElements.add(this.host);
+  }
+  hostDisconnected() {
+    connectedElements.delete(this.host);
+  }
+  dir() {
+    return `${this.host.dir || documentDirection}`.toLowerCase();
+  }
+  lang() {
+    return `${this.host.lang || documentLanguage}`.toLowerCase();
+  }
+  getTranslationData(lang) {
+    var _a, _b;
+    const locale = new Intl.Locale(lang.replace(/_/g, "-"));
+    const language = locale === null || locale === void 0 ? void 0 : locale.language.toLowerCase();
+    const region = (_b = (_a = locale === null || locale === void 0 ? void 0 : locale.region) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : "";
+    const primary = translations.get(`${language}-${region}`);
+    const secondary = translations.get(language);
+    return { locale, language, region, primary, secondary };
+  }
+  exists(key, options) {
+    var _a;
+    const { primary, secondary } = this.getTranslationData((_a = options.lang) !== null && _a !== void 0 ? _a : this.lang());
+    options = Object.assign({ includeFallback: false }, options);
+    if (primary && primary[key] || secondary && secondary[key] || options.includeFallback && fallback && fallback[key]) {
+      return true;
+    }
+    return false;
+  }
+  term(key, ...args) {
+    const { primary, secondary } = this.getTranslationData(this.lang());
+    let term;
+    if (primary && primary[key]) {
+      term = primary[key];
+    } else if (secondary && secondary[key]) {
+      term = secondary[key];
+    } else if (fallback && fallback[key]) {
+      term = fallback[key];
+    } else {
+      console.error(`No translation found for: ${String(key)}`);
+      return String(key);
+    }
+    if (typeof term === "function") {
+      return term(...args);
+    }
+    return term;
+  }
+  date(dateToFormat, options) {
+    dateToFormat = new Date(dateToFormat);
+    return new Intl.DateTimeFormat(this.lang(), options).format(dateToFormat);
+  }
+  number(numberToFormat, options) {
+    numberToFormat = Number(numberToFormat);
+    return isNaN(numberToFormat) ? "" : new Intl.NumberFormat(this.lang(), options).format(numberToFormat);
+  }
+  relativeTime(value, unit, options) {
+    return new Intl.RelativeTimeFormat(this.lang(), options).format(value, unit);
+  }
+};
+
+export {
+  registerTranslation,
+  LocalizeController
+};

package/cdn/chunks/chunk.TMWTIVPK.js

@@ -0,0 +1,21 @@
+import {
+  SlMenuLabel
+} from "./chunk.LLUFLSKF.js";
+
+// src/react/menu-label/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "sl-menu-label";
+SlMenuLabel.define("sl-menu-label");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlMenuLabel,
+  react: React,
+  events: {},
+  displayName: "SlMenuLabel"
+});
+var menu_label_default = reactWrapper;
+
+export {
+  menu_label_default
+};