@libraz/libsonare 1.5.4 → 1.6.0

package/dist/analysis.js

@@ -0,0 +1,2464 @@
+// src/errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["Ok"] = 0] = "Ok";
+  ErrorCode2[ErrorCode2["FileNotFound"] = 1] = "FileNotFound";
+  ErrorCode2[ErrorCode2["InvalidFormat"] = 2] = "InvalidFormat";
+  ErrorCode2[ErrorCode2["DecodeFailed"] = 3] = "DecodeFailed";
+  ErrorCode2[ErrorCode2["InvalidParameter"] = 4] = "InvalidParameter";
+  ErrorCode2[ErrorCode2["OutOfMemory"] = 5] = "OutOfMemory";
+  ErrorCode2[ErrorCode2["NotSupported"] = 6] = "NotSupported";
+  ErrorCode2[ErrorCode2["InvalidState"] = 7] = "InvalidState";
+  ErrorCode2[ErrorCode2["Cancelled"] = 8] = "Cancelled";
+  ErrorCode2[ErrorCode2["Unknown"] = 99] = "Unknown";
+  return ErrorCode2;
+})(ErrorCode || {});
+var SonareError = class extends Error {
+  constructor(code, codeName, message) {
+    super(message);
+    this.name = "SonareError";
+    this.code = code;
+    this.codeName = codeName;
+  }
+};
+function isSonareError(value) {
+  return value instanceof Error && value.name === "SonareError" && typeof value.code === "number";
+}
+
+// src/module_state.ts
+var wrappedModule = null;
+function nativeExceptionPtr(error) {
+  if (typeof error === "number") {
+    return error;
+  }
+  if (error !== null && typeof error === "object") {
+    const ptr = error.excPtr;
+    if (typeof ptr === "number") {
+      return ptr;
+    }
+  }
+  return null;
+}
+function makeSonareError(raw, thrown) {
+  let code = 99 /* Unknown */;
+  let codeName = "Unknown";
+  let message = `libsonare native exception (${thrown})`;
+  try {
+    const info = raw.sonareExceptionInfo?.(thrown);
+    if (info) {
+      code = info.code ?? code;
+      codeName = info.codeName ?? codeName;
+      message = info.message || message;
+    }
+  } catch {
+  }
+  return new SonareError(code, codeName, message);
+}
+function wrapModuleErrors(raw) {
+  const cache = /* @__PURE__ */ new Map();
+  const objectCache = /* @__PURE__ */ new WeakMap();
+  const convert = (error) => {
+    const ptr = nativeExceptionPtr(error);
+    if (ptr !== null) {
+      throw makeSonareError(raw, ptr);
+    }
+    throw error;
+  };
+  const wrapNativeObject = (value) => {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Promise) {
+      return value;
+    }
+    const objectValue = value;
+    const cached = objectCache.get(objectValue);
+    if (cached) {
+      return cached;
+    }
+    const methodCache = /* @__PURE__ */ new Map();
+    const wrapped = new Proxy(objectValue, {
+      get(target, prop, receiver) {
+        const member = Reflect.get(target, prop, receiver);
+        if (typeof member !== "function") {
+          return member;
+        }
+        const cachedMethod = methodCache.get(prop);
+        if (cachedMethod) {
+          return cachedMethod;
+        }
+        const method = member;
+        const wrappedMethod = (...args) => {
+          try {
+            return wrapNativeObject(Reflect.apply(method, target, args));
+          } catch (error) {
+            return convert(error);
+          }
+        };
+        methodCache.set(prop, wrappedMethod);
+        return wrappedMethod;
+      }
+    });
+    objectCache.set(objectValue, wrapped);
+    return wrapped;
+  };
+  const wrapFunction = (value) => {
+    const fnCache = /* @__PURE__ */ new Map();
+    return new Proxy(value, {
+      get(target, prop, receiver) {
+        const member = Reflect.get(target, prop, receiver);
+        if (typeof member !== "function") {
+          return member;
+        }
+        const cachedMember = fnCache.get(prop);
+        if (cachedMember) {
+          return cachedMember;
+        }
+        const fn = member;
+        const wrappedMember = (...args) => {
+          try {
+            return wrapNativeObject(Reflect.apply(fn, target, args));
+          } catch (error) {
+            return convert(error);
+          }
+        };
+        fnCache.set(prop, wrappedMember);
+        return wrappedMember;
+      },
+      apply(t, thisArg, args) {
+        try {
+          return wrapNativeObject(Reflect.apply(t, thisArg, args));
+        } catch (error) {
+          return convert(error);
+        }
+      },
+      construct(t, args, newTarget) {
+        try {
+          return wrapNativeObject(Reflect.construct(t, args, newTarget));
+        } catch (error) {
+          return convert(error);
+        }
+      }
+    });
+  };
+  return new Proxy(raw, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      const cached = cache.get(prop);
+      if (cached) {
+        return cached;
+      }
+      const wrapped = wrapFunction(value);
+      cache.set(prop, wrapped);
+      return wrapped;
+    }
+  });
+}
+function setSonareModule(module2) {
+  wrappedModule = wrapModuleErrors(module2);
+}
+function getSonareModule() {
+  if (!wrappedModule) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return wrappedModule;
+}
+
+// src/feature_core.ts
+function requireModule() {
+  return getSonareModule();
+}
+function tone(frequency = 440, sampleRate = 22050, duration = 1, phase = 0, amplitude = 1) {
+  const request = typeof frequency === "number" ? { frequency, sampleRate, duration, phase, amplitude } : frequency;
+  return requireModule().tone(
+    request.frequency ?? 440,
+    request.sampleRate ?? 22050,
+    request.duration ?? 1,
+    request.phase ?? 0,
+    request.amplitude ?? 1
+  );
+}
+function chirp(fmin = 440, fmax = 880, sampleRate = 22050, duration = 1, linear = true) {
+  const request = typeof fmin === "number" ? { fmin, fmax, sampleRate, duration, linear } : fmin;
+  return requireModule().chirp(
+    request.fmin ?? 440,
+    request.fmax ?? 880,
+    request.sampleRate ?? 22050,
+    request.duration ?? 1,
+    request.linear ?? true
+  );
+}
+function clicks(times, sampleRate = 22050, length = 0, frequency = 1e3, clickDuration = 0.1) {
+  const request = times instanceof Float32Array ? { times, sampleRate, length, frequency, clickDuration } : times;
+  return requireModule().clicks(
+    request.times,
+    request.sampleRate ?? 22050,
+    request.length ?? 0,
+    request.frequency ?? 1e3,
+    request.clickDuration ?? 0.1
+  );
+}
+function hzToMel(hz) {
+  return requireModule().hzToMel(hz);
+}
+function melToHz(mel) {
+  return requireModule().melToHz(mel);
+}
+function hzToMidi(hz) {
+  return requireModule().hzToMidi(hz);
+}
+function midiToHz(midi) {
+  return requireModule().midiToHz(midi);
+}
+function hzToNote(hz) {
+  return requireModule().hzToNote(hz);
+}
+function noteToHz(note) {
+  return requireModule().noteToHz(note);
+}
+function framesToTime(frames, sr = 22050, hopLength = 512) {
+  return requireModule().framesToTime(frames, sr, hopLength);
+}
+function timeToFrames(time, sr = 22050, hopLength = 512) {
+  return requireModule().timeToFrames(time, sr, hopLength);
+}
+function framesToSamples(frames, hopLength = 512, nFft = 0) {
+  return requireModule().framesToSamples(frames, hopLength, nFft);
+}
+function samplesToFrames(samples, hopLength = 512, nFft = 0) {
+  return requireModule().samplesToFrames(samples, hopLength, nFft);
+}
+function powerToDb(values, ref = 1, amin = 1e-10, topDb = 80) {
+  if (!(values instanceof Float32Array)) {
+    return powerToDb(values.values, values.ref, values.amin, values.topDb);
+  }
+  return requireModule().powerToDb(values, ref, amin, topDb);
+}
+function amplitudeToDb(values, ref = 1, amin = 1e-5, topDb = 80) {
+  if (!(values instanceof Float32Array)) {
+    return amplitudeToDb(values.values, values.ref, values.amin, values.topDb);
+  }
+  return requireModule().amplitudeToDb(values, ref, amin, topDb);
+}
+function dbToPower(values, ref = 1) {
+  return requireModule().dbToPower(values, ref);
+}
+function dbToAmplitude(values, ref = 1) {
+  return requireModule().dbToAmplitude(values, ref);
+}
+function preemphasis(samples, coef = 0.97, zi) {
+  if (!(samples instanceof Float32Array)) {
+    return preemphasis(samples.samples, samples.coef, samples.zi);
+  }
+  return requireModule().preemphasis(samples, coef, zi ?? null);
+}
+function deemphasis(samples, coef = 0.97, zi) {
+  if (!(samples instanceof Float32Array)) {
+    return deemphasis(samples.samples, samples.coef, samples.zi);
+  }
+  return requireModule().deemphasis(samples, coef, zi ?? null);
+}
+function trimSilence(samples, topDb = 60, frameLength = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return trimSilence(samples.samples, samples.topDb, samples.frameLength, samples.hopLength);
+  }
+  return requireModule().trimSilence(samples, topDb, frameLength, hopLength);
+}
+function splitSilence(samples, topDb = 60, frameLength = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return splitSilence(samples.samples, samples.topDb, samples.frameLength, samples.hopLength);
+  }
+  return requireModule().splitSilence(samples, topDb, frameLength, hopLength);
+}
+function frameSignal(samples, frameLength, hopLength) {
+  if (!(samples instanceof Float32Array)) {
+    return frameSignal(samples.samples, samples.frameLength, samples.hopLength);
+  }
+  return requireModule().frameSignal(samples, frameLength, hopLength);
+}
+function padCenter(values, targetSize, padValue = 0) {
+  if (!(values instanceof Float32Array)) {
+    return padCenter(values.values, values.targetSize, values.padValue);
+  }
+  return requireModule().padCenter(values, targetSize, padValue);
+}
+function fixLength(values, targetSize, padValue = 0) {
+  if (!(values instanceof Float32Array)) {
+    return fixLength(values.values, values.targetSize, values.padValue);
+  }
+  return requireModule().fixLength(values, targetSize, padValue);
+}
+function fixFrames(frames, xMin = 0, xMax = -1, pad = true) {
+  if (!(frames instanceof Int32Array)) {
+    return fixFrames(frames.frames, frames.xMin, frames.xMax, frames.pad);
+  }
+  return requireModule().fixFrames(frames, xMin, xMax, pad);
+}
+function onsetBacktrack(events, energy) {
+  if (!(events instanceof Int32Array)) {
+    return onsetBacktrack(events.events, events.energy);
+  }
+  return requireModule().onsetBacktrack(events, energy);
+}
+function peakPick(values, preMax, postMax, preAvg, postAvg, delta, wait) {
+  if (!(values instanceof Float32Array)) {
+    const r = values;
+    return peakPick(r.values, r.preMax, r.postMax, r.preAvg, r.postAvg, r.delta, r.wait);
+  }
+  return requireModule().peakPick(
+    values,
+    preMax,
+    postMax,
+    preAvg,
+    postAvg,
+    delta,
+    wait
+  );
+}
+function vectorNormalize(values, normType = 0, threshold = 0) {
+  if (!(values instanceof Float32Array)) {
+    return vectorNormalize(values.values, values.normType, values.threshold);
+  }
+  return requireModule().vectorNormalize(values, normType, threshold);
+}
+function pcen(values, nBins = 0, nFrames = 0, options = {}) {
+  if (!(values instanceof Float32Array)) {
+    const r = values;
+    const {
+      values: requestValues,
+      nBins: requestBins,
+      nFrames: requestFrames,
+      options: legacyOptions,
+      ...flatOptions
+    } = r;
+    return pcen(requestValues, requestBins, requestFrames, {
+      ...legacyOptions,
+      ...flatOptions
+    });
+  }
+  return requireModule().pcen(values, nBins, nFrames, options);
+}
+function tonnetz(chromagram, nChroma, nFrames) {
+  if (!(chromagram instanceof Float32Array)) {
+    return tonnetz(chromagram.chromagram, chromagram.nChroma, chromagram.nFrames);
+  }
+  return requireModule().tonnetz(chromagram, nChroma, nFrames);
+}
+function tempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, mode = "autocorrelation", center = true, norm = true) {
+  if (!(onsetEnvelope2 instanceof Float32Array)) {
+    const r = onsetEnvelope2;
+    return tempogram(
+      r.onsetEnvelope,
+      r.sampleRate,
+      r.hopLength,
+      r.winLength,
+      r.mode,
+      r.center,
+      r.norm
+    );
+  }
+  return requireModule().tempogram(
+    onsetEnvelope2,
+    sampleRate,
+    hopLength,
+    winLength,
+    mode,
+    center,
+    norm
+  );
+}
+function cyclicTempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, bpmMin = 60, nBins = 60) {
+  if (!(onsetEnvelope2 instanceof Float32Array)) {
+    const r = onsetEnvelope2;
+    return cyclicTempogram(
+      r.onsetEnvelope,
+      r.sampleRate,
+      r.hopLength,
+      r.winLength,
+      r.bpmMin,
+      r.nBins
+    );
+  }
+  return requireModule().cyclicTempogram(
+    onsetEnvelope2,
+    sampleRate,
+    hopLength,
+    winLength,
+    bpmMin,
+    nBins
+  );
+}
+function plp(onsetEnvelope2, sampleRate = 22050, hopLength = 512, tempoMin = 30, tempoMax = 300, winLength = 384) {
+  if (!(onsetEnvelope2 instanceof Float32Array)) {
+    const r = onsetEnvelope2;
+    return plp(r.onsetEnvelope, r.sampleRate, r.hopLength, r.tempoMin, r.tempoMax, r.winLength);
+  }
+  return requireModule().plp(onsetEnvelope2, sampleRate, hopLength, tempoMin, tempoMax, winLength);
+}
+
+// src/validation.ts
+var MIN_AUDIO_SAMPLE_RATE = 8e3;
+var MAX_AUDIO_SAMPLE_RATE = 384e3;
+function assertNonEmptySamples(fnName, samples, argName = "samples") {
+  if (samples.length === 0) {
+    throw new RangeError(`${fnName}: ${argName} must not be empty`);
+  }
+}
+function assertFiniteSamples(fnName, samples, validate, argName = "samples") {
+  if (!validate) {
+    return;
+  }
+  for (let i = 0; i < samples.length; i++) {
+    const v = samples[i];
+    if (!Number.isFinite(v)) {
+      throw new RangeError(`${fnName}: ${argName} contains NaN or Inf at index ${i}`);
+    }
+  }
+}
+function assertSamples(fnName, samples, validate, argName = "samples") {
+  assertNonEmptySamples(fnName, samples, argName);
+  assertFiniteSamples(fnName, samples, validate, argName);
+}
+function assertFiniteScalar(fnName, value, argName) {
+  if (!Number.isFinite(value)) {
+    throw new RangeError(`${fnName}: ${argName} must be a finite number`);
+  }
+}
+function assertSampleRate(fnName, sampleRate) {
+  if (!Number.isInteger(sampleRate) || sampleRate < MIN_AUDIO_SAMPLE_RATE || sampleRate > MAX_AUDIO_SAMPLE_RATE) {
+    throw new RangeError(
+      `${fnName}: sampleRate out of supported range [${MIN_AUDIO_SAMPLE_RATE}, ${MAX_AUDIO_SAMPLE_RATE}]`
+    );
+  }
+}
+function assertNonNegativeInteger(fnName, value, argName) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(`${fnName}: ${argName} must be a non-negative integer`);
+  }
+}
+function assertPositiveInteger(fnName, value, argName) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new RangeError(`${fnName}: ${argName} must be a positive integer`);
+  }
+}
+function assertInterleavedSamples(fnName, samples, channels, validate) {
+  assertSamples(fnName, samples, validate);
+  assertPositiveInteger(fnName, channels, "channels");
+  if (samples.length % channels !== 0) {
+    throw new RangeError(`${fnName}: samples length must be a multiple of channels`);
+  }
+}
+
+// src/feature_music.ts
+function requireModule2() {
+  return getSonareModule();
+}
+function validateMusicSamples(fnName, samples, sampleRate, options = {}) {
+  assertSampleRate(fnName, sampleRate);
+  assertSamples(fnName, samples, options.validate !== false);
+}
+function validatePositiveIntegers(fnName, values) {
+  for (const [name, value] of Object.entries(values)) {
+    assertPositiveInteger(fnName, value, name);
+  }
+}
+function validateFrequencyBounds(fnName, fmin, fmax) {
+  assertFiniteScalar(fnName, fmin, "fmin");
+  if (fmin < 0) {
+    throw new RangeError(`${fnName}: fmin must be non-negative`);
+  }
+  if (fmax !== void 0) {
+    assertFiniteScalar(fnName, fmax, "fmax");
+    if (fmax <= fmin) {
+      throw new RangeError(`${fnName}: fmax must be greater than fmin`);
+    }
+  }
+}
+function nnlsChroma(samples, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    return nnlsChroma(samples.samples, samples.sampleRate, samples);
+  }
+  validateMusicSamples("nnlsChroma", samples, sampleRate, options);
+  return requireModule2().nnlsChroma(
+    samples,
+    sampleRate,
+    options.enableStftBlend ?? true,
+    options.stftBlendWeight ?? 0.55,
+    options.stftBlendNFft ?? 4096
+  );
+}
+function cqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return cqt(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.nBins,
+      request.binsPerOctave,
+      request
+    );
+  }
+  validateMusicSamples("cqt", samples, sampleRate, options);
+  validatePositiveIntegers("cqt", { hopLength, nBins, binsPerOctave });
+  validateFrequencyBounds("cqt", fmin);
+  return requireModule2().cqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
+}
+function pseudoCqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return pseudoCqt(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.nBins,
+      request.binsPerOctave,
+      request
+    );
+  }
+  validateMusicSamples("pseudoCqt", samples, sampleRate, options);
+  validatePositiveIntegers("pseudoCqt", { hopLength, nBins, binsPerOctave });
+  validateFrequencyBounds("pseudoCqt", fmin);
+  return requireModule2().pseudoCqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
+}
+function hybridCqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return hybridCqt(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.nBins,
+      request.binsPerOctave,
+      request
+    );
+  }
+  validateMusicSamples("hybridCqt", samples, sampleRate, options);
+  validatePositiveIntegers("hybridCqt", { hopLength, nBins, binsPerOctave });
+  validateFrequencyBounds("hybridCqt", fmin);
+  return requireModule2().hybridCqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
+}
+function vqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, gamma = -1, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return vqt(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.nBins,
+      request.binsPerOctave,
+      request.gamma,
+      request
+    );
+  }
+  validateMusicSamples("vqt", samples, sampleRate, options);
+  validatePositiveIntegers("vqt", { hopLength, nBins, binsPerOctave });
+  validateFrequencyBounds("vqt", fmin);
+  assertFiniteScalar("vqt", gamma, "gamma");
+  return requireModule2().vqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave, gamma);
+}
+function validateCqtInverse(fnName, magnitude, nBins, nFrames, sampleRate, hopLength, fmin, binsPerOctave, nIter, options) {
+  assertSampleRate(fnName, sampleRate);
+  validatePositiveIntegers(fnName, { nBins, nFrames, hopLength, binsPerOctave, nIter });
+  if (nIter > 256) {
+    throw new RangeError(`${fnName}: nIter must be at most 256`);
+  }
+  validateFrequencyBounds(fnName, fmin);
+  if (fmin === 0) {
+    throw new RangeError(`${fnName}: fmin must be positive`);
+  }
+  if (magnitude.length !== nBins * nFrames) {
+    throw new RangeError(`${fnName}: magnitude length must equal nBins * nFrames`);
+  }
+  assertSamples(fnName, magnitude, options.validate !== false);
+}
+function cqtToAudio(magnitude, nBins = 0, nFrames = 0, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, binsPerOctave = 12, nIter = 32, options = {}) {
+  if (!(magnitude instanceof Float32Array)) {
+    const request = magnitude;
+    return cqtToAudio(
+      request.magnitude,
+      request.nBins,
+      request.nFrames,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.binsPerOctave,
+      request.nIter,
+      request
+    );
+  }
+  validateCqtInverse(
+    "cqtToAudio",
+    magnitude,
+    nBins,
+    nFrames,
+    sampleRate,
+    hopLength,
+    fmin,
+    binsPerOctave,
+    nIter,
+    options
+  );
+  return requireModule2().cqtToAudio(
+    magnitude,
+    nBins,
+    nFrames,
+    sampleRate,
+    hopLength,
+    fmin,
+    binsPerOctave,
+    nIter
+  );
+}
+function vqtToAudio(magnitude, nBins = 0, nFrames = 0, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, binsPerOctave = 12, gamma = -1, nIter = 32, options = {}) {
+  if (!(magnitude instanceof Float32Array)) {
+    const request = magnitude;
+    return vqtToAudio(
+      request.magnitude,
+      request.nBins,
+      request.nFrames,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.binsPerOctave,
+      request.gamma,
+      request.nIter,
+      request
+    );
+  }
+  validateCqtInverse(
+    "vqtToAudio",
+    magnitude,
+    nBins,
+    nFrames,
+    sampleRate,
+    hopLength,
+    fmin,
+    binsPerOctave,
+    nIter,
+    options
+  );
+  assertFiniteScalar("vqtToAudio", gamma, "gamma");
+  return requireModule2().vqtToAudio(
+    magnitude,
+    nBins,
+    nFrames,
+    sampleRate,
+    hopLength,
+    fmin,
+    binsPerOctave,
+    gamma,
+    nIter
+  );
+}
+function analyzeSections(samples, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return analyzeSections(r.samples, r.sampleRate, r);
+  }
+  validateMusicSamples("analyzeSections", samples, sampleRate, options);
+  validatePositiveIntegers("analyzeSections", {
+    nFft: options.nFft ?? 2048,
+    hopLength: options.hopLength ?? 512
+  });
+  assertFiniteScalar("analyzeSections", options.minSectionSec ?? 4, "minSectionSec");
+  if ((options.minSectionSec ?? 4) < 0) {
+    throw new RangeError("analyzeSections: minSectionSec must be non-negative");
+  }
+  const sections = requireModule2().analyzeSections(
+    samples,
+    sampleRate,
+    options.nFft ?? 2048,
+    options.hopLength ?? 512,
+    options.minSectionSec ?? 4
+  );
+  return Array.from(sections, (s) => ({ ...s, type: s.type }));
+}
+function analyzeMelody(samples, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return analyzeMelody(r.samples, r.sampleRate, r);
+  }
+  validateMusicSamples("analyzeMelody", samples, sampleRate, options);
+  const fmin = options.fmin ?? 65;
+  const fmax = options.fmax ?? 2093;
+  validateFrequencyBounds("analyzeMelody", fmin, fmax);
+  if (fmin <= 0) {
+    throw new SonareError(
+      4 /* InvalidParameter */,
+      "InvalidParameter",
+      "analyzeMelody: fmin must be positive"
+    );
+  }
+  validatePositiveIntegers("analyzeMelody", {
+    frameLength: options.frameLength ?? 2048,
+    hopLength: options.hopLength ?? 256
+  });
+  const threshold = options.threshold ?? 0.1;
+  assertFiniteScalar("analyzeMelody", threshold, "threshold");
+  if (threshold <= 0) {
+    throw new SonareError(
+      4 /* InvalidParameter */,
+      "InvalidParameter",
+      "analyzeMelody: threshold must be positive"
+    );
+  }
+  return requireModule2().analyzeMelody(
+    samples,
+    sampleRate,
+    options.fmin ?? 65,
+    options.fmax ?? 2093,
+    options.frameLength ?? 2048,
+    options.hopLength ?? 256,
+    options.threshold ?? 0.1,
+    options.usePyin ?? false,
+    options.center ?? true
+  );
+}
+function onsetEnvelope(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nMels = 128, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return onsetEnvelope(
+      request.samples,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.nMels,
+      request
+    );
+  }
+  validateMusicSamples("onsetEnvelope", samples, sampleRate, options);
+  validatePositiveIntegers("onsetEnvelope", { nFft, hopLength, nMels });
+  return requireModule2().onsetEnvelope(samples, sampleRate, nFft, hopLength, nMels);
+}
+function onsetStrengthMulti(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nMels = 128, nBands = 3, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return onsetStrengthMulti(
+      request.samples,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.nMels,
+      request.nBands,
+      request
+    );
+  }
+  validateMusicSamples("onsetStrengthMulti", samples, sampleRate, options);
+  validatePositiveIntegers("onsetStrengthMulti", { nFft, hopLength, nMels, nBands });
+  return requireModule2().onsetStrengthMulti(samples, sampleRate, nFft, hopLength, nMels, nBands);
+}
+function fourierTempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, center = true, norm = true, options = {}) {
+  if (!(onsetEnvelope2 instanceof Float32Array)) {
+    const request = onsetEnvelope2;
+    return fourierTempogram(
+      request.onsetEnvelope,
+      request.sampleRate,
+      request.hopLength,
+      request.winLength,
+      request.center,
+      request.norm,
+      request
+    );
+  }
+  assertSampleRate("fourierTempogram", sampleRate);
+  assertSamples("fourierTempogram", onsetEnvelope2, options.validate !== false, "onsetEnvelope");
+  validatePositiveIntegers("fourierTempogram", { hopLength, winLength });
+  return requireModule2().fourierTempogram(
+    onsetEnvelope2,
+    sampleRate,
+    hopLength,
+    winLength,
+    center,
+    norm
+  );
+}
+function tempogramRatio(tempogramData, winLength = 384, sampleRate = 22050, hopLength = 512, factors, options = {}) {
+  if (!(tempogramData instanceof Float32Array)) {
+    const request = tempogramData;
+    return tempogramRatio(
+      request.tempogramData,
+      request.winLength,
+      request.sampleRate,
+      request.hopLength,
+      request.factors,
+      request
+    );
+  }
+  assertSampleRate("tempogramRatio", sampleRate);
+  assertSamples("tempogramRatio", tempogramData, options.validate !== false, "tempogramData");
+  validatePositiveIntegers("tempogramRatio", { winLength, hopLength });
+  return requireModule2().tempogramRatio(tempogramData, winLength, sampleRate, hopLength, factors);
+}
+function lufs(samples, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return lufs(r.samples, r.sampleRate, r);
+  }
+  assertSampleRate("lufs", sampleRate);
+  assertSamples("lufs", samples, options.validate !== false);
+  return requireModule2().lufs(samples, sampleRate);
+}
+function momentaryLufs(samples, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return momentaryLufs(r.samples, r.sampleRate, r);
+  }
+  assertSampleRate("momentaryLufs", sampleRate);
+  assertSamples("momentaryLufs", samples, options.validate !== false);
+  return requireModule2().momentaryLufs(samples, sampleRate);
+}
+function shortTermLufs(samples, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return shortTermLufs(r.samples, r.sampleRate, r);
+  }
+  assertSampleRate("shortTermLufs", sampleRate);
+  assertSamples("shortTermLufs", samples, options.validate !== false);
+  return requireModule2().shortTermLufs(samples, sampleRate);
+}
+
+// src/feature_pitch.ts
+function requireModule3() {
+  return getSonareModule();
+}
+function piptrack(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 150, fmax = 4e3, threshold = 0.1) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return piptrack(
+      request.samples,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.fmin,
+      request.fmax,
+      request.threshold
+    );
+  }
+  return requireModule3().piptrack(samples, sampleRate, nFft, hopLength, fmin, fmax, threshold);
+}
+function pitchYin(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512, fmin = 65, fmax = 2093, threshold = 0.1, fillNa = false) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return pitchYin(
+      request.samples,
+      request.sampleRate,
+      request.frameLength,
+      request.hopLength,
+      request.fmin,
+      request.fmax,
+      request.threshold,
+      request.fillNa
+    );
+  }
+  return requireModule3().pitchYin(
+    samples,
+    sampleRate,
+    frameLength,
+    hopLength,
+    fmin,
+    fmax,
+    threshold,
+    fillNa
+  );
+}
+function pitchPyin(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512, fmin = 65, fmax = 2093, threshold = 0.1, fillNa = false) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return pitchPyin(
+      request.samples,
+      request.sampleRate,
+      request.frameLength,
+      request.hopLength,
+      request.fmin,
+      request.fmax,
+      request.threshold,
+      request.fillNa
+    );
+  }
+  return requireModule3().pitchPyin(
+    samples,
+    sampleRate,
+    frameLength,
+    hopLength,
+    fmin,
+    fmax,
+    threshold,
+    fillNa
+  );
+}
+function noteSegments(request) {
+  return requireModule3().noteSegments(request.f0Hz, request.voicedProb, request.frameRate, {
+    segmentationThresholdCents: request.segmentationThresholdCents,
+    minNoteMs: request.minNoteMs,
+    referenceHz: request.referenceHz
+  });
+}
+
+// src/feature_resample.ts
+function requireModule4() {
+  return getSonareModule();
+}
+function resample(samples, srcSr, targetSr) {
+  if (!(samples instanceof Float32Array)) {
+    return resample(samples.samples, samples.srcSr, samples.targetSr);
+  }
+  return requireModule4().resample(samples, srcSr, targetSr);
+}
+
+// src/feature_spectral.ts
+function requireModule5() {
+  return getSonareModule();
+}
+function validateSegmentMatrix(fnName, data, rows, cols, dataName) {
+  assertPositiveInteger(fnName, rows, "rows");
+  assertPositiveInteger(fnName, cols, "cols");
+  assertSamples(fnName, data, true, dataName);
+  const expected = rows * cols;
+  if (!Number.isSafeInteger(expected) || data.length !== expected) {
+    throw new RangeError(`${fnName}: ${dataName} length must equal rows * cols`);
+  }
+}
+function spectralCentroid(samples, sampleRate = 22050, nFft = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return spectralCentroid(samples.samples, samples.sampleRate, samples.nFft, samples.hopLength);
+  }
+  return requireModule5().spectralCentroid(samples, sampleRate, nFft, hopLength);
+}
+function spectralContrast(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nBands = 6, fmin = 200, quantile = 0.02) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return spectralContrast(
+      r.samples,
+      r.sampleRate,
+      r.nFft,
+      r.hopLength,
+      r.nBands,
+      r.fmin,
+      r.quantile
+    );
+  }
+  return requireModule5().spectralContrast(
+    samples,
+    sampleRate,
+    nFft,
+    hopLength,
+    nBands,
+    fmin,
+    quantile
+  );
+}
+function polyFeatures(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, order = 1) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return polyFeatures(r.samples, r.sampleRate, r.nFft, r.hopLength, r.order);
+  }
+  return requireModule5().polyFeatures(samples, sampleRate, nFft, hopLength, order);
+}
+function zeroCrossings(samples, threshold = 1e-10, refMagnitude = false, pad = true, zeroPos = true) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return zeroCrossings(r.samples, r.threshold, r.refMagnitude, r.pad, r.zeroPos);
+  }
+  return requireModule5().zeroCrossings(samples, threshold, refMagnitude, pad, zeroPos);
+}
+function pitchTuning(frequencies, resolution = 0.01, binsPerOctave = 12) {
+  if (!(frequencies instanceof Float32Array)) {
+    const r = frequencies;
+    return pitchTuning(r.frequencies, r.resolution, r.binsPerOctave);
+  }
+  return requireModule5().pitchTuning(frequencies, resolution, binsPerOctave);
+}
+function estimateTuning(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, resolution = 0.01, binsPerOctave = 12) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return estimateTuning(
+      r.samples,
+      r.sampleRate,
+      r.nFft,
+      r.hopLength,
+      r.resolution,
+      r.binsPerOctave
+    );
+  }
+  return requireModule5().estimateTuning(
+    samples,
+    sampleRate,
+    nFft,
+    hopLength,
+    resolution,
+    binsPerOctave
+  );
+}
+function decompose(s, nFeatures = 0, nFrames = 0, nComponents = 0, nIter = 50, beta = 2) {
+  if (!(s instanceof Float32Array)) {
+    const request = s;
+    return decompose(
+      request.s,
+      request.nFeatures,
+      request.nFrames,
+      request.nComponents,
+      request.nIter,
+      request.beta
+    );
+  }
+  return requireModule5().decompose(s, nFeatures, nFrames, nComponents, nIter, beta);
+}
+function decomposeWithInit(s, nFeatures = 0, nFrames = 0, nComponents = 0, nIter = 50, beta = 2, init2 = "random") {
+  if (!(s instanceof Float32Array)) {
+    const request = s;
+    return decomposeWithInit(
+      request.s,
+      request.nFeatures,
+      request.nFrames,
+      request.nComponents,
+      request.nIter,
+      request.beta,
+      request.init
+    );
+  }
+  return requireModule5().decomposeWithInit(s, nFeatures, nFrames, nComponents, nIter, beta, init2);
+}
+function nnFilter(s, nFeatures = 0, nFrames = 0, aggregate = "mean", k = 7, width = 1) {
+  if (!(s instanceof Float32Array)) {
+    const r = s;
+    return nnFilter(r.s, r.nFeatures, r.nFrames, r.aggregate, r.k, r.width);
+  }
+  return requireModule5().nnFilter(s, nFeatures, nFrames, aggregate, k, width);
+}
+function remix(samples, intervals, sampleRate = 22050, alignZeros = false) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return remix(r.samples, r.intervals, r.sampleRate, r.alignZeros);
+  }
+  const intervalsI32 = intervals instanceof Int32Array ? intervals : Int32Array.from(intervals, (v) => Math.trunc(v));
+  return requireModule5().remix(samples, intervalsI32, sampleRate, alignZeros);
+}
+function phaseVocoder(samples, sampleRate = 22050, rate = 1, nFft = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return phaseVocoder(r.samples, r.sampleRate ?? 22050, r.rate, r.nFft, r.hopLength);
+  }
+  return requireModule5().phaseVocoder(samples, sampleRate, rate, nFft, hopLength);
+}
+function hpssWithResidual(samples, sampleRate = 22050, kernelHarmonic = 31, kernelPercussive = 31) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return hpssWithResidual(r.samples, r.sampleRate, r.kernelHarmonic, r.kernelPercussive);
+  }
+  return requireModule5().hpssWithResidual(samples, sampleRate, kernelHarmonic, kernelPercussive);
+}
+function lufsInterleaved(samples, channels = 0, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return lufsInterleaved(r.samples, r.channels, r.sampleRate, r);
+  }
+  assertSampleRate("lufsInterleaved", sampleRate);
+  assertInterleavedSamples("lufsInterleaved", samples, channels, options.validate !== false);
+  return requireModule5().lufsInterleaved(samples, channels, sampleRate);
+}
+function ebur128LoudnessRange(samples, sampleRate = 22050) {
+  if (!(samples instanceof Float32Array)) {
+    return ebur128LoudnessRange(samples.samples, samples.sampleRate);
+  }
+  return requireModule5().ebur128LoudnessRange(samples, sampleRate);
+}
+function spectralBandwidth(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, p = 2) {
+  if (!(samples instanceof Float32Array)) {
+    return spectralBandwidth(
+      samples.samples,
+      samples.sampleRate,
+      samples.nFft,
+      samples.hopLength,
+      samples.p
+    );
+  }
+  return requireModule5().spectralBandwidth(samples, sampleRate, nFft, hopLength, p);
+}
+function spectralRolloff(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, rollPercent = 0.85) {
+  if (!(samples instanceof Float32Array)) {
+    return spectralRolloff(
+      samples.samples,
+      samples.sampleRate,
+      samples.nFft,
+      samples.hopLength,
+      samples.rollPercent
+    );
+  }
+  return requireModule5().spectralRolloff(samples, sampleRate, nFft, hopLength, rollPercent);
+}
+function spectralFlatness(samples, sampleRate = 22050, nFft = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return spectralFlatness(samples.samples, samples.sampleRate, samples.nFft, samples.hopLength);
+  }
+  return requireModule5().spectralFlatness(samples, sampleRate, nFft, hopLength);
+}
+function spectralFlux(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, lag = 1) {
+  if (!(samples instanceof Float32Array)) {
+    return spectralFlux(
+      samples.samples,
+      samples.sampleRate,
+      samples.nFft,
+      samples.hopLength,
+      samples.lag
+    );
+  }
+  return requireModule5().spectralFlux(samples, sampleRate, nFft, hopLength, lag);
+}
+function zeroCrossingRate(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return zeroCrossingRate(
+      samples.samples,
+      samples.sampleRate,
+      samples.frameLength,
+      samples.hopLength
+    );
+  }
+  return requireModule5().zeroCrossingRate(samples, sampleRate, frameLength, hopLength);
+}
+function rmsEnergy(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return rmsEnergy(samples.samples, samples.sampleRate, samples.frameLength, samples.hopLength);
+  }
+  return requireModule5().rmsEnergy(samples, sampleRate, frameLength, hopLength);
+}
+function segmentCrossSimilarity(request) {
+  validateSegmentMatrix("segmentCrossSimilarity", request.x, request.xRows, request.xCols, "x");
+  validateSegmentMatrix("segmentCrossSimilarity", request.y, request.yRows, request.yCols, "y");
+  if (request.xRows !== request.yRows) {
+    throw new RangeError("segmentCrossSimilarity: feature dimensions must match");
+  }
+  assertNonNegativeInteger("segmentCrossSimilarity", request.k ?? 0, "k");
+  return requireModule5().segmentCrossSimilarity(
+    request.x,
+    request.xRows,
+    request.xCols,
+    request.y,
+    request.yRows,
+    request.yCols,
+    request.k ?? 0,
+    request.metric ?? "cosine",
+    request.mode ?? "connectivity"
+  );
+}
+function segmentRecurrenceMatrix(request) {
+  validateSegmentMatrix(
+    "segmentRecurrenceMatrix",
+    request.data,
+    request.rows,
+    request.cols,
+    "data"
+  );
+  assertNonNegativeInteger("segmentRecurrenceMatrix", request.k ?? 0, "k");
+  assertNonNegativeInteger("segmentRecurrenceMatrix", request.width ?? 1, "width");
+  return requireModule5().segmentRecurrenceMatrix(
+    request.data,
+    request.rows,
+    request.cols,
+    request.k ?? 0,
+    request.width ?? 1,
+    request.sym ?? false,
+    request.metric ?? "euclidean",
+    request.mode ?? "connectivity"
+  );
+}
+function segmentRecurrenceToLag(request) {
+  validateSegmentMatrix(
+    "segmentRecurrenceToLag",
+    request.recurrence,
+    request.n,
+    request.n,
+    "recurrence"
+  );
+  return requireModule5().segmentRecurrenceToLag(
+    request.recurrence,
+    request.n,
+    request.pad ?? false
+  );
+}
+function segmentLagToRecurrence(request) {
+  validateSegmentMatrix("segmentLagToRecurrence", request.lag, request.rows, request.lags, "lag");
+  return requireModule5().segmentLagToRecurrence(request.lag, request.rows, request.lags);
+}
+function segmentSubsegment(request) {
+  validateSegmentMatrix("segmentSubsegment", request.data, request.rows, request.cols, "data");
+  assertPositiveInteger("segmentSubsegment", request.nSegments ?? 4, "nSegments");
+  return requireModule5().segmentSubsegment(
+    request.data,
+    request.rows,
+    request.cols,
+    request.boundaries,
+    request.nSegments ?? 4
+  );
+}
+function segmentAgglomerative(request) {
+  validateSegmentMatrix("segmentAgglomerative", request.data, request.rows, request.cols, "data");
+  assertPositiveInteger("segmentAgglomerative", request.k, "k");
+  return requireModule5().segmentAgglomerative(
+    request.data,
+    request.rows,
+    request.cols,
+    request.k,
+    request.linkage ?? "average"
+  );
+}
+function segmentPathEnhance(request) {
+  validateSegmentMatrix(
+    "segmentPathEnhance",
+    request.recurrence,
+    request.n,
+    request.n,
+    "recurrence"
+  );
+  assertPositiveInteger("segmentPathEnhance", request.win, "win");
+  assertPositiveInteger("segmentPathEnhance", request.maxRatio ?? 2, "maxRatio");
+  assertNonNegativeInteger("segmentPathEnhance", request.minRatio ?? 0, "minRatio");
+  assertPositiveInteger("segmentPathEnhance", request.nFilters ?? 7, "nFilters");
+  return requireModule5().segmentPathEnhance(
+    request.recurrence,
+    request.n,
+    request.win,
+    request.maxRatio ?? 2,
+    request.minRatio ?? 0,
+    request.nFilters ?? 7
+  );
+}
+
+// src/feature_spectrogram.ts
+function requireModule6() {
+  return getSonareModule();
+}
+function validateSpectrogramSamples(fnName, samples, sampleRate, options = {}) {
+  assertSampleRate(fnName, sampleRate);
+  assertSamples(fnName, samples, options.validate !== false);
+}
+function validatePositiveIntegers2(fnName, values) {
+  for (const [name, value] of Object.entries(values)) {
+    assertPositiveInteger(fnName, value, name);
+  }
+}
+function validateMelFrequencyRange(fnName, fmin, fmax, sampleRate) {
+  assertFiniteScalar(fnName, fmin, "fmin");
+  assertFiniteScalar(fnName, fmax, "fmax");
+  if (fmin < 0) {
+    throw new RangeError(`${fnName}: fmin must be non-negative`);
+  }
+  if (fmax < 0) {
+    throw new RangeError(`${fnName}: fmax must be non-negative`);
+  }
+  const effectiveFmax = fmax === 0 ? sampleRate / 2 : fmax;
+  if (effectiveFmax <= fmin) {
+    throw new RangeError(`${fnName}: fmax must be greater than fmin`);
+  }
+}
+function validateMatrix(fnName, data, rows, frames, dataName, rowName, options = {}) {
+  validatePositiveIntegers2(fnName, { [rowName]: rows, nFrames: frames });
+  assertSamples(fnName, data, options.validate !== false, dataName);
+  const expectedLength = rows * frames;
+  if (!Number.isSafeInteger(expectedLength) || data.length !== expectedLength) {
+    throw new RangeError(`${fnName}: ${dataName} length must equal ${rowName} * nFrames`);
+  }
+}
+function trim(samples, sampleRate = 22050, thresholdDb = -60, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return trim(r.samples, r.sampleRate, r.thresholdDb, r);
+  }
+  validateSpectrogramSamples("trim", samples, sampleRate, options);
+  assertFiniteScalar("trim", thresholdDb, "thresholdDb");
+  return requireModule6().trim(samples, sampleRate, thresholdDb);
+}
+function stft(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return stft(request.samples, request.sampleRate, request.nFft, request.hopLength, request);
+  }
+  validateSpectrogramSamples("stft", samples, sampleRate, options);
+  validatePositiveIntegers2("stft", { nFft, hopLength });
+  return requireModule6().stft(samples, sampleRate, nFft, hopLength);
+}
+function stftDb(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return stftDb(request.samples, request.sampleRate, request.nFft, request.hopLength, request);
+  }
+  validateSpectrogramSamples("stftDb", samples, sampleRate, options);
+  validatePositiveIntegers2("stftDb", { nFft, hopLength });
+  return requireModule6().stftDb(samples, sampleRate, nFft, hopLength);
+}
+function chromaCens(samples, sampleRate = 22050, hopLength = 512, nChroma = 12, binsPerOctave = 36, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return chromaCens(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.nChroma,
+      request.binsPerOctave,
+      request
+    );
+  }
+  validateSpectrogramSamples("chromaCens", samples, sampleRate, options);
+  validatePositiveIntegers2("chromaCens", { hopLength, nChroma, binsPerOctave });
+  if (binsPerOctave % nChroma !== 0) {
+    throw new RangeError("chromaCens: binsPerOctave must be a multiple of nChroma");
+  }
+  return requireModule6().chromaCens(samples, sampleRate, hopLength, nChroma, binsPerOctave);
+}
+function chromaCqt(samples, sampleRate = 22050, hopLength = 512, nChroma = 12, binsPerOctave = 36, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return chromaCqt(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.nChroma,
+      request.binsPerOctave,
+      request
+    );
+  }
+  validateSpectrogramSamples("chromaCqt", samples, sampleRate, options);
+  validatePositiveIntegers2("chromaCqt", { hopLength, nChroma, binsPerOctave });
+  if (binsPerOctave % nChroma !== 0) {
+    throw new RangeError("chromaCqt: binsPerOctave must be a multiple of nChroma");
+  }
+  return requireModule6().chromaCqt(samples, sampleRate, hopLength, nChroma, binsPerOctave);
+}
+function bassChroma(samples, sampleRate = 22050, hopLength = 512, nChroma = 12, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return bassChroma(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.nChroma,
+      request
+    );
+  }
+  validateSpectrogramSamples("bassChroma", samples, sampleRate, options);
+  validatePositiveIntegers2("bassChroma", { hopLength, nChroma });
+  return requireModule6().bassChroma(samples, sampleRate, hopLength, nChroma);
+}
+function melSpectrogram(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nMels = 128, fmin = 0, fmax = 0, htk = false, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return melSpectrogram(
+      request.samples,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.nMels,
+      request.fmin,
+      request.fmax,
+      request.htk,
+      request
+    );
+  }
+  validateSpectrogramSamples("melSpectrogram", samples, sampleRate, options);
+  validatePositiveIntegers2("melSpectrogram", { nFft, hopLength, nMels });
+  validateMelFrequencyRange("melSpectrogram", fmin, fmax, sampleRate);
+  return requireModule6().melSpectrogram(
+    samples,
+    sampleRate,
+    nFft,
+    hopLength,
+    nMels,
+    fmin,
+    fmax,
+    htk
+  );
+}
+function mfcc(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nMels = 128, nMfcc = 20, fmin = 0, fmax = 0, htk = false, lifter = 0, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return mfcc(
+      request.samples,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.nMels,
+      request.nMfcc,
+      request.fmin,
+      request.fmax,
+      request.htk,
+      request.lifter,
+      request
+    );
+  }
+  validateSpectrogramSamples("mfcc", samples, sampleRate, options);
+  validatePositiveIntegers2("mfcc", { nFft, hopLength, nMels, nMfcc });
+  validateMelFrequencyRange("mfcc", fmin, fmax, sampleRate);
+  return requireModule6().mfcc(
+    samples,
+    sampleRate,
+    nFft,
+    hopLength,
+    nMels,
+    nMfcc,
+    fmin,
+    fmax,
+    htk,
+    lifter
+  );
+}
+function melDelta(features, nFeatures, nFrames, width = 9) {
+  const request = features instanceof Float32Array ? { features, nFeatures: nFeatures ?? 0, nFrames: nFrames ?? 0, width } : features;
+  assertPositiveInteger("melDelta", request.nFeatures, "nFeatures");
+  assertPositiveInteger("melDelta", request.nFrames, "nFrames");
+  assertPositiveInteger("melDelta", request.width ?? 9, "width");
+  if ((request.width ?? 9) < 3 || (request.width ?? 9) % 2 === 0) {
+    throw new RangeError("melDelta: width must be an odd integer of at least 3");
+  }
+  if (request.features.length !== request.nFeatures * request.nFrames) {
+    throw new RangeError("melDelta: feature matrix length must equal nFeatures * nFrames");
+  }
+  return requireModule6().melDelta(
+    request.features,
+    request.nFeatures,
+    request.nFrames,
+    request.width ?? 9
+  );
+}
+function reassignedSpectrogram(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, refPower = 1e-6, fillNan = false) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return reassignedSpectrogram(
+      request.samples,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.refPower,
+      request.fillNan
+    );
+  }
+  assertSamples("reassignedSpectrogram", samples, true);
+  assertSampleRate("reassignedSpectrogram", sampleRate);
+  assertPositiveInteger("reassignedSpectrogram", nFft, "nFft");
+  assertPositiveInteger("reassignedSpectrogram", hopLength, "hopLength");
+  assertFiniteScalar("reassignedSpectrogram", refPower, "refPower");
+  if (refPower < 0) {
+    throw new RangeError("reassignedSpectrogram: refPower must be non-negative");
+  }
+  return requireModule6().reassignedSpectrogram(
+    samples,
+    sampleRate,
+    nFft,
+    hopLength,
+    refPower,
+    fillNan
+  );
+}
+function melToStft(melPower, nMels = 0, nFrames = 0, sampleRate = 22050, nFft = 2048, fmin = 0, fmax = 0, htk = false, options = {}) {
+  if (!(melPower instanceof Float32Array)) {
+    const request = melPower;
+    return melToStft(
+      request.melPower,
+      request.nMels,
+      request.nFrames,
+      request.sampleRate,
+      request.nFft,
+      request.fmin,
+      request.fmax,
+      request.htk,
+      request
+    );
+  }
+  assertSampleRate("melToStft", sampleRate);
+  validateMatrix("melToStft", melPower, nMels, nFrames, "melPower", "nMels", options);
+  validatePositiveIntegers2("melToStft", { nFft });
+  validateMelFrequencyRange("melToStft", fmin, fmax, sampleRate);
+  return requireModule6().melToStft(melPower, nMels, nFrames, sampleRate, nFft, fmin, fmax, htk);
+}
+function melToAudio(melPower, nMels = 0, nFrames = 0, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 0, fmax = 0, nIter = 32, htk = false, options = {}) {
+  if (!(melPower instanceof Float32Array)) {
+    const request = melPower;
+    return melToAudio(
+      request.melPower,
+      request.nMels,
+      request.nFrames,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.fmin,
+      request.fmax,
+      request.nIter,
+      request.htk,
+      request
+    );
+  }
+  assertSampleRate("melToAudio", sampleRate);
+  validateMatrix("melToAudio", melPower, nMels, nFrames, "melPower", "nMels", options);
+  validatePositiveIntegers2("melToAudio", { nFft, hopLength, nIter });
+  validateMelFrequencyRange("melToAudio", fmin, fmax, sampleRate);
+  return requireModule6().melToAudio(
+    melPower,
+    nMels,
+    nFrames,
+    sampleRate,
+    nFft,
+    hopLength,
+    fmin,
+    fmax,
+    nIter,
+    htk
+  );
+}
+function griffinLim(magnitude, nBins = 0, nFrames = 0, sampleRate = 22050, nFft = 2048, hopLength = 512, nIter = 32, momentum = 0.99, options = {}) {
+  if (!(magnitude instanceof Float32Array)) {
+    const request = magnitude;
+    return griffinLim(
+      request.magnitude,
+      request.nBins,
+      request.nFrames,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.nIter,
+      request.momentum,
+      request
+    );
+  }
+  assertSampleRate("griffinLim", sampleRate);
+  validateMatrix("griffinLim", magnitude, nBins, nFrames, "magnitude", "nBins", options);
+  validatePositiveIntegers2("griffinLim", { nFft, hopLength, nIter });
+  return requireModule6().griffinLim(
+    magnitude,
+    nBins,
+    nFrames,
+    sampleRate,
+    nFft,
+    hopLength,
+    nIter,
+    momentum
+  );
+}
+function mfccToMel(mfccCoefficients, nMfcc = 0, nFrames = 0, nMels = 128, lifter = 0, options = {}) {
+  if (!(mfccCoefficients instanceof Float32Array)) {
+    const request = mfccCoefficients;
+    return mfccToMel(
+      request.mfccCoefficients,
+      request.nMfcc,
+      request.nFrames,
+      request.nMels,
+      request.lifter,
+      request
+    );
+  }
+  validateMatrix(
+    "mfccToMel",
+    mfccCoefficients,
+    nMfcc,
+    nFrames,
+    "mfccCoefficients",
+    "nMfcc",
+    options
+  );
+  validatePositiveIntegers2("mfccToMel", { nMels });
+  return requireModule6().mfccToMel(mfccCoefficients, nMfcc, nFrames, nMels, lifter);
+}
+function mfccToAudio(mfccCoefficients, nMfcc = 0, nFrames = 0, nMels = 128, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 0, fmax = 0, nIter = 32, htk = false, lifter = 0, options = {}) {
+  if (!(mfccCoefficients instanceof Float32Array)) {
+    const request = mfccCoefficients;
+    return mfccToAudio(
+      request.mfccCoefficients,
+      request.nMfcc,
+      request.nFrames,
+      request.nMels,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.fmin,
+      request.fmax,
+      request.nIter,
+      request.htk,
+      request.lifter,
+      request
+    );
+  }
+  assertSampleRate("mfccToAudio", sampleRate);
+  validateMatrix(
+    "mfccToAudio",
+    mfccCoefficients,
+    nMfcc,
+    nFrames,
+    "mfccCoefficients",
+    "nMfcc",
+    options
+  );
+  validatePositiveIntegers2("mfccToAudio", { nMels, nFft, hopLength, nIter });
+  validateMelFrequencyRange("mfccToAudio", fmin, fmax, sampleRate);
+  return requireModule6().mfccToAudio(
+    mfccCoefficients,
+    nMfcc,
+    nFrames,
+    nMels,
+    sampleRate,
+    nFft,
+    hopLength,
+    fmin,
+    fmax,
+    nIter,
+    htk,
+    lifter
+  );
+}
+function chroma(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return chroma(request.samples, request.sampleRate, request.nFft, request.hopLength, request);
+  }
+  validateSpectrogramSamples("chroma", samples, sampleRate, options);
+  validatePositiveIntegers2("chroma", { nFft, hopLength });
+  return requireModule6().chroma(samples, sampleRate, nFft, hopLength);
+}
+
+// src/metering.ts
+function assertOversampleFactor(fnName, factor) {
+  const normalized = factor === 0 ? 4 : factor;
+  if (!Number.isInteger(normalized) || normalized < 1 || normalized > 16 || (normalized & normalized - 1) !== 0) {
+    throw new SonareError(
+      4 /* InvalidParameter */,
+      "InvalidParameter",
+      `${fnName}: oversampleFactor must be 0 or a power of two from 1 to 16`
+    );
+  }
+}
+function requireModule7() {
+  return getSonareModule();
+}
+function meteringPeakDb(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples("meteringPeakDb", request.samples, request.validate !== false);
+  return requireModule7().meteringPeakDb(request.samples, request.sampleRate ?? 22050);
+}
+function meteringRmsDb(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples("meteringRmsDb", request.samples, request.validate !== false);
+  return requireModule7().meteringRmsDb(request.samples, request.sampleRate ?? 22050);
+}
+function meteringSilenceRatio(samples, sampleRate = 22050, thresholdDb = -45, frameLength = 1024, hopLength = 256, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, thresholdDb, frameLength, hopLength, ...options } : samples;
+  assertSamples("meteringSilenceRatio", request.samples, request.validate !== false);
+  return requireModule7().meteringSilenceRatio(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.thresholdDb ?? -45,
+    request.frameLength ?? 1024,
+    request.hopLength ?? 256
+  );
+}
+function meteringCrestFactorDb(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples("meteringCrestFactorDb", request.samples, request.validate !== false);
+  return requireModule7().meteringCrestFactorDb(request.samples, request.sampleRate ?? 22050);
+}
+function meteringDcOffset(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples("meteringDcOffset", request.samples, request.validate !== false);
+  return requireModule7().meteringDcOffset(request.samples, request.sampleRate ?? 22050);
+}
+function meteringTruePeakDb(samples, sampleRate = 22050, oversampleFactor = 4, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, oversampleFactor, ...options } : samples;
+  assertSamples("meteringTruePeakDb", request.samples, request.validate !== false);
+  const factor = request.oversampleFactor ?? 4;
+  assertOversampleFactor("meteringTruePeakDb", factor);
+  return requireModule7().meteringTruePeakDb(request.samples, request.sampleRate ?? 22050, factor);
+}
+function meteringDetectClipping(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples("meteringDetectClipping", request.samples, request.validate !== false);
+  const minRegionSamples = request.minRegionSamples ?? 1;
+  if (!Number.isInteger(minRegionSamples) || minRegionSamples < 0) {
+    throw new RangeError("meteringDetectClipping: minRegionSamples must be a non-negative integer");
+  }
+  return requireModule7().meteringDetectClipping(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.threshold ?? 0.999,
+    minRegionSamples
+  );
+}
+function meteringDynamicRange(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples("meteringDynamicRange", request.samples, request.validate !== false);
+  return requireModule7().meteringDynamicRange(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.windowSec ?? 0,
+    request.hopSec ?? 0,
+    request.lowPercentile ?? -1,
+    request.highPercentile ?? -1
+  );
+}
+function meteringStereoCorrelation(left, right, sampleRate = 22050, options = {}) {
+  const request = left instanceof Float32Array ? { left, right, sampleRate, ...options } : left;
+  const validate = request.validate !== false;
+  assertSamples("meteringStereoCorrelation", request.left, validate, "left");
+  assertSamples("meteringStereoCorrelation", request.right, validate, "right");
+  return requireModule7().meteringStereoCorrelation(
+    request.left,
+    request.right,
+    request.sampleRate ?? 22050
+  );
+}
+function meteringStereoWidth(left, right, sampleRate = 22050, options = {}) {
+  const request = left instanceof Float32Array ? { left, right, sampleRate, ...options } : left;
+  const validate = request.validate !== false;
+  assertSamples("meteringStereoWidth", request.left, validate, "left");
+  assertSamples("meteringStereoWidth", request.right, validate, "right");
+  return requireModule7().meteringStereoWidth(
+    request.left,
+    request.right,
+    request.sampleRate ?? 22050
+  );
+}
+function meteringVectorscope(left, right, sampleRate = 22050, options = {}) {
+  const request = left instanceof Float32Array ? { left, right, sampleRate, ...options } : left;
+  const validate = request.validate !== false;
+  assertSamples("meteringVectorscope", request.left, validate, "left");
+  assertSamples("meteringVectorscope", request.right, validate, "right");
+  return requireModule7().meteringVectorscopeDecimated(
+    request.left,
+    request.right,
+    request.sampleRate ?? 22050,
+    request.maxPoints ?? 0
+  );
+}
+function meteringVectorscopeDecimated(left, right, sampleRate = 22050, maxPoints = 0, options = {}) {
+  const request = left instanceof Float32Array ? { left, right, sampleRate, maxPoints, ...options } : left;
+  const validate = request.validate !== false;
+  assertSamples("meteringVectorscopeDecimated", request.left, validate, "left");
+  assertSamples("meteringVectorscopeDecimated", request.right, validate, "right");
+  return requireModule7().meteringVectorscopeDecimated(
+    request.left,
+    request.right,
+    request.sampleRate ?? 22050,
+    request.maxPoints ?? 0
+  );
+}
+function meteringPhaseScope(left, right, sampleRate = 22050, options = {}) {
+  const request = left instanceof Float32Array ? { left, right, sampleRate, ...options } : left;
+  const validate = request.validate !== false;
+  assertSamples("meteringPhaseScope", request.left, validate, "left");
+  assertSamples("meteringPhaseScope", request.right, validate, "right");
+  return requireModule7().meteringPhaseScopeDecimated(
+    request.left,
+    request.right,
+    request.sampleRate ?? 22050,
+    request.maxPoints ?? 0
+  );
+}
+function meteringPhaseScopeDecimated(left, right, sampleRate = 22050, maxPoints = 0, options = {}) {
+  const request = left instanceof Float32Array ? { left, right, sampleRate, maxPoints, ...options } : left;
+  const validate = request.validate !== false;
+  assertSamples("meteringPhaseScopeDecimated", request.left, validate, "left");
+  assertSamples("meteringPhaseScopeDecimated", request.right, validate, "right");
+  return requireModule7().meteringPhaseScopeDecimated(
+    request.left,
+    request.right,
+    request.sampleRate ?? 22050,
+    request.maxPoints ?? 0
+  );
+}
+function meteringSpectrum(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples("meteringSpectrum", request.samples, request.validate !== false);
+  return requireModule7().meteringSpectrum(request.samples, request.sampleRate ?? 22050, request);
+}
+function meteringSpectrumFrame(samples, sampleRate = 22050, frameOffset = 0, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, frameOffset, ...options } : samples;
+  assertSamples("meteringSpectrumFrame", request.samples, request.validate !== false);
+  return requireModule7().meteringSpectrumFrame(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.frameOffset ?? 0,
+    request
+  );
+}
+function waveformPeaks(samples, channels, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, channels, ...options } : samples;
+  assertSamples("waveformPeaks", request.samples, request.validate !== false);
+  if (request.channels <= 0 || request.samples.length % request.channels !== 0) {
+    throw new RangeError("waveformPeaks: samples length must be a multiple of channels");
+  }
+  const samplesPerBucket = request.samplesPerBucket ?? 512;
+  if (samplesPerBucket <= 0) {
+    throw new RangeError("waveformPeaks: samplesPerBucket must be > 0");
+  }
+  return requireModule7().waveformPeaks(request.samples, request.channels, samplesPerBucket);
+}
+function waveformPeakPyramid(samples, channels, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, channels, ...options } : samples;
+  assertSamples("waveformPeakPyramid", request.samples, request.validate !== false);
+  if (request.channels <= 0 || request.samples.length % request.channels !== 0) {
+    throw new RangeError("waveformPeakPyramid: samples length must be a multiple of channels");
+  }
+  const levels = request.samplesPerBucketLevels ?? [512, 1024, 2048, 4096];
+  if (levels.length === 0 || levels.some((level) => level <= 0)) {
+    throw new RangeError("waveformPeakPyramid: samplesPerBucketLevels must be non-empty and > 0");
+  }
+  return requireModule7().waveformPeakPyramid(request.samples, request.channels, levels);
+}
+
+// src/public_types_music.ts
+var PitchClass = {
+  C: 0,
+  Cs: 1,
+  D: 2,
+  Ds: 3,
+  E: 4,
+  F: 5,
+  Fs: 6,
+  G: 7,
+  Gs: 8,
+  A: 9,
+  As: 10,
+  B: 11
+};
+var Mode = {
+  Major: 0,
+  Minor: 1,
+  Dorian: 2,
+  Phrygian: 3,
+  Lydian: 4,
+  Mixolydian: 5,
+  Locrian: 6
+};
+var KeyProfile = {
+  KrumhanslSchmuckler: 0,
+  Temperley: 1,
+  Shaath: 2,
+  FaraldoEDMT: 3,
+  FaraldoEDMA: 4,
+  FaraldoEDMM: 5,
+  BellmanBudge: 6
+};
+var ChordQuality = {
+  Major: 0,
+  Minor: 1,
+  Diminished: 2,
+  Augmented: 3,
+  Dominant7: 4,
+  Major7: 5,
+  Minor7: 6,
+  Sus2: 7,
+  Sus4: 8,
+  Unknown: 9,
+  Add9: 10,
+  MinorAdd9: 11,
+  Dim7: 12,
+  HalfDim7: 13,
+  Major9: 14,
+  Dominant9: 15,
+  Sus2Add4: 16
+};
+var SectionType = {
+  Intro: 0,
+  Verse: 1,
+  PreChorus: 2,
+  Chorus: 3,
+  Bridge: 4,
+  Instrumental: 5,
+  Outro: 6,
+  Unknown: 7
+};
+
+// src/analysis_helpers.ts
+var PITCH_CLASS_NAMES = [
+  "C",
+  "C#",
+  "D",
+  "D#",
+  "E",
+  "F",
+  "F#",
+  "G",
+  "G#",
+  "A",
+  "A#",
+  "B"
+];
+function pitchClassName(value) {
+  return PITCH_CLASS_NAMES[value] ?? "C";
+}
+function convertKeyCandidate(wasm) {
+  return {
+    key: {
+      root: wasm.key.root,
+      mode: wasm.key.mode,
+      confidence: wasm.key.confidence,
+      name: wasm.key.name,
+      shortName: wasm.key.shortName
+    },
+    correlation: wasm.correlation
+  };
+}
+function keyModeValues(modes) {
+  if (!modes) {
+    return [];
+  }
+  if (modes === "major-minor") {
+    return [Mode.Major, Mode.Minor];
+  }
+  if (modes === "all" || modes === "modal") {
+    return [
+      Mode.Major,
+      Mode.Minor,
+      Mode.Dorian,
+      Mode.Phrygian,
+      Mode.Lydian,
+      Mode.Mixolydian,
+      Mode.Locrian
+    ];
+  }
+  const names = {
+    major: Mode.Major,
+    minor: Mode.Minor,
+    dorian: Mode.Dorian,
+    phrygian: Mode.Phrygian,
+    lydian: Mode.Lydian,
+    mixolydian: Mode.Mixolydian,
+    locrian: Mode.Locrian
+  };
+  return modes.map((mode) => typeof mode === "number" ? mode : names[mode]);
+}
+function keyProfileValue(profile) {
+  if (profile === void 0) {
+    return -1;
+  }
+  if (typeof profile === "number") {
+    return profile;
+  }
+  const names = {
+    ks: KeyProfile.KrumhanslSchmuckler,
+    krumhansl: KeyProfile.KrumhanslSchmuckler,
+    temperley: KeyProfile.Temperley,
+    shaath: KeyProfile.Shaath,
+    keyfinder: KeyProfile.Shaath,
+    "faraldo-edmt": KeyProfile.FaraldoEDMT,
+    edmt: KeyProfile.FaraldoEDMT,
+    "faraldo-edma": KeyProfile.FaraldoEDMA,
+    edma: KeyProfile.FaraldoEDMA,
+    "faraldo-edmm": KeyProfile.FaraldoEDMM,
+    edmm: KeyProfile.FaraldoEDMM,
+    "bellman-budge": KeyProfile.BellmanBudge,
+    bellman: KeyProfile.BellmanBudge
+  };
+  return names[profile];
+}
+function convertChordAnalysisResult(wasm) {
+  return {
+    chords: wasm.chords.map((c) => ({
+      root: c.root,
+      bass: c.bass,
+      rootName: pitchClassName(c.root),
+      bassName: pitchClassName(c.bass),
+      quality: c.quality,
+      start: c.start,
+      end: c.end,
+      confidence: c.confidence,
+      name: c.name
+    }))
+  };
+}
+function chordChromaMethodValue(method) {
+  if (method === "stft") {
+    return 0;
+  }
+  if (method === "nnls") {
+    return 1;
+  }
+  throw new Error(`Invalid chord chroma method: ${method}`);
+}
+function convertAnalysisResult(wasm) {
+  const beatTimes = new Float32Array(wasm.beats.length);
+  for (let i = 0; i < wasm.beats.length; i++) {
+    beatTimes[i] = wasm.beats[i].time;
+  }
+  return {
+    bpm: wasm.bpm,
+    bpmConfidence: wasm.bpmConfidence,
+    bpmCandidates: wasm.bpmCandidates.map((candidate) => ({
+      value: candidate.value,
+      confidence: candidate.confidence,
+      relation: candidate.relation
+    })),
+    key: {
+      root: wasm.key.root,
+      mode: wasm.key.mode,
+      confidence: wasm.key.confidence,
+      name: wasm.key.name,
+      shortName: wasm.key.shortName
+    },
+    timeSignature: wasm.timeSignature,
+    timeSignatureCandidates: wasm.timeSignatureCandidates,
+    beatTimes,
+    beats: wasm.beats,
+    chords: wasm.chords.map((c) => ({
+      root: c.root,
+      bass: c.bass,
+      rootName: pitchClassName(c.root),
+      bassName: pitchClassName(c.bass),
+      quality: c.quality,
+      start: c.start,
+      end: c.end,
+      confidence: c.confidence,
+      name: c.name
+    })),
+    sections: wasm.sections.map((s) => ({
+      type: s.type,
+      start: s.start,
+      end: s.end,
+      energyLevel: s.energyLevel,
+      confidence: s.confidence,
+      name: s.name
+    })),
+    timbre: wasm.timbre,
+    dynamics: wasm.dynamics,
+    rhythm: wasm.rhythm,
+    melody: wasm.melody,
+    form: wasm.form
+  };
+}
+
+// src/quick_analysis.ts
+function requireModule8() {
+  return getSonareModule();
+}
+function validateAnalysisInput(fnName, samples, sampleRate, options = {}) {
+  assertSampleRate(fnName, sampleRate);
+  assertSamples(fnName, samples, options.validate !== false);
+}
+function detectBpm(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("detectBpm", request.samples, request.sampleRate ?? 22050, request);
+  return requireModule8().detectBpm(request.samples, request.sampleRate ?? 22050);
+}
+function detectKey(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("detectKey", request.samples, request.sampleRate ?? 22050, request);
+  const result = requireModule8()._detectKeyWithOptions(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.nFft ?? 4096,
+    request.hopLength ?? 512,
+    request.useHpss ?? false,
+    request.loudnessWeighted ?? false,
+    request.highPassHz ?? 0,
+    keyModeValues(request.modes),
+    keyProfileValue(request.profile),
+    request.genreHint ?? ""
+  );
+  return {
+    root: result.root,
+    mode: result.mode,
+    confidence: result.confidence,
+    name: result.name,
+    shortName: result.shortName
+  };
+}
+function detectKeyCandidates(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput(
+    "detectKeyCandidates",
+    request.samples,
+    request.sampleRate ?? 22050,
+    request
+  );
+  const candidates = requireModule8()._detectKeyCandidates(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.nFft ?? 4096,
+    request.hopLength ?? 512,
+    request.useHpss ?? false,
+    request.loudnessWeighted ?? false,
+    request.highPassHz ?? 0,
+    keyModeValues(request.modes),
+    keyProfileValue(request.profile),
+    request.genreHint ?? ""
+  );
+  return Array.from(candidates, convertKeyCandidate);
+}
+function detectOnsets(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("detectOnsets", request.samples, request.sampleRate ?? 22050, request);
+  return requireModule8().detectOnsets(request.samples, request.sampleRate ?? 22050, request);
+}
+function detectBeats(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("detectBeats", request.samples, request.sampleRate ?? 22050, request);
+  return requireModule8().detectBeats(request.samples, request.sampleRate ?? 22050);
+}
+function detectDownbeats(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("detectDownbeats", request.samples, request.sampleRate ?? 22050, request);
+  return requireModule8().detectDownbeats(request.samples, request.sampleRate ?? 22050);
+}
+function detectChords(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("detectChords", request.samples, request.sampleRate ?? 22050, request);
+  const result = requireModule8().detectChords(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.minDuration ?? 0.3,
+    request.smoothingWindow ?? 2,
+    request.threshold ?? 0.5,
+    request.useTriadsOnly ?? false,
+    request.nFft ?? 2048,
+    request.hopLength ?? 512,
+    request.useBeatSync ?? true,
+    request.useHmm ?? false,
+    request.hmmBeamWidth ?? 24,
+    request.useKeyContext ?? false,
+    request.keyRoot ?? PitchClass.C,
+    request.keyMode ?? Mode.Major,
+    request.detectInversions ?? false,
+    chordChromaMethodValue(request.chromaMethod ?? "stft")
+  );
+  return convertChordAnalysisResult(result);
+}
+function chordFunctionalAnalysis(samples, keyRoot, keyMode, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, keyRoot, keyMode, sampleRate, ...options } : samples;
+  validateAnalysisInput(
+    "chordFunctionalAnalysis",
+    request.samples,
+    request.sampleRate ?? 22050,
+    request
+  );
+  return requireModule8().chordFunctionalAnalysis(
+    request.samples,
+    request.keyRoot,
+    request.keyMode ?? Mode.Major,
+    request.sampleRate ?? 22050,
+    request.minDuration ?? 0.3,
+    request.smoothingWindow ?? 2,
+    request.threshold ?? 0.5,
+    request.useTriadsOnly ?? false,
+    request.nFft ?? 2048,
+    request.hopLength ?? 512,
+    request.useBeatSync ?? true,
+    request.useHmm ?? false,
+    request.hmmBeamWidth ?? 24,
+    request.useKeyContext ?? false,
+    request.detectInversions ?? false,
+    chordChromaMethodValue(request.chromaMethod ?? "stft")
+  );
+}
+function analyze(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("analyze", request.samples, request.sampleRate ?? 22050, request);
+  const result = requireModule8().analyze(request.samples, request.sampleRate ?? 22050, request);
+  return convertAnalysisResult(result);
+}
+function analyzeImpulseResponse(samples, sampleRate = 48e3, nOctaveBands = 6) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, nOctaveBands } : samples;
+  validateAnalysisInput(
+    "analyzeImpulseResponse",
+    request.samples,
+    request.sampleRate ?? 48e3,
+    request
+  );
+  const result = requireModule8().analyzeImpulseResponse(
+    request.samples,
+    request.sampleRate ?? 48e3,
+    request.nOctaveBands ?? 6
+  );
+  return result;
+}
+function detectAcoustic(samples, sampleRate = 48e3, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("detectAcoustic", request.samples, request.sampleRate ?? 48e3, request);
+  const result = requireModule8().detectAcoustic(
+    request.samples,
+    request.sampleRate ?? 48e3,
+    request.nOctaveBands ?? 6,
+    request.nThirdOctaveSubbands ?? 24,
+    request.minDecayDb ?? 30,
+    request.noiseFloorMarginDb ?? 10
+  );
+  return result;
+}
+function analyzeWithProgress(samples, sampleRate = 22050, onProgress) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, onProgress } : samples;
+  validateAnalysisInput(
+    "analyzeWithProgress",
+    request.samples,
+    request.sampleRate ?? 22050,
+    request
+  );
+  const result = requireModule8().analyzeWithProgress(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.onProgress ?? (() => {
+    }),
+    request.cancel ?? (() => false)
+  );
+  return convertAnalysisResult(result);
+}
+function analyzeBpm(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("analyzeBpm", request.samples, request.sampleRate ?? 22050, request);
+  assertNonNegativeInteger("analyzeBpm", request.maxCandidates ?? 5, "maxCandidates");
+  return requireModule8().analyzeBpm(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.bpmMin ?? 30,
+    request.bpmMax ?? 300,
+    request.startBpm ?? 120,
+    request.nFft ?? 2048,
+    request.hopLength ?? 512,
+    request.maxCandidates ?? 5
+  );
+}
+function analyzeRhythm(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("analyzeRhythm", request.samples, request.sampleRate ?? 22050, request);
+  return requireModule8().analyzeRhythm(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.bpmMin ?? 60,
+    request.bpmMax ?? 200,
+    request.startBpm ?? 120,
+    request.nFft ?? 2048,
+    request.hopLength ?? 512
+  );
+}
+function analyzeDynamics(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("analyzeDynamics", request.samples, request.sampleRate ?? 22050, request);
+  return requireModule8().analyzeDynamics(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.windowSec ?? 0.4,
+    request.hopLength ?? 512,
+    request.compressionThreshold ?? 6
+  );
+}
+function analyzeTimbre(samples, sampleRate = 22050, options = {}) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  validateAnalysisInput("analyzeTimbre", request.samples, request.sampleRate ?? 22050, request);
+  return requireModule8().analyzeTimbre(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.nFft ?? 2048,
+    request.hopLength ?? 512,
+    request.nMels ?? 128,
+    request.nMfcc ?? 13,
+    request.windowSec ?? 0.5
+  );
+}
+function hasFfmpegSupport() {
+  return requireModule8().hasFfmpegSupport();
+}
+
+// src/analysis.ts
+var module = null;
+var initPromise = null;
+async function init(options) {
+  if (module) {
+    return;
+  }
+  if (initPromise) {
+    return initPromise;
+  }
+  initPromise = (async () => {
+    try {
+      const createModule = options?.moduleFactory ?? (await import("./sonare-analysis.js")).default;
+      module = await createModule(options);
+      setSonareModule(module);
+    } catch (error) {
+      initPromise = null;
+      throw error;
+    }
+  })();
+  return initPromise;
+}
+function isInitialized() {
+  return module !== null;
+}
+function version() {
+  if (!module) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return module.version();
+}
+function capabilities() {
+  if (!module) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return module.capabilities();
+}
+function abiVersion() {
+  if (!module) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return module.abiVersion();
+}
+function engineAbiVersion() {
+  if (!module) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return module.engineAbiVersion();
+}
+function voiceChangerAbiVersion() {
+  if (!module) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return module.voiceChangerAbiVersion();
+}
+export {
+  ChordQuality,
+  ErrorCode,
+  KeyProfile,
+  Mode,
+  PitchClass,
+  SectionType,
+  SonareError,
+  abiVersion,
+  amplitudeToDb,
+  analyze,
+  analyzeBpm,
+  analyzeDynamics,
+  analyzeImpulseResponse,
+  analyzeMelody,
+  analyzeRhythm,
+  analyzeSections,
+  analyzeTimbre,
+  analyzeWithProgress,
+  bassChroma,
+  capabilities,
+  chirp,
+  chordFunctionalAnalysis,
+  chroma,
+  chromaCens,
+  chromaCqt,
+  clicks,
+  cqt,
+  cqtToAudio,
+  cyclicTempogram,
+  dbToAmplitude,
+  dbToPower,
+  decompose,
+  decomposeWithInit,
+  deemphasis,
+  detectAcoustic,
+  detectBeats,
+  detectBpm,
+  detectChords,
+  detectDownbeats,
+  detectKey,
+  detectKeyCandidates,
+  detectOnsets,
+  ebur128LoudnessRange,
+  engineAbiVersion,
+  estimateTuning,
+  fixFrames,
+  fixLength,
+  fourierTempogram,
+  frameSignal,
+  framesToSamples,
+  framesToTime,
+  griffinLim,
+  hasFfmpegSupport,
+  hpssWithResidual,
+  hybridCqt,
+  hzToMel,
+  hzToMidi,
+  hzToNote,
+  init,
+  isInitialized,
+  isSonareError,
+  lufs,
+  lufsInterleaved,
+  melDelta,
+  melSpectrogram,
+  melToAudio,
+  melToHz,
+  melToStft,
+  meteringCrestFactorDb,
+  meteringDcOffset,
+  meteringDetectClipping,
+  meteringDynamicRange,
+  meteringPeakDb,
+  meteringPhaseScope,
+  meteringPhaseScopeDecimated,
+  meteringRmsDb,
+  meteringSilenceRatio,
+  meteringSpectrum,
+  meteringSpectrumFrame,
+  meteringStereoCorrelation,
+  meteringStereoWidth,
+  meteringTruePeakDb,
+  meteringVectorscope,
+  meteringVectorscopeDecimated,
+  mfcc,
+  mfccToAudio,
+  mfccToMel,
+  midiToHz,
+  momentaryLufs,
+  nnFilter,
+  nnlsChroma,
+  noteSegments,
+  noteToHz,
+  onsetBacktrack,
+  onsetEnvelope,
+  onsetStrengthMulti,
+  padCenter,
+  pcen,
+  peakPick,
+  phaseVocoder,
+  piptrack,
+  pitchPyin,
+  pitchTuning,
+  pitchYin,
+  plp,
+  polyFeatures,
+  powerToDb,
+  preemphasis,
+  pseudoCqt,
+  reassignedSpectrogram,
+  remix,
+  resample,
+  rmsEnergy,
+  samplesToFrames,
+  segmentAgglomerative,
+  segmentCrossSimilarity,
+  segmentLagToRecurrence,
+  segmentPathEnhance,
+  segmentRecurrenceMatrix,
+  segmentRecurrenceToLag,
+  segmentSubsegment,
+  shortTermLufs,
+  spectralBandwidth,
+  spectralCentroid,
+  spectralContrast,
+  spectralFlatness,
+  spectralFlux,
+  spectralRolloff,
+  splitSilence,
+  stft,
+  stftDb,
+  tempogram,
+  tempogramRatio,
+  timeToFrames,
+  tone,
+  tonnetz,
+  trim,
+  trimSilence,
+  vectorNormalize,
+  version,
+  voiceChangerAbiVersion,
+  vqt,
+  vqtToAudio,
+  waveformPeakPyramid,
+  waveformPeaks,
+  zeroCrossingRate,
+  zeroCrossings
+};
+//# sourceMappingURL=analysis.js.map