@cutoff/audio-ui-core 1.0.0-preview.20260123.1125

package/dist/index.js

@@ -0,0 +1,1404 @@
+var N = Object.defineProperty;
+var z = (i, t, e) => t in i ? N(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var l = (i, t, e) => z(i, typeof t != "symbol" ? t + "" : t, e);
+import T from "fast-deep-equal";
+const W = {
+  /** Root class applied to all AudioUI components */
+  root: "audioui",
+  /** Container helper class for components that manage their own SVG sizing */
+  container: "audioui-component-container",
+  /** Highlight class used for interactive states */
+  highlight: "audioui-highlight",
+  /** Icon wrapper class for HTML overlay - ensures SVG icons fill their container */
+  iconWrapper: "audioui-icon-wrapper"
+}, J = {
+  /** Default adaptive color (white in dark mode, black in light mode) */
+  default: "var(--audioui-theme-default)",
+  /** Blue theme color */
+  blue: "var(--audioui-theme-blue)",
+  /** Orange theme color */
+  orange: "var(--audioui-theme-orange)",
+  /** Pink theme color */
+  pink: "var(--audioui-theme-pink)",
+  /** Green theme color */
+  green: "var(--audioui-theme-green)",
+  /** Purple theme color */
+  purple: "var(--audioui-theme-purple)",
+  /** Yellow theme color */
+  yellow: "var(--audioui-theme-yellow)"
+}, Q = {
+  default: {
+    light: "hsl(0, 0%, 10%)",
+    dark: "hsl(0, 0%, 96%)"
+  },
+  blue: {
+    light: "hsl(204, 88%, 52%)",
+    dark: "hsl(204, 88%, 53%)"
+  },
+  orange: {
+    light: "hsl(29, 100%, 48%)",
+    dark: "hsl(29, 100%, 50%)"
+  },
+  pink: {
+    light: "hsl(332, 92%, 52%)",
+    dark: "hsl(332, 95%, 54%)"
+  },
+  green: {
+    light: "hsl(160, 95%, 44%)",
+    dark: "hsl(160, 98%, 37%)"
+  },
+  purple: {
+    light: "hsl(252, 96%, 54%)",
+    dark: "hsl(252, 100%, 67%)"
+  },
+  yellow: {
+    light: "hsl(50, 100%, 50%)",
+    dark: "hsl(50, 100%, 50%)"
+  }
+}, tt = 0.3, et = 0.4, P = {
+  // Theming parameters
+  roundnessBase: "--audioui-roundness-base",
+  primaryColor: "--audioui-primary-color",
+  adaptiveDefaultColor: "--audioui-adaptive-default-color",
+  adaptive50: "--audioui-adaptive-50",
+  adaptive20: "--audioui-adaptive-20",
+  adaptiveLight: "--audioui-adaptive-light",
+  adaptiveDark: "--audioui-adaptive-dark",
+  primary50: "--audioui-primary-50",
+  primary20: "--audioui-primary-20",
+  primaryLight: "--audioui-primary-light",
+  primaryDark: "--audioui-primary-dark",
+  // Text and typography
+  textColor: "--audioui-text-color",
+  defaultFontSize: "--audioui-default-font-size",
+  // Interactive highlight
+  highlightEffect: "--audioui-highlight-effect",
+  highlightTransitionDuration: "--audioui-highlight-transition-duration",
+  // Cursor styles
+  cursorClickable: "--audioui-cursor-clickable",
+  cursorBidirectional: "--audioui-cursor-bidirectional",
+  cursorHorizontal: "--audioui-cursor-horizontal",
+  cursorVertical: "--audioui-cursor-vertical",
+  cursorCircular: "--audioui-cursor-circular",
+  cursorNoneditable: "--audioui-cursor-noneditable",
+  cursorDisabled: "--audioui-cursor-disabled",
+  // Keys colors
+  keysIvory: "--audioui-keys-ivory",
+  keysIvoryStroke: "--audioui-keys-ivory-stroke",
+  keysEbony: "--audioui-keys-ebony",
+  keysEbonyStroke: "--audioui-keys-ebony-stroke",
+  // Component style customization
+  knobCapFill: "--audioui-knob-cap-fill",
+  buttonStrokeWidth: "--audioui-button-stroke-width",
+  // Slider component colors
+  sliderTrackColor: "--audioui-slider-track-color",
+  sliderStripColor: "--audioui-slider-strip-color",
+  sliderCursorColor: "--audioui-slider-cursor-color",
+  sliderCursorBorderColor: "--audioui-slider-cursor-border-color",
+  sliderCursorBorderWidth: "--audioui-slider-cursor-border-width"
+}, it = "url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48Y2lyY2xlIGN4PSIxNiIgY3k9IjE2IiByPSIxMCIgc3Ryb2tlPSJ3aGl0ZSIgc3Ryb2tlLXdpZHRoPSI0Ii8+PGNpcmNsZSBjeD0iMTYiIGN5PSIxNiIgcj0iMTAiIHN0cm9rZT0iYmxhY2siIHN0cm9rZS13aWR0aD0iMiIvPjwvc3ZnPg==') 16 16, move", L = 5e-3, $ = 5e-3, ot = 30, R = 0.05;
+class nt {
+  constructor(t) {
+    l(this, "config");
+    l(this, "startX", 0);
+    l(this, "startY", 0);
+    l(this, "centerX", 0);
+    l(this, "centerY", 0);
+    l(this, "isDragging", !1);
+    l(this, "wheelAccumulator", 0);
+    l(this, "dragAccumulator", 0);
+    /**
+     * Handles the start of a mouse drag interaction.
+     * Should be called from the component's onMouseDown handler.
+     * @param clientX The X coordinate of the mouse event.
+     * @param clientY The Y coordinate of the mouse event.
+     * @param target The event target (used for circular center calculation).
+     */
+    l(this, "handleMouseDown", (t, e, o) => {
+      this.config.interactionMode !== "wheel" && this.startDrag(t, e, o);
+    });
+    /**
+     * Handles the start of a touch interaction.
+     * Should be called from the component's onTouchStart handler.
+     * @param clientX The X coordinate of the touch event.
+     * @param clientY The Y coordinate of the touch event.
+     * @param target The event target.
+     */
+    l(this, "handleTouchStart", (t, e, o) => {
+      this.config.interactionMode !== "wheel" && this.startDrag(t, e, o);
+    });
+    /**
+     * Handles wheel events.
+     * Should be called from the component's onWheel handler.
+     * @param e The wheel event.
+     */
+    l(this, "handleWheel", (t) => {
+      if (this.config.disabled || this.config.interactionMode !== "wheel" && this.config.interactionMode !== "both") return;
+      t.preventDefault && t.preventDefault(), t.stopPropagation && t.stopPropagation();
+      const e = t.deltaY, o = this.config.wheelSensitivity ?? $;
+      if (this.config.step) {
+        if (this.wheelAccumulator += e * o, Math.abs(this.wheelAccumulator) >= this.config.step) {
+          const n = Math.trunc(this.wheelAccumulator / this.config.step);
+          this.config.adjustValue(n * this.config.step, 1), this.wheelAccumulator -= n * this.config.step;
+        }
+      } else
+        this.config.adjustValue(e, o);
+    });
+    /**
+     * Handles keyboard events (Arrow keys, Home, End).
+     * Should be called from the component's onKeyDown handler.
+     * @param e The keyboard event.
+     */
+    l(this, "handleKeyDown", (t) => {
+      if (this.config.disabled) return;
+      let e = 0;
+      switch (t.key) {
+        case "ArrowUp":
+        case "ArrowRight":
+          e = 1;
+          break;
+        case "ArrowDown":
+        case "ArrowLeft":
+          e = -1;
+          break;
+        case "Home":
+          e = -1 / this.config.sensitivity;
+          break;
+        case "End":
+          e = 1 / this.config.sensitivity;
+          break;
+        default:
+          return;
+      }
+      t.preventDefault();
+      const o = e * (this.config.keyboardStep / this.config.sensitivity);
+      this.config.adjustValue(o, this.config.sensitivity);
+    });
+    this.config = {
+      interactionMode: "both",
+      direction: "both",
+      sensitivity: L,
+      keyboardStep: R,
+      disabled: !1,
+      // adjustValue is provided in config
+      ...t
+    }, this.handleGlobalMouseMove = this.handleGlobalMouseMove.bind(this), this.handleGlobalMouseUp = this.handleGlobalMouseUp.bind(this), this.handleGlobalTouchMove = this.handleGlobalTouchMove.bind(this);
+  }
+  /**
+   * Updates the configuration of the controller.
+   * @param config Partial configuration to update.
+   */
+  updateConfig(t) {
+    Object.assign(this.config, t);
+  }
+  startDrag(t, e, o) {
+    if (this.config.disabled) return;
+    if (this.startX = t, this.startY = e, this.isDragging = !0, this.dragAccumulator = 0, this.config.onDragStart?.(), this.config.direction === "circular" && o && o.getBoundingClientRect) {
+      const s = o.getBoundingClientRect();
+      this.centerX = s.left + s.width / 2, this.centerY = s.top + s.height / 2;
+    }
+    document.body.style.userSelect = "none";
+    let n = "var(--audioui-cursor-vertical)";
+    this.config.direction === "horizontal" && (n = "var(--audioui-cursor-horizontal)"), this.config.direction === "both" && (n = "var(--audioui-cursor-bidirectional)"), this.config.direction === "circular" && (n = "var(--audioui-cursor-circular)"), document.body.style.cursor = n, window.addEventListener("mousemove", this.handleGlobalMouseMove), window.addEventListener("mouseup", this.handleGlobalMouseUp), window.addEventListener("touchmove", this.handleGlobalTouchMove, { passive: !1 }), window.addEventListener("touchend", this.handleGlobalMouseUp);
+  }
+  handleGlobalMouseMove(t) {
+    this.isDragging && (t.preventDefault(), this.processDrag(t.clientX, t.clientY));
+  }
+  handleGlobalTouchMove(t) {
+    if (!this.isDragging) return;
+    t.preventDefault();
+    const e = t.touches[0];
+    this.processDrag(e.clientX, e.clientY);
+  }
+  processDrag(t, e) {
+    let o = 0;
+    if (this.config.direction === "vertical")
+      o = this.startY - e;
+    else if (this.config.direction === "horizontal")
+      o = t - this.startX;
+    else if (this.config.direction === "both")
+      o = t - this.startX + (this.startY - e);
+    else if (this.config.direction === "circular") {
+      const n = Math.atan2(e - this.centerY, t - this.centerX), s = Math.atan2(this.startY - this.centerY, this.startX - this.centerX);
+      let r = n - s;
+      r > Math.PI ? r -= 2 * Math.PI : r < -Math.PI && (r += 2 * Math.PI), o = r * (180 / Math.PI);
+    }
+    if (o !== 0) {
+      const n = o * this.config.sensitivity;
+      if (this.config.step) {
+        if (this.dragAccumulator += n, Math.abs(this.dragAccumulator) >= this.config.step) {
+          const r = Math.trunc(this.dragAccumulator / this.config.step) * this.config.step;
+          this.config.adjustValue(r, 1), this.dragAccumulator -= r;
+        }
+      } else
+        this.config.adjustValue(o, this.config.sensitivity);
+      this.startX = t, this.startY = e;
+    }
+  }
+  /**
+   * Handles global mouse up event to end drag.
+   */
+  handleGlobalMouseUp() {
+    this.isDragging && (this.isDragging = !1, this.config.onDragEnd?.(), document.body.style.userSelect = "", document.body.style.cursor = "", window.removeEventListener("mousemove", this.handleGlobalMouseMove), window.removeEventListener("mouseup", this.handleGlobalMouseUp), window.removeEventListener("touchmove", this.handleGlobalTouchMove), window.removeEventListener("touchend", this.handleGlobalMouseUp));
+  }
+  /**
+   * Cleans up event listeners.
+   */
+  dispose() {
+    this.handleGlobalMouseUp();
+  }
+}
+class st {
+  constructor(t) {
+    /**
+     * Handles click events.
+     * Cycles to the next value if the event was not already prevented (e.g. by a drag).
+     * @param defaultPrevented Whether the event's default action has been prevented.
+     */
+    l(this, "handleClick", (t) => {
+      this.config.disabled || t || this.cycleNext();
+    });
+    /**
+     * Handles keyboard events for discrete controls.
+     * Returns true if the event was handled (and thus should be prevented), false otherwise.
+     */
+    l(this, "handleKeyDown", (t) => {
+      if (this.config.disabled) return !1;
+      switch (t) {
+        case " ":
+        case "Enter":
+          return this.cycleNext(), !0;
+        case "ArrowUp":
+        case "ArrowRight":
+          return this.stepNext(), !0;
+        case "ArrowDown":
+        case "ArrowLeft":
+          return this.stepPrev(), !0;
+      }
+      return !1;
+    });
+    this.config = t;
+  }
+  /**
+   * Updates the configuration.
+   * @param config New configuration object.
+   */
+  updateConfig(t) {
+    this.config = t;
+  }
+  getCurrentIndex() {
+    const t = this.config.options.findIndex((e) => e.value === this.config.value);
+    return t === -1 ? 0 : t;
+  }
+  setValueAtIndex(t) {
+    if (this.config.disabled) return;
+    const e = this.config.options[t];
+    e && this.config.onValueChange(e.value);
+  }
+  /**
+   * Cycles to the next value, wrapping around to the start if needed.
+   */
+  cycleNext() {
+    if (this.config.options.length <= 1) return;
+    const e = (this.getCurrentIndex() + 1) % this.config.options.length;
+    this.setValueAtIndex(e);
+  }
+  /**
+   * Steps to the next value, clamping at the end.
+   */
+  stepNext() {
+    if (this.config.options.length <= 1) return;
+    const t = this.getCurrentIndex();
+    t < this.config.options.length - 1 && this.setValueAtIndex(t + 1);
+  }
+  /**
+   * Steps to the previous value, clamping at the start.
+   */
+  stepPrev() {
+    if (this.config.options.length <= 1) return;
+    const t = this.getCurrentIndex();
+    t > 0 && this.setValueAtIndex(t - 1);
+  }
+}
+class rt {
+  constructor(t) {
+    l(this, "isPressed", !1);
+    l(this, "isGlobalPointerDown", !1);
+    /**
+     * Handles global pointer down events (mouse or touch).
+     *
+     * This tracks when a pointer is pressed anywhere on the page, not just on this button.
+     * This allows the button to respond to drag-in behavior even when the press starts outside.
+     *
+     * @param {boolean} defaultPrevented - Whether the event's default action has been prevented. If true, the handler does nothing.
+     */
+    l(this, "handleGlobalPointerDown", (t) => {
+      this.config.disabled || t || (this.isGlobalPointerDown = !0);
+    });
+    /**
+     * Handles mouse down events on the button element.
+     *
+     * Behavior depends on interaction mode:
+     * - **Toggle mode**: Flips the current value (true ↔ false)
+     * - **Momentary mode**: Sets value to true and tracks press state for later release
+     *
+     * @param {boolean} defaultPrevented - Whether the event's default action has been prevented. If true, the handler does nothing.
+     */
+    l(this, "handleMouseDown", (t) => {
+      this.config.disabled || t || (this.isGlobalPointerDown = !0, this.config.mode === "toggle" ? this.config.onValueChange(!this.config.value) : (this.isPressed = !0, this.config.onValueChange(!0)));
+    });
+    /**
+     * Handles mouse up events on the button element.
+     *
+     * For momentary mode: Sets value to false if the button is currently pressed.
+     * This prevents false releases if the button wasn't actually pressed.
+     * Toggle mode: No action (toggle happens on mousedown only).
+     *
+     * Note: This is called when mouse is released on the button. The global pointer up
+     * handler will also be called to reset global state.
+     *
+     * @param {boolean} defaultPrevented - Whether the event's default action has been prevented. If true, the handler does nothing.
+     */
+    l(this, "handleMouseUp", (t) => {
+      this.config.disabled || t || this.config.mode === "momentary" && this.isPressed && (this.isPressed = !1, this.config.onValueChange(!1));
+    });
+    /**
+     * Handles global pointer up events (mouse or touch).
+     *
+     * This method is called when a pointer up event occurs anywhere on the page.
+     * It resets the global pointer state and handles release for momentary buttons.
+     *
+     * Only affects momentary mode buttons that are currently pressed.
+     */
+    l(this, "handleGlobalPointerUp", () => {
+      this.config.disabled || (this.isGlobalPointerDown = !1, this.config.mode === "momentary" && this.isPressed && (this.isPressed = !1, this.config.onValueChange(!1)));
+    });
+    /**
+     * Handles mouse enter events (pointer enters the button element).
+     *
+     * When a pointer enters the button while globally pressed:
+     * - **Momentary mode**: Sets value to true
+     * - **Toggle mode**: Toggles the value
+     *
+     * This enables drag-in behavior: pressing outside and dragging into the button activates it.
+     */
+    l(this, "handleMouseEnter", () => {
+      this.config.disabled || this.isGlobalPointerDown && (this.config.mode === "toggle" ? this.config.onValueChange(!this.config.value) : (this.isPressed = !0, this.config.onValueChange(!0)));
+    });
+    /**
+     * Handles mouse leave events (pointer leaves the button element).
+     *
+     * When a pointer leaves the button while globally pressed:
+     * - **Momentary mode**: Sets value to false
+     * - **Toggle mode**: No action (state remains as-is)
+     *
+     * This enables drag-out behavior: pressing inside and dragging out deactivates momentary buttons.
+     */
+    l(this, "handleMouseLeave", () => {
+      this.config.disabled || this.isGlobalPointerDown && this.config.mode === "momentary" && this.isPressed && (this.isPressed = !1, this.config.onValueChange(!1));
+    });
+    /**
+     * Handles keyboard key down events.
+     *
+     * Supported keys:
+     * - `Enter` or `Space`: Activates the button
+     *   - Toggle mode: Flips the value
+     *   - Momentary mode: Sets value to true
+     *
+     * @param {string} key - The keyboard key that was pressed
+     * @returns {boolean} `true` if the event was handled (and should be prevented), `false` otherwise
+     */
+    l(this, "handleKeyDown", (t) => this.config.disabled ? !1 : t === "Enter" || t === " " ? (this.config.mode === "toggle" ? this.config.onValueChange(!this.config.value) : this.config.onValueChange(!0), !0) : !1);
+    /**
+     * Handles keyboard key up events.
+     *
+     * Supported keys (momentary mode only):
+     * - `Enter` or `Space`: Releases the button (sets value to false)
+     *
+     * Toggle mode: No action (toggle happens on keydown only).
+     *
+     * @param {string} key - The keyboard key that was released
+     * @returns {boolean} `true` if the event was handled (and should be prevented), `false` otherwise
+     */
+    l(this, "handleKeyUp", (t) => this.config.disabled ? !1 : this.config.mode === "momentary" && (t === "Enter" || t === " ") ? (this.config.onValueChange(!1), !0) : !1);
+    this.config = t;
+  }
+  /**
+   * Updates the controller configuration.
+   *
+   * This method should be called whenever the configuration changes (e.g., value, mode, disabled state).
+   * The controller will use the new configuration for all subsequent interactions.
+   *
+   * @param {BooleanInteractionConfig} config - New configuration object
+   */
+  updateConfig(t) {
+    this.config = t;
+  }
+  /**
+   * Gets the current press state (for momentary buttons).
+   *
+   * This is primarily used for internal state tracking. External code typically
+   * doesn't need to check this, as the value reflects the button state.
+   *
+   * @returns {boolean} `true` if the button is currently pressed, `false` otherwise
+   */
+  getIsPressed() {
+    return this.isPressed;
+  }
+}
+class at {
+  /**
+   * Creates a new NoteInteractionController.
+   * @param config Initial configuration
+   */
+  constructor(t) {
+    l(this, "pointerNotes", /* @__PURE__ */ new Map());
+    this.config = t;
+  }
+  /**
+   * Updates the controller configuration.
+   * @param config New configuration object
+   */
+  updateConfig(t) {
+    this.config = t;
+  }
+  /**
+   * Handles the start of a pointer interaction (down).
+   *
+   * Tracks the pointer state globally and triggers onNoteOn if the pointer
+   * is over a specific note.
+   *
+   * @param pointerId Unique identifier for the pointer
+   * @param note The MIDI note number at the pointer location, or null if none
+   */
+  handlePointerDown(t, e) {
+    this.config.disabled || (this.handlePointerUp(t), this.pointerNotes.set(t, e), e !== null && this.config.onNoteOn(e, t));
+  }
+  /**
+   * Handles pointer movement (move).
+   *
+   * Enables glissando behavior by detecting when a tracked pointer moves
+   * from one note to another.
+   *
+   * @param pointerId Unique identifier for the pointer
+   * @param note The MIDI note number at the current pointer location, or null if none
+   */
+  handlePointerMove(t, e) {
+    if (this.config.disabled || !this.pointerNotes.has(t)) return;
+    const o = this.pointerNotes.get(t);
+    e !== o && (o != null && this.config.onNoteOff(o, t), this.pointerNotes.set(t, e), e !== null && this.config.onNoteOn(e, t));
+  }
+  /**
+   * Handles the end of a pointer interaction (up).
+   *
+   * Releases any active note associated with the pointer and removes it
+   * from the tracking map.
+   *
+   * @param pointerId Unique identifier for the pointer
+   */
+  handlePointerUp(t) {
+    const e = this.pointerNotes.get(t);
+    e !== void 0 && (e !== null && this.config.onNoteOff(e, t), this.pointerNotes.delete(t));
+  }
+  /**
+   * Cancels all active pointer interactions.
+   * Useful when the component is unmounted or focus is lost.
+   */
+  cancelAll() {
+    this.pointerNotes.forEach((t, e) => {
+      t !== null && this.config.onNoteOff(t, e);
+    }), this.pointerNotes.clear();
+  }
+}
+const v = {
+  forward: (i) => i,
+  inverse: (i) => i,
+  name: "linear"
+}, F = {
+  forward: (i) => i <= 0 ? 0 : i >= 1 ? 1 : Math.log(i * (Math.E - 1) + 1) / Math.log(Math.E),
+  inverse: (i) => i <= 0 ? 0 : i >= 1 ? 1 : (Math.pow(Math.E, i) - 1) / (Math.E - 1),
+  name: "log"
+}, V = {
+  forward: (i) => i <= 0 ? 0 : i >= 1 ? 1 : (Math.pow(Math.E, i) - 1) / (Math.E - 1),
+  inverse: (i) => i <= 0 ? 0 : i >= 1 ? 1 : Math.log(i * (Math.E - 1) + 1) / Math.log(Math.E),
+  name: "exp"
+};
+class lt {
+  constructor(t) {
+    l(this, "maxMidi");
+    l(this, "scaleFunction", null);
+    this.config = t;
+    const e = t.midiResolution ?? 32;
+    if (this.maxMidi = Math.pow(2, e) - 1, t.type === "continuous") {
+      const o = t.scale;
+      this.scaleFunction = this.resolveScale(o);
+    }
+  }
+  resolveScale(t) {
+    if (!t) return v;
+    if (typeof t == "string")
+      switch (t) {
+        case "linear":
+          return v;
+        case "log":
+          return F;
+        case "exp":
+          return V;
+        default:
+          return v;
+      }
+    return t;
+  }
+  /**
+   * [Internal] Pure math normalization from Real to 0..1.
+   *
+   * This is the first step in the conversion pipeline. It normalizes the real value
+   * to 0..1 in the real domain, then applies scale transformation (if not linear).
+   * The scale transformation happens in the normalized domain to create non-linear
+   * mappings (e.g., logarithmic for volume, exponential for envelope curves).
+   */
+  _normalizeReal(t) {
+    switch (this.config.type) {
+      case "continuous": {
+        const e = this.config, n = Math.max(0, Math.min(1, (t - e.min) / (e.max - e.min)));
+        return this.scaleFunction && this.scaleFunction !== v ? this.scaleFunction.forward(n) : n;
+      }
+      case "boolean":
+        return t ? 1 : 0;
+      case "discrete": {
+        const e = this.config, o = e.options.findIndex((s) => s.value === t);
+        if (o === -1) return 0;
+        const n = e.options.length;
+        return n > 1 ? o / (n - 1) : 0;
+      }
+    }
+  }
+  /**
+   * [Internal] Pure math denormalization from 0..1 to Real.
+   *
+   * This is the inverse of `_normalizeReal()`. It first applies the inverse scale
+   * transformation (if not linear), then denormalizes to the real value domain.
+   * Finally, it applies step quantization in the real domain (step is always linear,
+   * regardless of scale type).
+   */
+  _denormalizeReal(t) {
+    const e = Math.max(0, Math.min(1, t));
+    switch (this.config.type) {
+      case "continuous": {
+        const o = this.config;
+        let n = e;
+        this.scaleFunction && this.scaleFunction !== v && (n = this.scaleFunction.inverse(e));
+        let s = o.min + n * (o.max - o.min);
+        if (o.step) {
+          const r = Math.round((s - o.min) / o.step);
+          s = o.min + r * o.step, s = Math.round(s * 1e10) / 1e10;
+        }
+        return Math.max(o.min, Math.min(o.max, s));
+      }
+      case "boolean":
+        return e >= 0.5;
+      case "discrete": {
+        const o = this.config, n = o.options.length;
+        if (n === 0) return 0;
+        const s = Math.round(e * (n - 1));
+        return o.options[s].value;
+      }
+    }
+  }
+  /**
+   * Convert Real Value to MIDI Integer (The Pivot).
+   *
+   * This is the central conversion method that quantizes real-world values to MIDI integers.
+   * The MIDI integer serves as the source of truth, ensuring deterministic behavior and
+   * alignment with hardware standards.
+   *
+   * The conversion flow:
+   * 1. Normalize the real value to 0..1 (applying scale transformation if needed)
+   * 2. Quantize to the configured MIDI resolution (7-bit = 0-127, 14-bit = 0-16383, etc.)
+   *
+   * @param realValue The real-world value (number, boolean, or string depending on parameter type)
+   * @returns The quantized MIDI integer value
+   *
+   * @example
+   * ```ts
+   * const converter = new AudioParameterConverter({
+   *   type: "continuous",
+   *   min: 0,
+   *   max: 100,
+   *   midiResolution: 7
+   * });
+   * converter.toMidi(50); // 64 (50% of 0-100 maps to 64 in 0-127 range)
+   * ```
+   */
+  toMidi(t) {
+    switch (this.config.type) {
+      case "continuous": {
+        const e = this._normalizeReal(t);
+        return Math.round(e * this.maxMidi);
+      }
+      case "boolean":
+        return t ? this.maxMidi : 0;
+      case "discrete": {
+        const e = this.config, o = e.midiMapping ?? "spread";
+        if (o === "custom") {
+          const s = e.options.find((r) => r.value === t);
+          if (s?.midiValue !== void 0) return s.midiValue;
+        }
+        if (o === "sequential") {
+          const s = e.options.findIndex((r) => r.value === t);
+          return s === -1 ? 0 : s;
+        }
+        const n = this._normalizeReal(t);
+        return Math.round(n * this.maxMidi);
+      }
+    }
+  }
+  /**
+   * Convert MIDI Integer to Real Value.
+   *
+   * This method performs the inverse of `toMidi()`, converting a quantized MIDI integer
+   * back to a real-world value. The conversion flow:
+   * 1. Normalize the MIDI integer to 0..1
+   * 2. Apply inverse scale transformation (if not linear)
+   * 3. Denormalize to the real value domain
+   * 4. Apply step quantization (if configured)
+   *
+   * @param midiValue The MIDI integer value (will be clamped to valid range)
+   * @returns The real-world value (number, boolean, or string depending on parameter type)
+   *
+   * @example
+   * ```ts
+   * const converter = new AudioParameterConverter({
+   *   type: "continuous",
+   *   min: 0,
+   *   max: 100,
+   *   step: 1,
+   *   midiResolution: 7
+   * });
+   * converter.fromMidi(64); // 50 (64/127 ≈ 0.5, maps to 50 in 0-100 range)
+   * ```
+   */
+  fromMidi(t) {
+    const e = Math.max(0, Math.min(this.maxMidi, t));
+    switch (this.config.type) {
+      case "continuous": {
+        const o = e / this.maxMidi;
+        return this._denormalizeReal(o);
+      }
+      case "boolean": {
+        const o = this.maxMidi / 2;
+        return e >= o;
+      }
+      case "discrete": {
+        const o = this.config, n = o.midiMapping ?? "spread";
+        if (n === "custom") {
+          let r = o.options[0], c = 1 / 0;
+          for (const a of o.options)
+            if (a.midiValue !== void 0) {
+              const u = Math.abs(a.midiValue - e);
+              u < c && (c = u, r = a);
+            }
+          return r.value;
+        }
+        if (n === "sequential") {
+          const r = e;
+          return r >= 0 && r < o.options.length ? o.options[r].value : o.options[o.options.length - 1]?.value ?? 0;
+        }
+        const s = e / this.maxMidi;
+        return this._denormalizeReal(s);
+      }
+    }
+  }
+  normalize(t) {
+    return this.toMidi(t) / this.maxMidi;
+  }
+  denormalize(t) {
+    const e = Math.round(t * this.maxMidi);
+    return this.fromMidi(e);
+  }
+  /**
+   * Format a value for display as a string.
+   *
+   * This method generates a human-readable string representation of the value,
+   * including appropriate units and precision based on the parameter configuration.
+   *
+   * - Continuous parameters: Includes unit suffix and precision based on step size
+   * - Boolean parameters: Uses trueLabel/falseLabel or defaults to "On"/"Off"
+   * - Discrete parameters: Returns the label of the matching option
+   *
+   * @param value The value to format (number, boolean, or string)
+   * @returns Formatted string representation
+   *
+   * @example
+   * ```ts
+   * const converter = new AudioParameterConverter({
+   *   type: "continuous",
+   *   min: 0,
+   *   max: 100,
+   *   step: 0.1,
+   *   unit: "dB"
+   * });
+   * converter.format(50.5); // "50.5 dB"
+   *
+   * const boolConverter = new AudioParameterConverter({
+   *   type: "boolean",
+   *   trueLabel: "Enabled",
+   *   falseLabel: "Disabled"
+   * });
+   * boolConverter.format(true); // "Enabled"
+   * ```
+   */
+  format(t) {
+    switch (this.config.type) {
+      case "continuous": {
+        const e = this.config, o = t, n = e.step ? Math.max(0, Math.ceil(Math.log10(1 / e.step))) : 1, s = o.toFixed(n);
+        return `${parseFloat(s).toString()}${e.unit ? " " + e.unit : ""}`;
+      }
+      case "boolean": {
+        const e = this.config;
+        return (t ? e.trueLabel : e.falseLabel) ?? (t ? "On" : "Off");
+      }
+      case "discrete":
+        return this.config.options.find((n) => n.value === t)?.label ?? String(t);
+    }
+  }
+  /**
+   * Get the maximum display text for sizing purposes.
+   * Returns the longest formatted string among all possible values.
+   * Useful for RadialText referenceText prop to ensure consistent sizing.
+   *
+   * @param options - Optional configuration
+   * @param options.includeUnit - Whether to include the unit in the result (default: true).
+   *                              Set to false when displaying value and unit on separate lines.
+   * @returns The longest formatted display string
+   *
+   * @example
+   * ```ts
+   * const converter = new AudioParameterConverter(volumeParam);
+   * // Single line with unit
+   * <RadialText text={currentValue} referenceText={converter.getMaxDisplayText()} />
+   *
+   * // Multiline: value on first line, unit on second
+   * <RadialText
+   *   text={[formattedValue, unit]}
+   *   referenceText={[converter.getMaxDisplayText({ includeUnit: false }), unit]}
+   * />
+   * ```
+   */
+  getMaxDisplayText(t) {
+    const e = t?.includeUnit ?? !0;
+    switch (this.config.type) {
+      case "continuous": {
+        const o = this.config;
+        if (e) {
+          const n = this.format(o.min), s = this.format(o.max);
+          return n.length >= s.length ? n : s;
+        } else {
+          const n = o.step ? Math.max(0, Math.ceil(Math.log10(1 / o.step))) : 1, s = o.min.toFixed(n), r = o.max.toFixed(n), c = parseFloat(s).toString(), a = parseFloat(r).toString();
+          return c.length >= a.length ? c : a;
+        }
+      }
+      case "boolean": {
+        const o = this.config, n = o.trueLabel ?? "On", s = o.falseLabel ?? "Off";
+        return n.length >= s.length ? n : s;
+      }
+      case "discrete": {
+        const o = this.config;
+        let n = "";
+        for (const s of o.options) {
+          const r = s.label ?? String(s.value);
+          r.length > n.length && (n = r);
+        }
+        return n;
+      }
+    }
+  }
+}
+const ct = {
+  /**
+   * Creates a standard 7-bit MIDI CC parameter (0-127).
+   *
+   * This is the most common MIDI control change format, used for most hardware controllers
+   * and software synthesizers. The parameter uses 7-bit resolution (128 steps).
+   *
+   * @param name The parameter name (used to generate ID and name fields)
+   * @returns A ContinuousParameter configured for 7-bit MIDI CC
+   *
+   * @example
+   * ```ts
+   * const volumeParam = AudioParameterFactory.createMidiStandard7Bit("Volume");
+   * // { type: "continuous", min: 0, max: 127, step: 1, midiResolution: 7, ... }
+   * ```
+   */
+  createMidiStandard7Bit: (i) => ({
+    id: `cc-${i.toLowerCase().replace(/\s+/g, "-")}`,
+    name: i,
+    type: "continuous",
+    min: 0,
+    max: 127,
+    step: 1,
+    midiResolution: 7,
+    unit: ""
+  }),
+  /**
+   * Creates a standard 14-bit MIDI CC parameter (0-16383).
+   *
+   * This provides higher resolution than 7-bit CC, useful for parameters that require
+   * fine-grained control. The parameter uses 14-bit resolution (16,384 steps).
+   *
+   * @param name The parameter name (used to generate ID and name fields)
+   * @returns A ContinuousParameter configured for 14-bit MIDI CC
+   *
+   * @example
+   * ```ts
+   * const fineTuneParam = AudioParameterFactory.createMidiStandard14Bit("Fine Tune");
+   * // { type: "continuous", min: 0, max: 16383, step: 1, midiResolution: 14, ... }
+   * ```
+   */
+  createMidiStandard14Bit: (i) => ({
+    id: `cc14-${i.toLowerCase().replace(/\s+/g, "-")}`,
+    name: i,
+    type: "continuous",
+    min: 0,
+    max: 16383,
+    step: 1,
+    midiResolution: 14,
+    unit: ""
+  }),
+  /**
+   * Creates a bipolar 7-bit MIDI CC parameter (-64 to 63, centered at 0).
+   *
+   * This is useful for parameters that have a center point, such as pan controls or
+   * modulation depth. The range is symmetric around zero, with 64 steps in each direction.
+   *
+   * @param name The parameter name (used to generate ID and name fields)
+   * @returns A ContinuousParameter configured for bipolar 7-bit MIDI CC
+   *
+   * @example
+   * ```ts
+   * const panParam = AudioParameterFactory.createMidiBipolar7Bit("Pan");
+   * // { type: "continuous", min: -64, max: 63, step: 1, defaultValue: 0, ... }
+   * ```
+   */
+  createMidiBipolar7Bit: (i) => ({
+    id: `cc-bipolar-${i.toLowerCase().replace(/\s+/g, "-")}`,
+    name: i,
+    type: "continuous",
+    min: -64,
+    max: 63,
+    step: 1,
+    midiResolution: 7,
+    unit: "",
+    defaultValue: 0,
+    bipolar: !0
+  }),
+  /**
+   * Creates a bipolar 14-bit MIDI CC parameter (-8192 to 8191, centered at 0).
+   *
+   * This provides high-resolution bipolar control, useful for parameters that require
+   * fine-grained adjustment around a center point. The range is symmetric around zero,
+   * with 8,192 steps in each direction.
+   *
+   * @param name The parameter name (used to generate ID and name fields)
+   * @returns A ContinuousParameter configured for bipolar 14-bit MIDI CC
+   *
+   * @example
+   * ```ts
+   * const finePanParam = AudioParameterFactory.createMidiBipolar14Bit("Fine Pan");
+   * // { type: "continuous", min: -8192, max: 8191, step: 1, defaultValue: 0, ... }
+   * ```
+   */
+  createMidiBipolar14Bit: (i) => ({
+    id: `cc14-bipolar-${i.toLowerCase().replace(/\s+/g, "-")}`,
+    name: i,
+    type: "continuous",
+    min: -8192,
+    max: 8191,
+    step: 1,
+    midiResolution: 14,
+    unit: "",
+    defaultValue: 0,
+    bipolar: !0
+  }),
+  /**
+   * Creates a bipolar parameter with custom range (centered at 0).
+   *
+   * This is a flexible factory method for creating bipolar parameters with any range.
+   * The parameter is symmetric around zero, useful for pan controls, modulation depth,
+   * or any parameter that has a neutral center point.
+   *
+   * @param name The parameter name (used to generate ID and name fields)
+   * @param range The range value (default: 100). The parameter will span from -range to +range
+   * @param unit Optional unit suffix (e.g., "dB", "%")
+   * @returns A ContinuousParameter configured for bipolar control
+   *
+   * @example
+   * ```ts
+   * const panParam = AudioParameterFactory.createBipolar("Pan", 100, "%");
+   * // { type: "continuous", min: -100, max: 100, step: 1, defaultValue: 0, unit: "%", ... }
+   *
+   * const modDepthParam = AudioParameterFactory.createBipolar("Mod Depth", 50);
+   * // { type: "continuous", min: -50, max: 50, step: 1, defaultValue: 0, ... }
+   * ```
+   */
+  createBipolar: (i, t = 100, e = "") => ({
+    id: `bipolar-${i.toLowerCase().replace(/\s+/g, "-")}`,
+    name: i,
+    type: "continuous",
+    min: -t,
+    max: t,
+    step: 1,
+    unit: e,
+    defaultValue: 0,
+    bipolar: !0
+  }),
+  /**
+   * Creates a boolean switch parameter (Off/On).
+   *
+   * This factory method creates a boolean parameter suitable for on/off controls,
+   * with support for both toggle (latch) and momentary modes.
+   *
+   * @param name The parameter name (used to generate ID and name fields)
+   * @param mode The switch mode: "toggle" (latch) or "momentary" (only active while pressed)
+   * @returns A BooleanParameter configured as a switch
+   *
+   * @example
+   * ```ts
+   * const powerParam = AudioParameterFactory.createSwitch("Power", "toggle");
+   * // { type: "boolean", mode: "toggle", trueLabel: "On", falseLabel: "Off", ... }
+   *
+   * const recordParam = AudioParameterFactory.createSwitch("Record", "momentary");
+   * // { type: "boolean", mode: "momentary", ... }
+   * ```
+   */
+  createSwitch: (i, t = "toggle") => ({
+    id: `sw-${i.toLowerCase().replace(/\s+/g, "-")}`,
+    name: i,
+    type: "boolean",
+    mode: t,
+    defaultValue: !1,
+    trueLabel: "On",
+    falseLabel: "Off",
+    midiResolution: 7
+  }),
+  /**
+   * Creates a discrete (selector) parameter.
+   *
+   * This factory method creates a discrete parameter suitable for mode selectors,
+   * preset switches, or any control that cycles through discrete options.
+   *
+   * @param name The parameter name (used to generate ID and name fields)
+   * @param options Array of option objects, each with a value and label
+   * @returns A DiscreteParameter configured as a selector
+   *
+   * @example
+   * ```ts
+   * const waveParam = AudioParameterFactory.createSelector("Waveform", [
+   *   { value: "sine", label: "Sine" },
+   *   { value: "square", label: "Square" },
+   *   { value: "sawtooth", label: "Sawtooth" }
+   * ]);
+   * ```
+   */
+  createSelector: (i, t) => ({
+    id: `sel-${i.toLowerCase().replace(/\s+/g, "-")}`,
+    name: i,
+    type: "discrete",
+    options: t,
+    defaultValue: t[0]?.value,
+    midiResolution: 7,
+    midiMapping: "spread"
+  }),
+  /**
+   * Creates a generic continuous control parameter (for ad-hoc UI controls like Knob/Slider).
+   *
+   * This is the most flexible factory method, allowing you to specify all aspects of a
+   * continuous parameter. It's useful when you need a parameter that doesn't fit the
+   * standard MIDI presets.
+   *
+   * The method handles bipolar mode automatically: if `bipolar` is true, it adjusts
+   * min/max to be symmetric around zero when only one boundary is provided. For default values:
+   * - If `defaultValue` is provided, it is used (even when `bipolar=true`)
+   * - If `defaultValue` is not provided and `bipolar=true`, the center of the range is calculated
+   *   (0 for symmetric ranges, otherwise the midpoint)
+   * - If `defaultValue` is not provided and `bipolar=false`, falls back to `min` or 0
+   *
+   * @param config Configuration object with optional fields for all parameter properties
+   * @returns A ContinuousParameter configured according to the provided config
+   *
+   * @example
+   * ```ts
+   * const volumeParam = AudioParameterFactory.createControl({
+   *   name: "Volume",
+   *   min: 0,
+   *   max: 100,
+   *   step: 0.1,
+   *   unit: "dB",
+   *   scale: "log"
+   * });
+   *
+   * const panParam = AudioParameterFactory.createControl({
+   *   name: "Pan",
+   *   bipolar: true,
+   *   unit: "%"
+   * });
+   * // Automatically sets min: -100, max: 100, defaultValue: 0
+   *
+   * const customBipolarParam = AudioParameterFactory.createControl({
+   *   name: "Custom",
+   *   min: 0,
+   *   max: 127,
+   *   bipolar: true,
+   *   defaultValue: 64
+   * });
+   * // Uses provided defaultValue: 64 (center of 0-127 range)
+   * ```
+   */
+  createControl: (i) => {
+    const { id: t, name: e, label: o, min: n, max: s, step: r, bipolar: c, unit: a = "", defaultValue: u, scale: g, midiResolution: m } = i;
+    let d = n, f = s, h = u;
+    if (c) {
+      if (n === void 0 && s === void 0 ? (d = -100, f = 100) : n === void 0 && s !== void 0 ? d = -s : n !== void 0 && s === void 0 && (f = -n), h === void 0) {
+        const b = d ?? 0, M = f ?? 100;
+        b === -M ? h = 0 : h = (b + M) / 2;
+      }
+    } else
+      h = h ?? n ?? 0;
+    return {
+      id: t ?? "adhoc-control",
+      type: "continuous",
+      name: e ?? o ?? "",
+      min: d ?? 0,
+      max: f ?? 100,
+      step: r,
+      unit: a,
+      defaultValue: h,
+      scale: g,
+      midiResolution: m,
+      bipolar: c ?? !1
+    };
+  }
+}, x = (i, t, e, o) => {
+  const n = (o - 90) * Math.PI / 180;
+  return {
+    x: i + e * Math.cos(n),
+    y: t + e * Math.sin(n)
+  };
+};
+function ut(i, t = 90, e = 0, o = !1, n) {
+  const s = Math.max(0, Math.min(1, i));
+  let r = s;
+  n !== void 0 && n >= 1 && (n === 1 ? r = 0.5 : r = Math.round(s * (n - 1)) / (n - 1));
+  const c = Math.max(0, Math.min(360, t)), a = 180 + c / 2, u = 540 - c / 2, g = a, m = u, d = u - a, f = r * d + g, h = g - e, b = m - e;
+  let M = h;
+  o && (M = 360 - e);
+  const A = f - e;
+  return {
+    normalizedValue: r,
+    openness: c,
+    startAngle: h,
+    endAngle: b,
+    valueToAngle: A,
+    valueStartAngle: M
+  };
+}
+function ht(i, t, e) {
+  const o = Math.max(0, Math.min(1, e));
+  return i + t / 2 - o * t;
+}
+const dt = (i, t, e, o, n, s = "counter-clockwise") => {
+  e > o && ([e, o] = [o, e]);
+  const r = (f) => Math.round(f * 1e4) / 1e4, c = x(i, t, n, e), a = x(i, t, n, o), u = o - e <= 180 ? "0" : "1", [g, m, d] = s === "counter-clockwise" ? [a, c, 0] : [c, a, 1];
+  return ["M", r(g.x), r(g.y), "A", r(n), r(n), 0, u, d, r(m.x), r(m.y)].join(" ");
+}, G = {
+  xsmall: "audioui-size-square-xsmall",
+  small: "audioui-size-square-small",
+  normal: "audioui-size-square-normal",
+  large: "audioui-size-square-large",
+  xlarge: "audioui-size-square-xlarge"
+}, _ = {
+  xsmall: "audioui-size-hslider-xsmall",
+  small: "audioui-size-hslider-small",
+  normal: "audioui-size-hslider-normal",
+  large: "audioui-size-hslider-large",
+  xlarge: "audioui-size-hslider-xlarge"
+}, O = {
+  xsmall: "audioui-size-vslider-xsmall",
+  small: "audioui-size-vslider-small",
+  normal: "audioui-size-vslider-normal",
+  large: "audioui-size-vslider-large",
+  xlarge: "audioui-size-vslider-xlarge"
+}, U = {
+  xsmall: "audioui-size-keys-xsmall",
+  small: "audioui-size-keys-small",
+  normal: "audioui-size-keys-normal",
+  large: "audioui-size-keys-large",
+  xlarge: "audioui-size-keys-xlarge"
+};
+function ft(i, t = "normal", e = "vertical") {
+  switch (i) {
+    case "knob":
+    case "button":
+      return G[t];
+    case "keys":
+      return U[t];
+    case "slider":
+      return e === "horizontal" ? _[t] : O[t];
+    default:
+      throw new Error(`Unknown component type: ${i}`);
+  }
+}
+function gt(i, t = "normal", e = "vertical") {
+  switch (i) {
+    case "knob":
+    case "button":
+      return {
+        width: `var(--audioui-size-square-${t})`,
+        height: `var(--audioui-size-square-${t})`
+      };
+    case "keys":
+      return {
+        width: `var(--audioui-size-keys-width-${t})`,
+        height: `var(--audioui-size-keys-height-${t})`
+      };
+    case "slider":
+      return e === "horizontal" ? {
+        width: `var(--audioui-size-hslider-width-${t})`,
+        height: `var(--audioui-size-hslider-height-${t})`
+      } : {
+        width: `var(--audioui-size-vslider-width-${t})`,
+        height: `var(--audioui-size-vslider-height-${t})`
+      };
+    default:
+      throw new Error(`Unknown component type: ${i}`);
+  }
+}
+const w = {
+  blue: "hsl(204, 88%, 53%)",
+  orange: "hsl(29, 100%, 50%)",
+  pink: "hsl(332, 95%, 54%)",
+  green: "hsl(160, 98%, 37%)",
+  purple: "hsl(252, 100%, 67%)",
+  yellow: "hsl(50, 100%, 50%)",
+  white: "hsl(0, 0%, 100%)"
+}, I = /hsl\((\d+),\s*(\d+)%,\s*(\d+)%\)/;
+function mt() {
+  return typeof window > "u" ? !1 : document.documentElement.classList.contains("dark") || window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+function pt() {
+  return `var(${P.adaptiveDefaultColor})`;
+}
+function C(i, t) {
+  const e = w[i.toLowerCase()];
+  if (e) {
+    const n = e.match(I);
+    if (n) {
+      const s = n[1], r = n[2], c = parseInt(n[3], 10), a = Math.max(0, Math.min(100, c * (t / 100)));
+      return `hsl(${s}, ${r}%, ${a}%)`;
+    }
+  }
+  const o = 100 - t;
+  return `color-mix(in srgb, ${i}, black ${o}%)`;
+}
+function S(i, t) {
+  return `color-mix(in srgb, ${i} ${t}%, transparent)`;
+}
+function Y(i) {
+  const t = w[i.toLowerCase()];
+  t && (i = t);
+  const e = i.match(I);
+  if (e) {
+    const o = parseInt(e[1], 10), n = Math.min(100, parseInt(e[2], 10) + 10), s = Math.min(70, parseInt(e[3], 10) + 10);
+    return `hsl(${o}, ${n}%, ${s}%)`;
+  }
+  return `color-mix(in srgb, ${i} 80%, white 20%)`;
+}
+function Mt(i, t = "luminosity") {
+  const o = w[i.toLowerCase()] ?? i, n = Y(o);
+  return t === "luminosity" ? {
+    primary: o,
+    primary50: C(o, 50),
+    primary20: C(o, 20),
+    highlight: n
+  } : {
+    primary: o,
+    primary50: S(o, 50),
+    primary20: S(o, 20),
+    highlight: n
+  };
+}
+function p(i) {
+  return Math.max(0, Math.min(1, i));
+}
+function vt(i) {
+  return p(i) === 0 ? 0 : 1;
+}
+function bt(i) {
+  const t = p(i);
+  return Math.round(1 + t * 19);
+}
+function wt(i) {
+  const t = p(i);
+  return Math.round(t * 20);
+}
+function yt(i) {
+  const t = p(i);
+  return Math.round(1 + t * 49);
+}
+function xt(i) {
+  const t = p(i);
+  return Math.round(t * 50);
+}
+function Ct(i) {
+  const t = p(i);
+  return Math.round(t * 12);
+}
+const y = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], St = ["C", "D", "E", "F", "G", "A", "B"], It = [0, 2, 4, 5, 7, 9, 11], kt = {
+  C: 0,
+  D: 2,
+  E: 4,
+  F: 5,
+  G: 7,
+  A: 9,
+  B: 11
+}, B = /* @__PURE__ */ new Set([0, 2, 4, 5, 7, 9, 11]), k = [], D = /* @__PURE__ */ new Map();
+for (let i = 0; i < 128; i++) {
+  const t = Math.floor(i / 12) - 1, e = i % 12, n = `${y[e]}${t}`;
+  k[i] = n, D.set(n, i);
+}
+const Dt = (i) => {
+  if (i >= 0 && i < 128)
+    return k[i];
+  const t = Math.floor(i / 12) - 1, e = i % 12;
+  return `${y[e]}${t}`;
+}, E = (i) => {
+  const t = D.get(i);
+  if (t !== void 0)
+    return t;
+  const e = i.match(/^([A-G](#)?)(-?\d+)$/);
+  if (!e) return -1;
+  const [, o, , n] = e, s = y.findIndex((r) => r === o);
+  return s === -1 ? -1 : (parseInt(n) + 1) * 12 + s;
+}, H = (i) => {
+  const t = /* @__PURE__ */ new Set();
+  for (const e of i)
+    if (typeof e == "number")
+      t.add(e);
+    else {
+      const o = E(e);
+      o !== -1 && t.add(o);
+    }
+  return t;
+}, Et = (i, t) => {
+  if (t.length === 0) return !1;
+  const e = H(t);
+  if (typeof i == "string") {
+    const o = E(i);
+    return o !== -1 && e.has(o);
+  }
+  return e.has(i);
+}, At = (i) => {
+  const t = i % 12;
+  return !B.has(t);
+}, X = (i, t) => Math.floor((t - i + 1) / 2) + i, j = (i) => i > 0 ? `+${i}` : i.toString(), Nt = (i, t, e) => {
+  const o = X(t, e), n = i - o;
+  return j(n);
+}, zt = (i) => (t) => `${t}${i}`, Tt = (i) => (t) => t.toFixed(i), Pt = (...i) => (t, e, o) => {
+  let n = t;
+  for (const s of i)
+    if (typeof n == "string") {
+      const r = parseFloat(n);
+      isNaN(r) || (n = s(r, e, o));
+    } else
+      n = s(n, e, o);
+  return n.toString();
+}, Lt = (i, t, e) => {
+  const o = (i - t) / (e - t) * 100;
+  return `${Math.round(o)}%`;
+}, $t = (i) => i >= 1e3 ? `${(i / 1e3).toFixed(1)}kHz` : `${Math.round(i)}Hz`;
+function Rt({
+  deepCompareProps: i = ["style"],
+  alwaysCompareProps: t = ["children"]
+} = {}) {
+  const e = new Set(i), o = new Set(t);
+  return function(s, r) {
+    for (const a of o)
+      if (s[a] !== r[a])
+        return !1;
+    for (const a of e)
+      if (!T(s[a], r[a]))
+        return !1;
+    const c = Object.keys(s).filter(
+      (a) => !e.has(a) && !o.has(a)
+    );
+    for (const a of c)
+      if (s[a] !== r[a])
+        return !1;
+    return !0;
+  };
+}
+export {
+  lt as AudioParameterConverter,
+  ct as AudioParameterFactory,
+  rt as BooleanInteractionController,
+  y as CHROMATIC_NOTES,
+  it as CIRCULAR_CURSOR,
+  W as CLASSNAMES,
+  P as CSS_VARS,
+  nt as ContinuousInteractionController,
+  L as DEFAULT_CONTINUOUS_SENSITIVITY,
+  R as DEFAULT_KEYBOARD_STEP,
+  tt as DEFAULT_ROUNDNESS,
+  et as DEFAULT_THICKNESS,
+  $ as DEFAULT_WHEEL_SENSITIVITY,
+  kt as DIATONIC_TO_CHROMATIC,
+  st as DiscreteInteractionController,
+  V as ExpScale,
+  v as LinearScale,
+  F as LogScale,
+  at as NoteInteractionController,
+  ot as TARGET_PIXELS_PER_STEP,
+  St as WHITE_KEY_NAMES,
+  B as WHITE_KEY_POSITIONS,
+  It as WHITE_KEY_TO_CHROMATIC,
+  j as bipolarFormatter,
+  ut as calculateArcAngles,
+  dt as calculateArcPath,
+  X as calculateCenterValue,
+  ht as calculateLinearPosition,
+  p as clampNormalized,
+  Pt as combineFormatters,
+  H as createNoteNumSet,
+  Rt as createPropComparator,
+  $t as frequencyFormatter,
+  Mt as generateColorVariants,
+  Y as generateHighlightColor,
+  C as generateLuminosityVariant,
+  S as generateTransparencyVariant,
+  pt as getAdaptiveDefaultColor,
+  ft as getSizeClassForComponent,
+  gt as getSizeStyleForComponent,
+  _ as horizontalSliderSizeClassMap,
+  At as isBlackKey,
+  mt as isDarkMode,
+  Et as isNoteOn,
+  U as keysSizeClassMap,
+  Nt as midiBipolarFormatter,
+  Dt as noteNumToNote,
+  E as noteToNoteNum,
+  Lt as percentageFormatter,
+  x as polarToCartesian,
+  G as squareSizeClassMap,
+  J as themeColors,
+  Q as themeColorsDirect,
+  xt as translateButtonRoundness,
+  Ct as translateKeysRoundness,
+  vt as translateKnobRoundness,
+  bt as translateKnobThickness,
+  wt as translateSliderRoundness,
+  yt as translateSliderThickness,
+  O as verticalSliderSizeClassMap,
+  Tt as withPrecision,
+  zt as withUnit
+};
+//# sourceMappingURL=index.js.map