@lee-zg/melange 1.0.0 → 1.2.0

package/dist/chunk-3RM45M64.js

@@ -0,0 +1,1637 @@
+import { __name } from './chunk-7QVYU63E.js';
+
+// src/plugins/speech/synthesis.ts
+var SynthesisAudioUtils = {
+  /**
+   * 创建 AudioContext
+   */
+  createAudioContext() {
+    const AudioCtor = typeof window !== "undefined" ? window.AudioContext || window.webkitAudioContext : null;
+    if (!AudioCtor) {
+      throw new Error("\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 AudioContext");
+    }
+    return new AudioCtor();
+  },
+  /**
+   * ArrayBuffer 转 Base64
+   */
+  arrayBufferToBase64(buffer) {
+    let binary = "";
+    const bytes = new Uint8Array(buffer);
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i] ?? 0);
+    }
+    return typeof btoa !== "undefined" ? btoa(binary) : Buffer.from(binary).toString("base64");
+  },
+  /**
+   * Base64 转 ArrayBuffer
+   */
+  base64ToArrayBuffer(base64) {
+    const binary = typeof atob !== "undefined" ? atob(base64) : Buffer.from(base64, "base64").toString("binary");
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+  },
+  /**
+   * 计算音频时长（粗略估算）
+   */
+  estimateDuration(byteLength, format) {
+    const bitRates = {
+      mp3: 128e3,
+      // 128 kbps
+      wav: 256e3,
+      // 16bit 16kHz mono
+      ogg: 96e3,
+      // 96 kbps
+      pcm: 256e3
+      // 16bit 16kHz mono
+    };
+    return Math.ceil(byteLength * 8 / bitRates[format] * 1e3);
+  }
+};
+var BaseSynthesisStrategy = class {
+  constructor(config) {
+    this.config = config;
+  }
+  static {
+    __name(this, "BaseSynthesisStrategy");
+  }
+  listeners = {
+    start: [],
+    end: [],
+    pause: [],
+    resume: [],
+    boundary: [],
+    mark: [],
+    error: [],
+    state: []
+  };
+  _status = "IDLE" /* IDLE */;
+  /**
+   * 获取当前状态
+   */
+  get status() {
+    return this._status;
+  }
+  /**
+   * 设置状态
+   */
+  setStatus(status) {
+    if (this._status !== status) {
+      this._status = status;
+      this.emit("state", status);
+    }
+  }
+  /**
+   * 添加事件监听
+   */
+  on(event, fn) {
+    this.listeners[event].push(fn);
+  }
+  /**
+   * 移除事件监听
+   */
+  off(event, fn) {
+    const listeners = this.listeners[event];
+    const index = listeners.indexOf(fn);
+    if (index > -1) {
+      listeners.splice(index, 1);
+    }
+  }
+  /**
+   * 触发事件
+   */
+  emit(event, data) {
+    const listeners = this.listeners[event];
+    listeners.forEach((fn) => {
+      try {
+        fn(data);
+      } catch (e) {
+        console.error(`[Synthesis] \u4E8B\u4EF6\u5904\u7406\u5668\u9519\u8BEF (${event}):`, e);
+      }
+    });
+  }
+  /**
+   * 销毁资源
+   */
+  dispose() {
+    this.cancel();
+    Object.keys(this.listeners).forEach((key) => {
+      this.listeners[key] = [];
+    });
+  }
+};
+var NativeSynthesisStrategy = class extends BaseSynthesisStrategy {
+  static {
+    __name(this, "NativeSynthesisStrategy");
+  }
+  synthesis = null;
+  // Internal state tracking for current utterance (write-only, used for GC reference)
+  currentUtterance = null;
+  voicesLoaded = false;
+  voicesPromise = null;
+  constructor(config) {
+    super(config);
+    if (this.isAvailable()) {
+      this.synthesis = window.speechSynthesis;
+    }
+  }
+  isAvailable() {
+    return typeof window !== "undefined" && "speechSynthesis" in window;
+  }
+  async getVoices() {
+    if (!this.synthesis) return [];
+    if (this.voicesPromise) {
+      return this.voicesPromise;
+    }
+    this.voicesPromise = new Promise((resolve) => {
+      const loadVoices = /* @__PURE__ */ __name(() => {
+        const voices = this.synthesis.getVoices();
+        if (voices.length > 0) {
+          this.voicesLoaded = true;
+          resolve(
+            voices.map((voice) => ({
+              id: voice.voiceURI,
+              name: voice.name,
+              lang: voice.lang,
+              localService: voice.localService,
+              default: voice.default,
+              provider: "browser"
+            }))
+          );
+        }
+      }, "loadVoices");
+      loadVoices();
+      if (!this.voicesLoaded) {
+        this.synthesis.addEventListener("voiceschanged", loadVoices, { once: true });
+        setTimeout(() => {
+          if (!this.voicesLoaded) {
+            resolve([]);
+          }
+        }, 3e3);
+      }
+    });
+    return this.voicesPromise;
+  }
+  async speak(text, config) {
+    if (!this.synthesis) {
+      throw { code: "NOT_SUPPORTED", message: "\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u8BED\u97F3\u5408\u6210" };
+    }
+    this.cancel();
+    this.setStatus("LOADING" /* LOADING */);
+    return new Promise((resolve, reject) => {
+      const mergedConfig = { ...this.config, ...config };
+      const utterance = new SpeechSynthesisUtterance(text);
+      this.currentUtterance = utterance;
+      if (mergedConfig.lang) utterance.lang = mergedConfig.lang;
+      if (mergedConfig.volume !== void 0) utterance.volume = mergedConfig.volume;
+      if (mergedConfig.rate !== void 0) utterance.rate = mergedConfig.rate;
+      if (mergedConfig.pitch !== void 0) utterance.pitch = mergedConfig.pitch;
+      if (mergedConfig.voice) {
+        const voices = this.synthesis.getVoices();
+        const voiceConfig = mergedConfig.voice;
+        const targetVoice = typeof voiceConfig === "string" ? voices.find((v) => v.name === voiceConfig || v.voiceURI === voiceConfig) : voices.find((v) => v.voiceURI === voiceConfig.id);
+        if (targetVoice) {
+          utterance.voice = targetVoice;
+        }
+      }
+      utterance.onstart = () => {
+        this.setStatus("SPEAKING" /* SPEAKING */);
+        this.emit("start");
+      };
+      utterance.onend = () => {
+        this.setStatus("IDLE" /* IDLE */);
+        this.currentUtterance = null;
+        this.emit("end");
+        resolve();
+      };
+      utterance.onpause = () => {
+        this.setStatus("PAUSED" /* PAUSED */);
+        this.emit("pause");
+      };
+      utterance.onresume = () => {
+        this.setStatus("SPEAKING" /* SPEAKING */);
+        this.emit("resume");
+      };
+      utterance.onboundary = (event) => {
+        this.emit("boundary", {
+          charIndex: event.charIndex,
+          charLength: event.charLength,
+          elapsedTime: event.elapsedTime,
+          name: event.name
+        });
+      };
+      utterance.onmark = (event) => {
+        this.emit("mark", { name: event.name });
+      };
+      utterance.onerror = (event) => {
+        this.setStatus("IDLE" /* IDLE */);
+        this.currentUtterance = null;
+        const error = {
+          code: "UNKNOWN",
+          message: `\u8BED\u97F3\u5408\u6210\u9519\u8BEF: ${event.error}`,
+          originalError: event
+        };
+        this.emit("error", error);
+        reject(error);
+      };
+      this.synthesis.speak(utterance);
+    });
+  }
+  pause() {
+    if (this.synthesis && this.isSpeaking()) {
+      this.synthesis.pause();
+    }
+  }
+  resume() {
+    if (this.synthesis && this.isPaused()) {
+      this.synthesis.resume();
+    }
+  }
+  cancel() {
+    if (this.synthesis) {
+      this.synthesis.cancel();
+      this.currentUtterance = null;
+      this.setStatus("IDLE" /* IDLE */);
+    }
+  }
+  isSpeaking() {
+    return this.currentUtterance !== null && (this.synthesis?.speaking ?? false);
+  }
+  isPaused() {
+    return this.synthesis?.paused ?? false;
+  }
+};
+var CloudSynthesisStrategy = class extends BaseSynthesisStrategy {
+  static {
+    __name(this, "CloudSynthesisStrategy");
+  }
+  adapter;
+  audioContext = null;
+  sourceNode = null;
+  gainNode = null;
+  startTime = 0;
+  pauseTime = 0;
+  audioBuffer = null;
+  constructor(config) {
+    super(config);
+    if (!config.cloudAdapter) {
+      throw new Error("[CloudStrategy] \u9700\u8981\u63D0\u4F9B cloudAdapter");
+    }
+    this.adapter = config.cloudAdapter;
+  }
+  isAvailable() {
+    return typeof window !== "undefined" && "AudioContext" in window;
+  }
+  async getVoices() {
+    if (!this.adapter.getVoices) return [];
+    try {
+      const cloudVoices = await this.adapter.getVoices();
+      return cloudVoices.map((v) => ({
+        id: v.id,
+        name: v.name,
+        lang: v.lang,
+        localService: false,
+        default: false,
+        provider: "custom"
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async speak(text, config) {
+    if (!text.trim()) {
+      throw { code: "INVALID_TEXT", message: "\u6587\u672C\u5185\u5BB9\u4E3A\u7A7A" };
+    }
+    this.cancel();
+    const mergedConfig = { ...this.config, ...config };
+    this.setStatus("LOADING" /* LOADING */);
+    try {
+      this.emit("start");
+      const result = await this.adapter.synthesize(text, mergedConfig);
+      if (!this.audioContext) {
+        this.audioContext = SynthesisAudioUtils.createAudioContext();
+      }
+      if (this.audioContext.state === "suspended") {
+        await this.audioContext.resume();
+      }
+      this.audioBuffer = await this.audioContext.decodeAudioData(result.audioData.slice(0));
+      await this.playBuffer();
+    } catch (e) {
+      const error = e;
+      this.setStatus("IDLE" /* IDLE */);
+      const synthError = {
+        code: "ADAPTER_ERROR",
+        message: error.message || "\u5408\u6210\u5931\u8D25",
+        originalError: e
+      };
+      this.emit("error", synthError);
+      throw synthError;
+    }
+  }
+  async playBuffer() {
+    if (!this.audioContext || !this.audioBuffer) return;
+    return new Promise((resolve, reject) => {
+      try {
+        this.sourceNode = this.audioContext.createBufferSource();
+        this.sourceNode.buffer = this.audioBuffer;
+        this.gainNode = this.audioContext.createGain();
+        this.gainNode.gain.value = this.config.volume ?? 1;
+        this.sourceNode.connect(this.gainNode);
+        this.gainNode.connect(this.audioContext.destination);
+        this.sourceNode.onended = () => {
+          if (this._status === "SPEAKING" /* SPEAKING */) {
+            this.setStatus("IDLE" /* IDLE */);
+            this.emit("end");
+            resolve();
+          }
+        };
+        const offset = this.pauseTime > 0 ? this.pauseTime : 0;
+        this.sourceNode.start(0, offset);
+        this.startTime = this.audioContext.currentTime - offset;
+        this.pauseTime = 0;
+        this.setStatus("SPEAKING" /* SPEAKING */);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  pause() {
+    if (this._status === "SPEAKING" /* SPEAKING */ && this.audioContext && this.sourceNode) {
+      this.pauseTime = this.audioContext.currentTime - this.startTime;
+      this.sourceNode.stop();
+      this.sourceNode.disconnect();
+      this.sourceNode = null;
+      this.setStatus("PAUSED" /* PAUSED */);
+      this.emit("pause");
+    }
+  }
+  resume() {
+    if (this._status === "PAUSED" /* PAUSED */ && this.audioBuffer) {
+      this.emit("resume");
+      void this.playBuffer();
+    }
+  }
+  cancel() {
+    if (this.sourceNode) {
+      try {
+        this.sourceNode.stop();
+        this.sourceNode.disconnect();
+      } catch {
+      }
+      this.sourceNode = null;
+    }
+    this.audioBuffer = null;
+    this.pauseTime = 0;
+    this.startTime = 0;
+    this.setStatus("IDLE" /* IDLE */);
+  }
+  isSpeaking() {
+    return this._status === "SPEAKING" /* SPEAKING */;
+  }
+  isPaused() {
+    return this._status === "PAUSED" /* PAUSED */;
+  }
+  dispose() {
+    super.dispose();
+    this.cancel();
+    if (this.audioContext) {
+      void this.audioContext.close();
+      this.audioContext = null;
+    }
+  }
+};
+var SpeechSynthesizerImpl = class {
+  static {
+    __name(this, "SpeechSynthesizerImpl");
+  }
+  strategy = null;
+  config = {};
+  _currentProvider = "browser";
+  _status = "idle";
+  eventHandlers = /* @__PURE__ */ new Map();
+  customProviders = /* @__PURE__ */ new Map();
+  get currentProvider() {
+    return this._currentProvider;
+  }
+  get status() {
+    return this._status;
+  }
+  /**
+   * 获取当前合成状态
+   */
+  get synthesisStatus() {
+    return this.strategy?.status ?? "IDLE" /* IDLE */;
+  }
+  /**
+   * 初始化语音合成器
+   */
+  initialize(config) {
+    this._status = "loading";
+    this.config = {
+      lang: "zh-CN",
+      volume: 1,
+      rate: 1,
+      pitch: 1,
+      preferredProvider: "browser",
+      autoFallback: true,
+      fallbackProviders: ["azure", "google", "aws"],
+      mode: "auto",
+      audioFormat: "mp3",
+      ...config
+    };
+    try {
+      this.initializeStrategy();
+      this._status = "ready";
+      return Promise.resolve();
+    } catch (error) {
+      this._status = "error";
+      return Promise.reject(error);
+    }
+  }
+  /**
+   * 初始化合成策略
+   */
+  initializeStrategy() {
+    const advConfig = this.config;
+    const mode = advConfig.mode ?? "auto";
+    const hasNative = typeof window !== "undefined" && "speechSynthesis" in window;
+    if (mode === "native" || mode === "auto" && hasNative && !advConfig.cloudAdapter) {
+      const nativeStrategy = new NativeSynthesisStrategy(advConfig);
+      if (!nativeStrategy.isAvailable()) {
+        throw new Error("\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u539F\u751F\u8BED\u97F3\u5408\u6210");
+      }
+      this.strategy = nativeStrategy;
+      this._currentProvider = "browser";
+    } else if (mode === "cloud" || mode === "auto" && advConfig.cloudAdapter) {
+      if (!advConfig.cloudAdapter) {
+        throw new Error("\u4E91\u7AEF\u6A21\u5F0F\u9700\u8981\u63D0\u4F9B cloudAdapter");
+      }
+      this.strategy = new CloudSynthesisStrategy(advConfig);
+      this._currentProvider = "custom";
+    } else {
+      throw new Error("\u6CA1\u6709\u53EF\u7528\u7684\u5408\u6210\u7B56\u7565");
+    }
+    this.forwardStrategyEvents();
+  }
+  /**
+   * 转发策略事件
+   */
+  forwardStrategyEvents() {
+    if (!this.strategy) return;
+    this.strategy.on("start", () => this.emit("start", { type: "start" }));
+    this.strategy.on("end", () => this.emit("end", { type: "end" }));
+    this.strategy.on("pause", () => this.emit("pause", { type: "pause" }));
+    this.strategy.on("resume", () => this.emit("resume", { type: "resume" }));
+    this.strategy.on("boundary", (data) => {
+      const event = { type: "boundary" };
+      if (data.charIndex !== void 0) event.charIndex = data.charIndex;
+      if (data.charLength !== void 0) event.charLength = data.charLength;
+      if (data.elapsedTime !== void 0) event.elapsedTime = data.elapsedTime;
+      if (data.name !== void 0) event.name = data.name;
+      this.emit("boundary", event);
+    });
+    this.strategy.on("mark", (data) => {
+      const event = { type: "mark" };
+      if (data.name !== void 0) event.name = data.name;
+      this.emit("mark", event);
+    });
+    this.strategy.on("error", (err) => {
+      const errorEvent = {
+        type: "error",
+        error: {
+          code: err.code,
+          message: err.message
+        }
+      };
+      if (err.originalError) {
+        errorEvent.error.originalError = err.originalError;
+      }
+      this.emit("error", errorEvent);
+    });
+  }
+  /**
+   * 获取可用语音列表
+   */
+  async getVoices() {
+    if (!this.strategy) {
+      throw new Error("\u8BED\u97F3\u5408\u6210\u5668\u672A\u521D\u59CB\u5316");
+    }
+    return this.strategy.getVoices();
+  }
+  /**
+   * 朗读文本
+   */
+  async speak(text, config) {
+    if (this._status !== "ready") {
+      throw new Error("\u8BED\u97F3\u5408\u6210\u5668\u672A\u5C31\u7EEA");
+    }
+    return this.strategy?.speak(text, config);
+  }
+  /**
+   * 暂停朗读
+   */
+  pause() {
+    this.strategy?.pause();
+  }
+  /**
+   * 继续朗读
+   */
+  resume() {
+    this.strategy?.resume();
+  }
+  /**
+   * 取消朗读
+   */
+  cancel() {
+    this.strategy?.cancel();
+  }
+  /**
+   * 是否正在朗读
+   */
+  isSpeaking() {
+    return this.strategy?.isSpeaking() ?? false;
+  }
+  /**
+   * 是否已暂停
+   */
+  isPaused() {
+    return this.strategy?.isPaused() ?? false;
+  }
+  /**
+   * 添加事件监听
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * 移除事件监听
+   */
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * 触发事件
+   */
+  emit(type, event) {
+    this.eventHandlers.get(type)?.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (e) {
+        console.error("[SpeechSynthesizer] \u4E8B\u4EF6\u5904\u7406\u5668\u9519\u8BEF:", e);
+      }
+    });
+  }
+  /**
+   * 销毁实例
+   */
+  dispose() {
+    this.strategy?.dispose();
+    this.strategy = null;
+    this.eventHandlers.clear();
+    this._status = "idle";
+  }
+  /**
+   * 注册自定义提供商
+   */
+  registerProvider(type, provider) {
+    this.customProviders.set(type, provider);
+  }
+  /**
+   * 使用云端适配器
+   */
+  useCloudAdapter(adapter) {
+    this.config.cloudAdapter = adapter;
+    this.config.mode = "cloud";
+  }
+};
+async function createSpeechSynthesizer(config) {
+  const synthesizer = new SpeechSynthesizerImpl();
+  await synthesizer.initialize(config);
+  return synthesizer;
+}
+__name(createSpeechSynthesizer, "createSpeechSynthesizer");
+function isSpeechSynthesisSupported() {
+  return typeof window !== "undefined" && "speechSynthesis" in window;
+}
+__name(isSpeechSynthesisSupported, "isSpeechSynthesisSupported");
+async function speak(text, config) {
+  const synthesizer = await createSpeechSynthesizer(config);
+  try {
+    await synthesizer.speak(text, config);
+  } finally {
+    synthesizer.dispose();
+  }
+}
+__name(speak, "speak");
+
+// src/plugins/speech/recognition.ts
+var AudioUtils = {
+  /**
+   * 重采样音频数据
+   * @param data 原始音频数据
+   * @param inputRate 输入采样率
+   * @param outputRate 输出采样率
+   * @returns 重采样后的数据
+   */
+  resample(data, inputRate, outputRate) {
+    if (inputRate === outputRate) return data;
+    const compression = inputRate / outputRate;
+    const length = Math.ceil(data.length / compression);
+    const result = new Float32Array(length);
+    for (let i = 0; i < length; i++) {
+      result[i] = data[Math.floor(i * compression)] ?? 0;
+    }
+    return result;
+  },
+  /**
+   * Float32 转 Int16 PCM
+   * @param input Float32 数据
+   * @returns Int16 PCM 数据
+   */
+  floatTo16BitPCM(input) {
+    const output = new Int16Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      const s = Math.max(-1, Math.min(1, input[i] ?? 0));
+      output[i] = s < 0 ? s * 32768 : s * 32767;
+    }
+    return output;
+  },
+  /**
+   * 计算音量 RMS
+   * @param data 音频数据
+   * @returns RMS 值
+   */
+  calculateRMS(data) {
+    let sum = 0;
+    for (let i = 0; i < data.length; i++) {
+      const sample = data[i] ?? 0;
+      sum += sample * sample;
+    }
+    return Math.sqrt(sum / data.length);
+  },
+  /**
+   * 合并 PCM 片段
+   * @param buffers PCM 缓冲区数组
+   * @param totalLength 总采样数
+   * @returns 合并后的 Int16 数组
+   */
+  mergeBuffers(buffers, totalLength) {
+    const result = new Int16Array(totalLength);
+    let offset = 0;
+    for (const buffer of buffers) {
+      const view = new Int16Array(buffer);
+      result.set(view, offset);
+      offset += view.length;
+    }
+    return result;
+  },
+  /**
+   * PCM 转 WAV 封装
+   * @param samples PCM 采样数据
+   * @param sampleRate 采样率
+   * @param channels 声道数
+   * @returns WAV 格式 ArrayBuffer
+   */
+  encodeWAV(samples, sampleRate = 16e3, channels = 1) {
+    const buffer = new ArrayBuffer(44 + samples.length * 2);
+    const view = new DataView(buffer);
+    const writeString = /* @__PURE__ */ __name((offset, str) => {
+      for (let i = 0; i < str.length; i++) {
+        view.setUint8(offset + i, str.charCodeAt(i));
+      }
+    }, "writeString");
+    writeString(0, "RIFF");
+    view.setUint32(4, 36 + samples.length * 2, true);
+    writeString(8, "WAVE");
+    writeString(12, "fmt ");
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, channels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * channels * 2, true);
+    view.setUint16(32, channels * 2, true);
+    view.setUint16(34, 16, true);
+    writeString(36, "data");
+    view.setUint32(40, samples.length * 2, true);
+    const dataOffset = 44;
+    for (let i = 0; i < samples.length; i++) {
+      view.setInt16(dataOffset + i * 2, samples[i] ?? 0, true);
+    }
+    return buffer;
+  },
+  /**
+   * ArrayBuffer 转 Base64
+   * @param buffer ArrayBuffer
+   * @returns Base64 字符串
+   */
+  arrayBufferToBase64(buffer) {
+    let binary = "";
+    const bytes = new Uint8Array(buffer);
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i] ?? 0);
+    }
+    return typeof btoa !== "undefined" ? btoa(binary) : Buffer.from(binary).toString("base64");
+  }
+};
+var WORKLET_CODE = `
+class SpeechProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.buffer = [];
+    this.targetRate = 16000;
+    this.currentRate = 44100;
+    this.silenceFrames = 0;
+    this.maxSilenceFrames = 0;
+    this.vadThreshold = 0.02;
+    this.isRecording = false;
+    this.port.onmessage = this.handleMessage.bind(this);
+  }
+
+  static get parameterDescriptors() {
+    return [];
+  }
+
+  process(inputs) {
+    const input = inputs[0];
+    if (!input || !input.length || !this.isRecording) return true;
+    const channelData = input[0];
+
+    // VAD \u68C0\u6D4B
+    let sum = 0;
+    for (let i = 0; i < channelData.length; i++) {
+      sum += channelData[i] * channelData[i];
+    }
+    const rms = Math.sqrt(sum / channelData.length);
+
+    if (rms < this.vadThreshold) {
+      this.silenceFrames++;
+      if (this.maxSilenceFrames > 0 && this.silenceFrames > this.maxSilenceFrames) {
+        this.port.postMessage({ type: 'VAD_TIMEOUT' });
+        this.silenceFrames = 0;
+      }
+    } else {
+      this.silenceFrames = 0;
+    }
+
+    // \u91CD\u91C7\u6837
+    if (this.targetRate < this.currentRate) {
+      const compression = this.currentRate / this.targetRate;
+      for (let i = 0; i < channelData.length; i += compression) {
+        this.buffer.push(channelData[Math.floor(i)]);
+      }
+    } else {
+      this.buffer.push(...channelData);
+    }
+
+    // \u5B9A\u671F\u5237\u65B0 (~128ms)
+    if (this.buffer.length >= 2048) {
+      this.flush();
+    }
+    return true;
+  }
+
+  flush() {
+    if (this.buffer.length === 0) return;
+    const pcmData = new Int16Array(this.buffer.length);
+    for (let i = 0; i < this.buffer.length; i++) {
+      let s = Math.max(-1, Math.min(1, this.buffer[i]));
+      s = s < 0 ? s * 0x8000 : s * 0x7FFF;
+      pcmData[i] = s;
+    }
+    this.port.postMessage({ type: 'AUDIO_DATA', payload: pcmData.buffer }, [pcmData.buffer]);
+    this.buffer = [];
+  }
+
+  handleMessage(event) {
+    const { type, payload } = event.data;
+    if (type === 'CONFIG') {
+      this.targetRate = payload.targetRate || 16000;
+      this.currentRate = payload.currentRate || 44100;
+      this.vadThreshold = payload.vadThreshold || 0.02;
+      const secondsPerBlock = 128 / this.currentRate;
+      this.maxSilenceFrames = (payload.vadDuration / 1000) / secondsPerBlock;
+    }
+    if (type === 'SET_RECORDING') {
+      this.isRecording = payload;
+      if (!payload) this.flush();
+    }
+  }
+}
+registerProcessor('speech-processor', SpeechProcessor);
+`;
+var BaseRecognitionStrategy = class {
+  constructor(config) {
+    this.config = config;
+  }
+  static {
+    __name(this, "BaseRecognitionStrategy");
+  }
+  listeners = {
+    result: [],
+    error: [],
+    state: [],
+    start: [],
+    end: [],
+    soundstart: [],
+    soundend: [],
+    speechstart: [],
+    speechend: [],
+    audiostart: [],
+    audioend: []
+  };
+  _status = "IDLE" /* IDLE */;
+  /**
+   * 获取当前状态
+   */
+  get status() {
+    return this._status;
+  }
+  /**
+   * 设置状态
+   */
+  setStatus(status) {
+    if (this._status !== status) {
+      this._status = status;
+      this.emit("state", status);
+    }
+  }
+  /**
+   * 添加事件监听
+   */
+  on(event, fn) {
+    this.listeners[event].push(fn);
+  }
+  /**
+   * 移除事件监听
+   */
+  off(event, fn) {
+    const listeners = this.listeners[event];
+    const index = listeners.indexOf(fn);
+    if (index > -1) {
+      listeners.splice(index, 1);
+    }
+  }
+  /**
+   * 触发事件
+   */
+  emit(event, data) {
+    const listeners = this.listeners[event];
+    listeners.forEach((fn) => {
+      try {
+        fn(data);
+      } catch (e) {
+        console.error(`[Recognition] \u4E8B\u4EF6\u5904\u7406\u5668\u9519\u8BEF (${event}):`, e);
+      }
+    });
+  }
+  /**
+   * 销毁资源
+   */
+  dispose() {
+    this.abort();
+    Object.keys(this.listeners).forEach((key) => {
+      this.listeners[key] = [];
+    });
+  }
+};
+var NativeRecognitionStrategy = class extends BaseRecognitionStrategy {
+  static {
+    __name(this, "NativeRecognitionStrategy");
+  }
+  recognition = null;
+  SpeechRecognitionClass = null;
+  constructor(config) {
+    super(config);
+    const srClass = typeof window !== "undefined" ? window.SpeechRecognition ?? window.webkitSpeechRecognition : void 0;
+    this.SpeechRecognitionClass = srClass ?? null;
+  }
+  /**
+   * 检查是否可用
+   */
+  isAvailable() {
+    return this.SpeechRecognitionClass !== null;
+  }
+  async start() {
+    if (!this.SpeechRecognitionClass) {
+      throw { code: "NOT_SUPPORTED", message: "\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u8BED\u97F3\u8BC6\u522B" };
+    }
+    if (this._status !== "IDLE" /* IDLE */) {
+      return;
+    }
+    this.setStatus("CONNECTING" /* CONNECTING */);
+    return new Promise((resolve, reject) => {
+      this.recognition = new this.SpeechRecognitionClass();
+      this.recognition.lang = this.config.lang ?? "zh-CN";
+      this.recognition.continuous = this.config.continuous ?? false;
+      this.recognition.interimResults = this.config.interimResults ?? true;
+      this.recognition.maxAlternatives = this.config.maxAlternatives ?? 1;
+      this.recognition.onstart = () => {
+        this.setStatus("RECORDING" /* RECORDING */);
+        this.emit("start");
+        this.emit("audiostart");
+        resolve();
+      };
+      this.recognition.onend = () => {
+        this.setStatus("IDLE" /* IDLE */);
+        this.emit("audioend");
+        this.emit("end");
+      };
+      this.recognition.onresult = (e) => {
+        const results = e.results[e.resultIndex];
+        if (results?.[0]) {
+          this.emit("result", {
+            transcript: results[0].transcript,
+            isFinal: results.isFinal,
+            confidence: results[0].confidence,
+            original: e
+          });
+        }
+      };
+      this.recognition.onerror = (e) => {
+        const errorMap = {
+          "not-allowed": "NOT_ALLOWED",
+          "no-speech": "NO_SPEECH",
+          network: "NETWORK"
+        };
+        const error = {
+          code: errorMap[e.error] ?? "UNKNOWN",
+          message: this.getErrorMessage(e.error),
+          originalError: e
+        };
+        this.setStatus("IDLE" /* IDLE */);
+        this.emit("error", error);
+        if (e.error === "not-allowed" || e.error === "audio-capture") {
+          reject(error);
+        }
+      };
+      this.recognition.onsoundstart = () => this.emit("soundstart");
+      this.recognition.onsoundend = () => this.emit("soundend");
+      this.recognition.onspeechstart = () => this.emit("speechstart");
+      this.recognition.onspeechend = () => this.emit("speechend");
+      try {
+        this.recognition.start();
+      } catch (e) {
+        this.setStatus("IDLE" /* IDLE */);
+        reject({ code: "UNKNOWN", message: "\u542F\u52A8\u8BC6\u522B\u5931\u8D25", originalError: e });
+      }
+    });
+  }
+  stop() {
+    if (this.recognition && this._status === "RECORDING" /* RECORDING */) {
+      this.recognition.stop();
+    }
+  }
+  abort() {
+    if (this.recognition) {
+      this.recognition.abort();
+      this.setStatus("IDLE" /* IDLE */);
+    }
+  }
+  isListening() {
+    return this._status === "RECORDING" /* RECORDING */;
+  }
+  getErrorMessage(errorCode) {
+    const messages = {
+      "no-speech": "\u672A\u68C0\u6D4B\u5230\u8BED\u97F3\u8F93\u5165",
+      "audio-capture": "\u65E0\u6CD5\u8BBF\u95EE\u9EA6\u514B\u98CE",
+      "not-allowed": "\u9EA6\u514B\u98CE\u6743\u9650\u88AB\u62D2\u7EDD",
+      network: "\u7F51\u7EDC\u9519\u8BEF",
+      aborted: "\u8BC6\u522B\u88AB\u4E2D\u6B62",
+      "language-not-supported": "\u4E0D\u652F\u6301\u7684\u8BED\u8A00",
+      "service-not-allowed": "\u8BED\u97F3\u670D\u52A1\u4E0D\u53EF\u7528"
+    };
+    return messages[errorCode] ?? `\u8BED\u97F3\u8BC6\u522B\u9519\u8BEF: ${errorCode}`;
+  }
+};
+var CloudRecognitionStrategy = class extends BaseRecognitionStrategy {
+  static {
+    __name(this, "CloudRecognitionStrategy");
+  }
+  audioContext = null;
+  mediaStream = null;
+  workletNode = null;
+  scriptProcessor = null;
+  socket = null;
+  adapter;
+  transport;
+  // HTTP 模式缓冲
+  pcmChunks = [];
+  totalPCMLength = 0;
+  // 页面可见性监听器
+  visibilityHandler = null;
+  // 弱网消息队列
+  msgQueue = [];
+  MSG_QUEUE_MAX = 50;
+  // ScriptProcessor 降级参数
+  spSilenceCount = 0;
+  spMaxSilence = 0;
+  isRecordingFlag = false;
+  // 重连参数
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  // Worklet 加载标记
+  workletLoaded = false;
+  constructor(config) {
+    super(config);
+    if (!config.cloudAdapter) {
+      throw new Error("[CloudStrategy] \u9700\u8981\u63D0\u4F9B cloudAdapter");
+    }
+    this.adapter = config.cloudAdapter;
+    this.transport = config.transport ?? "websocket";
+  }
+  async start() {
+    if (this._status !== "IDLE" /* IDLE */) {
+      return;
+    }
+    this.setStatus("CONNECTING" /* CONNECTING */);
+    this.pcmChunks = [];
+    this.totalPCMLength = 0;
+    this.reconnectAttempts = 0;
+    try {
+      if (this.transport === "websocket") {
+        if (!this.adapter.getConnectUrl) {
+          throw new Error("\u9002\u914D\u5668\u7F3A\u5C11 getConnectUrl \u65B9\u6CD5");
+        }
+        const url = await Promise.resolve(this.adapter.getConnectUrl());
+        await this.initWebSocket(url);
+      }
+      const audioConfig = this.config.audioConfig ?? {};
+      this.mediaStream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          echoCancellation: audioConfig.echoCancellation ?? true,
+          noiseSuppression: audioConfig.noiseSuppression ?? true,
+          autoGainControl: audioConfig.autoGainControl ?? true
+        }
+      });
+      await this.initAudioContext();
+      if (this.transport === "http") {
+        this.setStatus("RECORDING" /* RECORDING */);
+      }
+      this.setupVisibilityListener();
+      this.emit("start");
+      this.emit("audiostart");
+    } catch (err) {
+      const error = err;
+      this.emit("error", {
+        code: "NOT_ALLOWED",
+        message: error.message || "\u542F\u52A8\u5931\u8D25",
+        originalError: err
+      });
+      this.cleanup();
+      throw err;
+    }
+  }
+  /**
+   * 初始化 WebSocket 连接
+   */
+  initWebSocket(url) {
+    return new Promise((resolve, reject) => {
+      this.socket = new WebSocket(url);
+      this.socket.binaryType = "arraybuffer";
+      const timeout = setTimeout(() => {
+        reject(new Error("WebSocket \u8FDE\u63A5\u8D85\u65F6"));
+      }, 1e4);
+      this.socket.onopen = () => {
+        clearTimeout(timeout);
+        this.setStatus("RECORDING" /* RECORDING */);
+        this.reconnectAttempts = 0;
+        if (this.adapter.getHandshakeParams) {
+          const params = this.adapter.getHandshakeParams();
+          if (params) {
+            const msg = typeof params === "string" ? params : JSON.stringify(params);
+            this.socket?.send(msg);
+          }
+        }
+        resolve();
+      };
+      this.socket.onerror = (e) => {
+        clearTimeout(timeout);
+        reject(e);
+      };
+      this.socket.onmessage = (e) => {
+        try {
+          const data = e.data;
+          const raw = typeof data === "string" ? data : new TextDecoder().decode(data);
+          const res = this.adapter.parseResult(JSON.parse(raw));
+          if (res) {
+            this.emit("result", res);
+          }
+        } catch {
+        }
+      };
+      this.socket.onclose = () => {
+        if (this._status === "RECORDING" /* RECORDING */) {
+          this.handleReconnect();
+        }
+      };
+    });
+  }
+  /**
+   * 处理重连逻辑
+   */
+  handleReconnect() {
+    const maxAttempts = this.config.maxReconnectAttempts ?? 3;
+    const interval = this.config.reconnectInterval ?? 2e3;
+    if (this.config.autoReconnect && this.reconnectAttempts < maxAttempts) {
+      this.reconnectAttempts++;
+      console.log(`[CloudStrategy] \u5C1D\u8BD5\u91CD\u8FDE (${this.reconnectAttempts}/${maxAttempts})`);
+      this.reconnectTimer = setTimeout(() => {
+        void (async () => {
+          try {
+            if (this.adapter.getConnectUrl) {
+              const url = await Promise.resolve(this.adapter.getConnectUrl());
+              await this.initWebSocket(url);
+            }
+          } catch {
+            this.handleReconnect();
+          }
+        })();
+      }, interval);
+    } else {
+      this.emit("error", {
+        code: "NETWORK",
+        message: "\u8FDE\u63A5\u5DF2\u65AD\u5F00"
+      });
+      void this.stop();
+    }
+  }
+  /**
+   * 初始化音频上下文
+   */
+  async initAudioContext() {
+    const AudioCtor = typeof window !== "undefined" && (window.AudioContext || window.webkitAudioContext);
+    if (!AudioCtor) {
+      throw new Error("\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 AudioContext");
+    }
+    this.audioContext = new AudioCtor();
+    if (this.audioContext.state === "suspended") {
+      await this.audioContext.resume();
+    }
+    const source = this.audioContext.createMediaStreamSource(this.mediaStream);
+    if (this.audioContext.audioWorklet && !this.workletLoaded) {
+      try {
+        const blob = new Blob([WORKLET_CODE], { type: "application/javascript" });
+        await this.audioContext.audioWorklet.addModule(URL.createObjectURL(blob));
+        this.workletLoaded = true;
+        this.setupWorklet(source);
+        console.log("[CloudStrategy] \u4F7F\u7528 AudioWorklet \u6A21\u5F0F");
+        return;
+      } catch (e) {
+        console.warn("[CloudStrategy] AudioWorklet \u52A0\u8F7D\u5931\u8D25\uFF0C\u964D\u7EA7\u5230 ScriptProcessor:", e);
+      }
+    }
+    this.setupScriptProcessor(source);
+    console.log("[CloudStrategy] \u4F7F\u7528 ScriptProcessor \u964D\u7EA7\u6A21\u5F0F");
+  }
+  /**
+   * 设置 AudioWorklet
+   */
+  setupWorklet(source) {
+    this.workletNode = new AudioWorkletNode(this.audioContext, "speech-processor");
+    const audioConfig = this.config.audioConfig ?? {};
+    this.workletNode.port.postMessage({
+      type: "CONFIG",
+      payload: {
+        currentRate: this.audioContext.sampleRate,
+        targetRate: audioConfig.sampleRate ?? 16e3,
+        vadThreshold: audioConfig.vadThreshold ?? 0.02,
+        vadDuration: audioConfig.vadDuration ?? 3e3
+      }
+    });
+    this.workletNode.port.onmessage = (e) => {
+      const { type, payload } = e.data;
+      if (type === "AUDIO_DATA" && payload) {
+        this.handlePCM(payload);
+      }
+      if (type === "VAD_TIMEOUT") {
+        this.emit("speechend");
+        void this.stop();
+      }
+    };
+    this.workletNode.port.postMessage({ type: "SET_RECORDING", payload: true });
+    source.connect(this.workletNode);
+    this.workletNode.connect(this.audioContext.destination);
+    this.emit("speechstart");
+  }
+  /**
+   * 设置 ScriptProcessor (降级方案)
+   */
+  setupScriptProcessor(source) {
+    const bufferSize = 4096;
+    this.scriptProcessor = this.audioContext.createScriptProcessor(bufferSize, 1, 1);
+    const audioConfig = this.config.audioConfig ?? {};
+    const targetRate = audioConfig.sampleRate ?? 16e3;
+    const currentRate = this.audioContext.sampleRate;
+    const secondsPerBuf = bufferSize / currentRate;
+    this.spMaxSilence = (audioConfig.vadDuration ?? 3e3) / 1e3 / secondsPerBuf;
+    this.spSilenceCount = 0;
+    this.isRecordingFlag = true;
+    this.scriptProcessor.onaudioprocess = (e) => {
+      if (!this.isRecordingFlag) return;
+      const input = e.inputBuffer.getChannelData(0);
+      const rms = AudioUtils.calculateRMS(input);
+      if (rms < (audioConfig.vadThreshold ?? 0.02)) {
+        this.spSilenceCount++;
+        if (this.spSilenceCount > this.spMaxSilence) {
+          this.emit("speechend");
+          void this.stop();
+          return;
+        }
+      } else {
+        this.spSilenceCount = 0;
+      }
+      const resampled = AudioUtils.resample(input, currentRate, targetRate);
+      const pcm = AudioUtils.floatTo16BitPCM(resampled);
+      this.handlePCM(pcm.buffer.slice(0));
+    };
+    source.connect(this.scriptProcessor);
+    this.scriptProcessor.connect(this.audioContext.destination);
+    this.emit("speechstart");
+  }
+  /**
+   * 处理 PCM 数据
+   */
+  handlePCM(buffer) {
+    if (this.transport === "websocket") {
+      let payload = buffer;
+      if (this.adapter.transformAudioData) {
+        payload = this.adapter.transformAudioData(buffer);
+      }
+      if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+        this.flushMsgQueue();
+        this.socket.send(payload);
+      } else if (this.socket && this.socket.readyState === WebSocket.CONNECTING) {
+        if (payload instanceof ArrayBuffer && this.msgQueue.length < this.MSG_QUEUE_MAX) {
+          this.msgQueue.push(payload);
+        }
+      }
+    } else {
+      const chunk = buffer.slice(0);
+      this.pcmChunks.push(chunk);
+      this.totalPCMLength += chunk.byteLength / 2;
+    }
+  }
+  /**
+   * 刷新消息队列
+   */
+  flushMsgQueue() {
+    while (this.msgQueue.length > 0 && this.socket?.readyState === WebSocket.OPEN) {
+      const data = this.msgQueue.shift();
+      if (data) {
+        this.socket.send(data);
+      }
+    }
+  }
+  /**
+   * 设置页面可见性监听
+   */
+  setupVisibilityListener() {
+    if (typeof document === "undefined") return;
+    this.visibilityHandler = () => {
+      if (document.hidden && this._status === "RECORDING" /* RECORDING */) {
+        this.emit("error", {
+          code: "NOT_ALLOWED",
+          message: "\u9875\u9762\u5DF2\u8FDB\u5165\u540E\u53F0\uFF0C\u5F55\u97F3\u5DF2\u6682\u505C"
+        });
+        void this.stop();
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  async stop() {
+    if (this._status === "IDLE" /* IDLE */) {
+      return;
+    }
+    this.isRecordingFlag = false;
+    this.workletNode?.port.postMessage({ type: "SET_RECORDING", payload: false });
+    this.mediaStream?.getTracks().forEach((t) => t.stop());
+    if (this.transport === "http" && this.pcmChunks.length > 0 && this.adapter.recognizeShortAudio) {
+      try {
+        this.setStatus("PROCESSING" /* PROCESSING */);
+        const mergedPCM = AudioUtils.mergeBuffers(this.pcmChunks, this.totalPCMLength);
+        const sampleRate = this.config.audioConfig?.sampleRate ?? 16e3;
+        const wavBuffer = AudioUtils.encodeWAV(mergedPCM, sampleRate);
+        const result = await this.adapter.recognizeShortAudio(wavBuffer);
+        this.emit("result", result);
+      } catch (e) {
+        const error = e;
+        this.emit("error", {
+          code: "ADAPTER_ERROR",
+          message: error.message || "\u8BC6\u522B\u5931\u8D25",
+          originalError: e
+        });
+      }
+    }
+    this.cleanup();
+    this.emit("audioend");
+    this.emit("end");
+  }
+  abort() {
+    this.isRecordingFlag = false;
+    this.cleanup();
+    this.emit("end");
+  }
+  isListening() {
+    return this._status === "RECORDING" /* RECORDING */;
+  }
+  /**
+   * 清理资源
+   */
+  cleanup() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+    this.workletNode?.disconnect();
+    this.scriptProcessor?.disconnect();
+    void this.audioContext?.close();
+    if (this.visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
+    this.workletNode = null;
+    this.scriptProcessor = null;
+    this.audioContext = null;
+    this.mediaStream = null;
+    this.pcmChunks = [];
+    this.totalPCMLength = 0;
+    this.msgQueue = [];
+    this.setStatus("IDLE" /* IDLE */);
+  }
+};
+var SpeechRecognizerImpl = class {
+  static {
+    __name(this, "SpeechRecognizerImpl");
+  }
+  strategy = null;
+  config = {};
+  _currentProvider = "browser";
+  _status = "idle";
+  eventHandlers = /* @__PURE__ */ new Map();
+  customProviders = /* @__PURE__ */ new Map();
+  get currentProvider() {
+    return this._currentProvider;
+  }
+  get status() {
+    return this._status;
+  }
+  /**
+   * 获取当前识别状态
+   */
+  get recognitionStatus() {
+    return this.strategy?.status ?? "IDLE" /* IDLE */;
+  }
+  /**
+   * 初始化语音识别器
+   */
+  initialize(config) {
+    this._status = "loading";
+    this.config = {
+      lang: "zh-CN",
+      continuous: false,
+      interimResults: true,
+      maxAlternatives: 1,
+      mode: "auto",
+      autoReconnect: true,
+      maxReconnectAttempts: 3,
+      reconnectInterval: 2e3,
+      audioConfig: {
+        sampleRate: 16e3,
+        vadThreshold: 0.02,
+        vadDuration: 3e3,
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true
+      },
+      ...config
+    };
+    try {
+      this.initializeStrategy();
+      this._status = "ready";
+      return Promise.resolve();
+    } catch (error) {
+      this._status = "error";
+      return Promise.reject(error);
+    }
+  }
+  /**
+   * 初始化识别策略
+   */
+  initializeStrategy() {
+    const advConfig = this.config;
+    const mode = advConfig.mode ?? "auto";
+    const hasNative = typeof window !== "undefined" && ("SpeechRecognition" in window || "webkitSpeechRecognition" in window);
+    if (mode === "native" || mode === "auto" && hasNative && !advConfig.cloudAdapter) {
+      const nativeStrategy = new NativeRecognitionStrategy(advConfig);
+      if (!nativeStrategy.isAvailable()) {
+        throw new Error("\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u539F\u751F\u8BED\u97F3\u8BC6\u522B");
+      }
+      this.strategy = nativeStrategy;
+      this._currentProvider = "browser";
+    } else if (mode === "cloud" || mode === "auto" && advConfig.cloudAdapter) {
+      if (!advConfig.cloudAdapter) {
+        throw new Error("\u4E91\u7AEF\u6A21\u5F0F\u9700\u8981\u63D0\u4F9B cloudAdapter");
+      }
+      this.strategy = new CloudRecognitionStrategy(advConfig);
+      this._currentProvider = "custom";
+    } else {
+      throw new Error("\u6CA1\u6709\u53EF\u7528\u7684\u8BC6\u522B\u7B56\u7565");
+    }
+    this.forwardStrategyEvents();
+  }
+  /**
+   * 转发策略事件
+   */
+  forwardStrategyEvents() {
+    if (!this.strategy) return;
+    this.strategy.on("result", (res) => {
+      this.emit("result", {
+        type: "result",
+        result: this.convertResult(res)
+      });
+    });
+    this.strategy.on("error", (err) => {
+      const errorEvent = {
+        type: "error",
+        error: {
+          code: err.code,
+          message: err.message
+        }
+      };
+      if (err.originalError) {
+        errorEvent.error.originalError = err.originalError;
+      }
+      this.emit("error", errorEvent);
+    });
+    this.strategy.on("start", () => this.emit("start", { type: "start" }));
+    this.strategy.on("end", () => this.emit("end", { type: "end" }));
+    this.strategy.on("soundstart", () => this.emit("soundstart", { type: "soundstart" }));
+    this.strategy.on("soundend", () => this.emit("soundend", { type: "soundend" }));
+    this.strategy.on("speechstart", () => this.emit("speechstart", { type: "speechstart" }));
+    this.strategy.on("speechend", () => this.emit("speechend", { type: "speechend" }));
+    this.strategy.on("audiostart", () => this.emit("audiostart", { type: "audiostart" }));
+    this.strategy.on("audioend", () => this.emit("audioend", { type: "audioend" }));
+  }
+  /**
+   * 转换识别结果格式
+   */
+  convertResult(res) {
+    return {
+      results: [
+        {
+          transcript: res.transcript,
+          confidence: res.confidence,
+          isFinal: res.isFinal
+        }
+      ],
+      bestTranscript: res.transcript,
+      bestConfidence: res.confidence,
+      isFinal: res.isFinal
+    };
+  }
+  /**
+   * 开始识别
+   */
+  async start(config) {
+    if (this._status !== "ready") {
+      throw new Error("\u8BC6\u522B\u5668\u672A\u5C31\u7EEA");
+    }
+    if (config) {
+      this.config = { ...this.config, ...config };
+      this.initializeStrategy();
+    }
+    return this.strategy?.start();
+  }
+  /**
+   * 停止识别
+   */
+  stop() {
+    this.strategy?.stop();
+  }
+  /**
+   * 中止识别
+   */
+  abort() {
+    this.strategy?.abort();
+  }
+  /**
+   * 是否正在识别
+   */
+  isListening() {
+    return this.strategy?.isListening() ?? false;
+  }
+  /**
+   * 添加事件监听
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * 移除事件监听
+   */
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * 触发事件
+   */
+  emit(type, event) {
+    this.eventHandlers.get(type)?.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (e) {
+        console.error("[SpeechRecognizer] \u4E8B\u4EF6\u5904\u7406\u5668\u9519\u8BEF:", e);
+      }
+    });
+  }
+  /**
+   * 销毁实例
+   */
+  dispose() {
+    this.strategy?.dispose();
+    this.strategy = null;
+    this.eventHandlers.clear();
+    this._status = "idle";
+  }
+  /**
+   * 注册自定义提供商
+   */
+  registerProvider(type, provider) {
+    this.customProviders.set(type, provider);
+  }
+  /**
+   * 使用云端适配器
+   */
+  useCloudAdapter(adapter) {
+    this.config.cloudAdapter = adapter;
+    this.config.mode = "cloud";
+  }
+};
+function getSpeechRecognitionConstructor() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  return window.SpeechRecognition ?? window.webkitSpeechRecognition ?? null;
+}
+__name(getSpeechRecognitionConstructor, "getSpeechRecognitionConstructor");
+async function createSpeechRecognizer(config) {
+  const recognizer = new SpeechRecognizerImpl();
+  await recognizer.initialize(config);
+  return recognizer;
+}
+__name(createSpeechRecognizer, "createSpeechRecognizer");
+function isSpeechRecognitionSupported() {
+  return getSpeechRecognitionConstructor() !== null;
+}
+__name(isSpeechRecognitionSupported, "isSpeechRecognitionSupported");
+async function listen(config) {
+  const recognizer = await createSpeechRecognizer({
+    ...config,
+    continuous: false
+  });
+  return new Promise((resolve, reject) => {
+    let hasResult = false;
+    recognizer.on("result", (event) => {
+      if (event.result && event.result.isFinal) {
+        hasResult = true;
+        recognizer.dispose();
+        resolve(event.result);
+      }
+    });
+    recognizer.on("error", (event) => {
+      recognizer.dispose();
+      reject(event.error);
+    });
+    recognizer.on("end", () => {
+      if (!hasResult) {
+        recognizer.dispose();
+        resolve({
+          results: [],
+          bestTranscript: "",
+          bestConfidence: 0,
+          isFinal: true
+        });
+      }
+    });
+    recognizer.start().catch(reject);
+  });
+}
+__name(listen, "listen");
+
+export { SpeechRecognizerImpl, SpeechSynthesizerImpl, createSpeechRecognizer, createSpeechSynthesizer, isSpeechRecognitionSupported, isSpeechSynthesisSupported, listen, speak };
+//# sourceMappingURL=chunk-3RM45M64.js.map
+//# sourceMappingURL=chunk-3RM45M64.js.map