var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);

// src/biquad/Coefficients.ts
var FilterType = {
  SinglePoleLowPassApprox: 0,
  SinglePoleLowPass: 1,
  LowPass: 2,
  HighPass: 3,
  BandPass: 4,
  Notch: 5,
  AllPass: 6,
  LowShelf: 7,
  HighShelf: 8,
  PeakingEQ: 9
};
var Q_BUTTERWORTH = Math.SQRT1_2;
var _Coefficients = class _Coefficients {
  constructor(data) {
    // Denominator coefficients
    __publicField(this, "a1", 0);
    __publicField(this, "a2", 0);
    // Nominator coefficients
    __publicField(this, "b0", 0);
    __publicField(this, "b1", 0);
    __publicField(this, "b2", 0);
    if (data) {
      this.a1 = data.a1;
      this.a2 = data.a2;
      this.b0 = data.b0;
      this.b1 = data.b1;
      this.b2 = data.b2;
    }
  }
  static from(filter, samplingFreq, cutoffFreq, Q, dbGain = -10) {
    if (2 * cutoffFreq > samplingFreq) {
      throw new Error(`Cutoff frequency is too big!`);
    }
    if (Q < 0) {
      throw new Error(`Q may not be negative`);
    }
    const omega = 2 * Math.PI * cutoffFreq / samplingFreq;
    const bqf = typeof filter === "string" ? FilterType[filter] : filter;
    switch (bqf) {
      case FilterType.SinglePoleLowPassApprox: {
        const alpha = omega / (omega + 1);
        return new _Coefficients({
          a1: alpha - 1,
          a2: 0,
          b0: alpha,
          b1: 0,
          b2: 0
        });
      }
      case FilterType.SinglePoleLowPass: {
        const omega_t = Math.tan(omega / 2);
        const a0 = 1 + omega_t;
        return new _Coefficients({
          a1: (omega_t - 1) / a0,
          a2: 0,
          b0: omega_t / a0,
          b1: omega_t / a0,
          b2: 0
        });
      }
      case FilterType.LowPass: {
        const omega_s = Math.sin(omega);
        const omega_c = Math.cos(omega);
        const alpha = omega_s / (2 * Q);
        const b0 = (1 - omega_c) * 0.5;
        const b1 = 1 - omega_c;
        const b2 = (1 - omega_c) * 0.5;
        const a0 = 1 + alpha;
        const a1 = -2 * omega_c;
        const a2 = 1 - alpha;
        const div = 1 / a0;
        return new _Coefficients({
          a1: a1 * div,
          a2: a2 * div,
          b0: b0 * div,
          b1: b1 * div,
          b2: b2 * div
        });
      }
      case FilterType.HighPass: {
        const omega_s = Math.sin(omega);
        const omega_c = Math.cos(omega);
        const alpha = omega_s / (2 * Q);
        const b0 = (1 + omega_c) * 0.5;
        const b1 = -(1 + omega_c);
        const b2 = (1 + omega_c) * 0.5;
        const a0 = 1 + alpha;
        const a1 = -2 * omega_c;
        const a2 = 1 - alpha;
        const div = 1 / a0;
        return new _Coefficients({
          a1: a1 * div,
          a2: a2 * div,
          b0: b0 * div,
          b1: b1 * div,
          b2: b2 * div
        });
      }
      case FilterType.Notch: {
        const omega_s = Math.sin(omega);
        const omega_c = Math.cos(omega);
        const alpha = omega_s / (2 * Q);
        const b0 = 1;
        const b1 = -2 * omega_c;
        const b2 = 1;
        const a0 = 1 + alpha;
        const a1 = -2 * omega_c;
        const a2 = 1 - alpha;
        const div = 1 / a0;
        return new _Coefficients({
          a1: a1 * div,
          a2: a2 * div,
          b0: b0 * div,
          b1: b1 * div,
          b2: b2 * div
        });
      }
      case FilterType.BandPass: {
        const omega_s = Math.sin(omega);
        const omega_c = Math.cos(omega);
        const alpha = omega_s / (2 * Q);
        const b0 = omega_s / 2;
        const b1 = 0;
        const b2 = -(omega_s / 2);
        const a0 = 1 + alpha;
        const a1 = -2 * omega_c;
        const a2 = 1 - alpha;
        const div = 1 / a0;
        return new _Coefficients({
          a1: a1 * div,
          a2: a2 * div,
          b0: b0 * div,
          b1: b1 * div,
          b2: b2 * div
        });
      }
      case FilterType.AllPass: {
        const omega_s = Math.sin(omega);
        const omega_c = Math.cos(omega);
        const alpha = omega_s / (2 * Q);
        const b0 = 1 - alpha;
        const b1 = -2 * omega_c;
        const b2 = 1 + alpha;
        const a0 = 1 + alpha;
        const a1 = -2 * omega_c;
        const a2 = 1 - alpha;
        return new _Coefficients({
          a1: a1 / a0,
          a2: a2 / a0,
          b0: b0 / a0,
          b1: b1 / a0,
          b2: b2 / a0
        });
      }
      case FilterType.LowShelf: {
        const a = Math.pow(10, dbGain / 40);
        const omega_s = Math.sin(omega);
        const omega_c = Math.cos(omega);
        const alpha = omega_s / (2 * Q);
        const b0 = a * (a + 1 - (a - 1) * omega_c + 2 * alpha * Math.sqrt(a));
        const b1 = 2 * a * (a - 1 - (a + 1) * omega_c);
        const b2 = a * (a + 1 - (a - 1) * omega_c - 2 * alpha * Math.sqrt(a));
        const a0 = a + 1 + (a - 1) * omega_c + 2 * alpha * Math.sqrt(a);
        const a1 = -2 * (a - 1 + (a + 1) * omega_c);
        const a2 = a + 1 + (a - 1) * omega_c - 2 * alpha * Math.sqrt(a);
        return new _Coefficients({
          a1: a1 / a0,
          a2: a2 / a0,
          b0: b0 / a0,
          b1: b1 / a0,
          b2: b2 / a0
        });
      }
      case FilterType.HighShelf: {
        const a = Math.pow(10, dbGain / 40);
        const omega_s = Math.sin(omega);
        const omega_c = Math.cos(omega);
        const alpha = omega_s / (2 * Q);
        const b0 = a * (a + 1 + (a - 1) * omega_c + 2 * alpha * Math.sqrt(a));
        const b1 = -2 * a * (a - 1 + (a + 1) * omega_c);
        const b2 = a * (a + 1 + (a - 1) * omega_c - 2 * alpha * Math.sqrt(a));
        const a0 = a + 1 - (a - 1) * omega_c + 2 * alpha * Math.sqrt(a);
        const a1 = 2 * (a - 1 - (a + 1) * omega_c);
        const a2 = a + 1 - (a - 1) * omega_c - 2 * alpha * Math.sqrt(a);
        return new _Coefficients({
          a1: a1 / a0,
          a2: a2 / a0,
          b0: b0 / a0,
          b1: b1 / a0,
          b2: b2 / a0
        });
      }
      case FilterType.PeakingEQ: {
        const a = Math.pow(10, dbGain / 40);
        const omega_s = Math.sin(omega);
        const omega_c = Math.cos(omega);
        const alpha = omega_s / (2 * Q);
        const b0 = 1 + alpha * a;
        const b1 = -2 * omega_c;
        const b2 = 1 - alpha * a;
        const a0 = 1 + alpha / a;
        const a1 = -2 * omega_c;
        const a2 = 1 - alpha / a;
        return new _Coefficients({
          a1: a1 / a0,
          a2: a2 / a0,
          b0: b0 / a0,
          b1: b1 / a0,
          b2: b2 / a0
        });
      }
      default:
        throw new TypeError(`Invalid filter type "${filter}"`);
    }
  }
};
__name(_Coefficients, "Coefficients");
var Coefficients = _Coefficients;

// src/biquad/Biquad.ts
var _BiquadFilter = class _BiquadFilter {
  constructor(coefficients) {
    this.coefficients = coefficients;
    __publicField(this, "x1", 0);
    __publicField(this, "x2", 0);
    __publicField(this, "y1", 0);
    __publicField(this, "y2", 0);
    __publicField(this, "s1", 0);
    __publicField(this, "s2", 0);
  }
  setFilter(filter, options) {
    const coefficients = Coefficients.from(
      filter,
      options.fs,
      options.f0,
      options.Q,
      options.gain
    );
    this.update(coefficients);
  }
  update(coefficients) {
    this.coefficients = coefficients;
  }
  replace(coefficients) {
    this.coefficients = coefficients;
  }
  reset() {
    this.x1 = 0;
    this.x2 = 0;
    this.y1 = 0;
    this.y2 = 0;
    this.s1 = 0;
    this.s2 = 0;
  }
  run(input) {
    const { a1, a2, b0, b1, b2 } = this.coefficients;
    const out = b0 * input + b1 * this.x1 + b2 * this.x2 - a1 * this.y1 - a2 * this.y2;
    this.x2 = this.x1;
    this.x1 = input;
    this.y2 = this.y1;
    this.y1 = out;
    return out;
  }
  runTransposed(input) {
    const { a1, a2, b0, b1, b2 } = this.coefficients;
    const out = this.s1 + b0 * input;
    this.s1 = this.s2 + b1 * input - a1 * out;
    this.s2 = b2 * input - a2 * out;
    return out;
  }
};
__name(_BiquadFilter, "BiquadFilter");
var BiquadFilter = _BiquadFilter;

// src/utils/Frequency.ts
var _Frequency = class _Frequency {
  constructor(__val) {
    this.__val = __val;
    if (typeof __val !== "number" || isNaN(__val) || __val === Infinity)
      throw new TypeError("Frequency value must be a number");
    if (this.__val < 0)
      throw new Error(`Frequency value cannot be negative (${__val})`);
  }
  khz() {
    return this.__val * 1e3;
  }
  mhz() {
    return this.__val * 1e6;
  }
  hz() {
    return this.__val;
  }
  dt() {
    return 1 / this.__val;
  }
  valueOf() {
    return this.__val;
  }
  toString() {
    return `${this.__val}Hz`;
  }
  toJSON() {
    return this.toString();
  }
};
__name(_Frequency, "Frequency");
var Frequency = _Frequency;

// src/utils/PCMTransformer.ts
import { Transform } from "stream";
var _PCMTransformer = class _PCMTransformer extends Transform {
  constructor(options = {}) {
    super(options);
    __publicField(this, "type", "s16le");
    __publicField(this, "bits");
    __publicField(this, "bytes");
    __publicField(this, "extremum");
    __publicField(this, "disabled", false);
    __publicField(this, "sampleRate", 48e3);
    __publicField(this, "onUpdate", /* @__PURE__ */ __name(() => {
    }, "onUpdate"));
    options.type ?? (options.type = "s16le");
    this.disabled = !!options.disabled;
    if (typeof options.sampleRate === "number" && options.sampleRate > 0) {
      this.sampleRate = options.sampleRate;
    }
    switch (options.type) {
      case "s16be":
      case "s16le":
        this.type = options.type;
        this.bits = 16;
        break;
      case "s32be":
      case "s32le":
        this.type = options.type;
        this.bits = 32;
        break;
      default:
        throw new TypeError(
          `Expected type to be one of ${["s16be", "s16le", "s32be", "s32le"].join(", ")}, got "${options.type}"`
        );
    }
    this.bytes = this.bits / 8;
    this.extremum = Math.pow(2, this.bits - 1);
  }
  disable() {
    this.disabled = true;
  }
  enable() {
    this.disabled = false;
  }
  toggle() {
    this.disabled = !this.disabled;
    return this.disabled;
  }
  _readInt(buffer, index) {
    const method = `readInt${this.type.substring(1).toUpperCase()}`;
    return buffer[method](index);
  }
  _writeInt(buffer, int, index) {
    const method = `writeInt${this.type.substring(1).toUpperCase()}`;
    return buffer[method](int, index);
  }
  clamp(val, max = this.extremum - 1, min = -this.extremum) {
    return Math.min(max, Math.max(min, val));
  }
  setSampleRate(rate) {
    this.sampleRate = rate;
    return;
  }
};
__name(_PCMTransformer, "PCMTransformer");
var PCMTransformer = _PCMTransformer;

// src/biquad/BiquadStream.ts
var _BiquadStream = class _BiquadStream extends PCMTransformer {
  constructor(options = {}) {
    super(options);
    __publicField(this, "biquad");
    __publicField(this, "cutoff", 80);
    __publicField(this, "gain", 0);
    __publicField(this, "biquadFilter");
    __publicField(this, "Q", Q_BUTTERWORTH);
    if ("cutoff" in options) this.cutoff = options.cutoff;
    if ("gain" in options) this.gain = options.gain;
    if ("Q" in options) this.Q = options.Q;
    if ("biquadFilter" in options) {
      if (typeof options.biquadFilter === "string" || typeof options.biquadFilter === "number")
        this.biquadFilter = options.filter;
      if (this.biquadFilter != null) {
        this.biquad = new BiquadFilter(
          Coefficients.from(
            this.biquadFilter,
            this.sampleRate,
            this.cutoff,
            this.Q,
            this.gain
          )
        );
      }
    }
  }
  get filters() {
    return this.biquadFilter;
  }
  set filters(f) {
    if (f == null || typeof f === "string" || typeof f === "number") {
      this.update({ filter: f });
    } else {
      throw new TypeError(`Invalid biquad filter type "${f}"`);
    }
  }
  getFilterName() {
    if (this.biquadFilter == null) return null;
    if (typeof this.biquadFilter === "string") return this.biquadFilter;
    return Object.entries(FilterType).find(
      (r) => r[1] === this.biquadFilter
    )?.[0];
  }
  update(options) {
    if ("cutoff" in options) this.cutoff = options.cutoff;
    if ("gain" in options) this.gain = options.gain;
    if ("Q" in options) this.Q = options.Q;
    if ("filter" in options) this.biquadFilter = options.filter;
    if (this.biquadFilter != null) {
      this.biquad = new BiquadFilter(
        Coefficients.from(
          this.biquadFilter,
          this.sampleRate,
          this.cutoff,
          this.Q,
          this.gain
        )
      );
    }
    this.onUpdate?.();
  }
  setFilter(filter) {
    this.update({ filter });
  }
  setQ(Q) {
    this.update({ Q });
  }
  setCutoff(f0) {
    this.update({ cutoff: f0 });
  }
  setGain(dB) {
    this.update({ gain: dB });
  }
  _transform(chunk, encoding, callback) {
    if (this.disabled || !this.biquad) {
      this.push(chunk);
      return callback();
    }
    const endIndex = Math.floor(chunk.length / 2) * 2;
    const { bytes } = this;
    for (let sampleIndex = 0; sampleIndex < endIndex; sampleIndex += bytes) {
      const int = this._readInt(chunk, sampleIndex);
      const result = this.biquad.run(int);
      this._writeInt(chunk, this.clamp(result), sampleIndex);
    }
    this.push(chunk);
    return callback();
  }
};
__name(_BiquadStream, "BiquadStream");
var BiquadStream = _BiquadStream;

// src/equalizer/ChannelProcessor.ts
var _ChannelProcessor = class _ChannelProcessor {
  constructor(bandMultipliers) {
    __publicField(this, "history");
    __publicField(this, "bandMultipliers");
    __publicField(this, "current");
    __publicField(this, "m1");
    __publicField(this, "m2");
    this.history = new Array(Equalizer.BAND_COUNT * 6).fill(0);
    this.bandMultipliers = bandMultipliers;
    this.current = 0;
    this.m1 = 2;
    this.m2 = 1;
  }
  processInt(int) {
    let result = int * 0.25;
    for (let bandIndex = 0; bandIndex < Equalizer.BAND_COUNT; bandIndex++) {
      const x = bandIndex * 6;
      const y = x + 3;
      const coefficients = Equalizer.Coefficients48000[bandIndex];
      const bandResult = coefficients.alpha * (int - this.history[x + this.m2]) + coefficients.gamma * this.history[y + this.m1] - coefficients.beta * this.history[y + this.m2];
      this.history[x + this.current] = int;
      this.history[y + this.current] = bandResult;
      result += bandResult * this.bandMultipliers[bandIndex];
    }
    const val = result * 4;
    return val;
  }
  process(samples, extremum = 131072, bytes = 2, readInt, writeInt) {
    const endIndex = Math.floor(samples.length / 2) * 2;
    for (let sampleIndex = 0; sampleIndex < endIndex; sampleIndex += bytes) {
      const sample = readInt?.(samples, sampleIndex) ?? samples.readInt16LE(sampleIndex);
      const result = this.processInt(sample);
      const val = Math.min(extremum - 1, Math.max(-extremum, result));
      writeInt?.(samples, val, sampleIndex) ?? samples.writeInt16LE(val, sampleIndex);
      this.step();
    }
    return samples;
  }
  step() {
    if (++this.current === 3) {
      this.current = 0;
    }
    if (++this.m1 === 3) {
      this.m1 = 0;
    }
    if (++this.m2 === 3) {
      this.m2 = 0;
    }
  }
  reset() {
    this.history.fill(0);
  }
};
__name(_ChannelProcessor, "ChannelProcessor");
var ChannelProcessor = _ChannelProcessor;

// src/equalizer/Coefficients.ts
var _EqualizerCoefficients = class _EqualizerCoefficients {
  constructor(beta, alpha, gamma) {
    this.beta = beta;
    this.alpha = alpha;
    this.gamma = gamma;
  }
  setBeta(v) {
    this.beta = v;
  }
  setAlpha(v) {
    this.alpha = v;
  }
  setGamma(v) {
    this.gamma = v;
  }
  toJSON() {
    const { alpha, beta, gamma } = this;
    return { alpha, beta, gamma };
  }
};
__name(_EqualizerCoefficients, "EqualizerCoefficients");
var EqualizerCoefficients = _EqualizerCoefficients;

// src/equalizer/EqualizerConfiguration.ts
var _EqualizerConfiguration = class _EqualizerConfiguration {
  constructor(bandMultipliers) {
    this.bandMultipliers = bandMultipliers;
  }
  setGain(band, value) {
    if (this.isValidBand(band)) {
      this.bandMultipliers[band] = Math.max(Math.min(value, 1), -0.25);
    }
  }
  getGain(band) {
    if (this.isValidBand(band)) {
      return this.bandMultipliers[band];
    } else {
      return 0;
    }
  }
  isValidBand(band) {
    return band >= 0 && band < this.bandMultipliers.length;
  }
};
__name(_EqualizerConfiguration, "EqualizerConfiguration");
var EqualizerConfiguration = _EqualizerConfiguration;

// src/equalizer/Equalizer.ts
var _Equalizer = class _Equalizer extends EqualizerConfiguration {
  constructor(channelCount, bandMultipliers) {
    super(bandMultipliers);
    __publicField(this, "channels", []);
    __publicField(this, "channelCount");
    this.channelCount = channelCount;
    this.channels = this.createChannelProcessor();
  }
  createChannelProcessor() {
    return Array.from({ length: this.channelCount }, () => {
      return new ChannelProcessor(this.bandMultipliers);
    });
  }
  process(input) {
    return this.channels.map((c, i) => {
      const { data, extremum, readInt, writeInt, bytes } = input[i];
      return c.process(data, extremum, bytes, readInt, writeInt);
    });
  }
};
__name(_Equalizer, "Equalizer");
__publicField(_Equalizer, "BAND_COUNT", 15);
__publicField(_Equalizer, "SAMPLE_RATE", 48e3);
__publicField(_Equalizer, "Coefficients48000", [
  new EqualizerCoefficients(0.99847546664, 76226668143e-14, 1.9984647656),
  new EqualizerCoefficients(0.99756184654, 0.0012190767289, 1.9975344645),
  new EqualizerCoefficients(0.99616261379, 0.0019186931041, 1.9960947369),
  new EqualizerCoefficients(0.99391578543, 0.0030421072865, 1.9937449618),
  new EqualizerCoefficients(0.99028307215, 0.0048584639242, 1.9898465702),
  new EqualizerCoefficients(0.98485897264, 0.0075705136795, 1.9837962543),
  new EqualizerCoefficients(0.97588512657, 0.012057436715, 1.9731772447),
  new EqualizerCoefficients(0.96228521814, 0.018857390928, 1.9556164694),
  new EqualizerCoefficients(0.94080933132, 0.029595334338, 1.9242054384),
  new EqualizerCoefficients(0.90702059196, 0.046489704022, 1.8653476166),
  new EqualizerCoefficients(0.85868004289, 0.070659978553, 1.7600401337),
  new EqualizerCoefficients(0.78409610788, 0.10795194606, 1.5450725522),
  new EqualizerCoefficients(0.68332861002, 0.15833569499, 1.1426447155),
  new EqualizerCoefficients(
    0.55267518228,
    0.22366240886,
    0.40186190803
  ),
  new EqualizerCoefficients(
    0.41811888447,
    0.29094055777,
    -0.70905944223
  )
]);
var Equalizer = _Equalizer;

// src/equalizer/EqualizerStream.ts
var _EqualizerStream = class _EqualizerStream extends PCMTransformer {
  constructor(options) {
    super(options);
    __publicField(this, "bandMultipliers", new Array(Equalizer.BAND_COUNT).fill(0));
    __publicField(this, "equalizer");
    options = Object.assign(
      {},
      {
        bandMultiplier: [],
        channels: 1
      },
      options || {}
    );
    this.equalizer = new Equalizer(options.channels || 1, this.bandMultipliers);
    if (Array.isArray(options.bandMultiplier))
      this._processBands(options.bandMultiplier);
  }
  _processBands(multiplier) {
    for (const mul of multiplier) {
      if (mul.band > Equalizer.BAND_COUNT - 1 || mul.band < 0)
        throw new RangeError(
          `Band value out of range. Expected >0 & <${Equalizer.BAND_COUNT - 1}, received "${mul.band}"`
        );
      this.equalizer.setGain(mul.band, mul.gain);
    }
    this.onUpdate?.();
  }
  _transform(chunk, encoding, callback) {
    if (this.disabled) {
      this.push(chunk);
      return callback();
    }
    this.equalizer.process(
      [
        {
          data: chunk,
          extremum: this.extremum,
          readInt: /* @__PURE__ */ __name((b, idx) => this._readInt(b, idx), "readInt"),
          writeInt: /* @__PURE__ */ __name((b, i, idx) => this._writeInt(b, i, idx), "writeInt"),
          bytes: this.bytes
        }
      ]
    );
    this.push(chunk);
    return callback();
  }
  getEQ() {
    return this.bandMultipliers.map((m, i) => ({
      band: i,
      gain: m
    }));
  }
  setEQ(bands) {
    this._processBands(bands);
  }
  resetEQ() {
    this._processBands(
      Array.from(
        {
          length: Equalizer.BAND_COUNT
        },
        (_, i) => ({
          band: i,
          gain: 0
        })
      )
    );
  }
};
__name(_EqualizerStream, "EqualizerStream");
var EqualizerStream = _EqualizerStream;

// src/audio/MonoStereoTransformer.ts
var _MonoStereoTransformer = class _MonoStereoTransformer extends PCMTransformer {
  constructor(options) {
    super(options);
    __publicField(this, "strategy");
    if (!["m2s", "s2m"].includes(options?.strategy)) {
      throw new TypeError(`Strategy must be "m2s" or "s2m"`);
    }
    this.strategy = options.strategy;
  }
  setStrategy(strategy) {
    this.strategy = strategy;
  }
  _transform(chunk, encoding, callback) {
    if (this.disabled) {
      this.push(chunk);
      return callback();
    }
    const len = Math.floor(chunk.length / 2) * 2;
    if (this.strategy === "m2s") {
      this.push(this.toStereo(chunk, len));
    } else {
      this.push(this.toMono(chunk, len));
    }
    return callback();
  }
  toStereo(sample, len) {
    const bytes = this.bytes;
    const stereoBuffer = Buffer.alloc(len * 2);
    for (let i = 0; i < len; i += bytes) {
      stereoBuffer[i * 2 + 0] = sample[i];
      stereoBuffer[i * 2 + 1] = sample[i + 1];
      stereoBuffer[i * 2 + 2] = sample[i];
      stereoBuffer[i * 2 + 3] = sample[i + 1];
    }
    return stereoBuffer;
  }
  toMono(sample, len) {
    const bytes = this.bytes;
    const monoBuffer = Buffer.alloc(Math.floor(len / 2));
    for (let i = 0; i < len; i += bytes) {
      monoBuffer[i] = sample[i * 2 + 0];
      monoBuffer[i + 1] = sample[i * 2 + 1];
    }
    return monoBuffer;
  }
};
__name(_MonoStereoTransformer, "MonoStereoTransformer");
var MonoStereoTransformer = _MonoStereoTransformer;

