https://austn.net/assets/chunk-PMM2NWUE.js

9// node_modules/automation-events/node_modules/@babel/runtime/helpers/arrayWithHoles.js
10var require_arrayWithHoles = __commonJS({
11  "node_modules/automation-events/node_modules/@babel/runtime/helpers/arrayWithHoles.js"(exports, module) {
12    function _arrayWithHoles(r) {
13      if (Array.isArray(r)) return r;
14    }
15    module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
16  }
17});
18

19// node_modules/automation-events/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js
20var require_iterableToArrayLimit = __commonJS({
21  "node_modules/automation-events/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js"(exports, module) {
22    function _iterableToArrayLimit(r, l) {
23      var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
24      if (null != t) {
25        var e, n, i, u, a = [], f = true, o = false;
26        try {
27          if (i = (t = t.call(r)).next, 0 === l) {
28            if (Object(t) !== t) return;
29            f = false;
30          } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
31        } catch (r2) {
32          o = true, n = r2;
33        } finally {
34          try {
35            if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
36          } finally {
37            if (o) throw n;
38          }
39        }
40        return a;
41      }
42    }
43    module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
44  }
45});
46

47// node_modules/automation-events/node_modules/@babel/runtime/helpers/arrayLikeToArray.js
48var require_arrayLikeToArray = __commonJS({
49  "node_modules/automation-events/node_modules/@babel/runtime/helpers/arrayLikeToArray.js"(exports, module) {
50    function _arrayLikeToArray(r, a) {
51      (null == a || a > r.length) && (a = r.length);
52      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
53      return n;
54    }
55    module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
56  }
57});
58

59// node_modules/automation-events/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js
60var require_unsupportedIterableToArray = __commonJS({
61  "node_modules/automation-events/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js"(exports, module) {
62    var arrayLikeToArray = require_arrayLikeToArray();
63    function _unsupportedIterableToArray(r, a) {
64      if (r) {
65        if ("string" == typeof r) return arrayLikeToArray(r, a);
66        var t = {}.toString.call(r).slice(8, -1);
67        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;
68      }
69    }
70    module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
71  }
72});
73

74// node_modules/automation-events/node_modules/@babel/runtime/helpers/nonIterableRest.js
75var require_nonIterableRest = __commonJS({
76  "node_modules/automation-events/node_modules/@babel/runtime/helpers/nonIterableRest.js"(exports, module) {
77    function _nonIterableRest() {
78      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
79    }
80    module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
81  }
82});
83

84// node_modules/automation-events/node_modules/@babel/runtime/helpers/slicedToArray.js
85var require_slicedToArray = __commonJS({
86  "node_modules/automation-events/node_modules/@babel/runtime/helpers/slicedToArray.js"(exports, module) {
87    var arrayWithHoles = require_arrayWithHoles();
88    var iterableToArrayLimit = require_iterableToArrayLimit();
89    var unsupportedIterableToArray = require_unsupportedIterableToArray();
90    var nonIterableRest = require_nonIterableRest();
91    function _slicedToArray(r, e) {
92      return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();
93    }
94    module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
95  }
96});
97

98// node_modules/automation-events/node_modules/@babel/runtime/helpers/classCallCheck.js
99var require_classCallCheck = __commonJS({
100  "node_modules/automation-events/node_modules/@babel/runtime/helpers/classCallCheck.js"(exports, module) {
101    function _classCallCheck(a, n) {
102      if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
103    }
104    module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
105  }
106});
107

108// node_modules/automation-events/node_modules/@babel/runtime/helpers/typeof.js
109var require_typeof = __commonJS({
110  "node_modules/automation-events/node_modules/@babel/runtime/helpers/typeof.js"(exports, module) {
111    function _typeof(o) {
112      "@babel/helpers - typeof";
113      return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
114        return typeof o2;
115      } : function(o2) {
116        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
117      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
118    }
119    module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
120  }
121});
122

123// node_modules/automation-events/node_modules/@babel/runtime/helpers/toPrimitive.js
124var require_toPrimitive = __commonJS({
125  "node_modules/automation-events/node_modules/@babel/runtime/helpers/toPrimitive.js"(exports, module) {
126    var _typeof = require_typeof()["default"];
127    function toPrimitive(t, r) {
128      if ("object" != _typeof(t) || !t) return t;
129      var e = t[Symbol.toPrimitive];
130      if (void 0 !== e) {
131        var i = e.call(t, r || "default");
132        if ("object" != _typeof(i)) return i;
133        throw new TypeError("@@toPrimitive must return a primitive value.");
134      }
135      return ("string" === r ? String : Number)(t);
136    }
137    module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
138  }
139});
140

141// node_modules/automation-events/node_modules/@babel/runtime/helpers/toPropertyKey.js
142var require_toPropertyKey = __commonJS({
143  "node_modules/automation-events/node_modules/@babel/runtime/helpers/toPropertyKey.js"(exports, module) {
144    var _typeof = require_typeof()["default"];
145    var toPrimitive = require_toPrimitive();
146    function toPropertyKey(t) {
147      var i = toPrimitive(t, "string");
148      return "symbol" == _typeof(i) ? i : i + "";
149    }
150    module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
151  }
152});
153

154// node_modules/automation-events/node_modules/@babel/runtime/helpers/createClass.js
155var require_createClass = __commonJS({
156  "node_modules/automation-events/node_modules/@babel/runtime/helpers/createClass.js"(exports, module) {
157    var toPropertyKey = require_toPropertyKey();
158    function _defineProperties(e, r) {
159      for (var t = 0; t < r.length; t++) {
160        var o = r[t];
161        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, toPropertyKey(o.key), o);
162      }
163    }
164    function _createClass(e, r, t) {
165      return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
166        writable: false
167      }), e;
168    }
169    module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
170  }
171});
172

