react-audio-wavekit 0.1.5 → 0.1.6

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
+};

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getTargetValueAtTime = require("./get-target-value-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 getValueOfAutomationEventAtIndexAtTime = (automationEvents, index, time, defaultValue) => {
+  const automationEvent = automationEvents[index];
+  return automationEvent === void 0 ? defaultValue : anyRampToValueAutomationEvent.isAnyRampToValueAutomationEvent(automationEvent) || setValueAutomationEvent.isSetValueAutomationEvent(automationEvent) ? automationEvent.value : setValueCurveAutomationEvent.isSetValueCurveAutomationEvent(automationEvent) ? automationEvent.values[automationEvent.values.length - 1] : getTargetValueAtTime.getTargetValueAtTime(time, getValueOfAutomationEventAtIndexAtTime(automationEvents, index - 1, automationEvent.startTime, defaultValue), automationEvent);
+};
+exports.getValueOfAutomationEventAtIndexAtTime = getValueOfAutomationEventAtIndexAtTime;

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

@@ -0,0 +1,11 @@
+import { getTargetValueAtTime } from "./get-target-value-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 getValueOfAutomationEventAtIndexAtTime = (automationEvents, index, time, defaultValue) => {
+  const automationEvent = automationEvents[index];
+  return automationEvent === void 0 ? defaultValue : isAnyRampToValueAutomationEvent(automationEvent) || isSetValueAutomationEvent(automationEvent) ? automationEvent.value : isSetValueCurveAutomationEvent(automationEvent) ? automationEvent.values[automationEvent.values.length - 1] : getTargetValueAtTime(time, getValueOfAutomationEventAtIndexAtTime(automationEvents, index - 1, automationEvent.startTime, defaultValue), automationEvent);
+};
+export {
+  getValueOfAutomationEventAtIndexAtTime
+};

package/dist/node_modules/automation-events/build/es2019/functions/interpolate-value.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interpolateValue = (values, theoreticIndex) => {
+  const lowerIndex = Math.floor(theoreticIndex);
+  const upperIndex = Math.ceil(theoreticIndex);
+  if (lowerIndex === upperIndex) {
+    return values[lowerIndex];
+  }
+  return (1 - (theoreticIndex - lowerIndex)) * values[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * values[upperIndex];
+};
+exports.interpolateValue = interpolateValue;