@lostgradient/cinder 0.4.0 → 0.4.1

package/dist/server/index.server-g8kdhzf2.js

@@ -0,0 +1,146 @@
+// src/_internal/text-direction.ts
+function resolveTextDirection(element, fallback) {
+  let currentElement = element ?? null;
+  let documentDirection;
+  let styledDirectionElement = null;
+  while (currentElement) {
+    const direction = currentElement.getAttribute("dir")?.toLowerCase();
+    if (direction === "rtl" || direction === "ltr") {
+      if (typeof getComputedStyle === "function" && styledDirectionElement) {
+        const styledDirection2 = getComputedStyle(styledDirectionElement).direction;
+        if (styledDirection2 === "rtl" || styledDirection2 === "ltr")
+          return styledDirection2;
+      }
+      if (currentElement === currentElement.ownerDocument.documentElement) {
+        documentDirection = direction;
+        break;
+      }
+      return direction;
+    }
+    if (direction === "auto" && typeof getComputedStyle === "function") {
+      const computedDirection2 = getComputedStyle(currentElement).direction;
+      if (computedDirection2 === "rtl" || computedDirection2 === "ltr")
+        return computedDirection2;
+    }
+    const styledDirection = currentElement.style.direction;
+    if (!styledDirectionElement && (styledDirection === "rtl" || styledDirection === "ltr")) {
+      styledDirectionElement = currentElement;
+    }
+    currentElement = currentElement.parentElement;
+  }
+  if (typeof getComputedStyle === "function" && styledDirectionElement) {
+    const direction = getComputedStyle(styledDirectionElement).direction;
+    if (direction === "rtl" || direction === "ltr")
+      return direction;
+  }
+  const computedDirection = readComputedTextDirection(element);
+  const rootComputedDirection = readComputedTextDirection(element?.ownerDocument.documentElement);
+  if (computedDirection && computedDirection !== rootComputedDirection)
+    return computedDirection;
+  if (computedDirection && fallback && computedDirection !== fallback && hasDirectionStylingHint(element)) {
+    return computedDirection;
+  }
+  if (!fallback && computedDirection === "rtl")
+    return computedDirection;
+  if (fallback)
+    return fallback;
+  if (documentDirection)
+    return documentDirection;
+  return;
+}
+function readComputedTextDirection(element) {
+  if (!element || typeof getComputedStyle !== "function")
+    return;
+  const direction = getComputedStyle(element).direction;
+  return direction === "rtl" || direction === "ltr" ? direction : undefined;
+}
+function hasDirectionStylingHint(element) {
+  let currentElement = element?.parentElement;
+  while (currentElement && currentElement !== currentElement.ownerDocument.documentElement) {
+    if (currentElement.style.direction)
+      return true;
+    if (matchesDirectionStyleRule(currentElement))
+      return true;
+    currentElement = currentElement.parentElement;
+  }
+  return false;
+}
+function matchesDirectionStyleRule(element) {
+  for (const sheet of Array.from(element.ownerDocument.styleSheets)) {
+    let rules;
+    try {
+      rules = sheet.cssRules;
+    } catch {
+      continue;
+    }
+    if (matchesDirectionStyleRuleList(element, rules))
+      return true;
+  }
+  return false;
+}
+function matchesDirectionStyleRuleList(element, rules) {
+  for (const rule of Array.from(rules)) {
+    if (isCssStyleRule(rule)) {
+      if (!rule.style.direction) {
+        const nestedRules2 = readNestedCssRules(rule);
+        if (nestedRules2 && matchesDirectionStyleRuleList(element, nestedRules2))
+          return true;
+        continue;
+      }
+      try {
+        if (element.matches(rule.selectorText))
+          return true;
+      } catch {
+        continue;
+      }
+    }
+    const nestedRules = readNestedCssRules(rule);
+    if (nestedRules && isConditionalRuleActive(rule) && matchesDirectionStyleRuleList(element, nestedRules)) {
+      return true;
+    }
+  }
+  return false;
+}
+function readNestedCssRules(rule) {
+  if (!("cssRules" in rule))
+    return;
+  try {
+    const nestedRules = Reflect.get(rule, "cssRules");
+    return isCssRuleCollection(nestedRules) ? nestedRules : undefined;
+  } catch {
+    return;
+  }
+}
+function isCssRuleCollection(value) {
+  if (typeof CSSRuleList !== "undefined" && value instanceof CSSRuleList)
+    return true;
+  return Array.isArray(value) && value.every(isCssRule);
+}
+function isCssRule(value) {
+  return typeof value === "object" && value !== null && typeof Reflect.get(value, "cssText") === "string" && typeof Reflect.get(value, "type") === "number";
+}
+function isCssStyleRule(rule) {
+  return typeof Reflect.get(rule, "selectorText") === "string" && typeof Reflect.get(rule, "style") === "object" && Reflect.get(rule, "style") !== null;
+}
+function isConditionalRuleActive(rule) {
+  const conditionText = Reflect.get(rule, "conditionText");
+  if (typeof conditionText !== "string" || !conditionText.trim())
+    return true;
+  if (isMediaRule(rule) && typeof matchMedia === "function") {
+    return matchMedia(conditionText).matches;
+  }
+  if (isSupportsRule(rule) && typeof CSS !== "undefined" && typeof CSS.supports === "function") {
+    return CSS.supports(conditionText);
+  }
+  return true;
+}
+function isMediaRule(rule) {
+  return typeof Reflect.get(rule, "media") === "object" && Reflect.get(rule, "media") !== null;
+}
+function isSupportsRule(rule) {
+  return rule.constructor.name === "CSSSupportsRule" || Reflect.get(rule, "type") === 12;
+}
+
+export { resolveTextDirection };
+
+//# debugId=0392BA8AB37AAFB964756E2164756E21