173// node_modules/automation-events/build/es5/bundle.js
174var require_bundle = __commonJS({
175  "node_modules/automation-events/build/es5/bundle.js"(exports, module) {
176    (function(global, factory) {
177      typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require_slicedToArray(), require_classCallCheck(), require_createClass()) : typeof define === "function" && define.amd ? define(["exports", "@babel/runtime/helpers/slicedToArray", "@babel/runtime/helpers/classCallCheck", "@babel/runtime/helpers/createClass"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.automationEvents = {}, global._slicedToArray, global._classCallCheck, global._createClass));
178    })(exports, function(exports2, _slicedToArray, _classCallCheck, _createClass) {
179      "use strict";
180      var createExtendedExponentialRampToValueAutomationEvent = function createExtendedExponentialRampToValueAutomationEvent2(value, endTime, insertTime) {
181        return {
182          endTime,
183          insertTime,
184          type: "exponentialRampToValue",
185          value
186        };
187      };
188      var createExtendedLinearRampToValueAutomationEvent = function createExtendedLinearRampToValueAutomationEvent2(value, endTime, insertTime) {
189        return {
190          endTime,
191          insertTime,
192          type: "linearRampToValue",
193          value
194        };
195      };
196      var createSetValueAutomationEvent2 = function createSetValueAutomationEvent3(value, startTime) {
197        return {
198          startTime,
199          type: "setValue",
200          value
201        };
202      };
203      var createSetValueCurveAutomationEvent2 = function createSetValueCurveAutomationEvent3(values, startTime, duration) {
204        return {
205          duration,
206          startTime,
207          type: "setValueCurve",
208          values
209        };
210      };
211      var getTargetValueAtTime = function getTargetValueAtTime2(time, valueAtStartTime, _ref) {
212        var startTime = _ref.startTime, target = _ref.target, timeConstant = _ref.timeConstant;
213        return target + (valueAtStartTime - target) * Math.exp((startTime - time) / timeConstant);
214      };
215      var isExponentialRampToValueAutomationEvent = function isExponentialRampToValueAutomationEvent2(automationEvent) {
216        return automationEvent.type === "exponentialRampToValue";
217      };
218      var isLinearRampToValueAutomationEvent = function isLinearRampToValueAutomationEvent2(automationEvent) {
219        return automationEvent.type === "linearRampToValue";
220      };
221      var isAnyRampToValueAutomationEvent = function isAnyRampToValueAutomationEvent2(automationEvent) {
222        return isExponentialRampToValueAutomationEvent(automationEvent) || isLinearRampToValueAutomationEvent(automationEvent);
223      };
224      var isSetValueAutomationEvent = function isSetValueAutomationEvent2(automationEvent) {
225        return automationEvent.type === "setValue";
226      };
227      var isSetValueCurveAutomationEvent = function isSetValueCurveAutomationEvent2(automationEvent) {
228        return automationEvent.type === "setValueCurve";
229      };
230      var _getValueOfAutomationEventAtIndexAtTime = function getValueOfAutomationEventAtIndexAtTime(automationEvents, index, time, defaultValue) {
231        var automationEvent = automationEvents[index];
232        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);
233      };
234      var getEndTimeAndValueOfPreviousAutomationEvent = function getEndTimeAndValueOfPreviousAutomationEvent2(automationEvents, index, currentAutomationEvent, nextAutomationEvent, defaultValue) {
235        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)];
236      };
237      var isCancelAndHoldAutomationEvent = function isCancelAndHoldAutomationEvent2(automationEvent) {
238        return automationEvent.type === "cancelAndHold";
239      };
240      var isCancelScheduledValuesAutomationEvent = function isCancelScheduledValuesAutomationEvent2(automationEvent) {
241        return automationEvent.type === "cancelScheduledValues";
242      };
243      var getEventTime = function getEventTime2(automationEvent) {
244        if (isCancelAndHoldAutomationEvent(automationEvent) || isCancelScheduledValuesAutomationEvent(automationEvent)) {
245          return automationEvent.cancelTime;
246        }
247        if (isExponentialRampToValueAutomationEvent(automationEvent) || isLinearRampToValueAutomationEvent(automationEvent)) {
248          return automationEvent.endTime;
249        }
250        return automationEvent.startTime;
251      };
252      var getExponentialRampValueAtTime = function getExponentialRampValueAtTime2(time, startTime, valueAtStartTime, _ref) {
253        var endTime = _ref.endTime, value = _ref.value;
254        if (valueAtStartTime === value) {
255          return value;
256        }
257        if (0 < valueAtStartTime && 0 < value || valueAtStartTime < 0 && value < 0) {
258          return valueAtStartTime * Math.pow(value / valueAtStartTime, (time - startTime) / (endTime - startTime));
259        }
260        return 0;
261      };
262      var getLinearRampValueAtTime = function getLinearRampValueAtTime2(time, startTime, valueAtStartTime, _ref) {
263        var endTime = _ref.endTime, value = _ref.value;
264        return valueAtStartTime + (time - startTime) / (endTime - startTime) * (value - valueAtStartTime);
265      };
266      var interpolateValue = function interpolateValue2(values, theoreticIndex) {
267        var lowerIndex = Math.floor(theoreticIndex);
268        var upperIndex = Math.ceil(theoreticIndex);
269        if (lowerIndex === upperIndex) {
270          return values[lowerIndex];
271        }
272        return (1 - (theoreticIndex - lowerIndex)) * values[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * values[upperIndex];
273      };
274      var getValueCurveValueAtTime = function getValueCurveValueAtTime2(time, _ref) {
275        var duration = _ref.duration, startTime = _ref.startTime, values = _ref.values;
276        var theoreticIndex = (time - startTime) / duration * (values.length - 1);
277        return interpolateValue(values, theoreticIndex);
278      };
279      var isSetTargetAutomationEvent = function isSetTargetAutomationEvent2(automationEvent) {
280        return automationEvent.type === "setTarget";
281      };
282      var AutomationEventList2 = /* @__PURE__ */ function() {
283        function AutomationEventList3(defaultValue) {
284          _classCallCheck(this, AutomationEventList3);
285          this._automationEvents = [];
286          this._currenTime = 0;
287          this._defaultValue = defaultValue;
288        }
289        return _createClass(AutomationEventList3, [{
290          key: Symbol.iterator,
291          value: function value() {
292            return this._automationEvents[Symbol.iterator]();
293          }
294        }, {
295          key: "add",
296          value: function add(automationEvent) {
297            var eventTime = getEventTime(automationEvent);
298            if (isCancelAndHoldAutomationEvent(automationEvent) || isCancelScheduledValuesAutomationEvent(automationEvent)) {
299              var index = this._automationEvents.findIndex(function(currentAutomationEvent) {
300                if (isCancelScheduledValuesAutomationEvent(automationEvent) && isSetValueCurveAutomationEvent(currentAutomationEvent)) {
301                  return currentAutomationEvent.startTime + currentAutomationEvent.duration >= eventTime;
302                }
303                return getEventTime(currentAutomationEvent) >= eventTime;
304              });
305              var removedAutomationEvent = this._automationEvents[index];
306              if (index !== -1) {
307                this._automationEvents = this._automationEvents.slice(0, index);
308              }
309              if (isCancelAndHoldAutomationEvent(automationEvent)) {
310                var lastAutomationEvent = this._automationEvents[this._automationEvents.length - 1];
311                if (removedAutomationEvent !== void 0 && isAnyRampToValueAutomationEvent(removedAutomationEvent)) {
312                  if (lastAutomationEvent !== void 0 && isSetTargetAutomationEvent(lastAutomationEvent)) {
313                    throw new Error("The internal list is malformed.");
314                  }
315                  var startTime = lastAutomationEvent === void 0 ? removedAutomationEvent.insertTime : isSetValueCurveAutomationEvent(lastAutomationEvent) ? lastAutomationEvent.startTime + lastAutomationEvent.duration : getEventTime(lastAutomationEvent);
316                  var startValue = lastAutomationEvent === void 0 ? this._defaultValue : isSetValueCurveAutomationEvent(lastAutomationEvent) ? lastAutomationEvent.values[lastAutomationEvent.values.length - 1] : lastAutomationEvent.value;
317                  var value = isExponentialRampToValueAutomationEvent(removedAutomationEvent) ? getExponentialRampValueAtTime(eventTime, startTime, startValue, removedAutomationEvent) : getLinearRampValueAtTime(eventTime, startTime, startValue, removedAutomationEvent);
318                  var truncatedAutomationEvent = isExponentialRampToValueAutomationEvent(removedAutomationEvent) ? createExtendedExponentialRampToValueAutomationEvent(value, eventTime, this._currenTime) : createExtendedLinearRampToValueAutomationEvent(value, eventTime, this._currenTime);
319                  this._automationEvents.push(truncatedAutomationEvent);
320                }
321                if (lastAutomationEvent !== void 0 && isSetTargetAutomationEvent(lastAutomationEvent)) {
322                  this._automationEvents.push(createSetValueAutomationEvent2(this.getValue(eventTime), eventTime));
323                }
324                if (lastAutomationEvent !== void 0 && isSetValueCurveAutomationEvent(lastAutomationEvent) && lastAutomationEvent.startTime + lastAutomationEvent.duration > eventTime) {
325                  var duration = eventTime - lastAutomationEvent.startTime;
326                  var ratio = (lastAutomationEvent.values.length - 1) / lastAutomationEvent.duration;
327                  var length = Math.max(2, 1 + Math.ceil(duration * ratio));
328                  var fraction = duration / (length - 1) * ratio;
329                  var values = lastAutomationEvent.values.slice(0, length);
330                  if (fraction < 1) {
331                    for (var i = 1; i < length; i += 1) {
332                      var factor = fraction * i % 1;
333                      values[i] = lastAutomationEvent.values[i - 1] * (1 - factor) + lastAutomationEvent.values[i] * factor;
334                    }
335                  }
336                  this._automationEvents[this._automationEvents.length - 1] = createSetValueCurveAutomationEvent2(values, lastAutomationEvent.startTime, duration);
337                }
338              }
339            } else {
340              var _index = this._automationEvents.findIndex(function(currentAutomationEvent) {
341                return getEventTime(currentAutomationEvent) > eventTime;
342              });
343              var previousAutomationEvent = _index === -1 ? this._automationEvents[this._automationEvents.length - 1] : this._automationEvents[_index - 1];
344              if (previousAutomationEvent !== void 0 && isSetValueCurveAutomationEvent(previousAutomationEvent) && getEventTime(previousAutomationEvent) + previousAutomationEvent.duration > eventTime) {
345                return false;
346              }
347              var persistentAutomationEvent = isExponentialRampToValueAutomationEvent(automationEvent) ? createExtendedExponentialRampToValueAutomationEvent(automationEvent.value, automationEvent.endTime, this._currenTime) : isLinearRampToValueAutomationEvent(automationEvent) ? createExtendedLinearRampToValueAutomationEvent(automationEvent.value, eventTime, this._currenTime) : automationEvent;
348              if (_index === -1) {
349                this._automationEvents.push(persistentAutomationEvent);
350              } else {
351                if (isSetValueCurveAutomationEvent(automationEvent) && eventTime + automationEvent.duration > getEventTime(this._automationEvents[_index])) {
352                  return false;
353                }
354                this._automationEvents.splice(_index, 0, persistentAutomationEvent);
355              }
356            }
357            return true;
358          }
359        }, {
360          key: "flush",
361          value: function flush(time) {
362            var index = this._automationEvents.findIndex(function(currentAutomationEvent) {
363              return getEventTime(currentAutomationEvent) > time;
364            });
365            if (index > 1) {
366              var remainingAutomationEvents = this._automationEvents.slice(index - 1);
367              var firstRemainingAutomationEvent = remainingAutomationEvents[0];
368              if (isSetTargetAutomationEvent(firstRemainingAutomationEvent)) {
369                remainingAutomationEvents.unshift(createSetValueAutomationEvent2(_getValueOfAutomationEventAtIndexAtTime(this._automationEvents, index - 2, firstRemainingAutomationEvent.startTime, this._defaultValue), firstRemainingAutomationEvent.startTime));
370              }
371              this._automationEvents = remainingAutomationEvents;
372            }
373          }
374        }, {
375          key: "getValue",
376          value: function getValue(time) {
377            if (this._automationEvents.length === 0) {
378              return this._defaultValue;
379            }
380            var indexOfNextEvent = this._automationEvents.findIndex(function(automationEvent) {
381              return getEventTime(automationEvent) > time;
382            });
383            var nextAutomationEvent = this._automationEvents[indexOfNextEvent];
384            var indexOfCurrentEvent = (indexOfNextEvent === -1 ? this._automationEvents.length : indexOfNextEvent) - 1;
385            var currentAutomationEvent = this._automationEvents[indexOfCurrentEvent];
386            if (currentAutomationEvent !== void 0 && isSetTargetAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !isAnyRampToValueAutomationEvent(nextAutomationEvent) || nextAutomationEvent.insertTime > time)) {
387              return getTargetValueAtTime(time, _getValueOfAutomationEventAtIndexAtTime(this._automationEvents, indexOfCurrentEvent - 1, currentAutomationEvent.startTime, this._defaultValue), currentAutomationEvent);
388            }
389            if (currentAutomationEvent !== void 0 && isSetValueAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !isAnyRampToValueAutomationEvent(nextAutomationEvent))) {
390              return currentAutomationEvent.value;
391            }
392            if (currentAutomationEvent !== void 0 && isSetValueCurveAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !isAnyRampToValueAutomationEvent(nextAutomationEvent) || currentAutomationEvent.startTime + currentAutomationEvent.duration > time)) {
393              if (time < currentAutomationEvent.startTime + currentAutomationEvent.duration) {
394                return getValueCurveValueAtTime(time, currentAutomationEvent);
395              }
396              return currentAutomationEvent.values[currentAutomationEvent.values.length - 1];
397            }
398            if (currentAutomationEvent !== void 0 && isAnyRampToValueAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === void 0 || !isAnyRampToValueAutomationEvent(nextAutomationEvent))) {
399              return currentAutomationEvent.value;
400            }
401            if (nextAutomationEvent !== void 0 && isExponentialRampToValueAutomationEvent(nextAutomationEvent)) {
402              var _getEndTimeAndValueOf = getEndTimeAndValueOfPreviousAutomationEvent(this._automationEvents, indexOfCurrentEvent, currentAutomationEvent, nextAutomationEvent, this._defaultValue), _getEndTimeAndValueOf2 = _slicedToArray(_getEndTimeAndValueOf, 2), startTime = _getEndTimeAndValueOf2[0], value = _getEndTimeAndValueOf2[1];
403              return getExponentialRampValueAtTime(time, startTime, value, nextAutomationEvent);
404            }
405            if (nextAutomationEvent !== void 0 && isLinearRampToValueAutomationEvent(nextAutomationEvent)) {
406              var _getEndTimeAndValueOf3 = getEndTimeAndValueOfPreviousAutomationEvent(this._automationEvents, indexOfCurrentEvent, currentAutomationEvent, nextAutomationEvent, this._defaultValue), _getEndTimeAndValueOf4 = _slicedToArray(_getEndTimeAndValueOf3, 2), _startTime = _getEndTimeAndValueOf4[0], _value = _getEndTimeAndValueOf4[1];
407              return getLinearRampValueAtTime(time, _startTime, _value, nextAutomationEvent);
408            }
409            return this._defaultValue;
410          }
411        }]);
412      }();
413      var createCancelAndHoldAutomationEvent2 = function createCancelAndHoldAutomationEvent3(cancelTime) {
414        return {
415          cancelTime,
416          type: "cancelAndHold"
417        };
418      };
419      var createCancelScheduledValuesAutomationEvent2 = function createCancelScheduledValuesAutomationEvent3(cancelTime) {
420        return {
421          cancelTime,
422          type: "cancelScheduledValues"
423        };
424      };
425      var createExponentialRampToValueAutomationEvent2 = function createExponentialRampToValueAutomationEvent3(value, endTime) {
426        return {
427          endTime,
428          type: "exponentialRampToValue",
429          value
430        };
431      };
432      var createLinearRampToValueAutomationEvent2 = function createLinearRampToValueAutomationEvent3(value, endTime) {
433        return {
434          endTime,
435          type: "linearRampToValue",
436          value
437        };
438      };
439      var createSetTargetAutomationEvent2 = function createSetTargetAutomationEvent3(target, startTime, timeConstant) {
440        return {
441          startTime,
442          target,
443          timeConstant,
444          type: "setTarget"
445        };
446      };
447      exports2.AutomationEventList = AutomationEventList2;
448      exports2.createCancelAndHoldAutomationEvent = createCancelAndHoldAutomationEvent2;
449      exports2.createCancelScheduledValuesAutomationEvent = createCancelScheduledValuesAutomationEvent2;
450      exports2.createExponentialRampToValueAutomationEvent = createExponentialRampToValueAutomationEvent2;
451      exports2.createLinearRampToValueAutomationEvent = createLinearRampToValueAutomationEvent2;
452      exports2.createSetTargetAutomationEvent = createSetTargetAutomationEvent2;
453      exports2.createSetValueAutomationEvent = createSetValueAutomationEvent2;
454      exports2.createSetValueCurveAutomationEvent = createSetValueCurveAutomationEvent2;
455    });
456  }
457});
458