// src/audio/transformers/index.ts
var transformers_exports = {};
__export(transformers_exports, {
  applyBiquad: () => applyBiquad,
  applyEqualization: () => applyEqualization,
  applyPulsator: () => applyPulsator,
  applyTremolo: () => applyTremolo,
  applyVibrato: () => applyVibrato,
  applyVolume: () => applyVolume
});

// src/audio/transformers/biquad.ts
function applyBiquad(filterer, int) {
  return filterer.run(int);
}
__name(applyBiquad, "applyBiquad");

// src/audio/transformers/dsp.ts
function applyPulsator(config, int, channel) {
  const sin = Math.sin(config.x);
  const currentChannelVal = channel === 0 ? sin : -sin;
  const res = int * (currentChannelVal + 1) / 2;
  config.x += config.dI;
  return res;
}
__name(applyPulsator, "applyPulsator");
function applyTremolo(config, int, sampleRate) {
  const fOffset = 1 - config.depth;
  const modSignal = fOffset + config.depth * Math.sin(config.phase);
  config.phase += 2 * Math.PI / sampleRate * config.frequency;
  return modSignal * int;
}
__name(applyTremolo, "applyTremolo");
function applyVibrato(config, int, sampleRate) {
  const fOffset = 1 - config.depth;
  const modSignal = fOffset + config.depth * Math.sin(2 * Math.PI * config.phase);
  config.phase += 2 * Math.PI / sampleRate * config.frequency;
  return modSignal * int;
}
__name(applyVibrato, "applyVibrato");
function applyVolume(vol, int) {
  return vol * int;
}
__name(applyVolume, "applyVolume");

// src/audio/transformers/equalizer.ts
function applyEqualization(eq, int) {
  const processor = eq.channels[0];
  const result = processor.processInt(int);
  processor.step();
  return result;
}
__name(applyEqualization, "applyEqualization");

// src/audio/AudioFilter.ts
var AudioFilters = {
  "8D": "8D",
  Tremolo: "Tremolo",
  Vibrato: "Vibrato"
};
var AF_NIGHTCORE_RATE = 1.3;
var AF_VAPORWAVE_RATE = 0.8;
var BASS_EQ_BANDS = Array.from(
  { length: 3 },
  (_, i) => ({
    band: i,
    gain: 0.25
  })
);
var _AudioFilter = class _AudioFilter extends PCMTransformer {
  constructor(options) {
    super(options);
    __publicField(this, "filters", []);
    __publicField(this, "targetSampleRate", this.sampleRate);
    __publicField(this, "pulsatorConfig", {
      hz: 0.02,
      x: 0,
      dI: 3926990816987241e-21
    });
    __publicField(this, "tremoloConfig", {
      phase: 0,
      depth: 0.5,
      frequency: 5
    });
    __publicField(this, "vibratoConfig", {
      phase: 0,
      depth: 0.5,
      frequency: 5
    });
    if (options && Array.isArray(options.filters)) {
      this.setFilters(options.filters);
    }
    this.onUpdate?.();
  }
  setTargetSampleRate(rate) {
    this.targetSampleRate = rate || this.sampleRate;
    return;
  }
  setPulsator(hz) {
    hz /= 4;
    this.pulsatorConfig.hz = hz;
    const samplesPerCycle = this.targetSampleRate / (hz * 2 * Math.PI);
    this.pulsatorConfig.dI = hz === 0 ? 0 : 1 / samplesPerCycle;
    this.onUpdate?.();
  }
  get pulsator() {
    return this.pulsatorConfig.hz;
  }
  setTremolo({
    depth = this.tremoloConfig.depth,
    frequency = this.tremoloConfig.frequency,
    phase = this.tremoloConfig.phase
  }) {
    if (typeof depth === "number") this.tremoloConfig.depth = depth;
    if (typeof frequency === "number") this.tremoloConfig.frequency = frequency;
    if (typeof phase === "number") this.tremoloConfig.phase = phase;
    this.onUpdate?.();
  }
  setVibrato({
    depth = this.vibratoConfig.depth,
    frequency = this.vibratoConfig.frequency,
    phase = this.vibratoConfig.phase
  }) {
    if (typeof depth === "number") this.vibratoConfig.depth = depth;
    if (typeof frequency === "number") this.vibratoConfig.frequency = frequency;
    if (typeof phase === "number") this.vibratoConfig.phase = phase;
    this.onUpdate?.();
  }
  get tremolo() {
    return this.tremoloConfig;
  }
  setFilters(filters) {
    if (!Array.isArray(filters) || !filters.every((r) => r in AudioFilters)) {
      return false;
    }
    this.filters = filters;
    this.onUpdate?.();
    return true;
  }
  _transform(chunk, encoding, callback) {
    if (this.disabled || !this.filters.length) {
      return callback(null, chunk);
    }
    const len = Math.floor(chunk.length / 2) * 2;
    const { bytes } = this;
    let L = false;
    for (let i = 0; i < len; i += bytes) {
      const int = this._readInt(chunk, i);
      const value = this.applyFilters(int, +(L = !L));
      this._writeInt(chunk, this.clamp(value), i);
    }
    this.push(chunk);
    return callback();
  }
  get currentSampleRate() {
    return this.targetSampleRate || this.sampleRate;
  }
  applyFilters(byte, channel) {
    if (this.filters.length) {
      for (const filter of this.filters) {
        if (filter === "8D") {
          byte = applyPulsator(this.pulsatorConfig, byte, channel);
        }
        if (filter === "Tremolo") {
          byte = applyTremolo(this.tremoloConfig, byte, this.currentSampleRate);
        }
        if (filter === "Vibrato") {
          byte = applyVibrato(this.vibratoConfig, byte, this.currentSampleRate);
        }
      }
    }
    return byte;
  }
};
__name(_AudioFilter, "AudioFilter");
var AudioFilter = _AudioFilter;

// src/audio/PCMResampler.ts
var _PCMResampler = class _PCMResampler extends PCMTransformer {
  constructor(options) {
    super(options);
    __publicField(this, "inputSampleRate");
    __publicField(this, "channels");
    __publicField(this, "buffer");
    __publicField(this, "currentFilter", null);
    this.inputSampleRate = options?.inputSampleRate ?? 48e3;
    this.channels = options?.channels ?? 2;
    this.buffer = Buffer.alloc(0);
    if (this.inputSampleRate < 1) {
      this.inputSampleRate = 48e3;
    }
    if (options?.targetSampleRate) {
      this.setSampleRate(options?.targetSampleRate);
    }
  }
  setFilter(filter) {
    if (this.currentFilter === filter) return;
    switch (filter) {
      case "nightcore":
        this.setSampleRate(this.inputSampleRate * 1.25);
        break;
      case "vaporwave":
        this.setSampleRate(this.inputSampleRate * 0.8);
        break;
      default:
        this.setSampleRate(this.inputSampleRate);
        break;
    }
    this.currentFilter = filter;
  }
  getParameters() {
    return {
      currentFilter: this.currentFilter,
      inputSampleRate: this.inputSampleRate,
      channels: this.channels,
      sampleRate: this.sampleRate
    };
  }
  toggleFilter(filter) {
    const same = this.currentFilter === filter;
    this.setFilter(same ? null : filter);
    return !same;
  }
  getRatio() {
    if (this.inputSampleRate === 0) return 1;
    return this.sampleRate / this.inputSampleRate;
  }
  resample(input) {
    const bytesPerFrame = this.bytes * this.channels;
    const inputFrames = Math.floor(input.length / bytesPerFrame);
    const outputFrames = Math.floor(
      inputFrames * this.inputSampleRate / this.sampleRate
    );
    const output = Buffer.alloc(outputFrames * bytesPerFrame);
    for (let outFrame = 0; outFrame < outputFrames; outFrame++) {
      const inPos = outFrame * this.sampleRate / this.inputSampleRate;
      const inFrame = Math.floor(inPos);
      if (inFrame >= inputFrames - 1 || (inFrame + 1) * bytesPerFrame + (this.channels - 1) * this.bytes > input.length) {
        break;
      }
      const fraction = inPos - inFrame;
      for (let channel = 0; channel < this.channels; channel++) {
        const pos1 = inFrame * bytesPerFrame + channel * this.bytes;
        const pos2 = (inFrame + 1) * bytesPerFrame + channel * this.bytes;
        if (pos1 + this.bytes > input.length || pos2 + this.bytes > input.length) {
          continue;
        }
        const sample1 = this._readInt(input, pos1);
        const sample2 = this._readInt(input, pos2);
        const interpolated = sample1 + fraction * (sample2 - sample1);
        const clamped = this.clamp(Math.round(interpolated));
        const outPos = outFrame * bytesPerFrame + channel * this.bytes;
        this._writeInt(output, clamped, outPos);
      }
    }
    return output;
  }
  _transform(chunk, encoding, callback) {
    if (this.disabled || this.sampleRate === this.inputSampleRate) {
      this.push(chunk);
      callback();
      return;
    }
    this.buffer = Buffer.concat([this.buffer, chunk]);
    const bytesPerFrame = this.bytes * this.channels;
    const minFramesNeeded = Math.ceil(
      bytesPerFrame * (this.inputSampleRate / this.sampleRate)
    );
    const completeFrames = Math.floor(this.buffer.length / bytesPerFrame) - 1;
    if (completeFrames >= minFramesNeeded) {
      const processSize = completeFrames * bytesPerFrame;
      const toProcess = this.buffer.slice(0, processSize);
      this.buffer = this.buffer.slice(processSize);
      const resampled = this.resample(toProcess);
      this.push(resampled);
    }
    callback();
  }
  _flush(callback) {
    if (this.disabled) {
      callback();
      return;
    }
    if (this.buffer.length > 0) {
      const resampled = this.resample(this.buffer);
      this.push(resampled);
    }
    callback();
  }
  setSampleRate(rate) {
    if (rate === this.sampleRate) return;
    if (rate < 1) {
      throw new RangeError("Sample rate must be greater than 0");
    }
    super.setSampleRate(rate);
    this.onUpdate();
  }
};
__name(_PCMResampler, "PCMResampler");
var PCMResampler = _PCMResampler;

// src/audio/VolumeTransformer.ts
var _VolumeTransformer = class _VolumeTransformer extends PCMTransformer {
  constructor(options) {
    super(options);
    __publicField(this, "_volume", 1);
    if (typeof options?.volume === "number") {
      this.setVolume(options.volume);
    }
  }
  get volumeApprox() {
    return this._volume * 100;
  }
  get volume() {
    return Math.floor(this.volumeApprox);
  }
  set volume(volume) {
    this.setVolume(volume);
  }
  setVolume(volume) {
    if (typeof volume !== "number" || isNaN(volume))
      throw new Error(
        `Expected volume amount to be a number, received ${typeof volume}!`
      );
    if (volume < 0) volume = 0;
    if (!isFinite(volume)) volume = 100;
    this._volume = volume / 100;
    this.onUpdate?.();
    return true;
  }
  _transform(chunk, encoding, callback) {
    if (this.disabled || this._volume === 1) {
      this.push(chunk);
      return callback();
    }
    const len = Math.floor(chunk.length / 2) * 2;
    const { bytes } = this;
    for (let i = 0; i < len; i += bytes) {
      const int = this._readInt(chunk, i);
      const amp = this.clamp(int * this._volume);
      this._writeInt(chunk, amp, i);
    }
    this.push(chunk);
    return callback();
  }
  toString() {
    return `${this.volume}%`;
  }
};
__name(_VolumeTransformer, "VolumeTransformer");
var VolumeTransformer = _VolumeTransformer;

// src/audio/CompressorTransformer.ts
var _CompressorTransformer = class _CompressorTransformer extends PCMTransformer {
  constructor(options = {}) {
    super(options);
    __publicField(this, "threshold");
    __publicField(this, "ratio");
    __publicField(this, "attack");
    __publicField(this, "release");
    __publicField(this, "makeupGain");
    __publicField(this, "kneeWidth");
    __publicField(this, "envelope", 0);
    __publicField(this, "gainReduction", 1);
    __publicField(this, "previousGainReduction", 1);
    this.threshold = options.threshold ?? -20;
    this.ratio = options.ratio ?? 4;
    this.attack = options.attack ?? 20;
    this.release = options.release ?? 100;
    this.makeupGain = options.makeupGain ?? 0;
    this.kneeWidth = options.kneeWidth ?? 6;
    this.attack = Math.exp(-1 / (this.sampleRate * this.attack / 1e3));
    this.release = Math.exp(-1 / (this.sampleRate * this.release / 1e3));
  }
  linearToDb(linear) {
    const val = 20 * Math.log10(Math.max(linear, 1e-6));
    return val;
  }
  dbToLinear(db) {
    const val = Math.pow(10, db / 20);
    return val;
  }
  setThreshold(db) {
    this.threshold = Math.max(-100, Math.min(0, db));
    this.onUpdate();
  }
  setRatio(ratio) {
    this.ratio = Math.max(1, ratio);
    this.onUpdate();
  }
  setAttack(ms) {
    this.attack = Math.exp(-1 / (this.sampleRate * Math.max(0.1, ms) / 1e3));
    this.onUpdate();
  }
  setRelease(ms) {
    this.release = Math.exp(
      -1 / (this.sampleRate * Math.max(0.1, ms) / 1e3)
    );
    this.onUpdate();
  }
  setMakeupGain(db) {
    this.makeupGain = Math.max(-20, Math.min(20, db));
    this.onUpdate();
  }
  setKneeWidth(db) {
    this.kneeWidth = Math.max(0, Math.min(20, db));
    this.onUpdate();
  }
  setCompressor(options) {
    if (typeof options.threshold === "number") {
      this.setThreshold(options.threshold);
    }
    if (typeof options.ratio === "number") {
      this.setRatio(options.ratio);
    }
    if (typeof options.attack === "number") {
      this.setAttack(options.attack);
    }
    if (typeof options.release === "number") {
      this.setRelease(options.release);
    }
    if (typeof options.makeupGain === "number") {
      this.setMakeupGain(options.makeupGain);
    }
    if (typeof options.kneeWidth === "number") {
      this.setKneeWidth(options.kneeWidth);
    }
    this.onUpdate();
    return this.getParameters();
  }
  getParameters() {
    return {
      threshold: this.threshold,
      ratio: this.ratio,
      attack: this.attack,
      release: this.release,
      makeupGain: this.makeupGain,
      kneeWidth: this.kneeWidth
    };
  }
  computeGainReduction(inputLevel) {
    const inputDb = this.linearToDb(inputLevel);
    let gainReductionDb = 0;
    if (2 * (inputDb - this.threshold) < -this.kneeWidth) {
      gainReductionDb = 0;
    } else if (2 * Math.abs(inputDb - this.threshold) <= this.kneeWidth) {
      const x = inputDb - this.threshold + this.kneeWidth / 2;
      gainReductionDb = (1 / this.ratio - 1) * Math.pow(x, 2) / (2 * this.kneeWidth);
    } else {
      gainReductionDb = (inputDb - this.threshold) * (1 - 1 / this.ratio);
    }
    return this.dbToLinear(-gainReductionDb + this.makeupGain);
  }
  processSample(input) {
    if (this.disabled) return input;
    const inputFloat = input / this.extremum;
    const inputLevel = Math.abs(inputFloat);
    const coeff = inputLevel > this.envelope ? this.attack : this.release;
    this.envelope = coeff * this.envelope + (1 - coeff) * inputLevel;
    const targetGainReduction = this.computeGainReduction(this.envelope);
    this.gainReduction = Math.min(
      this.previousGainReduction * this.attack + targetGainReduction * (1 - this.attack),
      targetGainReduction
    );
    this.previousGainReduction = this.gainReduction;
    const outputFloat = inputFloat * this.gainReduction;
    return this.clamp(Math.floor(outputFloat * this.extremum));
  }
  _transform(chunk, encoding, callback) {
    if (this.disabled) {
      callback(null, chunk);
      return;
    }
    const output = Buffer.alloc(chunk.length);
    for (let i = 0; i < chunk.length; i += this.bytes) {
      const sample = this._readInt(chunk, i);
      const processed = this.processSample(sample);
      this._writeInt(output, processed, i);
    }
    callback(null, output);
  }
};
__name(_CompressorTransformer, "CompressorTransformer");
var CompressorTransformer = _CompressorTransformer;

// src/audio/PCMSeekerTransformer.ts
import { EventEmitter } from "events";
var _PCMSeekerTransformer = class _PCMSeekerTransformer extends PCMTransformer {
  constructor(options = {
    channels: 2,
    totalDuration: 0
  }) {
    super(options);
    __publicField(this, "totalDuration");
    __publicField(this, "channels");
    __publicField(this, "bytesPerFrame");
    __publicField(this, "currentPosition", 0);
    __publicField(this, "seekTarget", null);
    __publicField(this, "buffer", Buffer.alloc(0));
    __publicField(this, "events", new EventEmitter());
    if (options.totalDuration == null || options.totalDuration < 0) {
      throw new Error("totalDuration must be a positive number");
    }
    if (!options.channels || options.channels <= 0) {
      throw new Error("channels must be a positive number");
    }
    this.totalDuration = options.totalDuration;
    this.channels = options.channels;
    if (typeof options.seekTarget === "number" && options.seekTarget > 0) {
      this.seekTarget = options.seekTarget;
    }
    this.updateDependentValues();
  }
  getParameters() {
    return {
      currentPosition: this.currentPosition,
      seekTarget: this.seekTarget,
      totalDuration: this.totalDuration
    };
  }
  updateDependentValues() {
    this.bytesPerFrame = this.bytes * this.channels;
    if (this.currentPosition > 0) {
      const currentMs = this.currentPosition / (this.sampleRate / 1e3);
      this.currentPosition = Math.floor(currentMs / 1e3 * this.sampleRate);
    }
    if (this.seekTarget !== null) {
      const seekMs = this.seekTarget / (this.sampleRate / 1e3);
      this.seekTarget = Math.floor(seekMs / 1e3 * this.sampleRate);
    }
  }
  /**
   * Calculate byte position from sample position
   * @param samplePosition Position in samples
   * @returns Position in bytes
   */
  sampleToBytePosition(samplePosition) {
    return samplePosition * this.bytesPerFrame;
  }
  setTotalDuration(duration) {
    if (duration <= 0) {
      throw new Error("totalDuration must be a positive number");
    }
    this.totalDuration = duration;
    this.updateDependentValues();
    this.onUpdate();
  }
  setSampleRate(rate) {
    super.setSampleRate(rate);
    this.updateDependentValues();
    this.onUpdate();
  }
  /**
   * Seek to a specific position in milliseconds
   * @param ms Position in milliseconds (negative values seek from end)
   * @returns Actual position in milliseconds after seeking
   */
  seek(ms) {
    if (this.totalDuration === 0) return 0;
    if (ms < 0) {
      ms = Math.max(0, this.totalDuration + ms);
    }
    ms = Math.max(0, Math.min(this.totalDuration, ms));
    const targetSample = Math.floor(ms / 1e3 * this.sampleRate);
    if (targetSample < this.currentPosition) {
      this.buffer = Buffer.alloc(0);
      const bytePosition = this.sampleToBytePosition(targetSample);
      this.events.emit("seek", {
        position: ms,
        sample: targetSample,
        bytePosition
      });
    }
    this.seekTarget = targetSample;
    return targetSample / this.sampleRate * 1e3;
  }
  getPosition() {
    return this.currentPosition / this.sampleRate * 1e3;
  }
  handleSeek(chunk) {
    if (this.seekTarget === null) return chunk;
    const chunkStartSample = this.currentPosition;
    const chunkSamples = Math.floor(chunk.length / this.bytesPerFrame);
    const chunkEndSample = chunkStartSample + chunkSamples;
    if (this.seekTarget >= chunkEndSample) {
      this.currentPosition += chunkSamples;
      return Buffer.alloc(0);
    }
    if (this.seekTarget >= chunkStartSample) {
      const offsetSamples = this.seekTarget - chunkStartSample;
      const offsetBytes = offsetSamples * this.bytesPerFrame;
      this.currentPosition = this.seekTarget;
      this.seekTarget = null;
      return chunk.subarray(offsetBytes);
    }
    this.currentPosition = this.seekTarget;
    this.seekTarget = null;
    return chunk;
  }
  _transform(chunk, encoding, callback) {
    try {
      if (this.disabled || this.totalDuration === 0) {
        callback(null, chunk);
        return;
      }
      const combinedBuffer = Buffer.concat([this.buffer, chunk]);
      const frameCount = Math.floor(combinedBuffer.length / this.bytesPerFrame);
      const processableBytes = frameCount * this.bytesPerFrame;
      this.buffer = combinedBuffer.subarray(processableBytes);
      let processBuffer = combinedBuffer.subarray(0, processableBytes);
      if (this.seekTarget !== null) {
        processBuffer = this.handleSeek(processBuffer);
      } else {
        this.currentPosition += frameCount;
      }
      callback(null, processBuffer);
    } catch (error) {
      callback(error);
    }
  }
  _flush(callback) {
    if (this.buffer.length >= this.bytesPerFrame) {
      const frameCount = Math.floor(this.buffer.length / this.bytesPerFrame);
      const processableBytes = frameCount * this.bytesPerFrame;
      callback(null, this.buffer.subarray(0, processableBytes));
    }
    callback();
  }
};
__name(_PCMSeekerTransformer, "PCMSeekerTransformer");
var PCMSeekerTransformer = _PCMSeekerTransformer;

// src/audio/ReverbTransformer.ts
var _ReverbTransformer = class _ReverbTransformer extends PCMTransformer {
  constructor(options = {}) {
    super(options);
    __publicField(this, "roomSize");
    __publicField(this, "damping");
    __publicField(this, "wetLevel");
    __publicField(this, "dryLevel");
    __publicField(this, "delayLines");
    __publicField(this, "delayLineLength");
    __publicField(this, "delayIndices");
    __publicField(this, "numDelayLines", 8);
    __publicField(this, "feedback", 0.84);
    this.roomSize = options.roomSize ?? 0.5;
    this.damping = options.damping ?? 0.5;
    this.wetLevel = options.wetLevel ?? 0.3;
    this.dryLevel = options.dryLevel ?? 0.7;
    this.delayLineLength = Math.floor(this.sampleRate * 0.05);
    this.delayLines = Array.from(
      { length: this.numDelayLines },
      () => new Float32Array(this.delayLineLength)
    );
    this.delayIndices = Array(this.numDelayLines).fill(0);
  }
  setRoomSize(size) {
    this.roomSize = Math.max(0, Math.min(1, size));
    this.onUpdate();
  }
  setDamping(damping) {
    this.damping = Math.max(0, Math.min(1, damping));
    this.onUpdate();
  }
  setWetLevel(level) {
    this.wetLevel = Math.max(0, Math.min(1, level));
    this.onUpdate();
  }
  setDryLevel(level) {
    this.dryLevel = Math.max(0, Math.min(1, level));
    this.onUpdate();
  }
  setReverb(options) {
    if (typeof options.roomSize === "number") {
      this.setRoomSize(options.roomSize);
    }
    if (typeof options.damping === "number") {
      this.setDamping(options.damping);
    }
    if (typeof options.wetLevel === "number") {
      this.setWetLevel(options.wetLevel);
    }
    if (typeof options.dryLevel === "number") {
      this.setDryLevel(options.dryLevel);
    }
    this.onUpdate();
    return this.getParameters();
  }
  getParameters() {
    return {
      roomSize: this.roomSize,
      damping: this.damping,
      wetLevel: this.wetLevel,
      dryLevel: this.dryLevel
    };
  }
  processSample(input) {
    if (this.disabled) return input;
    const inputFloat = input / this.extremum;
    let wet = 0;
    for (let i = 0; i < this.numDelayLines; i++) {
      const delayLine = this.delayLines[i];
      const delayIndex = this.delayIndices[i];
      const delayed = delayLine[delayIndex];
      const processed = delayed * this.roomSize * (1 - this.damping);
      delayLine[delayIndex] = inputFloat + processed * this.feedback;
      this.delayIndices[i] = (delayIndex + 1) % this.delayLineLength;
      wet += processed;
    }
    const output = inputFloat * this.dryLevel + wet * this.wetLevel / this.numDelayLines;
    return this.clamp(Math.floor(output * this.extremum));
  }
  _transform(chunk, encoding, callback) {
    if (this.disabled) {
      callback(null, chunk);
      return;
    }
    const output = Buffer.alloc(chunk.length);
    for (let i = 0; i < chunk.length; i += this.bytes) {
      const sample = this._readInt(chunk, i);
      const processed = this.processSample(sample);
      this._writeInt(output, processed, i);
    }
    callback(null, output);
  }
};
__name(_ReverbTransformer, "ReverbTransformer");
var ReverbTransformer = _ReverbTransformer;

