@kongyo2/kongyoroid 1.0.0 → 2.0.0

package/dist/formant.js

@@ -1,622 +0,0 @@
-import { setImmediate as yieldToEventLoop } from "node:timers/promises";
-import { checkAbort, invalid } from "./errors.js";
-import { LIMITS } from "./limits.js";
-import { kanaToUnits } from "./mora.js";
-import { parseKanaNotation } from "./notation.js";
-import { midiToHz } from "./pitch.js";
-import { encodePcm16, wavHeader } from "./wav.js";
-function vowel(f, amp) {
-    return { f, bw: [80, 110, 170, 230], amp, voiced: 1, noise: 0.02, level: 1, kind: "vowel", duration: 0.1 };
-}
-function whisper(base) {
-    return { ...base, voiced: 0, noise: 1, level: 0.22, bw: [140, 180, 240, 300] };
-}
-function nasal(f, duration) {
-    return {
-        f,
-        bw: [90, 220, 280, 320],
-        amp: [1, 0.22, 0.09, 0.03],
-        voiced: 1,
-        noise: 0.01,
-        level: 0.72,
-        kind: "nasal",
-        duration,
-    };
-}
-function stop(f, amp, voiced, level, duration) {
-    return { f, bw: [220, 320, 420, 520], amp, voiced, noise: 1, level, kind: "stop", duration };
-}
-function fricative(f, bw, amp, voiced, level, duration, kind = "fricative") {
-    return { f, bw, amp, voiced, noise: 1, level, kind, duration };
-}
-function glide(f, amp) {
-    return { f, bw: [70, 120, 180, 240], amp, voiced: 1, noise: 0.02, level: 0.82, kind: "glide", duration: 0.045 };
-}
-function palatal(base) {
-    return { ...base, f: [base.f[0], Math.max(base.f[1], 2100), Math.max(base.f[2], 2900), base.f[3]] };
-}
-function labial(base) {
-    return { ...base, f: [base.f[0], Math.min(base.f[1], 900), base.f[2], base.f[3]] };
-}
-const A = vowel([750, 1200, 2600, 3500], [1, 0.5, 0.25, 0.1]);
-const I = vowel([290, 2250, 3000, 3600], [1, 0.32, 0.2, 0.08]);
-const U = vowel([330, 1300, 2350, 3400], [1, 0.28, 0.16, 0.06]);
-const E = vowel([500, 1900, 2550, 3500], [1, 0.45, 0.25, 0.1]);
-const O = vowel([520, 900, 2500, 3400], [1, 0.45, 0.18, 0.07]);
-const SILENCE = {
-    f: [500, 1500, 2500, 3500],
-    bw: [200, 200, 200, 200],
-    amp: [0, 0, 0, 0],
-    voiced: 0,
-    noise: 0,
-    level: 0,
-    kind: "silence",
-    duration: 0.08,
-};
-const K = stop([1500, 2500, 3500, 4500], [0.4, 1, 0.6, 0.3], 0, 0.7, 0.065);
-const G = stop([400, 1800, 2600, 3400], [0.7, 1, 0.5, 0.25], 0.45, 0.65, 0.05);
-const T = stop([1000, 3500, 4500, 5500], [0.3, 1, 0.7, 0.4], 0, 0.7, 0.06);
-const D = stop([350, 2000, 3000, 4000], [0.8, 1, 0.5, 0.25], 0.5, 0.65, 0.045);
-const P = stop([600, 1300, 2500, 3500], [1, 0.6, 0.3, 0.15], 0, 0.55, 0.065);
-const B = stop([300, 1000, 2300, 3300], [1, 0.6, 0.3, 0.15], 0.55, 0.6, 0.045);
-const S = fricative([4500, 6000, 7500, 9000], [800, 900, 1000, 1200], [0.6, 1, 0.8, 0.5], 0, 0.45, 0.085);
-const SH = fricative([2600, 3800, 5200, 7000], [500, 600, 800, 1000], [0.8, 1, 0.7, 0.4], 0, 0.5, 0.085);
-const H = fricative([900, 1900, 2800, 3600], [300, 400, 500, 600], [0.7, 0.8, 0.5, 0.3], 0, 0.32, 0.07);
-const F = fricative([1100, 2100, 3200, 4500], [600, 700, 800, 900], [0.7, 0.8, 0.6, 0.4], 0, 0.3, 0.075);
-const NASAL_N = nasal([280, 1300, 2300, 3300], 0.055);
-const M = nasal([250, 950, 2200, 3200], 0.06);
-const R = {
-    f: [380, 1400, 2300, 3300],
-    bw: [100, 150, 200, 250],
-    amp: [1, 0.45, 0.2, 0.08],
-    voiced: 1,
-    noise: 0.02,
-    level: 0.6,
-    kind: "flap",
-    duration: 0.026,
-};
-const Y = glide([280, 2100, 2900, 3500], [1, 0.35, 0.2, 0.08]);
-const W = glide([300, 700, 2300, 3300], [1, 0.4, 0.15, 0.06]);
-const TIMBRES = {
-    a: A,
-    i: I,
-    u: U,
-    e: E,
-    o: O,
-    A: whisper(A),
-    I: whisper(I),
-    U: whisper(U),
-    E: whisper(E),
-    O: whisper(O),
-    N: nasal([280, 1100, 2300, 3300], 0.085),
-    cl: SILENCE,
-    pau: SILENCE,
-    k: K,
-    ky: palatal(K),
-    kw: labial(K),
-    g: G,
-    gy: palatal(G),
-    gw: labial(G),
-    t: T,
-    ty: palatal(T),
-    d: D,
-    dy: palatal(D),
-    p: P,
-    py: palatal(P),
-    b: B,
-    by: palatal(B),
-    s: S,
-    sh: SH,
-    z: fricative(S.f, S.bw, S.amp, 0.6, 0.5, 0.07),
-    j: fricative(SH.f, SH.bw, SH.amp, 0.6, 0.5, 0.075, "affricate"),
-    ch: fricative(SH.f, SH.bw, SH.amp, 0, 0.55, 0.085, "affricate"),
-    ts: fricative(S.f, S.bw, S.amp, 0, 0.5, 0.085, "affricate"),
-    h: H,
-    hy: palatal(H),
-    f: F,
-    v: fricative(F.f, F.bw, F.amp, 0.7, 0.45, 0.06),
-    n: NASAL_N,
-    ny: palatal(NASAL_N),
-    m: M,
-    my: palatal(M),
-    r: R,
-    ry: palatal(R),
-    y: Y,
-    w: W,
-};
-const PALATALIZED = new Set(["ky", "gy", "ty", "dy", "py", "by", "hy", "ny", "my", "ry"]);
-const LABIALIZED = new Set(["kw", "gw"]);
-const BASE_F0 = 150;
-function isVoicedSustain(phoneme) {
-    const kind = TIMBRES[phoneme].kind;
-    return (kind === "vowel" || kind === "nasal" || kind === "glide" || kind === "flap") && TIMBRES[phoneme].voiced > 0;
-}
-function finalize(drafts, sampleRate, plan) {
-    const segments = [];
-    let cursor = 0;
-    let seconds = 0;
-    for (const [index, draft] of drafts.entries()) {
-        seconds += draft.seconds;
-        const end = Math.round(seconds * sampleRate);
-        const frames = end - cursor;
-        if (frames <= 0)
-            continue;
-        cursor = end;
-        const previous = drafts[index - 1];
-        const next = drafts[index + 1];
-        segments.push({
-            phoneme: draft.phoneme,
-            frames,
-            f0Start: draft.f0Start,
-            f0End: draft.f0End,
-            amplitude: draft.amplitude,
-            vibrato: draft.vibrato,
-            rampIn: previous === undefined || !isVoicedSustain(previous.phoneme),
-            rampOut: next === undefined || !isVoicedSustain(next.phoneme),
-        });
-    }
-    if (cursor > LIMITS.formantSeconds * sampleRate) {
-        invalid("$", `Audio would last ${(cursor / sampleRate).toFixed(1)} s; the formant engine renders at most ${LIMITS.formantSeconds} s per request.`, "Split the input into shorter requests, or use the voicevox engine.");
-    }
-    return { ...plan, segments, frames: cursor };
-}
-function consonantDrafts(consonant, seconds, f0Start, f0End) {
-    if (consonant === null)
-        return [];
-    const out = [{ phoneme: consonant, seconds, f0Start, f0End, amplitude: 1, vibrato: false }];
-    if (PALATALIZED.has(consonant))
-        out.push({ phoneme: "y", seconds: 0.03, f0Start: f0End, f0End, amplitude: 0.9, vibrato: false });
-    if (LABIALIZED.has(consonant))
-        out.push({ phoneme: "w", seconds: 0.03, f0Start: f0End, f0End, amplitude: 0.9, vibrato: false });
-    return out;
-}
-function shapePitch(hz, pitch, intonation) {
-    const mean = Math.log(BASE_F0 * 1.08);
-    const scaled = mean + (Math.log(hz) - mean) * intonation;
-    return Math.exp(scaled * 2 ** pitch);
-}
-function heuristicPhrases(units) {
-    const phrases = [];
-    let moras = [];
-    const flush = (pauseWeight, interrogative) => {
-        if (moras.length === 0) {
-            const last = phrases.at(-1);
-            if (last !== undefined && pauseWeight > 0) {
-                phrases[phrases.length - 1] = {
-                    phrase: { ...last.phrase, pause: true, interrogative: last.phrase.interrogative || interrogative },
-                    pauseWeight: last.pauseWeight + pauseWeight,
-                };
-            }
-            return;
-        }
-        phrases.push({ phrase: { moras, accent: moras.length, pause: pauseWeight > 0, interrogative }, pauseWeight });
-        moras = [];
-    };
-    for (const unit of units) {
-        if (unit.kind === "pause") {
-            flush(unit.weight, unit.text === "?");
-            continue;
-        }
-        moras.push({ text: unit.text, consonant: unit.consonant, vowel: unit.vowel });
-        if (moras.length >= 7)
-            flush(0, false);
-    }
-    flush(0, false);
-    return phrases;
-}
-export function planSpeech(request, sampleRate) {
-    const phrases = request.kana === undefined
-        ? heuristicPhrases(kanaToUnits(request.text, "$.text"))
-        : parseKanaNotation(request.kana, "$.kana").map((phrase) => ({ phrase, pauseWeight: 1 }));
-    if (phrases.length === 0)
-        invalid("$.text", "Text contains no readable kana.");
-    const speed = request.speed;
-    const drafts = [];
-    const rest = (seconds) => {
-        drafts.push({ phoneme: "pau", seconds, f0Start: 0, f0End: 0, amplitude: 0, vibrato: false });
-    };
-    rest(request.prePause);
-    let previousHz = shapePitch(BASE_F0, request.pitch, request.intonation);
-    for (const [phraseIndex, { phrase, pauseWeight }] of phrases.entries()) {
-        const declination = Math.max(0.85, 1 - 0.04 * phraseIndex);
-        const count = phrase.moras.length;
-        for (const [moraIndex, mora] of phrase.moras.entries()) {
-            const position = moraIndex + 1;
-            const high = phrase.accent === 1 ? position === 1 : position >= 2 && position <= phrase.accent;
-            const slope = high ? 1.22 - (0.1 * moraIndex) / Math.max(1, count - 1) : 0.97;
-            const targetHz = shapePitch(BASE_F0 * slope * declination, request.pitch, request.intonation);
-            const last = moraIndex === count - 1;
-            const endHz = request.upspeak && phrase.interrogative && last ? targetHz * 1.35 : targetHz * 0.985;
-            const timbre = TIMBRES[mora.vowel];
-            const consonant = mora.consonant;
-            const consonantSeconds = consonant === null ? 0 : TIMBRES[consonant].duration / speed;
-            drafts.push(...consonantDrafts(consonant, consonantSeconds, previousHz, targetHz));
-            const vowelSeconds = (mora.vowel === "cl"
-                ? 0.08
-                : mora.vowel === "N"
-                    ? 0.085
-                    : timbre.kind === "vowel" && timbre.voiced === 0
-                        ? 0.07
-                        : consonant === null
-                            ? 0.12
-                            : 0.095) / speed;
-            drafts.push({
-                phoneme: mora.vowel,
-                seconds: vowelSeconds,
-                f0Start: targetHz,
-                f0End: endHz,
-                amplitude: 1,
-                vibrato: false,
-            });
-            previousHz = endHz;
-        }
-        if (phrase.pause) {
-            const base = request.pauseLength ?? 0.18 * pauseWeight;
-            rest((base * request.pauseScale) / speed);
-        }
-        else if (phraseIndex < phrases.length - 1) {
-            rest(0.02 / speed);
-        }
-    }
-    rest(request.postPause);
-    return finalize(drafts, sampleRate, {
-        sampleRate,
-        seed: request.seed,
-        volume: request.volume,
-        vibratoDepth: 0,
-        vibratoRate: 0,
-    });
-}
-export function planSong(request, sampleRate) {
-    const secondsPerBeat = 60 / request.tempo;
-    const notes = request.notes;
-    const drafts = [];
-    const rest = (seconds) => {
-        drafts.push({ phoneme: "pau", seconds, f0Start: 0, f0End: 0, amplitude: 0, vibrato: false });
-    };
-    const leadIn = notes[0]?.key === null ? 0 : request.leadIn;
-    const durations = notes.map((note) => note.beats * secondsPerBeat);
-    const consonantOf = (index) => {
-        const note = notes[index];
-        if (note === undefined || note.key === null)
-            return { consonant: null, seconds: 0, fromOwn: false };
-        const units = kanaToUnits(note.lyric, `$.notes[${index}].lyric`);
-        const unit = units[0];
-        if (unit === undefined || unit.kind !== "mora" || unit.consonant === null) {
-            return { consonant: null, seconds: 0, fromOwn: false };
-        }
-        const nominal = TIMBRES[unit.consonant].duration + (PALATALIZED.has(unit.consonant) || LABIALIZED.has(unit.consonant) ? 0.03 : 0);
-        const fromOwn = index === 0 && leadIn <= 0;
-        const available = index === 0 ? (fromOwn ? (durations[0] ?? 0) * 0.4 : leadIn) : (durations[index - 1] ?? 0) * 0.4;
-        return { consonant: unit.consonant, seconds: Math.min(nominal, available), fromOwn };
-    };
-    let previousHz = 0;
-    const first = consonantOf(0);
-    if (leadIn > 0)
-        rest(leadIn - first.seconds);
-    for (const [index, note] of notes.entries()) {
-        const duration = durations[index] ?? 0;
-        const own = consonantOf(index);
-        const following = consonantOf(index + 1);
-        if (note.key === null) {
-            rest(Math.max(0, duration - following.seconds));
-            previousHz = 0;
-            continue;
-        }
-        const hz = midiToHz(note.key);
-        const vowelUnit = kanaToUnits(note.lyric, `$.notes[${index}].lyric`)[0];
-        const vowelPhoneme = vowelUnit !== undefined && vowelUnit.kind === "mora" ? vowelUnit.vowel : "a";
-        if (own.consonant !== null && own.seconds > 0) {
-            const glideSeconds = PALATALIZED.has(own.consonant) || LABIALIZED.has(own.consonant) ? Math.min(0.03, own.seconds * 0.4) : 0;
-            const parts = consonantDrafts(own.consonant, own.seconds - glideSeconds, previousHz || hz, hz);
-            for (const part of parts)
-                if (part.phoneme === "y" || part.phoneme === "w")
-                    part.seconds = glideSeconds;
-            drafts.push(...parts);
-        }
-        const vowelSeconds = Math.max(0, duration - following.seconds - (own.fromOwn ? own.seconds : 0));
-        const previous = drafts.at(-1);
-        if (previous !== undefined &&
-            previous.phoneme === vowelPhoneme &&
-            previous.vibrato &&
-            previous.f0End === hz &&
-            own.consonant === null) {
-            previous.seconds += vowelSeconds;
-        }
-        else {
-            drafts.push({
-                phoneme: vowelPhoneme,
-                seconds: vowelSeconds,
-                f0Start: previousHz === 0 ? hz : previousHz,
-                f0End: hz,
-                amplitude: 1,
-                vibrato: true,
-            });
-        }
-        previousHz = hz;
-    }
-    if (notes.at(-1)?.key !== null)
-        rest(request.leadOut);
-    return finalize(drafts, sampleRate, {
-        sampleRate,
-        seed: request.seed,
-        volume: request.volume,
-        vibratoDepth: request.vibratoDepth ?? 25,
-        vibratoRate: request.vibratoRate,
-    });
-}
-class Resonator {
-    a1 = 0;
-    a2 = 0;
-    b = 0;
-    y1 = 0;
-    y2 = 0;
-    x1 = 0;
-    x2 = 0;
-    tune(frequency, width, rate) {
-        const radius = Math.exp((-Math.PI * width) / rate);
-        this.a1 = 2 * radius * Math.cos((2 * Math.PI * Math.min(rate * 0.45, frequency)) / rate);
-        this.a2 = radius * radius;
-        this.b = (1 - radius) * 0.5;
-    }
-    step(x) {
-        const y = this.b * (x - this.x2) + this.a1 * this.y1 - this.a2 * this.y2;
-        this.x2 = this.x1;
-        this.x1 = x;
-        this.y2 = this.y1;
-        this.y1 = y;
-        return y;
-    }
-}
-function polyBlep(t, step) {
-    if (t < step) {
-        const x = t / step;
-        return x + x - x * x - 1;
-    }
-    if (t > 1 - step) {
-        const x = (t - 1) / step;
-        return x * x + x + x + 1;
-    }
-    return 0;
-}
-const CONTROL = 32;
-class FormantRenderer {
-    plan;
-    filters = [new Resonator(), new Resonator(), new Resonator(), new Resonator()];
-    frequencies = new Float64Array([500, 1500, 2500, 3500]);
-    widths = new Float64Array([100, 150, 200, 250]);
-    gains = new Float64Array(4);
-    segmentIndex = 0;
-    segmentStart = 0;
-    cursor = 0;
-    phase = 0;
-    random;
-    source = 0;
-    dcIn = 0;
-    dcOut = 0;
-    pitchStep = 0;
-    voiced = 0;
-    noise = 0;
-    level = 0;
-    envelope = 0;
-    lastHz = BASE_F0;
-    constructor(plan) {
-        this.plan = plan;
-        this.random = plan.seed >>> 0 || 1;
-    }
-    nextRandom() {
-        let r = this.random;
-        r ^= r << 13;
-        r ^= r >>> 17;
-        r ^= r << 5;
-        this.random = r >>> 0;
-        return this.random / 2_147_483_648 - 1;
-    }
-    control(segment, local, rate) {
-        const timbre = TIMBRES[segment.phoneme];
-        const progress = local / Math.max(1, segment.frames);
-        const seconds = local / rate;
-        const tau = timbre.kind === "vowel" || timbre.kind === "nasal" || timbre.kind === "glide" ? 0.014 : 0.006;
-        const mix = 1 - Math.exp(-CONTROL / (rate * tau));
-        for (let band = 0; band < 4; band++) {
-            const f = this.frequencies[band] ?? 500;
-            const w = this.widths[band] ?? 100;
-            const targetF = timbre.f[band] ?? f;
-            const targetW = timbre.bw[band] ?? w;
-            const nextF = f + (targetF - f) * mix;
-            const nextW = w + (targetW - w) * mix;
-            this.frequencies[band] = nextF;
-            this.widths[band] = nextW;
-            this.gains[band] = timbre.amp[band] ?? 0;
-            this.filters[band]?.tune(nextF, nextW, rate);
-        }
-        let hz = segment.f0Start > 0 && segment.f0End > 0
-            ? segment.f0Start + (segment.f0End - segment.f0Start) * Math.min(1, progress * 3)
-            : this.lastHz;
-        if (segment.f0End > 0)
-            this.lastHz = segment.f0End;
-        if (segment.vibrato && this.plan.vibratoDepth > 0) {
-            const fade = Math.min(1, Math.max(0, (seconds - 0.12) / 0.18));
-            const cents = this.plan.vibratoDepth * fade * Math.sin(2 * Math.PI * this.plan.vibratoRate * (this.cursor / rate));
-            hz *= 2 ** (cents / 1200);
-        }
-        hz *= 1 + 0.004 * this.nextRandom();
-        this.pitchStep = hz / rate;
-        let voiced = timbre.voiced;
-        let noise = timbre.noise;
-        let level = timbre.level;
-        switch (timbre.kind) {
-            case "stop": {
-                const closure = 0.6;
-                if (progress < closure) {
-                    noise = 0;
-                    voiced = timbre.voiced > 0 ? 0.12 : 0;
-                    level = timbre.voiced > 0 ? 0.3 : 0;
-                }
-                else {
-                    const burst = (progress - closure) / (1 - closure);
-                    noise = Math.exp(-burst * 5);
-                    voiced = timbre.voiced * Math.min(1, burst * 3);
-                }
-                break;
-            }
-            case "affricate":
-                if (progress < 0.3) {
-                    noise = 0;
-                    voiced = timbre.voiced * 0.2;
-                    level *= 0.3;
-                }
-                break;
-            case "flap":
-                level *= 0.5 + 0.5 * Math.abs(Math.cos(Math.PI * progress));
-                break;
-            default:
-                break;
-        }
-        this.voiced = voiced;
-        this.noise = noise;
-        this.level = level * segment.amplitude;
-    }
-    fill(buffer) {
-        const plan = this.plan;
-        const rate = plan.sampleRate;
-        const attack = Math.max(1, Math.round(rate * 0.008));
-        const release = Math.max(1, Math.round(rate * 0.014));
-        for (let i = 0; i < buffer.length; i++, this.cursor++) {
-            let segment = plan.segments[this.segmentIndex];
-            while (segment !== undefined && this.cursor >= this.segmentStart + segment.frames) {
-                this.segmentStart += segment.frames;
-                this.segmentIndex += 1;
-                segment = plan.segments[this.segmentIndex];
-            }
-            if (segment === undefined) {
-                buffer[i] = 0;
-                continue;
-            }
-            const local = this.cursor - this.segmentStart;
-            if (local % CONTROL === 0 || local === 0)
-                this.control(segment, local, rate);
-            const saw = 2 * this.phase - 1 - polyBlep(this.phase, this.pitchStep);
-            this.phase += this.pitchStep;
-            this.phase -= Math.floor(this.phase);
-            this.source += 0.3 * (saw - this.source);
-            const excitation = this.source * this.voiced + this.nextRandom() * this.noise * 0.6;
-            let filtered = 0;
-            for (let band = 0; band < 4; band++) {
-                filtered += (this.gains[band] ?? 0) * (this.filters[band]?.step(excitation) ?? 0);
-            }
-            const dc = filtered - this.dcIn + 0.995 * this.dcOut;
-            this.dcIn = filtered;
-            this.dcOut = dc;
-            const target = (segment.rampIn && local < attack ? local / attack : 1) *
-                (segment.rampOut && segment.frames - local < release ? (segment.frames - local) / release : 1);
-            this.envelope += 0.2 * (target - this.envelope);
-            buffer[i] = Math.tanh(dc * 7) * this.level * this.envelope;
-        }
-    }
-}
-const LEVEL_TARGET = { vowel: 0.3, nasal: 0.22, glide: 0.26 };
-function levelGain(segment, block, sung) {
-    const kind = TIMBRES[segment.phoneme].kind;
-    if ((kind !== "vowel" && kind !== "nasal" && kind !== "glide") || TIMBRES[segment.phoneme].voiced === 0)
-        return 1;
-    let sum = 0;
-    for (let i = 0; i < block.length; i++)
-        sum += (block[i] ?? 0) ** 2;
-    const rms = Math.sqrt(sum / Math.max(1, block.length));
-    if (rms < 1e-4)
-        return 1;
-    const ratio = (LEVEL_TARGET[kind] * segment.amplitude) / rms;
-    return Math.min(2, Math.max(0.5, ratio ** (sung ? 0.85 : 0.5)));
-}
-function applyLevel(block, gain, previousGain, ramp, volume) {
-    for (let i = 0; i < block.length; i++) {
-        const blend = i < ramp ? i / ramp : 1;
-        const g = previousGain + (gain - previousGain) * blend;
-        const value = (block[i] ?? 0) * g * volume;
-        block[i] = volume > 1 ? Math.tanh(value) : value;
-    }
-}
-export function* renderChunks(plan, options = {}) {
-    const renderer = new FormantRenderer(plan);
-    const ramp = Math.max(1, Math.round(plan.sampleRate * 0.006));
-    const sung = plan.vibratoDepth > 0;
-    let previousGain = 1;
-    for (const segment of plan.segments) {
-        checkAbort(options.signal);
-        const block = new Float32Array(segment.frames);
-        renderer.fill(block);
-        const gain = levelGain(segment, block, sung);
-        applyLevel(block, gain, previousGain, ramp, plan.volume);
-        previousGain = gain;
-        yield block;
-    }
-}
-export async function renderInto(plan, sink, options = {}) {
-    const renderer = new FormantRenderer(plan);
-    const ramp = Math.max(1, Math.round(plan.sampleRate * 0.006));
-    const sung = plan.vibratoDepth > 0;
-    const step = Math.max(1024, Math.round(plan.sampleRate / 4));
-    let previousGain = 1;
-    const fillFrom = async (block, offset) => {
-        if (offset >= block.length)
-            return;
-        renderer.fill(block.subarray(offset, Math.min(block.length, offset + step)));
-        await yieldToEventLoop();
-        checkAbort(options.signal);
-        return fillFrom(block, offset + step);
-    };
-    const next = async (index) => {
-        const segment = plan.segments[index];
-        if (segment === undefined)
-            return;
-        checkAbort(options.signal);
-        const block = new Float32Array(segment.frames);
-        await fillFrom(block, 0);
-        const gain = levelGain(segment, block, sung);
-        applyLevel(block, gain, previousGain, ramp, plan.volume);
-        previousGain = gain;
-        sink(block);
-        return next(index + 1);
-    };
-    await next(0);
-}
-export function renderPlan(plan, options = {}) {
-    const pcm = new Float32Array(plan.frames);
-    let offset = 0;
-    for (const chunk of renderChunks(plan, options)) {
-        pcm.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return pcm;
-}
-export function encodePlanSync(plan, options = {}) {
-    const out = new Uint8Array(44 + plan.frames * 2);
-    out.set(wavHeader(plan.frames, plan.sampleRate));
-    let offset = 44;
-    for (const chunk of renderChunks(plan, options)) {
-        encodePcm16(chunk, out, offset);
-        offset += chunk.length * 2;
-    }
-    return out;
-}
-export async function encodePlan(plan, options = {}) {
-    const out = new Uint8Array(44 + plan.frames * 2);
-    out.set(wavHeader(plan.frames, plan.sampleRate));
-    let offset = 44;
-    await renderInto(plan, (chunk) => {
-        encodePcm16(chunk, out, offset);
-        offset += chunk.length * 2;
-    }, options);
-    return out;
-}
-export function planRequest(request, sampleRate) {
-    return request.kind === "speech" ? planSpeech(request, sampleRate) : planSong(request, sampleRate);
-}
-export function renderFormantSync(request, sampleRate, options = {}) {
-    return encodePlanSync(planRequest(request, sampleRate), options);
-}
-export async function renderFormant(request, sampleRate, options = {}) {
-    return encodePlan(planRequest(request, sampleRate), options);
-}
-//# sourceMappingURL=formant.js.map