459// node_modules/fft.js/lib/fft.js
460var require_fft = __commonJS({
461  "node_modules/fft.js/lib/fft.js"(exports, module) {
462    "use strict";
463    function FFT3(size) {
464      this.size = size | 0;
465      if (this.size <= 1 || (this.size & this.size - 1) !== 0)
466        throw new Error("FFT size must be a power of two and bigger than 1");
467      this._csize = size << 1;
468      var table = new Array(this.size * 2);
469      for (var i = 0; i < table.length; i += 2) {
470        const angle = Math.PI * i / this.size;
471        table[i] = Math.cos(angle);
472        table[i + 1] = -Math.sin(angle);
473      }
474      this.table = table;
475      var power = 0;
476      for (var t = 1; this.size > t; t <<= 1)
477        power++;
478      this._width = power % 2 === 0 ? power - 1 : power;
479      this._bitrev = new Array(1 << this._width);
480      for (var j = 0; j < this._bitrev.length; j++) {
481        this._bitrev[j] = 0;
482        for (var shift = 0; shift < this._width; shift += 2) {
483          var revShift = this._width - shift - 2;
484          this._bitrev[j] |= (j >>> shift & 3) << revShift;
485        }
486      }
487      this._out = null;
488      this._data = null;
489      this._inv = 0;
490    }
491    module.exports = FFT3;
492    FFT3.prototype.fromComplexArray = function fromComplexArray(complex, storage) {
493      var res = storage || new Array(complex.length >>> 1);
494      for (var i = 0; i < complex.length; i += 2)
495        res[i >>> 1] = complex[i];
496      return res;
497    };
498    FFT3.prototype.createComplexArray = function createComplexArray() {
499      const res = new Array(this._csize);
500      for (var i = 0; i < res.length; i++)
501        res[i] = 0;
502      return res;
503    };
504    FFT3.prototype.toComplexArray = function toComplexArray(input, storage) {
505      var res = storage || this.createComplexArray();
506      for (var i = 0; i < res.length; i += 2) {
507        res[i] = input[i >>> 1];
508        res[i + 1] = 0;
509      }
510      return res;
511    };
512    FFT3.prototype.completeSpectrum = function completeSpectrum(spectrum) {
513      var size = this._csize;
514      var half = size >>> 1;
515      for (var i = 2; i < half; i += 2) {
516        spectrum[size - i] = spectrum[i];
517        spectrum[size - i + 1] = -spectrum[i + 1];
518      }
519    };
520    FFT3.prototype.transform = function transform(out, data) {
521      if (out === data)
522        throw new Error("Input and output buffers must be different");
523      this._out = out;
524      this._data = data;
525      this._inv = 0;
526      this._transform4();
527      this._out = null;
528      this._data = null;
529    };
530    FFT3.prototype.realTransform = function realTransform(out, data) {
531      if (out === data)
532        throw new Error("Input and output buffers must be different");
533      this._out = out;
534      this._data = data;
535      this._inv = 0;
536      this._realTransform4();
537      this._out = null;
538      this._data = null;
539    };
540    FFT3.prototype.inverseTransform = function inverseTransform(out, data) {
541      if (out === data)
542        throw new Error("Input and output buffers must be different");
543      this._out = out;
544      this._data = data;
545      this._inv = 1;
546      this._transform4();
547      for (var i = 0; i < out.length; i++)
548        out[i] /= this.size;
549      this._out = null;
550      this._data = null;
551    };
552    FFT3.prototype._transform4 = function _transform4() {
553      var out = this._out;
554      var size = this._csize;
555      var width = this._width;
556      var step = 1 << width;
557      var len = size / step << 1;
558      var outOff;
559      var t;
560      var bitrev = this._bitrev;
561      if (len === 4) {
562        for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
563          const off = bitrev[t];
564          this._singleTransform2(outOff, off, step);
565        }
566      } else {
567        for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
568          const off = bitrev[t];
569          this._singleTransform4(outOff, off, step);
570        }
571      }
572      var inv = this._inv ? -1 : 1;
573      var table = this.table;
574      for (step >>= 2; step >= 2; step >>= 2) {
575        len = size / step << 1;
576        var quarterLen = len >>> 2;
577        for (outOff = 0; outOff < size; outOff += len) {
578          var limit = outOff + quarterLen;
579          for (var i = outOff, k = 0; i < limit; i += 2, k += step) {
580            const A = i;
581            const B = A + quarterLen;
582            const C = B + quarterLen;
583            const D = C + quarterLen;
584            const Ar = out[A];
585            const Ai = out[A + 1];
586            const Br = out[B];
587            const Bi = out[B + 1];
588            const Cr = out[C];
589            const Ci = out[C + 1];
590            const Dr = out[D];
591            const Di = out[D + 1];
592            const MAr = Ar;
593            const MAi = Ai;
594            const tableBr = table[k];
595            const tableBi = inv * table[k + 1];
596            const MBr = Br * tableBr - Bi * tableBi;
597            const MBi = Br * tableBi + Bi * tableBr;
598            const tableCr = table[2 * k];
599            const tableCi = inv * table[2 * k + 1];
600            const MCr = Cr * tableCr - Ci * tableCi;
601            const MCi = Cr * tableCi + Ci * tableCr;
602            const tableDr = table[3 * k];
603            const tableDi = inv * table[3 * k + 1];
604            const MDr = Dr * tableDr - Di * tableDi;
605            const MDi = Dr * tableDi + Di * tableDr;
606            const T0r = MAr + MCr;
607            const T0i = MAi + MCi;
608            const T1r = MAr - MCr;
609            const T1i = MAi - MCi;
610            const T2r = MBr + MDr;
611            const T2i = MBi + MDi;
612            const T3r = inv * (MBr - MDr);
613            const T3i = inv * (MBi - MDi);
614            const FAr = T0r + T2r;
615            const FAi = T0i + T2i;
616            const FCr = T0r - T2r;
617            const FCi = T0i - T2i;
618            const FBr = T1r + T3i;
619            const FBi = T1i - T3r;
620            const FDr = T1r - T3i;
621            const FDi = T1i + T3r;
622            out[A] = FAr;
623            out[A + 1] = FAi;
624            out[B] = FBr;
625            out[B + 1] = FBi;
626            out[C] = FCr;
627            out[C + 1] = FCi;
628            out[D] = FDr;
629            out[D + 1] = FDi;
630          }
631        }
632      }
633    };
634    FFT3.prototype._singleTransform2 = function _singleTransform2(outOff, off, step) {
635      const out = this._out;
636      const data = this._data;
637      const evenR = data[off];
638      const evenI = data[off + 1];
639      const oddR = data[off + step];
640      const oddI = data[off + step + 1];
641      const leftR = evenR + oddR;
642      const leftI = evenI + oddI;
643      const rightR = evenR - oddR;
644      const rightI = evenI - oddI;
645      out[outOff] = leftR;
646      out[outOff + 1] = leftI;
647      out[outOff + 2] = rightR;
648      out[outOff + 3] = rightI;
649    };
650    FFT3.prototype._singleTransform4 = function _singleTransform4(outOff, off, step) {
651      const out = this._out;
652      const data = this._data;
653      const inv = this._inv ? -1 : 1;
654      const step2 = step * 2;
655      const step3 = step * 3;
656      const Ar = data[off];
657      const Ai = data[off + 1];
658      const Br = data[off + step];
659      const Bi = data[off + step + 1];
660      const Cr = data[off + step2];
661      const Ci = data[off + step2 + 1];
662      const Dr = data[off + step3];
663      const Di = data[off + step3 + 1];
664      const T0r = Ar + Cr;
665      const T0i = Ai + Ci;
666      const T1r = Ar - Cr;
667      const T1i = Ai - Ci;
668      const T2r = Br + Dr;
669      const T2i = Bi + Di;
670      const T3r = inv * (Br - Dr);
671      const T3i = inv * (Bi - Di);
672      const FAr = T0r + T2r;
673      const FAi = T0i + T2i;
674      const FBr = T1r + T3i;
675      const FBi = T1i - T3r;
676      const FCr = T0r - T2r;
677      const FCi = T0i - T2i;
678      const FDr = T1r - T3i;
679      const FDi = T1i + T3r;
680      out[outOff] = FAr;
681      out[outOff + 1] = FAi;
682      out[outOff + 2] = FBr;
683      out[outOff + 3] = FBi;
684      out[outOff + 4] = FCr;
685      out[outOff + 5] = FCi;
686      out[outOff + 6] = FDr;
687      out[outOff + 7] = FDi;
688    };
689    FFT3.prototype._realTransform4 = function _realTransform4() {
690      var out = this._out;
691      var size = this._csize;
692      var width = this._width;
693      var step = 1 << width;
694      var len = size / step << 1;
695      var outOff;
696      var t;
697      var bitrev = this._bitrev;
698      if (len === 4) {
699        for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
700          const off = bitrev[t];
701          this._singleRealTransform2(outOff, off >>> 1, step >>> 1);
702        }
703      } else {
704        for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
705          const off = bitrev[t];
706          this._singleRealTransform4(outOff, off >>> 1, step >>> 1);
707        }
708      }
709      var inv = this._inv ? -1 : 1;
710      var table = this.table;
711      for (step >>= 2; step >= 2; step >>= 2) {
712        len = size / step << 1;
713        var halfLen = len >>> 1;
714        var quarterLen = halfLen >>> 1;
715        var hquarterLen = quarterLen >>> 1;
716        for (outOff = 0; outOff < size; outOff += len) {
717          for (var i = 0, k = 0; i <= hquarterLen; i += 2, k += step) {
718            var A = outOff + i;
719            var B = A + quarterLen;
720            var C = B + quarterLen;
721            var D = C + quarterLen;
722            var Ar = out[A];
723            var Ai = out[A + 1];
724            var Br = out[B];
725            var Bi = out[B + 1];
726            var Cr = out[C];
727            var Ci = out[C + 1];
728            var Dr = out[D];
729            var Di = out[D + 1];
730            var MAr = Ar;
731            var MAi = Ai;
732            var tableBr = table[k];
733            var tableBi = inv * table[k + 1];
734            var MBr = Br * tableBr - Bi * tableBi;
735            var MBi = Br * tableBi + Bi * tableBr;
736            var tableCr = table[2 * k];
737            var tableCi = inv * table[2 * k + 1];
738            var MCr = Cr * tableCr - Ci * tableCi;
739            var MCi = Cr * tableCi + Ci * tableCr;
740            var tableDr = table[3 * k];
741            var tableDi = inv * table[3 * k + 1];
742            var MDr = Dr * tableDr - Di * tableDi;
743            var MDi = Dr * tableDi + Di * tableDr;
744            var T0r = MAr + MCr;
745            var T0i = MAi + MCi;
746            var T1r = MAr - MCr;
747            var T1i = MAi - MCi;
748            var T2r = MBr + MDr;
749            var T2i = MBi + MDi;
750            var T3r = inv * (MBr - MDr);
751            var T3i = inv * (MBi - MDi);
752            var FAr = T0r + T2r;
753            var FAi = T0i + T2i;
754            var FBr = T1r + T3i;
755            var FBi = T1i - T3r;
756            out[A] = FAr;
757            out[A + 1] = FAi;
758            out[B] = FBr;
759            out[B + 1] = FBi;
760            if (i === 0) {
761              var FCr = T0r - T2r;
762              var FCi = T0i - T2i;
763              out[C] = FCr;
764              out[C + 1] = FCi;
765              continue;
766            }
767            if (i === hquarterLen)
768              continue;
769            var ST0r = T1r;
770            var ST0i = -T1i;
771            var ST1r = T0r;
772            var ST1i = -T0i;
773            var ST2r = -inv * T3i;
774            var ST2i = -inv * T3r;
775            var ST3r = -inv * T2i;
776            var ST3i = -inv * T2r;
777            var SFAr = ST0r + ST2r;
778            var SFAi = ST0i + ST2i;
779            var SFBr = ST1r + ST3i;
780            var SFBi = ST1i - ST3r;
781            var SA = outOff + quarterLen - i;
782            var SB = outOff + halfLen - i;
783            out[SA] = SFAr;
784            out[SA + 1] = SFAi;
785            out[SB] = SFBr;
786            out[SB + 1] = SFBi;
787          }
788        }
789      }
790    };
791    FFT3.prototype._singleRealTransform2 = function _singleRealTransform2(outOff, off, step) {
792      const out = this._out;
793      const data = this._data;
794      const evenR = data[off];
795      const oddR = data[off + step];
796      const leftR = evenR + oddR;
797      const rightR = evenR - oddR;
798      out[outOff] = leftR;
799      out[outOff + 1] = 0;
800      out[outOff + 2] = rightR;
801      out[outOff + 3] = 0;
802    };
803    FFT3.prototype._singleRealTransform4 = function _singleRealTransform4(outOff, off, step) {
804      const out = this._out;
805      const data = this._data;
806      const inv = this._inv ? -1 : 1;
807      const step2 = step * 2;
808      const step3 = step * 3;
809      const Ar = data[off];
810      const Br = data[off + step];
811      const Cr = data[off + step2];
812      const Dr = data[off + step3];
813      const T0r = Ar + Cr;
814      const T1r = Ar - Cr;
815      const T2r = Br + Dr;
816      const T3r = inv * (Br - Dr);
817      const FAr = T0r + T2r;
818      const FBr = T1r;
819      const FBi = -T3r;
820      const FCr = T0r - T2r;
821      const FDr = T1r;
822      const FDi = T3r;
823      out[outOff] = FAr;
824      out[outOff + 1] = 0;
825      out[outOff + 2] = FBr;
826      out[outOff + 3] = FBi;
827      out[outOff + 4] = FCr;
828      out[outOff + 5] = 0;
829      out[outOff + 6] = FDr;
830      out[outOff + 7] = FDi;
831    };
832  }
833});
834

