react-audio-wavekit 0.1.4 → 0.1.6

package/README.md

@@ -113,6 +113,7 @@ Scrolling timeline waveform (Voice Memos style). Canvas grows horizontally as re
 | `fftSize` | `number` | `2048` | FFT size for frequency analysis |
 | `smoothingTimeConstant` | `number` | `0.8` | Smoothing constant (0-1) |
 | `sampleInterval` | `number` | `50` | Sample interval in ms |
+| `amplitudeScale` | `number` | `1.5` | Amplitude multiplier (lower = quieter waveform) |
 | `appearance` | `LiveStreamingRecorderAppearance` | - | See [Appearance Options](#appearance-options) |
 
 **Canvas Props:**
@@ -143,6 +144,7 @@ Fixed-width waveform where bars compress as recording grows.
 | `fftSize` | `number` | `2048` | FFT size for frequency analysis |
 | `smoothingTimeConstant` | `number` | `0.8` | Smoothing constant (0-1) |
 | `sampleInterval` | `number` | `50` | Sample interval in ms |
+| `amplitudeScale` | `number` | `1.5` | Amplitude multiplier (lower = quieter waveform) |
 | `appearance` | `WaveformAppearance` | - | See [Appearance Options](#appearance-options) |
 
 ### LiveRecorder
@@ -163,6 +165,7 @@ Real-time frequency bars visualization.
 | `fftSize` | `number` | `2048` | FFT size for frequency analysis |
 | `smoothingTimeConstant` | `number` | `0.8` | Smoothing constant (0-1) |
 | `showIdleState` | `boolean` | `true` | Show minimal bars when not recording |
+| `amplitudeScale` | `number` | `1.5` | Amplitude multiplier (lower = quieter waveform) |
 | `appearance` | `WaveformAppearance` | - | See [Appearance Options](#appearance-options) |
 
 ---

package/dist/index.d.ts

@@ -65,6 +65,11 @@ declare interface LiveRecorderProps extends React.CanvasHTMLAttributes<HTMLCanva
      * @default true
      */
     showIdleState?: boolean;
+    /**
+     * Amplitude multiplier - lower values produce quieter waveforms
+     * @default 1.5
+     */
+    amplitudeScale?: number;
 }
 
 declare interface LiveRecorderRef {
@@ -191,6 +196,11 @@ declare interface UseRecordingAmplitudesOptions {
     smoothingTimeConstant?: number;
     /** Interval in ms for sampling amplitude data */
     sampleInterval?: number;
+    /**
+     * Amplitude multiplier - lower values produce quieter waveforms
+     * @default 1.5
+     */
+    amplitudeScale?: number;
 }
 
 declare interface UseRecordingAmplitudesReturn {

package/dist/node_modules/automation-events/build/es2019/classes/automation-event-list.cjs

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createExtendedExponentialRampToValueAutomationEvent = require("../functions/create-extended-exponential-ramp-to-value-automation-event.cjs");
+const createExtendedLinearRampToValueAutomationEvent = require("../functions/create-extended-linear-ramp-to-value-automation-event.cjs");
+const createSetValueAutomationEvent = require("../functions/create-set-value-automation-event.cjs");
+const createSetValueCurveAutomationEvent = require("../functions/create-set-value-curve-automation-event.cjs");
+const getEndTimeAndValueOfPreviousAutomationEvent = require("../functions/get-end-time-and-value-of-previous-automation-event.cjs");
+const getEventTime = require("../functions/get-event-time.cjs");
+const getExponentialRampValueAtTime = require("../functions/get-exponential-ramp-value-at-time.cjs");
+const getLinearRampValueAtTime = require("../functions/get-linear-ramp-value-at-time.cjs");
+const getTargetValueAtTime = require("../functions/get-target-value-at-time.cjs");
+const getValueCurveValueAtTime = require("../functions/get-value-curve-value-at-time.cjs");
+const getValueOfAutomationEventAtIndexAtTime = require("../functions/get-value-of-automation-event-at-index-at-time.cjs");
+const anyRampToValueAutomationEvent = require("../guards/any-ramp-to-value-automation-event.cjs");
+const cancelAndHoldAutomationEvent = require("../guards/cancel-and-hold-automation-event.cjs");
+const cancelScheduledValuesAutomationEvent = require("../guards/cancel-scheduled-values-automation-event.cjs");
+const exponentialRampToValueAutomationEvent = require("../guards/exponential-ramp-to-value-automation-event.cjs");
+const linearRampToValueAutomationEvent = require("../guards/linear-ramp-to-value-automation-event.cjs");
+const setTargetAutomationEvent = require("../guards/set-target-automation-event.cjs");
+const setValueAutomationEvent = require("../guards/set-value-automation-event.cjs");
+const setValueCurveAutomationEvent = require("../guards/set-value-curve-automation-event.cjs");
+class AutomationEventList {
+  constructor(defaultValue) {
+    this._automationEvents = [];
+    this._currenTime = 0;
+    this._defaultValue = defaultValue;
+  }
+  [Symbol.iterator]() {
+    return this._automationEvents[Symbol.iterator]();
+  }
+  add(automationEvent) {
+    const eventTime = getEventTime.getEventTime(automationEvent);
+    if (cancelAndHoldAutomationEvent.isCancelAndHoldAutomationEvent(automationEvent) || cancelScheduledValuesAutomationEvent.isCancelScheduledValuesAutomationEvent(automationEvent)) {
+      const index = this._automationEvents.findIndex((currentAutomationEvent) => {
+        if (cancelScheduledValuesAutomationEvent.isCancelScheduledValuesAutomationEvent(automationEvent) && setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(currentAutomationEvent)) {
+          return currentAutomationEvent.startTime + currentAutomationEvent.duration >= eventTime;
+        }
+        return getEventTime.getEventTime(currentAutomationEvent) >= eventTime;
+      });
+      const removedAutomationEvent = this._automationEvents[index];
+      if (index !== -1) {
+        this._automationEvents = this._automationEvents.slice(0, index);
+      }
+      if (cancelAndHoldAutomationEvent.isCancelAndHoldAutomationEvent(automationEvent)) {
+        const lastAutomationEvent = this._automationEvents[this._automationEvents.length - 1];
+        if (removedAutomationEvent !== void 0 && anyRampToValueAutomationEvent.isAnyRampToValueAutomationEvent(removedAutomationEvent)) {
+          if (lastAutomationEvent !== void 0 && setTargetAutomationEvent.isSetTargetAutomationEvent(lastAutomationEvent)) {
+            throw new Error("The internal list is malformed.");
+          }
+          const startTime = lastAutomationEvent === void 0 ? removedAutomationEvent.insertTime : setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(lastAutomationEvent) ? lastAutomationEvent.startTime + lastAutomationEvent.duration : getEventTime.getEventTime(lastAutomationEvent);
+          const startValue = lastAutomationEvent === void 0 ? this._defaultValue : setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(lastAutomationEvent) ? lastAutomationEvent.values[lastAutomationEvent.values.length - 1] : lastAutomationEvent.value;
+          const value = exponentialRampToValueAutomationEvent.isExponentialRampToValueAutomationEvent(removedAutomationEvent) ? getExponentialRampValueAtTime.getExponentialRampValueAtTime(eventTime, startTime, startValue, removedAutomationEvent) : getLinearRampValueAtTime.getLinearRampValueAtTime(eventTime, startTime, startValue, removedAutomationEvent);
+          const truncatedAutomationEvent = exponentialRampToValueAutomationEvent.isExponentialRampToValueAutomationEvent(removedAutomationEvent) ? createExtendedExponentialRampToValueAutomationEvent.createExtendedExponentialRampToValueAutomationEvent(value, eventTime, this._currenTime) : createExtendedLinearRampToValueAutomationEvent.createExtendedLinearRampToValueAutomationEvent(value, eventTime, this._currenTime);
+          this._automationEvents.push(truncatedAutomationEvent);
+        }
+        if (lastAutomationEvent !== void 0 && setTargetAutomationEvent.isSetTargetAutomationEvent(lastAutomationEvent)) {
+          this._automationEvents.push(createSetValueAutomationEvent.createSetValueAutomationEvent(this.getValue(eventTime), eventTime));
+        }
+        if (lastAutomationEvent !== void 0 && setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(lastAutomationEvent) && lastAutomationEvent.startTime + lastAutomationEvent.duration > eventTime) {
+          const duration = eventTime - lastAutomationEvent.startTime;
+          const ratio = (lastAutomationEvent.values.length - 1) / lastAutomationEvent.duration;
+          const length = Math.max(2, 1 + Math.ceil(duration * ratio));
+          const fraction = duration / (length - 1) * ratio;
+          const values = lastAutomationEvent.values.slice(0, length);
+          if (fraction < 1) {
+            for (let i = 1; i < length; i += 1) {
+              const factor = fraction * i % 1;
+              values[i] = lastAutomationEvent.values[i - 1] * (1 - factor) + lastAutomationEvent.values[i] * factor;
+            }
+          }
+          this._automationEvents[this._automationEvents.length - 1] = createSetValueCurveAutomationEvent.createSetValueCurveAutomationEvent(values, lastAutomationEvent.startTime, duration);
+        }
+      }
+    } else {
+      const index = this._automationEvents.findIndex((currentAutomationEvent) => getEventTime.getEventTime(currentAutomationEvent) > eventTime);
+      const previousAutomationEvent = index === -1 ? this._automationEvents[this._automationEvents.length - 1] : this._automationEvents[index - 1];
+      if (previousAutomationEvent !== void 0 && setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(previousAutomationEvent) && getEventTime.getEventTime(previousAutomationEvent) + previousAutomationEvent.duration > eventTime) {
+        return false;
+      }
+      const persistentAutomationEvent = exponentialRampToValueAutomationEvent.isExponentialRampToValueAutomationEvent(automationEvent) ? createExtendedExponentialRampToValueAutomationEvent.createExtendedExponentialRampToValueAutomationEvent(automationEvent.value, automationEvent.endTime, this._currenTime) : linearRampToValueAutomationEvent.isLinearRampToValueAutomationEvent(automationEvent) ? createExtendedLinearRampToValueAutomationEvent.createExtendedLinearRampToValueAutomationEvent(automationEvent.value, eventTime, this._currenTime) : automationEvent;
+      if (index === -1) {
+        this._automationEvents.push(persistentAutomationEvent);
+      } else {
+        if (setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(automationEvent) && eventTime + automationEvent.duration > getEventTime.getEventTime(this._automationEvents[index])) {
+          return false;
+        }
+        this._automationEvents.splice(index, 0, persistentAutomationEvent);
+      }
+    }
+    return true;
+  }
+  flush(time) {
+    const index = this._automationEvents.findIndex((currentAutomationEvent) => getEventTime.getEventTime(currentAutomationEvent) > time);
+    if (index > 1) {
+      const remainingAutomationEvents = this._automationEvents.slice(index - 1);
+      const firstRemainingAutomationEvent = remainingAutomationEvents[0];
+      if (setTargetAutomationEvent.isSetTargetAutomationEvent(firstRemainingAutomationEvent)) {
+        remainingAutomationEvents.unshift(createSetValueAutomationEvent.createSetValueAutomationEvent(getValueOfAutomationEventAtIndexAtTime.getValueOfAutomationEventAtIndexAtTime(this._automationEvents, index - 2, firstRemainingAutomationEvent.startTime, this._defaultValue), firstRemainingAutomationEvent.startTime));
+      }
+      this._automationEvents = remainingAutomationEvents;
+    }
+  }
+  getValue(time) {
+    if (this._automationEvents.length === 0) {
+      return this._defaultValue;
+    }
+    const indexOfNextEvent = this._automationEvents.findIndex((automationEvent) => getEventTime.getEventTime(automationEvent) > time);
+    const nextAutomationEvent = this._automationEvents[indexOfNextEvent];
+    const indexOfCurrentEvent = (indexOfNextEvent === -1 ? this._automationEvents.length : indexOfNextEvent) - 1;
+    const currentAutomationEvent = this._automationEvents[indexOfCurrentEvent];
+    if (currentAutomationEvent !== void 0 && setTargetAutomationEvent.isSetTargetAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !anyRampToValueAutomationEvent.isAnyRampToValueAutomationEvent(nextAutomationEvent) || nextAutomationEvent.insertTime > time)) {
+      return getTargetValueAtTime.getTargetValueAtTime(time, getValueOfAutomationEventAtIndexAtTime.getValueOfAutomationEventAtIndexAtTime(this._automationEvents, indexOfCurrentEvent - 1, currentAutomationEvent.startTime, this._defaultValue), currentAutomationEvent);
+    }
+    if (currentAutomationEvent !== void 0 && setValueAutomationEvent.isSetValueAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !anyRampToValueAutomationEvent.isAnyRampToValueAutomationEvent(nextAutomationEvent))) {
+      return currentAutomationEvent.value;
+    }
+    if (currentAutomationEvent !== void 0 && setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !anyRampToValueAutomationEvent.isAnyRampToValueAutomationEvent(nextAutomationEvent) || currentAutomationEvent.startTime + currentAutomationEvent.duration > time)) {
+      if (time < currentAutomationEvent.startTime + currentAutomationEvent.duration) {
+        return getValueCurveValueAtTime.getValueCurveValueAtTime(time, currentAutomationEvent);
+      }
+      return currentAutomationEvent.values[currentAutomationEvent.values.length - 1];
+    }
+    if (currentAutomationEvent !== void 0 && anyRampToValueAutomationEvent.isAnyRampToValueAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !anyRampToValueAutomationEvent.isAnyRampToValueAutomationEvent(nextAutomationEvent))) {
+      return currentAutomationEvent.value;
+    }
+    if (nextAutomationEvent !== void 0 && exponentialRampToValueAutomationEvent.isExponentialRampToValueAutomationEvent(nextAutomationEvent)) {
+      const [startTime, value] = getEndTimeAndValueOfPreviousAutomationEvent.getEndTimeAndValueOfPreviousAutomationEvent(this._automationEvents, indexOfCurrentEvent, currentAutomationEvent, nextAutomationEvent, this._defaultValue);
+      return getExponentialRampValueAtTime.getExponentialRampValueAtTime(time, startTime, value, nextAutomationEvent);
+    }
+    if (nextAutomationEvent !== void 0 && linearRampToValueAutomationEvent.isLinearRampToValueAutomationEvent(nextAutomationEvent)) {
+      const [startTime, value] = getEndTimeAndValueOfPreviousAutomationEvent.getEndTimeAndValueOfPreviousAutomationEvent(this._automationEvents, indexOfCurrentEvent, currentAutomationEvent, nextAutomationEvent, this._defaultValue);
+      return getLinearRampValueAtTime.getLinearRampValueAtTime(time, startTime, value, nextAutomationEvent);
+    }
+    return this._defaultValue;
+  }
+}
+exports.AutomationEventList = AutomationEventList;

