retrotalk 2.1.0

package/dist/retrotalk.js

@@ -0,0 +1,2108 @@
+/*! RetroTalk v2.1.0 | MIT License | https://github.com/harayoki/retrotalk */
+(() => {
+  // src/simple_audio.js
+  var SimpleAudio = class {
+    /**
+     * @param {AudioContext} ctx 呼び出し側で作った AudioContext。
+     *   これが無いと再生できません（`unlock()` を参照）
+     * @param {object} [opts]
+     * @param {number} [opts.maxVoices=8] 同時に再生できる音の数
+     */
+    constructor(ctx, opts = {}) {
+      this.ctx = ctx || null;
+      this.seVoices = [];
+      this.maxVoices = opts.maxVoices ?? 8;
+      this.bgmVoices = 0;
+      this._seSeq = 0;
+      this._sePausedAll = false;
+      this._keepSec = 0;
+    }
+    /**
+     * 再生できる状態にします。
+     *
+     * ユーザーがページを一度操作したあとに呼びます。ブラウザの制限によるものです。
+     * `talk()` と `playTalk()` は内部で呼ぶので、通常は呼び出す必要がありません。
+     *
+     * AudioContext はここでは作りません。呼び出し側で作って渡してください。
+     *
+     * ```js
+     * const voice = new TalkAudio(new AudioContext());
+     * ```
+     *
+     * ブラウザが同時に作れる AudioContext の数には上限があり、
+     * ライブラリがそれぞれ勝手に作ると足りなくなります。
+     *
+     * @throws {Error} AudioContext が渡されていないとき
+     */
+    unlock() {
+      if (!this.ctx) {
+        throw new Error("SimpleAudio: AudioContext を渡してください — new TalkAudio(new AudioContext())");
+      }
+      if (this.ctx.state === "suspended") this.ctx.resume();
+    }
+    /**
+     * 出力の記録を開始します。継承先が実装します。
+     * `_out()` から呼ばれるため、ここでは空のまま用意してあります
+     */
+    _startTap() {
+    }
+    /** 再生が終わった音を片づける */
+    _cleanupSE(now) {
+      this.seVoices = this.seVoices.filter((v) => {
+        if (now < v.endTime) return true;
+        if (v.left !== 0 && v.timer) return true;
+        if (!v.system && (v.paused || this._sePausedAll)) return true;
+        if (v.timer) {
+          clearTimeout(v.timer);
+          v.timer = 0;
+        }
+        try {
+          v.gain.disconnect();
+        } catch (e) {
+        }
+        return false;
+      });
+    }
+    /** 再生中の音の数 */
+    _usedVoices() {
+      return this.bgmVoices + this.seVoices.reduce((n, v) => n + v.voices, 0);
+    }
+    /** 音を 1 つ止める */
+    _stopVoice(v) {
+      if (v.timer) {
+        clearTimeout(v.timer);
+        v.timer = 0;
+      }
+      v.left = 0;
+      for (const n of v.nodes) {
+        try {
+          n.stop(0);
+        } catch (e) {
+        }
+      }
+      try {
+        v.gain.disconnect();
+      } catch (e) {
+      }
+      this.seVoices = this.seVoices.filter((x) => x !== v);
+    }
+    /**
+     * 音の出力先を返します。すべての音がここを通るため、
+     * ここ 1 か所で全体の消音と音量を扱えます
+     */
+    _out() {
+      if (!this.ctx) return null;
+      if (!this._bus) {
+        this._master = this.ctx.createGain();
+        this._master.gain.value = this._muted ? 0 : this.volume;
+        this._master.connect(this.ctx.destination);
+        this._bus = this.ctx.createGain();
+        this._bus.gain.value = 1;
+        this._bus.connect(this._master);
+        if (this._keepSec > 0) this._startTap(this._keepSec);
+      }
+      return this._bus;
+    }
+    /**
+     * 消音します。再生は止めずに出力だけを閉じるので、
+     * 戻したときは続きから聞こえます。
+     *
+     * @param {boolean} [on] 省略すると切り替えます
+     * @returns {boolean} いま消音しているか
+     */
+    mute(on) {
+      this._muted = on === void 0 ? !this._muted : !!on;
+      this._out();
+      const out = this._master;
+      if (out) {
+        const t = this.ctx.currentTime;
+        out.gain.cancelScheduledValues(t);
+        out.gain.setValueAtTime(out.gain.value, t);
+        out.gain.linearRampToValueAtTime(this._muted ? 0 : this.volume, t + 0.05);
+      }
+      return this._muted;
+    }
+    /**
+     * 音量です。0 〜 8 で、初期値は 1 です。
+     *
+     * 1 を超えると増幅します。上げすぎると歪むので、聞きながら決めてください。
+     * 消音は `mute()` の役目で、このプロパティは音量だけを扱います。
+     */
+    get volume() {
+      return this._vol == null ? 1 : this._vol;
+    }
+    set volume(v) {
+      this._vol = Math.max(0, Math.min(8, Number(v) || 0));
+      if (this._master && !this._muted) {
+        const t = this.ctx.currentTime;
+        this._master.gain.cancelScheduledValues(t);
+        this._master.gain.setValueAtTime(this._master.gain.value, t);
+        this._master.gain.linearRampToValueAtTime(this._vol, t + 0.05);
+      }
+    }
+    /** いま消音しているか */
+    get muted() {
+      return !!this._muted;
+    }
+  };
+
+  // src/kana.js
+  var KANA = {
+    ア: ["", "a"],
+    イ: ["", "i"],
+    ウ: ["", "u"],
+    エ: ["", "e"],
+    オ: ["", "o"],
+    カ: ["k", "a"],
+    キ: ["k", "i"],
+    ク: ["k", "u"],
+    ケ: ["k", "e"],
+    コ: ["k", "o"],
+    ガ: ["g", "a"],
+    ギ: ["g", "i"],
+    グ: ["g", "u"],
+    ゲ: ["g", "e"],
+    ゴ: ["g", "o"],
+    サ: ["s", "a"],
+    シ: ["sh", "i"],
+    ス: ["s", "u"],
+    セ: ["s", "e"],
+    ソ: ["s", "o"],
+    ザ: ["z", "a"],
+    ジ: ["j", "i"],
+    ズ: ["z", "u"],
+    ゼ: ["z", "e"],
+    ゾ: ["z", "o"],
+    タ: ["t", "a"],
+    チ: ["ch", "i"],
+    ツ: ["ts", "u"],
+    テ: ["t", "e"],
+    ト: ["t", "o"],
+    ダ: ["d", "a"],
+    ヂ: ["j", "i"],
+    ヅ: ["z", "u"],
+    デ: ["d", "e"],
+    ド: ["d", "o"],
+    ナ: ["n", "a"],
+    ニ: ["n", "i"],
+    ヌ: ["n", "u"],
+    ネ: ["n", "e"],
+    ノ: ["n", "o"],
+    ハ: ["h", "a"],
+    ヒ: ["h", "i"],
+    フ: ["f", "u"],
+    ヘ: ["h", "e"],
+    ホ: ["h", "o"],
+    バ: ["b", "a"],
+    ビ: ["b", "i"],
+    ブ: ["b", "u"],
+    ベ: ["b", "e"],
+    ボ: ["b", "o"],
+    パ: ["p", "a"],
+    ピ: ["p", "i"],
+    プ: ["p", "u"],
+    ペ: ["p", "e"],
+    ポ: ["p", "o"],
+    マ: ["m", "a"],
+    ミ: ["m", "i"],
+    ム: ["m", "u"],
+    メ: ["m", "e"],
+    モ: ["m", "o"],
+    ヤ: ["y", "a"],
+    ユ: ["y", "u"],
+    ヨ: ["y", "o"],
+    ラ: ["r", "a"],
+    リ: ["r", "i"],
+    ル: ["r", "u"],
+    レ: ["r", "e"],
+    ロ: ["r", "o"],
+    ワ: ["w", "a"],
+    ヲ: ["", "o"],
+    ン: ["", "n"],
+    // 小書きの「ヮ」。「クヮ」は本来 1 拍ですが、唇を丸めた k は用意していません。
+    // ワ と同じ 1 拍として扱い、`( )` でくくれば 1 拍として歌えます
+    ヮ: ["w", "a"],
+    // 古い仮名。いまは イ エ と同じに読みます。飛ばしても得は無く、
+    // 読めるようにしておけば古い綴りの詞をそのまま渡せます
+    ヰ: ["", "i"],
+    ヱ: ["", "e"],
+    ヴ: ["b", "u"]
+  };
+  var SMALL = { ャ: "a", ュ: "u", ョ: "o", ァ: "a", ィ: "i", ゥ: "u", ェ: "e", ォ: "o" };
+  var PALATAL_SMALL = "ャュョ";
+  function applySmall(out, ch) {
+    if (!out.length) return;
+    const last = out[out.length - 1];
+    if (PALATAL_SMALL.includes(ch) && last.v === "i") last.pal = true;
+    last.v = SMALL[ch];
+  }
+  var DIGITS = {
+    0: "ゼロ",
+    1: "イチ",
+    2: "ニ",
+    3: "サン",
+    4: "ヨン",
+    5: "ゴ",
+    6: "ロク",
+    7: "ナナ",
+    8: "ハチ",
+    9: "キュウ"
+  };
+  var LATIN = {
+    A: "エー",
+    B: "ビー",
+    C: "シー",
+    D: "ディー",
+    E: "イー",
+    F: "エフ",
+    G: "ジー",
+    H: "エイチ",
+    I: "アイ",
+    J: "ジェー",
+    K: "ケー",
+    L: "エル",
+    M: "エム",
+    N: "エヌ",
+    O: "オー",
+    P: "ピー",
+    Q: "キュー",
+    R: "アール",
+    S: "エス",
+    T: "ティー",
+    U: "ユー",
+    V: "ブイ",
+    W: "ダブリュー",
+    X: "エックス",
+    Y: "ワイ",
+    Z: "ゼット"
+  };
+  function toHalf(ch) {
+    return ch >= "０" && ch <= "９" || ch >= "Ａ" && ch <= "Ｚ" || ch >= "ａ" && ch <= "ｚ" ? String.fromCharCode(ch.charCodeAt(0) - 65248) : ch;
+  }
+  function readingOf(ch) {
+    const half = toHalf(ch);
+    return DIGITS[half] || LATIN[half.toUpperCase()] || null;
+  }
+  function toKatakana(text) {
+    return text.replace(/[ぁ-ゖ]/g, (c) => String.fromCharCode(c.charCodeAt(0) + 96));
+  }
+  function checkTalk(text) {
+    const s = toKatakana(String(text));
+    const unknown = [];
+    let kana = 0;
+    for (let i = 0; i < s.length; i++) {
+      const ch = s[i];
+      if (KANA[ch] || SMALL[ch] || ch === "ー" || ch === "ッ") {
+        kana++;
+        continue;
+      }
+      const said = readingOf(ch);
+      if (said) {
+        kana += [...said].filter((c) => !SMALL[c] && c !== "ー").length;
+        continue;
+      }
+      if (" 　、，。！!？?…〜~".includes(ch)) continue;
+      if ("()（）".includes(ch)) continue;
+      if (ch === "." && s.slice(i, i + 3) === "...") {
+        i += 2;
+        continue;
+      }
+      if ("><＞＜".includes(ch)) continue;
+      if ("'‘’＇/+;^＾_＿".includes(ch)) continue;
+      if (ch === "\n" || ch === "\r" || ch === "	") continue;
+      if (ch === "@") {
+        const k = s[i + 1];
+        let j = i + 2;
+        while (j < s.length && s[j] >= "0" && s[j] <= "9") j++;
+        if (j > i + 2 && "psvPSV".includes(k)) {
+          i = j - 1;
+          continue;
+        }
+      }
+      const kind = /[\u4e00-\u9fff\u3005]/.test(ch) ? "kanji" : "other";
+      unknown.push({ ch, at: i, kind });
+    }
+    return { ok: unknown.length === 0, kana, unknown };
+  }
+  function parseTalk(text) {
+    const s = toKatakana(String(text));
+    const out = [];
+    let pendingStop = false;
+    let pendingVoiced = false;
+    let group = 0;
+    let lift = false;
+    for (let i = 0; i < s.length; i++) {
+      const ch = s[i];
+      if (ch === "ー") {
+        if (out.length) out[out.length - 1].hold += 1;
+        continue;
+      }
+      if (ch === "〜" || ch === "~") {
+        if (out.length) {
+          out[out.length - 1].hold += 1;
+          out[out.length - 1].wave = true;
+        }
+        continue;
+      }
+      if (ch === "ッ") {
+        pendingStop = true;
+        continue;
+      }
+      if (ch === "^" || ch === "＾") {
+        pendingVoiced = true;
+        continue;
+      }
+      if (ch === "(" || ch === "（") {
+        group = 1;
+        lift = true;
+        continue;
+      }
+      if (ch === ")" || ch === "）") {
+        group = 0;
+        lift = false;
+        continue;
+      }
+      if (ch === "@") {
+        const k2 = s[i + 1];
+        let j = i + 2, n = "";
+        while (j < s.length && s[j] >= "0" && s[j] <= "9") n += s[j++];
+        i = j - 1;
+        const kind = { p: "pitch", s: "speed", v: "vol" }[String(k2).toLowerCase()];
+        if (n && kind) {
+          const val = kind === "speed" ? +n / 100 : kind === "vol" ? Math.max(0, Math.min(15, +n)) / 15 : +n;
+          out.push({ pause: 1e-4, set: { [kind]: val } });
+        }
+        continue;
+      }
+      if (ch === ">" || ch === "＞") {
+        out.push({ pause: 1e-4, tune: 1 });
+        continue;
+      }
+      if (ch === "<" || ch === "＜") {
+        out.push({ pause: 1e-4, tune: -1 });
+        continue;
+      }
+      if (SMALL[ch]) {
+        applySmall(out, ch);
+        continue;
+      }
+      if (ch === " " || ch === "　" || ch === "_" || ch === "＿") {
+        out.push({ pause: 0.12 });
+        continue;
+      }
+      if (ch === "、" || ch === "，") {
+        out.push({ pause: 0.12, brk: true, mark: "," });
+        continue;
+      }
+      if ("。！!？?…".includes(ch) || ch === "." && s.slice(i, i + 3) === "...") {
+        const norm = (c) => c === "！" ? "!" : c === "？" ? "?" : c;
+        const a = norm(ch), b = norm(s[i + 1] || "");
+        let mark;
+        if (a === "!" && b === "?" || a === "?" && b === "!") {
+          mark = "!?";
+          i++;
+        } else if (a === "…") mark = "…";
+        else if (a === ".") {
+          mark = "…";
+          i += 2;
+        } else mark = a === "!" ? "!" : a === "?" ? "?" : ".";
+        if (mark === "…") while (s[i + 1] === "…") i++;
+        out.push({ pause: mark === "…" ? 0.42 : 0.24, brk: true, mark });
+        continue;
+      }
+      const said = readingOf(ch);
+      if (said) {
+        for (const c of said) {
+          if (c === "ー") {
+            if (out.length) out[out.length - 1].hold += 1;
+            continue;
+          }
+          if (c === "ッ") {
+            pendingStop = true;
+            continue;
+          }
+          if (SMALL[c]) {
+            applySmall(out, c);
+            continue;
+          }
+          const kk = KANA[c];
+          out.push({
+            c: kk[0],
+            v: kk[1],
+            hold: 0,
+            stop: pendingStop,
+            ...pendingVoiced ? { devoice: false } : null
+          });
+          pendingStop = false;
+          pendingVoiced = false;
+        }
+        continue;
+      }
+      const k = KANA[ch];
+      if (!k) continue;
+      out.push({
+        c: k[0],
+        v: k[1],
+        hold: 0,
+        stop: pendingStop,
+        tie: group > 1,
+        lift,
+        ...pendingVoiced ? { devoice: false } : null
+      });
+      if (group) group++;
+      pendingStop = false;
+      pendingVoiced = false;
+    }
+    return out;
+  }
+
+  // src/aquestalk.js
+  var STEP = 4;
+  var AFTER = -1;
+  var BREAKS = "、,;";
+  var LONG_PAUSE = 0.25;
+  var ENDS = "。？?！!";
+  var tidy = (s) => String(s).replace(/[\u2018\u2019\uff07]/g, "'").replace(/\r\n?/g, "\n");
+  var kanaOnly = (s, strict = true) => s.replace(
+    strict ? /['\/_\u301c\uff5e><\uff1e\uff1c]/g : /['\/]/g,
+    ""
+  );
+  function moraCount(kana) {
+    return parseTalk(kanaOnly(kana)).filter((m) => !m.pause && !m.set && !m.tune).length;
+  }
+  function accentPhrase(moras, acc, tune) {
+    const out = [];
+    let n = 0;
+    const to = (want) => {
+      while (tune < want) {
+        out.push({ pause: 1e-4, tune: 1 });
+        tune++;
+      }
+      while (tune > want) {
+        out.push({ pause: 1e-4, tune: -1 });
+        tune--;
+      }
+    };
+    for (const m of moras) {
+      if (m.pause || m.set || m.tune) {
+        out.push(m);
+        continue;
+      }
+      if (n === 0) to(acc === 1 ? STEP : 0);
+      else if (n === 1) to(acc === 1 ? AFTER : STEP);
+      else if (acc > 1 && n === acc) to(AFTER);
+      out.push(m);
+      n++;
+    }
+    return { moras: out, tune };
+  }
+  function phrase(src, tune, strict = true) {
+    const moras = parseTalk(kanaOnly(src, strict));
+    const at = src.indexOf("'");
+    if (!strict && at < 0) {
+      const out = [];
+      while (tune > 0) {
+        out.push({ pause: 1e-4, tune: -1 });
+        tune--;
+      }
+      while (tune < 0) {
+        out.push({ pause: 1e-4, tune: 1 });
+        tune++;
+      }
+      out.push(...moras);
+      return { moras: out, tune: 0 };
+    }
+    const acc = at < 0 ? 0 : moraCount(src.slice(0, at));
+    const off = /* @__PURE__ */ new Set();
+    for (let i = 0; i < src.length; i++) {
+      if (src[i] === "_") off.add(moraCount(src.slice(0, i)));
+    }
+    let n = 0;
+    const marked = strict ? moras.map((m) => m.pause || m.set || m.tune ? m : { ...m, devoice: off.has(n++) }) : moras;
+    return accentPhrase(marked, acc, tune);
+  }
+  function parseAqua(text, opts = {}) {
+    const strict = opts.strict !== false;
+    const src = tidy(text);
+    const out = [];
+    let tune = 0;
+    let buf = "";
+    const flush = (sep) => {
+      if (buf.trim()) {
+        const got = phrase(buf, tune, strict);
+        out.push(...got.moras);
+        tune = got.tune;
+      }
+      buf = "";
+      if (sep) {
+        if (ENDS.includes(sep)) tune = 0;
+        if (sep === ";") out.push({ pause: LONG_PAUSE, brk: true, mark: "," });
+        else out.push(...parseTalk(strict && ENDS.includes(sep) ? "。" : sep));
+      }
+    };
+    for (const ch of src) {
+      if (ch === "/") {
+        flush("");
+        continue;
+      }
+      if (ch === "+") continue;
+      if (ch === ";") {
+        flush(";");
+        continue;
+      }
+      if (BREAKS.includes(ch)) {
+        flush(ch);
+        continue;
+      }
+      if (ENDS.includes(ch)) {
+        flush(ch === "?" ? "？" : ch === "!" ? "！" : ch);
+        continue;
+      }
+      if (ch === " " || ch === "　" || ch === "\n") {
+        flush(" ");
+        continue;
+      }
+      buf += ch;
+    }
+    flush("");
+    return out;
+  }
+  function checkAqua(text) {
+    let plain = "";
+    for (const ch of tidy(text)) {
+      if (ch === "\n") {
+        plain += " ";
+        continue;
+      }
+      if (ch === "/" || ch === "_" || ch === "'" || ch === "+") continue;
+      plain += BREAKS.includes(ch) ? "、" : ch;
+    }
+    return checkTalk(plain);
+  }
+
+  // src/voicevox.js
+  function queries(data) {
+    const talk = data && data.talk;
+    if (talk && talk.audioItems) {
+      const keys = talk.audioKeys || Object.keys(talk.audioItems);
+      return keys.map((k) => talk.audioItems[k]).filter((it) => it && it.query).map((it) => it.query);
+    }
+    if (data && (data.accentPhrases || data.accent_phrases)) return [data];
+    return [];
+  }
+  var moraSec = (mo) => (+mo.consonantLength || +mo.consonant_length || 0) + (+mo.vowelLength || +mo.vowel_length || 0);
+  var pick = (o, a, b, def) => {
+    const v = o[a] ?? o[b];
+    return v === void 0 || v === null ? def : v;
+  };
+  function flatten(list, meta) {
+    const out = [];
+    for (const q of list) {
+      const speedScale = meta ? +pick(q, "speedScale", "speed_scale", 1) || 1 : 1;
+      const pitchScale = meta ? +pick(q, "pitchScale", "pitch_scale", 0) || 0 : 0;
+      const intoScale = meta ? +pick(q, "intonationScale", "intonation_scale", 1) : 1;
+      const pauseScale = meta ? +pick(q, "pauseLengthScale", "pause_length_scale", 1) || 1 : 1;
+      const pre = meta ? +pick(q, "prePhonemeLength", "pre_phoneme_length", 0) || 0 : 0;
+      const post = meta ? +pick(q, "postPhonemeLength", "post_phoneme_length", 0) || 0 : 0;
+      const phrases = q.accentPhrases || q.accent_phrases || [];
+      const said = [];
+      for (const ph of phrases) {
+        for (const mo of ph.moras || []) if (+mo.pitch > 0) said.push(+mo.pitch);
+      }
+      const mid = said.length ? said.reduce((a, b) => a + b, 0) / said.length : 0;
+      const into = intoScale >= 0 ? intoScale : 1;
+      if (pre > 0) out.push({ gap: pre / speedScale });
+      for (const ph of phrases) {
+        const moras = ph.moras || [];
+        for (const mo of moras) {
+          const p = +mo.pitch || 0;
+          out.push({
+            kana: String(mo.text || ""),
+            // `pitchScale` はオクターブなので、対数へ直してから足す
+            pitch: p > 0 ? mid + (p - mid) * into + pitchScale * Math.LN2 : 0,
+            sec: moraSec(mo) / speedScale
+          });
+        }
+        const pau = ph.pauseMora || ph.pause_mora;
+        if (pau) out.push({ gap: moraSec(pau) * pauseScale / speedScale });
+      }
+      if (post > 0) out.push({ gap: post / speedScale });
+      out.push({ end: true });
+    }
+    return out;
+  }
+  function voicevoxText(src, opts = {}) {
+    let data = src;
+    if (typeof data === "string") {
+      try {
+        data = JSON.parse(data);
+      } catch (e) {
+        data = null;
+      }
+    }
+    const list = queries(data);
+    if (!list.length) {
+      console.warn("[RetroTalk] VOICEVOX の読みが見つかりません(.vvproj の talk か、/audio_query の返しを渡してください)");
+      return "";
+    }
+    const usePitch = opts.usePitch !== false;
+    const useLength = opts.useLength !== false;
+    const flat = flatten(list, opts.useMeta !== false);
+    const base0 = +opts.speed > 0 ? +opts.speed : 1;
+    const secs = flat.filter((f) => f.sec > 0).map((f) => f.sec);
+    const midSec = secs.length ? secs.reduce((a, b) => a + b, 0) / secs.length : 0;
+    const toHz = (p) => Math.max(50, Math.min(800, Math.round(Math.exp(p))));
+    const toSpeed = (sec) => Math.round(100 * Math.max(0.6, Math.min(
+      1.8,
+      base0 * Math.sqrt(midSec / sec)
+    )));
+    let out = "";
+    let speed = Math.round(base0 * 100);
+    let hz = 0;
+    for (const f of flat) {
+      if (f.end) {
+        out += "。";
+        continue;
+      }
+      if (f.gap !== void 0) {
+        if (!useLength) out += "、";
+        else if (f.gap >= 0.2) out += "。";
+        else if (f.gap >= 0.08) out += "、";
+        else out += " ";
+        continue;
+      }
+      if (usePitch && f.pitch > 0 && toHz(f.pitch) !== hz) {
+        hz = toHz(f.pitch);
+        out += "@p" + hz;
+      }
+      if (useLength && midSec > 0 && f.sec > 0) {
+        const want = toSpeed(f.sec);
+        if (want !== speed) {
+          speed = want;
+          out += "@s" + speed;
+        }
+      }
+      out += f.kana;
+    }
+    return out.replace(/[、。 ]*。[、。 ]*/g, "。").replace(/[、 ]*、[、 ]*/g, "、").replace(/ +/g, " ").replace(/^[、。 ]+/, "").trim();
+  }
+  function voicevoxInfo(src) {
+    let data = src;
+    if (typeof data === "string") {
+      try {
+        data = JSON.parse(data);
+      } catch (e) {
+        data = null;
+      }
+    }
+    const list = queries(data);
+    let moras = 0;
+    for (const q of list) {
+      for (const ph of q.accentPhrases || q.accent_phrases || []) {
+        moras += (ph.moras || []).length;
+      }
+    }
+    return {
+      ok: list.length > 0 && moras > 0,
+      version: String(data && (data.appVersion || data.app_version) || ""),
+      lines: list.length,
+      moras
+    };
+  }
+  function parseVoicevox(src, opts = {}) {
+    return parseTalk(voicevoxText(src, opts));
+  }
+
+  // src/sing.js
+  var SEMI = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
+  function parseSing(mml) {
+    const src = String(mml).toLowerCase();
+    const notes = [];
+    const warn = [];
+    let octave = 4, defLen = 4, tempo = 120, pos = 0, vol = 1, q = 1;
+    const add = (list, what) => {
+      if (!list.includes(what)) list.push(what);
+    };
+    const readNumber = () => {
+      let n = "";
+      while (pos < src.length && src[pos] >= "0" && src[pos] <= "9") n += src[pos++];
+      return n === "" ? null : parseInt(n, 10);
+    };
+    const readDuration = () => {
+      const len = readNumber() ?? defLen;
+      let d = 240 / tempo / Math.max(1, len);
+      let dot = d;
+      while (src[pos] === ".") {
+        pos++;
+        dot /= 2;
+        d += dot;
+      }
+      return d;
+    };
+    while (pos < src.length) {
+      const ch = src[pos++];
+      if (" \n	\r|".includes(ch)) continue;
+      if (SEMI[ch] !== void 0) {
+        let semi = SEMI[ch];
+        while (src[pos] === "+" || src[pos] === "#") {
+          semi++;
+          pos++;
+        }
+        while (src[pos] === "-") {
+          semi--;
+          pos++;
+        }
+        const sec = readDuration();
+        const midi = (octave + 1) * 12 + semi;
+        notes.push({ hz: 440 * Math.pow(2, (midi - 69) / 12), sec, rest: false, vol, q });
+        continue;
+      }
+      if (ch === "r") {
+        notes.push({ hz: 0, sec: readDuration(), rest: true, vol, q: 1 });
+        continue;
+      }
+      if (ch === "&") {
+        while (pos < src.length && " \n	\r".includes(src[pos])) pos++;
+        if (SEMI[src[pos]] !== void 0 && notes.length) {
+          pos++;
+          while ("+#-".includes(src[pos])) pos++;
+          notes[notes.length - 1].sec += readDuration();
+        }
+        continue;
+      }
+      if (ch === "o") {
+        octave = Math.max(1, Math.min(8, readNumber() ?? octave));
+        continue;
+      }
+      if (ch === ">") {
+        octave = Math.min(8, octave + 1);
+        continue;
+      }
+      if (ch === "<") {
+        octave = Math.max(1, octave - 1);
+        continue;
+      }
+      if (ch === "l") {
+        defLen = readNumber() ?? defLen;
+        continue;
+      }
+      if (ch === "t") {
+        tempo = Math.max(20, readNumber() ?? tempo);
+        continue;
+      }
+      if (ch === "@") {
+        let kind = "";
+        if (src[pos] && src[pos] !== "{") kind = src[pos++];
+        if (src[pos] === "{") {
+          while (pos < src.length && src[pos] !== "}") pos++;
+          pos++;
+        } else readNumber();
+        add(warn, "@" + kind);
+        continue;
+      }
+      if (ch === "'") {
+        while (pos < src.length && src[pos] !== "'") pos++;
+        pos++;
+        readDuration();
+        add(warn, "'…'");
+        continue;
+      }
+      if (ch === "v") {
+        vol = Math.max(0, Math.min(15, readNumber() ?? 15)) / 15;
+        continue;
+      }
+      if (ch === "q") {
+        q = Math.max(0, Math.min(8, readNumber() ?? 8)) / 8;
+        continue;
+      }
+      if ("$p".includes(ch)) {
+        readNumber();
+        add(warn, ch);
+        continue;
+      }
+      if ("[]".includes(ch)) {
+        readNumber();
+        add(warn, ch);
+        continue;
+      }
+      add(warn, ch);
+    }
+    return { notes, warn };
+  }
+
+  // src/talk.js
+  var TICK = 1006e-7;
+  var RATE = Math.round(1 / TICK);
+  var FRAME = 0.01;
+  var P_MIN = 1;
+  var P_MAX = 128;
+  var FREQ_A = 136.2;
+  var FREQ_K = 0.0552;
+  var idxToHz = (idx) => FREQ_A * Math.exp(FREQ_K * idx);
+  var hzToIdx = (hz) => Math.log(hz / FREQ_A) / FREQ_K;
+  var F_HOME = [62, 0, 57, 47, 32];
+  var VOICED_STAGES = [1, 4, 3];
+  var B_HOME = [9, 4, 9, 9, 11];
+  var B_STEPS = 16;
+  var bposToBw = (pos) => 40 * Math.pow(30, pos / (B_STEPS - 1));
+  var B_VOICED = [3, 4.5, 6.5];
+  var B_NASAL = [3, 8, 9];
+  var B_BAR = [3, 13, 14];
+  var B_NASALIZED = [3, 7, 9];
+  var B_NOISE = [8, 9, 10];
+  var B_BURST = [12, 13, 13];
+  var B_PARK_NOISE = 15;
+  var SLEW_F = 6;
+  var SLEW_B = 4;
+  var SLEW_P = 2;
+  var TALK_STYLES = ["flat", "natural", "adsr", "vibrato"];
+  var SING = {
+    attack: 6,
+    // 立ち上がりに使うフレーム数
+    attackDrop: 5,
+    // 立ち上がりの頭で下げておく段数
+    decay: 10,
+    // 立ち上がったあと落ち着くまでのフレーム数
+    sustain: 1,
+    // 落ち着いたあと下げたままにする段数
+    release: 6,
+    // 切り際に使うフレーム数
+    releaseDrop: 4,
+    // 切り際で下げる段数
+    // 震えはじめるまで(フレーム)。短い音符では震えないのがこれ。
+    // 四分音符(t120 で 50 フレーム)の尻で震えだすと、音符ごとに尾を引いて
+    // 「震え」ではなく「ふらつき」に聞こえたので、伸ばす音まで待たせる
+    vibWait: 30,
+    vibRamp: 16,
+    // 震えが本気になるまで(フレーム)
+    vibHz: 4.5,
+    // 震える速さ。速いほど段の行き来が目立つので、少し遅く
+    // 震える幅(セント。半音の 100 分の 1)。
+    // 狭くしすぎると震えない。高さは P(周期の刻み)でしか持てないので、
+    // 幅が P の 1 目盛りに届かないと、2 つの値を行き来するだけの
+    // トリルになってしまう。45 セントで 4 段ほど動く(200Hz あたり)。
+    // 30 セントだと段を 2 つ行き来するだけで、震えではなくトリルに聞こえた
+    vibCents: 45
+  };
+  var NATURAL_DROP = 3;
+  var NATURAL_BEND = 0.7;
+  var NATURAL_HEAD = 0.6;
+  function pushBang(out, body, frames, attack) {
+    const tail = Math.max(1, Math.round(frames * (1 - 1 / BANG_LONG)));
+    const from = frames - tail;
+    const hold = Math.round(from * BANG_HOLD);
+    for (let k = 0; k < frames; k++) {
+      const t = k <= hold ? 0 : Math.min(1, (k - hold) / Math.max(1, attack));
+      let amp = body.amp + BANG_ATTACK * (1 - Math.pow(t, 0.6));
+      if (k >= from) amp -= BANG_TAIL_DROP * ((k - from + 1) / tail);
+      out.push({ ...body, amp: Math.max(1, amp), frames: 1 });
+    }
+  }
+  var BANG_ATTACK = 3;
+  var BANG_FRAMES = 5;
+  var BANG_HOLD = 0.5;
+  var BANG_LONG = 1.2;
+  var BANG_PRE_LONG = 1.4;
+  var BANG_TAIL_DROP = 6;
+  function pushDecay(out, body, frames) {
+    for (let k = 0; k < frames; k++) {
+      const t = k / Math.max(1, frames - 1);
+      const drop = NATURAL_DROP * Math.pow(t, NATURAL_BEND) + NATURAL_HEAD * Math.max(0, 1 - k / 2);
+      out.push({ ...body, amp: Math.max(1, body.amp - drop), frames: 1 });
+    }
+  }
+  var WAVE = {
+    hz: 4,
+    // 揺れる速さ
+    // 揺れる幅(セント)。歌の震え(30)より広い。言い方を表すものなので、
+    // はっきり揺れないと「伸ばしただけ」に聞こえる。
+    // 高さは周期の刻みでしか持てないので、高い声ほど段が粗くなる
+    cents: 60,
+    ramp: 5,
+    // 揺れが本気になるまで(フレーム)
+    sag: 2
+    // 終わりまでに落とす段数
+  };
+  function pushWave(out, body, frames, f0, frameSec) {
+    for (let k = 0; k < frames; k++) {
+      const depth = Math.min(1, (k + 1) / WAVE.ramp);
+      const cents = WAVE.cents * depth * Math.sin(2 * Math.PI * WAVE.hz * k * frameSec);
+      const P = Math.max(P_MIN, Math.min(
+        P_MAX,
+        Math.round(1 / (f0 * Math.pow(2, cents / 1200) * TICK))
+      ));
+      const drop = WAVE.sag * (k / Math.max(1, frames - 1));
+      out.push({ ...body, P, amp: Math.max(1, Math.round(body.amp - drop)), frames: 1 });
+    }
+  }
+  function tri(phase) {
+    const t = phase - Math.floor(phase);
+    return t < 0.5 ? 4 * t - 1 : 3 - 4 * t;
+  }
+  function pushSung(out, body, frames, f0, style) {
+    const { attackDrop, sustain, releaseDrop } = SING;
+    const attack = Math.max(1, Math.min(SING.attack, Math.floor(frames / 3)));
+    const release = Math.max(1, Math.min(SING.release, Math.floor(frames / 3)));
+    const decay = Math.max(1, Math.min(SING.decay, frames - attack - release));
+    for (let k = 0; k < frames; k++) {
+      let drop = 0;
+      if (k < attack) drop += attackDrop * (1 - (k + 1) / attack);
+      else if (k < attack + decay) drop += sustain * ((k - attack + 1) / decay);
+      else drop += sustain;
+      const left = frames - 1 - k;
+      if (left < release) drop += releaseDrop * (1 - left / release);
+      let P = body.P;
+      if (style === "vibrato" && k >= SING.vibWait) {
+        const depth = Math.min(1, (k - SING.vibWait) / SING.vibRamp);
+        const cents = SING.vibCents * depth * tri(SING.vibHz * (k - SING.vibWait) * (SING.frameSec || 0.01));
+        P = Math.max(P_MIN, Math.min(
+          P_MAX,
+          Math.round(1 / (f0 * Math.pow(2, cents / 1200) * TICK))
+        ));
+      }
+      out.push({ ...body, P, amp: Math.max(1, Math.round(body.amp - drop)), frames: 1 });
+    }
+  }
+  var NOISE_LEVEL = 0.2;
+  var SILENCE_DAMP = 0.94;
+  var F_SHIFT = 2;
+  var FV_LEVEL = 0.25;
+  var ASPIRATE = 9;
+  var ASPIRATE_FADE = 3;
+  var BAR_HZ1 = 200;
+  var BAR_AMP = 7;
+  var COART = 2;
+  var PAL = 2;
+  var PAL_NASAL_FRAMES = 6;
+  var ASSEMBLY = {
+    palNasalFrames: PAL_NASAL_FRAMES,
+    nasalAmp: null,
+    nasalTail: true,
+    nasalizedGlide: true,
+    glideAfterNasal: "ramp",
+    palF3: "vowel",
+    voicedBurstAmp: 12,
+    voicedBurstVoice: false,
+    voicedGap: "voice",
+    barAmp: BAR_AMP,
+    barBand: "bar"
+  };
+  var PALATAL_ALREADY = /* @__PURE__ */ new Set(["sh", "ch", "j", "y"]);
+  var palVoiced = (v) => [CONSONANTS2.y.hz[0], CONSONANTS2.y.hz[1], (VOWELS2[v] || VOWELS2.a)[2]];
+  var VOICELESS = /* @__PURE__ */ new Set(["k", "s", "t", "h", "p", "sh", "ch", "ts", "f"]);
+  var DEVOICED = 8;
+  var DEVOICED_FRAMES = 6;
+  var BANG_MARKS = /* @__PURE__ */ new Set(["!", "!?"]);
+  var LIFT_MARKS = /* @__PURE__ */ new Set(["!", "?", "!?"]);
+  function markDevoiced(moras) {
+    const out = moras.map(() => false);
+    let prev = -1;
+    let phrase2 = [];
+    const keepOne = () => {
+      if (!phrase2.length || phrase2.some((k) => !out[k])) return;
+      out[phrase2[phrase2.length - 1]] = false;
+    };
+    for (let i = 0; i < moras.length; i++) {
+      const m = moras[i];
+      if (m.set || m.tune) continue;
+      if (m.pause) {
+        keepOne();
+        phrase2 = [];
+        prev = -1;
+        continue;
+      }
+      const was = prev;
+      prev = i;
+      phrase2.push(i);
+      if (m.devoice !== void 0) {
+        out[i] = !!m.devoice;
+        continue;
+      }
+      if (m.v !== "i" && m.v !== "u") continue;
+      if (m.hold) continue;
+      if (!VOICELESS.has(m.c)) continue;
+      let j = i + 1;
+      while (j < moras.length && (moras[j].set || moras[j].tune)) j++;
+      const next = moras[j];
+      if (next && !next.pause && !VOICELESS.has(next.c)) continue;
+      if (next && next.pause && LIFT_MARKS.has(next.mark)) continue;
+      if (was >= 0 && out[was]) continue;
+      out[i] = true;
+    }
+    keepOne();
+    return out;
+  }
+  var VOWELS2 = {
+    a: [648, 1028, 2560],
+    i: [280, 2230, 3e3],
+    u: [320, 1300, 2200],
+    e: [470, 1900, 2550],
+    o: [520, 850, 2500],
+    n: [280, 1200, 2400]
+    // 撥音。鼻へ抜けるので弱く
+  };
+  var NASAL = {
+    m: [280, 1e3, 2200],
+    // 唇。マ行と同じところ
+    n: [280, 1500, 2500],
+    // 舌の先。ナ行と同じところ
+    ng: [280, 1900, 2300]
+    // 舌の奥。カ行と同じところ
+  };
+  function nasalFor(c) {
+    if (c === "m" || c === "p" || c === "b") return NASAL.m;
+    if (c === "k" || c === "g") return NASAL.ng;
+    if (c === "t" || c === "d" || c === "n" || c === "r" || c === "s" || c === "z" || c === "ts" || c === "ch" || c === "j" || c === "sh") return NASAL.n;
+    return VOWELS2.n;
+  }
+  var CONSONANTS2 = {
+    // カ行とタ行は、第 2 フォルマントがほとんど同じ。分けているのは第 3 のほう —
+    // 舌の奥で閉じる音(カ・ガ)は第 2 と第 3 が近寄り、
+    // 舌の先で閉じる音(タ・ダ)は第 3 が高いところから母音へ落ちてくる。
+    // その落ちる音が、息の漏れているあいだに聞こえる(`ASPIRATE`)。
+    // ここを 2500 と 2800 にしていたころは、3 つとも同じに聞こえた(2026-09-03)
+    k: {
+      kind: "burst",
+      closure: 6,
+      frames: 1,
+      gap: 3,
+      hz: [300, 1900, 2300],
+      hzBy: {
+        i: [300, 2900, 3300],
+        e: [300, 2500, 2900],
+        u: [300, 1300, 2200],
+        o: [300, 1200, 2300]
+      }
+    },
+    // 有声の破裂の一撃は、無声と同じ大きさ(12)で、ノイズだけ。
+    // 一度 14 で声も乗せていた(閉鎖が無音だったころ、「開いた」と分かるのが
+    // 一撃だけだったため)。いまは閉鎖に声があり(`BAR_AMP`)、開いたあとも
+    // 声がすぐ戻る(`gap` を有声で鳴らす)ので、一撃で「開いた」を言う必要が無い。
+    // 声を乗せた大きな一撃は、拗音でイ段の位置に置くと `ギュ` が `シュ` に聞こえた
+    // (2026-09-03)。人の声でも、有声の破裂の一撃は無声より弱い
+    g: {
+      kind: "burst",
+      closure: 4,
+      frames: 1,
+      gap: 1,
+      hz: [300, 1900, 2250],
+      voiced: true,
+      hzBy: {
+        i: [300, 2700, 3100],
+        e: [300, 2400, 2800],
+        u: [300, 1300, 2100],
+        o: [300, 1200, 2200]
+      }
+    },
+    // タ の息は 1 フレームだけ。破裂の一撃も、そのあとの息も、
+    // 高いところが鳴る(第 3 が 3400)。それを 30ms 続けると `サ` になる —
+    // 実際、母音のあとの `タ` が `サ` に聞こえていた(2026-09-03)。
+    // `サ` は 70ms 続くので、分けているのは長さ。20ms まで詰める
+    t: { kind: "burst", closure: 6, frames: 1, gap: 1, hz: [300, 1750, 3400] },
+    d: { kind: "burst", closure: 4, frames: 1, gap: 1, hz: [300, 1700, 3100], voiced: true },
+    p: { kind: "burst", closure: 6, frames: 1, gap: 1, hz: [300, 900, 2300] },
+    b: { kind: "burst", closure: 4, frames: 1, gap: 1, hz: [300, 900, 2200], voiced: true },
+    // サ行・シャ行は大きい。こすれる音のうち、この 2 つは山が高いところに
+    // あって母音と紛れないので、大きくしても母音へ溶けない(ハ行とは逆)。
+    // 既定(9)では母音より 11dB 下で、弱いと言われた(2026-09-03)
+    s: { kind: "noise", frames: 7, amp: 11, hz: [500, 3400, 4e3] },
+    z: { kind: "noise", frames: 4, hz: [400, 3e3, 3600], voiced: true },
+    sh: { kind: "noise", frames: 7, amp: 11, hz: [500, 2300, 3100] },
+    j: { kind: "noise", frames: 4, hz: [400, 2300, 3e3], voiced: true },
+    ch: { kind: "noise", closure: 4, frames: 5, gap: 1, hz: [500, 2400, 3400] },
+    ts: { kind: "burst", closure: 5, frames: 3, gap: 1, hz: [500, 3300, 3900] },
+    // ハ行は息だけの音なので、幅を広く取る(`wide`)。
+    //
+    // サ行と違って山が母音と同じあたりにあるので、狭い幅で鳴らすと
+    // ささやいた母音になる。実際「アハ」が「アア」と聞こえていた(2026-09-03)。
+    // 広げると帯ではなく息に聞こえる。
+    //
+    // 大きさを上げてはいけない。同じ形で母音に近い大きさにすると、
+    // ますますひと続きの母音になる(11 まで上げて悪くなった)
+    h: {
+      kind: "noise",
+      frames: 6,
+      wide: true,
+      hz: [600, 1500, 2400],
+      hzBy: { i: [300, 2800, 3300] }
+    },
+    // ヒ は口の前のほうでこすれる
+    f: { kind: "noise", frames: 6, wide: true, hz: [500, 1600, 2500] },
+    // 鼻に抜ける音は小さい。口を閉じていて、音は鼻からしか出ない。
+    // 有声の既定(11)のままだと母音とほとんど同じ大きさなので、
+    // 言葉の切れ目にならない — 「ギュウニュウ」が 490ms ぶっ通しで鳴って、
+    // 言葉というより効果音に聞こえた(2026-09-03)。母音より 5 段(12dB)下げる
+    // 鼻音は、はっきり鳴って長い。閉じているのは口だけで、鼻からは出ている。
+    // 有声の破裂音(閉鎖はほとんど無音)と分けているのはここなので、
+    // 弱くも短くもしない — 弱くすると破裂音に寄り、実際「ニュ」が
+    // 「ドゥ」に聞こえたことがある(2026-09-03)。
+    //
+    // 長さは触らない。「`ニュ` は `グ` より長い、短くできない」という
+    // 自分の口での確かめを受けて 60ms・80ms を試したが、
+    // どちらも「むしろ変」だった(2026-09-03)。
+    // 人の発声がそうでも、この音では不自然になる。40ms のまま。
+    //
+    // 拗音(`ニャ` `ニュ` `ニョ`)は渡りの位置で鳴らす(`palVoiced`)。
+    // ここに `hzBy: { i: [280, 2100, 2500] }` を置いて試したら、
+    // 鼻音が母音と同じ大きさになった(-5dB → +0.5dB。第 2 が 2kHz を越えると
+    // 置きっぱなしの 2 段と重なって明るくなる)。鼻音は暗く小さくなければならない
+    n: { kind: "voiced", frames: 4, amp: 10, nasal: true, hz: [280, 1500, 2500] },
+    m: { kind: "voiced", frames: 4, amp: 10, nasal: true, hz: [280, 1e3, 2300] },
+    r: { kind: "voiced", frames: 2, hz: [400, 1400, 1800] },
+    y: { kind: "voiced", frames: 3, hz: [300, 2100, 2900] },
+    w: { kind: "voiced", frames: 3, hz: [320, 800, 2200] }
+  };
+  var TALK_DEFAULTS = {
+    pitch: 280,
+    // 声の高さ(Hz)
+    pitchShift: 0,
+    // 文の中の `@p` ごと上げ下げする量(半音)
+    tuneStep: 1,
+    // `＞` `＜` 1 つで動く量(半音)
+    volume: 10,
+    // `@v` を書かなかったときの音量(0〜15)
+    volumeShift: 0,
+    // 文の中の `@v` ごと上げ下げする量(段。`@v` と同じ 0〜15 の目盛り)
+    speedShift: 1,
+    // 文の中の `@s` ごと掛ける倍率
+    speed: 1,
+    // しゃべる速さ
+    fall: 4,
+    // 語尾へ下がる量(半音)
+    rise: 1,
+    // 出だしで上がる量(半音)
+    formantShift: F_SHIFT,
+    bandShift: 0,
+    // 共鳴の鋭さ
+    breath: 0,
+    // 息の混じり
+    jitter: 0,
+    // 周期のゆらぎ
+    ring: 0,
+    // 掛け合わせる音の高さ(Hz)
+    interp: false,
+    // フレーム間を埋めるか
+    frame: FRAME,
+    // 1 フレームの長さ(秒)
+    bits: 0,
+    // 量子化のビット数(0 で無し)
+    style: "flat",
+    slewF: SLEW_F,
+    slewB: SLEW_B,
+    slewP: SLEW_P,
+    lag: 0,
+    lagPerMora: 0,
+    seed: 1,
+    gainNorm: true,
+    level: 0.15
+  };
+  var D = TALK_DEFAULTS;
+  function makeRandom(seed) {
+    let s = seed | 0 || 2654435769;
+    return () => {
+      s ^= s << 13;
+      s ^= s >>> 17;
+      s ^= s << 5;
+      return (s >>> 0) / 4294967296 * 2 - 1;
+    };
+  }
+  function toParams(hz, shift = 0) {
+    const p = [shift, shift, shift, shift, shift];
+    VOICED_STAGES.forEach((stage, k) => {
+      p[stage] = hzToIdx(hz[k]) - F_HOME[stage] + shift;
+    });
+    return p;
+  }
+  function toBpos(noise, wide, voicedKind) {
+    const bp = noise ? B_HOME.map(() => B_PARK_NOISE) : B_HOME.slice();
+    const table = noise ? wide ? B_BURST : B_NOISE : voicedKind === "nasal" ? B_NASAL : voicedKind === "bar" ? B_BAR : voicedKind === "nasalized" ? B_NASALIZED : B_VOICED;
+    VOICED_STAGES.forEach((stage, k) => {
+      bp[stage] = table[k];
+    });
+    return bp;
+  }
+  function buildTargets(moras, opts) {
+    const frame = opts.frame ?? D.frame;
+    const A = { ...ASSEMBLY, ...opts.assembly || {} };
+    const auto = opts.format !== "voicevox";
+    const fall = auto ? opts.fall ?? D.fall : 0;
+    const rise = auto ? opts.rise ?? D.rise : 0;
+    const out = [];
+    const pShift = Math.pow(2, (opts.pitchShift ?? D.pitchShift) / 12);
+    let pitch = (opts.pitch ?? D.pitch) * pShift;
+    const sMul = Math.max(0.05, opts.speedShift ?? D.speedShift);
+    const tuneStep = opts.tuneStep ?? D.tuneStep;
+    let speed = (opts.speed ?? D.speed) * sMul;
+    const vAdd = (opts.volumeShift ?? D.volumeShift) / 15;
+    let vol = Math.max(0, Math.min(15, opts.volume ?? D.volume)) / 15;
+    const withShift = (v) => Math.max(0, Math.min(1, v + vAdd));
+    const volOf = [];
+    let postGap = 0;
+    let tied = null, tiedShare = 0, tiedLeft = 0, tiedRest = 0;
+    const takeNote = (m, mi) => {
+      if (m.tie && tied) {
+        tiedLeft--;
+        const frames = tiedLeft > 0 ? tiedShare : tiedRest;
+        if (tiedLeft > 0) tiedRest -= tiedShare;
+        return { ...tied, frames, gap: tiedLeft > 0 ? 0 : tied.gap };
+      }
+      const raw = notes[noteAt++];
+      if (!raw) return null;
+      let n = 1;
+      for (let k = mi + 1; k < moras.length; k++) {
+        const q = moras[k];
+        if (q.set || q.tune) continue;
+        if (q.pause || !q.tie) break;
+        n++;
+      }
+      if (n < 2) {
+        tied = null;
+        return raw;
+      }
+      tiedShare = Math.max(1, Math.floor(raw.frames / (n + 1)));
+      tiedLeft = n - 1;
+      tiedRest = raw.frames - tiedShare;
+      tied = raw;
+      return { ...raw, frames: tiedShare, gap: 0 };
+    };
+    const perTick = D.frame / frame;
+    const nf = (n) => Math.max(1, Math.round(n * perTick / speed));
+    const nfSec = (sec) => Math.max(1, Math.round(sec / frame / speed));
+    const BANG_LIFT = 2;
+    const SHAPE = {
+      ".": { lift: 0, up: rise, down: fall },
+      // `！` は、最後の 1 字だけ上がる。そこまではふつうの文と同じに読む。
+      //
+      // 文まるごと持ち上げていたころは、出だしから裏返って聞こえた。
+      // 上がり下がりまで止めたら、こんどは手前がずっと平らになった
+      // (2026-09-04)。上げるのは尻(`TAIL_UP`)、手前は言い切る文と同じでよい。
+      // まるごと張りたいときは `（ ）` でくくる
+      "!": { lift: 0, up: rise, down: fall },
+      "?": { lift: 0, up: rise, down: fall },
+      // `！？` は文まるごとは上げない。上げると出だしから裏返って聞こえる —
+      // 「ソウナノ！？」の `ソ` からうわずっていた(2026-09-04)。
+      // 驚きは語尾で出す(下の `TAIL_UP`)
+      "!?": { lift: 0, up: rise, down: fall },
+      "…": { lift: 0, up: 0, down: fall * 1.3 }
+    };
+    const GROUP_SHAPE = {
+      "!": () => 0,
+      // 段々に上げない。くくった中はまるごと同じだけ上がる。
+      // 上げていくと、字を追うごとに高くなって階段に聞こえた(2026-09-05)
+      "?": () => Math.max(2, fall),
+      "!?": () => Math.max(2, fall)
+    };
+    const TAIL_UP = {
+      // `？` の 3 分の 1。張りと長さだけでは `。` と聞き分けられなかったが、
+      // `？` に近いところまで上げると尋ねているように聞こえる
+      "!": [Math.max(1, fall / 3)],
+      "?": [Math.max(2, fall)],
+      "!?": [Math.max(2, fall)]
+    };
+    const PUSH = { "!": 2, "!?": 3, "…": -2 };
+    let tune = 0;
+    const TUNE_MAX = 12;
+    const f0at = (t, mark, tail, flat) => {
+      const ups = TAIL_UP[mark];
+      if (ups && tail && tail <= ups.length) {
+        return pitch * Math.pow(2, (ups[ups.length - tail] + tune) / 12);
+      }
+      const sh = SHAPE[mark] || SHAPE["."];
+      const base = sh.lift + (flat ? t < 0.15 ? 0 : -sh.down * ((t - 0.15) / 0.85) : t < 0.15 ? sh.up * (t / 0.15) : sh.up - (sh.up + sh.down) * ((t - 0.15) / 0.85));
+      return pitch * Math.pow(2, (base + tune) / 12);
+    };
+    let notes = opts.notes || null;
+    if (!notes && opts.sing) {
+      const got = parseSing(opts.sing);
+      if (got.warn.length) {
+        console.warn("[RetroTalk] 歌の音符に読めないものがあります — " + got.warn.join(" ") + "(使えるのは cdefgab r + # - 数字 . l o > < t &)");
+      }
+      notes = got.notes.map((n) => {
+        const all = Math.max(1, Math.round(n.sec / frame));
+        const on = Math.max(1, Math.round(all * (n.q ?? 1)));
+        return { hz: n.hz, rest: n.rest, vol: n.vol, frames: on, gap: all - on };
+      });
+    }
+    const shift = opts.formantShift ?? D.formantShift;
+    let style = opts.style ?? D.style;
+    if (!TALK_STYLES.includes(style)) {
+      console.warn(`[RetroTalk] 音の形に ${style} はありません(${TALK_STYLES.join(" / ")})`);
+      style = "flat";
+    }
+    SING.frameSec = frame;
+    let noteAt = 0;
+    const ts = [];
+    const mk = [];
+    const tl = [];
+    {
+      let head = 0;
+      const spread = (end, mark) => {
+        const n = Math.max(1, end - head - 1);
+        for (let k = head; k < end; k++) {
+          ts[k] = (k - head) / n;
+          mk[k] = mark;
+        }
+        let seen = 0;
+        for (let k = end - 1; k >= head; k--) {
+          if (moras[k].pause || moras[k].set || moras[k].tune) continue;
+          tl[k] = ++seen;
+          if (seen >= 2) break;
+        }
+      };
+      for (let k = 0; k < moras.length; k++) {
+        if (!moras[k].brk) continue;
+        spread(k, moras[k].mark || ".");
+        ts[k] = 0;
+        mk[k] = moras[k].mark || ".";
+        head = k + 1;
+      }
+      spread(moras.length, ".");
+    }
+    const liftOf = [];
+    const preLong = [];
+    for (let k = 0; k < moras.length; k++) {
+      if (!moras[k].lift) continue;
+      let end = k;
+      while (end + 1 < moras.length && moras[end + 1].lift) end++;
+      let shape = null;
+      let gm = null;
+      for (let j = end + 1; j < moras.length; j++) {
+        const q = moras[j];
+        if (q.set || q.tune) continue;
+        if (q.pause) {
+          gm = q.mark;
+          shape = GROUP_SHAPE[q.mark] || null;
+        }
+        break;
+      }
+      if (BANG_MARKS.has(gm)) {
+        for (let j = k - 1; j >= 0; j--) {
+          const q = moras[j];
+          if (q.set || q.tune) continue;
+          if (q.pause) break;
+          preLong[j] = true;
+          break;
+        }
+      }
+      const at = [];
+      for (let j = k; j <= end; j++) if (!moras[j].pause && !moras[j].set) at.push(j);
+      for (const [n, j] of at.entries()) {
+        const u = at.length > 1 ? n / (at.length - 1) : 0.5;
+        liftOf[j] = { t: ts[k] ?? 0, up: shape ? shape(u) : 0, mark: gm };
+      }
+      k = end;
+    }
+    const devoiced = notes ? moras.map(() => false) : markDevoiced(moras);
+    let i = 0;
+    for (const m of moras) {
+      const mi = i++;
+      const t = ts[mi] ?? 0;
+      if (m.set) {
+        if (m.set.pitch > 0) pitch = m.set.pitch * pShift;
+        if (m.set.speed > 0) speed = m.set.speed * sMul;
+        if (m.set.vol !== void 0) vol = m.set.vol;
+        continue;
+      }
+      volOf[mi] = withShift(vol);
+      if (m.tune) {
+        tune = Math.max(-TUNE_MAX, Math.min(TUNE_MAX, tune + m.tune * tuneStep));
+        continue;
+      }
+      if (m.pause) {
+        if (m.brk) tune = 0;
+        out.push({ silent: true, frames: nfSec(m.pause), mora: mi, brk: !!m.brk });
+        continue;
+      }
+      const mark = mk[i - 1] || ".";
+      const g = liftOf[mi];
+      const bang = g ? mark === "!" && g.mark === "!" : BANG_MARKS.has(mark) && tl[i - 1] === 1;
+      const longBody = bang || g && g.mark === "!?";
+      const preBang = preLong[mi] || !g && BANG_MARKS.has(mark) && tl[i - 1] === 2;
+      if (postGap > 0) {
+        out.push({ silent: true, frames: postGap, mora: mi });
+        postGap = 0;
+      }
+      if (m.stop) out.push({ silent: true, frames: nf(6), mora: mi });
+      if (!m.tie) {
+        while (notes && notes[noteAt] && notes[noteAt].rest) {
+          out.push({ silent: true, frames: notes[noteAt++].frames, mora: mi });
+        }
+      }
+      const note = notes ? takeNote(m, mi) : null;
+      if (note && note.gap > 0) postGap = note.gap;
+      if (note && note.vol !== void 0) volOf[mi] = withShift(vol * note.vol);
+      const f0 = note ? note.hz : g ? g.up ? pitch * Math.pow(2, (g.up + tune) / 12) : f0at(g.t, mark, 0, true) : f0at(t, mark, tl[i - 1]);
+      const push = mark === "!" ? 0 : PUSH[mark] || 0;
+      const P = Math.max(P_MIN, Math.min(P_MAX, Math.round(1 / (f0 * TICK))));
+      const cons = CONSONANTS2[m.c];
+      const next = (() => {
+        for (let k = mi + 1; k < moras.length; k++) {
+          const q = moras[k];
+          if (q.set || q.tune) continue;
+          if (q.pause) return null;
+          return q;
+        }
+        return null;
+      })();
+      const vowel = m.v === "n" ? nasalFor(next && next.c) : VOWELS2[m.v] || VOWELS2.a;
+      const nextLocus = (() => {
+        if (!next) return null;
+        const c = CONSONANTS2[next.c];
+        if (!c || c.kind === "noise" || next.c === "ts") return null;
+        if (next.pal && !PALATAL_ALREADY.has(next.c) && (c.kind === "voiced" || c.voiced)) {
+          return A.palF3 === "y" ? CONSONANTS2.y.hz : palVoiced(next.v);
+        }
+        return c.hzBy && c.hzBy[next.pal ? "i" : next.v] || c.hz;
+      })();
+      const pal = !!m.pal && !!cons && !PALATAL_ALREADY.has(m.c);
+      const voicedCons = !!cons && (cons.kind === "voiced" || !!cons.voiced);
+      const vAmp = Math.min(15, (m.v === "n" ? 11 : 14) + push);
+      const palHz = voicedCons && A.palF3 !== "y" ? palVoiced(m.v) : CONSONANTS2.y.hz;
+      if (cons) {
+        const hz = pal && voicedCons && !cons.nasal ? palHz : cons.hzBy && cons.hzBy[pal ? "i" : m.v] || cons.hz;
+        const noise = cons.kind !== "voiced";
+        const barHz = cons.voiced && cons.closure ? [BAR_HZ1, hz[1], hz[2]] : hz;
+        if (cons.closure && cons.voiced) {
+          out.push({
+            hz: barHz,
+            param: toParams(barHz, shift),
+            bpos: toBpos(false, false, A.barBand),
+            P,
+            amp: A.barAmp,
+            voiced: true,
+            noise: false,
+            frames: nf(cons.closure),
+            mora: mi
+          });
+        } else if (cons.closure) {
+          out.push({
+            silent: true,
+            frames: nf(cons.closure),
+            mora: mi,
+            glideTo: hz,
+            glideNoise: noise
+          });
+        }
+        out.push({
+          hz: barHz,
+          param: toParams(barHz, shift),
+          bpos: toBpos(noise, cons.kind === "burst" || cons.wide, cons.nasal && "nasal"),
+          P,
+          // 表で `amp` を持っているものはそちら(ハ行・サ行・鼻音。理由は表に書いた)
+          amp: cons.nasal ? A.nasalAmp ?? cons.amp : cons.voiced && cons.kind === "burst" ? A.voicedBurstAmp : cons.amp ?? (cons.kind === "noise" ? 9 : cons.kind === "burst" ? 12 : 11),
+          // 有声の破裂の一撃は、ノイズだけ。声は閉鎖(`BAR_AMP`)と、
+          // 次のフレームからの戻りで聞こえる。一撃に声を乗せると、
+          // 拗音で高いところに置いたとき `シュ` に寄る(表の `g` に書いた)
+          voiced: cons.kind === "voiced" || !!cons.voiced && (cons.kind === "noise" || A.voicedBurstVoice),
+          noise,
+          // 有声摩擦音(実機の FV)だけ、声を薄くする。
+          // ここを「ノイズを通す有声フレーム全部」に掛けていたので、
+          // 有声の破裂音(ガ・ダ・バ)の一撃まで 4 分の 1 になっていた。
+          // 「ギュウニュウ」の頭が聞こえなかったのはこれ(2026-09-03)。
+          // ザ・ジャ は声が飛び出さないよう薄いままにする
+          fv: cons.kind === "noise" && !!cons.voiced,
+          // 拗音の鼻音だけ長い(`PAL_NASAL_FRAMES`)。最後の 1 フレームは下で別に置く
+          frames: nf(pal && cons.nasal ? A.palNasalFrames - (A.nasalTail ? 1 : 0) : cons.frames),
+          mora: mi
+        });
+        if (pal && cons.nasal && A.nasalTail) {
+          const tail = [barHz[0], palHz[1], palHz[2]];
+          out.push({
+            hz: tail,
+            param: toParams(tail, shift),
+            bpos: toBpos(false, false, "nasal"),
+            P,
+            amp: A.nasalAmp ?? cons.amp ?? 11,
+            voiced: true,
+            noise: false,
+            frames: 1,
+            mora: mi
+          });
+        }
+        const after = pal ? palHz : vowel;
+        if (cons.gap && cons.voiced && A.voicedGap === "silent") {
+          out.push({ silent: true, frames: nf(cons.gap), glideTo: after, mora: mi });
+        } else if (cons.gap && cons.voiced) {
+          out.push({
+            hz: after,
+            param: toParams(after, shift),
+            bpos: toBpos(false),
+            P,
+            amp: Math.max(1, vAmp - 2),
+            voiced: true,
+            noise: false,
+            frames: nf(cons.gap),
+            mora: mi
+          });
+        } else if (cons.gap) {
+          for (let k = 0; k < nf(cons.gap); k++) {
+            out.push({
+              hz: after,
+              param: toParams(after, shift),
+              bpos: toBpos(true, true),
+              P,
+              amp: Math.max(1, ASPIRATE - ASPIRATE_FADE * k),
+              voiced: false,
+              noise: true,
+              frames: 1,
+              mora: mi
+            });
+          }
+        }
+      }
+      const dev = devoiced[mi];
+      const body = dev ? {
+        hz: vowel,
+        param: toParams(vowel, shift),
+        bpos: toBpos(true, true),
+        P,
+        amp: DEVOICED,
+        voiced: false,
+        noise: true,
+        mora: mi
+      } : {
+        hz: vowel,
+        param: toParams(vowel, shift),
+        bpos: toBpos(false),
+        P,
+        amp: vAmp,
+        voiced: true,
+        noise: false,
+        mora: mi
+      };
+      const palFrames = pal ? nf(PAL) : 0;
+      if (palFrames) {
+        const glide = {
+          // 鼻音のあとは幅を広げる(`B_NASALIZED`)。母音の出だしが鼻にかかる
+          hz: palHz,
+          param: toParams(palHz, shift),
+          bpos: toBpos(false, false, cons.nasal && A.nasalizedGlide && "nasalized"),
+          P,
+          // 母音より少し弱い。渡りであって、母音ではない
+          amp: Math.max(1, vAmp - 2),
+          voiced: true,
+          noise: false,
+          frames: palFrames,
+          mora: mi
+        };
+        if (cons.nasal && A.glideAfterNasal === "ramp" && palFrames > 1) {
+          out.push({ ...glide, frames: 1 });
+          out.push({ ...glide, amp: vAmp, frames: palFrames - 1 });
+        } else if (cons.nasal && A.glideAfterNasal === "full") {
+          out.push({ ...glide, amp: vAmp });
+        } else out.push(glide);
+      }
+      const vFrames = note ? Math.max(1, note.frames - palFrames - (cons ? (cons.closure || 0) + cons.frames + (cons.gap || 0) : 0)) : Math.max(1, Math.round(nf((dev ? DEVOICED_FRAMES : 11) * (1 + m.hold * 0.9)) * (longBody ? BANG_LONG : preBang ? BANG_PRE_LONG : 1)) - palFrames);
+      const coart = note || m.wave || dev || !nextLocus ? 0 : Math.min(COART, Math.max(0, vFrames - 3));
+      const bend = () => out.push({
+        ...body,
+        param: toParams([vowel[0], nextLocus[1], nextLocus[2]], shift),
+        amp: Math.max(1, body.amp - 1),
+        frames: coart
+      });
+      if (m.wave && !note) pushWave(out, body, vFrames, f0, frame);
+      else if (bang && !note) {
+        pushBang(out, body, vFrames - coart, nf(BANG_FRAMES));
+        if (coart) bend();
+      } else if (style === "natural") {
+        pushDecay(out, body, vFrames - coart);
+        if (coart) bend();
+      } else if (style !== "flat") {
+        pushSung(out, body, vFrames - coart, f0, style);
+        if (coart) bend();
+      } else if (coart) {
+        out.push({ ...body, frames: vFrames - coart });
+        bend();
+      } else out.push({ ...body, frames: vFrames });
+    }
+    if (notes) {
+      const sung = notes.filter((n) => !n.rest).length;
+      const said = moras.filter((m) => !m.pause && !m.set && !m.tie).length;
+      if (sung !== said) {
+        console.warn(`[RetroTalk] 歌: 拍 ${said} 個に対して音符 ${sung} 個です` + (sung < said ? "(足りないぶんは、ふつうに読みます)" : "(余ったぶんは鳴りません)"));
+      }
+    }
+    for (const t of out) t.vol = volOf[t.mora] ?? 1;
+    return out;
+  }
+  function readText(text, opts) {
+    if (opts.format === "aquestalk") return parseAqua(text);
+    if (opts.format === "voicevox") return parseVoicevox(text, opts);
+    if (typeof text === "string" && ACCENT_MARK.test(text)) {
+      return parseAqua(text, { strict: false });
+    }
+    return parseTalk(text);
+  }
+  var ACCENT_MARK = /['\u2018\u2019\uff07/+]/;
+  function runFrames(targets, opts) {
+    const slewF = opts.slewF ?? D.slewF;
+    const slewB = opts.slewB ?? D.slewB;
+    const slewP = opts.slewP ?? D.slewP;
+    const shift = opts.formantShift ?? D.formantShift;
+    const bShift = opts.bandShift ?? D.bandShift;
+    const frames = [];
+    const step = (cur, want, lim) => cur + Math.max(-lim, Math.min(lim, want - cur));
+    let param = [0, 0, 0, 0, 0];
+    let bpos = B_HOME.slice();
+    let P = (targets.find((t) => !t.silent && t.P) || {}).P || 30;
+    for (let ti = 0; ti < targets.length; ti++) {
+      const t = targets[ti];
+      if (t.brk) {
+        for (let k = ti + 1; k < targets.length; k++) {
+          const nx = targets[k];
+          if (nx.silent || !nx.P) continue;
+          P = nx.P;
+          break;
+        }
+      }
+      const want = t.silent ? t.glideTo ? toParams(t.glideTo, shift) : param : t.param;
+      const wantB = (t.silent ? t.glideTo ? toBpos(!!t.glideNoise) : bpos : t.bpos).map((v) => v + bShift);
+      const wantP = t.silent ? P : t.P;
+      for (let n = 0; n < t.frames; n++) {
+        param = param.map((v, k) => step(v, want[k], slewF));
+        bpos = bpos.map((v, k) => Math.max(0, Math.min(B_STEPS - 1, step(v, wantB[k], slewB))));
+        P = Math.max(P_MIN, Math.min(P_MAX, step(P, wantP, slewP)));
+        frames.push({
+          param: param.slice(),
+          bpos: bpos.slice(),
+          P,
+          // 絵に描くための Hz。番地のままでは読めない。並びは第 1〜3 フォルマント
+          formant: VOICED_STAGES.map((s) => idxToHz(param[s] + F_HOME[s])),
+          formantBw: VOICED_STAGES.map((s) => bposToBw(bpos[s])),
+          norm: chainNorm(param, bpos),
+          amp: t.silent ? 0 : t.amp,
+          voiced: !t.silent && t.voiced,
+          noise: !t.silent && t.noise,
+          fv: !t.silent && !!t.fv,
+          mora: t.mora,
+          vol: t.vol ?? 1
+        });
+      }
+    }
+    return frames;
+  }
+  function talkFrames(text, opts = {}) {
+    return runFrames(buildTargets(readText(text, opts), opts), opts);
+  }
+  function softClip(x) {
+    const KNEE = 0.9;
+    const a = Math.abs(x);
+    if (a <= KNEE) return x;
+    return Math.sign(x) * (KNEE + (1 - KNEE) * Math.tanh((a - KNEE) / (1 - KNEE)));
+  }
+  function gatedRms(data, n) {
+    let all = 0;
+    for (let k = 0; k < n; k++) all += data[k] * data[k];
+    const gate = Math.sqrt(all / n) * 0.5;
+    let sum = 0, cnt = 0;
+    for (let k = 0; k < n; k++) {
+      if (Math.abs(data[k]) > gate) {
+        sum += data[k] * data[k];
+        cnt++;
+      }
+    }
+    return cnt ? Math.sqrt(sum / cnt) : 0;
+  }
+  var ampToGain = (a) => a <= 0 ? 0 : Math.pow(10, (a - 15) * 0.125);
+  function stageGain(hz, bw, f) {
+    const r = Math.exp(-Math.PI * bw / RATE);
+    const th = 2 * Math.PI * hz / RATE;
+    const b = 2 * r * Math.cos(th), c = -r * r, a = 1 - b - c;
+    const w = 2 * Math.PI * f / RATE;
+    const re = 1 - b * Math.cos(w) - c * Math.cos(2 * w);
+    const im = b * Math.sin(w) + c * Math.sin(2 * w);
+    return a / Math.sqrt(re * re + im * im);
+  }
+  function chainNorm(param, bpos) {
+    const hz = param.map((v, s) => Math.min(idxToHz(v + F_HOME[s]), RATE * 0.45));
+    const bw = bpos.map(bposToBw);
+    let mx = 0;
+    for (const f of hz) {
+      let g = 1;
+      for (let s = 0; s < 5; s++) g *= stageGain(hz[s], bw[s], f);
+      if (g > mx) mx = g;
+    }
+    return mx > 0 ? mx : 1;
+  }
+  function renderTalk(text, opts = {}) {
+    const interp = opts.interp ?? D.interp;
+    const bits = opts.bits ?? D.bits;
+    const breath = opts.breath ?? D.breath;
+    const jitter = opts.jitter ?? D.jitter;
+    const ring = Math.max(0, opts.ring ?? D.ring);
+    const rnd = makeRandom(opts.seed ?? D.seed);
+    const moras = readText(text, opts);
+    const targets = buildTargets(moras, opts);
+    const frames = runFrames(targets, opts);
+    const lead = Math.max(0, (opts.lag ?? D.lag) + (opts.lagPerMora ?? D.lagPerMora) * moras.length);
+    const perFrame = Math.round((opts.frame ?? D.frame) * RATE);
+    const leadN = Math.round(lead * RATE);
+    const n = leadN + frames.length * perFrame + Math.round(0.02 * RATE);
+    const data = new Float32Array(n);
+    const volAt = new Float32Array(n).fill(1);
+    const y1 = new Float64Array(5), y2 = new Float64Array(5);
+    let phase = 0;
+    let at = leadN;
+    for (let fi = 0; fi < frames.length; fi++) {
+      const f = frames[fi];
+      const prev = fi > 0 ? frames[fi - 1] : f;
+      for (let k = 0; k < perFrame; k++) {
+        const u = interp || f.amp <= 0 || f.voiced !== prev.voiced || f.noise !== prev.noise ? k / perFrame : 1;
+        const lerp = (a, b) => a + (b - a) * u;
+        let src = 0;
+        if (f.noise) src = rnd() * NOISE_LEVEL;
+        if (f.voiced) {
+          let P = Math.max(1, Math.round(lerp(prev.P, f.P)));
+          if (breath > 0) src += rnd() * NOISE_LEVEL * breath;
+          if (jitter > 0) P = Math.max(1, Math.round(P * (1 + rnd() * jitter)));
+          if (--phase <= 0) {
+            src += f.fv ? FV_LEVEL : 1;
+            phase = P;
+          }
+        } else {
+          phase = 0;
+        }
+        src *= ampToGain(lerp(prev.amp, f.amp)) / lerp(prev.norm, f.norm);
+        if (f.amp <= 0) {
+          for (let s2 = 0; s2 < 5; s2++) {
+            y1[s2] *= SILENCE_DAMP;
+            y2[s2] *= SILENCE_DAMP;
+          }
+        }
+        let x = src;
+        for (let s = 0; s < 5; s++) {
+          const hz = Math.min(
+            idxToHz(lerp(prev.param[s], f.param[s]) + F_HOME[s]),
+            RATE * 0.45
+          );
+          const bw = bposToBw(lerp(prev.bpos[s], f.bpos[s]));
+          const r = Math.exp(-Math.PI * bw / RATE);
+          const b = 2 * r * Math.cos(2 * Math.PI * hz / RATE);
+          const c = -r * r;
+          const a = 1 - b - c;
+          const y = a * x + b * y1[s] + c * y2[s];
+          y2[s] = y1[s];
+          y1[s] = y;
+          x = y;
+        }
+        if (ring > 0) x *= Math.sin(2 * Math.PI * ring * (at / RATE));
+        if (at < n) {
+          volAt[at] = f.vol ?? 1;
+          data[at++] = x;
+        }
+      }
+    }
+    if (opts.gainNorm ?? D.gainNorm) {
+      const up = Math.max(0, (opts.formantShift ?? D.formantShift) - D.formantShift);
+      const AIM = (opts.level ?? D.level) * (1 + Math.min(0.6, up * 0.1));
+      const rms = gatedRms(data, n);
+      if (rms > 0) {
+        for (let k = 0; k < n; k++) data[k] = softClip(data[k] * (AIM / rms));
+        for (let pass = 0; pass < 2; pass++) {
+          const now = gatedRms(data, n);
+          if (!(now > 0)) break;
+          const fix = Math.min(1.5, AIM / now);
+          if (fix <= 1.01) break;
+          for (let k = 0; k < n; k++) data[k] = softClip(data[k] * fix);
+        }
+      }
+    }
+    for (let k = 0; k < n; k++) data[k] *= volAt[k];
+    if (bits > 0) {
+      const levels = Math.pow(2, bits) / 2;
+      for (let k = 0; k < n; k++) data[k] = Math.round(data[k] * levels) / levels;
+    }
+    return { rate: RATE, data, frames: frames.length };
+  }
+
+  // src/talk_audio.js
+  var AUTO_TALK = "\0talk:";
+  var TalkAudio = class extends SimpleAudio {
+    /**
+     * @param {AudioContext} ctx 呼び出し側で作った AudioContext
+     * @param {object} [opts]
+     * @param {number} [opts.maxVoices=8] 同時に再生できる音の数
+     * @param {number} [opts.maxTalk=1] 同時に再生できるセリフの数
+     */
+    constructor(ctx, opts = {}) {
+      super(ctx, opts);
+      this.talkDefs = /* @__PURE__ */ new Map();
+      this.maxTalk = opts.maxTalk ?? 1;
+      this._talkSeq = 0;
+    }
+    /**
+     * テキストに名前を付けて登録します。再生はしません。
+     *
+     * 同じテキストを何度も再生するときに使います。作った波形は名前ごとに
+     * 保持するので、2 回目以降は作り直しません。
+     *
+     * `@` で始まる指示をテキストに混ぜられます。指示はそこから後ろに効きます。
+     *
+     *   `@p<Hz>`  声の高さ。例 `@p200`
+     *   `@s<%>`   話す速さ。例 `@s150`（1.5 倍）
+     *   `@v<0-15>` 音量。例 `@v8`
+     *
+     * ```js
+     * voice.defineTalk('two', 'ワタシデス。@p180 イエ、ワタシデス。');
+     * ```
+     *
+     * 抑揚は句読点（`、` `。`）で元に戻ります。文全体で少しずつ下がるため、
+     * 切れ目が無いと長い文の終わりで音が沈みます。空白では戻りません。
+     *
+     * @param {string} name 登録名
+     * @param {string} text カタカナ。空白と句読点は間になります
+     * @param {object} [opts]
+     *   音声のパラメータ。一覧は `renderTalk()` の説明にあります。
+     *   `unknown` は読めない文字が混ざったときの扱いで、
+     *   `warn`（初期値）/ `error` / `ignore` から選びます
+     * @returns {void}
+     */
+    defineTalk(name, text, opts = {}) {
+      const how = opts.unknown ?? "warn";
+      if (how !== "ignore") {
+        const got = opts.format === "voicevox" ? { ok: true, unknown: [] } : opts.format === "aquestalk" ? checkAqua(text) : checkTalk(text);
+        if (!got.ok) {
+          const what = got.unknown.slice(0, 8).map((u) => u.ch).join(" ");
+          const more = got.unknown.length > 8 ? ` ほか ${got.unknown.length - 8} 字` : "";
+          const label = name.startsWith(AUTO_TALK) ? text : name;
+          const say = `[RetroTalk] talk "${label}": 読めない字があります — ${what}${more}(漢字と数字は読みにしてから渡します)`;
+          if (how === "error") throw new Error(say);
+          console.warn(say);
+        }
+      }
+      this.talkDefs.set(name, { text, opts, buffer: null });
+    }
+    /**
+     * テキストをその場で再生します。
+     *
+     * `defineTalk()` と `playTalk()` をまとめて行う短い書き方です。
+     *
+     * ```js
+     * voice.talk('コンニチワ');
+     * ```
+     *
+     * 登録は残らないので、作った波形も保持しません。同じテキストを
+     * 繰り返し再生するなら `defineTalk()` で名前を付けてください。
+     *
+     * @param {string} text カタカナ。`defineTalk()` と同じ
+     * @param {object} [opts] 音声のパラメータ。`defineTalk()` と同じ
+     * @param {number} [priority=0] `playTalk()` と同じ
+     * @returns {number|undefined} 再生 ID。再生できなかったときは undefined
+     */
+    talk(text, opts = {}, priority = 0) {
+      const name = AUTO_TALK + ++this._talkSeq;
+      this.defineTalk(name, text, opts);
+      const id = this.playTalk(name, priority, opts);
+      this.talkDefs.delete(name);
+      return id;
+    }
+    /**
+     * 読み上げられない文字を調べます。再生はしません。
+     *
+     * 登録する前に確かめるときに使います。読めない文字がテキストのどこにあるかも返します。
+     *
+     * ```js
+     * const got = voice.checkTalk('今日は 3ガツ デス');
+     * // { ok: false, kana: 6, unknown: [{ ch: '今', at: 0, kind: 'kanji' }, ...] }
+     * ```
+     *
+     * @param {string} text 調べるテキスト
+     * @returns {{ok: boolean, kana: number,
+     *            unknown: Array<{ch: string, at: number, kind: string}>}}
+     *   `ok` は読めない文字が無ければ true、`kana` は読めた文字数、
+     *   `at` はテキスト内の位置、`kind` は文字の種別
+     */
+    checkTalk(text) {
+      return checkTalk(text);
+    }
+    /**
+     * 波形の生成だけを行います。再生はしません。
+     *
+     * `playTalk()` は初回に波形を生成するため、その分だけ再生の開始が遅れます。
+     * 複数を重ねて再生するとき、この遅れがずれになります。2 人分を続けて
+     * `playTalk()` すると、2 人目は 1 人目の生成が終わってから始まります。
+     * 先に両方を生成しておけば、ずれずに重なります。
+     *
+     * @param {string|string[]} name `defineTalk()` で登録した名前。配列で渡せます
+     * @returns {void}
+     */
+    prepareTalk(name) {
+      if (Array.isArray(name)) {
+        for (const n of name) this.prepareTalk(n);
+        return;
+      }
+      const def = this.talkDefs.get(name);
+      if (!def || !this.ctx || def.buffer) return;
+      const { rate, data } = renderTalk(def.text, def.opts);
+      const buf = this.ctx.createBuffer(1, data.length, rate);
+      buf.getChannelData(0).set(data);
+      def.buffer = buf;
+    }
+    /**
+     * 登録済みのテキストを再生します。
+     *
+     * 波形は初回に生成し、名前ごとに保持します。2 回目以降は作り直しません。
+     * 同時再生数（`maxTalk`）を超えると、優先度の低いものが停止します。
+     *
+     * @param {string|string[]} name `defineTalk()` で登録した名前。
+     *   配列を渡すと、すべての波形を生成してから続けて再生します
+     * @param {number} [priority=0] 値が大きいほど優先されます
+     * @param {object} [opts]
+     *   `gain` は音量の倍率、`rate` は再生速度（1 より大きいと速く高くなります）
+     * @returns {number|number[]|undefined} 再生 ID。配列を渡したときは配列。
+     *   再生できなかったときは undefined
+     */
+    playTalk(name, priority = 0, opts = {}) {
+      this.unlock();
+      if (Array.isArray(name)) {
+        this.prepareTalk(name);
+        return name.map((n) => this.playTalk(n, priority, opts));
+      }
+      const def = this.talkDefs.get(name);
+      if (!def || !this.ctx) return;
+      const room = Math.max(1, this.maxTalk | 0) || 1;
+      const talking = this.seVoices.filter((v2) => v2.talk);
+      for (let i = 0; i <= talking.length - room; i++) this._stopVoice(talking[i]);
+      const now = this.ctx.currentTime;
+      this._cleanupSE(now);
+      if (this.seVoices.some((v2) => v2.exclusive && v2.priority > priority)) return;
+      while (this._usedVoices() + 1 > this.maxVoices) {
+        let low = null;
+        for (const v2 of this.seVoices) {
+          if (v2.priority >= priority) continue;
+          if (!low || v2.priority < low.priority) low = v2;
+        }
+        if (!low) return 0;
+        this._stopVoice(low);
+      }
+      this.prepareTalk(name);
+      const gain = this.ctx.createGain();
+      gain.gain.value = (def.opts.gain ?? 1) * 0.9;
+      gain.connect(this._out());
+      const src = this.ctx.createBufferSource();
+      src.buffer = def.buffer;
+      src.connect(gain);
+      const when = now + 0.02;
+      src.start(when);
+      const v = {
+        gain,
+        nodes: [src],
+        priority,
+        voices: 1,
+        noise: 0,
+        endTime: when + def.buffer.duration,
+        exclusive: !!opts.exclusive,
+        talk: name,
+        id: ++this._seSeq
+      };
+      this.seVoices.push(v);
+      return v.id;
+    }
+    /**
+     * 保持している波形を破棄します。
+     *
+     * `defineTalk()` は名前ごとに波形を持ち続けます。作り直さずに済ませるためですが、
+     * その分メモリを使います。使わなくなったものは破棄できます。
+     *
+     * ```js
+     * voice.forgetTalk('hello');              // 名前を指定して破棄
+     * voice.forgetTalk(['demo1', 'demo2']);   // まとめて破棄
+     * voice.forgetTalk();                     // すべて破棄
+     * ```
+     *
+     * 再生中のものは最後まで再生されます。波形は再生側が参照しています。
+     *
+     * @param {string|string[]} [name] 登録名。省略するとすべて破棄します
+     * @returns {void}
+     */
+    forgetTalk(name) {
+      if (name == null) {
+        this.talkDefs.clear();
+        return;
+      }
+      for (const n of Array.isArray(name) ? name : [name]) this.talkDefs.delete(n);
+    }
+    /**
+     * 再生中のものを停止します。
+     *
+     * @param {string|number} [what] 登録名、または `playTalk()` の戻り値。
+     *   省略するとすべて停止します
+     * @returns {void}
+     */
+    stopTalk(what) {
+      for (const v of [...this.seVoices]) {
+        if (!v.talk) continue;
+        if (what !== void 0 && v.talk !== what && v.id !== what) continue;
+        this._stopVoice(v);
+      }
+    }
+  };
+
+  // src/wav.js
+  function encodeWAV(buffer) {
+    const ch = buffer.numberOfChannels;
+    const frames = buffer.length;
+    const rate = buffer.sampleRate;
+    const bytes = 2;
+    const dataSize = frames * ch * bytes;
+    const out = new Uint8Array(44 + dataSize);
+    const view = new DataView(out.buffer);
+    let p = 0;
+    const str = (t) => {
+      for (const c of t) out[p++] = c.charCodeAt(0);
+    };
+    const u32 = (v) => {
+      view.setUint32(p, v, true);
+      p += 4;
+    };
+    const u16 = (v) => {
+      view.setUint16(p, v, true);
+      p += 2;
+    };
+    str("RIFF");
+    u32(36 + dataSize);
+    str("WAVE");
+    str("fmt ");
+    u32(16);
+    u16(1);
+    u16(ch);
+    u32(rate);
+    u32(rate * ch * bytes);
+    u16(ch * bytes);
+    u16(8 * bytes);
+    str("data");
+    u32(dataSize);
+    const src = [];
+    for (let c = 0; c < ch; c++) src.push(buffer.getChannelData(c));
+    for (let i = 0; i < frames; i++) {
+      for (let c = 0; c < ch; c++) {
+        const v = Math.max(-1, Math.min(1, src[c][i]));
+        view.setInt16(p, Math.round(v < 0 ? v * 32768 : v * 32767), true);
+        p += 2;
+      }
+    }
+    return out;
+  }
+
+  // src/version.js
+  var RETROTALK_VERSION = "2.1.0";
+
+  // src/index.js
+  Object.assign(TalkAudio, {
+    renderTalk,
+    talkFrames,
+    parseTalk,
+    checkTalk,
+    checkAqua,
+    voicevoxText,
+    voicevoxInfo,
+    encodeWAV,
+    TALK_DEFAULTS,
+    TALK_STYLES,
+    VERSION: RETROTALK_VERSION
+  });
+  var index_default = TalkAudio;
+
+  // src/global.js
+  globalThis.MmsxxRetroTalk = index_default;
+})();