react-native-audio-api 0.4.12-beta.4 → 0.4.12

package/src/web-core/custom/signalsmithStretch/SignalsmithStretch.js

@@ -0,0 +1,945 @@
+var SignalsmithStretch = (() => {
+  var _scriptName =
+    typeof document != 'undefined' ? document.currentScript?.src : undefined;
+
+  return async function (moduleArg = {}) {
+    var moduleRtn;
+
+    var Module = moduleArg;
+    var readyPromiseResolve, readyPromiseReject;
+    var readyPromise = new Promise((resolve, reject) => {
+      readyPromiseResolve = resolve;
+      readyPromiseReject = reject;
+    });
+    var ENVIRONMENT_IS_WEB = typeof window == 'object';
+    var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != 'undefined';
+    var ENVIRONMENT_IS_NODE =
+      typeof process == 'object' &&
+      typeof process.versions == 'object' &&
+      typeof process.versions.node == 'string' &&
+      process.type != 'renderer';
+    var ENVIRONMENT_IS_SHELL =
+      !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+    var crypto = globalThis?.crypto || {
+      getRandomValues: (array) => {
+        for (var i = 0; i < array.length; i++)
+          array[i] = (Math.random() * 256) | 0;
+      },
+    };
+    var performance = globalThis?.performance || { now: (_) => Date.now() };
+    var moduleOverrides = Object.assign({}, Module);
+    var arguments_ = [];
+    var quit_ = (status, toThrow) => {
+      throw toThrow;
+    };
+    var scriptDirectory = '';
+    var readAsync, readBinary;
+    if (ENVIRONMENT_IS_SHELL) {
+      readBinary = (f) => {
+        if (typeof readbuffer == 'function') {
+          return new Uint8Array(readbuffer(f));
+        }
+        let data = read(f, 'binary');
+        assert(typeof data == 'object');
+        return data;
+      };
+      readAsync = async (f) => readBinary(f);
+      globalThis.clearTimeout ??= (id) => {};
+      globalThis.setTimeout ??= (f) => f();
+      arguments_ = globalThis.arguments || globalThis.scriptArgs;
+      if (typeof quit == 'function') {
+        quit_ = (status, toThrow) => {
+          setTimeout(() => {
+            if (!(toThrow instanceof ExitStatus)) {
+              let toLog = toThrow;
+              if (toThrow && typeof toThrow == 'object' && toThrow.stack) {
+                toLog = [toThrow, toThrow.stack];
+              }
+              err(`exiting due to exception: ${toLog}`);
+            }
+            quit(status);
+          });
+          throw toThrow;
+        };
+      }
+      if (typeof print != 'undefined') {
+        globalThis.console ??= {};
+        console.log = print;
+        console.warn = console.error = globalThis.printErr ?? print;
+      }
+    } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+      if (ENVIRONMENT_IS_WORKER) {
+        scriptDirectory = self.location.href;
+      } else if (typeof document != 'undefined' && document.currentScript) {
+        scriptDirectory = document.currentScript.src;
+      }
+      if (_scriptName) {
+        scriptDirectory = _scriptName;
+      }
+      if (scriptDirectory.startsWith('blob:')) {
+        scriptDirectory = '';
+      } else {
+        scriptDirectory = scriptDirectory.slice(
+          0,
+          scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/') + 1
+        );
+      }
+      {
+        if (ENVIRONMENT_IS_WORKER) {
+          readBinary = (url) => {
+            var xhr = new XMLHttpRequest();
+            xhr.open('GET', url, false);
+            xhr.responseType = 'arraybuffer';
+            xhr.send(null);
+            return new Uint8Array(xhr.response);
+          };
+        }
+        readAsync = async (url) => {
+          var response = await fetch(url, { credentials: 'same-origin' });
+          if (response.ok) {
+            return response.arrayBuffer();
+          }
+          throw new Error(response.status + ' : ' + response.url);
+        };
+      }
+    } else {
+    }
+    var out = console.log.bind(console);
+    var err = console.error.bind(console);
+    Object.assign(Module, moduleOverrides);
+    moduleOverrides = null;
+    var wasmBinary;
+    var wasmMemory;
+    var ABORT = false;
+    var EXITSTATUS;
+    var HEAP8,
+      HEAPU8,
+      HEAP16,
+      HEAPU16,
+      HEAP32,
+      HEAPU32,
+      HEAPF32,
+      HEAP64,
+      HEAPU64,
+      HEAPF64;
+    var runtimeInitialized = false;
+    function updateMemoryViews() {
+      var b = wasmMemory.buffer;
+      Module['HEAP8'] = HEAP8 = new Int8Array(b);
+      HEAP16 = new Int16Array(b);
+      HEAPU8 = new Uint8Array(b);
+      HEAPU16 = new Uint16Array(b);
+      HEAP32 = new Int32Array(b);
+      HEAPU32 = new Uint32Array(b);
+      HEAPF32 = new Float32Array(b);
+      HEAPF64 = new Float64Array(b);
+      HEAP64 = new BigInt64Array(b);
+      HEAPU64 = new BigUint64Array(b);
+    }
+    function preRun() {}
+    function initRuntime() {
+      runtimeInitialized = true;
+      wasmExports['e']();
+    }
+    function preMain() {}
+    function postRun() {}
+    var runDependencies = 0;
+    var dependenciesFulfilled = null;
+    function addRunDependency(id) {
+      runDependencies++;
+    }
+    function removeRunDependency(id) {
+      runDependencies--;
+      if (runDependencies == 0) {
+        if (dependenciesFulfilled) {
+          var callback = dependenciesFulfilled;
+          dependenciesFulfilled = null;
+          callback();
+        }
+      }
+    }
+    function abort(what) {
+      what = 'Aborted(' + what + ')';
+      err(what);
+      ABORT = true;
+      what += '. Build with -sASSERTIONS for more info.';
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject(e);
+      throw e;
+    }
+    var wasmBinaryFile =
+      'data:application/octet-stream;base64,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';
+    function getBinarySync(file) {
+      if (file == wasmBinaryFile && wasmBinary) {
+        return new Uint8Array(wasmBinary);
+      }
+      var binary = tryParseAsDataURI(file);
+      if (binary) {
+        return binary;
+      }
+      if (readBinary) {
+        return readBinary(file);
+      }
+      throw 'both async and sync fetching of the wasm failed';
+    }
+    async function getWasmBinary(binaryFile) {
+      return getBinarySync(binaryFile);
+    }
+    async function instantiateArrayBuffer(binaryFile, imports) {
+      try {
+        var binary = await getWasmBinary(binaryFile);
+        var instance = await WebAssembly.instantiate(binary, imports);
+        return instance;
+      } catch (reason) {
+        err(`failed to asynchronously prepare wasm: ${reason}`);
+        abort(reason);
+      }
+    }
+    async function instantiateAsync(binary, binaryFile, imports) {
+      return instantiateArrayBuffer(binaryFile, imports);
+    }
+    function getWasmImports() {
+      return { a: wasmImports };
+    }
+    async function createWasm() {
+      function receiveInstance(instance, module) {
+        wasmExports = instance.exports;
+        wasmMemory = wasmExports['d'];
+        updateMemoryViews();
+        removeRunDependency('wasm-instantiate');
+        return wasmExports;
+      }
+      addRunDependency('wasm-instantiate');
+      function receiveInstantiationResult(result) {
+        return receiveInstance(result['instance']);
+      }
+      var info = getWasmImports();
+      try {
+        var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+        var exports = receiveInstantiationResult(result);
+        return exports;
+      } catch (e) {
+        readyPromiseReject(e);
+        return Promise.reject(e);
+      }
+    }
+    class ExitStatus {
+      name = 'ExitStatus';
+      constructor(status) {
+        this.message = `Program terminated with exit(${status})`;
+        this.status = status;
+      }
+    }
+    var base64Decode = (b64) => {
+      var b1,
+        b2,
+        i = 0,
+        j = 0,
+        bLength = b64.length;
+      var output = new Uint8Array(
+        ((bLength * 3) >> 2) -
+          (b64[bLength - 2] == '=') -
+          (b64[bLength - 1] == '=')
+      );
+      for (; i < bLength; i += 4, j += 3) {
+        b1 = base64ReverseLookup[b64.charCodeAt(i + 1)];
+        b2 = base64ReverseLookup[b64.charCodeAt(i + 2)];
+        output[j] = (base64ReverseLookup[b64.charCodeAt(i)] << 2) | (b1 >> 4);
+        output[j + 1] = (b1 << 4) | (b2 >> 2);
+        output[j + 2] = (b2 << 6) | base64ReverseLookup[b64.charCodeAt(i + 3)];
+      }
+      return output;
+    };
+    var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
+    var dataURIPrefix = 'data:application/octet-stream;base64,';
+    var tryParseAsDataURI = (filename) => {
+      if (isDataURI(filename)) {
+        return base64Decode(filename.slice(dataURIPrefix.length));
+      }
+    };
+    var __abort_js = () => abort('');
+    var getHeapMax = () => 2147483648;
+    var alignMemory = (size, alignment) =>
+      Math.ceil(size / alignment) * alignment;
+    var abortOnCannotGrowMemory = (requestedSize) => {
+      abort('OOM');
+    };
+    var growMemory = (size) => {
+      var b = wasmMemory.buffer;
+      var pages = ((size - b.byteLength + 65535) / 65536) | 0;
+      try {
+        wasmMemory.grow(pages);
+        updateMemoryViews();
+        return 1;
+      } catch (e) {}
+    };
+    var _emscripten_resize_heap = (requestedSize) => {
+      var oldSize = HEAPU8.length;
+      requestedSize >>>= 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        abortOnCannotGrowMemory(requestedSize);
+      }
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + 0.5 / cutDown);
+        overGrownHeapSize = Math.min(
+          overGrownHeapSize,
+          requestedSize + 100663296
+        );
+        var newSize = Math.min(
+          maxHeapSize,
+          alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)
+        );
+        var replacement = growMemory(newSize);
+        if (replacement) {
+          return true;
+        }
+      }
+      abortOnCannotGrowMemory(requestedSize);
+    };
+    var initRandomFill = () => (view) => crypto.getRandomValues(view);
+    var randomFill = (view) => {
+      (randomFill = initRandomFill())(view);
+    };
+    var _random_get = (buffer, size) => {
+      randomFill(HEAPU8.subarray(buffer, buffer + size));
+      return 0;
+    };
+    var keepRuntimeAlive = () => true;
+    var _proc_exit = (code) => {
+      EXITSTATUS = code;
+      if (!keepRuntimeAlive()) {
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    };
+    var exitJS = (status, implicit) => {
+      EXITSTATUS = status;
+      _proc_exit(status);
+    };
+    var handleException = (e) => {
+      if (e instanceof ExitStatus || e == 'unwind') {
+        return EXITSTATUS;
+      }
+      quit_(1, e);
+    };
+    var UTF8Decoder =
+      typeof TextDecoder != 'undefined' ? new TextDecoder() : undefined;
+    var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => {
+      var endIdx = idx + maxBytesToRead;
+      var endPtr = idx;
+      while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+      }
+      var str = '';
+      while (idx < endPtr) {
+        var u0 = heapOrArray[idx++];
+        if (!(u0 & 128)) {
+          str += String.fromCharCode(u0);
+          continue;
+        }
+        var u1 = heapOrArray[idx++] & 63;
+        if ((u0 & 224) == 192) {
+          str += String.fromCharCode(((u0 & 31) << 6) | u1);
+          continue;
+        }
+        var u2 = heapOrArray[idx++] & 63;
+        if ((u0 & 240) == 224) {
+          u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+        } else {
+          u0 =
+            ((u0 & 7) << 18) |
+            (u1 << 12) |
+            (u2 << 6) |
+            (heapOrArray[idx++] & 63);
+        }
+        if (u0 < 65536) {
+          str += String.fromCharCode(u0);
+        } else {
+          var ch = u0 - 65536;
+          str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+        }
+      }
+      return str;
+    };
+    var UTF8ToString = (ptr, maxBytesToRead) =>
+      ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
+    for (var base64ReverseLookup = new Uint8Array(123), i = 25; i >= 0; --i) {
+      base64ReverseLookup[48 + i] = 52 + i;
+      base64ReverseLookup[65 + i] = i;
+      base64ReverseLookup[97 + i] = 26 + i;
+    }
+    base64ReverseLookup[43] = 62;
+    base64ReverseLookup[47] = 63;
+    var wasmImports = {
+      c: __abort_js,
+      b: _emscripten_resize_heap,
+      a: _random_get,
+    };
+    var wasmExports = await createWasm();
+    var ___wasm_call_ctors = wasmExports['e'];
+    var _setBuffers = (Module['_setBuffers'] = wasmExports['g']);
+    var _blockSamples = (Module['_blockSamples'] = wasmExports['h']);
+    var _intervalSamples = (Module['_intervalSamples'] = wasmExports['i']);
+    var _inputLatency = (Module['_inputLatency'] = wasmExports['j']);
+    var _outputLatency = (Module['_outputLatency'] = wasmExports['k']);
+    var _reset = (Module['_reset'] = wasmExports['l']);
+    var _presetDefault = (Module['_presetDefault'] = wasmExports['m']);
+    var _presetCheaper = (Module['_presetCheaper'] = wasmExports['n']);
+    var _configure = (Module['_configure'] = wasmExports['o']);
+    var _setTransposeFactor = (Module['_setTransposeFactor'] =
+      wasmExports['p']);
+    var _setTransposeSemitones = (Module['_setTransposeSemitones'] =
+      wasmExports['q']);
+    var _seek = (Module['_seek'] = wasmExports['r']);
+    var _process = (Module['_process'] = wasmExports['s']);
+    var _flush = (Module['_flush'] = wasmExports['t']);
+    var _main = (Module['_main'] = wasmExports['u']);
+    Module['UTF8ToString'] = UTF8ToString;
+    function callMain() {
+      var entryFunction = _main;
+      var argc = 0;
+      var argv = 0;
+      try {
+        var ret = entryFunction(argc, argv);
+        exitJS(ret, true);
+        return ret;
+      } catch (e) {
+        return handleException(e);
+      }
+    }
+    function run() {
+      if (runDependencies > 0) {
+        dependenciesFulfilled = run;
+        return;
+      }
+      preRun();
+      if (runDependencies > 0) {
+        dependenciesFulfilled = run;
+        return;
+      }
+      function doRun() {
+        Module['calledRun'] = true;
+        if (ABORT) return;
+        initRuntime();
+        preMain();
+        readyPromiseResolve(Module);
+        var noInitialRun;
+        if (!noInitialRun) callMain();
+        postRun();
+      }
+      {
+        doRun();
+      }
+    }
+    run();
+    moduleRtn = readyPromise;
+
+    return moduleRtn;
+  };
+})();
+function registerWorkletProcessor(Module, audioNodeKey) {
+  class WasmProcessor extends AudioWorkletProcessor {
+    constructor(options) {
+      super(options);
+      this.wasmReady = false;
+      this.wasmModule = null;
+      this.channels = 0;
+      this.buffersIn = [];
+      this.buffersOut = [];
+
+      this.audioBuffers = []; // list of (multi-channel) audio buffers
+      this.audioBuffersStart = 0; // time-stamp for the first audio buffer
+      this.audioBuffersEnd = 0; // just to be helpful
+
+      this.timeIntervalSamples = sampleRate * 0.1;
+      this.timeIntervalCounter = 0;
+
+      this.timeMap = [
+        {
+          active: false,
+          input: 0,
+          output: 0,
+          rate: 1,
+          semitones: 0,
+          loopStart: 0,
+          loopEnd: 0,
+        },
+      ];
+
+      let remoteMethods = {
+        configure: (config) => {
+          let blockChanged =
+            config.blockMs != this.config.blockMs ||
+            config.intervalMs != this.config.intervalMs;
+          Object.assign(this.config, config);
+          if (config.blockMs && blockChanged) this.configure();
+        },
+        setUpdateInterval: (seconds) => {
+          this.timeIntervalSamples = sampleRate * seconds;
+        },
+        stop: (when) => {
+          if (typeof when !== 'number') when = currentTime;
+          return remoteMethods.schedule({ active: false, output: when });
+        },
+        start: (when, offset, duration, rate, semitones) => {
+          if (typeof when === 'object') {
+            if (!('active' in when)) when.active = true;
+            return remoteMethods.schedule(when);
+          }
+
+          let obj = {
+            active: true,
+            input: 0,
+            output: currentTime + this.outputLatencySeconds,
+          };
+          if (typeof when === 'number') obj.output = when;
+          if (typeof offset === 'number') obj.input = offset;
+          if (typeof rate === 'number') obj.rate = rate;
+          if (typeof semitones === 'number') obj.semitones = semitones;
+          let result = remoteMethods.schedule(obj);
+          if (typeof duration === 'number') {
+            remoteMethods.stop(obj.output + duration);
+            obj.output += duration;
+            obj.active = false;
+            remoteMethods.schedule(obj);
+          }
+          return result;
+        },
+        schedule: (objIn, adjustPrevious) => {
+          let outputTime =
+            'outputTime' in objIn ? objIn.outputTime : currentTime;
+
+          let latestSegment = this.timeMap[this.timeMap.length - 1];
+          while (
+            this.timeMap.length &&
+            this.timeMap[this.timeMap.length - 1].output >= outputTime
+          ) {
+            latestSegment = this.timeMap.pop();
+          }
+
+          let obj = {
+            active: latestSegment.active,
+            input: null,
+            output: outputTime,
+            rate: latestSegment.rate,
+            semitones: latestSegment.semitones,
+            loopStart: latestSegment.loopStart,
+            loopEnd: latestSegment.loopEnd,
+          };
+          Object.assign(obj, objIn);
+          if (obj.input === null) {
+            let rate = latestSegment.active ? latestSegment.rate : 0;
+            obj.input =
+              latestSegment.input + (obj.output - latestSegment.output) * rate;
+          }
+          this.timeMap.push(obj);
+
+          if (adjustPrevious && this.timeMap.length > 1) {
+            let previous = this.timeMap[this.timeMap.length - 2];
+            if (previous.output < currentTime) {
+              let rate = previous.active ? previous.rate : 0;
+              previous.input += (currentTime - previous.output) * rate;
+              previous.output = currentTime;
+            }
+            previous.rate =
+              (obj.input - previous.input) / (obj.output - previous.output);
+          }
+
+          let currentMapSegment = this.timeMap[0];
+          while (
+            this.timeMap.length > 1 &&
+            this.timeMap[1].output <= outputTime
+          ) {
+            this.timeMap.shift();
+            currentMapSegment = this.timeMap[0];
+          }
+          let rate = currentMapSegment.active ? currentMapSegment.rate : 0;
+          let inputTime =
+            currentMapSegment.input +
+            (outputTime - currentMapSegment.output) * rate;
+          this.timeIntervalCounter = this.timeIntervalSamples;
+          this.port.postMessage(['time', inputTime]);
+
+          return obj;
+        },
+        dropBuffers: (toSeconds) => {
+          if (typeof toSeconds !== 'number') {
+            let buffers = this.audioBuffers.flat(1).map((b) => b.buffer);
+            this.audioBuffers = [];
+            this.audioBuffersStart = this.audioBuffersEnd = 0;
+            return {
+              value: { start: 0, end: 0 },
+              transfer: buffers,
+            };
+          }
+          let transfer = [];
+          while (this.audioBuffers.length) {
+            let first = this.audioBuffers[0];
+            let length = first[0].length;
+            let endSamples = this.audioBuffersStart + length;
+            let endSeconds = endSamples / sampleRate;
+            if (endSeconds > toSeconds) break;
+
+            this.audioBuffers.shift().forEach((b) => transfer.push(b.buffer));
+            this.audioBuffersStart += length;
+          }
+          return {
+            value: {
+              start: this.audioBuffersStart / sampleRate,
+              end: this.audioBuffersEnd / sampleRate,
+            },
+            transfer: transfer,
+          };
+        },
+        addBuffers: (sampleBuffers) => {
+          sampleBuffers = [].concat(sampleBuffers);
+          this.audioBuffers.push(sampleBuffers);
+          let length = sampleBuffers[0].length;
+          this.audioBuffersEnd += length;
+          return this.audioBuffersEnd / sampleRate;
+        },
+      };
+
+      let pendingMessages = [];
+      this.port.onmessage = (event) => pendingMessages.push(event);
+
+      Module().then((wasmModule) => {
+        this.wasmModule = wasmModule;
+        this.wasmReady = true;
+
+        wasmModule._main();
+
+        this.channels = options.numberOfOutputs
+          ? options.outputChannelCount[0]
+          : 2; // stereo by default
+        this.configure();
+
+        this.port.onmessage = (event) => {
+          let data = event.data;
+          let messageId = data.shift();
+          let method = data.shift();
+          let result = remoteMethods[method](...data);
+          if (result?.transfer) {
+            this.port.postMessage([messageId, result.value], result.transfer);
+          } else {
+            this.port.postMessage([messageId, result]);
+          }
+        };
+        let methodArgCounts = {};
+        for (let key in remoteMethods) {
+          methodArgCounts[key] = remoteMethods[key].length;
+        }
+        this.port.postMessage(['ready', methodArgCounts]);
+        pendingMessages.forEach(this.port.onmessage);
+        pendingMessages = null;
+      });
+    }
+
+    config = {
+      tonalityHz: 8000,
+    };
+    configure() {
+      if (this.config.blockMs) {
+        let blockSamples = Math.round(
+          (this.config.blockMs / 1000) * sampleRate
+        );
+        let intervalSamples = Math.round(
+          ((this.config.intervalMs || this.config.blockMs * 0.25) / 1000) *
+            sampleRate
+        );
+        this.wasmModule._configure(
+          this.channels,
+          blockSamples,
+          intervalSamples
+        );
+        this.wasmModule._reset();
+      } else {
+        this.wasmModule._presetDefault(this.channels, sampleRate);
+      }
+      this.updateBuffers();
+      this.inputLatencySeconds = this.wasmModule._inputLatency() / sampleRate;
+      this.outputLatencySeconds = this.wasmModule._outputLatency() / sampleRate;
+    }
+
+    updateBuffers() {
+      let wasmModule = this.wasmModule;
+      // longer than one STFT block, so we can seek smoothly
+      this.bufferLength =
+        wasmModule._inputLatency() + wasmModule._outputLatency();
+
+      let lengthBytes = this.bufferLength * 4;
+      let bufferPointer = wasmModule._setBuffers(
+        this.channels,
+        this.bufferLength
+      );
+      this.buffersIn = [];
+      this.buffersOut = [];
+      for (let c = 0; c < this.channels; ++c) {
+        this.buffersIn.push(bufferPointer + lengthBytes * c);
+        this.buffersOut.push(bufferPointer + lengthBytes * (c + this.channels));
+      }
+    }
+
+    process(inputList, outputList, parameters) {
+      if (!this.wasmReady) {
+        outputList.forEach((output) => {
+          output.forEach((channel) => {
+            channel.fill(0);
+          });
+        });
+        return true;
+      }
+      if (!outputList[0]?.length) return false;
+
+      let outputTime = currentTime + this.outputLatencySeconds;
+      while (this.timeMap.length > 1 && this.timeMap[1].output <= outputTime) {
+        this.timeMap.shift();
+      }
+      let currentMapSegment = this.timeMap[0];
+
+      let wasmModule = this.wasmModule;
+      wasmModule._setTransposeSemitones(
+        currentMapSegment.semitones,
+        this.config.tonalityHz / sampleRate
+      );
+
+      // Check the input/output channel counts
+      if (outputList[0].length != this.channels) {
+        this.channels = outputList[0]?.length || 0;
+        configure();
+      }
+      let outputBlockSize = outputList[0][0].length;
+
+      let memory = wasmModule.exports
+        ? wasmModule.exports.memory.buffer
+        : wasmModule.HEAP8.buffer;
+      // Buffer list (one per channel)
+      let inputs = inputList[0];
+      if (!currentMapSegment.active) {
+        outputList[0].forEach((_, c) => {
+          let channelBuffer = inputs[c % inputs.length];
+          let buffer = new Float32Array(
+            memory,
+            this.buffersIn[c],
+            outputBlockSize
+          );
+          buffer.fill(0);
+        });
+        // Should detect silent input and skip processing
+        wasmModule._process(outputBlockSize, outputBlockSize);
+      } else if (inputs?.length) {
+        // Live input
+        outputList[0].forEach((_, c) => {
+          let channelBuffer = inputs[c % inputs.length];
+          let buffer = new Float32Array(
+            memory,
+            this.buffersIn[c],
+            outputBlockSize
+          );
+          if (channelBuffer) {
+            buffer.set(channelBuffer);
+          } else {
+            buffer.fill(0);
+          }
+        });
+        wasmModule._process(outputBlockSize, outputBlockSize);
+      } else {
+        let inputTime =
+          currentMapSegment.input +
+          (outputTime - currentMapSegment.output) * currentMapSegment.rate;
+        let loopLength =
+          currentMapSegment.loopEnd - currentMapSegment.loopStart;
+        if (loopLength > 0 && inputTime >= currentMapSegment.loopEnd) {
+          currentMapSegment.input -= loopLength;
+          inputTime -= loopLength;
+        }
+
+        inputTime += this.inputLatencySeconds;
+        let inputSamplesEnd = Math.round(inputTime * sampleRate);
+
+        // Fill the buffer with previous input
+        let buffers = outputList[0].map(
+          (_, c) =>
+            new Float32Array(memory, this.buffersIn[c], this.bufferLength)
+        );
+
+        let blockSamples = 0; // current write position in the temporary input buffer
+        let audioBufferIndex = 0;
+        let audioSamples = this.audioBuffersStart; // start of current audio buffer
+        // zero-pad until the start of the audio data
+        let inputSamples = inputSamplesEnd - this.bufferLength;
+        if (inputSamples < audioSamples) {
+          blockSamples = audioSamples - inputSamples;
+          buffers.forEach((b) => b.fill(0, 0, blockSamples));
+          inputSamples = audioSamples;
+        }
+        while (
+          audioBufferIndex < this.audioBuffers.length &&
+          audioSamples < inputSamplesEnd
+        ) {
+          let audioBuffer = this.audioBuffers[audioBufferIndex];
+          let startIndex = inputSamples - audioSamples; // start index within the audio buffer
+          let bufferEnd = audioSamples + audioBuffer[0].length;
+          // how many samples to copy: min(how many left in the buffer, how many more we need)
+          let count = Math.min(
+            audioBuffer[0].length - startIndex,
+            inputSamplesEnd - inputSamples
+          );
+          if (count > 0) {
+            buffers.forEach((buffer, c) => {
+              let channelBuffer = audioBuffer[c % audioBuffer.length];
+              buffer
+                .subarray(blockSamples)
+                .set(channelBuffer.subarray(startIndex, startIndex + count));
+            });
+            audioSamples += count;
+            blockSamples += count;
+          } else {
+            // we're already past this buffer - skip it
+            audioSamples += audioBuffer[0].length;
+          }
+          ++audioBufferIndex;
+        }
+        if (blockSamples < this.bufferLength) {
+          buffers.forEach((buffer) => buffer.subarray(blockSamples).fill(0));
+        }
+
+        // constantly seeking, so we don't have to worry about the input buffers needing to be a rate-dependent size
+        wasmModule._seek(this.bufferLength, currentMapSegment.rate);
+        wasmModule._process(0, outputBlockSize);
+
+        this.timeIntervalCounter -= outputBlockSize;
+        if (this.timeIntervalCounter <= 0) {
+          this.timeIntervalCounter = this.timeIntervalSamples;
+          this.port.postMessage(['time', inputTime]);
+        }
+      }
+
+      // Re-fetch in case the memory changed (even though there *shouldn't* be any allocations)
+      memory = wasmModule.exports
+        ? wasmModule.exports.memory.buffer
+        : wasmModule.HEAP8.buffer;
+      outputList[0].forEach((channelBuffer, c) => {
+        let buffer = new Float32Array(
+          memory,
+          this.buffersOut[c],
+          outputBlockSize
+        );
+        channelBuffer.set(buffer);
+      });
+
+      return true;
+    }
+  }
+
+  registerProcessor(audioNodeKey, WasmProcessor);
+}
+
+/**
+	Creates a Stretch node
+	@async
+	@function SignalsmithStretch
+	@param {AudioContext} audioContext
+	@param {Object} options - channel configuration (as per [options]{@link https://developer.mozilla.org/en-US/docs/Web/API/AudioWorkletNode/AudioWorkletNode#options})
+	@returns {Promise<StretchNode>}
+*/
+SignalsmithStretch = ((Module, audioNodeKey) => {
+  if (
+    typeof AudioWorkletProcessor === 'function' &&
+    typeof registerProcessor === 'function'
+  ) {
+    // AudioWorklet side
+    registerWorkletProcessor(Module, audioNodeKey);
+    return {};
+  }
+  let promiseKey = Symbol();
+  let createNode = async function (audioContext, options) {
+    /**
+			@classdesc An `AudioWorkletNode` with Signalsmith Stretch extensions
+			@name StretchNode
+			@augments AudioWorkletNode
+			@property {number} inputTime - the current playback (in seconds) within the input audio stored by the node
+		 */
+    let audioNode;
+    options = options || {
+      numberOfInputs: 1,
+      numberOfOutputs: 1,
+      outputChannelCount: [2],
+    };
+    try {
+      audioNode = new AudioWorkletNode(audioContext, audioNodeKey, options);
+    } catch (e) {
+      if (!audioContext[promiseKey]) {
+        let moduleUrl = createNode.moduleUrl;
+        if (!moduleUrl) {
+          let moduleCode = `(${registerWorkletProcessor})((_scriptName=>${Module})(),${JSON.stringify(audioNodeKey)})`;
+          moduleUrl = URL.createObjectURL(
+            new Blob([moduleCode], { type: 'text/javascript' })
+          );
+        }
+        audioContext[promiseKey] =
+          audioContext.audioWorklet.addModule(moduleUrl);
+      }
+      await audioContext[promiseKey];
+      audioNode = new AudioWorkletNode(audioContext, audioNodeKey, options);
+    }
+
+    // messages with Promise responses
+    let requestMap = {};
+    let idCounter = 0;
+    let timeUpdateCallback = null;
+    let post = (transfer, ...data) => {
+      let id = idCounter++;
+      return new Promise((resolve) => {
+        requestMap[id] = resolve;
+        audioNode.port.postMessage([id].concat(data), transfer);
+      });
+    };
+    audioNode.inputTime = 0;
+    audioNode.port.onmessage = (event) => {
+      let data = event.data;
+      let id = data[0],
+        value = data[1];
+      if (id == 'time') {
+        audioNode.inputTime = value;
+        if (timeUpdateCallback) timeUpdateCallback(value);
+      }
+      if (id in requestMap) {
+        requestMap[id](value);
+        delete requestMap[id];
+      }
+    };
+
+    return new Promise((resolve) => {
+      requestMap['ready'] = (remoteMethodKeys) => {
+        Object.keys(remoteMethodKeys).forEach((key) => {
+          let argCount = remoteMethodKeys[key];
+          audioNode[key] = (...args) => {
+            let transfer = null;
+            if (args.length > argCount) {
+              transfer = args.pop();
+            }
+            return post(transfer, key, ...args);
+          };
+        });
+        /** @lends StretchNode.prototype
+					@method setUpdateInterval
+				*/
+        audioNode.setUpdateInterval = (seconds, callback) => {
+          timeUpdateCallback = callback;
+          return post(null, 'setUpdateInterval', seconds);
+        };
+        resolve(audioNode);
+      };
+    });
+  };
+  return createNode;
+})(SignalsmithStretch, 'signalsmith-stretch');
+// register as a CommonJS/AMD module
+if (typeof exports === 'object' && typeof module === 'object') {
+  module.exports = SignalsmithStretch;
+} else if (typeof define === 'function' && define['amd']) {
+  define([], () => SignalsmithStretch);
+}