@cruglobal/cornerstone-components 0.6.1 → 0.6.2

package/dist/bundled/chunks/chunk.UPLISVPS.js

@@ -0,0 +1,339 @@
+/*! Cornerstone Components 0.6.2 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  zoomable_frame_styles_default
+} from "./chunk.QOHTE36K.js";
+import {
+  parseSpaceDelimitedTokens
+} from "./chunk.QVMFBQ5Z.js";
+import {
+  o as o2
+} from "./chunk.OFJBXFXN.js";
+import {
+  CornerstoneElement,
+  customElement,
+  e,
+  n,
+  r
+} from "./chunk.VO5P54JZ.js";
+import {
+  LocalizeController
+} from "./chunk.QUVFD4CZ.js";
+import {
+  o
+} from "./chunk.CRKHH5GL.js";
+import {
+  b
+} from "./chunk.B2T6AD2P.js";
+import {
+  __decorateClass
+} from "./chunk.QQCENPXN.js";
+
+// src/internal/color-scheme-controller.ts
+var ColorSchemeController = class {
+  constructor(host, onThemeChange) {
+    this.handleTransitionEnd = () => {
+      this.onThemeChange();
+    };
+    (this.host = host).addController(this);
+    this.onThemeChange = onThemeChange;
+    if (typeof document !== "undefined") {
+      this.hiddenElement = document.createElement("div");
+      this.hiddenElement.setAttribute("aria-hidden", "true");
+      Object.assign(this.hiddenElement.style, {
+        position: "absolute",
+        width: "0",
+        height: "0",
+        overflow: "hidden",
+        pointerEvents: "none",
+        opacity: "0",
+        // Transition on a WA surface token — changes whenever the theme class changes
+        color: "var(--cs-color-surface-default, transparent)",
+        transition: "color 0.001ms"
+      });
+    }
+  }
+  hostConnected() {
+    if (this.hiddenElement) {
+      this.host.appendChild(this.hiddenElement);
+      this.hiddenElement.addEventListener("transitionend", this.handleTransitionEnd);
+    }
+  }
+  hostDisconnected() {
+    if (this.hiddenElement) {
+      this.hiddenElement.removeEventListener("transitionend", this.handleTransitionEnd);
+      this.hiddenElement.remove();
+    }
+  }
+};
+
+// src/components/zoomable-frame/zoomable-frame.ts
+var CsZoomableFrame = class extends CornerstoneElement {
+  constructor() {
+    super();
+    this.localize = new LocalizeController(this);
+    // SSR guard: MutationObserver is not available during server-side rendering
+    this.themeObserver = !o ? new MutationObserver(() => this.syncTheme()) : null;
+    this.availableZoomLevels = [];
+    this.allowfullscreen = false;
+    this.loading = "eager";
+    this.zoom = 1;
+    this.zoomLevels = "25% 50% 75% 100% 125% 150% 175% 200%";
+    this.withoutControls = false;
+    this.withoutInteraction = false;
+    this.withThemeSync = false;
+    new ColorSchemeController(this, () => this.syncTheme());
+  }
+  /** Returns the internal iframe's `window` object. (Readonly property) */
+  get contentWindow() {
+    return this.iframe?.contentWindow || null;
+  }
+  /** Returns the internal iframe's `document` object. (Readonly property) */
+  get contentDocument() {
+    return this.iframe?.contentDocument || null;
+  }
+  parseZoomLevels(zoomLevelsString) {
+    const tokens = parseSpaceDelimitedTokens(zoomLevelsString);
+    const levels = [];
+    for (const token of tokens) {
+      let value;
+      if (token.endsWith("%")) {
+        const percentage = parseFloat(token.slice(0, -1));
+        if (!isNaN(percentage)) {
+          value = Math.max(0, percentage / 100);
+        } else {
+          continue;
+        }
+      } else {
+        value = parseFloat(token);
+        if (!isNaN(value)) {
+          value = Math.max(0, value);
+        } else {
+          continue;
+        }
+      }
+      levels.push(value);
+    }
+    return [...new Set(levels)].sort((a, b2) => a - b2);
+  }
+  getCurrentZoomIndex() {
+    if (this.availableZoomLevels.length === 0) {
+      return -1;
+    }
+    let closestIndex = 0;
+    let closestDiff = Math.abs(this.availableZoomLevels[0] - this.zoom);
+    for (let i = 1; i < this.availableZoomLevels.length; i++) {
+      const diff = Math.abs(this.availableZoomLevels[i] - this.zoom);
+      if (diff < closestDiff) {
+        closestDiff = diff;
+        closestIndex = i;
+      }
+    }
+    return closestIndex;
+  }
+  isZoomInDisabled() {
+    if (this.availableZoomLevels.length === 0) {
+      return false;
+    }
+    const currentIndex = this.getCurrentZoomIndex();
+    return currentIndex >= this.availableZoomLevels.length - 1;
+  }
+  isZoomOutDisabled() {
+    if (this.availableZoomLevels.length === 0) {
+      return false;
+    }
+    const currentIndex = this.getCurrentZoomIndex();
+    return currentIndex <= 0;
+  }
+  willUpdate(changedProperties) {
+    if (changedProperties.has("zoom")) {
+      this.setStyleProperty("--zoom", `${this.zoom}`);
+    }
+    super.willUpdate(changedProperties);
+  }
+  updated(changedProperties) {
+    if (changedProperties.has("zoomLevels")) {
+      this.availableZoomLevels = this.parseZoomLevels(this.zoomLevels);
+      if (this.availableZoomLevels.length > 0) {
+        const currentIndex = this.getCurrentZoomIndex();
+        if (Math.abs(this.availableZoomLevels[currentIndex] - this.zoom) > 1e-3) {
+          this.zoom = this.availableZoomLevels[currentIndex];
+        }
+      }
+    }
+    if (changedProperties.has("withThemeSync")) {
+      if (this.withThemeSync) {
+        this.themeObserver?.observe(document.documentElement, { attributes: true, attributeFilter: ["class"] });
+        this.syncTheme();
+      } else {
+        this.themeObserver?.disconnect();
+      }
+    }
+    super.updated(changedProperties);
+  }
+  /** Zooms in to the next available zoom level. */
+  zoomIn() {
+    if (this.availableZoomLevels.length === 0) {
+      this.zoom = Math.min(this.zoom + 0.05, 2);
+      return;
+    }
+    const currentIndex = this.getCurrentZoomIndex();
+    if (currentIndex < this.availableZoomLevels.length - 1) {
+      this.zoom = this.availableZoomLevels[currentIndex + 1];
+    }
+  }
+  /** Zooms out to the previous available zoom level. */
+  zoomOut() {
+    if (this.availableZoomLevels.length === 0) {
+      this.zoom = Math.max(this.zoom - 0.05, 0);
+      return;
+    }
+    const currentIndex = this.getCurrentZoomIndex();
+    if (currentIndex > 0) {
+      this.zoom = this.availableZoomLevels[currentIndex - 1];
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.themeObserver?.disconnect();
+  }
+  syncTheme() {
+    if (!this.withThemeSync) {
+      return;
+    }
+    try {
+      const iframeRoot = this.contentDocument?.documentElement;
+      if (!iframeRoot) {
+        return;
+      }
+      const prefixes = ["cs-theme-", "cs-brand-", "cs-palette-"];
+      const schemeCls = /* @__PURE__ */ new Set();
+      const themeCls = /* @__PURE__ */ new Set();
+      let el = this;
+      let schemeFound = false;
+      while (el) {
+        if (!schemeFound) {
+          if (el.classList.contains("cs-dark")) {
+            schemeCls.add("cs-dark");
+            schemeFound = true;
+          } else if (el.classList.contains("cs-light")) {
+            schemeCls.add("cs-light");
+            schemeFound = true;
+          }
+        }
+        for (const cls of el.classList) {
+          if (prefixes.some((p) => cls.startsWith(p))) {
+            themeCls.add(cls);
+          }
+        }
+        el = el.parentElement;
+      }
+      iframeRoot.classList.toggle("cs-dark", schemeCls.has("cs-dark"));
+      iframeRoot.classList.toggle("cs-light", schemeCls.has("cs-light"));
+      const toRemove = Array.from(iframeRoot.classList).filter((c) => prefixes.some((p) => c.startsWith(p)));
+      iframeRoot.classList.remove(...toRemove);
+      iframeRoot.classList.add(...themeCls);
+    } catch {
+    }
+  }
+  handleLoad() {
+    if (this.withThemeSync) {
+      this.syncTheme();
+    }
+    this.dispatchEvent(new Event("load", { bubbles: false, cancelable: false, composed: true }));
+  }
+  handleError() {
+    this.dispatchEvent(new Event("error", { bubbles: false, cancelable: false, composed: true }));
+  }
+  render() {
+    return b`
+      <div id="frame-container">
+        <iframe
+          id="iframe"
+          part="iframe"
+          ?inert=${this.withoutInteraction}
+          ?allowfullscreen=${this.allowfullscreen}
+          loading=${this.loading}
+          referrerpolicy=${this.referrerpolicy}
+          sandbox=${o2(this.sandbox ?? void 0)}
+          src=${o2(this.src ?? void 0)}
+          srcdoc=${o2(this.srcdoc ?? void 0)}
+          @load=${this.handleLoad}
+          @error=${this.handleError}
+        ></iframe>
+      </div>
+
+      ${!this.withoutControls ? b`
+              <div id="controls" part="controls">
+                <button
+                  part="zoom-out-button"
+                  aria-label=${this.localize.term("zoomOut")}
+                  @click=${this.zoomOut}
+                  ?disabled=${this.isZoomOutDisabled()}
+                >
+                  <slot name="zoom-out-icon">
+                    <cs-icon name="remove" label="Zoom out"></cs-icon>
+                  </slot>
+                </button>
+                <span>${this.localize.number(this.zoom, { style: "percent", maximumFractionDigits: 1 })}</span>
+                <button
+                  part="zoom-in-button"
+                  aria-label=${this.localize.term("zoomIn")}
+                  @click=${this.zoomIn}
+                  ?disabled=${this.isZoomInDisabled()}
+                >
+                  <slot name="zoom-in-icon">
+                    <cs-icon name="add" label="Zoom in"></cs-icon>
+                  </slot>
+                </button>
+              </div>
+            ` : ""}
+    `;
+  }
+};
+CsZoomableFrame.css = zoomable_frame_styles_default;
+__decorateClass([
+  r()
+], CsZoomableFrame.prototype, "availableZoomLevels", 2);
+__decorateClass([
+  e("#iframe")
+], CsZoomableFrame.prototype, "iframe", 2);
+__decorateClass([
+  n()
+], CsZoomableFrame.prototype, "src", 2);
+__decorateClass([
+  n()
+], CsZoomableFrame.prototype, "srcdoc", 2);
+__decorateClass([
+  n({ type: Boolean })
+], CsZoomableFrame.prototype, "allowfullscreen", 2);
+__decorateClass([
+  n()
+], CsZoomableFrame.prototype, "loading", 2);
+__decorateClass([
+  n()
+], CsZoomableFrame.prototype, "referrerpolicy", 2);
+__decorateClass([
+  n()
+], CsZoomableFrame.prototype, "sandbox", 2);
+__decorateClass([
+  n({ type: Number, reflect: true })
+], CsZoomableFrame.prototype, "zoom", 2);
+__decorateClass([
+  n({ attribute: "zoom-levels" })
+], CsZoomableFrame.prototype, "zoomLevels", 2);
+__decorateClass([
+  n({ type: Boolean, attribute: "without-controls", reflect: true })
+], CsZoomableFrame.prototype, "withoutControls", 2);
+__decorateClass([
+  n({ type: Boolean, attribute: "without-interaction", reflect: true })
+], CsZoomableFrame.prototype, "withoutInteraction", 2);
+__decorateClass([
+  n({ type: Boolean, attribute: "with-theme-sync", reflect: true })
+], CsZoomableFrame.prototype, "withThemeSync", 2);
+CsZoomableFrame = __decorateClass([
+  customElement("cs-zoomable-frame")
+], CsZoomableFrame);
+
+export {
+  CsZoomableFrame
+};