1492// node_modules/tone/build/esm/version.js
1493var version = "15.1.22";
1494

1495// node_modules/standardized-audio-context/build/es2019/module.js
1496var import_automation_events2 = __toESM(require_bundle());
1497

1498// node_modules/standardized-audio-context/build/es2019/factories/abort-error.js
1499var createAbortError = () => new DOMException("", "AbortError");
1500

1501// node_modules/standardized-audio-context/build/es2019/factories/add-active-input-connection-to-audio-node.js
1502var createAddActiveInputConnectionToAudioNode = (insertElementInSet2) => {
1503  return (activeInputs, source, [output, input, eventListener], ignoreDuplicates) => {
1504    insertElementInSet2(activeInputs[input], [source, output, eventListener], (activeInputConnection) => activeInputConnection[0] === source && activeInputConnection[1] === output, ignoreDuplicates);
1505  };
1506};
1507

1508// node_modules/standardized-audio-context/build/es2019/factories/add-audio-node-connections.js
1509var createAddAudioNodeConnections = (audioNodeConnectionsStore) => {
1510  return (audioNode, audioNodeRenderer, nativeAudioNode) => {
1511    const activeInputs = [];
1512    for (let i = 0; i < nativeAudioNode.numberOfInputs; i += 1) {
1513      activeInputs.push(/* @__PURE__ */ new Set());
1514    }
1515    audioNodeConnectionsStore.set(audioNode, {
1516      activeInputs,
1517      outputs: /* @__PURE__ */ new Set(),
1518      passiveInputs: /* @__PURE__ */ new WeakMap(),
1519      renderer: audioNodeRenderer
1520    });
1521  };
1522};
1523

1524// node_modules/standardized-audio-context/build/es2019/factories/add-audio-param-connections.js
1525var createAddAudioParamConnections = (audioParamConnectionsStore) => {
1526  return (audioParam, audioParamRenderer) => {
1527    audioParamConnectionsStore.set(audioParam, { activeInputs: /* @__PURE__ */ new Set(), passiveInputs: /* @__PURE__ */ new WeakMap(), renderer: audioParamRenderer });
1528  };
1529};
1530

1531// node_modules/standardized-audio-context/build/es2019/globals.js
1532var ACTIVE_AUDIO_NODE_STORE = /* @__PURE__ */ new WeakSet();
1533var AUDIO_NODE_CONNECTIONS_STORE = /* @__PURE__ */ new WeakMap();
1534var AUDIO_NODE_STORE = /* @__PURE__ */ new WeakMap();
1535var AUDIO_PARAM_CONNECTIONS_STORE = /* @__PURE__ */ new WeakMap();
1536var AUDIO_PARAM_STORE = /* @__PURE__ */ new WeakMap();
1537var CONTEXT_STORE = /* @__PURE__ */ new WeakMap();
1538var EVENT_LISTENERS = /* @__PURE__ */ new WeakMap();
1539var CYCLE_COUNTERS = /* @__PURE__ */ new WeakMap();
1540var NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS = /* @__PURE__ */ new WeakMap();
1541var NODE_TO_PROCESSOR_MAPS = /* @__PURE__ */ new WeakMap();
1542

1543// node_modules/standardized-audio-context/build/es2019/helpers/is-constructible.js
1544var handler = {
1545  construct() {
1546    return handler;
1547  }
1548};
1549var isConstructible = (constructible) => {
1550  try {
1551    const proxy = new Proxy(constructible, handler);
1552    new proxy();
1553  } catch {
1554    return false;
1555  }
1556  return true;
1557};
1558

1559// node_modules/standardized-audio-context/build/es2019/helpers/split-import-statements.js
1560var IMPORT_STATEMENT_REGEX = /^import(?:(?:[\s]+[\w]+|(?:[\s]+[\w]+[\s]*,)?[\s]*\{[\s]*[\w]+(?:[\s]+as[\s]+[\w]+)?(?:[\s]*,[\s]*[\w]+(?:[\s]+as[\s]+[\w]+)?)*[\s]*}|(?:[\s]+[\w]+[\s]*,)?[\s]*\*[\s]+as[\s]+[\w]+)[\s]+from)?(?:[\s]*)("([^"\\]|\\.)+"|'([^'\\]|\\.)+')(?:[\s]*);?/;
1561var splitImportStatements = (source, url) => {
1562  const importStatements = [];
1563  let sourceWithoutImportStatements = source.replace(/^[\s]+/, "");
1564  let result = sourceWithoutImportStatements.match(IMPORT_STATEMENT_REGEX);
1565  while (result !== null) {
1566    const unresolvedUrl = result[1].slice(1, -1);
1567    const importStatementWithResolvedUrl = result[0].replace(/([\s]+)?;?$/, "").replace(unresolvedUrl, new URL(unresolvedUrl, url).toString());
1568    importStatements.push(importStatementWithResolvedUrl);
1569    sourceWithoutImportStatements = sourceWithoutImportStatements.slice(result[0].length).replace(/^[\s]+/, "");
1570    result = sourceWithoutImportStatements.match(IMPORT_STATEMENT_REGEX);
1571  }
1572  return [importStatements.join(";"), sourceWithoutImportStatements];
1573};
1574

1575// node_modules/standardized-audio-context/build/es2019/factories/add-audio-worklet-module.js
1576var verifyParameterDescriptors = (parameterDescriptors) => {
1577  if (parameterDescriptors !== void 0 && !Array.isArray(parameterDescriptors)) {
1578    throw new TypeError("The parameterDescriptors property of given value for processorCtor is not an array.");
1579  }
1580};
1581var verifyProcessorCtor = (processorCtor) => {
1582  if (!isConstructible(processorCtor)) {
1583    throw new TypeError("The given value for processorCtor should be a constructor.");
1584  }
1585  if (processorCtor.prototype === null || typeof processorCtor.prototype !== "object") {
1586    throw new TypeError("The given value for processorCtor should have a prototype.");
1587  }
1588};
1589var createAddAudioWorkletModule = (cacheTestResult2, createNotSupportedError2, evaluateSource, exposeCurrentFrameAndCurrentTime2, fetchSource, getNativeContext2, getOrCreateBackupOfflineAudioContext2, isNativeOfflineAudioContext2, nativeAudioWorkletNodeConstructor2, ongoingRequests, resolvedRequests, testAudioWorkletProcessorPostMessageSupport, window3) => {
1590  let index = 0;
1591  return (context2, moduleURL, options = { credentials: "omit" }) => {
1592    const resolvedRequestsOfContext = resolvedRequests.get(context2);
1593    if (resolvedRequestsOfContext !== void 0 && resolvedRequestsOfContext.has(moduleURL)) {
1594      return Promise.resolve();
1595    }
1596    const ongoingRequestsOfContext = ongoingRequests.get(context2);
1597    if (ongoingRequestsOfContext !== void 0) {
1598      const promiseOfOngoingRequest = ongoingRequestsOfContext.get(moduleURL);
1599      if (promiseOfOngoingRequest !== void 0) {
1600        return promiseOfOngoingRequest;
1601      }
1602    }
1603    const nativeContext = getNativeContext2(context2);
1604    const promise = nativeContext.audioWorklet === void 0 ? fetchSource(moduleURL).then(([source, absoluteUrl]) => {
1605      const [importStatements, sourceWithoutImportStatements] = splitImportStatements(source, absoluteUrl);
1606      const wrappedSource = `${importStatements};((a,b)=>{(a[b]=a[b]||[]).push((AudioWorkletProcessor,global,registerProcessor,sampleRate,self,window)=>{${sourceWithoutImportStatements}
1607})})(window,'_AWGS')`;
1608      return evaluateSource(wrappedSource);
1609    }).then(() => {
1610      const evaluateAudioWorkletGlobalScope = window3._AWGS.pop();
1611      if (evaluateAudioWorkletGlobalScope === void 0) {
1612        throw new SyntaxError();
1613      }
1614      exposeCurrentFrameAndCurrentTime2(nativeContext.currentTime, nativeContext.sampleRate, () => evaluateAudioWorkletGlobalScope(class AudioWorkletProcessor {
1615      }, void 0, (name, processorCtor) => {
1616        if (name.trim() === "") {
1617          throw createNotSupportedError2();
1618        }
1619        const nodeNameToProcessorConstructorMap = NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.get(nativeContext);
1620        if (nodeNameToProcessorConstructorMap !== void 0) {
1621          if (nodeNameToProcessorConstructorMap.has(name)) {
1622            throw createNotSupportedError2();
1623          }
1624          verifyProcessorCtor(processorCtor);
1625          verifyParameterDescriptors(processorCtor.parameterDescriptors);
1626          nodeNameToProcessorConstructorMap.set(name, processorCtor);
1627        } else {
1628          verifyProcessorCtor(processorCtor);
1629          verifyParameterDescriptors(processorCtor.parameterDescriptors);
1630          NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.set(nativeContext, /* @__PURE__ */ new Map([[name, processorCtor]]));
1631        }
1632      }, nativeContext.sampleRate, void 0, void 0));
1633    }) : Promise.all([
1634      fetchSource(moduleURL),
1635      Promise.resolve(cacheTestResult2(testAudioWorkletProcessorPostMessageSupport, testAudioWorkletProcessorPostMessageSupport))
1636    ]).then(([[source, absoluteUrl], isSupportingPostMessage]) => {
1637      const currentIndex = index + 1;
1638      index = currentIndex;
1639      const [importStatements, sourceWithoutImportStatements] = splitImportStatements(source, absoluteUrl);
1640      const patchedAudioWorkletProcessor = isSupportingPostMessage ? "AudioWorkletProcessor" : "class extends AudioWorkletProcessor {__b=new WeakSet();constructor(){super();(p=>p.postMessage=(q=>(m,t)=>q.call(p,m,t?t.filter(u=>!this.__b.has(u)):t))(p.postMessage))(this.port)}}";
1641      const memberDefinition = isSupportingPostMessage ? "" : "__c = (a) => a.forEach(e=>this.__b.add(e.buffer));";
1642      const bufferRegistration = isSupportingPostMessage ? "" : "i.forEach(this.__c);o.forEach(this.__c);this.__c(Object.values(p));";
1643      const wrappedSource = `${importStatements};((AudioWorkletProcessor,registerProcessor)=>{${sourceWithoutImportStatements}
1644})(${patchedAudioWorkletProcessor},(n,p)=>registerProcessor(n,class extends p{${memberDefinition}process(i,o,p){${bufferRegistration}return super.process(i.map(j=>j.some(k=>k.length===0)?[]:j),o,p)}}));registerProcessor('__sac${currentIndex}',class extends AudioWorkletProcessor{process(){return !1}})`;
1645      const blob = new Blob([wrappedSource], { type: "application/javascript; charset=utf-8" });
1646      const url = URL.createObjectURL(blob);
1647      return nativeContext.audioWorklet.addModule(url, options).then(() => {
1648        if (isNativeOfflineAudioContext2(nativeContext)) {
1649          return nativeContext;
1650        }
1651        const backupOfflineAudioContext = getOrCreateBackupOfflineAudioContext2(nativeContext);
1652        return backupOfflineAudioContext.audioWorklet.addModule(url, options).then(() => backupOfflineAudioContext);
1653      }).then((nativeContextOrBackupOfflineAudioContext) => {
1654        if (nativeAudioWorkletNodeConstructor2 === null) {
1655          throw new SyntaxError();
1656        }
1657        try {
1658          new nativeAudioWorkletNodeConstructor2(nativeContextOrBackupOfflineAudioContext, `__sac${currentIndex}`);
1659        } catch {
1660          throw new SyntaxError();
1661        }
1662      }).finally(() => URL.revokeObjectURL(url));
1663    });
1664    if (ongoingRequestsOfContext === void 0) {
1665      ongoingRequests.set(context2, /* @__PURE__ */ new Map([[moduleURL, promise]]));
1666    } else {
1667      ongoingRequestsOfContext.set(moduleURL, promise);
1668    }
1669    promise.then(() => {
1670      const updatedResolvedRequestsOfContext = resolvedRequests.get(context2);
1671      if (updatedResolvedRequestsOfContext === void 0) {
1672        resolvedRequests.set(context2, /* @__PURE__ */ new Set([moduleURL]));
1673      } else {
1674        updatedResolvedRequestsOfContext.add(moduleURL);
1675      }
1676    }).finally(() => {
1677      const updatedOngoingRequestsOfContext = ongoingRequests.get(context2);
1678      if (updatedOngoingRequestsOfContext !== void 0) {
1679        updatedOngoingRequestsOfContext.delete(moduleURL);
1680      }
1681    });
1682    return promise;
1683  };
1684};
1685