// src/FiltersChainBuilder.ts
import { pipeline } from "stream";
var _FiltersChain = class _FiltersChain {
  constructor(presets = {}) {
    this.presets = presets;
    __publicField(this, "equalizer", null);
    __publicField(this, "filters", null);
    __publicField(this, "biquad", null);
    __publicField(this, "volume", null);
    __publicField(this, "resampler", null);
    __publicField(this, "compressor", null);
    __publicField(this, "seeker", null);
    __publicField(this, "reverb", null);
    __publicField(this, "destination", null);
    __publicField(this, "source", null);
    __publicField(this, "onUpdate", /* @__PURE__ */ __name(() => null, "onUpdate"));
    __publicField(this, "onError", /* @__PURE__ */ __name(() => null, "onError"));
  }
  create(src, presets = this.presets) {
    this.destroy();
    this.source = src;
    const resampler = !presets.resampler?.disabled ? new PCMResampler(presets.resampler) : null;
    const equalizerStream = !presets.equalizer?.disabled ? new EqualizerStream(presets.equalizer) : null;
    const dspStream = !presets.dsp?.disabled ? new AudioFilter(presets.dsp) : null;
    const biquadStream = !presets.biquad?.disabled ? new BiquadStream(presets.biquad) : null;
    const volumeTransformer = !presets.volume?.disabled ? new VolumeTransformer(presets.volume) : null;
    const compressor = !presets.compressor?.disabled ? new CompressorTransformer(presets.compressor) : null;
    const seeker = !presets.seeker?.disabled ? new PCMSeekerTransformer(presets.seeker) : null;
    const reverb = !presets.reverb?.disabled ? new ReverbTransformer(presets.reverb) : null;
    this.resampler = resampler;
    this.equalizer = equalizerStream;
    this.filters = dspStream;
    this.biquad = biquadStream;
    this.volume = volumeTransformer;
    this.compressor = compressor;
    this.seeker = seeker;
    this.reverb = reverb;
    if (resampler) resampler.onUpdate = this.onUpdate;
    if (equalizerStream) equalizerStream.onUpdate = this.onUpdate;
    if (dspStream) dspStream.onUpdate = this.onUpdate;
    if (biquadStream) biquadStream.onUpdate = this.onUpdate;
    if (volumeTransformer) volumeTransformer.onUpdate = this.onUpdate;
    if (compressor) compressor.onUpdate = this.onUpdate;
    if (seeker) seeker.onUpdate = this.onUpdate;
    if (reverb) reverb.onUpdate = this.onUpdate;
    const chains = [
      src,
      resampler,
      equalizerStream,
      reverb,
      dspStream,
      biquadStream,
      compressor,
      volumeTransformer,
      seeker
    ].filter(Boolean);
    if (!chains.length) return src;
    this.destination = pipeline(...chains, (err) => {
      if (err) {
        this.destroy();
        if (!err.message.includes("ERR_STREAM_PREMATURE_CLOSE"))
          this.onError(err);
      }
    });
    this.destination.once("close", this.destroy.bind(this));
    return this.destination;
  }
  destroy() {
    this.resampler?.destroy();
    this.equalizer?.destroy();
    this.biquad?.destroy();
    this.filters?.destroy();
    this.volume?.destroy();
    this.compressor?.destroy();
    this.seeker?.destroy();
    this.reverb?.destroy();
    this.destination?.destroy();
    this.source?.destroy();
    this.resampler?.removeAllListeners();
    this.equalizer?.removeAllListeners();
    this.biquad?.removeAllListeners();
    this.filters?.removeAllListeners();
    this.volume?.removeAllListeners();
    this.compressor?.removeAllListeners();
    this.seeker?.removeAllListeners();
    this.reverb?.removeAllListeners();
    this.destination?.removeAllListeners();
    this.source?.removeAllListeners();
    this.resampler = null;
    this.equalizer = null;
    this.biquad = null;
    this.filters = null;
    this.volume = null;
    this.compressor = null;
    this.seeker = null;
    this.reverb = null;
    this.destination = null;
    this.source = null;
  }
};
__name(_FiltersChain, "FiltersChain");
var FiltersChain = _FiltersChain;

