@kongyo2/kongyoroid 1.0.0

package/dist/formant.js

@@ -0,0 +1,622 @@
+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