1686// node_modules/standardized-audio-context/build/es2019/helpers/get-value-for-key.js
1687var getValueForKey = (map, key) => {
1688  const value = map.get(key);
1689  if (value === void 0) {
1690    throw new Error("A value with the given key could not be found.");
1691  }
1692  return value;
1693};
1694

1695// node_modules/standardized-audio-context/build/es2019/helpers/pick-element-from-set.js
1696var pickElementFromSet = (set, predicate) => {
1697  const matchingElements = Array.from(set).filter(predicate);
1698  if (matchingElements.length > 1) {
1699    throw Error("More than one element was found.");
1700  }
1701  if (matchingElements.length === 0) {
1702    throw Error("No element was found.");
1703  }
1704  const [matchingElement] = matchingElements;
1705  set.delete(matchingElement);
1706  return matchingElement;
1707};
1708

1709// node_modules/standardized-audio-context/build/es2019/helpers/delete-passive-input-connection-to-audio-node.js
1710var deletePassiveInputConnectionToAudioNode = (passiveInputs, source, output, input) => {
1711  const passiveInputConnections = getValueForKey(passiveInputs, source);
1712  const matchingConnection = pickElementFromSet(passiveInputConnections, (passiveInputConnection) => passiveInputConnection[0] === output && passiveInputConnection[1] === input);
1713  if (passiveInputConnections.size === 0) {
1714    passiveInputs.delete(source);
1715  }
1716  return matchingConnection;
1717};
1718

1719// node_modules/standardized-audio-context/build/es2019/helpers/get-event-listeners-of-audio-node.js
1720var getEventListenersOfAudioNode = (audioNode) => {
1721  return getValueForKey(EVENT_LISTENERS, audioNode);
1722};
1723

1724// node_modules/standardized-audio-context/build/es2019/helpers/set-internal-state-to-active.js
1725var setInternalStateToActive = (audioNode) => {
1726  if (ACTIVE_AUDIO_NODE_STORE.has(audioNode)) {
1727    throw new Error("The AudioNode is already stored.");
1728  }
1729  ACTIVE_AUDIO_NODE_STORE.add(audioNode);
1730  getEventListenersOfAudioNode(audioNode).forEach((eventListener) => eventListener(true));
1731};
1732

1733// node_modules/standardized-audio-context/build/es2019/guards/audio-worklet-node.js
1734var isAudioWorkletNode = (audioNode) => {
1735  return "port" in audioNode;
1736};
1737

1738// node_modules/standardized-audio-context/build/es2019/helpers/set-internal-state-to-passive.js
1739var setInternalStateToPassive = (audioNode) => {
1740  if (!ACTIVE_AUDIO_NODE_STORE.has(audioNode)) {
1741    throw new Error("The AudioNode is not stored.");
1742  }
1743  ACTIVE_AUDIO_NODE_STORE.delete(audioNode);
1744  getEventListenersOfAudioNode(audioNode).forEach((eventListener) => eventListener(false));
1745};
1746

1747// node_modules/standardized-audio-context/build/es2019/helpers/set-internal-state-to-passive-when-necessary.js
1748var setInternalStateToPassiveWhenNecessary = (audioNode, activeInputs) => {
1749  if (!isAudioWorkletNode(audioNode) && activeInputs.every((connections) => connections.size === 0)) {
1750    setInternalStateToPassive(audioNode);
1751  }
1752};
1753

1754// node_modules/standardized-audio-context/build/es2019/factories/add-connection-to-audio-node.js
1755var createAddConnectionToAudioNode = (addActiveInputConnectionToAudioNode2, addPassiveInputConnectionToAudioNode2, connectNativeAudioNodeToNativeAudioNode2, deleteActiveInputConnectionToAudioNode2, disconnectNativeAudioNodeFromNativeAudioNode2, getAudioNodeConnections2, getAudioNodeTailTime2, getEventListenersOfAudioNode2, getNativeAudioNode2, insertElementInSet2, isActiveAudioNode2, isPartOfACycle2, isPassiveAudioNode2) => {
1756  const tailTimeTimeoutIds = /* @__PURE__ */ new WeakMap();
1757  return (source, destination, output, input, isOffline) => {
1758    const { activeInputs, passiveInputs } = getAudioNodeConnections2(destination);
1759    const { outputs } = getAudioNodeConnections2(source);
1760    const eventListeners = getEventListenersOfAudioNode2(source);
1761    const eventListener = (isActive) => {
1762      const nativeDestinationAudioNode = getNativeAudioNode2(destination);
1763      const nativeSourceAudioNode = getNativeAudioNode2(source);
1764      if (isActive) {
1765        const partialConnection = deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);
1766        addActiveInputConnectionToAudioNode2(activeInputs, source, partialConnection, false);
1767        if (!isOffline && !isPartOfACycle2(source)) {
1768          connectNativeAudioNodeToNativeAudioNode2(nativeSourceAudioNode, nativeDestinationAudioNode, output, input);
1769        }
1770        if (isPassiveAudioNode2(destination)) {
1771          setInternalStateToActive(destination);
1772        }
1773      } else {
1774        const partialConnection = deleteActiveInputConnectionToAudioNode2(activeInputs, source, output, input);
1775        addPassiveInputConnectionToAudioNode2(passiveInputs, input, partialConnection, false);
1776        if (!isOffline && !isPartOfACycle2(source)) {
1777          disconnectNativeAudioNodeFromNativeAudioNode2(nativeSourceAudioNode, nativeDestinationAudioNode, output, input);
1778        }
1779        const tailTime = getAudioNodeTailTime2(destination);
1780        if (tailTime === 0) {
1781          if (isActiveAudioNode2(destination)) {
1782            setInternalStateToPassiveWhenNecessary(destination, activeInputs);
1783          }
1784        } else {
1785          const tailTimeTimeoutId = tailTimeTimeoutIds.get(destination);
1786          if (tailTimeTimeoutId !== void 0) {
1787            clearTimeout(tailTimeTimeoutId);
1788          }
1789          tailTimeTimeoutIds.set(destination, setTimeout(() => {
1790            if (isActiveAudioNode2(destination)) {
1791              setInternalStateToPassiveWhenNecessary(destination, activeInputs);
1792            }
1793          }, tailTime * 1e3));
1794        }
1795      }
1796    };
1797    if (insertElementInSet2(outputs, [destination, output, input], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output && outputConnection[2] === input, true)) {
1798      eventListeners.add(eventListener);
1799      if (isActiveAudioNode2(source)) {
1800        addActiveInputConnectionToAudioNode2(activeInputs, source, [output, input, eventListener], true);
1801      } else {
1802        addPassiveInputConnectionToAudioNode2(passiveInputs, input, [source, output, eventListener], true);
1803      }
1804      return true;
1805    }
1806    return false;
1807  };
1808};
1809

1810// node_modules/standardized-audio-context/build/es2019/factories/add-passive-input-connection-to-audio-node.js
1811var createAddPassiveInputConnectionToAudioNode = (insertElementInSet2) => {
1812  return (passiveInputs, input, [source, output, eventListener], ignoreDuplicates) => {
1813    const passiveInputConnections = passiveInputs.get(source);
1814    if (passiveInputConnections === void 0) {
1815      passiveInputs.set(source, /* @__PURE__ */ new Set([[output, input, eventListener]]));
1816    } else {
1817      insertElementInSet2(passiveInputConnections, [output, input, eventListener], (passiveInputConnection) => passiveInputConnection[0] === output && passiveInputConnection[1] === input, ignoreDuplicates);
1818    }
1819  };
1820};
1821

1822// node_modules/standardized-audio-context/build/es2019/factories/add-silent-connection.js
1823var createAddSilentConnection = (createNativeGainNode2) => {
1824  return (nativeContext, nativeAudioScheduledSourceNode) => {
1825    const nativeGainNode = createNativeGainNode2(nativeContext, {
1826      channelCount: 1,
1827      channelCountMode: "explicit",
1828      channelInterpretation: "discrete",
1829      gain: 0
1830    });
1831    nativeAudioScheduledSourceNode.connect(nativeGainNode).connect(nativeContext.destination);
1832    const disconnect2 = () => {
1833      nativeAudioScheduledSourceNode.removeEventListener("ended", disconnect2);
1834      nativeAudioScheduledSourceNode.disconnect(nativeGainNode);
1835      nativeGainNode.disconnect();
1836    };
1837    nativeAudioScheduledSourceNode.addEventListener("ended", disconnect2);
1838  };
1839};
1840

1841// node_modules/standardized-audio-context/build/es2019/factories/add-unrendered-audio-worklet-node.js
1842var createAddUnrenderedAudioWorkletNode = (getUnrenderedAudioWorkletNodes2) => {
1843  return (nativeContext, audioWorkletNode) => {
1844    getUnrenderedAudioWorkletNodes2(nativeContext).add(audioWorkletNode);
1845  };
1846};
1847

1848// node_modules/standardized-audio-context/build/es2019/factories/analyser-node-constructor.js
1849var DEFAULT_OPTIONS = {
1850  channelCount: 2,
1851  channelCountMode: "max",
1852  channelInterpretation: "speakers",
1853  fftSize: 2048,
1854  maxDecibels: -30,
1855  minDecibels: -100,
1856  smoothingTimeConstant: 0.8
1857};
1858var createAnalyserNodeConstructor = (audionNodeConstructor, createAnalyserNodeRenderer2, createIndexSizeError2, createNativeAnalyserNode2, getNativeContext2, isNativeOfflineAudioContext2) => {
1859  return class AnalyserNode extends audionNodeConstructor {
1860    constructor(context2, options) {
1861      const nativeContext = getNativeContext2(context2);
1862      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
1863      const nativeAnalyserNode = createNativeAnalyserNode2(nativeContext, mergedOptions);
1864      const analyserNodeRenderer = isNativeOfflineAudioContext2(nativeContext) ? createAnalyserNodeRenderer2() : null;
1865      super(context2, false, nativeAnalyserNode, analyserNodeRenderer);
1866      this._nativeAnalyserNode = nativeAnalyserNode;
1867    }
1868    get fftSize() {
1869      return this._nativeAnalyserNode.fftSize;
1870    }
1871    set fftSize(value) {
1872      this._nativeAnalyserNode.fftSize = value;
1873    }
1874    get frequencyBinCount() {
1875      return this._nativeAnalyserNode.frequencyBinCount;
1876    }
1877    get maxDecibels() {
1878      return this._nativeAnalyserNode.maxDecibels;
1879    }
1880    set maxDecibels(value) {
1881      const maxDecibels = this._nativeAnalyserNode.maxDecibels;
1882      this._nativeAnalyserNode.maxDecibels = value;
1883      if (!(value > this._nativeAnalyserNode.minDecibels)) {
1884        this._nativeAnalyserNode.maxDecibels = maxDecibels;
1885        throw createIndexSizeError2();
1886      }
1887    }
1888    get minDecibels() {
1889      return this._nativeAnalyserNode.minDecibels;
1890    }
1891    set minDecibels(value) {
1892      const minDecibels = this._nativeAnalyserNode.minDecibels;
1893      this._nativeAnalyserNode.minDecibels = value;
1894      if (!(this._nativeAnalyserNode.maxDecibels > value)) {
1895        this._nativeAnalyserNode.minDecibels = minDecibels;
1896        throw createIndexSizeError2();
1897      }
1898    }
1899    get smoothingTimeConstant() {
1900      return this._nativeAnalyserNode.smoothingTimeConstant;
1901    }
1902    set smoothingTimeConstant(value) {
1903      this._nativeAnalyserNode.smoothingTimeConstant = value;
1904    }
1905    getByteFrequencyData(array) {
1906      this._nativeAnalyserNode.getByteFrequencyData(array);
1907    }
1908    getByteTimeDomainData(array) {
1909      this._nativeAnalyserNode.getByteTimeDomainData(array);
1910    }
1911    getFloatFrequencyData(array) {
1912      this._nativeAnalyserNode.getFloatFrequencyData(array);
1913    }
1914    getFloatTimeDomainData(array) {
1915      this._nativeAnalyserNode.getFloatTimeDomainData(array);
1916    }
1917  };
1918};
1919