// src/version.ts
var version = (
  /* @__MACRO__ getVersion */
  "7.2.0"
);
export {
  AF_NIGHTCORE_RATE,
  AF_VAPORWAVE_RATE,
  AudioFilter,
  AudioFilters,
  BASS_EQ_BANDS,
  BiquadFilter,
  BiquadStream,
  ChannelProcessor,
  Coefficients,
  CompressorTransformer,
  Equalizer,
  EqualizerCoefficients,
  EqualizerConfiguration,
  EqualizerStream,
  FilterType,
  FiltersChain,
  Frequency,
  MonoStereoTransformer,
  transformers_exports as PCMAudioTransformer,
  PCMResampler,
  PCMSeekerTransformer,
  PCMTransformer,
  Q_BUTTERWORTH,
  ReverbTransformer,
  VolumeTransformer,
  version
};
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/biquad/Coefficients.ts", "../src/biquad/Biquad.ts", "../src/utils/Frequency.ts", "../src/utils/PCMTransformer.ts", "../src/biquad/BiquadStream.ts", "../src/equalizer/ChannelProcessor.ts", "../src/equalizer/Coefficients.ts", "../src/equalizer/EqualizerConfiguration.ts", "../src/equalizer/Equalizer.ts", "../src/equalizer/EqualizerStream.ts", "../src/audio/MonoStereoTransformer.ts", "../src/audio/transformers/index.ts", "../src/audio/transformers/biquad.ts", "../src/audio/transformers/dsp.ts", "../src/audio/transformers/equalizer.ts", "../src/audio/AudioFilter.ts", "../src/audio/PCMResampler.ts", "../src/audio/VolumeTransformer.ts", "../src/audio/CompressorTransformer.ts", "../src/audio/PCMSeekerTransformer.ts", "../src/audio/ReverbTransformer.ts", "../src/FiltersChainBuilder.ts", "../src/version.ts"],
  "sourcesContent": ["export const FilterType = {\n  SinglePoleLowPassApprox: 0,\n  SinglePoleLowPass: 1,\n  LowPass: 2,\n  HighPass: 3,\n  BandPass: 4,\n  Notch: 5,\n  AllPass: 6,\n  LowShelf: 7,\n  HighShelf: 8,\n  PeakingEQ: 9\n} as const;\n\nexport type BiquadFilters =\nkeyof typeof FilterType |\n(typeof FilterType)[keyof typeof FilterType];\n\ninterface CoefficientsInit {\n  a1: number;\n  a2: number;\n  b0: number;\n  b1: number;\n  b2: number;\n}\n\nexport const Q_BUTTERWORTH = Math.SQRT1_2;\n\nexport class Coefficients {\n  // Denominator coefficients\n  public a1 = 0;\n  public a2 = 0;\n\n  // Nominator coefficients\n  public b0 = 0;\n  public b1 = 0;\n  public b2 = 0;\n\n  public constructor(data?: CoefficientsInit) {\n    if (data) {\n      this.a1 = data.a1;\n      this.a2 = data.a2;\n      this.b0 = data.b0;\n      this.b1 = data.b1;\n      this.b2 = data.b2;\n    }\n  }\n\n  public static from(\n  filter: BiquadFilters,\n  samplingFreq: number,\n  cutoffFreq: number,\n  Q: number,\n  dbGain = -10)\n  {\n    if (2.0 * cutoffFreq > samplingFreq) {\n      throw new Error(`Cutoff frequency is too big!`);\n    }\n\n    if (Q < 0) {\n      throw new Error(`Q may not be negative`);\n    }\n\n    const omega = 2.0 * Math.PI * cutoffFreq / samplingFreq;\n\n    const bqf = typeof filter === 'string' ? FilterType[filter] : filter;\n\n    switch (bqf) {\n      case FilterType.SinglePoleLowPassApprox:{\n          const alpha = omega / (omega + 1.0);\n\n          return new Coefficients({\n            a1: alpha - 1.0,\n            a2: 0.0,\n            b0: alpha,\n            b1: 0.0,\n            b2: 0.0\n          });\n        }\n      case FilterType.SinglePoleLowPass:{\n          const omega_t = Math.tan(omega / 2.0);\n          const a0 = 1.0 + omega_t;\n\n          return new Coefficients({\n            a1: (omega_t - 1.0) / a0,\n            a2: 0.0,\n            b0: omega_t / a0,\n            b1: omega_t / a0,\n            b2: 0.0\n          });\n        }\n      case FilterType.LowPass:{\n          const omega_s = Math.sin(omega);\n          const omega_c = Math.cos(omega);\n          const alpha = omega_s / (2.0 * Q);\n\n          const b0 = (1.0 - omega_c) * 0.5;\n          const b1 = 1.0 - omega_c;\n          const b2 = (1.0 - omega_c) * 0.5;\n          const a0 = 1.0 + alpha;\n          const a1 = -2.0 * omega_c;\n          const a2 = 1.0 - alpha;\n\n          const div = 1.0 / a0;\n\n          return new Coefficients({\n            a1: a1 * div,\n            a2: a2 * div,\n            b0: b0 * div,\n            b1: b1 * div,\n            b2: b2 * div\n          });\n        }\n      case FilterType.HighPass:{\n          const omega_s = Math.sin(omega);\n          const omega_c = Math.cos(omega);\n          const alpha = omega_s / (2.0 * Q);\n\n          const b0 = (1.0 + omega_c) * 0.5;\n          const b1 = -(1.0 + omega_c);\n          const b2 = (1.0 + omega_c) * 0.5;\n          const a0 = 1.0 + alpha;\n          const a1 = -2.0 * omega_c;\n          const a2 = 1.0 - alpha;\n\n          const div = 1.0 / a0;\n\n          return new Coefficients({\n            a1: a1 * div,\n            a2: a2 * div,\n            b0: b0 * div,\n            b1: b1 * div,\n            b2: b2 * div\n          });\n        }\n      case FilterType.Notch:{\n          const omega_s = Math.sin(omega);\n          const omega_c = Math.cos(omega);\n          const alpha = omega_s / (2.0 * Q);\n\n          const b0 = 1.0;\n          const b1 = -2.0 * omega_c;\n          const b2 = 1.0;\n          const a0 = 1.0 + alpha;\n          const a1 = -2.0 * omega_c;\n          const a2 = 1.0 - alpha;\n\n          const div = 1.0 / a0;\n\n          return new Coefficients({\n            a1: a1 * div,\n            a2: a2 * div,\n            b0: b0 * div,\n            b1: b1 * div,\n            b2: b2 * div\n          });\n        }\n      case FilterType.BandPass:{\n          const omega_s = Math.sin(omega);\n          const omega_c = Math.cos(omega);\n          const alpha = omega_s / (2.0 * Q);\n\n          const b0 = omega_s / 2.0;\n          const b1 = 0;\n          const b2 = -(omega_s / 2.0);\n          const a0 = 1.0 + alpha;\n          const a1 = -2.0 * omega_c;\n          const a2 = 1.0 - alpha;\n\n          const div = 1.0 / a0;\n\n          return new Coefficients({\n            a1: a1 * div,\n            a2: a2 * div,\n            b0: b0 * div,\n            b1: b1 * div,\n            b2: b2 * div\n          });\n        }\n      case FilterType.AllPass:{\n          const omega_s = Math.sin(omega);\n          const omega_c = Math.cos(omega);\n          const alpha = omega_s / (2.0 * Q);\n\n          const b0 = 1.0 - alpha;\n          const b1 = -2.0 * omega_c;\n          const b2 = 1.0 + alpha;\n          const a0 = 1.0 + alpha;\n          const a1 = -2.0 * omega_c;\n          const a2 = 1.0 - alpha;\n\n          return new Coefficients({\n            a1: a1 / a0,\n            a2: a2 / a0,\n            b0: b0 / a0,\n            b1: b1 / a0,\n            b2: b2 / a0\n          });\n        }\n      case FilterType.LowShelf:{\n          const a = Math.pow(10.0, dbGain / 40.0);\n          const omega_s = Math.sin(omega);\n          const omega_c = Math.cos(omega);\n          const alpha = omega_s / (2.0 * Q);\n\n          const b0 =\n          a * (a + 1.0 - (a - 1.0) * omega_c + 2.0 * alpha * Math.sqrt(a));\n          const b1 = 2.0 * a * (a - 1.0 - (a + 1.0) * omega_c);\n          const b2 =\n          a * (a + 1.0 - (a - 1.0) * omega_c - 2.0 * alpha * Math.sqrt(a));\n          const a0 = a + 1.0 + (a - 1.0) * omega_c + 2.0 * alpha * Math.sqrt(a);\n          const a1 = -2.0 * (a - 1.0 + (a + 1.0) * omega_c);\n          const a2 = a + 1.0 + (a - 1.0) * omega_c - 2.0 * alpha * Math.sqrt(a);\n\n          return new Coefficients({\n            a1: a1 / a0,\n            a2: a2 / a0,\n            b0: b0 / a0,\n            b1: b1 / a0,\n            b2: b2 / a0\n          });\n        }\n      case FilterType.HighShelf:{\n          const a = Math.pow(10.0, dbGain / 40.0);\n          const omega_s = Math.sin(omega);\n          const omega_c = Math.cos(omega);\n          const alpha = omega_s / (2.0 * Q);\n\n          const b0 =\n          a * (a + 1.0 + (a - 1.0) * omega_c + 2.0 * alpha * Math.sqrt(a));\n          const b1 = -2.0 * a * (a - 1.0 + (a + 1.0) * omega_c);\n          const b2 =\n          a * (a + 1.0 + (a - 1.0) * omega_c - 2.0 * alpha * Math.sqrt(a));\n          const a0 = a + 1.0 - (a - 1.0) * omega_c + 2.0 * alpha * Math.sqrt(a);\n          const a1 = 2.0 * (a - 1.0 - (a + 1.0) * omega_c);\n          const a2 = a + 1.0 - (a - 1.0) * omega_c - 2.0 * alpha * Math.sqrt(a);\n\n          return new Coefficients({\n            a1: a1 / a0,\n            a2: a2 / a0,\n            b0: b0 / a0,\n            b1: b1 / a0,\n            b2: b2 / a0\n          });\n        }\n      case FilterType.PeakingEQ:{\n          const a = Math.pow(10.0, dbGain / 40.0);\n          const omega_s = Math.sin(omega);\n          const omega_c = Math.cos(omega);\n          const alpha = omega_s / (2.0 * Q);\n\n          const b0 = 1.0 + alpha * a;\n          const b1 = -2.0 * omega_c;\n          const b2 = 1.0 - alpha * a;\n          const a0 = 1.0 + alpha / a;\n          const a1 = -2.0 * omega_c;\n          const a2 = 1.0 - alpha / a;\n\n          return new Coefficients({\n            a1: a1 / a0,\n            a2: a2 / a0,\n            b0: b0 / a0,\n            b1: b1 / a0,\n            b2: b2 / a0\n          });\n        }\n      default:\n        throw new TypeError(`Invalid filter type \"${filter}\"`);\n    }\n  }\n}", "import { BiquadFilters, Coefficients } from './Coefficients';\n\nexport interface BiquadSetFilterProps {\n  f0: number;\n  fs: number;\n  Q: number;\n  gain?: number;\n}\n\nexport class BiquadFilter {\n  public x1 = 0.0;\n  public x2 = 0.0;\n  public y1 = 0.0;\n  public y2 = 0.0;\n  public s1 = 0.0;\n  public s2 = 0.0;\n\n  public constructor(public coefficients: Coefficients) {}\n\n  public setFilter(filter: BiquadFilters, options: BiquadSetFilterProps) {\n    const coefficients = Coefficients.from(\n      filter,\n      options.fs,\n      options.f0,\n      options.Q,\n      options.gain\n    );\n\n    this.update(coefficients);\n  }\n\n  public update(coefficients: Coefficients) {\n    this.coefficients = coefficients;\n  }\n\n  public replace(coefficients: Coefficients) {\n    this.coefficients = coefficients;\n  }\n\n  public reset() {\n    this.x1 = 0.0;\n    this.x2 = 0.0;\n    this.y1 = 0.0;\n    this.y2 = 0.0;\n    this.s1 = 0.0;\n    this.s2 = 0.0;\n  }\n\n  public run(input: number) {\n    const { a1, a2, b0, b1, b2 } = this.coefficients;\n\n    const out =\n    b0 * input + b1 * this.x1 + b2 * this.x2 - a1 * this.y1 - a2 * this.y2;\n\n    this.x2 = this.x1;\n    this.x1 = input;\n    this.y2 = this.y1;\n    this.y1 = out;\n\n    return out;\n  }\n\n  public runTransposed(input: number) {\n    const { a1, a2, b0, b1, b2 } = this.coefficients;\n\n    const out = this.s1 + b0 * input;\n\n    this.s1 = this.s2 + b1 * input - a1 * out;\n    this.s2 = b2 * input - a2 * out;\n\n    return out;\n  }\n}", "export class Frequency {\n  public constructor(private __val: number) {\n    if (typeof __val !== 'number' || isNaN(__val) || __val === Infinity)\n    throw new TypeError('Frequency value must be a number');\n    if (this.__val < 0)\n    throw new Error(`Frequency value cannot be negative (${__val})`);\n  }\n\n  public khz() {\n    return this.__val * 1000.0;\n  }\n\n  public mhz() {\n    return this.__val * 1_000_000.0;\n  }\n\n  public hz() {\n    return this.__val;\n  }\n\n  public dt() {\n    return 1.0 / this.__val;\n  }\n\n  public valueOf() {\n    return this.__val;\n  }\n\n  public toString() {\n    return `${this.__val}Hz`;\n  }\n\n  public toJSON() {\n    return this.toString();\n  }\n}", "import { Transform, TransformOptions } from 'stream';\n\nexport type PCMType = `s${16 | 32}${'l' | 'b'}e`;\n\nexport interface PCMTransformerOptions extends TransformOptions {\n  type?: PCMType;\n  disabled?: boolean;\n  sampleRate?: number;\n}\n\nexport class PCMTransformer extends Transform {\n  public readonly type: PCMType = 's16le';\n  public bits: number;\n  public bytes: number;\n  public extremum: number;\n  public disabled = false;\n  public sampleRate = 48000;\n  public onUpdate = (): void => {\n\n    /* noop */};\n\n  public constructor(options: PCMTransformerOptions = {}) {\n    super(options);\n\n    options.type ??= 's16le';\n    this.disabled = !!options.disabled;\n    if (typeof options.sampleRate === 'number' && options.sampleRate > 0) {\n      this.sampleRate = options.sampleRate;\n    }\n\n    switch (options.type) {\n      case 's16be':\n      case 's16le':\n        this.type = options.type;\n        this.bits = 16;\n        break;\n      case 's32be':\n      case 's32le':\n        this.type = options.type;\n        this.bits = 32;\n        break;\n      default:\n        throw new TypeError(\n          `Expected type to be one of ${(\n          ['s16be', 's16le', 's32be', 's32le'] as PCMType[]).\n          join(', ')}, got \"${options.type}\"`\n        );\n    }\n\n    this.bytes = this.bits / 8;\n    this.extremum = Math.pow(2, this.bits - 1);\n  }\n\n  public disable() {\n    this.disabled = true;\n  }\n\n  public enable() {\n    this.disabled = false;\n  }\n\n  public toggle() {\n    this.disabled = !this.disabled;\n\n    return this.disabled;\n  }\n\n  public _readInt(buffer: Buffer, index: number) {\n    const method = `readInt${this.type.\n    substring(1).\n    toUpperCase()}` as `readInt${16 | 32}${'L' | 'B'}E`;\n    return buffer[method](index);\n  }\n\n  public _writeInt(buffer: Buffer, int: number, index: number) {\n    const method = `writeInt${this.type.\n    substring(1).\n    toUpperCase()}` as `writeInt${16 | 32}${'L' | 'B'}E`;\n    return buffer[method](int, index);\n  }\n\n  public clamp(val: number, max = this.extremum - 1, min = -this.extremum) {\n    return Math.min(max, Math.max(min, val));\n  }\n\n  public setSampleRate(rate: number) {\n    this.sampleRate = rate;\n    return;\n  }\n}", "import { TransformCallback } from 'stream';\nimport { PCMTransformer, PCMTransformerOptions } from '../utils';\nimport { BiquadFilter } from './Biquad';\nimport {\n  BiquadFilters,\n  Coefficients,\n  FilterType,\n  Q_BUTTERWORTH } from\n'./Coefficients';\n\nexport interface BiquadStreamOptions extends PCMTransformerOptions {\n  filter?: BiquadFilters;\n  Q?: number;\n  cutoff?: number;\n  gain?: number;\n}\n\nexport interface BiquadFilterUpdateData {\n  filter?: BiquadFilters;\n  Q?: number;\n  cutoff?: number;\n  gain?: number;\n}\n\nexport class BiquadStream extends PCMTransformer {\n  public biquad!: BiquadFilter;\n  public cutoff = 80;\n  public gain = 0;\n  public biquadFilter!: BiquadFilters;\n  public Q = Q_BUTTERWORTH;\n  public constructor(options: BiquadStreamOptions = {}) {\n    super(options);\n\n    if ('cutoff' in options) this.cutoff = options.cutoff!;\n    if ('gain' in options) this.gain = options.gain!;\n    if ('Q' in options) this.Q = options.Q!;\n    if ('biquadFilter' in options) {\n      if (\n      typeof options.biquadFilter === 'string' ||\n      typeof options.biquadFilter === 'number')\n\n      this.biquadFilter = options.filter!;\n      if (this.biquadFilter != null) {\n        this.biquad = new BiquadFilter(\n          Coefficients.from(\n            this.biquadFilter,\n            this.sampleRate,\n            this.cutoff,\n            this.Q,\n            this.gain\n          )\n        );\n      }\n    }\n  }\n\n  public get filters() {\n    return this.biquadFilter;\n  }\n\n  public set filters(f: BiquadFilters) {\n    if (f == null || typeof f === 'string' || typeof f === 'number') {\n      this.update({ filter: f });\n    } else {\n      throw new TypeError(`Invalid biquad filter type \"${f}\"`);\n    }\n  }\n\n  public getFilterName() {\n    if (this.biquadFilter == null) return null;\n    if (typeof this.biquadFilter === 'string') return this.biquadFilter;\n    return Object.entries(FilterType).find(\n      (r) => r[1] === this.biquadFilter\n    )?.[0] as BiquadFilters;\n  }\n\n  public update(options: BiquadFilterUpdateData) {\n    if ('cutoff' in options) this.cutoff = options.cutoff!;\n    if ('gain' in options) this.gain = options.gain!;\n    if ('Q' in options) this.Q = options.Q!;\n    if ('filter' in options) this.biquadFilter = options.filter!;\n\n    if (this.biquadFilter != null) {\n      this.biquad = new BiquadFilter(\n        Coefficients.from(\n          this.biquadFilter,\n          this.sampleRate,\n          this.cutoff,\n          this.Q,\n          this.gain\n        )\n      );\n    }\n\n    this.onUpdate?.();\n  }\n\n  public setFilter(filter: BiquadFilters) {\n    this.update({ filter });\n  }\n\n  public setQ(Q: number) {\n    this.update({ Q });\n  }\n\n  public setCutoff(f0: number) {\n    this.update({ cutoff: f0 });\n  }\n\n  public setGain(dB: number) {\n    this.update({ gain: dB });\n  }\n\n  public _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: TransformCallback)\n  {\n    if (this.disabled || !this.biquad) {\n      this.push(chunk);\n      return callback();\n    }\n\n    const endIndex = Math.floor(chunk.length / 2) * 2;\n    const { bytes } = this;\n\n    for (let sampleIndex = 0; sampleIndex < endIndex; sampleIndex += bytes) {\n      const int = this._readInt(chunk, sampleIndex);\n      const result = this.biquad.run(int);\n      this._writeInt(chunk, this.clamp(result), sampleIndex);\n    }\n\n    this.push(chunk);\n    return callback();\n  }\n}", "import { Equalizer } from './Equalizer';\n\nexport type ReadIntCallback = (buffer: Buffer, index: number) => number;\nexport type WriteIntCallback = (\nbuffer: Buffer,\nint: number,\nindex: number)\n=> number;\n\nexport class ChannelProcessor {\n  public history: number[];\n  public bandMultipliers: number[];\n  public current: number;\n  public m1: number;\n  public m2: number;\n\n  public constructor(bandMultipliers: number[]) {\n    this.history = new Array(Equalizer.BAND_COUNT * 6).fill(0);\n    this.bandMultipliers = bandMultipliers;\n    this.current = 0;\n    this.m1 = 2;\n    this.m2 = 1;\n  }\n\n  public processInt(int: number) {\n    let result = int * 0.25;\n\n    for (let bandIndex = 0; bandIndex < Equalizer.BAND_COUNT; bandIndex++) {\n      const x = bandIndex * 6;\n      const y = x + 3;\n\n      const coefficients = Equalizer.Coefficients48000[bandIndex];\n\n      const bandResult =\n      coefficients.alpha * (int - this.history[x + this.m2]) +\n      coefficients.gamma * this.history[y + this.m1] -\n      coefficients.beta * this.history[y + this.m2];\n\n      this.history[x + this.current] = int;\n      this.history[y + this.current] = bandResult;\n\n      result += bandResult * this.bandMultipliers[bandIndex];\n    }\n\n    const val = result * 4.0;\n\n    return val;\n  }\n\n  public process(\n  samples: Buffer,\n  extremum = 131072,\n  bytes = 2,\n  readInt?: ReadIntCallback,\n  writeInt?: WriteIntCallback)\n  {\n    const endIndex = Math.floor(samples.length / 2) * 2;\n    for (let sampleIndex = 0; sampleIndex < endIndex; sampleIndex += bytes) {\n      const sample =\n      readInt?.(samples, sampleIndex) ?? samples.readInt16LE(sampleIndex);\n      const result = this.processInt(sample);\n\n      const val = Math.min(extremum - 1, Math.max(-extremum, result));\n      writeInt?.(samples, val, sampleIndex) ??\n      samples.writeInt16LE(val, sampleIndex);\n\n      this.step();\n    }\n\n    return samples;\n  }\n\n  public step() {\n    if (++this.current === 3) {\n      this.current = 0;\n    }\n\n    if (++this.m1 === 3) {\n      this.m1 = 0;\n    }\n\n    if (++this.m2 === 3) {\n      this.m2 = 0;\n    }\n  }\n\n  public reset() {\n    this.history.fill(0.0);\n  }\n}", "export class EqualizerCoefficients {\n  public constructor(\n  public beta: number,\n  public alpha: number,\n  public gamma: number)\n  {}\n\n  public setBeta(v: number) {\n    this.beta = v;\n  }\n\n  public setAlpha(v: number) {\n    this.alpha = v;\n  }\n\n  public setGamma(v: number) {\n    this.gamma = v;\n  }\n\n  public toJSON() {\n    const { alpha, beta, gamma } = this;\n\n    return { alpha, beta, gamma };\n  }\n}", "export class EqualizerConfiguration {\n  public constructor(public bandMultipliers: number[]) {}\n\n  public setGain(band: number, value: number) {\n    if (this.isValidBand(band)) {\n      this.bandMultipliers[band] = Math.max(Math.min(value, 1.0), -0.25);\n    }\n  }\n\n  public getGain(band: number) {\n    if (this.isValidBand(band)) {\n      return this.bandMultipliers[band];\n    } else {\n      return 0.0;\n    }\n  }\n\n  public isValidBand(band: number) {\n    return band >= 0 && band < this.bandMultipliers.length;\n  }\n}", "import {\n  ChannelProcessor,\n  ReadIntCallback,\n  WriteIntCallback } from\n'./ChannelProcessor';\nimport { EqualizerCoefficients } from './Coefficients';\nimport { EqualizerConfiguration } from './EqualizerConfiguration';\n\nexport interface ChannelProcessorInput {\n  data: Buffer;\n  readInt?: ReadIntCallback;\n  writeInt?: WriteIntCallback;\n  extremum?: number;\n  bytes?: number;\n}\n\nexport class Equalizer extends EqualizerConfiguration {\n  public static BAND_COUNT = 15 as const;\n  public static SAMPLE_RATE = 48000 as const;\n  public static Coefficients48000 = [\n  new EqualizerCoefficients(9.9847546664e-1, 7.6226668143e-4, 1.9984647656),\n  new EqualizerCoefficients(9.9756184654e-1, 1.2190767289e-3, 1.9975344645),\n  new EqualizerCoefficients(9.9616261379e-1, 1.9186931041e-3, 1.9960947369),\n  new EqualizerCoefficients(9.9391578543e-1, 3.0421072865e-3, 1.9937449618),\n  new EqualizerCoefficients(9.9028307215e-1, 4.8584639242e-3, 1.9898465702),\n  new EqualizerCoefficients(9.8485897264e-1, 7.5705136795e-3, 1.9837962543),\n  new EqualizerCoefficients(9.7588512657e-1, 1.2057436715e-2, 1.9731772447),\n  new EqualizerCoefficients(9.6228521814e-1, 1.8857390928e-2, 1.9556164694),\n  new EqualizerCoefficients(9.4080933132e-1, 2.9595334338e-2, 1.9242054384),\n  new EqualizerCoefficients(9.0702059196e-1, 4.6489704022e-2, 1.8653476166),\n  new EqualizerCoefficients(8.5868004289e-1, 7.0659978553e-2, 1.7600401337),\n  new EqualizerCoefficients(7.8409610788e-1, 1.0795194606e-1, 1.5450725522),\n  new EqualizerCoefficients(6.8332861002e-1, 1.5833569499e-1, 1.1426447155),\n  new EqualizerCoefficients(\n    5.5267518228e-1,\n    2.2366240886e-1,\n    4.0186190803e-1\n  ),\n  new EqualizerCoefficients(\n    4.1811888447e-1,\n    2.9094055777e-1,\n    -7.0905944223e-1\n  )];\n\n  public channels: ChannelProcessor[] = [];\n  public channelCount: number;\n\n  public constructor(channelCount: number, bandMultipliers: number[]) {\n    super(bandMultipliers);\n    this.channelCount = channelCount;\n    this.channels = this.createChannelProcessor();\n  }\n\n  public createChannelProcessor() {\n    return Array.from({ length: this.channelCount }, () => {\n      return new ChannelProcessor(this.bandMultipliers);\n    });\n  }\n\n  public process(input: ChannelProcessorInput[]) {\n    return this.channels.map((c, i) => {\n      const { data, extremum, readInt, writeInt, bytes } = input[i];\n\n      return c.process(data, extremum, bytes, readInt, writeInt);\n    });\n  }\n}", "import { TransformCallback } from 'stream';\nimport { PCMTransformer, PCMTransformerOptions } from '../utils';\nimport { Equalizer } from './Equalizer';\n\nexport interface EqualizerStreamOptions extends PCMTransformerOptions {\n  bandMultiplier?: EqualizerBand[];\n  channels?: number;\n}\n\nexport interface EqualizerBand {\n  band: number;\n  gain: number;\n}\n\nexport class EqualizerStream extends PCMTransformer {\n  public bandMultipliers: number[] = new Array(Equalizer.BAND_COUNT).fill(0);\n  public equalizer: Equalizer;\n  public constructor(options?: EqualizerStreamOptions) {\n    super(options);\n\n    options = Object.assign(\n      {},\n      {\n        bandMultiplier: [],\n        channels: 1\n      },\n      options || {}\n    );\n\n    this.equalizer = new Equalizer(options.channels || 1, this.bandMultipliers);\n    if (Array.isArray(options.bandMultiplier))\n    this._processBands(options.bandMultiplier);\n  }\n\n  public _processBands(multiplier: EqualizerBand[]) {\n    for (const mul of multiplier) {\n      if (mul.band > Equalizer.BAND_COUNT - 1 || mul.band < 0)\n      throw new RangeError(\n        `Band value out of range. Expected >0 & <${\n        Equalizer.BAND_COUNT - 1}, received \"${\n        mul.band}\"`\n      );\n      this.equalizer.setGain(mul.band, mul.gain);\n    }\n\n    this.onUpdate?.();\n  }\n\n  public _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: TransformCallback)\n  : void {\n    if (this.disabled) {\n      this.push(chunk);\n      return callback();\n    }\n\n    this.equalizer.process([\n    {\n      data: chunk,\n      extremum: this.extremum,\n      readInt: (b, idx) => this._readInt(b, idx),\n      writeInt: (b, i, idx) => this._writeInt(b, i, idx),\n      bytes: this.bytes\n    }]\n    );\n\n    this.push(chunk);\n\n    return callback();\n  }\n\n  public getEQ() {\n    return this.bandMultipliers.map((m, i) => ({\n      band: i,\n      gain: m\n    })) as EqualizerBand[];\n  }\n\n  public setEQ(bands: EqualizerBand[]) {\n    this._processBands(bands);\n  }\n\n  public resetEQ() {\n    this._processBands(\n      Array.from(\n        {\n          length: Equalizer.BAND_COUNT\n        },\n        (_, i) => ({\n          band: i,\n          gain: 0\n        })\n      )\n    );\n  }\n}", "import { TransformCallback } from 'stream';\nimport { PCMTransformer, PCMTransformerOptions } from '../utils';\n\n/*\nMono: [0, 1, 2, 3, 4, 5]\nStereo: [0, 1, 0, 1, 2, 3, 2, 3, 4, 5, 4, 5]\n*/\n\nexport type MSTStrategy = 'm2s' | 's2m';\n\nexport interface MonoStereoTransformerOptions extends PCMTransformerOptions {\n  strategy: MSTStrategy;\n}\n\nexport class MonoStereoTransformer extends PCMTransformer {\n  public strategy: MSTStrategy;\n\n  public constructor(options?: MonoStereoTransformerOptions) {\n    super(options);\n    if (!['m2s', 's2m'].includes(options?.strategy as MSTStrategy)) {\n      throw new TypeError(`Strategy must be \"m2s\" or \"s2m\"`);\n    }\n\n    this.strategy = options!.strategy;\n  }\n\n  public setStrategy(strategy: MSTStrategy) {\n    this.strategy = strategy;\n  }\n\n  public _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: TransformCallback)\n  : void {\n    if (this.disabled) {\n      this.push(chunk);\n      return callback();\n    }\n\n    const len = Math.floor(chunk.length / 2) * 2;\n\n    if (this.strategy === 'm2s') {\n      this.push(this.toStereo(chunk, len));\n    } else {\n      this.push(this.toMono(chunk, len));\n    }\n\n    return callback();\n  }\n\n  public toStereo(sample: Buffer, len: number) {\n    const bytes = this.bytes;\n    const stereoBuffer = Buffer.alloc(len * 2);\n\n    for (let i = 0; i < len; i += bytes) {\n      stereoBuffer[i * 2 + 0] = sample[i];\n      stereoBuffer[i * 2 + 1] = sample[i + 1];\n      stereoBuffer[i * 2 + 2] = sample[i];\n      stereoBuffer[i * 2 + 3] = sample[i + 1];\n    }\n\n    return stereoBuffer;\n  }\n\n  public toMono(sample: Buffer, len: number) {\n    const bytes = this.bytes;\n    const monoBuffer = Buffer.alloc(Math.floor(len / 2));\n\n    for (let i = 0; i < len; i += bytes) {\n      monoBuffer[i] = sample[i * 2 + 0];\n      monoBuffer[i + 1] = sample[i * 2 + 1];\n    }\n\n    return monoBuffer;\n  }\n}", "export * from './biquad';\nexport * from './dsp';\nexport * from './equalizer';", "import { BiquadFilter, BiquadFilters, Coefficients } from '../../biquad';\n\nexport interface AFBiquadConfig {\n  biquad: BiquadFilter;\n  sample: number;\n  cutoff: number;\n  gain: number;\n  filter: BiquadFilters;\n  coefficient: Coefficients;\n  Q: number;\n}\n\nexport function applyBiquad(filterer: BiquadFilter, int: number) {\n  return filterer.run(int);\n}", "export interface AFPulsatorConfig {\n  hz: number;\n  x: number;\n  dI: number;\n}\n\nexport interface AFTremoloConfig {\n  phase: number;\n  depth: number;\n  frequency: number;\n}\n\nexport type AFVibratoConfig = AFTremoloConfig;\n\nexport type LR = 0 | 1;\n\nexport function applyPulsator(\nconfig: AFPulsatorConfig,\nint: number,\nchannel: LR)\n{\n  const sin = Math.sin(config.x);\n  const currentChannelVal = channel === 0 ? sin : -sin;\n  const res = int * (currentChannelVal + 1.0) / 2.0;\n\n  config.x += config.dI;\n\n  return res;\n}\n\nexport function applyTremolo(\nconfig: AFTremoloConfig,\nint: number,\nsampleRate: number)\n{\n  const fOffset = 1.0 - config.depth;\n  const modSignal = fOffset + config.depth * Math.sin(config.phase);\n  config.phase += 2 * Math.PI / sampleRate * config.frequency;\n  return modSignal * int;\n}\n\nexport function applyVibrato(\nconfig: AFVibratoConfig,\nint: number,\nsampleRate: number)\n{\n  const fOffset = 1.0 - config.depth;\n  const modSignal =\n  fOffset + config.depth * Math.sin(2 * Math.PI * config.phase);\n  config.phase += 2 * Math.PI / sampleRate * config.frequency;\n  return modSignal * int;\n}\n\nexport function applyVolume(vol: number, int: number) {\n  return vol * int;\n}", "import { Equalizer } from '../../equalizer';\n\nexport function applyEqualization(eq: Equalizer, int: number) {\n  const processor = eq.channels[0];\n  const result = processor.processInt(int);\n  processor.step();\n  return result;\n}", "import { TransformCallback } from 'stream';\nimport { PCMTransformer, PCMTransformerOptions } from '../utils';\nimport {\n  AFPulsatorConfig,\n  AFTremoloConfig,\n  AFVibratoConfig,\n  LR,\n  applyPulsator,\n  applyTremolo,\n  applyVibrato } from\n'./transformers';\nimport { EqualizerBand } from '../equalizer';\n\nexport const AudioFilters = {\n  '8D': '8D',\n  Tremolo: 'Tremolo',\n  Vibrato: 'Vibrato'\n} as const;\n\nexport type PCMFilters = keyof typeof AudioFilters;\n\nexport interface PCMFiltererOptions extends PCMTransformerOptions {\n  filters?: PCMFilters[];\n}\n\nexport const AF_NIGHTCORE_RATE = 1.3 as const;\nexport const AF_VAPORWAVE_RATE = 0.8 as const;\n\nexport const BASS_EQ_BANDS: EqualizerBand[] = Array.from(\n  { length: 3 },\n  (_, i) => ({\n    band: i,\n    gain: 0.25\n  })\n);\n\n// based on lavadsp\nexport class AudioFilter extends PCMTransformer {\n  public filters: PCMFilters[] = [];\n  public targetSampleRate = this.sampleRate;\n\n  public pulsatorConfig: AFPulsatorConfig = {\n    hz: 0.02,\n    x: 0,\n    dI: 0.000003926990816987241\n  };\n\n  public tremoloConfig: AFTremoloConfig = {\n    phase: 0,\n    depth: 0.5,\n    frequency: 5.0\n  };\n\n  public vibratoConfig: AFVibratoConfig = {\n    phase: 0,\n    depth: 0.5,\n    frequency: 5.0\n  };\n\n  public constructor(options?: PCMFiltererOptions) {\n    super(options);\n\n    if (options && Array.isArray(options.filters)) {\n      this.setFilters(options.filters);\n    }\n\n    this.onUpdate?.();\n  }\n\n  public setTargetSampleRate(rate: number) {\n    this.targetSampleRate = rate || this.sampleRate;\n    return;\n  }\n\n  public setPulsator(hz: number) {\n    hz /= 4; // match ffmpeg\n    this.pulsatorConfig.hz = hz;\n    const samplesPerCycle = this.targetSampleRate / (hz * 2 * Math.PI);\n    this.pulsatorConfig.dI = hz === 0 ? 0 : 1 / samplesPerCycle;\n\n    this.onUpdate?.();\n  }\n\n  public get pulsator() {\n    return this.pulsatorConfig.hz;\n  }\n\n  public setTremolo({\n    depth = this.tremoloConfig.depth,\n    frequency = this.tremoloConfig.frequency,\n    phase = this.tremoloConfig.phase\n  }: Partial<AFTremoloConfig>) {\n    if (typeof depth === 'number') this.tremoloConfig.depth = depth;\n    if (typeof frequency === 'number') this.tremoloConfig.frequency = frequency;\n    if (typeof phase === 'number') this.tremoloConfig.phase = phase;\n\n    this.onUpdate?.();\n  }\n\n  public setVibrato({\n    depth = this.vibratoConfig.depth,\n    frequency = this.vibratoConfig.frequency,\n    phase = this.vibratoConfig.phase\n  }: Partial<AFVibratoConfig>) {\n    if (typeof depth === 'number') this.vibratoConfig.depth = depth;\n    if (typeof frequency === 'number') this.vibratoConfig.frequency = frequency;\n    if (typeof phase === 'number') this.vibratoConfig.phase = phase;\n\n    this.onUpdate?.();\n  }\n\n  public get tremolo() {\n    return this.tremoloConfig;\n  }\n\n  public setFilters(filters: PCMFilters[]) {\n    if (!Array.isArray(filters) || !filters.every((r) => r in AudioFilters)) {\n      return false;\n    }\n\n    this.filters = filters;\n\n    this.onUpdate?.();\n\n    return true;\n  }\n\n  public _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: TransformCallback)\n  : void {\n    if (this.disabled || !this.filters.length) {\n      return callback(null, chunk);\n    }\n\n    const len = Math.floor(chunk.length / 2) * 2;\n    const { bytes } = this;\n\n    // left-right channel\n    let L = false;\n\n    for (let i = 0; i < len; i += bytes) {\n      const int = this._readInt(chunk, i);\n      const value = this.applyFilters(int, +(L = !L) as LR);\n      this._writeInt(chunk, this.clamp(value), i);\n    }\n\n    this.push(chunk);\n\n    return callback();\n  }\n\n  public get currentSampleRate() {\n    return this.targetSampleRate || this.sampleRate;\n  }\n\n  public applyFilters(byte: number, channel: LR) {\n    if (this.filters.length) {\n      for (const filter of this.filters) {\n        if (filter === '8D') {\n          byte = applyPulsator(this.pulsatorConfig, byte, channel);\n        }\n\n        if (filter === 'Tremolo') {\n          byte = applyTremolo(this.tremoloConfig, byte, this.currentSampleRate);\n        }\n\n        if (filter === 'Vibrato') {\n          byte = applyVibrato(this.vibratoConfig, byte, this.currentSampleRate);\n        }\n      }\n    }\n\n    return byte;\n  }\n}", "import { PCMTransformer, PCMTransformerOptions } from '../utils';\n\nexport interface PCMResamplerOptions extends PCMTransformerOptions {\n  inputSampleRate: number;\n  targetSampleRate: number;\n  channels?: number;\n}\n\nexport interface ResampleParameters {\n  currentFilter: CommonResamplerFilterPreset | null;\n  inputSampleRate: number;\n  channels: number;\n  sampleRate: number;\n}\n\nexport type CommonResamplerFilterPreset = 'nightcore' | 'vaporwave';\n\nexport class PCMResampler extends PCMTransformer {\n  private readonly inputSampleRate: number;\n  private readonly channels: number;\n  private buffer: Buffer;\n  public currentFilter: CommonResamplerFilterPreset | null = null;\n\n  public constructor(options?: PCMResamplerOptions) {\n    super(options);\n\n    this.inputSampleRate = options?.inputSampleRate ?? 48000;\n    this.channels = options?.channels ?? 2;\n    this.buffer = Buffer.alloc(0);\n\n    if (this.inputSampleRate < 1) {\n      this.inputSampleRate = 48000;\n    }\n\n    if (options?.targetSampleRate) {\n      this.setSampleRate(options?.targetSampleRate);\n    }\n  }\n\n  public setFilter(filter: CommonResamplerFilterPreset | null) {\n    if (this.currentFilter === filter) return;\n\n    switch (filter) {\n      case 'nightcore':\n        this.setSampleRate(this.inputSampleRate * 1.25);\n        break;\n      case 'vaporwave':\n        this.setSampleRate(this.inputSampleRate * 0.8);\n        break;\n      default:\n        this.setSampleRate(this.inputSampleRate);\n        break;\n    }\n\n    this.currentFilter = filter;\n  }\n\n  public getParameters(): ResampleParameters {\n    return {\n      currentFilter: this.currentFilter,\n      inputSampleRate: this.inputSampleRate,\n      channels: this.channels,\n      sampleRate: this.sampleRate\n    };\n  }\n\n  public toggleFilter(filter: CommonResamplerFilterPreset): boolean {\n    const same = this.currentFilter === filter;\n    this.setFilter(same ? null : filter);\n\n    return !same;\n  }\n\n  public getRatio(): number {\n    if (this.inputSampleRate === 0) return 1;\n\n    return this.sampleRate / this.inputSampleRate;\n  }\n\n  private resample(input: Buffer): Buffer {\n    const bytesPerFrame = this.bytes * this.channels;\n    const inputFrames = Math.floor(input.length / bytesPerFrame);\n    const outputFrames = Math.floor(\n      inputFrames * this.inputSampleRate / this.sampleRate\n    );\n    const output = Buffer.alloc(outputFrames * bytesPerFrame);\n\n    for (let outFrame = 0; outFrame < outputFrames; outFrame++) {\n      const inPos = outFrame * this.sampleRate / this.inputSampleRate;\n      const inFrame = Math.floor(inPos);\n\n      if (\n      inFrame >= inputFrames - 1 ||\n      (inFrame + 1) * bytesPerFrame + (this.channels - 1) * this.bytes >\n      input.length)\n      {\n        break;\n      }\n\n      const fraction = inPos - inFrame;\n\n      for (let channel = 0; channel < this.channels; channel++) {\n        const pos1 = inFrame * bytesPerFrame + channel * this.bytes;\n        const pos2 = (inFrame + 1) * bytesPerFrame + channel * this.bytes;\n\n        if (\n        pos1 + this.bytes > input.length ||\n        pos2 + this.bytes > input.length)\n        {\n          continue;\n        }\n\n        const sample1 = this._readInt(input, pos1);\n        const sample2 = this._readInt(input, pos2);\n\n        const interpolated = sample1 + fraction * (sample2 - sample1);\n        const clamped = this.clamp(Math.round(interpolated));\n\n        const outPos = outFrame * bytesPerFrame + channel * this.bytes;\n        this._writeInt(output, clamped, outPos);\n      }\n    }\n\n    return output;\n  }\n\n  public override _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: (error?: Error | null, data?: Buffer) => void)\n  : void {\n    if (this.disabled || this.sampleRate === this.inputSampleRate) {\n      this.push(chunk);\n      callback();\n      return;\n    }\n\n    this.buffer = Buffer.concat([this.buffer, chunk]);\n\n    const bytesPerFrame = this.bytes * this.channels;\n    const minFramesNeeded = Math.ceil(\n      bytesPerFrame * (this.inputSampleRate / this.sampleRate)\n    );\n    const completeFrames = Math.floor(this.buffer.length / bytesPerFrame) - 1;\n\n    if (completeFrames >= minFramesNeeded) {\n      const processSize = completeFrames * bytesPerFrame;\n      const toProcess = this.buffer.slice(0, processSize);\n      this.buffer = this.buffer.slice(processSize);\n\n      const resampled = this.resample(toProcess);\n      this.push(resampled);\n    }\n\n    callback();\n  }\n\n  public override _flush(\n  callback: (error?: Error | null, data?: Buffer) => void)\n  : void {\n    if (this.disabled) {\n      callback();\n      return;\n    }\n\n    if (this.buffer.length > 0) {\n      const resampled = this.resample(this.buffer);\n      this.push(resampled);\n    }\n    callback();\n  }\n\n  public override setSampleRate(rate: number): void {\n    if (rate === this.sampleRate) return;\n\n    if (rate < 1) {\n      throw new RangeError('Sample rate must be greater than 0');\n    }\n\n    super.setSampleRate(rate);\n    this.onUpdate();\n  }\n}", "import { TransformCallback } from 'stream';\nimport { PCMTransformer, PCMTransformerOptions } from '../utils';\n\nexport interface VolumeTransformerOptions extends PCMTransformerOptions {\n  volume?: number;\n}\n\nexport class VolumeTransformer extends PCMTransformer {\n  private _volume = 1;\n  public constructor(options?: VolumeTransformerOptions) {\n    super(options);\n\n    if (typeof options?.volume === 'number') {\n      this.setVolume(options.volume);\n    }\n  }\n\n  public get volumeApprox() {\n    return this._volume * 100;\n  }\n\n  public get volume() {\n    return Math.floor(this.volumeApprox);\n  }\n\n  public set volume(volume: number) {\n    this.setVolume(volume);\n  }\n\n  public setVolume(volume: number) {\n    if (typeof volume !== 'number' || isNaN(volume))\n    throw new Error(\n      `Expected volume amount to be a number, received ${typeof volume}!`\n    );\n    if (volume < 0) volume = 0;\n    if (!isFinite(volume)) volume = 100;\n\n    this._volume = volume / 100;\n\n    this.onUpdate?.();\n\n    return true;\n  }\n\n  public _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: TransformCallback)\n  : void {\n    if (this.disabled || this._volume === 1) {\n      this.push(chunk);\n      return callback();\n    }\n\n    const len = Math.floor(chunk.length / 2) * 2;\n    const { bytes } = this;\n\n    for (let i = 0; i < len; i += bytes) {\n      const int = this._readInt(chunk, i);\n      const amp = this.clamp(int * this._volume);\n      this._writeInt(chunk, amp, i);\n    }\n\n    this.push(chunk);\n\n    return callback();\n  }\n\n  public toString() {\n    return `${this.volume}%`;\n  }\n}", "import { PCMTransformer, PCMTransformerOptions } from '../utils/PCMTransformer';\n\nexport interface CompressorOptions extends PCMTransformerOptions {\n  threshold?: number;\n  ratio?: number;\n  attack?: number;\n  release?: number;\n  makeupGain?: number;\n  kneeWidth?: number;\n}\n\nexport interface CompressorParameters {\n  threshold: number;\n  ratio: number;\n  attack: number;\n  release: number;\n  makeupGain: number;\n  kneeWidth: number;\n}\n\nexport class CompressorTransformer extends PCMTransformer {\n  private threshold: number;\n  private ratio: number;\n  private attack: number;\n  private release: number;\n  private makeupGain: number;\n  private kneeWidth: number;\n  private envelope: number = 0;\n  private gainReduction: number = 1;\n  private previousGainReduction: number = 1;\n\n  constructor(options: CompressorOptions = {}) {\n    super(options);\n\n    this.threshold = options.threshold ?? -20;\n    this.ratio = options.ratio ?? 4;\n    this.attack = options.attack ?? 20;\n    this.release = options.release ?? 100;\n    this.makeupGain = options.makeupGain ?? 0;\n    this.kneeWidth = options.kneeWidth ?? 6;\n    this.attack = Math.exp(-1 / (this.sampleRate * this.attack / 1000));\n    this.release = Math.exp(-1 / (this.sampleRate * this.release / 1000));\n  }\n\n  private linearToDb(linear: number): number {\n    const val = 20 * Math.log10(Math.max(linear, 1e-6));\n    return val;\n  }\n\n  private dbToLinear(db: number): number {\n    const val = Math.pow(10, db / 20);\n    return val;\n  }\n\n  public setThreshold(db: number) {\n    this.threshold = Math.max(-100, Math.min(0, db));\n    this.onUpdate();\n  }\n\n  public setRatio(ratio: number) {\n    this.ratio = Math.max(1, ratio);\n    this.onUpdate();\n  }\n\n  public setAttack(ms: number) {\n    this.attack = Math.exp(-1 / (this.sampleRate * Math.max(0.1, ms) / 1000));\n    this.onUpdate();\n  }\n\n  public setRelease(ms: number) {\n    this.release = Math.exp(\n      -1 / (this.sampleRate * Math.max(0.1, ms) / 1000)\n    );\n    this.onUpdate();\n  }\n\n  public setMakeupGain(db: number) {\n    this.makeupGain = Math.max(-20, Math.min(20, db));\n    this.onUpdate();\n  }\n\n  public setKneeWidth(db: number) {\n    this.kneeWidth = Math.max(0, Math.min(20, db));\n    this.onUpdate();\n  }\n\n  public setCompressor(options: Partial<CompressorParameters>) {\n    if (typeof options.threshold === 'number') {\n      this.setThreshold(options.threshold);\n    }\n\n    if (typeof options.ratio === 'number') {\n      this.setRatio(options.ratio);\n    }\n\n    if (typeof options.attack === 'number') {\n      this.setAttack(options.attack);\n    }\n\n    if (typeof options.release === 'number') {\n      this.setRelease(options.release);\n    }\n\n    if (typeof options.makeupGain === 'number') {\n      this.setMakeupGain(options.makeupGain);\n    }\n\n    if (typeof options.kneeWidth === 'number') {\n      this.setKneeWidth(options.kneeWidth);\n    }\n\n    this.onUpdate();\n\n    return this.getParameters();\n  }\n\n  public getParameters(): CompressorParameters {\n    return {\n      threshold: this.threshold,\n      ratio: this.ratio,\n      attack: this.attack,\n      release: this.release,\n      makeupGain: this.makeupGain,\n      kneeWidth: this.kneeWidth\n    };\n  }\n\n  private computeGainReduction(inputLevel: number): number {\n    const inputDb = this.linearToDb(inputLevel);\n\n    let gainReductionDb = 0;\n\n    if (2 * (inputDb - this.threshold) < -this.kneeWidth) {\n      gainReductionDb = 0;\n    } else if (2 * Math.abs(inputDb - this.threshold) <= this.kneeWidth) {\n      const x = inputDb - this.threshold + this.kneeWidth / 2;\n      gainReductionDb =\n      (1 / this.ratio - 1) * Math.pow(x, 2) / (2 * this.kneeWidth);\n    } else {\n      gainReductionDb = (inputDb - this.threshold) * (1 - 1 / this.ratio);\n    }\n\n    return this.dbToLinear(-gainReductionDb + this.makeupGain);\n  }\n\n  private processSample(input: number): number {\n    if (this.disabled) return input;\n\n    const inputFloat = input / this.extremum;\n\n    const inputLevel = Math.abs(inputFloat);\n    const coeff = inputLevel > this.envelope ? this.attack : this.release;\n    this.envelope = coeff * this.envelope + (1 - coeff) * inputLevel;\n\n    const targetGainReduction = this.computeGainReduction(this.envelope);\n\n    this.gainReduction = Math.min(\n      this.previousGainReduction * this.attack +\n      targetGainReduction * (1 - this.attack),\n      targetGainReduction\n    );\n    this.previousGainReduction = this.gainReduction;\n\n    const outputFloat = inputFloat * this.gainReduction;\n\n    return this.clamp(Math.floor(outputFloat * this.extremum));\n  }\n\n  public override _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: (error?: Error | null, data?: Buffer) => void)\n  : void {\n    if (this.disabled) {\n      callback(null, chunk);\n      return;\n    }\n\n    const output = Buffer.alloc(chunk.length);\n\n    for (let i = 0; i < chunk.length; i += this.bytes) {\n      const sample = this._readInt(chunk, i);\n      const processed = this.processSample(sample);\n      this._writeInt(output, processed, i);\n    }\n\n    callback(null, output);\n  }\n}", "import { PCMTransformer, PCMTransformerOptions } from '../utils';\nimport { EventEmitter } from 'events';\n\nexport interface PCMSeekerOptions extends PCMTransformerOptions {\n  totalDuration: number;\n  channels: number;\n  seekTarget?: number | null;\n}\n\nexport interface SeekerParameters {\n  currentPosition: number;\n  seekTarget: number | null;\n  totalDuration: number;\n}\n\nexport interface SeekEvent {\n  position: number;\n  sample: number;\n  bytePosition: number;\n}\n\nexport class PCMSeekerTransformer extends PCMTransformer {\n  private totalDuration: number;\n  private readonly channels: number;\n  private bytesPerFrame!: number;\n  private currentPosition = 0;\n  private seekTarget: number | null = null;\n  private buffer: Buffer = Buffer.alloc(0);\n  public readonly events = new EventEmitter();\n\n  public constructor(\n  options: PCMSeekerOptions = {\n    channels: 2,\n    totalDuration: 0\n  })\n  {\n    super(options);\n\n    if (options.totalDuration == null || options.totalDuration < 0) {\n      throw new Error('totalDuration must be a positive number');\n    }\n\n    if (!options.channels || options.channels <= 0) {\n      throw new Error('channels must be a positive number');\n    }\n\n    this.totalDuration = options.totalDuration;\n    this.channels = options.channels;\n\n    if (typeof options.seekTarget === 'number' && options.seekTarget > 0) {\n      this.seekTarget = options.seekTarget;\n    }\n\n    this.updateDependentValues();\n  }\n\n  public getParameters(): SeekerParameters {\n    return {\n      currentPosition: this.currentPosition,\n      seekTarget: this.seekTarget,\n      totalDuration: this.totalDuration\n    };\n  }\n\n  private updateDependentValues(): void {\n    this.bytesPerFrame = this.bytes * this.channels;\n\n    if (this.currentPosition > 0) {\n      const currentMs = this.currentPosition / (this.sampleRate / 1000);\n      this.currentPosition = Math.floor(currentMs / 1000 * this.sampleRate);\n    }\n\n    if (this.seekTarget !== null) {\n      const seekMs = this.seekTarget / (this.sampleRate / 1000);\n      this.seekTarget = Math.floor(seekMs / 1000 * this.sampleRate);\n    }\n  }\n\n  /**\n   * Calculate byte position from sample position\n   * @param samplePosition Position in samples\n   * @returns Position in bytes\n   */\n  private sampleToBytePosition(samplePosition: number): number {\n    return samplePosition * this.bytesPerFrame;\n  }\n\n  public setTotalDuration(duration: number): void {\n    if (duration <= 0) {\n      throw new Error('totalDuration must be a positive number');\n    }\n\n    this.totalDuration = duration;\n    this.updateDependentValues();\n    this.onUpdate();\n  }\n\n  public override setSampleRate(rate: number): void {\n    super.setSampleRate(rate);\n    this.updateDependentValues();\n    this.onUpdate();\n  }\n\n  /**\n   * Seek to a specific position in milliseconds\n   * @param ms Position in milliseconds (negative values seek from end)\n   * @returns Actual position in milliseconds after seeking\n   */\n  public seek(ms: number): number {\n    if (this.totalDuration === 0) return 0;\n\n    if (ms < 0) {\n      ms = Math.max(0, this.totalDuration + ms);\n    }\n\n    ms = Math.max(0, Math.min(this.totalDuration, ms));\n    const targetSample = Math.floor(ms / 1000 * this.sampleRate);\n\n    if (targetSample < this.currentPosition) {\n      this.buffer = Buffer.alloc(0);\n\n      const bytePosition = this.sampleToBytePosition(targetSample);\n\n      this.events.emit('seek', {\n        position: ms,\n        sample: targetSample,\n        bytePosition: bytePosition\n      } as SeekEvent);\n    }\n\n    this.seekTarget = targetSample;\n    return targetSample / this.sampleRate * 1000;\n  }\n\n  public getPosition(): number {\n    return this.currentPosition / this.sampleRate * 1000;\n  }\n\n  private handleSeek(chunk: Buffer): Buffer {\n    if (this.seekTarget === null) return chunk;\n\n    const chunkStartSample = this.currentPosition;\n    const chunkSamples = Math.floor(chunk.length / this.bytesPerFrame);\n    const chunkEndSample = chunkStartSample + chunkSamples;\n\n    if (this.seekTarget >= chunkEndSample) {\n      this.currentPosition += chunkSamples;\n      return Buffer.alloc(0);\n    }\n\n    if (this.seekTarget >= chunkStartSample) {\n      const offsetSamples = this.seekTarget - chunkStartSample;\n      const offsetBytes = offsetSamples * this.bytesPerFrame;\n      this.currentPosition = this.seekTarget;\n      this.seekTarget = null;\n      return chunk.subarray(offsetBytes);\n    }\n\n    this.currentPosition = this.seekTarget;\n    this.seekTarget = null;\n    return chunk;\n  }\n\n  public override _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: (error?: Error | null, data?: Buffer) => void)\n  : void {\n    try {\n      if (this.disabled || this.totalDuration === 0) {\n        callback(null, chunk);\n        return;\n      }\n\n      const combinedBuffer = Buffer.concat([this.buffer, chunk]);\n      const frameCount = Math.floor(combinedBuffer.length / this.bytesPerFrame);\n      const processableBytes = frameCount * this.bytesPerFrame;\n\n      this.buffer = combinedBuffer.subarray(processableBytes);\n\n      let processBuffer = combinedBuffer.subarray(0, processableBytes);\n\n      if (this.seekTarget !== null) {\n        processBuffer = this.handleSeek(processBuffer);\n      } else {\n        this.currentPosition += frameCount;\n      }\n\n      callback(null, processBuffer);\n    } catch (error) {\n      callback(error as Error);\n    }\n  }\n\n  public override _flush(\n  callback: (error?: Error | null, data?: Buffer) => void)\n  : void {\n    if (this.buffer.length >= this.bytesPerFrame) {\n      const frameCount = Math.floor(this.buffer.length / this.bytesPerFrame);\n      const processableBytes = frameCount * this.bytesPerFrame;\n      callback(null, this.buffer.subarray(0, processableBytes));\n    }\n\n    callback();\n  }\n}", "import { PCMTransformer, PCMTransformerOptions } from '../utils';\n\nexport interface ReverbOptions extends PCMTransformerOptions {\n  roomSize?: number;\n  damping?: number;\n  wetLevel?: number;\n  dryLevel?: number;\n}\n\nexport interface ReverbParameters {\n  roomSize: number;\n  damping: number;\n  wetLevel: number;\n  dryLevel: number;\n}\n\nexport class ReverbTransformer extends PCMTransformer {\n  private roomSize: number;\n  private damping: number;\n  private wetLevel: number;\n  private dryLevel: number;\n\n  private readonly delayLines: Float32Array[];\n  private readonly delayLineLength: number;\n  private delayIndices: number[];\n  private readonly numDelayLines = 8;\n  private readonly feedback: number = 0.84;\n\n  constructor(options: ReverbOptions = {}) {\n    super(options);\n\n    this.roomSize = options.roomSize ?? 0.5;\n    this.damping = options.damping ?? 0.5;\n    this.wetLevel = options.wetLevel ?? 0.3;\n    this.dryLevel = options.dryLevel ?? 0.7;\n\n    this.delayLineLength = Math.floor(this.sampleRate * 0.05);\n    this.delayLines = Array.from(\n      { length: this.numDelayLines },\n      () => new Float32Array(this.delayLineLength)\n    );\n    this.delayIndices = Array(this.numDelayLines).fill(0);\n  }\n\n  public setRoomSize(size: number) {\n    this.roomSize = Math.max(0, Math.min(1, size));\n    this.onUpdate();\n  }\n\n  public setDamping(damping: number) {\n    this.damping = Math.max(0, Math.min(1, damping));\n    this.onUpdate();\n  }\n\n  public setWetLevel(level: number) {\n    this.wetLevel = Math.max(0, Math.min(1, level));\n    this.onUpdate();\n  }\n\n  public setDryLevel(level: number) {\n    this.dryLevel = Math.max(0, Math.min(1, level));\n    this.onUpdate();\n  }\n\n  public setReverb(options: Partial<ReverbParameters>) {\n    if (typeof options.roomSize === 'number') {\n      this.setRoomSize(options.roomSize);\n    }\n\n    if (typeof options.damping === 'number') {\n      this.setDamping(options.damping);\n    }\n\n    if (typeof options.wetLevel === 'number') {\n      this.setWetLevel(options.wetLevel);\n    }\n\n    if (typeof options.dryLevel === 'number') {\n      this.setDryLevel(options.dryLevel);\n    }\n\n    this.onUpdate();\n\n    return this.getParameters();\n  }\n\n  public getParameters(): ReverbParameters {\n    return {\n      roomSize: this.roomSize,\n      damping: this.damping,\n      wetLevel: this.wetLevel,\n      dryLevel: this.dryLevel\n    };\n  }\n\n  private processSample(input: number): number {\n    if (this.disabled) return input;\n\n    const inputFloat = input / this.extremum;\n    let wet = 0;\n\n    for (let i = 0; i < this.numDelayLines; i++) {\n      const delayLine = this.delayLines[i];\n      const delayIndex = this.delayIndices[i];\n\n      const delayed = delayLine[delayIndex];\n\n      const processed = delayed * this.roomSize * (1 - this.damping);\n\n      delayLine[delayIndex] = inputFloat + processed * this.feedback;\n\n      this.delayIndices[i] = (delayIndex + 1) % this.delayLineLength;\n\n      wet += processed;\n    }\n\n    const output =\n    inputFloat * this.dryLevel + wet * this.wetLevel / this.numDelayLines;\n\n    return this.clamp(Math.floor(output * this.extremum));\n  }\n\n  public override _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: (error?: Error | null, data?: Buffer) => void)\n  : void {\n    if (this.disabled) {\n      callback(null, chunk);\n      return;\n    }\n\n    const output = Buffer.alloc(chunk.length);\n\n    for (let i = 0; i < chunk.length; i += this.bytes) {\n      const sample = this._readInt(chunk, i);\n      const processed = this.processSample(sample);\n      this._writeInt(output, processed, i);\n    }\n\n    callback(null, output);\n  }\n}", "import { type Readable, pipeline } from 'stream';\nimport { EqualizerStream, EqualizerStreamOptions } from './equalizer';\nimport {\n  AudioFilter,\n  CompressorOptions,\n  CompressorTransformer,\n  PCMFiltererOptions,\n  PCMResampler,\n  PCMResamplerOptions,\n  PCMSeekerOptions,\n  PCMSeekerTransformer,\n  ReverbOptions,\n  ReverbTransformer } from\n'./audio';\nimport { BiquadStream, BiquadStreamOptions } from './biquad';\nimport {\n  VolumeTransformer,\n  VolumeTransformerOptions } from\n'./audio/VolumeTransformer';\n\nexport interface DSPFiltersPreset {\n  equalizer?: EqualizerStreamOptions;\n  dsp?: PCMFiltererOptions;\n  biquad?: BiquadStreamOptions;\n  volume?: VolumeTransformerOptions;\n  resampler?: PCMResamplerOptions;\n  compressor?: CompressorOptions;\n  seeker?: PCMSeekerOptions;\n  reverb?: ReverbOptions;\n}\n\nexport class FiltersChain {\n  public equalizer: EqualizerStream | null = null;\n  public filters: AudioFilter | null = null;\n  public biquad: BiquadStream | null = null;\n  public volume: VolumeTransformer | null = null;\n  public resampler: PCMResampler | null = null;\n  public compressor: CompressorTransformer | null = null;\n  public seeker: PCMSeekerTransformer | null = null;\n  public reverb: ReverbTransformer | null = null;\n  public destination: Readable | null = null;\n  public source: Readable | null = null;\n  public onUpdate: () => unknown = () => null;\n  public onError: (err: Error) => unknown = () => null;\n\n  public constructor(public presets: DSPFiltersPreset = {}) {}\n\n  public create(src: Readable, presets: DSPFiltersPreset = this.presets) {\n    this.destroy();\n\n    this.source = src;\n\n    const resampler = !presets.resampler?.disabled ?\n    new PCMResampler(presets.resampler) :\n    null;\n\n    const equalizerStream = !presets.equalizer?.disabled ?\n    new EqualizerStream(presets.equalizer) :\n    null;\n\n    const dspStream = !presets.dsp?.disabled ?\n    new AudioFilter(presets.dsp) :\n    null;\n\n    const biquadStream = !presets.biquad?.disabled ?\n    new BiquadStream(presets.biquad) :\n    null;\n\n    const volumeTransformer = !presets.volume?.disabled ?\n    new VolumeTransformer(presets.volume) :\n    null;\n\n    const compressor = !presets.compressor?.disabled ?\n    new CompressorTransformer(presets.compressor) :\n    null;\n\n    const seeker = !presets.seeker?.disabled ?\n    new PCMSeekerTransformer(presets.seeker) :\n    null;\n\n    const reverb = !presets.reverb?.disabled ?\n    new ReverbTransformer(presets.reverb) :\n    null;\n\n    this.resampler = resampler;\n    this.equalizer = equalizerStream;\n    this.filters = dspStream;\n    this.biquad = biquadStream;\n    this.volume = volumeTransformer;\n    this.compressor = compressor;\n    this.seeker = seeker;\n    this.reverb = reverb;\n\n    // update listeners\n    if (resampler) resampler.onUpdate = this.onUpdate;\n    if (equalizerStream) equalizerStream.onUpdate = this.onUpdate;\n    if (dspStream) dspStream.onUpdate = this.onUpdate;\n    if (biquadStream) biquadStream.onUpdate = this.onUpdate;\n    if (volumeTransformer) volumeTransformer.onUpdate = this.onUpdate;\n    if (compressor) compressor.onUpdate = this.onUpdate;\n    if (seeker) seeker.onUpdate = this.onUpdate;\n    if (reverb) reverb.onUpdate = this.onUpdate;\n\n    const chains = [\n    src,\n    resampler,\n    equalizerStream,\n    reverb,\n    dspStream,\n    biquadStream,\n    compressor,\n    volumeTransformer,\n    seeker].\n    filter(Boolean) as Readonly<Readable[]>;\n\n    if (!chains.length) return src;\n\n    // @ts-ignore\n    this.destination = pipeline(...chains, (err: Error | null) => {\n      if (err) {\n        this.destroy();\n        if (!err.message.includes('ERR_STREAM_PREMATURE_CLOSE'))\n        this.onError(err);\n      }\n    });\n\n    this.destination!.once('close', this.destroy.bind(this));\n\n    return this.destination as Readable;\n  }\n\n  public destroy() {\n    // cleanup\n    this.resampler?.destroy();\n    this.equalizer?.destroy();\n    this.biquad?.destroy();\n    this.filters?.destroy();\n    this.volume?.destroy();\n    this.compressor?.destroy();\n    this.seeker?.destroy();\n    this.reverb?.destroy();\n    this.destination?.destroy();\n    this.source?.destroy();\n\n    // remove events\n    this.resampler?.removeAllListeners();\n    this.equalizer?.removeAllListeners();\n    this.biquad?.removeAllListeners();\n    this.filters?.removeAllListeners();\n    this.volume?.removeAllListeners();\n    this.compressor?.removeAllListeners();\n    this.seeker?.removeAllListeners();\n    this.reverb?.removeAllListeners();\n    this.destination?.removeAllListeners();\n    this.source?.removeAllListeners();\n\n    // unref\n    this.resampler = null;\n    this.equalizer = null;\n    this.biquad = null;\n    this.filters = null;\n    this.volume = null;\n    this.compressor = null;\n    this.seeker = null;\n    this.reverb = null;\n    this.destination = null;\n    this.source = null;\n  }\n}", "\n\n\n\n\n\nexport const version = /* @__MACRO__ getVersion */\"7.2.0\";"],
  "mappings": ";;;;;;;;;;AAAO,IAAM,aAAa;AAAA,EACxB,yBAAyB;AAAA,EACzB,mBAAmB;AAAA,EACnB,SAAS;AAAA,EACT,UAAU;AAAA,EACV,UAAU;AAAA,EACV,OAAO;AAAA,EACP,SAAS;AAAA,EACT,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AACb;AAcO,IAAM,gBAAgB,KAAK;AAE3B,IAAM,gBAAN,MAAM,cAAa;AAAA,EAUjB,YAAY,MAAyB;AAR5C;AAAA,wBAAO,MAAK;AACZ,wBAAO,MAAK;AAGZ;AAAA,wBAAO,MAAK;AACZ,wBAAO,MAAK;AACZ,wBAAO,MAAK;AAGV,QAAI,MAAM;AACR,WAAK,KAAK,KAAK;AACf,WAAK,KAAK,KAAK;AACf,WAAK,KAAK,KAAK;AACf,WAAK,KAAK,KAAK;AACf,WAAK,KAAK,KAAK;AAAA,IACjB;AAAA,EACF;AAAA,EAEA,OAAc,KACd,QACA,cACA,YACA,GACA,SAAS,KACT;AACE,QAAI,IAAM,aAAa,cAAc;AACnC,YAAM,IAAI,MAAM,8BAA8B;AAAA,IAChD;AAEA,QAAI,IAAI,GAAG;AACT,YAAM,IAAI,MAAM,uBAAuB;AAAA,IACzC;AAEA,UAAM,QAAQ,IAAM,KAAK,KAAK,aAAa;AAE3C,UAAM,MAAM,OAAO,WAAW,WAAW,WAAW,MAAM,IAAI;AAE9D,YAAQ,KAAK;AAAA,MACX,KAAK,WAAW,yBAAwB;AACpC,cAAM,QAAQ,SAAS,QAAQ;AAE/B,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,QAAQ;AAAA,UACZ,IAAI;AAAA,UACJ,IAAI;AAAA,UACJ,IAAI;AAAA,UACJ,IAAI;AAAA,QACN,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,mBAAkB;AAC9B,cAAM,UAAU,KAAK,IAAI,QAAQ,CAAG;AACpC,cAAM,KAAK,IAAM;AAEjB,eAAO,IAAI,cAAa;AAAA,UACtB,KAAK,UAAU,KAAO;AAAA,UACtB,IAAI;AAAA,UACJ,IAAI,UAAU;AAAA,UACd,IAAI,UAAU;AAAA,UACd,IAAI;AAAA,QACN,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,SAAQ;AACpB,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,QAAQ,WAAW,IAAM;AAE/B,cAAM,MAAM,IAAM,WAAW;AAC7B,cAAM,KAAK,IAAM;AACjB,cAAM,MAAM,IAAM,WAAW;AAC7B,cAAM,KAAK,IAAM;AACjB,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK,IAAM;AAEjB,cAAM,MAAM,IAAM;AAElB,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,QACX,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,UAAS;AACrB,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,QAAQ,WAAW,IAAM;AAE/B,cAAM,MAAM,IAAM,WAAW;AAC7B,cAAM,KAAK,EAAE,IAAM;AACnB,cAAM,MAAM,IAAM,WAAW;AAC7B,cAAM,KAAK,IAAM;AACjB,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK,IAAM;AAEjB,cAAM,MAAM,IAAM;AAElB,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,QACX,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,OAAM;AAClB,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,QAAQ,WAAW,IAAM;AAE/B,cAAM,KAAK;AACX,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK;AACX,cAAM,KAAK,IAAM;AACjB,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK,IAAM;AAEjB,cAAM,MAAM,IAAM;AAElB,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,QACX,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,UAAS;AACrB,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,QAAQ,WAAW,IAAM;AAE/B,cAAM,KAAK,UAAU;AACrB,cAAM,KAAK;AACX,cAAM,KAAK,EAAE,UAAU;AACvB,cAAM,KAAK,IAAM;AACjB,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK,IAAM;AAEjB,cAAM,MAAM,IAAM;AAElB,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,QACX,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,SAAQ;AACpB,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,QAAQ,WAAW,IAAM;AAE/B,cAAM,KAAK,IAAM;AACjB,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK,IAAM;AACjB,cAAM,KAAK,IAAM;AACjB,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK,IAAM;AAEjB,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,QACX,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,UAAS;AACrB,cAAM,IAAI,KAAK,IAAI,IAAM,SAAS,EAAI;AACtC,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,QAAQ,WAAW,IAAM;AAE/B,cAAM,KACN,KAAK,IAAI,KAAO,IAAI,KAAO,UAAU,IAAM,QAAQ,KAAK,KAAK,CAAC;AAC9D,cAAM,KAAK,IAAM,KAAK,IAAI,KAAO,IAAI,KAAO;AAC5C,cAAM,KACN,KAAK,IAAI,KAAO,IAAI,KAAO,UAAU,IAAM,QAAQ,KAAK,KAAK,CAAC;AAC9D,cAAM,KAAK,IAAI,KAAO,IAAI,KAAO,UAAU,IAAM,QAAQ,KAAK,KAAK,CAAC;AACpE,cAAM,KAAK,MAAQ,IAAI,KAAO,IAAI,KAAO;AACzC,cAAM,KAAK,IAAI,KAAO,IAAI,KAAO,UAAU,IAAM,QAAQ,KAAK,KAAK,CAAC;AAEpE,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,QACX,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,WAAU;AACtB,cAAM,IAAI,KAAK,IAAI,IAAM,SAAS,EAAI;AACtC,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,QAAQ,WAAW,IAAM;AAE/B,cAAM,KACN,KAAK,IAAI,KAAO,IAAI,KAAO,UAAU,IAAM,QAAQ,KAAK,KAAK,CAAC;AAC9D,cAAM,KAAK,KAAO,KAAK,IAAI,KAAO,IAAI,KAAO;AAC7C,cAAM,KACN,KAAK,IAAI,KAAO,IAAI,KAAO,UAAU,IAAM,QAAQ,KAAK,KAAK,CAAC;AAC9D,cAAM,KAAK,IAAI,KAAO,IAAI,KAAO,UAAU,IAAM,QAAQ,KAAK,KAAK,CAAC;AACpE,cAAM,KAAK,KAAO,IAAI,KAAO,IAAI,KAAO;AACxC,cAAM,KAAK,IAAI,KAAO,IAAI,KAAO,UAAU,IAAM,QAAQ,KAAK,KAAK,CAAC;AAEpE,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,QACX,CAAC;AAAA,MACH;AAAA,MACF,KAAK,WAAW,WAAU;AACtB,cAAM,IAAI,KAAK,IAAI,IAAM,SAAS,EAAI;AACtC,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,UAAU,KAAK,IAAI,KAAK;AAC9B,cAAM,QAAQ,WAAW,IAAM;AAE/B,cAAM,KAAK,IAAM,QAAQ;AACzB,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK,IAAM,QAAQ;AACzB,cAAM,KAAK,IAAM,QAAQ;AACzB,cAAM,KAAK,KAAO;AAClB,cAAM,KAAK,IAAM,QAAQ;AAEzB,eAAO,IAAI,cAAa;AAAA,UACtB,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,UACT,IAAI,KAAK;AAAA,QACX,CAAC;AAAA,MACH;AAAA,MACF;AACE,cAAM,IAAI,UAAU,wBAAwB,MAAM,GAAG;AAAA,IACzD;AAAA,EACF;AACF;AAlP0B;AAAnB,IAAM,eAAN;;;AClBA,IAAM,gBAAN,MAAM,cAAa;AAAA,EAQjB,YAAmB,cAA4B;AAA5B;AAP1B,wBAAO,MAAK;AACZ,wBAAO,MAAK;AACZ,wBAAO,MAAK;AACZ,wBAAO,MAAK;AACZ,wBAAO,MAAK;AACZ,wBAAO,MAAK;AAAA,EAE2C;AAAA,EAEhD,UAAU,QAAuB,SAA+B;AACrE,UAAM,eAAe,aAAa;AAAA,MAChC;AAAA,MACA,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,QAAQ;AAAA,IACV;AAEA,SAAK,OAAO,YAAY;AAAA,EAC1B;AAAA,EAEO,OAAO,cAA4B;AACxC,SAAK,eAAe;AAAA,EACtB;AAAA,EAEO,QAAQ,cAA4B;AACzC,SAAK,eAAe;AAAA,EACtB;AAAA,EAEO,QAAQ;AACb,SAAK,KAAK;AACV,SAAK,KAAK;AACV,SAAK,KAAK;AACV,SAAK,KAAK;AACV,SAAK,KAAK;AACV,SAAK,KAAK;AAAA,EACZ;AAAA,EAEO,IAAI,OAAe;AACxB,UAAM,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,KAAK;AAEpC,UAAM,MACN,KAAK,QAAQ,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK;AAEpE,SAAK,KAAK,KAAK;AACf,SAAK,KAAK;AACV,SAAK,KAAK,KAAK;AACf,SAAK,KAAK;AAEV,WAAO;AAAA,EACT;AAAA,EAEO,cAAc,OAAe;AAClC,UAAM,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,KAAK;AAEpC,UAAM,MAAM,KAAK,KAAK,KAAK;AAE3B,SAAK,KAAK,KAAK,KAAK,KAAK,QAAQ,KAAK;AACtC,SAAK,KAAK,KAAK,QAAQ,KAAK;AAE5B,WAAO;AAAA,EACT;AACF;AA/D0B;AAAnB,IAAM,eAAN;;;ACTA,IAAM,aAAN,MAAM,WAAU;AAAA,EACd,YAAoB,OAAe;AAAf;AACzB,QAAI,OAAO,UAAU,YAAY,MAAM,KAAK,KAAK,UAAU;AAC3D,YAAM,IAAI,UAAU,kCAAkC;AACtD,QAAI,KAAK,QAAQ;AACjB,YAAM,IAAI,MAAM,uCAAuC,KAAK,GAAG;AAAA,EACjE;AAAA,EAEO,MAAM;AACX,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEO,MAAM;AACX,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEO,KAAK;AACV,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,KAAK;AACV,WAAO,IAAM,KAAK;AAAA,EACpB;AAAA,EAEO,UAAU;AACf,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,WAAW;AAChB,WAAO,GAAG,KAAK,KAAK;AAAA,EACtB;AAAA,EAEO,SAAS;AACd,WAAO,KAAK,SAAS;AAAA,EACvB;AACF;AAnCuB;AAAhB,IAAM,YAAN;;;ACAP,SAAS,iBAAmC;AAUrC,IAAM,kBAAN,MAAM,wBAAuB,UAAU;AAAA,EAWrC,YAAY,UAAiC,CAAC,GAAG;AACtD,UAAM,OAAO;AAXf,wBAAgB,QAAgB;AAChC,wBAAO;AACP,wBAAO;AACP,wBAAO;AACP,wBAAO,YAAW;AAClB,wBAAO,cAAa;AACpB,wBAAO,YAAW,6BAAY;AAAA,IAElB,GAFM;AAOhB,YAAQ,SAAR,QAAQ,OAAS;AACjB,SAAK,WAAW,CAAC,CAAC,QAAQ;AAC1B,QAAI,OAAO,QAAQ,eAAe,YAAY,QAAQ,aAAa,GAAG;AACpE,WAAK,aAAa,QAAQ;AAAA,IAC5B;AAEA,YAAQ,QAAQ,MAAM;AAAA,MACpB,KAAK;AAAA,MACL,KAAK;AACH,aAAK,OAAO,QAAQ;AACpB,aAAK,OAAO;AACZ;AAAA,MACF,KAAK;AAAA,MACL,KAAK;AACH,aAAK,OAAO,QAAQ;AACpB,aAAK,OAAO;AACZ;AAAA,MACF;AACE,cAAM,IAAI;AAAA,UACR,8BACA,CAAC,SAAS,SAAS,SAAS,OAAO,EACnC,KAAK,IAAI,CAAC,UAAU,QAAQ,IAAI;AAAA,QAClC;AAAA,IACJ;AAEA,SAAK,QAAQ,KAAK,OAAO;AACzB,SAAK,WAAW,KAAK,IAAI,GAAG,KAAK,OAAO,CAAC;AAAA,EAC3C;AAAA,EAEO,UAAU;AACf,SAAK,WAAW;AAAA,EAClB;AAAA,EAEO,SAAS;AACd,SAAK,WAAW;AAAA,EAClB;AAAA,EAEO,SAAS;AACd,SAAK,WAAW,CAAC,KAAK;AAEtB,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,SAAS,QAAgB,OAAe;AAC7C,UAAM,SAAS,UAAU,KAAK,KAC9B,UAAU,CAAC,EACX,YAAY,CAAC;AACb,WAAO,OAAO,MAAM,EAAE,KAAK;AAAA,EAC7B;AAAA,EAEO,UAAU,QAAgB,KAAa,OAAe;AAC3D,UAAM,SAAS,WAAW,KAAK,KAC/B,UAAU,CAAC,EACX,YAAY,CAAC;AACb,WAAO,OAAO,MAAM,EAAE,KAAK,KAAK;AAAA,EAClC;AAAA,EAEO,MAAM,KAAa,MAAM,KAAK,WAAW,GAAG,MAAM,CAAC,KAAK,UAAU;AACvE,WAAO,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,GAAG,CAAC;AAAA,EACzC;AAAA,EAEO,cAAc,MAAc;AACjC,SAAK,aAAa;AAClB;AAAA,EACF;AACF;AA/E8C;AAAvC,IAAM,iBAAN;;;ACcA,IAAM,gBAAN,MAAM,sBAAqB,eAAe;AAAA,EAMxC,YAAY,UAA+B,CAAC,GAAG;AACpD,UAAM,OAAO;AANf,wBAAO;AACP,wBAAO,UAAS;AAChB,wBAAO,QAAO;AACd,wBAAO;AACP,wBAAO,KAAI;AAIT,QAAI,YAAY,QAAS,MAAK,SAAS,QAAQ;AAC/C,QAAI,UAAU,QAAS,MAAK,OAAO,QAAQ;AAC3C,QAAI,OAAO,QAAS,MAAK,IAAI,QAAQ;AACrC,QAAI,kBAAkB,SAAS;AAC7B,UACA,OAAO,QAAQ,iBAAiB,YAChC,OAAO,QAAQ,iBAAiB;AAEhC,aAAK,eAAe,QAAQ;AAC5B,UAAI,KAAK,gBAAgB,MAAM;AAC7B,aAAK,SAAS,IAAI;AAAA,UAChB,aAAa;AAAA,YACX,KAAK;AAAA,YACL,KAAK;AAAA,YACL,KAAK;AAAA,YACL,KAAK;AAAA,YACL,KAAK;AAAA,UACP;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,IAAW,UAAU;AACnB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAW,QAAQ,GAAkB;AACnC,QAAI,KAAK,QAAQ,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;AAC/D,WAAK,OAAO,EAAE,QAAQ,EAAE,CAAC;AAAA,IAC3B,OAAO;AACL,YAAM,IAAI,UAAU,+BAA+B,CAAC,GAAG;AAAA,IACzD;AAAA,EACF;AAAA,EAEO,gBAAgB;AACrB,QAAI,KAAK,gBAAgB,KAAM,QAAO;AACtC,QAAI,OAAO,KAAK,iBAAiB,SAAU,QAAO,KAAK;AACvD,WAAO,OAAO,QAAQ,UAAU,EAAE;AAAA,MAChC,CAAC,MAAM,EAAE,CAAC,MAAM,KAAK;AAAA,IACvB,IAAI,CAAC;AAAA,EACP;AAAA,EAEO,OAAO,SAAiC;AAC7C,QAAI,YAAY,QAAS,MAAK,SAAS,QAAQ;AAC/C,QAAI,UAAU,QAAS,MAAK,OAAO,QAAQ;AAC3C,QAAI,OAAO,QAAS,MAAK,IAAI,QAAQ;AACrC,QAAI,YAAY,QAAS,MAAK,eAAe,QAAQ;AAErD,QAAI,KAAK,gBAAgB,MAAM;AAC7B,WAAK,SAAS,IAAI;AAAA,QAChB,aAAa;AAAA,UACX,KAAK;AAAA,UACL,KAAK;AAAA,UACL,KAAK;AAAA,UACL,KAAK;AAAA,UACL,KAAK;AAAA,QACP;AAAA,MACF;AAAA,IACF;AAEA,SAAK,WAAW;AAAA,EAClB;AAAA,EAEO,UAAU,QAAuB;AACtC,SAAK,OAAO,EAAE,OAAO,CAAC;AAAA,EACxB;AAAA,EAEO,KAAK,GAAW;AACrB,SAAK,OAAO,EAAE,EAAE,CAAC;AAAA,EACnB;AAAA,EAEO,UAAU,IAAY;AAC3B,SAAK,OAAO,EAAE,QAAQ,GAAG,CAAC;AAAA,EAC5B;AAAA,EAEO,QAAQ,IAAY;AACzB,SAAK,OAAO,EAAE,MAAM,GAAG,CAAC;AAAA,EAC1B;AAAA,EAEO,WACP,OACA,UACA,UACA;AACE,QAAI,KAAK,YAAY,CAAC,KAAK,QAAQ;AACjC,WAAK,KAAK,KAAK;AACf,aAAO,SAAS;AAAA,IAClB;AAEA,UAAM,WAAW,KAAK,MAAM,MAAM,SAAS,CAAC,IAAI;AAChD,UAAM,EAAE,MAAM,IAAI;AAElB,aAAS,cAAc,GAAG,cAAc,UAAU,eAAe,OAAO;AACtE,YAAM,MAAM,KAAK,SAAS,OAAO,WAAW;AAC5C,YAAM,SAAS,KAAK,OAAO,IAAI,GAAG;AAClC,WAAK,UAAU,OAAO,KAAK,MAAM,MAAM,GAAG,WAAW;AAAA,IACvD;AAEA,SAAK,KAAK,KAAK;AACf,WAAO,SAAS;AAAA,EAClB;AACF;AA/GiD;AAA1C,IAAM,eAAN;;;ACfA,IAAM,oBAAN,MAAM,kBAAiB;AAAA,EAOrB,YAAY,iBAA2B;AAN9C,wBAAO;AACP,wBAAO;AACP,wBAAO;AACP,wBAAO;AACP,wBAAO;AAGL,SAAK,UAAU,IAAI,MAAM,UAAU,aAAa,CAAC,EAAE,KAAK,CAAC;AACzD,SAAK,kBAAkB;AACvB,SAAK,UAAU;AACf,SAAK,KAAK;AACV,SAAK,KAAK;AAAA,EACZ;AAAA,EAEO,WAAW,KAAa;AAC7B,QAAI,SAAS,MAAM;AAEnB,aAAS,YAAY,GAAG,YAAY,UAAU,YAAY,aAAa;AACrE,YAAM,IAAI,YAAY;AACtB,YAAM,IAAI,IAAI;AAEd,YAAM,eAAe,UAAU,kBAAkB,SAAS;AAE1D,YAAM,aACN,aAAa,SAAS,MAAM,KAAK,QAAQ,IAAI,KAAK,EAAE,KACpD,aAAa,QAAQ,KAAK,QAAQ,IAAI,KAAK,EAAE,IAC7C,aAAa,OAAO,KAAK,QAAQ,IAAI,KAAK,EAAE;AAE5C,WAAK,QAAQ,IAAI,KAAK,OAAO,IAAI;AACjC,WAAK,QAAQ,IAAI,KAAK,OAAO,IAAI;AAEjC,gBAAU,aAAa,KAAK,gBAAgB,SAAS;AAAA,IACvD;AAEA,UAAM,MAAM,SAAS;AAErB,WAAO;AAAA,EACT;AAAA,EAEO,QACP,SACA,WAAW,QACX,QAAQ,GACR,SACA,UACA;AACE,UAAM,WAAW,KAAK,MAAM,QAAQ,SAAS,CAAC,IAAI;AAClD,aAAS,cAAc,GAAG,cAAc,UAAU,eAAe,OAAO;AACtE,YAAM,SACN,UAAU,SAAS,WAAW,KAAK,QAAQ,YAAY,WAAW;AAClE,YAAM,SAAS,KAAK,WAAW,MAAM;AAErC,YAAM,MAAM,KAAK,IAAI,WAAW,GAAG,KAAK,IAAI,CAAC,UAAU,MAAM,CAAC;AAC9D,iBAAW,SAAS,KAAK,WAAW,KACpC,QAAQ,aAAa,KAAK,WAAW;AAErC,WAAK,KAAK;AAAA,IACZ;AAEA,WAAO;AAAA,EACT;AAAA,EAEO,OAAO;AACZ,QAAI,EAAE,KAAK,YAAY,GAAG;AACxB,WAAK,UAAU;AAAA,IACjB;AAEA,QAAI,EAAE,KAAK,OAAO,GAAG;AACnB,WAAK,KAAK;AAAA,IACZ;AAEA,QAAI,EAAE,KAAK,OAAO,GAAG;AACnB,WAAK,KAAK;AAAA,IACZ;AAAA,EACF;AAAA,EAEO,QAAQ;AACb,SAAK,QAAQ,KAAK,CAAG;AAAA,EACvB;AACF;AAhF8B;AAAvB,IAAM,mBAAN;;;ACTA,IAAM,yBAAN,MAAM,uBAAsB;AAAA,EAC1B,YACA,MACA,OACA,OACP;AAHO;AACA;AACA;AAAA,EACN;AAAA,EAEM,QAAQ,GAAW;AACxB,SAAK,OAAO;AAAA,EACd;AAAA,EAEO,SAAS,GAAW;AACzB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEO,SAAS,GAAW;AACzB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEO,SAAS;AACd,UAAM,EAAE,OAAO,MAAM,MAAM,IAAI;AAE/B,WAAO,EAAE,OAAO,MAAM,MAAM;AAAA,EAC9B;AACF;AAxBmC;AAA5B,IAAM,wBAAN;;;ACAA,IAAM,0BAAN,MAAM,wBAAuB;AAAA,EAC3B,YAAmB,iBAA2B;AAA3B;AAAA,EAA4B;AAAA,EAE/C,QAAQ,MAAc,OAAe;AAC1C,QAAI,KAAK,YAAY,IAAI,GAAG;AAC1B,WAAK,gBAAgB,IAAI,IAAI,KAAK,IAAI,KAAK,IAAI,OAAO,CAAG,GAAG,KAAK;AAAA,IACnE;AAAA,EACF;AAAA,EAEO,QAAQ,MAAc;AAC3B,QAAI,KAAK,YAAY,IAAI,GAAG;AAC1B,aAAO,KAAK,gBAAgB,IAAI;AAAA,IAClC,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AAAA,EAEO,YAAY,MAAc;AAC/B,WAAO,QAAQ,KAAK,OAAO,KAAK,gBAAgB;AAAA,EAClD;AACF;AApBoC;AAA7B,IAAM,yBAAN;;;ACgBA,IAAM,aAAN,MAAM,mBAAkB,uBAAuB;AAAA,EA+B7C,YAAY,cAAsB,iBAA2B;AAClE,UAAM,eAAe;AAJvB,wBAAO,YAA+B,CAAC;AACvC,wBAAO;AAIL,SAAK,eAAe;AACpB,SAAK,WAAW,KAAK,uBAAuB;AAAA,EAC9C;AAAA,EAEO,yBAAyB;AAC9B,WAAO,MAAM,KAAK,EAAE,QAAQ,KAAK,aAAa,GAAG,MAAM;AACrD,aAAO,IAAI,iBAAiB,KAAK,eAAe;AAAA,IAClD,CAAC;AAAA,EACH;AAAA,EAEO,QAAQ,OAAgC;AAC7C,WAAO,KAAK,SAAS,IAAI,CAAC,GAAG,MAAM;AACjC,YAAM,EAAE,MAAM,UAAU,SAAS,UAAU,MAAM,IAAI,MAAM,CAAC;AAE5D,aAAO,EAAE,QAAQ,MAAM,UAAU,OAAO,SAAS,QAAQ;AAAA,IAC3D,CAAC;AAAA,EACH;AACF;AAlDsD;AACpD,cADW,YACG,cAAa;AAC3B,cAFW,YAEG,eAAc;AAC5B,cAHW,YAGG,qBAAoB;AAAA,EAClC,IAAI,sBAAsB,eAAiB,iBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,iBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,iBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,iBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,iBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,iBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,gBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,gBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,gBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,gBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,gBAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,eAAiB,YAAY;AAAA,EACxE,IAAI,sBAAsB,eAAiB,eAAiB,YAAY;AAAA,EACxE,IAAI;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA,IAAI;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAC;AA1BI,IAAM,YAAN;;;ACFA,IAAM,mBAAN,MAAM,yBAAwB,eAAe;AAAA,EAG3C,YAAY,SAAkC;AACnD,UAAM,OAAO;AAHf,wBAAO,mBAA4B,IAAI,MAAM,UAAU,UAAU,EAAE,KAAK,CAAC;AACzE,wBAAO;AAIL,cAAU,OAAO;AAAA,MACf,CAAC;AAAA,MACD;AAAA,QACE,gBAAgB,CAAC;AAAA,QACjB,UAAU;AAAA,MACZ;AAAA,MACA,WAAW,CAAC;AAAA,IACd;AAEA,SAAK,YAAY,IAAI,UAAU,QAAQ,YAAY,GAAG,KAAK,eAAe;AAC1E,QAAI,MAAM,QAAQ,QAAQ,cAAc;AACxC,WAAK,cAAc,QAAQ,cAAc;AAAA,EAC3C;AAAA,EAEO,cAAc,YAA6B;AAChD,eAAW,OAAO,YAAY;AAC5B,UAAI,IAAI,OAAO,UAAU,aAAa,KAAK,IAAI,OAAO;AACtD,cAAM,IAAI;AAAA,UACR,2CACA,UAAU,aAAa,CAAC,eACxB,IAAI,IAAI;AAAA,QACV;AACA,WAAK,UAAU,QAAQ,IAAI,MAAM,IAAI,IAAI;AAAA,IAC3C;AAEA,SAAK,WAAW;AAAA,EAClB;AAAA,EAEO,WACP,OACA,UACA,UACO;AACL,QAAI,KAAK,UAAU;AACjB,WAAK,KAAK,KAAK;AACf,aAAO,SAAS;AAAA,IAClB;AAEA,SAAK,UAAU;AAAA,MAAQ;AAAA,QACvB;AAAA,UACE,MAAM;AAAA,UACN,UAAU,KAAK;AAAA,UACf,SAAS,wBAAC,GAAG,QAAQ,KAAK,SAAS,GAAG,GAAG,GAAhC;AAAA,UACT,UAAU,wBAAC,GAAG,GAAG,QAAQ,KAAK,UAAU,GAAG,GAAG,GAAG,GAAvC;AAAA,UACV,OAAO,KAAK;AAAA,QACd;AAAA,MAAC;AAAA,IACD;AAEA,SAAK,KAAK,KAAK;AAEf,WAAO,SAAS;AAAA,EAClB;AAAA,EAEO,QAAQ;AACb,WAAO,KAAK,gBAAgB,IAAI,CAAC,GAAG,OAAO;AAAA,MACzC,MAAM;AAAA,MACN,MAAM;AAAA,IACR,EAAE;AAAA,EACJ;AAAA,EAEO,MAAM,OAAwB;AACnC,SAAK,cAAc,KAAK;AAAA,EAC1B;AAAA,EAEO,UAAU;AACf,SAAK;AAAA,MACH,MAAM;AAAA,QACJ;AAAA,UACE,QAAQ,UAAU;AAAA,QACpB;AAAA,QACA,CAAC,GAAG,OAAO;AAAA,UACT,MAAM;AAAA,UACN,MAAM;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAnFoD;AAA7C,IAAM,kBAAN;;;ACAA,IAAM,yBAAN,MAAM,+BAA8B,eAAe;AAAA,EAGjD,YAAY,SAAwC;AACzD,UAAM,OAAO;AAHf,wBAAO;AAIL,QAAI,CAAC,CAAC,OAAO,KAAK,EAAE,SAAS,SAAS,QAAuB,GAAG;AAC9D,YAAM,IAAI,UAAU,iCAAiC;AAAA,IACvD;AAEA,SAAK,WAAW,QAAS;AAAA,EAC3B;AAAA,EAEO,YAAY,UAAuB;AACxC,SAAK,WAAW;AAAA,EAClB;AAAA,EAEO,WACP,OACA,UACA,UACO;AACL,QAAI,KAAK,UAAU;AACjB,WAAK,KAAK,KAAK;AACf,aAAO,SAAS;AAAA,IAClB;AAEA,UAAM,MAAM,KAAK,MAAM,MAAM,SAAS,CAAC,IAAI;AAE3C,QAAI,KAAK,aAAa,OAAO;AAC3B,WAAK,KAAK,KAAK,SAAS,OAAO,GAAG,CAAC;AAAA,IACrC,OAAO;AACL,WAAK,KAAK,KAAK,OAAO,OAAO,GAAG,CAAC;AAAA,IACnC;AAEA,WAAO,SAAS;AAAA,EAClB;AAAA,EAEO,SAAS,QAAgB,KAAa;AAC3C,UAAM,QAAQ,KAAK;AACnB,UAAM,eAAe,OAAO,MAAM,MAAM,CAAC;AAEzC,aAAS,IAAI,GAAG,IAAI,KAAK,KAAK,OAAO;AACnC,mBAAa,IAAI,IAAI,CAAC,IAAI,OAAO,CAAC;AAClC,mBAAa,IAAI,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC;AACtC,mBAAa,IAAI,IAAI,CAAC,IAAI,OAAO,CAAC;AAClC,mBAAa,IAAI,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC;AAAA,IACxC;AAEA,WAAO;AAAA,EACT;AAAA,EAEO,OAAO,QAAgB,KAAa;AACzC,UAAM,QAAQ,KAAK;AACnB,UAAM,aAAa,OAAO,MAAM,KAAK,MAAM,MAAM,CAAC,CAAC;AAEnD,aAAS,IAAI,GAAG,IAAI,KAAK,KAAK,OAAO;AACnC,iBAAW,CAAC,IAAI,OAAO,IAAI,IAAI,CAAC;AAChC,iBAAW,IAAI,CAAC,IAAI,OAAO,IAAI,IAAI,CAAC;AAAA,IACtC;AAEA,WAAO;AAAA,EACT;AACF;AA9D0D;AAAnD,IAAM,wBAAN;;;ACdP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACYO,SAAS,YAAY,UAAwB,KAAa;AAC/D,SAAO,SAAS,IAAI,GAAG;AACzB;AAFgB;;;ACIT,SAAS,cAChB,QACA,KACA,SACA;AACE,QAAM,MAAM,KAAK,IAAI,OAAO,CAAC;AAC7B,QAAM,oBAAoB,YAAY,IAAI,MAAM,CAAC;AACjD,QAAM,MAAM,OAAO,oBAAoB,KAAO;AAE9C,SAAO,KAAK,OAAO;AAEnB,SAAO;AACT;AAZgB;AAcT,SAAS,aAChB,QACA,KACA,YACA;AACE,QAAM,UAAU,IAAM,OAAO;AAC7B,QAAM,YAAY,UAAU,OAAO,QAAQ,KAAK,IAAI,OAAO,KAAK;AAChE,SAAO,SAAS,IAAI,KAAK,KAAK,aAAa,OAAO;AAClD,SAAO,YAAY;AACrB;AATgB;AAWT,SAAS,aAChB,QACA,KACA,YACA;AACE,QAAM,UAAU,IAAM,OAAO;AAC7B,QAAM,YACN,UAAU,OAAO,QAAQ,KAAK,IAAI,IAAI,KAAK,KAAK,OAAO,KAAK;AAC5D,SAAO,SAAS,IAAI,KAAK,KAAK,aAAa,OAAO;AAClD,SAAO,YAAY;AACrB;AAVgB;AAYT,SAAS,YAAY,KAAa,KAAa;AACpD,SAAO,MAAM;AACf;AAFgB;;;ACnDT,SAAS,kBAAkB,IAAe,KAAa;AAC5D,QAAM,YAAY,GAAG,SAAS,CAAC;AAC/B,QAAM,SAAS,UAAU,WAAW,GAAG;AACvC,YAAU,KAAK;AACf,SAAO;AACT;AALgB;;;ACWT,IAAM,eAAe;AAAA,EAC1B,MAAM;AAAA,EACN,SAAS;AAAA,EACT,SAAS;AACX;AAQO,IAAM,oBAAoB;AAC1B,IAAM,oBAAoB;AAE1B,IAAM,gBAAiC,MAAM;AAAA,EAClD,EAAE,QAAQ,EAAE;AAAA,EACZ,CAAC,GAAG,OAAO;AAAA,IACT,MAAM;AAAA,IACN,MAAM;AAAA,EACR;AACF;AAGO,IAAM,eAAN,MAAM,qBAAoB,eAAe;AAAA,EAsBvC,YAAY,SAA8B;AAC/C,UAAM,OAAO;AAtBf,wBAAO,WAAwB,CAAC;AAChC,wBAAO,oBAAmB,KAAK;AAE/B,wBAAO,kBAAmC;AAAA,MACxC,IAAI;AAAA,MACJ,GAAG;AAAA,MACH,IAAI;AAAA,IACN;AAEA,wBAAO,iBAAiC;AAAA,MACtC,OAAO;AAAA,MACP,OAAO;AAAA,MACP,WAAW;AAAA,IACb;AAEA,wBAAO,iBAAiC;AAAA,MACtC,OAAO;AAAA,MACP,OAAO;AAAA,MACP,WAAW;AAAA,IACb;AAKE,QAAI,WAAW,MAAM,QAAQ,QAAQ,OAAO,GAAG;AAC7C,WAAK,WAAW,QAAQ,OAAO;AAAA,IACjC;AAEA,SAAK,WAAW;AAAA,EAClB;AAAA,EAEO,oBAAoB,MAAc;AACvC,SAAK,mBAAmB,QAAQ,KAAK;AACrC;AAAA,EACF;AAAA,EAEO,YAAY,IAAY;AAC7B,UAAM;AACN,SAAK,eAAe,KAAK;AACzB,UAAM,kBAAkB,KAAK,oBAAoB,KAAK,IAAI,KAAK;AAC/D,SAAK,eAAe,KAAK,OAAO,IAAI,IAAI,IAAI;AAE5C,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,IAAW,WAAW;AACpB,WAAO,KAAK,eAAe;AAAA,EAC7B;AAAA,EAEO,WAAW;AAAA,IAChB,QAAQ,KAAK,cAAc;AAAA,IAC3B,YAAY,KAAK,cAAc;AAAA,IAC/B,QAAQ,KAAK,cAAc;AAAA,EAC7B,GAA6B;AAC3B,QAAI,OAAO,UAAU,SAAU,MAAK,cAAc,QAAQ;AAC1D,QAAI,OAAO,cAAc,SAAU,MAAK,cAAc,YAAY;AAClE,QAAI,OAAO,UAAU,SAAU,MAAK,cAAc,QAAQ;AAE1D,SAAK,WAAW;AAAA,EAClB;AAAA,EAEO,WAAW;AAAA,IAChB,QAAQ,KAAK,cAAc;AAAA,IAC3B,YAAY,KAAK,cAAc;AAAA,IAC/B,QAAQ,KAAK,cAAc;AAAA,EAC7B,GAA6B;AAC3B,QAAI,OAAO,UAAU,SAAU,MAAK,cAAc,QAAQ;AAC1D,QAAI,OAAO,cAAc,SAAU,MAAK,cAAc,YAAY;AAClE,QAAI,OAAO,UAAU,SAAU,MAAK,cAAc,QAAQ;AAE1D,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,IAAW,UAAU;AACnB,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,WAAW,SAAuB;AACvC,QAAI,CAAC,MAAM,QAAQ,OAAO,KAAK,CAAC,QAAQ,MAAM,CAAC,MAAM,KAAK,YAAY,GAAG;AACvE,aAAO;AAAA,IACT;AAEA,SAAK,UAAU;AAEf,SAAK,WAAW;AAEhB,WAAO;AAAA,EACT;AAAA,EAEO,WACP,OACA,UACA,UACO;AACL,QAAI,KAAK,YAAY,CAAC,KAAK,QAAQ,QAAQ;AACzC,aAAO,SAAS,MAAM,KAAK;AAAA,IAC7B;AAEA,UAAM,MAAM,KAAK,MAAM,MAAM,SAAS,CAAC,IAAI;AAC3C,UAAM,EAAE,MAAM,IAAI;AAGlB,QAAI,IAAI;AAER,aAAS,IAAI,GAAG,IAAI,KAAK,KAAK,OAAO;AACnC,YAAM,MAAM,KAAK,SAAS,OAAO,CAAC;AAClC,YAAM,QAAQ,KAAK,aAAa,KAAK,EAAE,IAAI,CAAC,EAAQ;AACpD,WAAK,UAAU,OAAO,KAAK,MAAM,KAAK,GAAG,CAAC;AAAA,IAC5C;AAEA,SAAK,KAAK,KAAK;AAEf,WAAO,SAAS;AAAA,EAClB;AAAA,EAEA,IAAW,oBAAoB;AAC7B,WAAO,KAAK,oBAAoB,KAAK;AAAA,EACvC;AAAA,EAEO,aAAa,MAAc,SAAa;AAC7C,QAAI,KAAK,QAAQ,QAAQ;AACvB,iBAAW,UAAU,KAAK,SAAS;AACjC,YAAI,WAAW,MAAM;AACnB,iBAAO,cAAc,KAAK,gBAAgB,MAAM,OAAO;AAAA,QACzD;AAEA,YAAI,WAAW,WAAW;AACxB,iBAAO,aAAa,KAAK,eAAe,MAAM,KAAK,iBAAiB;AAAA,QACtE;AAEA,YAAI,WAAW,WAAW;AACxB,iBAAO,aAAa,KAAK,eAAe,MAAM,KAAK,iBAAiB;AAAA,QACtE;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;AA3IgD;AAAzC,IAAM,cAAN;;;ACpBA,IAAM,gBAAN,MAAM,sBAAqB,eAAe;AAAA,EAMxC,YAAY,SAA+B;AAChD,UAAM,OAAO;AANf,wBAAiB;AACjB,wBAAiB;AACjB,wBAAQ;AACR,wBAAO,iBAAoD;AAKzD,SAAK,kBAAkB,SAAS,mBAAmB;AACnD,SAAK,WAAW,SAAS,YAAY;AACrC,SAAK,SAAS,OAAO,MAAM,CAAC;AAE5B,QAAI,KAAK,kBAAkB,GAAG;AAC5B,WAAK,kBAAkB;AAAA,IACzB;AAEA,QAAI,SAAS,kBAAkB;AAC7B,WAAK,cAAc,SAAS,gBAAgB;AAAA,IAC9C;AAAA,EACF;AAAA,EAEO,UAAU,QAA4C;AAC3D,QAAI,KAAK,kBAAkB,OAAQ;AAEnC,YAAQ,QAAQ;AAAA,MACd,KAAK;AACH,aAAK,cAAc,KAAK,kBAAkB,IAAI;AAC9C;AAAA,MACF,KAAK;AACH,aAAK,cAAc,KAAK,kBAAkB,GAAG;AAC7C;AAAA,MACF;AACE,aAAK,cAAc,KAAK,eAAe;AACvC;AAAA,IACJ;AAEA,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEO,gBAAoC;AACzC,WAAO;AAAA,MACL,eAAe,KAAK;AAAA,MACpB,iBAAiB,KAAK;AAAA,MACtB,UAAU,KAAK;AAAA,MACf,YAAY,KAAK;AAAA,IACnB;AAAA,EACF;AAAA,EAEO,aAAa,QAA8C;AAChE,UAAM,OAAO,KAAK,kBAAkB;AACpC,SAAK,UAAU,OAAO,OAAO,MAAM;AAEnC,WAAO,CAAC;AAAA,EACV;AAAA,EAEO,WAAmB;AACxB,QAAI,KAAK,oBAAoB,EAAG,QAAO;AAEvC,WAAO,KAAK,aAAa,KAAK;AAAA,EAChC;AAAA,EAEQ,SAAS,OAAuB;AACtC,UAAM,gBAAgB,KAAK,QAAQ,KAAK;AACxC,UAAM,cAAc,KAAK,MAAM,MAAM,SAAS,aAAa;AAC3D,UAAM,eAAe,KAAK;AAAA,MACxB,cAAc,KAAK,kBAAkB,KAAK;AAAA,IAC5C;AACA,UAAM,SAAS,OAAO,MAAM,eAAe,aAAa;AAExD,aAAS,WAAW,GAAG,WAAW,cAAc,YAAY;AAC1D,YAAM,QAAQ,WAAW,KAAK,aAAa,KAAK;AAChD,YAAM,UAAU,KAAK,MAAM,KAAK;AAEhC,UACA,WAAW,cAAc,MACxB,UAAU,KAAK,iBAAiB,KAAK,WAAW,KAAK,KAAK,QAC3D,MAAM,QACN;AACE;AAAA,MACF;AAEA,YAAM,WAAW,QAAQ;AAEzB,eAAS,UAAU,GAAG,UAAU,KAAK,UAAU,WAAW;AACxD,cAAM,OAAO,UAAU,gBAAgB,UAAU,KAAK;AACtD,cAAM,QAAQ,UAAU,KAAK,gBAAgB,UAAU,KAAK;AAE5D,YACA,OAAO,KAAK,QAAQ,MAAM,UAC1B,OAAO,KAAK,QAAQ,MAAM,QAC1B;AACE;AAAA,QACF;AAEA,cAAM,UAAU,KAAK,SAAS,OAAO,IAAI;AACzC,cAAM,UAAU,KAAK,SAAS,OAAO,IAAI;AAEzC,cAAM,eAAe,UAAU,YAAY,UAAU;AACrD,cAAM,UAAU,KAAK,MAAM,KAAK,MAAM,YAAY,CAAC;AAEnD,cAAM,SAAS,WAAW,gBAAgB,UAAU,KAAK;AACzD,aAAK,UAAU,QAAQ,SAAS,MAAM;AAAA,MACxC;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEgB,WAChB,OACA,UACA,UACO;AACL,QAAI,KAAK,YAAY,KAAK,eAAe,KAAK,iBAAiB;AAC7D,WAAK,KAAK,KAAK;AACf,eAAS;AACT;AAAA,IACF;AAEA,SAAK,SAAS,OAAO,OAAO,CAAC,KAAK,QAAQ,KAAK,CAAC;AAEhD,UAAM,gBAAgB,KAAK,QAAQ,KAAK;AACxC,UAAM,kBAAkB,KAAK;AAAA,MAC3B,iBAAiB,KAAK,kBAAkB,KAAK;AAAA,IAC/C;AACA,UAAM,iBAAiB,KAAK,MAAM,KAAK,OAAO,SAAS,aAAa,IAAI;AAExE,QAAI,kBAAkB,iBAAiB;AACrC,YAAM,cAAc,iBAAiB;AACrC,YAAM,YAAY,KAAK,OAAO,MAAM,GAAG,WAAW;AAClD,WAAK,SAAS,KAAK,OAAO,MAAM,WAAW;AAE3C,YAAM,YAAY,KAAK,SAAS,SAAS;AACzC,WAAK,KAAK,SAAS;AAAA,IACrB;AAEA,aAAS;AAAA,EACX;AAAA,EAEgB,OAChB,UACO;AACL,QAAI,KAAK,UAAU;AACjB,eAAS;AACT;AAAA,IACF;AAEA,QAAI,KAAK,OAAO,SAAS,GAAG;AAC1B,YAAM,YAAY,KAAK,SAAS,KAAK,MAAM;AAC3C,WAAK,KAAK,SAAS;AAAA,IACrB;AACA,aAAS;AAAA,EACX;AAAA,EAEgB,cAAc,MAAoB;AAChD,QAAI,SAAS,KAAK,WAAY;AAE9B,QAAI,OAAO,GAAG;AACZ,YAAM,IAAI,WAAW,oCAAoC;AAAA,IAC3D;AAEA,UAAM,cAAc,IAAI;AACxB,SAAK,SAAS;AAAA,EAChB;AACF;AArKiD;AAA1C,IAAM,eAAN;;;ACVA,IAAM,qBAAN,MAAM,2BAA0B,eAAe;AAAA,EAE7C,YAAY,SAAoC;AACrD,UAAM,OAAO;AAFf,wBAAQ,WAAU;AAIhB,QAAI,OAAO,SAAS,WAAW,UAAU;AACvC,WAAK,UAAU,QAAQ,MAAM;AAAA,IAC/B;AAAA,EACF;AAAA,EAEA,IAAW,eAAe;AACxB,WAAO,KAAK,UAAU;AAAA,EACxB;AAAA,EAEA,IAAW,SAAS;AAClB,WAAO,KAAK,MAAM,KAAK,YAAY;AAAA,EACrC;AAAA,EAEA,IAAW,OAAO,QAAgB;AAChC,SAAK,UAAU,MAAM;AAAA,EACvB;AAAA,EAEO,UAAU,QAAgB;AAC/B,QAAI,OAAO,WAAW,YAAY,MAAM,MAAM;AAC9C,YAAM,IAAI;AAAA,QACR,mDAAmD,OAAO,MAAM;AAAA,MAClE;AACA,QAAI,SAAS,EAAG,UAAS;AACzB,QAAI,CAAC,SAAS,MAAM,EAAG,UAAS;AAEhC,SAAK,UAAU,SAAS;AAExB,SAAK,WAAW;AAEhB,WAAO;AAAA,EACT;AAAA,EAEO,WACP,OACA,UACA,UACO;AACL,QAAI,KAAK,YAAY,KAAK,YAAY,GAAG;AACvC,WAAK,KAAK,KAAK;AACf,aAAO,SAAS;AAAA,IAClB;AAEA,UAAM,MAAM,KAAK,MAAM,MAAM,SAAS,CAAC,IAAI;AAC3C,UAAM,EAAE,MAAM,IAAI;AAElB,aAAS,IAAI,GAAG,IAAI,KAAK,KAAK,OAAO;AACnC,YAAM,MAAM,KAAK,SAAS,OAAO,CAAC;AAClC,YAAM,MAAM,KAAK,MAAM,MAAM,KAAK,OAAO;AACzC,WAAK,UAAU,OAAO,KAAK,CAAC;AAAA,IAC9B;AAEA,SAAK,KAAK,KAAK;AAEf,WAAO,SAAS;AAAA,EAClB;AAAA,EAEO,WAAW;AAChB,WAAO,GAAG,KAAK,MAAM;AAAA,EACvB;AACF;AAhEsD;AAA/C,IAAM,oBAAN;;;ACaA,IAAM,yBAAN,MAAM,+BAA8B,eAAe;AAAA,EAWxD,YAAY,UAA6B,CAAC,GAAG;AAC3C,UAAM,OAAO;AAXf,wBAAQ;AACR,wBAAQ;AACR,wBAAQ;AACR,wBAAQ;AACR,wBAAQ;AACR,wBAAQ;AACR,wBAAQ,YAAmB;AAC3B,wBAAQ,iBAAwB;AAChC,wBAAQ,yBAAgC;AAKtC,SAAK,YAAY,QAAQ,aAAa;AACtC,SAAK,QAAQ,QAAQ,SAAS;AAC9B,SAAK,SAAS,QAAQ,UAAU;AAChC,SAAK,UAAU,QAAQ,WAAW;AAClC,SAAK,aAAa,QAAQ,cAAc;AACxC,SAAK,YAAY,QAAQ,aAAa;AACtC,SAAK,SAAS,KAAK,IAAI,MAAM,KAAK,aAAa,KAAK,SAAS,IAAK;AAClE,SAAK,UAAU,KAAK,IAAI,MAAM,KAAK,aAAa,KAAK,UAAU,IAAK;AAAA,EACtE;AAAA,EAEQ,WAAW,QAAwB;AACzC,UAAM,MAAM,KAAK,KAAK,MAAM,KAAK,IAAI,QAAQ,IAAI,CAAC;AAClD,WAAO;AAAA,EACT;AAAA,EAEQ,WAAW,IAAoB;AACrC,UAAM,MAAM,KAAK,IAAI,IAAI,KAAK,EAAE;AAChC,WAAO;AAAA,EACT;AAAA,EAEO,aAAa,IAAY;AAC9B,SAAK,YAAY,KAAK,IAAI,MAAM,KAAK,IAAI,GAAG,EAAE,CAAC;AAC/C,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,SAAS,OAAe;AAC7B,SAAK,QAAQ,KAAK,IAAI,GAAG,KAAK;AAC9B,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,UAAU,IAAY;AAC3B,SAAK,SAAS,KAAK,IAAI,MAAM,KAAK,aAAa,KAAK,IAAI,KAAK,EAAE,IAAI,IAAK;AACxE,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,WAAW,IAAY;AAC5B,SAAK,UAAU,KAAK;AAAA,MAClB,MAAM,KAAK,aAAa,KAAK,IAAI,KAAK,EAAE,IAAI;AAAA,IAC9C;AACA,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,cAAc,IAAY;AAC/B,SAAK,aAAa,KAAK,IAAI,KAAK,KAAK,IAAI,IAAI,EAAE,CAAC;AAChD,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,aAAa,IAAY;AAC9B,SAAK,YAAY,KAAK,IAAI,GAAG,KAAK,IAAI,IAAI,EAAE,CAAC;AAC7C,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,cAAc,SAAwC;AAC3D,QAAI,OAAO,QAAQ,cAAc,UAAU;AACzC,WAAK,aAAa,QAAQ,SAAS;AAAA,IACrC;AAEA,QAAI,OAAO,QAAQ,UAAU,UAAU;AACrC,WAAK,SAAS,QAAQ,KAAK;AAAA,IAC7B;AAEA,QAAI,OAAO,QAAQ,WAAW,UAAU;AACtC,WAAK,UAAU,QAAQ,MAAM;AAAA,IAC/B;AAEA,QAAI,OAAO,QAAQ,YAAY,UAAU;AACvC,WAAK,WAAW,QAAQ,OAAO;AAAA,IACjC;AAEA,QAAI,OAAO,QAAQ,eAAe,UAAU;AAC1C,WAAK,cAAc,QAAQ,UAAU;AAAA,IACvC;AAEA,QAAI,OAAO,QAAQ,cAAc,UAAU;AACzC,WAAK,aAAa,QAAQ,SAAS;AAAA,IACrC;AAEA,SAAK,SAAS;AAEd,WAAO,KAAK,cAAc;AAAA,EAC5B;AAAA,EAEO,gBAAsC;AAC3C,WAAO;AAAA,MACL,WAAW,KAAK;AAAA,MAChB,OAAO,KAAK;AAAA,MACZ,QAAQ,KAAK;AAAA,MACb,SAAS,KAAK;AAAA,MACd,YAAY,KAAK;AAAA,MACjB,WAAW,KAAK;AAAA,IAClB;AAAA,EACF;AAAA,EAEQ,qBAAqB,YAA4B;AACvD,UAAM,UAAU,KAAK,WAAW,UAAU;AAE1C,QAAI,kBAAkB;AAEtB,QAAI,KAAK,UAAU,KAAK,aAAa,CAAC,KAAK,WAAW;AACpD,wBAAkB;AAAA,IACpB,WAAW,IAAI,KAAK,IAAI,UAAU,KAAK,SAAS,KAAK,KAAK,WAAW;AACnE,YAAM,IAAI,UAAU,KAAK,YAAY,KAAK,YAAY;AACtD,yBACC,IAAI,KAAK,QAAQ,KAAK,KAAK,IAAI,GAAG,CAAC,KAAK,IAAI,KAAK;AAAA,IACpD,OAAO;AACL,yBAAmB,UAAU,KAAK,cAAc,IAAI,IAAI,KAAK;AAAA,IAC/D;AAEA,WAAO,KAAK,WAAW,CAAC,kBAAkB,KAAK,UAAU;AAAA,EAC3D;AAAA,EAEQ,cAAc,OAAuB;AAC3C,QAAI,KAAK,SAAU,QAAO;AAE1B,UAAM,aAAa,QAAQ,KAAK;AAEhC,UAAM,aAAa,KAAK,IAAI,UAAU;AACtC,UAAM,QAAQ,aAAa,KAAK,WAAW,KAAK,SAAS,KAAK;AAC9D,SAAK,WAAW,QAAQ,KAAK,YAAY,IAAI,SAAS;AAEtD,UAAM,sBAAsB,KAAK,qBAAqB,KAAK,QAAQ;AAEnE,SAAK,gBAAgB,KAAK;AAAA,MACxB,KAAK,wBAAwB,KAAK,SAClC,uBAAuB,IAAI,KAAK;AAAA,MAChC;AAAA,IACF;AACA,SAAK,wBAAwB,KAAK;AAElC,UAAM,cAAc,aAAa,KAAK;AAEtC,WAAO,KAAK,MAAM,KAAK,MAAM,cAAc,KAAK,QAAQ,CAAC;AAAA,EAC3D;AAAA,EAEgB,WAChB,OACA,UACA,UACO;AACL,QAAI,KAAK,UAAU;AACjB,eAAS,MAAM,KAAK;AACpB;AAAA,IACF;AAEA,UAAM,SAAS,OAAO,MAAM,MAAM,MAAM;AAExC,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,KAAK,OAAO;AACjD,YAAM,SAAS,KAAK,SAAS,OAAO,CAAC;AACrC,YAAM,YAAY,KAAK,cAAc,MAAM;AAC3C,WAAK,UAAU,QAAQ,WAAW,CAAC;AAAA,IACrC;AAEA,aAAS,MAAM,MAAM;AAAA,EACvB;AACF;AAxK0D;AAAnD,IAAM,wBAAN;;;ACnBP,SAAS,oBAAoB;AAoBtB,IAAM,wBAAN,MAAM,8BAA6B,eAAe;AAAA,EAShD,YACP,UAA4B;AAAA,IAC1B,UAAU;AAAA,IACV,eAAe;AAAA,EACjB,GACA;AACE,UAAM,OAAO;AAdf,wBAAQ;AACR,wBAAiB;AACjB,wBAAQ;AACR,wBAAQ,mBAAkB;AAC1B,wBAAQ,cAA4B;AACpC,wBAAQ,UAAiB,OAAO,MAAM,CAAC;AACvC,wBAAgB,UAAS,IAAI,aAAa;AAUxC,QAAI,QAAQ,iBAAiB,QAAQ,QAAQ,gBAAgB,GAAG;AAC9D,YAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAEA,QAAI,CAAC,QAAQ,YAAY,QAAQ,YAAY,GAAG;AAC9C,YAAM,IAAI,MAAM,oCAAoC;AAAA,IACtD;AAEA,SAAK,gBAAgB,QAAQ;AAC7B,SAAK,WAAW,QAAQ;AAExB,QAAI,OAAO,QAAQ,eAAe,YAAY,QAAQ,aAAa,GAAG;AACpE,WAAK,aAAa,QAAQ;AAAA,IAC5B;AAEA,SAAK,sBAAsB;AAAA,EAC7B;AAAA,EAEO,gBAAkC;AACvC,WAAO;AAAA,MACL,iBAAiB,KAAK;AAAA,MACtB,YAAY,KAAK;AAAA,MACjB,eAAe,KAAK;AAAA,IACtB;AAAA,EACF;AAAA,EAEQ,wBAA8B;AACpC,SAAK,gBAAgB,KAAK,QAAQ,KAAK;AAEvC,QAAI,KAAK,kBAAkB,GAAG;AAC5B,YAAM,YAAY,KAAK,mBAAmB,KAAK,aAAa;AAC5D,WAAK,kBAAkB,KAAK,MAAM,YAAY,MAAO,KAAK,UAAU;AAAA,IACtE;AAEA,QAAI,KAAK,eAAe,MAAM;AAC5B,YAAM,SAAS,KAAK,cAAc,KAAK,aAAa;AACpD,WAAK,aAAa,KAAK,MAAM,SAAS,MAAO,KAAK,UAAU;AAAA,IAC9D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,qBAAqB,gBAAgC;AAC3D,WAAO,iBAAiB,KAAK;AAAA,EAC/B;AAAA,EAEO,iBAAiB,UAAwB;AAC9C,QAAI,YAAY,GAAG;AACjB,YAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAEA,SAAK,gBAAgB;AACrB,SAAK,sBAAsB;AAC3B,SAAK,SAAS;AAAA,EAChB;AAAA,EAEgB,cAAc,MAAoB;AAChD,UAAM,cAAc,IAAI;AACxB,SAAK,sBAAsB;AAC3B,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,KAAK,IAAoB;AAC9B,QAAI,KAAK,kBAAkB,EAAG,QAAO;AAErC,QAAI,KAAK,GAAG;AACV,WAAK,KAAK,IAAI,GAAG,KAAK,gBAAgB,EAAE;AAAA,IAC1C;AAEA,SAAK,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,eAAe,EAAE,CAAC;AACjD,UAAM,eAAe,KAAK,MAAM,KAAK,MAAO,KAAK,UAAU;AAE3D,QAAI,eAAe,KAAK,iBAAiB;AACvC,WAAK,SAAS,OAAO,MAAM,CAAC;AAE5B,YAAM,eAAe,KAAK,qBAAqB,YAAY;AAE3D,WAAK,OAAO,KAAK,QAAQ;AAAA,QACvB,UAAU;AAAA,QACV,QAAQ;AAAA,QACR;AAAA,MACF,CAAc;AAAA,IAChB;AAEA,SAAK,aAAa;AAClB,WAAO,eAAe,KAAK,aAAa;AAAA,EAC1C;AAAA,EAEO,cAAsB;AAC3B,WAAO,KAAK,kBAAkB,KAAK,aAAa;AAAA,EAClD;AAAA,EAEQ,WAAW,OAAuB;AACxC,QAAI,KAAK,eAAe,KAAM,QAAO;AAErC,UAAM,mBAAmB,KAAK;AAC9B,UAAM,eAAe,KAAK,MAAM,MAAM,SAAS,KAAK,aAAa;AACjE,UAAM,iBAAiB,mBAAmB;AAE1C,QAAI,KAAK,cAAc,gBAAgB;AACrC,WAAK,mBAAmB;AACxB,aAAO,OAAO,MAAM,CAAC;AAAA,IACvB;AAEA,QAAI,KAAK,cAAc,kBAAkB;AACvC,YAAM,gBAAgB,KAAK,aAAa;AACxC,YAAM,cAAc,gBAAgB,KAAK;AACzC,WAAK,kBAAkB,KAAK;AAC5B,WAAK,aAAa;AAClB,aAAO,MAAM,SAAS,WAAW;AAAA,IACnC;AAEA,SAAK,kBAAkB,KAAK;AAC5B,SAAK,aAAa;AAClB,WAAO;AAAA,EACT;AAAA,EAEgB,WAChB,OACA,UACA,UACO;AACL,QAAI;AACF,UAAI,KAAK,YAAY,KAAK,kBAAkB,GAAG;AAC7C,iBAAS,MAAM,KAAK;AACpB;AAAA,MACF;AAEA,YAAM,iBAAiB,OAAO,OAAO,CAAC,KAAK,QAAQ,KAAK,CAAC;AACzD,YAAM,aAAa,KAAK,MAAM,eAAe,SAAS,KAAK,aAAa;AACxE,YAAM,mBAAmB,aAAa,KAAK;AAE3C,WAAK,SAAS,eAAe,SAAS,gBAAgB;AAEtD,UAAI,gBAAgB,eAAe,SAAS,GAAG,gBAAgB;AAE/D,UAAI,KAAK,eAAe,MAAM;AAC5B,wBAAgB,KAAK,WAAW,aAAa;AAAA,MAC/C,OAAO;AACL,aAAK,mBAAmB;AAAA,MAC1B;AAEA,eAAS,MAAM,aAAa;AAAA,IAC9B,SAAS,OAAO;AACd,eAAS,KAAc;AAAA,IACzB;AAAA,EACF;AAAA,EAEgB,OAChB,UACO;AACL,QAAI,KAAK,OAAO,UAAU,KAAK,eAAe;AAC5C,YAAM,aAAa,KAAK,MAAM,KAAK,OAAO,SAAS,KAAK,aAAa;AACrE,YAAM,mBAAmB,aAAa,KAAK;AAC3C,eAAS,MAAM,KAAK,OAAO,SAAS,GAAG,gBAAgB,CAAC;AAAA,IAC1D;AAEA,aAAS;AAAA,EACX;AACF;AAxLyD;AAAlD,IAAM,uBAAN;;;ACLA,IAAM,qBAAN,MAAM,2BAA0B,eAAe;AAAA,EAYpD,YAAY,UAAyB,CAAC,GAAG;AACvC,UAAM,OAAO;AAZf,wBAAQ;AACR,wBAAQ;AACR,wBAAQ;AACR,wBAAQ;AAER,wBAAiB;AACjB,wBAAiB;AACjB,wBAAQ;AACR,wBAAiB,iBAAgB;AACjC,wBAAiB,YAAmB;AAKlC,SAAK,WAAW,QAAQ,YAAY;AACpC,SAAK,UAAU,QAAQ,WAAW;AAClC,SAAK,WAAW,QAAQ,YAAY;AACpC,SAAK,WAAW,QAAQ,YAAY;AAEpC,SAAK,kBAAkB,KAAK,MAAM,KAAK,aAAa,IAAI;AACxD,SAAK,aAAa,MAAM;AAAA,MACtB,EAAE,QAAQ,KAAK,cAAc;AAAA,MAC7B,MAAM,IAAI,aAAa,KAAK,eAAe;AAAA,IAC7C;AACA,SAAK,eAAe,MAAM,KAAK,aAAa,EAAE,KAAK,CAAC;AAAA,EACtD;AAAA,EAEO,YAAY,MAAc;AAC/B,SAAK,WAAW,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,IAAI,CAAC;AAC7C,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,WAAW,SAAiB;AACjC,SAAK,UAAU,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC;AAC/C,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,YAAY,OAAe;AAChC,SAAK,WAAW,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK,CAAC;AAC9C,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,YAAY,OAAe;AAChC,SAAK,WAAW,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK,CAAC;AAC9C,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,UAAU,SAAoC;AACnD,QAAI,OAAO,QAAQ,aAAa,UAAU;AACxC,WAAK,YAAY,QAAQ,QAAQ;AAAA,IACnC;AAEA,QAAI,OAAO,QAAQ,YAAY,UAAU;AACvC,WAAK,WAAW,QAAQ,OAAO;AAAA,IACjC;AAEA,QAAI,OAAO,QAAQ,aAAa,UAAU;AACxC,WAAK,YAAY,QAAQ,QAAQ;AAAA,IACnC;AAEA,QAAI,OAAO,QAAQ,aAAa,UAAU;AACxC,WAAK,YAAY,QAAQ,QAAQ;AAAA,IACnC;AAEA,SAAK,SAAS;AAEd,WAAO,KAAK,cAAc;AAAA,EAC5B;AAAA,EAEO,gBAAkC;AACvC,WAAO;AAAA,MACL,UAAU,KAAK;AAAA,MACf,SAAS,KAAK;AAAA,MACd,UAAU,KAAK;AAAA,MACf,UAAU,KAAK;AAAA,IACjB;AAAA,EACF;AAAA,EAEQ,cAAc,OAAuB;AAC3C,QAAI,KAAK,SAAU,QAAO;AAE1B,UAAM,aAAa,QAAQ,KAAK;AAChC,QAAI,MAAM;AAEV,aAAS,IAAI,GAAG,IAAI,KAAK,eAAe,KAAK;AAC3C,YAAM,YAAY,KAAK,WAAW,CAAC;AACnC,YAAM,aAAa,KAAK,aAAa,CAAC;AAEtC,YAAM,UAAU,UAAU,UAAU;AAEpC,YAAM,YAAY,UAAU,KAAK,YAAY,IAAI,KAAK;AAEtD,gBAAU,UAAU,IAAI,aAAa,YAAY,KAAK;AAEtD,WAAK,aAAa,CAAC,KAAK,aAAa,KAAK,KAAK;AAE/C,aAAO;AAAA,IACT;AAEA,UAAM,SACN,aAAa,KAAK,WAAW,MAAM,KAAK,WAAW,KAAK;AAExD,WAAO,KAAK,MAAM,KAAK,MAAM,SAAS,KAAK,QAAQ,CAAC;AAAA,EACtD;AAAA,EAEgB,WAChB,OACA,UACA,UACO;AACL,QAAI,KAAK,UAAU;AACjB,eAAS,MAAM,KAAK;AACpB;AAAA,IACF;AAEA,UAAM,SAAS,OAAO,MAAM,MAAM,MAAM;AAExC,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,KAAK,OAAO;AACjD,YAAM,SAAS,KAAK,SAAS,OAAO,CAAC;AACrC,YAAM,YAAY,KAAK,cAAc,MAAM;AAC3C,WAAK,UAAU,QAAQ,WAAW,CAAC;AAAA,IACrC;AAEA,aAAS,MAAM,MAAM;AAAA,EACvB;AACF;AA9HsD;AAA/C,IAAM,oBAAN;;;AChBP,SAAwB,gBAAgB;AA+BjC,IAAM,gBAAN,MAAM,cAAa;AAAA,EAcjB,YAAmB,UAA4B,CAAC,GAAG;AAAhC;AAb1B,wBAAO,aAAoC;AAC3C,wBAAO,WAA8B;AACrC,wBAAO,UAA8B;AACrC,wBAAO,UAAmC;AAC1C,wBAAO,aAAiC;AACxC,wBAAO,cAA2C;AAClD,wBAAO,UAAsC;AAC7C,wBAAO,UAAmC;AAC1C,wBAAO,eAA+B;AACtC,wBAAO,UAA0B;AACjC,wBAAO,YAA0B,6BAAM,MAAN;AACjC,wBAAO,WAAmC,6BAAM,MAAN;AAAA,EAEiB;AAAA,EAEpD,OAAO,KAAe,UAA4B,KAAK,SAAS;AACrE,SAAK,QAAQ;AAEb,SAAK,SAAS;AAEd,UAAM,YAAY,CAAC,QAAQ,WAAW,WACtC,IAAI,aAAa,QAAQ,SAAS,IAClC;AAEA,UAAM,kBAAkB,CAAC,QAAQ,WAAW,WAC5C,IAAI,gBAAgB,QAAQ,SAAS,IACrC;AAEA,UAAM,YAAY,CAAC,QAAQ,KAAK,WAChC,IAAI,YAAY,QAAQ,GAAG,IAC3B;AAEA,UAAM,eAAe,CAAC,QAAQ,QAAQ,WACtC,IAAI,aAAa,QAAQ,MAAM,IAC/B;AAEA,UAAM,oBAAoB,CAAC,QAAQ,QAAQ,WAC3C,IAAI,kBAAkB,QAAQ,MAAM,IACpC;AAEA,UAAM,aAAa,CAAC,QAAQ,YAAY,WACxC,IAAI,sBAAsB,QAAQ,UAAU,IAC5C;AAEA,UAAM,SAAS,CAAC,QAAQ,QAAQ,WAChC,IAAI,qBAAqB,QAAQ,MAAM,IACvC;AAEA,UAAM,SAAS,CAAC,QAAQ,QAAQ,WAChC,IAAI,kBAAkB,QAAQ,MAAM,IACpC;AAEA,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,UAAU;AACf,SAAK,SAAS;AACd,SAAK,SAAS;AACd,SAAK,aAAa;AAClB,SAAK,SAAS;AACd,SAAK,SAAS;AAGd,QAAI,UAAW,WAAU,WAAW,KAAK;AACzC,QAAI,gBAAiB,iBAAgB,WAAW,KAAK;AACrD,QAAI,UAAW,WAAU,WAAW,KAAK;AACzC,QAAI,aAAc,cAAa,WAAW,KAAK;AAC/C,QAAI,kBAAmB,mBAAkB,WAAW,KAAK;AACzD,QAAI,WAAY,YAAW,WAAW,KAAK;AAC3C,QAAI,OAAQ,QAAO,WAAW,KAAK;AACnC,QAAI,OAAQ,QAAO,WAAW,KAAK;AAEnC,UAAM,SAAS;AAAA,MACf;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAM,EACN,OAAO,OAAO;AAEd,QAAI,CAAC,OAAO,OAAQ,QAAO;AAG3B,SAAK,cAAc,SAAS,GAAG,QAAQ,CAAC,QAAsB;AAC5D,UAAI,KAAK;AACP,aAAK,QAAQ;AACb,YAAI,CAAC,IAAI,QAAQ,SAAS,4BAA4B;AACtD,eAAK,QAAQ,GAAG;AAAA,MAClB;AAAA,IACF,CAAC;AAED,SAAK,YAAa,KAAK,SAAS,KAAK,QAAQ,KAAK,IAAI,CAAC;AAEvD,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,UAAU;AAEf,SAAK,WAAW,QAAQ;AACxB,SAAK,WAAW,QAAQ;AACxB,SAAK,QAAQ,QAAQ;AACrB,SAAK,SAAS,QAAQ;AACtB,SAAK,QAAQ,QAAQ;AACrB,SAAK,YAAY,QAAQ;AACzB,SAAK,QAAQ,QAAQ;AACrB,SAAK,QAAQ,QAAQ;AACrB,SAAK,aAAa,QAAQ;AAC1B,SAAK,QAAQ,QAAQ;AAGrB,SAAK,WAAW,mBAAmB;AACnC,SAAK,WAAW,mBAAmB;AACnC,SAAK,QAAQ,mBAAmB;AAChC,SAAK,SAAS,mBAAmB;AACjC,SAAK,QAAQ,mBAAmB;AAChC,SAAK,YAAY,mBAAmB;AACpC,SAAK,QAAQ,mBAAmB;AAChC,SAAK,QAAQ,mBAAmB;AAChC,SAAK,aAAa,mBAAmB;AACrC,SAAK,QAAQ,mBAAmB;AAGhC,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,SAAS;AACd,SAAK,UAAU;AACf,SAAK,SAAS;AACd,SAAK,aAAa;AAClB,SAAK,SAAS;AACd,SAAK,SAAS;AACd,SAAK,cAAc;AACnB,SAAK,SAAS;AAAA,EAChB;AACF;AAzI0B;AAAnB,IAAM,eAAN;;;ACzBA,IAAM;AAAA;AAAA,EAAqC;AAAA;",
  "names": []
}