package/dist/server/index.server-gae09raw.js

@@ -0,0 +1,75 @@
+import {
+  Floating_action_button
+} from "./index.server-q550gsbe.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/speed-dial-action/speed-dial-action.svelte
+import * as $ from "svelte/internal/server";
+
+// src/components/speed-dial/speed-dial.context.ts
+import { createContext } from "svelte";
+var [getSpeedDialContextStrict, setSpeedDialContext] = createContext();
+function getSpeedDialContext() {
+  try {
+    return getSpeedDialContextStrict();
+  } catch {
+    throw new Error("SpeedDial.Action must be rendered inside a SpeedDial parent.");
+  }
+}
+
+// src/components/speed-dial-action/speed-dial-action.svelte
+function Speed_dial_action($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const fallbackButtonId = $.props_id($$renderer2);
+    let {
+      id = fallbackButtonId,
+      label,
+      icon,
+      onclick,
+      disabled = false,
+      labelPlacement = "auto",
+      class: customClassName,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const context = getSpeedDialContext();
+    let rootElement = null;
+    function handleClick(event) {
+      if (disabled)
+        return;
+      onclick?.(event);
+      context.close({ focusTrigger: true });
+    }
+    $$renderer2.push(`<div${$.attr_class($.clsx(classNames("cinder-speed-dial-action", customClassName)))}${$.attr("data-cinder-label-placement", labelPlacement)}${$.attr("data-cinder-open", context.isOpen ? "" : undefined)}${$.attr("data-cinder-direction", context.direction)}>`);
+    Floating_action_button($$renderer2, $.spread_props([
+      rest,
+      {
+        id,
+        size: "sm",
+        "aria-label": label,
+        disabled,
+        onclick: handleClick,
+        children: ($$renderer3) => {
+          icon?.($$renderer3);
+          $$renderer3.push(`<!---->`);
+        },
+        $$slots: { default: true }
+      }
+    ]));
+    $$renderer2.push(`<!----> `);
+    if (labelPlacement !== "none") {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<label${$.attr("for", id)} class="cinder-speed-dial-action__label" aria-hidden="true">${$.escape(label)}</label>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+export { setSpeedDialContext, Speed_dial_action };
+
+//# debugId=EB10635737F2521864756E2164756E21

package/dist/server/index.server-gbzsb04q.js

@@ -0,0 +1,71 @@
+// src/utilities/use-announcer.svelte.ts
+import * as $ from "svelte/internal/server";
+function useAnnouncer(options) {
+  const { clearDelay = 1000, debounceMs = 0 } = options ?? {};
+  let message = "";
+  let debounceTimeout = null;
+  let setMessageTimeout = null;
+  let autoClearTimeout = null;
+  function setMessage(text) {
+    if (setMessageTimeout) {
+      globalThis.clearTimeout(setMessageTimeout);
+      setMessageTimeout = null;
+    }
+    if (autoClearTimeout) {
+      globalThis.clearTimeout(autoClearTimeout);
+      autoClearTimeout = null;
+    }
+    message = "";
+    setMessageTimeout = globalThis.setTimeout(() => {
+      setMessageTimeout = null;
+      message = text;
+      autoClearTimeout = globalThis.setTimeout(() => {
+        message = "";
+        autoClearTimeout = null;
+      }, clearDelay);
+    }, 0);
+  }
+  function announce(text) {
+    if (debounceMs > 0) {
+      if (debounceTimeout) {
+        globalThis.clearTimeout(debounceTimeout);
+      }
+      debounceTimeout = globalThis.setTimeout(() => {
+        debounceTimeout = null;
+        setMessage(text);
+      }, debounceMs);
+    } else {
+      setMessage(text);
+    }
+  }
+  function clear() {
+    if (debounceTimeout) {
+      globalThis.clearTimeout(debounceTimeout);
+      debounceTimeout = null;
+    }
+    if (setMessageTimeout) {
+      globalThis.clearTimeout(setMessageTimeout);
+      setMessageTimeout = null;
+    }
+    if (autoClearTimeout) {
+      globalThis.clearTimeout(autoClearTimeout);
+      autoClearTimeout = null;
+    }
+    message = "";
+  }
+  function destroy() {
+    clear();
+  }
+  return {
+    get message() {
+      return message;
+    },
+    announce,
+    clear,
+    destroy
+  };
+}
+
+export { useAnnouncer };
+
+//# debugId=A0FB74373019F9B964756E2164756E21

package/dist/server/index.server-ge07r1p8.js

@@ -0,0 +1,8 @@
+// ../../node_modules/esm-env/false.js
+var false_default = false;
+
+// ../../node_modules/esm-env/true.js
+var true_default = true;
+export { false_default, true_default };
+
+//# debugId=8D925CE476CFC24C64756E2164756E21

package/dist/server/index.server-ghvqpc50.js

@@ -0,0 +1,71 @@
+import {
+  useMutationObserver
+} from "./index.server-p045dgmk.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/button-group/button-group.svelte
+import * as $ from "svelte/internal/server";
+var groupIdCounter = 0;
+function Button_group($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      label,
+      labelledBy,
+      orientation = "horizontal",
+      class: customClassName,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const mergedClassName = $.derived(() => classNames("cinder-button-group", customClassName));
+    const ariaLabelAttribute = $.derived(() => typeof label === "string" ? label : undefined);
+    const ariaLabelledByAttribute = $.derived(() => typeof labelledBy === "string" ? labelledBy : undefined);
+    const groupId = String(++groupIdCounter);
+    const tagDirectChildren = (element) => {
+      const ATTR = "data-cinder-button-group-item";
+      const tagged = new Set;
+      const sync = () => {
+        const currentChildren = new Set(Array.from(element.children));
+        for (const child of currentChildren) {
+          child.setAttribute(ATTR, groupId);
+          tagged.add(child);
+        }
+        for (const previouslyTagged of Array.from(tagged)) {
+          if (!currentChildren.has(previouslyTagged)) {
+            if (previouslyTagged.getAttribute(ATTR) === groupId) {
+              previouslyTagged.removeAttribute(ATTR);
+            }
+            tagged.delete(previouslyTagged);
+          }
+        }
+      };
+      sync();
+      const detachObserver = useMutationObserver(sync, { childList: true })(element);
+      return () => {
+        detachObserver?.();
+        for (const child of Array.from(tagged)) {
+          if (child.getAttribute(ATTR) === groupId) {
+            child.removeAttribute(ATTR);
+          }
+        }
+      };
+    };
+    $$renderer2.push(`<div${$.attributes({
+      ...rest,
+      role: "group",
+      "aria-label": ariaLabelAttribute(),
+      "aria-labelledby": ariaLabelledByAttribute(),
+      class: $.clsx(mergedClassName()),
+      "data-cinder-orientation": orientation
+    })}>`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+  });
+}
+
+export { Button_group };
+
+//# debugId=DF273DA6204B71AE64756E2164756E21

package/dist/server/index.server-gj3eb1ce.js

@@ -0,0 +1,23 @@
+import {
+  Tabs
+} from "./index.server-n3zbnw3w.js";
+import {
+  Tab
+} from "./index.server-52fkd3c2.js";
+import {
+  Tab_list
+} from "./index.server-xpghbgpz.js";
+import {
+  Tab_panel
+} from "./index.server-8d3tttbj.js";
+
+// src/components/tabs/index.ts
+var Tabs2 = Object.assign(Tabs, {
+  List: Tab_list,
+  Trigger: Tab,
+  Panel: Tab_panel
+});
+var tabs_default = Tabs2;
+export { Tabs2 as Tabs, tabs_default };
+
+//# debugId=A6A54FA0575E549964756E2164756E21

package/dist/server/index.server-grb4gyta.js

@@ -0,0 +1,210 @@
+import {
+  heatmapCellFill,
+  heatmapDomainOfRows,
+  toFiniteOrNull
+} from "./index.server-d63pwytk.js";
+import {
+  useResizeObserver
+} from "./index.server-9w7qdn8h.js";
+import {
+  dataTableClass
+} from "./index.server-chj73na5.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/spectrogram/spectrogram.svelte
+import * as $ from "svelte/internal/server";
+function Spectrogram($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const generatedId = $.props_id($$renderer2);
+    let {
+      label,
+      description,
+      frames,
+      frequencyLabels,
+      height = 200,
+      loading = false,
+      dataTableVisibility = "screen-reader-only",
+      dataTableCaption,
+      class: customClassName,
+      empty,
+      loadingContent,
+      id,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const rootId = $.derived(() => id ?? generatedId);
+    const descriptionId = $.derived(() => description ? `${rootId()}-description` : undefined);
+    const marginTop = 8;
+    const marginRight = 16;
+    const marginBottom = 32;
+    const marginLeft = 60;
+    let measuredWidth = 400;
+    const observeResize = useResizeObserver((entries) => {
+      const entry = entries[0];
+      if (entry && entry.contentRect.width > 0)
+        measuredWidth = entry.contentRect.width;
+    });
+    const plotWidth = $.derived(() => Math.max(1, measuredWidth - marginLeft - marginRight));
+    const plotHeight = $.derived(() => Math.max(1, height - marginTop - marginBottom));
+    const binCount = $.derived(() => frames.reduce((max, frame) => Math.max(max, frame.bins.length), 0));
+    const binIndices = $.derived(() => Array.from({ length: binCount() }, (_, index) => index));
+    const isEmpty = $.derived(() => frames.length === 0 || binCount() === 0);
+    const cellWidth = $.derived(() => frames.length > 0 ? plotWidth() / frames.length : 0);
+    const cellHeight = $.derived(() => binCount() > 0 ? plotHeight() / binCount() : 0);
+    function binValueAt(frameIndex, binIndex) {
+      return toFiniteOrNull(frames[frameIndex]?.bins[binIndex]);
+    }
+    const domain = $.derived(() => heatmapDomainOfRows(frames.map((frame) => frame.bins)));
+    function cellFill(value) {
+      return heatmapCellFill(value, domain(), "sequential");
+    }
+    function binY(binIndex) {
+      return plotHeight() - (binIndex + 1) * cellHeight();
+    }
+    const yLabels = $.derived(() => Array.from({ length: binCount() }, (_, index) => frequencyLabels?.[index] ?? String(index)));
+    const maxYLabels = 8;
+    const yLabelStep = $.derived(() => Math.max(1, Math.ceil(binCount() / maxYLabels)));
+    const maxXLabels = 10;
+    const xLabelStep = $.derived(() => Math.max(1, Math.ceil(frames.length / maxXLabels)));
+    const hasDataTable = $.derived(() => dataTableVisibility !== "hidden");
+    const maxTableFrames = 10;
+    const maxTableBins = 10;
+    const tableFrameStep = $.derived(() => Math.max(1, Math.ceil(frames.length / maxTableFrames)));
+    const tableBinStep = $.derived(() => Math.max(1, Math.ceil(binCount() / maxTableBins)));
+    const tableFrames = $.derived(() => frames.map((frame, frameIndex) => ({ frame, frameIndex })).filter((_, index) => index % tableFrameStep() === 0).slice(0, maxTableFrames));
+    const tableBinIndices = $.derived(() => Array.from({ length: binCount() }, (_, index) => index).filter((index) => index % tableBinStep() === 0).slice(0, maxTableBins).reverse());
+    const isTruncated = $.derived(() => frames.length > maxTableFrames || binCount() > maxTableBins);
+    const tableCaption = $.derived(() => isTruncated() ? `${dataTableCaption ?? label} (showing ${tableFrames().length} of ${frames.length} frames, ${tableBinIndices().length} of ${binCount()} bins)` : dataTableCaption ?? label);
+    function formatValue(value) {
+      if (value === null)
+        return "—";
+      return new Intl.NumberFormat(undefined, { maximumFractionDigits: 3 }).format(value);
+    }
+    $$renderer2.push(`<figure${$.attributes({
+      ...rest,
+      id: rootId(),
+      class: $.clsx(classNames("cinder-spectrogram", customClassName)),
+      "aria-label": label,
+      "aria-describedby": descriptionId()
+    })}>`);
+    if (description) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$.attr("id", descriptionId())} class="cinder-spectrogram__description">${$.escape(description)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <div class="cinder-spectrogram__viewport"${$.attr("data-cinder-loading", loading || undefined)}${$.attr_style("", { height: `${$.stringify(height)}px` })}>`);
+    if (loading) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="cinder-spectrogram__state">`);
+      if (loadingContent) {
+        $$renderer2.push("<!--[0-->");
+        loadingContent($$renderer2);
+        $$renderer2.push(`<!---->`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        $$renderer2.push(`Loading…`);
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else if (isEmpty()) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`<div class="cinder-spectrogram__state">`);
+      if (empty) {
+        $$renderer2.push("<!--[0-->");
+        empty($$renderer2);
+        $$renderer2.push(`<!---->`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        $$renderer2.push(`No spectrogram data`);
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <svg role="img"${$.attr("viewBox", `0 0 ${measuredWidth} ${height}`)}${$.attr("aria-hidden", loading || isEmpty() ? "true" : undefined)}${$.attr("aria-labelledby", !loading && !isEmpty() ? `${rootId()}-svg-title` : undefined)}>`);
+    if (!loading && !isEmpty()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<title${$.attr("id", `${$.stringify(rootId())}-svg-title`)}>${$.escape(label)}</title>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+    if (!loading && !isEmpty()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<g${$.attr("transform", `translate(${marginLeft}, ${marginTop})`)}><!--[-->`);
+      const each_array = $.ensure_array_like(frames);
+      for (let frameIndex = 0, $$length = each_array.length;frameIndex < $$length; frameIndex++) {
+        let _frame = each_array[frameIndex];
+        $$renderer2.push(`<!--[-->`);
+        const each_array_1 = $.ensure_array_like(binIndices());
+        for (let $$index = 0, $$length2 = each_array_1.length;$$index < $$length2; $$index++) {
+          let binIndex = each_array_1[$$index];
+          $$renderer2.push(`<rect class="cinder-spectrogram__cell"${$.attr("x", frameIndex * cellWidth())}${$.attr("y", binY(binIndex))}${$.attr("width", cellWidth())}${$.attr("height", cellHeight())}${$.attr("fill", cellFill(binValueAt(frameIndex, binIndex)))} aria-hidden="true"></rect>`);
+        }
+        $$renderer2.push(`<!--]-->`);
+      }
+      $$renderer2.push(`<!--]--><!--[-->`);
+      const each_array_2 = $.ensure_array_like(yLabels());
+      for (let index = 0, $$length = each_array_2.length;index < $$length; index++) {
+        let yLabel = each_array_2[index];
+        if (index % yLabelStep() === 0) {
+          $$renderer2.push("<!--[0-->");
+          $$renderer2.push(`<text class="cinder-spectrogram__tick-label"${$.attr("x", -6)}${$.attr("y", binY(index) + cellHeight() / 2)} text-anchor="end" dominant-baseline="middle">${$.escape(yLabel)}</text>`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]-->`);
+      }
+      $$renderer2.push(`<!--]--><!--[-->`);
+      const each_array_3 = $.ensure_array_like(frames);
+      for (let index = 0, $$length = each_array_3.length;index < $$length; index++) {
+        let frame = each_array_3[index];
+        if (index % xLabelStep() === 0) {
+          $$renderer2.push("<!--[0-->");
+          $$renderer2.push(`<text class="cinder-spectrogram__tick-label"${$.attr("x", index * cellWidth() + cellWidth() / 2)}${$.attr("y", plotHeight() + 16)} text-anchor="middle" dominant-baseline="auto">${$.escape(frame.label)}</text>`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]-->`);
+      }
+      $$renderer2.push(`<!--]--></g>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></svg></div> `);
+    if (hasDataTable()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<table${$.attr_class($.clsx(dataTableClass(dataTableVisibility)))}><caption>${$.escape(tableCaption())}</caption><thead><tr><th scope="col">Frequency bin</th><!--[-->`);
+      const each_array_4 = $.ensure_array_like(tableFrames());
+      for (let $$index_4 = 0, $$length = each_array_4.length;$$index_4 < $$length; $$index_4++) {
+        let entry = each_array_4[$$index_4];
+        $$renderer2.push(`<th scope="col">${$.escape(entry.frame.label)}</th>`);
+      }
+      $$renderer2.push(`<!--]--></tr></thead><tbody><!--[-->`);
+      const each_array_5 = $.ensure_array_like(tableBinIndices());
+      for (let $$index_6 = 0, $$length = each_array_5.length;$$index_6 < $$length; $$index_6++) {
+        let binIndex = each_array_5[$$index_6];
+        $$renderer2.push(`<tr><th scope="row">${$.escape(yLabels()[binIndex] ?? binIndex)}</th><!--[-->`);
+        const each_array_6 = $.ensure_array_like(tableFrames());
+        for (let $$index_5 = 0, $$length2 = each_array_6.length;$$index_5 < $$length2; $$index_5++) {
+          let entry = each_array_6[$$index_5];
+          $$renderer2.push(`<td>${$.escape(formatValue(binValueAt(entry.frameIndex, binIndex)))}</td>`);
+        }
+        $$renderer2.push(`<!--]--></tr>`);
+      }
+      $$renderer2.push(`<!--]--></tbody></table>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></figure>`);
+  });
+}
+
+// src/components/spectrogram/index.ts
+var spectrogram_default = Spectrogram;
+export { Spectrogram, spectrogram_default };
+
+//# debugId=A35D5BC693584D8664756E2164756E21