1920// node_modules/standardized-audio-context/build/es2019/helpers/is-owned-by-context.js
1921var isOwnedByContext = (nativeAudioNode, nativeContext) => {
1922  return nativeAudioNode.context === nativeContext;
1923};
1924

1925// node_modules/standardized-audio-context/build/es2019/factories/analyser-node-renderer-factory.js
1926var createAnalyserNodeRendererFactory = (createNativeAnalyserNode2, getNativeAudioNode2, renderInputsOfAudioNode2) => {
1927  return () => {
1928    const renderedNativeAnalyserNodes = /* @__PURE__ */ new WeakMap();
1929    const createAnalyserNode = async (proxy, nativeOfflineAudioContext) => {
1930      let nativeAnalyserNode = getNativeAudioNode2(proxy);
1931      const nativeAnalyserNodeIsOwnedByContext = isOwnedByContext(nativeAnalyserNode, nativeOfflineAudioContext);
1932      if (!nativeAnalyserNodeIsOwnedByContext) {
1933        const options = {
1934          channelCount: nativeAnalyserNode.channelCount,
1935          channelCountMode: nativeAnalyserNode.channelCountMode,
1936          channelInterpretation: nativeAnalyserNode.channelInterpretation,
1937          fftSize: nativeAnalyserNode.fftSize,
1938          maxDecibels: nativeAnalyserNode.maxDecibels,
1939          minDecibels: nativeAnalyserNode.minDecibels,
1940          smoothingTimeConstant: nativeAnalyserNode.smoothingTimeConstant
1941        };
1942        nativeAnalyserNode = createNativeAnalyserNode2(nativeOfflineAudioContext, options);
1943      }
1944      renderedNativeAnalyserNodes.set(nativeOfflineAudioContext, nativeAnalyserNode);
1945      await renderInputsOfAudioNode2(proxy, nativeOfflineAudioContext, nativeAnalyserNode);
1946      return nativeAnalyserNode;
1947    };
1948    return {
1949      render(proxy, nativeOfflineAudioContext) {
1950        const renderedNativeAnalyserNode = renderedNativeAnalyserNodes.get(nativeOfflineAudioContext);
1951        if (renderedNativeAnalyserNode !== void 0) {
1952          return Promise.resolve(renderedNativeAnalyserNode);
1953        }
1954        return createAnalyserNode(proxy, nativeOfflineAudioContext);
1955      }
1956    };
1957  };
1958};
1959

1960// node_modules/standardized-audio-context/build/es2019/helpers/test-audio-buffer-copy-channel-methods-out-of-bounds-support.js
1961var testAudioBufferCopyChannelMethodsOutOfBoundsSupport = (nativeAudioBuffer) => {
1962  try {
1963    nativeAudioBuffer.copyToChannel(new Float32Array(1), 0, -1);
1964  } catch {
1965    return false;
1966  }
1967  return true;
1968};
1969

1970// node_modules/standardized-audio-context/build/es2019/factories/index-size-error.js
1971var createIndexSizeError = () => new DOMException("", "IndexSizeError");
1972

1973// node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-buffer-get-channel-data-method.js
1974var wrapAudioBufferGetChannelDataMethod = (audioBuffer) => {
1975  audioBuffer.getChannelData = /* @__PURE__ */ ((getChannelData) => {
1976    return (channel) => {
1977      try {
1978        return getChannelData.call(audioBuffer, channel);
1979      } catch (err) {
1980        if (err.code === 12) {
1981          throw createIndexSizeError();
1982        }
1983        throw err;
1984      }
1985    };
1986  })(audioBuffer.getChannelData);
1987};
1988