package/dist/node_modules/automation-events/build/es2019/classes/automation-event-list.js

@@ -0,0 +1,137 @@
+import { createExtendedExponentialRampToValueAutomationEvent } from "../functions/create-extended-exponential-ramp-to-value-automation-event.js";
+import { createExtendedLinearRampToValueAutomationEvent } from "../functions/create-extended-linear-ramp-to-value-automation-event.js";
+import { createSetValueAutomationEvent } from "../functions/create-set-value-automation-event.js";
+import { createSetValueCurveAutomationEvent } from "../functions/create-set-value-curve-automation-event.js";
+import { getEndTimeAndValueOfPreviousAutomationEvent } from "../functions/get-end-time-and-value-of-previous-automation-event.js";
+import { getEventTime } from "../functions/get-event-time.js";
+import { getExponentialRampValueAtTime } from "../functions/get-exponential-ramp-value-at-time.js";
+import { getLinearRampValueAtTime } from "../functions/get-linear-ramp-value-at-time.js";
+import { getTargetValueAtTime } from "../functions/get-target-value-at-time.js";
+import { getValueCurveValueAtTime } from "../functions/get-value-curve-value-at-time.js";
+import { getValueOfAutomationEventAtIndexAtTime } from "../functions/get-value-of-automation-event-at-index-at-time.js";
+import { isAnyRampToValueAutomationEvent } from "../guards/any-ramp-to-value-automation-event.js";
+import { isCancelAndHoldAutomationEvent } from "../guards/cancel-and-hold-automation-event.js";
+import { isCancelScheduledValuesAutomationEvent } from "../guards/cancel-scheduled-values-automation-event.js";
+import { isExponentialRampToValueAutomationEvent } from "../guards/exponential-ramp-to-value-automation-event.js";
+import { isLinearRampToValueAutomationEvent } from "../guards/linear-ramp-to-value-automation-event.js";
+import { isSetTargetAutomationEvent } from "../guards/set-target-automation-event.js";
+import { isSetValueAutomationEvent } from "../guards/set-value-automation-event.js";
+import { isSetValueCurveAutomationEvent } from "../guards/set-value-curve-automation-event.js";
+class AutomationEventList {
+  constructor(defaultValue) {
+    this._automationEvents = [];
+    this._currenTime = 0;
+    this._defaultValue = defaultValue;
+  }
+  [Symbol.iterator]() {
+    return this._automationEvents[Symbol.iterator]();
+  }
+  add(automationEvent) {
+    const eventTime = getEventTime(automationEvent);
+    if (isCancelAndHoldAutomationEvent(automationEvent) || isCancelScheduledValuesAutomationEvent(automationEvent)) {
+      const index = this._automationEvents.findIndex((currentAutomationEvent) => {
+        if (isCancelScheduledValuesAutomationEvent(automationEvent) && isSetValueCurveAutomationEvent(currentAutomationEvent)) {
+          return currentAutomationEvent.startTime + currentAutomationEvent.duration >= eventTime;
+        }
+        return getEventTime(currentAutomationEvent) >= eventTime;
+      });
+      const removedAutomationEvent = this._automationEvents[index];
+      if (index !== -1) {
+        this._automationEvents = this._automationEvents.slice(0, index);
+      }
+      if (isCancelAndHoldAutomationEvent(automationEvent)) {
+        const lastAutomationEvent = this._automationEvents[this._automationEvents.length - 1];
+        if (removedAutomationEvent !== void 0 && isAnyRampToValueAutomationEvent(removedAutomationEvent)) {
+          if (lastAutomationEvent !== void 0 && isSetTargetAutomationEvent(lastAutomationEvent)) {
+            throw new Error("The internal list is malformed.");
+          }
+          const startTime = lastAutomationEvent === void 0 ? removedAutomationEvent.insertTime : isSetValueCurveAutomationEvent(lastAutomationEvent) ? lastAutomationEvent.startTime + lastAutomationEvent.duration : getEventTime(lastAutomationEvent);
+          const startValue = lastAutomationEvent === void 0 ? this._defaultValue : isSetValueCurveAutomationEvent(lastAutomationEvent) ? lastAutomationEvent.values[lastAutomationEvent.values.length - 1] : lastAutomationEvent.value;
+          const value = isExponentialRampToValueAutomationEvent(removedAutomationEvent) ? getExponentialRampValueAtTime(eventTime, startTime, startValue, removedAutomationEvent) : getLinearRampValueAtTime(eventTime, startTime, startValue, removedAutomationEvent);
+          const truncatedAutomationEvent = isExponentialRampToValueAutomationEvent(removedAutomationEvent) ? createExtendedExponentialRampToValueAutomationEvent(value, eventTime, this._currenTime) : createExtendedLinearRampToValueAutomationEvent(value, eventTime, this._currenTime);
+          this._automationEvents.push(truncatedAutomationEvent);
+        }
+        if (lastAutomationEvent !== void 0 && isSetTargetAutomationEvent(lastAutomationEvent)) {
+          this._automationEvents.push(createSetValueAutomationEvent(this.getValue(eventTime), eventTime));
+        }
+        if (lastAutomationEvent !== void 0 && isSetValueCurveAutomationEvent(lastAutomationEvent) && lastAutomationEvent.startTime + lastAutomationEvent.duration > eventTime) {
+          const duration = eventTime - lastAutomationEvent.startTime;
+          const ratio = (lastAutomationEvent.values.length - 1) / lastAutomationEvent.duration;
+          const length = Math.max(2, 1 + Math.ceil(duration * ratio));
+          const fraction = duration / (length - 1) * ratio;
+          const values = lastAutomationEvent.values.slice(0, length);
+          if (fraction < 1) {
+            for (let i = 1; i < length; i += 1) {
+              const factor = fraction * i % 1;
+              values[i] = lastAutomationEvent.values[i - 1] * (1 - factor) + lastAutomationEvent.values[i] * factor;
+            }
+          }
+          this._automationEvents[this._automationEvents.length - 1] = createSetValueCurveAutomationEvent(values, lastAutomationEvent.startTime, duration);
+        }
+      }
+    } else {
+      const index = this._automationEvents.findIndex((currentAutomationEvent) => getEventTime(currentAutomationEvent) > eventTime);
+      const previousAutomationEvent = index === -1 ? this._automationEvents[this._automationEvents.length - 1] : this._automationEvents[index - 1];
+      if (previousAutomationEvent !== void 0 && isSetValueCurveAutomationEvent(previousAutomationEvent) && getEventTime(previousAutomationEvent) + previousAutomationEvent.duration > eventTime) {
+        return false;
+      }
+      const persistentAutomationEvent = isExponentialRampToValueAutomationEvent(automationEvent) ? createExtendedExponentialRampToValueAutomationEvent(automationEvent.value, automationEvent.endTime, this._currenTime) : isLinearRampToValueAutomationEvent(automationEvent) ? createExtendedLinearRampToValueAutomationEvent(automationEvent.value, eventTime, this._currenTime) : automationEvent;
+      if (index === -1) {
+        this._automationEvents.push(persistentAutomationEvent);
+      } else {
+        if (isSetValueCurveAutomationEvent(automationEvent) && eventTime + automationEvent.duration > getEventTime(this._automationEvents[index])) {
+          return false;
+        }
+        this._automationEvents.splice(index, 0, persistentAutomationEvent);
+      }
+    }
+    return true;
+  }
+  flush(time) {
+    const index = this._automationEvents.findIndex((currentAutomationEvent) => getEventTime(currentAutomationEvent) > time);
+    if (index > 1) {
+      const remainingAutomationEvents = this._automationEvents.slice(index - 1);
+      const firstRemainingAutomationEvent = remainingAutomationEvents[0];
+      if (isSetTargetAutomationEvent(firstRemainingAutomationEvent)) {
+        remainingAutomationEvents.unshift(createSetValueAutomationEvent(getValueOfAutomationEventAtIndexAtTime(this._automationEvents, index - 2, firstRemainingAutomationEvent.startTime, this._defaultValue), firstRemainingAutomationEvent.startTime));
+      }
+      this._automationEvents = remainingAutomationEvents;
+    }
+  }
+  getValue(time) {
+    if (this._automationEvents.length === 0) {
+      return this._defaultValue;
+    }
+    const indexOfNextEvent = this._automationEvents.findIndex((automationEvent) => getEventTime(automationEvent) > time);
+    const nextAutomationEvent = this._automationEvents[indexOfNextEvent];
+    const indexOfCurrentEvent = (indexOfNextEvent === -1 ? this._automationEvents.length : indexOfNextEvent) - 1;
+    const currentAutomationEvent = this._automationEvents[indexOfCurrentEvent];
+    if (currentAutomationEvent !== void 0 && isSetTargetAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !isAnyRampToValueAutomationEvent(nextAutomationEvent) || nextAutomationEvent.insertTime > time)) {
+      return getTargetValueAtTime(time, getValueOfAutomationEventAtIndexAtTime(this._automationEvents, indexOfCurrentEvent - 1, currentAutomationEvent.startTime, this._defaultValue), currentAutomationEvent);
+    }
+    if (currentAutomationEvent !== void 0 && isSetValueAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !isAnyRampToValueAutomationEvent(nextAutomationEvent))) {
+      return currentAutomationEvent.value;
+    }
+    if (currentAutomationEvent !== void 0 && isSetValueCurveAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !isAnyRampToValueAutomationEvent(nextAutomationEvent) || currentAutomationEvent.startTime + currentAutomationEvent.duration > time)) {
+      if (time < currentAutomationEvent.startTime + currentAutomationEvent.duration) {
+        return getValueCurveValueAtTime(time, currentAutomationEvent);
+      }
+      return currentAutomationEvent.values[currentAutomationEvent.values.length - 1];
+    }
+    if (currentAutomationEvent !== void 0 && isAnyRampToValueAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !isAnyRampToValueAutomationEvent(nextAutomationEvent))) {
+      return currentAutomationEvent.value;
+    }
+    if (nextAutomationEvent !== void 0 && isExponentialRampToValueAutomationEvent(nextAutomationEvent)) {
+      const [startTime, value] = getEndTimeAndValueOfPreviousAutomationEvent(this._automationEvents, indexOfCurrentEvent, currentAutomationEvent, nextAutomationEvent, this._defaultValue);
+      return getExponentialRampValueAtTime(time, startTime, value, nextAutomationEvent);
+    }
+    if (nextAutomationEvent !== void 0 && isLinearRampToValueAutomationEvent(nextAutomationEvent)) {
+      const [startTime, value] = getEndTimeAndValueOfPreviousAutomationEvent(this._automationEvents, indexOfCurrentEvent, currentAutomationEvent, nextAutomationEvent, this._defaultValue);
+      return getLinearRampValueAtTime(time, startTime, value, nextAutomationEvent);
+    }
+    return this._defaultValue;
+  }
+}
+export {
+  AutomationEventList
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-cancel-and-hold-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createCancelAndHoldAutomationEvent = (cancelTime) => {
+  return { cancelTime, type: "cancelAndHold" };
+};
+exports.createCancelAndHoldAutomationEvent = createCancelAndHoldAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-cancel-and-hold-automation-event.js

@@ -0,0 +1,6 @@
+const createCancelAndHoldAutomationEvent = (cancelTime) => {
+  return { cancelTime, type: "cancelAndHold" };
+};
+export {
+  createCancelAndHoldAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-cancel-scheduled-values-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createCancelScheduledValuesAutomationEvent = (cancelTime) => {
+  return { cancelTime, type: "cancelScheduledValues" };
+};
+exports.createCancelScheduledValuesAutomationEvent = createCancelScheduledValuesAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-cancel-scheduled-values-automation-event.js

@@ -0,0 +1,6 @@
+const createCancelScheduledValuesAutomationEvent = (cancelTime) => {
+  return { cancelTime, type: "cancelScheduledValues" };
+};
+export {
+  createCancelScheduledValuesAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-exponential-ramp-to-value-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createExponentialRampToValueAutomationEvent = (value, endTime) => {
+  return { endTime, type: "exponentialRampToValue", value };
+};
+exports.createExponentialRampToValueAutomationEvent = createExponentialRampToValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-exponential-ramp-to-value-automation-event.js

@@ -0,0 +1,6 @@
+const createExponentialRampToValueAutomationEvent = (value, endTime) => {
+  return { endTime, type: "exponentialRampToValue", value };
+};
+export {
+  createExponentialRampToValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-extended-exponential-ramp-to-value-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createExtendedExponentialRampToValueAutomationEvent = (value, endTime, insertTime) => {
+  return { endTime, insertTime, type: "exponentialRampToValue", value };
+};
+exports.createExtendedExponentialRampToValueAutomationEvent = createExtendedExponentialRampToValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-extended-exponential-ramp-to-value-automation-event.js

@@ -0,0 +1,6 @@
+const createExtendedExponentialRampToValueAutomationEvent = (value, endTime, insertTime) => {
+  return { endTime, insertTime, type: "exponentialRampToValue", value };
+};
+export {
+  createExtendedExponentialRampToValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-extended-linear-ramp-to-value-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createExtendedLinearRampToValueAutomationEvent = (value, endTime, insertTime) => {
+  return { endTime, insertTime, type: "linearRampToValue", value };
+};
+exports.createExtendedLinearRampToValueAutomationEvent = createExtendedLinearRampToValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-extended-linear-ramp-to-value-automation-event.js

@@ -0,0 +1,6 @@
+const createExtendedLinearRampToValueAutomationEvent = (value, endTime, insertTime) => {
+  return { endTime, insertTime, type: "linearRampToValue", value };
+};
+export {
+  createExtendedLinearRampToValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-linear-ramp-to-value-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createLinearRampToValueAutomationEvent = (value, endTime) => {
+  return { endTime, type: "linearRampToValue", value };
+};
+exports.createLinearRampToValueAutomationEvent = createLinearRampToValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-linear-ramp-to-value-automation-event.js

@@ -0,0 +1,6 @@
+const createLinearRampToValueAutomationEvent = (value, endTime) => {
+  return { endTime, type: "linearRampToValue", value };
+};
+export {
+  createLinearRampToValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-set-target-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createSetTargetAutomationEvent = (target, startTime, timeConstant) => {
+  return { startTime, target, timeConstant, type: "setTarget" };
+};
+exports.createSetTargetAutomationEvent = createSetTargetAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-set-target-automation-event.js

@@ -0,0 +1,6 @@
+const createSetTargetAutomationEvent = (target, startTime, timeConstant) => {
+  return { startTime, target, timeConstant, type: "setTarget" };
+};
+export {
+  createSetTargetAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-set-value-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createSetValueAutomationEvent = (value, startTime) => {
+  return { startTime, type: "setValue", value };
+};
+exports.createSetValueAutomationEvent = createSetValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-set-value-automation-event.js

@@ -0,0 +1,6 @@
+const createSetValueAutomationEvent = (value, startTime) => {
+  return { startTime, type: "setValue", value };
+};
+export {
+  createSetValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/create-set-value-curve-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createSetValueCurveAutomationEvent = (values, startTime, duration) => {
+  return { duration, startTime, type: "setValueCurve", values };
+};
+exports.createSetValueCurveAutomationEvent = createSetValueCurveAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/create-set-value-curve-automation-event.js

@@ -0,0 +1,6 @@
+const createSetValueCurveAutomationEvent = (values, startTime, duration) => {
+  return { duration, startTime, type: "setValueCurve", values };
+};
+export {
+  createSetValueCurveAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/get-end-time-and-value-of-previous-automation-event.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getValueOfAutomationEventAtIndexAtTime = require("./get-value-of-automation-event-at-index-at-time.cjs");
+const anyRampToValueAutomationEvent = require("../guards/any-ramp-to-value-automation-event.cjs");
+const setValueAutomationEvent = require("../guards/set-value-automation-event.cjs");
+const setValueCurveAutomationEvent = require("../guards/set-value-curve-automation-event.cjs");
+const getEndTimeAndValueOfPreviousAutomationEvent = (automationEvents, index, currentAutomationEvent, nextAutomationEvent, defaultValue) => {
+  return currentAutomationEvent === void 0 ? [nextAutomationEvent.insertTime, defaultValue] : anyRampToValueAutomationEvent.isAnyRampToValueAutomationEvent(currentAutomationEvent) ? [currentAutomationEvent.endTime, currentAutomationEvent.value] : setValueAutomationEvent.isSetValueAutomationEvent(currentAutomationEvent) ? [currentAutomationEvent.startTime, currentAutomationEvent.value] : setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(currentAutomationEvent) ? [
+    currentAutomationEvent.startTime + currentAutomationEvent.duration,
+    currentAutomationEvent.values[currentAutomationEvent.values.length - 1]
+  ] : [
+    currentAutomationEvent.startTime,
+    getValueOfAutomationEventAtIndexAtTime.getValueOfAutomationEventAtIndexAtTime(automationEvents, index - 1, currentAutomationEvent.startTime, defaultValue)
+  ];
+};
+exports.getEndTimeAndValueOfPreviousAutomationEvent = getEndTimeAndValueOfPreviousAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/functions/get-end-time-and-value-of-previous-automation-event.js

@@ -0,0 +1,16 @@
+import { getValueOfAutomationEventAtIndexAtTime } from "./get-value-of-automation-event-at-index-at-time.js";
+import { isAnyRampToValueAutomationEvent } from "../guards/any-ramp-to-value-automation-event.js";
+import { isSetValueAutomationEvent } from "../guards/set-value-automation-event.js";
+import { isSetValueCurveAutomationEvent } from "../guards/set-value-curve-automation-event.js";
+const getEndTimeAndValueOfPreviousAutomationEvent = (automationEvents, index, currentAutomationEvent, nextAutomationEvent, defaultValue) => {
+  return currentAutomationEvent === void 0 ? [nextAutomationEvent.insertTime, defaultValue] : isAnyRampToValueAutomationEvent(currentAutomationEvent) ? [currentAutomationEvent.endTime, currentAutomationEvent.value] : isSetValueAutomationEvent(currentAutomationEvent) ? [currentAutomationEvent.startTime, currentAutomationEvent.value] : isSetValueCurveAutomationEvent(currentAutomationEvent) ? [
+    currentAutomationEvent.startTime + currentAutomationEvent.duration,
+    currentAutomationEvent.values[currentAutomationEvent.values.length - 1]
+  ] : [
+    currentAutomationEvent.startTime,
+    getValueOfAutomationEventAtIndexAtTime(automationEvents, index - 1, currentAutomationEvent.startTime, defaultValue)
+  ];
+};
+export {
+  getEndTimeAndValueOfPreviousAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/functions/get-event-time.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const cancelAndHoldAutomationEvent = require("../guards/cancel-and-hold-automation-event.cjs");
+const cancelScheduledValuesAutomationEvent = require("../guards/cancel-scheduled-values-automation-event.cjs");
+const exponentialRampToValueAutomationEvent = require("../guards/exponential-ramp-to-value-automation-event.cjs");
+const linearRampToValueAutomationEvent = require("../guards/linear-ramp-to-value-automation-event.cjs");
+const getEventTime = (automationEvent) => {
+  if (cancelAndHoldAutomationEvent.isCancelAndHoldAutomationEvent(automationEvent) || cancelScheduledValuesAutomationEvent.isCancelScheduledValuesAutomationEvent(automationEvent)) {
+    return automationEvent.cancelTime;
+  }
+  if (exponentialRampToValueAutomationEvent.isExponentialRampToValueAutomationEvent(automationEvent) || linearRampToValueAutomationEvent.isLinearRampToValueAutomationEvent(automationEvent)) {
+    return automationEvent.endTime;
+  }
+  return automationEvent.startTime;
+};
+exports.getEventTime = getEventTime;

package/dist/node_modules/automation-events/build/es2019/functions/get-event-time.js

@@ -0,0 +1,16 @@
+import { isCancelAndHoldAutomationEvent } from "../guards/cancel-and-hold-automation-event.js";
+import { isCancelScheduledValuesAutomationEvent } from "../guards/cancel-scheduled-values-automation-event.js";
+import { isExponentialRampToValueAutomationEvent } from "../guards/exponential-ramp-to-value-automation-event.js";
+import { isLinearRampToValueAutomationEvent } from "../guards/linear-ramp-to-value-automation-event.js";
+const getEventTime = (automationEvent) => {
+  if (isCancelAndHoldAutomationEvent(automationEvent) || isCancelScheduledValuesAutomationEvent(automationEvent)) {
+    return automationEvent.cancelTime;
+  }
+  if (isExponentialRampToValueAutomationEvent(automationEvent) || isLinearRampToValueAutomationEvent(automationEvent)) {
+    return automationEvent.endTime;
+  }
+  return automationEvent.startTime;
+};
+export {
+  getEventTime
+};

package/dist/node_modules/automation-events/build/es2019/functions/get-exponential-ramp-value-at-time.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getExponentialRampValueAtTime = (time, startTime, valueAtStartTime, { endTime, value }) => {
+  if (valueAtStartTime === value) {
+    return value;
+  }
+  if (0 < valueAtStartTime && 0 < value || valueAtStartTime < 0 && value < 0) {
+    return valueAtStartTime * (value / valueAtStartTime) ** ((time - startTime) / (endTime - startTime));
+  }
+  return 0;
+};
+exports.getExponentialRampValueAtTime = getExponentialRampValueAtTime;

package/dist/node_modules/automation-events/build/es2019/functions/get-exponential-ramp-value-at-time.js

@@ -0,0 +1,12 @@
+const getExponentialRampValueAtTime = (time, startTime, valueAtStartTime, { endTime, value }) => {
+  if (valueAtStartTime === value) {
+    return value;
+  }
+  if (0 < valueAtStartTime && 0 < value || valueAtStartTime < 0 && value < 0) {
+    return valueAtStartTime * (value / valueAtStartTime) ** ((time - startTime) / (endTime - startTime));
+  }
+  return 0;
+};
+export {
+  getExponentialRampValueAtTime
+};

package/dist/node_modules/automation-events/build/es2019/functions/get-linear-ramp-value-at-time.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getLinearRampValueAtTime = (time, startTime, valueAtStartTime, { endTime, value }) => {
+  return valueAtStartTime + (time - startTime) / (endTime - startTime) * (value - valueAtStartTime);
+};
+exports.getLinearRampValueAtTime = getLinearRampValueAtTime;

package/dist/node_modules/automation-events/build/es2019/functions/get-linear-ramp-value-at-time.js

@@ -0,0 +1,6 @@
+const getLinearRampValueAtTime = (time, startTime, valueAtStartTime, { endTime, value }) => {
+  return valueAtStartTime + (time - startTime) / (endTime - startTime) * (value - valueAtStartTime);
+};
+export {
+  getLinearRampValueAtTime
+};

package/dist/node_modules/automation-events/build/es2019/functions/get-target-value-at-time.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getTargetValueAtTime = (time, valueAtStartTime, { startTime, target, timeConstant }) => {
+  return target + (valueAtStartTime - target) * Math.exp((startTime - time) / timeConstant);
+};
+exports.getTargetValueAtTime = getTargetValueAtTime;

package/dist/node_modules/automation-events/build/es2019/functions/get-target-value-at-time.js

@@ -0,0 +1,6 @@
+const getTargetValueAtTime = (time, valueAtStartTime, { startTime, target, timeConstant }) => {
+  return target + (valueAtStartTime - target) * Math.exp((startTime - time) / timeConstant);
+};
+export {
+  getTargetValueAtTime
+};

package/dist/node_modules/automation-events/build/es2019/functions/get-value-curve-value-at-time.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interpolateValue = require("./interpolate-value.cjs");
+const getValueCurveValueAtTime = (time, { duration, startTime, values }) => {
+  const theoreticIndex = (time - startTime) / duration * (values.length - 1);
+  return interpolateValue.interpolateValue(values, theoreticIndex);
+};
+exports.getValueCurveValueAtTime = getValueCurveValueAtTime;

package/dist/node_modules/automation-events/build/es2019/functions/get-value-curve-value-at-time.js

@@ -0,0 +1,8 @@
+import { interpolateValue } from "./interpolate-value.js";
+const getValueCurveValueAtTime = (time, { duration, startTime, values }) => {
+  const theoreticIndex = (time - startTime) / duration * (values.length - 1);
+  return interpolateValue(values, theoreticIndex);
+};
+export {
+  getValueCurveValueAtTime
+};