package/dist/bundled/chunks/chunk.UPT2UL3V.js

@@ -0,0 +1,345 @@
+/*! Cornerstone Components 0.6.2 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  __commonJS
+} from "./chunk.QQCENPXN.js";
+
+// ../../node_modules/react/cjs/react.production.min.js
+var require_react_production_min = __commonJS({
+  "../../node_modules/react/cjs/react.production.min.js"(exports) {
+    "use strict";
+    var l = /* @__PURE__ */ Symbol.for("react.element");
+    var n2 = /* @__PURE__ */ Symbol.for("react.portal");
+    var p = /* @__PURE__ */ Symbol.for("react.fragment");
+    var q = /* @__PURE__ */ Symbol.for("react.strict_mode");
+    var r = /* @__PURE__ */ Symbol.for("react.profiler");
+    var t2 = /* @__PURE__ */ Symbol.for("react.provider");
+    var u = /* @__PURE__ */ Symbol.for("react.context");
+    var v = /* @__PURE__ */ Symbol.for("react.forward_ref");
+    var w = /* @__PURE__ */ Symbol.for("react.suspense");
+    var x = /* @__PURE__ */ Symbol.for("react.memo");
+    var y = /* @__PURE__ */ Symbol.for("react.lazy");
+    var z = Symbol.iterator;
+    function A(a) {
+      if (null === a || "object" !== typeof a) return null;
+      a = z && a[z] || a["@@iterator"];
+      return "function" === typeof a ? a : null;
+    }
+    var B = { isMounted: function() {
+      return false;
+    }, enqueueForceUpdate: function() {
+    }, enqueueReplaceState: function() {
+    }, enqueueSetState: function() {
+    } };
+    var C = Object.assign;
+    var D = {};
+    function E(a, b, e2) {
+      this.props = a;
+      this.context = b;
+      this.refs = D;
+      this.updater = e2 || B;
+    }
+    E.prototype.isReactComponent = {};
+    E.prototype.setState = function(a, b) {
+      if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+      this.updater.enqueueSetState(this, a, b, "setState");
+    };
+    E.prototype.forceUpdate = function(a) {
+      this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+    };
+    function F() {
+    }
+    F.prototype = E.prototype;
+    function G(a, b, e2) {
+      this.props = a;
+      this.context = b;
+      this.refs = D;
+      this.updater = e2 || B;
+    }
+    var H = G.prototype = new F();
+    H.constructor = G;
+    C(H, E.prototype);
+    H.isPureReactComponent = true;
+    var I = Array.isArray;
+    var J = Object.prototype.hasOwnProperty;
+    var K = { current: null };
+    var L = { key: true, ref: true, __self: true, __source: true };
+    function M(a, b, e2) {
+      var d, c = {}, k = null, h = null;
+      if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
+      var g = arguments.length - 2;
+      if (1 === g) c.children = e2;
+      else if (1 < g) {
+        for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
+        c.children = f;
+      }
+      if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
+      return { $$typeof: l, type: a, key: k, ref: h, props: c, _owner: K.current };
+    }
+    function N(a, b) {
+      return { $$typeof: l, type: a.type, key: b, ref: a.ref, props: a.props, _owner: a._owner };
+    }
+    function O(a) {
+      return "object" === typeof a && null !== a && a.$$typeof === l;
+    }
+    function escape(a) {
+      var b = { "=": "=0", ":": "=2" };
+      return "$" + a.replace(/[=:]/g, function(a2) {
+        return b[a2];
+      });
+    }
+    var P = /\/+/g;
+    function Q(a, b) {
+      return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+    }
+    function R(a, b, e2, d, c) {
+      var k = typeof a;
+      if ("undefined" === k || "boolean" === k) a = null;
+      var h = false;
+      if (null === a) h = true;
+      else switch (k) {
+        case "string":
+        case "number":
+          h = true;
+          break;
+        case "object":
+          switch (a.$$typeof) {
+            case l:
+            case n2:
+              h = true;
+          }
+      }
+      if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e2 = "", null != a && (e2 = a.replace(P, "$&/") + "/"), R(c, b, e2, "", function(a2) {
+        return a2;
+      })) : null != c && (O(c) && (c = N(c, e2 + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
+      h = 0;
+      d = "" === d ? "." : d + ":";
+      if (I(a)) for (var g = 0; g < a.length; g++) {
+        k = a[g];
+        var f = d + Q(k, g);
+        h += R(k, b, e2, f, c);
+      }
+      else if (f = A(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done; ) k = k.value, f = d + Q(k, g++), h += R(k, b, e2, f, c);
+      else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+      return h;
+    }
+    function S(a, b, e2) {
+      if (null == a) return a;
+      var d = [], c = 0;
+      R(a, d, "", "", function(a2) {
+        return b.call(e2, a2, c++);
+      });
+      return d;
+    }
+    function T(a) {
+      if (-1 === a._status) {
+        var b = a._result;
+        b = b();
+        b.then(function(b2) {
+          if (0 === a._status || -1 === a._status) a._status = 1, a._result = b2;
+        }, function(b2) {
+          if (0 === a._status || -1 === a._status) a._status = 2, a._result = b2;
+        });
+        -1 === a._status && (a._status = 0, a._result = b);
+      }
+      if (1 === a._status) return a._result.default;
+      throw a._result;
+    }
+    var U = { current: null };
+    var V = { transition: null };
+    var W = { ReactCurrentDispatcher: U, ReactCurrentBatchConfig: V, ReactCurrentOwner: K };
+    function X() {
+      throw Error("act(...) is not supported in production builds of React.");
+    }
+    exports.Children = { map: S, forEach: function(a, b, e2) {
+      S(a, function() {
+        b.apply(this, arguments);
+      }, e2);
+    }, count: function(a) {
+      var b = 0;
+      S(a, function() {
+        b++;
+      });
+      return b;
+    }, toArray: function(a) {
+      return S(a, function(a2) {
+        return a2;
+      }) || [];
+    }, only: function(a) {
+      if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
+      return a;
+    } };
+    exports.Component = E;
+    exports.Fragment = p;
+    exports.Profiler = r;
+    exports.PureComponent = G;
+    exports.StrictMode = q;
+    exports.Suspense = w;
+    exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
+    exports.act = X;
+    exports.cloneElement = function(a, b, e2) {
+      if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
+      var d = C({}, a.props), c = a.key, k = a.ref, h = a._owner;
+      if (null != b) {
+        void 0 !== b.ref && (k = b.ref, h = K.current);
+        void 0 !== b.key && (c = "" + b.key);
+        if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
+        for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+      }
+      var f = arguments.length - 2;
+      if (1 === f) d.children = e2;
+      else if (1 < f) {
+        g = Array(f);
+        for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
+        d.children = g;
+      }
+      return { $$typeof: l, type: a.type, key: c, ref: k, props: d, _owner: h };
+    };
+    exports.createContext = function(a) {
+      a = { $$typeof: u, _currentValue: a, _currentValue2: a, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
+      a.Provider = { $$typeof: t2, _context: a };
+      return a.Consumer = a;
+    };
+    exports.createElement = M;
+    exports.createFactory = function(a) {
+      var b = M.bind(null, a);
+      b.type = a;
+      return b;
+    };
+    exports.createRef = function() {
+      return { current: null };
+    };
+    exports.forwardRef = function(a) {
+      return { $$typeof: v, render: a };
+    };
+    exports.isValidElement = O;
+    exports.lazy = function(a) {
+      return { $$typeof: y, _payload: { _status: -1, _result: a }, _init: T };
+    };
+    exports.memo = function(a, b) {
+      return { $$typeof: x, type: a, compare: void 0 === b ? null : b };
+    };
+    exports.startTransition = function(a) {
+      var b = V.transition;
+      V.transition = {};
+      try {
+        a();
+      } finally {
+        V.transition = b;
+      }
+    };
+    exports.unstable_act = X;
+    exports.useCallback = function(a, b) {
+      return U.current.useCallback(a, b);
+    };
+    exports.useContext = function(a) {
+      return U.current.useContext(a);
+    };
+    exports.useDebugValue = function() {
+    };
+    exports.useDeferredValue = function(a) {
+      return U.current.useDeferredValue(a);
+    };
+    exports.useEffect = function(a, b) {
+      return U.current.useEffect(a, b);
+    };
+    exports.useId = function() {
+      return U.current.useId();
+    };
+    exports.useImperativeHandle = function(a, b, e2) {
+      return U.current.useImperativeHandle(a, b, e2);
+    };
+    exports.useInsertionEffect = function(a, b) {
+      return U.current.useInsertionEffect(a, b);
+    };
+    exports.useLayoutEffect = function(a, b) {
+      return U.current.useLayoutEffect(a, b);
+    };
+    exports.useMemo = function(a, b) {
+      return U.current.useMemo(a, b);
+    };
+    exports.useReducer = function(a, b, e2) {
+      return U.current.useReducer(a, b, e2);
+    };
+    exports.useRef = function(a) {
+      return U.current.useRef(a);
+    };
+    exports.useState = function(a) {
+      return U.current.useState(a);
+    };
+    exports.useSyncExternalStore = function(a, b, e2) {
+      return U.current.useSyncExternalStore(a, b, e2);
+    };
+    exports.useTransition = function() {
+      return U.current.useTransition();
+    };
+    exports.version = "18.3.1";
+  }
+});
+
+// ../../node_modules/react/index.js
+var require_react = __commonJS({
+  "../../node_modules/react/index.js"(exports, module) {
+    "use strict";
+    if (true) {
+      module.exports = require_react_production_min();
+    } else {
+      module.exports = null;
+    }
+  }
+});
+
+// ../../node_modules/@lit/react/create-component.js
+var e = /* @__PURE__ */ new Set(["children", "localName", "ref", "style", "className"]);
+var n = /* @__PURE__ */ new WeakMap();
+var t = (e2, t2, o2, l, a) => {
+  const s = a?.[t2];
+  void 0 === s ? (e2[t2] = o2, null == o2 && t2 in HTMLElement.prototype && e2.removeAttribute(t2)) : o2 !== l && ((e3, t3, o3) => {
+    let l2 = n.get(e3);
+    void 0 === l2 && n.set(e3, l2 = /* @__PURE__ */ new Map());
+    let a2 = l2.get(t3);
+    void 0 !== o3 ? void 0 === a2 ? (l2.set(t3, a2 = { handleEvent: o3 }), e3.addEventListener(t3, a2)) : a2.handleEvent = o3 : void 0 !== a2 && (l2.delete(t3), e3.removeEventListener(t3, a2));
+  })(e2, s, o2);
+};
+var o = ({ react: n2, tagName: o2, elementClass: l, events: a, displayName: s }) => {
+  const c = new Set(Object.keys(a ?? {})), r = n2.forwardRef(((s2, r2) => {
+    const i = n2.useRef(/* @__PURE__ */ new Map()), d = n2.useRef(null), f = {}, u = {};
+    for (const [n3, t2] of Object.entries(s2)) e.has(n3) ? f["className" === n3 ? "class" : n3] = t2 : c.has(n3) || n3 in l.prototype ? u[n3] = t2 : f[n3] = t2;
+    return n2.useLayoutEffect((() => {
+      if (null === d.current) return;
+      const e2 = /* @__PURE__ */ new Map();
+      for (const n3 in u) t(d.current, n3, s2[n3], i.current.get(n3), a), i.current.delete(n3), e2.set(n3, s2[n3]);
+      for (const [e3, n3] of i.current) t(d.current, e3, void 0, n3, a);
+      i.current = e2;
+    })), n2.useLayoutEffect((() => {
+      d.current?.removeAttribute("defer-hydration");
+    }), []), f.suppressHydrationWarning = true, n2.createElement(o2, { ...f, ref: n2.useCallback(((e2) => {
+      d.current = e2, "function" == typeof r2 ? r2(e2) : null !== r2 && (r2.current = e2);
+    }), [r2]) });
+  }));
+  return r.displayName = s ?? l.name, r;
+};
+
+export {
+  require_react,
+  o
+};
+/*! Bundled license information:
+
+react/cjs/react.production.min.js:
+  (**
+   * @license React
+   * react.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+@lit/react/create-component.js:
+  (**
+   * @license
+   * Copyright 2018 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/

package/dist/bundled/chunks/chunk.UQ2XZMRE.js

@@ -0,0 +1,13 @@
+/*! Cornerstone Components 0.6.2 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/events/tab-show.ts
+var CsTabShowEvent = class extends Event {
+  constructor(detail) {
+    super("cs-tab-show", { bubbles: true, cancelable: false, composed: true });
+    this.detail = detail;
+  }
+};
+
+export {
+  CsTabShowEvent
+};