1989// node_modules/standardized-audio-context/build/es2019/factories/audio-buffer-constructor.js
1990var DEFAULT_OPTIONS2 = {
1991  numberOfChannels: 1
1992};
1993var createAudioBufferConstructor = (audioBufferStore2, cacheTestResult2, createNotSupportedError2, nativeAudioBufferConstructor2, nativeOfflineAudioContextConstructor2, testNativeAudioBufferConstructorSupport, wrapAudioBufferCopyChannelMethods2, wrapAudioBufferCopyChannelMethodsOutOfBounds2) => {
1994  let nativeOfflineAudioContext = null;
1995  return class AudioBuffer {
1996    constructor(options) {
1997      if (nativeOfflineAudioContextConstructor2 === null) {
1998        throw new Error("Missing the native OfflineAudioContext constructor.");
1999      }
2000      const { length, numberOfChannels, sampleRate } = { ...DEFAULT_OPTIONS2, ...options };
2001      if (nativeOfflineAudioContext === null) {
2002        nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor2(1, 1, 44100);
2003      }
2004      const audioBuffer = nativeAudioBufferConstructor2 !== null && cacheTestResult2(testNativeAudioBufferConstructorSupport, testNativeAudioBufferConstructorSupport) ? new nativeAudioBufferConstructor2({ length, numberOfChannels, sampleRate }) : nativeOfflineAudioContext.createBuffer(numberOfChannels, length, sampleRate);
2005      if (audioBuffer.numberOfChannels === 0) {
2006        throw createNotSupportedError2();
2007      }
2008      if (typeof audioBuffer.copyFromChannel !== "function") {
2009        wrapAudioBufferCopyChannelMethods2(audioBuffer);
2010        wrapAudioBufferGetChannelDataMethod(audioBuffer);
2011      } else if (!cacheTestResult2(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {
2012        wrapAudioBufferCopyChannelMethodsOutOfBounds2(audioBuffer);
2013      }
2014      audioBufferStore2.add(audioBuffer);
2015      return audioBuffer;
2016    }
2017    static [Symbol.hasInstance](instance) {
2018      return instance !== null && typeof instance === "object" && Object.getPrototypeOf(instance) === AudioBuffer.prototype || audioBufferStore2.has(instance);
2019    }
2020  };
2021};
2022

2023// node_modules/standardized-audio-context/build/es2019/constants.js
2024var MOST_NEGATIVE_SINGLE_FLOAT = -34028234663852886e22;
2025var MOST_POSITIVE_SINGLE_FLOAT = -MOST_NEGATIVE_SINGLE_FLOAT;
2026

2027// node_modules/standardized-audio-context/build/es2019/helpers/is-active-audio-node.js
2028var isActiveAudioNode = (audioNode) => ACTIVE_AUDIO_NODE_STORE.has(audioNode);
2029

2030// node_modules/standardized-audio-context/build/es2019/factories/audio-buffer-source-node-constructor.js
2031var DEFAULT_OPTIONS3 = {
2032  buffer: null,
2033  channelCount: 2,
2034  channelCountMode: "max",
2035  channelInterpretation: "speakers",
2036  // Bug #149: Safari does not yet support the detune AudioParam.
2037  loop: false,
2038  loopEnd: 0,
2039  loopStart: 0,
2040  playbackRate: 1
2041};
2042var createAudioBufferSourceNodeConstructor = (audioNodeConstructor2, createAudioBufferSourceNodeRenderer2, createAudioParam2, createInvalidStateError2, createNativeAudioBufferSourceNode2, getNativeContext2, isNativeOfflineAudioContext2, wrapEventListener2) => {
2043  return class AudioBufferSourceNode extends audioNodeConstructor2 {
2044    constructor(context2, options) {
2045      const nativeContext = getNativeContext2(context2);
2046      const mergedOptions = { ...DEFAULT_OPTIONS3, ...options };
2047      const nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode2(nativeContext, mergedOptions);
2048      const isOffline = isNativeOfflineAudioContext2(nativeContext);
2049      const audioBufferSourceNodeRenderer = isOffline ? createAudioBufferSourceNodeRenderer2() : null;
2050      super(context2, false, nativeAudioBufferSourceNode, audioBufferSourceNodeRenderer);
2051      this._audioBufferSourceNodeRenderer = audioBufferSourceNodeRenderer;
2052      this._isBufferNullified = false;
2053      this._isBufferSet = mergedOptions.buffer !== null;
2054      this._nativeAudioBufferSourceNode = nativeAudioBufferSourceNode;
2055      this._onended = null;
2056      this._playbackRate = createAudioParam2(this, isOffline, nativeAudioBufferSourceNode.playbackRate, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
2057    }
2058    get buffer() {
2059      if (this._isBufferNullified) {
2060        return null;
2061      }
2062      return this._nativeAudioBufferSourceNode.buffer;
2063    }
2064    set buffer(value) {
2065      this._nativeAudioBufferSourceNode.buffer = value;
2066      if (value !== null) {
2067        if (this._isBufferSet) {
2068          throw createInvalidStateError2();
2069        }
2070        this._isBufferSet = true;
2071      }
2072    }
2073    get loop() {
2074      return this._nativeAudioBufferSourceNode.loop;
2075    }
2076    set loop(value) {
2077      this._nativeAudioBufferSourceNode.loop = value;
2078    }
2079    get loopEnd() {
2080      return this._nativeAudioBufferSourceNode.loopEnd;
2081    }
2082    set loopEnd(value) {
2083      this._nativeAudioBufferSourceNode.loopEnd = value;
2084    }
2085    get loopStart() {
2086      return this._nativeAudioBufferSourceNode.loopStart;
2087    }
2088    set loopStart(value) {
2089      this._nativeAudioBufferSourceNode.loopStart = value;
2090    }
2091    get onended() {
2092      return this._onended;
2093    }
2094    set onended(value) {
2095      const wrappedListener = typeof value === "function" ? wrapEventListener2(this, value) : null;
2096      this._nativeAudioBufferSourceNode.onended = wrappedListener;
2097      const nativeOnEnded = this._nativeAudioBufferSourceNode.onended;
2098      this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;
2099    }
2100    get playbackRate() {
2101      return this._playbackRate;
2102    }
2103    start(when = 0, offset = 0, duration) {
2104      this._nativeAudioBufferSourceNode.start(when, offset, duration);
2105      if (this._audioBufferSourceNodeRenderer !== null) {
2106        this._audioBufferSourceNodeRenderer.start = duration === void 0 ? [when, offset] : [when, offset, duration];
2107      }
2108      if (this.context.state !== "closed") {
2109        setInternalStateToActive(this);
2110        const resetInternalStateToPassive = () => {
2111          this._nativeAudioBufferSourceNode.removeEventListener("ended", resetInternalStateToPassive);
2112          if (isActiveAudioNode(this)) {
2113            setInternalStateToPassive(this);
2114          }
2115        };
2116        this._nativeAudioBufferSourceNode.addEventListener("ended", resetInternalStateToPassive);
2117      }
2118    }
2119    stop(when = 0) {
2120      this._nativeAudioBufferSourceNode.stop(when);
2121      if (this._audioBufferSourceNodeRenderer !== null) {
2122        this._audioBufferSourceNodeRenderer.stop = when;
2123      }
2124    }
2125  };
2126};
2127

2128// node_modules/standardized-audio-context/build/es2019/factories/audio-buffer-source-node-renderer-factory.js
2129var createAudioBufferSourceNodeRendererFactory = (connectAudioParam2, createNativeAudioBufferSourceNode2, getNativeAudioNode2, renderAutomation2, renderInputsOfAudioNode2) => {
2130  return () => {
2131    const renderedNativeAudioBufferSourceNodes = /* @__PURE__ */ new WeakMap();
2132    let start2 = null;
2133    let stop = null;
2134    const createAudioBufferSourceNode = async (proxy, nativeOfflineAudioContext) => {
2135      let nativeAudioBufferSourceNode = getNativeAudioNode2(proxy);
2136      const nativeAudioBufferSourceNodeIsOwnedByContext = isOwnedByContext(nativeAudioBufferSourceNode, nativeOfflineAudioContext);
2137      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
2138        const options = {
2139          buffer: nativeAudioBufferSourceNode.buffer,
2140          channelCount: nativeAudioBufferSourceNode.channelCount,
2141          channelCountMode: nativeAudioBufferSourceNode.channelCountMode,
2142          channelInterpretation: nativeAudioBufferSourceNode.channelInterpretation,
2143          // Bug #149: Safari does not yet support the detune AudioParam.
2144          loop: nativeAudioBufferSourceNode.loop,
2145          loopEnd: nativeAudioBufferSourceNode.loopEnd,
2146          loopStart: nativeAudioBufferSourceNode.loopStart,
2147          playbackRate: nativeAudioBufferSourceNode.playbackRate.value
2148        };
2149        nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode2(nativeOfflineAudioContext, options);
2150        if (start2 !== null) {
2151          nativeAudioBufferSourceNode.start(...start2);
2152        }
2153        if (stop !== null) {
2154          nativeAudioBufferSourceNode.stop(stop);
2155        }
2156      }
2157      renderedNativeAudioBufferSourceNodes.set(nativeOfflineAudioContext, nativeAudioBufferSourceNode);
2158      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
2159        await renderAutomation2(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
2160      } else {
2161        await connectAudioParam2(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
2162      }
2163      await renderInputsOfAudioNode2(proxy, nativeOfflineAudioContext, nativeAudioBufferSourceNode);
2164      return nativeAudioBufferSourceNode;
2165    };
2166    return {
2167      set start(value) {
2168        start2 = value;
2169      },
2170      set stop(value) {
2171        stop = value;
2172      },
2173      render(proxy, nativeOfflineAudioContext) {
2174        const renderedNativeAudioBufferSourceNode = renderedNativeAudioBufferSourceNodes.get(nativeOfflineAudioContext);
2175        if (renderedNativeAudioBufferSourceNode !== void 0) {
2176          return Promise.resolve(renderedNativeAudioBufferSourceNode);
2177        }
2178        return createAudioBufferSourceNode(proxy, nativeOfflineAudioContext);
2179      }
2180    };
2181  };
2182};
2183

2184// node_modules/standardized-audio-context/build/es2019/guards/audio-buffer-source-node.js
2185var isAudioBufferSourceNode = (audioNode) => {
2186  return "playbackRate" in audioNode;
2187};
2188

2189// node_modules/standardized-audio-context/build/es2019/guards/biquad-filter-node.js
2190var isBiquadFilterNode = (audioNode) => {
2191  return "frequency" in audioNode && "gain" in audioNode;
2192};
2193

2194// node_modules/standardized-audio-context/build/es2019/guards/constant-source-node.js
2195var isConstantSourceNode = (audioNode) => {
2196  return "offset" in audioNode;
2197};
2198

2199// node_modules/standardized-audio-context/build/es2019/guards/gain-node.js
2200var isGainNode = (audioNode) => {
2201  return !("frequency" in audioNode) && "gain" in audioNode;
2202};
2203

2204// node_modules/standardized-audio-context/build/es2019/guards/oscillator-node.js
2205var isOscillatorNode = (audioNode) => {
2206  return "detune" in audioNode && "frequency" in audioNode && !("gain" in audioNode);
2207};
2208

2209// node_modules/standardized-audio-context/build/es2019/guards/stereo-panner-node.js
2210var isStereoPannerNode = (audioNode) => {
2211  return "pan" in audioNode;
2212};
2213

2214// node_modules/standardized-audio-context/build/es2019/helpers/get-audio-node-connections.js
2215var getAudioNodeConnections = (audioNode) => {
2216  return getValueForKey(AUDIO_NODE_CONNECTIONS_STORE, audioNode);
2217};
2218

2219// node_modules/standardized-audio-context/build/es2019/helpers/get-audio-param-connections.js
2220var getAudioParamConnections = (audioParam) => {
2221  return getValueForKey(AUDIO_PARAM_CONNECTIONS_STORE, audioParam);
2222};
2223

2224// node_modules/standardized-audio-context/build/es2019/helpers/deactivate-active-audio-node-input-connections.js
2225var deactivateActiveAudioNodeInputConnections = (audioNode, trace) => {
2226  const { activeInputs } = getAudioNodeConnections(audioNode);
2227  activeInputs.forEach((connections) => connections.forEach(([source]) => {
2228    if (!trace.includes(audioNode)) {
2229      deactivateActiveAudioNodeInputConnections(source, [...trace, audioNode]);
2230    }
2231  }));
2232  const audioParams = isAudioBufferSourceNode(audioNode) ? [
2233    // Bug #149: Safari does not yet support the detune AudioParam.
2234    audioNode.playbackRate
2235  ] : isAudioWorkletNode(audioNode) ? Array.from(audioNode.parameters.values()) : isBiquadFilterNode(audioNode) ? [audioNode.Q, audioNode.detune, audioNode.frequency, audioNode.gain] : isConstantSourceNode(audioNode) ? [audioNode.offset] : isGainNode(audioNode) ? [audioNode.gain] : isOscillatorNode(audioNode) ? [audioNode.detune, audioNode.frequency] : isStereoPannerNode(audioNode) ? [audioNode.pan] : [];
2236  for (const audioParam of audioParams) {
2237    const audioParamConnections = getAudioParamConnections(audioParam);
2238    if (audioParamConnections !== void 0) {
2239      audioParamConnections.activeInputs.forEach(([source]) => deactivateActiveAudioNodeInputConnections(source, trace));
2240    }
2241  }
2242  if (isActiveAudioNode(audioNode)) {
2243    setInternalStateToPassive(audioNode);
2244  }
2245};
2246

2247// node_modules/standardized-audio-context/build/es2019/helpers/deactivate-audio-graph.js
2248var deactivateAudioGraph = (context2) => {
2249  deactivateActiveAudioNodeInputConnections(context2.destination, []);
2250};
2251

2252// node_modules/standardized-audio-context/build/es2019/helpers/is-valid-latency-hint.js
2253var isValidLatencyHint = (latencyHint) => {
2254  return latencyHint === void 0 || typeof latencyHint === "number" || typeof latencyHint === "string" && (latencyHint === "balanced" || latencyHint === "interactive" || latencyHint === "playback");
2255};
2256

2257// node_modules/standardized-audio-context/build/es2019/factories/audio-context-constructor.js
2258var createAudioContextConstructor = (baseAudioContextConstructor2, createInvalidStateError2, createNotSupportedError2, createUnknownError2, mediaElementAudioSourceNodeConstructor2, mediaStreamAudioDestinationNodeConstructor2, mediaStreamAudioSourceNodeConstructor2, mediaStreamTrackAudioSourceNodeConstructor2, nativeAudioContextConstructor2) => {
2259  return class AudioContext extends baseAudioContextConstructor2 {
2260    constructor(options = {}) {
2261      if (nativeAudioContextConstructor2 === null) {
2262        throw new Error("Missing the native AudioContext constructor.");
2263      }
2264      let nativeAudioContext;
2265      try {
2266        nativeAudioContext = new nativeAudioContextConstructor2(options);
2267      } catch (err) {
2268        if (err.code === 12 && err.message === "sampleRate is not in range") {
2269          throw createNotSupportedError2();
2270        }
2271        throw err;
2272      }
2273      if (nativeAudioContext === null) {
2274        throw createUnknownError2();
2275      }
2276      if (!isValidLatencyHint(options.latencyHint)) {
2277        throw new TypeError(`The provided value '${options.latencyHint}' is not a valid enum value of type AudioContextLatencyCategory.`);
2278      }
2279      if (options.sampleRate !== void 0 && nativeAudioContext.sampleRate !== options.sampleRate) {
2280        throw createNotSupportedError2();
2281      }
2282      super(nativeAudioContext, 2);
2283      const { latencyHint } = options;
2284      const { sampleRate } = nativeAudioContext;
2285      this._baseLatency = typeof nativeAudioContext.baseLatency === "number" ? nativeAudioContext.baseLatency : latencyHint === "balanced" ? 512 / sampleRate : latencyHint === "interactive" || latencyHint === void 0 ? 256 / sampleRate : latencyHint === "playback" ? 1024 / sampleRate : (
2286        /*
2287         * @todo The min (256) and max (16384) values are taken from the allowed bufferSize values of a
2288         * ScriptProcessorNode.
2289         */
2290        Math.max(2, Math.min(128, Math.round(latencyHint * sampleRate / 128))) * 128 / sampleRate
2291      );
2292      this._nativeAudioContext = nativeAudioContext;
2293      if (nativeAudioContextConstructor2.name === "webkitAudioContext") {
2294        this._nativeGainNode = nativeAudioContext.createGain();
2295        this._nativeOscillatorNode = nativeAudioContext.createOscillator();
2296        this._nativeGainNode.gain.value = 1e-37;
2297        this._nativeOscillatorNode.connect(this._nativeGainNode).connect(nativeAudioContext.destination);
2298        this._nativeOscillatorNode.start();
2299      } else {
2300        this._nativeGainNode = null;
2301        this._nativeOscillatorNode = null;
2302      }
2303      this._state = null;
2304      if (nativeAudioContext.state === "running") {
2305        this._state = "suspended";
2306        const revokeState = () => {
2307          if (this._state === "suspended") {
2308            this._state = null;
2309          }
2310          nativeAudioContext.removeEventListener("statechange", revokeState);
2311        };
2312        nativeAudioContext.addEventListener("statechange", revokeState);
2313      }
2314    }
2315    get baseLatency() {
2316      return this._baseLatency;
2317    }
2318    get state() {
2319      return this._state !== null ? this._state : this._nativeAudioContext.state;
2320    }
2321    close() {
2322      if (this.state === "closed") {
2323        return this._nativeAudioContext.close().then(() => {
2324          throw createInvalidStateError2();
2325        });
2326      }
2327      if (this._state === "suspended") {
2328        this._state = null;
2329      }
2330      return this._nativeAudioContext.close().then(() => {
2331        if (this._nativeGainNode !== null && this._nativeOscillatorNode !== null) {
2332          this._nativeOscillatorNode.stop();
2333          this._nativeGainNode.disconnect();
2334          this._nativeOscillatorNode.disconnect();
2335        }
2336        deactivateAudioGraph(this);
2337      });
2338    }
2339    createMediaElementSource(mediaElement) {
2340      return new mediaElementAudioSourceNodeConstructor2(this, { mediaElement });
2341    }
2342    createMediaStreamDestination() {
2343      return new mediaStreamAudioDestinationNodeConstructor2(this);
2344    }
2345    createMediaStreamSource(mediaStream) {
2346      return new mediaStreamAudioSourceNodeConstructor2(this, { mediaStream });
2347    }
2348    createMediaStreamTrackSource(mediaStreamTrack) {
2349      return new mediaStreamTrackAudioSourceNodeConstructor2(this, { mediaStreamTrack });
2350    }
2351    resume() {
2352      if (this._state === "suspended") {
2353        return new Promise((resolve, reject) => {
2354          const resolvePromise = () => {
2355            this._nativeAudioContext.removeEventListener("statechange", resolvePromise);
2356            if (this._nativeAudioContext.state === "running") {
2357              resolve();
2358            } else {
2359              this.resume().then(resolve, reject);
2360            }
2361          };
2362          this._nativeAudioContext.addEventListener("statechange", resolvePromise);
2363        });
2364      }
2365      return this._nativeAudioContext.resume().catch((err) => {
2366        if (err === void 0 || err.code === 15) {
2367          throw createInvalidStateError2();
2368        }
2369        throw err;
2370      });
2371    }
2372    suspend() {
2373      return this._nativeAudioContext.suspend().catch((err) => {
2374        if (err === void 0) {
2375          throw createInvalidStateError2();
2376        }
2377        throw err;
2378      });
2379    }
2380  };
2381};
2382

2383// node_modules/standardized-audio-context/build/es2019/factories/audio-destination-node-constructor.js
2384var createAudioDestinationNodeConstructor = (audioNodeConstructor2, createAudioDestinationNodeRenderer2, createIndexSizeError2, createInvalidStateError2, createNativeAudioDestinationNode, getNativeContext2, isNativeOfflineAudioContext2, renderInputsOfAudioNode2) => {
2385  return class AudioDestinationNode extends audioNodeConstructor2 {
2386    constructor(context2, channelCount) {
2387      const nativeContext = getNativeContext2(context2);
2388      const isOffline = isNativeOfflineAudioContext2(nativeContext);
2389      const nativeAudioDestinationNode = createNativeAudioDestinationNode(nativeContext, channelCount, isOffline);
2390      const audioDestinationNodeRenderer = isOffline ? createAudioDestinationNodeRenderer2(renderInputsOfAudioNode2) : null;
2391      super(context2, false, nativeAudioDestinationNode, audioDestinationNodeRenderer);
2392      this._isNodeOfNativeOfflineAudioContext = isOffline;
2393      this._nativeAudioDestinationNode = nativeAudioDestinationNode;
2394    }
2395    get channelCount() {
2396      return this._nativeAudioDestinationNode.channelCount;
2397    }
2398    set channelCount(value) {
2399      if (this._isNodeOfNativeOfflineAudioContext) {
2400        throw createInvalidStateError2();
2401      }
2402      if (value > this._nativeAudioDestinationNode.maxChannelCount) {
2403        throw createIndexSizeError2();
2404      }
2405      this._nativeAudioDestinationNode.channelCount = value;
2406    }
2407    get channelCountMode() {
2408      return this._nativeAudioDestinationNode.channelCountMode;
2409    }
2410    set channelCountMode(value) {
2411      if (this._isNodeOfNativeOfflineAudioContext) {
2412        throw createInvalidStateError2();
2413      }
2414      this._nativeAudioDestinationNode.channelCountMode = value;
2415    }
2416    get maxChannelCount() {
2417      return this._nativeAudioDestinationNode.maxChannelCount;
2418    }
2419  };
2420};
2421

2422// node_modules/standardized-audio-context/build/es2019/factories/audio-destination-node-renderer-factory.js
2423var createAudioDestinationNodeRenderer = (renderInputsOfAudioNode2) => {
2424  const renderedNativeAudioDestinationNodes = /* @__PURE__ */ new WeakMap();
2425  const createAudioDestinationNode = async (proxy, nativeOfflineAudioContext) => {
2426    const nativeAudioDestinationNode = nativeOfflineAudioContext.destination;
2427    renderedNativeAudioDestinationNodes.set(nativeOfflineAudioContext, nativeAudioDestinationNode);
2428    await renderInputsOfAudioNode2(proxy, nativeOfflineAudioContext, nativeAudioDestinationNode);
2429    return nativeAudioDestinationNode;
2430  };
2431  return {
2432    render(proxy, nativeOfflineAudioContext) {
2433      const renderedNativeAudioDestinationNode = renderedNativeAudioDestinationNodes.get(nativeOfflineAudioContext);
2434      if (renderedNativeAudioDestinationNode !== void 0) {
2435        return Promise.resolve(renderedNativeAudioDestinationNode);
2436      }
2437      return createAudioDestinationNode(proxy, nativeOfflineAudioContext);
2438    }
2439  };
2440};
2441

2442// node_modules/standardized-audio-context/build/es2019/factories/audio-listener-factory.js
2443var createAudioListenerFactory = (createAudioParam2, createNativeChannelMergerNode2, createNativeConstantSourceNode2, createNativeScriptProcessorNode2, createNotSupportedError2, getFirstSample2, isNativeOfflineAudioContext2, overwriteAccessors2) => {
2444  return (context2, nativeContext) => {
2445    const nativeListener = nativeContext.listener;
2446    const createFakeAudioParams = () => {
2447      const buffer = new Float32Array(1);
2448      const channelMergerNode = createNativeChannelMergerNode2(nativeContext, {
2449        channelCount: 1,
2450        channelCountMode: "explicit",
2451        channelInterpretation: "speakers",
2452        numberOfInputs: 9
2453      });
2454      const isOffline = isNativeOfflineAudioContext2(nativeContext);
2455      let isScriptProcessorNodeCreated = false;
2456      let lastOrientation = [0, 0, -1, 0, 1, 0];
2457      let lastPosition = [0, 0, 0];
2458      const createScriptProcessorNode = () => {
2459        if (isScriptProcessorNodeCreated) {
2460          return;
2461        }
2462        isScriptProcessorNodeCreated = true;
2463        const scriptProcessorNode = createNativeScriptProcessorNode2(nativeContext, 256, 9, 0);
2464        scriptProcessorNode.onaudioprocess = ({ inputBuffer }) => {
2465          const orientation = [
2466            getFirstSample2(inputBuffer, buffer, 0),
2467            getFirstSample2(inputBuffer, buffer, 1),
2468            getFirstSample2(inputBuffer, buffer, 2),
2469            getFirstSample2(inputBuffer, buffer, 3),
2470            getFirstSample2(inputBuffer, buffer, 4),
2471            getFirstSample2(inputBuffer, buffer, 5)
2472          ];
2473          if (orientation.some((value, index) => value !== lastOrientation[index])) {
2474            nativeListener.setOrientation(...orientation);
2475            lastOrientation = orientation;
2476          }
2477          const positon = [
2478            getFirstSample2(inputBuffer, buffer, 6),
2479            getFirstSample2(inputBuffer, buffer, 7),
2480            getFirstSample2(inputBuffer, buffer, 8)
2481          ];
2482          if (positon.some((value, index) => value !== lastPosition[index])) {
2483            nativeListener.setPosition(...positon);
2484            lastPosition = positon;
2485          }
2486        };
2487        channelMergerNode.connect(scriptProcessorNode);
2488      };
2489      const createSetOrientation = (index) => (value) => {
2490        if (value !== lastOrientation[index]) {
2491          lastOrientation[index] = value;
2492          nativeListener.setOrientation(...lastOrientation);
2493        }
2494      };
2495      const createSetPosition = (index) => (value) => {
2496        if (value !== lastPosition[index]) {
2497          lastPosition[index] = value;
2498          nativeListener.setPosition(...lastPosition);
2499        }
2500      };
2501      const createFakeAudioParam = (input, initialValue, setValue) => {
2502        const constantSourceNode = createNativeConstantSourceNode2(nativeContext, {
2503          channelCount: 1,
2504          channelCountMode: "explicit",
2505          channelInterpretation: "discrete",
2506          offset: initialValue
2507        });
2508        constantSourceNode.connect(channelMergerNode, 0, input);
2509        constantSourceNode.start();
2510        Object.defineProperty(constantSourceNode.offset, "defaultValue", {
2511          get() {
2512            return initialValue;
2513          }
2514        });
2515        const audioParam = createAudioParam2({ context: context2 }, isOffline, constantSourceNode.offset, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
2516        overwriteAccessors2(audioParam, "value", (get) => () => get.call(audioParam), (set) => (value) => {
2517          try {
2518            set.call(audioParam, value);
2519          } catch (err) {
2520            if (err.code !== 9) {
2521              throw err;
2522            }
2523          }
2524          createScriptProcessorNode();
2525          if (isOffline) {
2526            setValue(value);
2527          }
2528        });
2529        audioParam.cancelAndHoldAtTime = ((cancelAndHoldAtTime) => {
2530          if (isOffline) {
2531            return () => {
2532              throw createNotSupportedError2();
2533            };
2534          }
2535          return (...args) => {
2536            const value = cancelAndHoldAtTime.apply(audioParam, args);
2537            createScriptProcessorNode();
2538            return value;
2539          };
2540        })(audioParam.cancelAndHoldAtTime);
2541        audioParam.cancelScheduledValues = ((cancelScheduledValues) => {
2542          if (isOffline) {
2543            return () => {
2544              throw createNotSupportedError2();
2545            };
2546          }
2547          return (...args) => {
2548            const value = cancelScheduledValues.apply(audioParam, args);
2549            createScriptProcessorNode();
2550            return value;
2551          };
2552        })(audioParam.cancelScheduledValues);
2553        audioParam.exponentialRampToValueAtTime = ((exponentialRampToValueAtTime) => {
2554          if (isOffline) {
2555            return () => {
2556              throw createNotSupportedError2();
2557            };
2558          }
2559          return (...args) => {
2560            const value = exponentialRampToValueAtTime.apply(audioParam, args);
2561            createScriptProcessorNode();
2562            return value;
2563          };
2564        })(audioParam.exponentialRampToValueAtTime);
2565        audioParam.linearRampToValueAtTime = ((linearRampToValueAtTime) => {
2566          if (isOffline) {
2567            return () => {
2568              throw createNotSupportedError2();
2569            };
2570          }
2571          return (...args) => {
2572            const value = linearRampToValueAtTime.apply(audioParam, args);
2573            createScriptProcessorNode();
2574            return value;
2575          };
2576        })(audioParam.linearRampToValueAtTime);
2577        audioParam.setTargetAtTime = ((setTargetAtTime) => {
2578          if (isOffline) {
2579            return () => {
2580              throw createNotSupportedError2();
2581            };
2582          }
2583          return (...args) => {
2584            const value = setTargetAtTime.apply(audioParam, args);
2585            createScriptProcessorNode();
2586            return value;
2587          };
2588        })(audioParam.setTargetAtTime);
2589        audioParam.setValueAtTime = ((setValueAtTime) => {
2590          if (isOffline) {
2591            return () => {
2592              throw createNotSupportedError2();
2593            };
2594          }
2595          return (...args) => {
2596            const value = setValueAtTime.apply(audioParam, args);
2597            createScriptProcessorNode();
2598            return value;
2599          };
2600        })(audioParam.setValueAtTime);
2601        audioParam.setValueCurveAtTime = ((setValueCurveAtTime) => {
2602          if (isOffline) {
2603            return () => {
2604              throw createNotSupportedError2();
2605            };
2606          }
2607          return (...args) => {
2608            const value = setValueCurveAtTime.apply(audioParam, args);
2609            createScriptProcessorNode();
2610            return value;
2611          };
2612        })(audioParam.setValueCurveAtTime);
2613        return audioParam;
2614      };
2615      return {
2616        forwardX: createFakeAudioParam(0, 0, createSetOrientation(0)),
2617        forwardY: createFakeAudioParam(1, 0, createSetOrientation(1)),
2618        forwardZ: createFakeAudioParam(2, -1, createSetOrientation(2)),
2619        positionX: createFakeAudioParam(6, 0, createSetPosition(0)),
2620        positionY: createFakeAudioParam(7, 0, createSetPosition(1)),
2621        positionZ: createFakeAudioParam(8, 0, createSetPosition(2)),
2622        upX: createFakeAudioParam(3, 0, createSetOrientation(3)),
2623        upY: createFakeAudioParam(4, 1, createSetOrientation(4)),
2624        upZ: createFakeAudioParam(5, 0, createSetOrientation(5))
2625      };
2626    };
2627    const { forwardX, forwardY, forwardZ, positionX, positionY, positionZ, upX, upY, upZ } = nativeListener.forwardX === void 0 ? createFakeAudioParams() : nativeListener;
2628    return {
2629      get forwardX() {
2630        return forwardX;
2631      },
2632      get forwardY() {
2633        return forwardY;
2634      },
2635      get forwardZ() {
2636        return forwardZ;
2637      },
2638      get positionX() {
2639        return positionX;
2640      },
2641      get positionY() {
2642        return positionY;
2643      },
2644      get positionZ() {
2645        return positionZ;
2646      },
2647      get upX() {
2648        return upX;
2649      },
2650      get upY() {
2651        return upY;
2652      },
2653      get upZ() {
2654        return upZ;
2655      }
2656    };
2657  };
2658};
2659