@timur00kh/whisper.wasm 0.0.1

package/dist/index.es.js

@@ -0,0 +1,576 @@
+const p = class p {
+  constructor(e = p.levels.INFO, t = "") {
+    this.level = e, this.prefix = t;
+  }
+  debug(...e) {
+    this.level <= p.levels.DEBUG && console.debug(`[${this.prefix}] [DEBUG]`, ...e);
+  }
+  info(...e) {
+    this.level <= p.levels.INFO && console.info(`[${this.prefix}] [INFO]`, ...e);
+  }
+  warn(...e) {
+    this.level <= p.levels.WARN && console.warn(`[${this.prefix}] [WARN]`, ...e);
+  }
+  error(...e) {
+    this.level <= p.levels.ERROR && console.error(`[${this.prefix}] [ERROR]`, ...e);
+  }
+  setLevel(e) {
+    this.level = e;
+  }
+  getLevel() {
+    return this.level;
+  }
+};
+p.levels = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+let b = p;
+const _ = async () => WebAssembly.validate(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 253, 15, 253, 98, 11])), B = {
+  language: "auto",
+  threads: 4,
+  translate: !1
+};
+function M(l) {
+  const e = String(l).trim().replace(",", "."), t = e.split(":").map(Number);
+  if (t.some(Number.isNaN)) throw new Error(`Bad time: "${l}"`);
+  let r = 0, a = 0, i = 0;
+  if (t.length === 3)
+    [r, a] = t, i = parseFloat(e.split(":").pop() || "0");
+  else if (t.length === 2)
+    [a] = t, i = parseFloat(e.split(":").pop() || "0");
+  else
+    throw new Error(`Bad time format: "${l}"`);
+  return Math.floor(((r * 60 + a) * 60 + i) * 1e3);
+}
+function T(l) {
+  const t = /^\s*\[?\s*([0-9]{1,2}:[0-9]{2}:(?:[0-9]{2}[.,][0-9]{1,3})|[0-9]{1,2}:[0-9]{2}[.,][0-9]{1,3})\s*-->\s*([0-9]{1,2}:[0-9]{2}:(?:[0-9]{2}[.,][0-9]{1,3})|[0-9]{1,2}:[0-9]{2}[.,][0-9]{1,3})\s*\]?\s*(.*)\s*$/.exec(l);
+  if (!t)
+    throw new Error("Line does not match VTT-like pattern: " + l);
+  const r = t[1], a = t[2], i = t[3] || "", s = M(r), n = M(a);
+  if (n < s)
+    throw new Error("End time is before start time");
+  return {
+    startMs: s,
+    endMs: n,
+    start: r,
+    end: a,
+    text: i
+  };
+}
+function q(l) {
+  return new Promise((e) => setTimeout(e, l));
+}
+function R(l, e = 16e3 * 100) {
+  const t = [];
+  for (let r = 0; r < l.length; r += e)
+    t.push(l.subarray(r, r + e));
+  return t;
+}
+class x {
+  constructor(e, t) {
+    this.whisperService = e, this.logger = new b((t == null ? void 0 : t.logLevel) || b.levels.ERROR, "TranscriptionSession");
+  }
+  async *streamimg(e, t = {}) {
+    const r = R(e);
+    let a = 0;
+    for await (const i of r) {
+      const s = [];
+      let n = null, o = !1, h, d = 0;
+      for (this.whisperService.transcribe(
+        i,
+        (c) => {
+          d = c.timeEnd, c.timeStart += a, c.timeEnd += a, n ? (n(c), n = null) : s.push(c);
+        },
+        t
+      ).then(() => {
+        o = !0, a += d, n == null || n(void 0);
+      }).catch((c) => {
+        h = c;
+      }); ; ) {
+        if (h) throw h;
+        if (o) break;
+        if (s.length)
+          yield s.shift();
+        else {
+          const c = await new Promise((f) => n = f);
+          c && (yield c);
+        }
+      }
+      t.sleepMsBetweenChunks && await q(t.sleepMsBetweenChunks);
+    }
+  }
+}
+class L extends EventTarget {
+  on(e, t) {
+    return this.addEventListener(e, t), () => this.removeEventListener(e, t);
+  }
+  emit(e, t) {
+    this.dispatchEvent(new CustomEvent(e, { detail: t }));
+  }
+}
+class A {
+  constructor(e) {
+    this.wasmModule = null, this.instance = null, this.modelFileName = "whisper.bin", this.isTranscribing = !1, this.bus = new L(), this.logger = new b((e == null ? void 0 : e.logLevel) ?? b.levels.ERROR, "WhisperWasmService"), e != null && e.init && this.loadWasmScript();
+  }
+  async checkWasmSupport() {
+    return await _();
+  }
+  async loadWasmScript() {
+    this.wasmModule = await (await import("./libmain-DyRJqz-4.mjs")).default({
+      print: (e, ...t) => {
+        this.logger.debug(t), e.startsWith("[") ? (this.logger.info(e), this.bus.emit("transcribe", e)) : (this.logger.debug(e), this.bus.emit("system_info", e));
+      },
+      printErr: (e, ...t) => {
+        this.logger.debug(t), this.logger.warn(e), this.bus.emit("transcribeError", e);
+      }
+    });
+  }
+  async loadWasmModule(e) {
+    if (!await this.checkWasmSupport())
+      throw new Error("WASM is not supported");
+    return this.wasmModule && (this.wasmModule.FS_unlink(this.modelFileName), this.wasmModule.free()), await this.loadWasmScript(), await q(100), this.storeFS(this.modelFileName, e), this.instance = this.wasmModule.init(this.modelFileName), Promise.resolve();
+  }
+  storeFS(e, t) {
+    if (!this.wasmModule)
+      throw new Error("WASM module not loaded");
+    try {
+      this.wasmModule.FS_unlink(e);
+    } catch {
+    }
+    this.wasmModule.FS_createDataFile("/", e, t, !0, !0, !0);
+  }
+  async transcribe(e, t, r = {}) {
+    if (this.isTranscribing)
+      throw new Error("Already transcribing");
+    if (!this.wasmModule)
+      throw new Error("WASM module not loaded");
+    if (!this.instance)
+      throw new Error("WASM instance not loaded");
+    const a = 120;
+    e.length > 16e3 * a && this.logger.warn(
+      "It's not recommended to transcribe audio data that is longer than 120 seconds"
+    ), this.isTranscribing = !0;
+    const { language: i, threads: s, translate: n } = {
+      ...B,
+      ...r
+    }, o = [], h = Date.now();
+    return this.wasmModule.full_default(this.instance, e, i, s, n), await new Promise((d, c) => {
+      const f = this.bus.on("transcribe", (g) => {
+        const { startMs: w, endMs: y, text: z } = T(g.detail), v = {
+          timeStart: w,
+          timeEnd: y,
+          text: z,
+          raw: g.detail
+        };
+        o.push(v), t == null || t(v);
+      }), u = setTimeout(
+        () => {
+          this.isTranscribing = !1, f(), m(), this.logger.error("Transcribe timeout"), c(new Error("Transcribe timeout"));
+        },
+        a * 2 * 1e3
+      ), m = this.bus.on("transcribeError", (g) => {
+        this.isTranscribing = !1, f(), m(), clearTimeout(u), this.logger.debug("Transcribe error", g.detail), d({ segments: o, transcribeDurationMs: Date.now() - h });
+      });
+    });
+  }
+  createSession() {
+    return new x(this, { logLevel: this.logger.getLevel() });
+  }
+}
+const S = {
+  "tiny.en": {
+    id: "tiny.en",
+    name: "Tiny English",
+    size: 75,
+    language: "en",
+    quantized: !1,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.en.bin"
+  },
+  tiny: {
+    id: "tiny",
+    name: "Tiny Multilingual",
+    size: 75,
+    language: "multilingual",
+    quantized: !1,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin"
+  },
+  "base.en": {
+    id: "base.en",
+    name: "Base English",
+    size: 142,
+    language: "en",
+    quantized: !1,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin"
+  },
+  base: {
+    id: "base",
+    name: "Base Multilingual",
+    size: 142,
+    language: "multilingual",
+    quantized: !1,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin"
+  },
+  "small.en": {
+    id: "small.en",
+    name: "Small English",
+    size: 466,
+    language: "en",
+    quantized: !1,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.en.bin"
+  },
+  small: {
+    id: "small",
+    name: "Small Multilingual",
+    size: 466,
+    language: "multilingual",
+    quantized: !1,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.bin"
+  },
+  "tiny.en-q5_1": {
+    id: "tiny.en-q5_1",
+    name: "Tiny English (Q5_1)",
+    size: 31,
+    language: "en",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.en-q5_1.bin"
+  },
+  "tiny-q5_1": {
+    id: "tiny-q5_1",
+    name: "Tiny Multilingual (Q5_1)",
+    size: 31,
+    language: "multilingual",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny-q5_1.bin"
+  },
+  "base.en-q5_1": {
+    id: "base.en-q5_1",
+    name: "Base English (Q5_1)",
+    size: 57,
+    language: "en",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en-q5_1.bin"
+  },
+  "base-q5_1": {
+    id: "base-q5_1",
+    name: "Base Multilingual (Q5_1)",
+    size: 57,
+    language: "multilingual",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base-q5_1.bin"
+  },
+  "small.en-q5_1": {
+    id: "small.en-q5_1",
+    name: "Small English (Q5_1)",
+    size: 182,
+    language: "en",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.en-q5_1.bin"
+  },
+  "small-q5_1": {
+    id: "small-q5_1",
+    name: "Small Multilingual (Q5_1)",
+    size: 182,
+    language: "multilingual",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small-q5_1.bin"
+  },
+  "medium.en-q5_0": {
+    id: "medium.en-q5_0",
+    name: "Medium English (Q5_0)",
+    size: 515,
+    language: "en",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-medium.en-q5_0.bin"
+  },
+  "medium-q5_0": {
+    id: "medium-q5_0",
+    name: "Medium Multilingual (Q5_0)",
+    size: 515,
+    language: "multilingual",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-medium-q5_0.bin"
+  },
+  "large-q5_0": {
+    id: "large-q5_0",
+    name: "Large Multilingual (Q5_0)",
+    size: 1030,
+    language: "multilingual",
+    quantized: !0,
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-q5_0.bin"
+  }
+};
+function W() {
+  return Object.values(S).map(({ url: l, ...e }) => e);
+}
+function E(l) {
+  return S[l];
+}
+class F {
+  constructor(e = { logLevel: b.levels.ERROR }) {
+    this.cacheEnabled = !0, this.models = W(), this.logger = new b(e.logLevel, "ModelManager");
+  }
+  /**
+   * Loads model by name
+   */
+  async loadModel(e, t = !0, r) {
+    var m;
+    const a = E(e);
+    if (!a)
+      throw new Error(`Model ${e} not found in config`);
+    if (this.cacheEnabled && t) {
+      const g = await this.getCachedModel(e);
+      if (g)
+        return this.logger.info(`Model ${e} loaded from cache`), r && r(100), g;
+    }
+    this.logger.info(`Loading model ${e} from ${a.url}`);
+    const i = await fetch(a.url);
+    if (!i.ok)
+      throw new Error(`Failed to load model: ${i.statusText}`);
+    const s = i.headers.get("content-length"), n = s ? parseInt(s, 10) : 0;
+    let o = 0;
+    const h = (m = i.body) == null ? void 0 : m.getReader();
+    if (!h)
+      throw new Error("Response body is not readable");
+    const d = [];
+    try {
+      let g = !1;
+      for (; !g; ) {
+        const w = await h.read();
+        if (g = w.done, !g && w.value && (d.push(w.value), o += w.value.length, r && n > 0)) {
+          const y = Math.round(o / n * 100);
+          r(y);
+        }
+      }
+    } finally {
+      h.releaseLock();
+    }
+    const c = d.reduce((g, w) => g + w.length, 0), f = new Uint8Array(c);
+    let u = 0;
+    for (const g of d)
+      f.set(g, u), u += g.length;
+    return this.cacheEnabled && t && await this.saveModelToCache(e, f), r && r(100), f;
+  }
+  /**
+   * Loads WASM model by URL and saves it to IndexedDB using the URL itself as key.
+   */
+  async loadModelByUrl(e, t) {
+    var r;
+    try {
+      if (this.cacheEnabled) {
+        const u = await this.getCachedModelByUrl(e);
+        if (u)
+          return this.logger.info(`WASM module loaded from cache by URL: ${e}`), t && t(100), u;
+      }
+      this.logger.info(`Loading WASM module from URL: ${e}`);
+      const a = await fetch(e);
+      if (!a.ok)
+        throw new Error(`Failed to load WASM module: ${a.statusText}`);
+      const i = a.headers.get("content-length"), s = i ? parseInt(i, 10) : 0;
+      let n = 0;
+      const o = (r = a.body) == null ? void 0 : r.getReader();
+      if (!o)
+        throw new Error("Response body is not readable");
+      const h = [];
+      try {
+        let u = !1;
+        for (; !u; ) {
+          const m = await o.read();
+          if (u = m.done, !u && m.value && (h.push(m.value), n += m.value.length, t && s > 0)) {
+            const g = Math.round(n / s * 100);
+            t(g);
+          }
+        }
+      } finally {
+        o.releaseLock();
+      }
+      const d = h.reduce((u, m) => u + m.length, 0), c = new Uint8Array(d);
+      let f = 0;
+      for (const u of h)
+        c.set(u, f), f += u.length;
+      return this.cacheEnabled && await this.saveModelToCacheByUrl(e, c), t && t(100), c;
+    } catch (a) {
+      throw this.logger.error(a), new Error("Failed to load WASM module");
+    }
+  }
+  /**
+   * Get model from IndexedDB by URL (key is the URL itself)
+   */
+  async getCachedModelByUrl(e) {
+    try {
+      const a = (await this.openIndexedDB()).transaction(["modelsByUrl"], "readonly").objectStore("modelsByUrl");
+      return new Promise((i, s) => {
+        const n = a.get(e);
+        n.onsuccess = () => {
+          const o = n.result;
+          o && o.data ? i(o.data) : i(null);
+        }, n.onerror = () => s(n.error);
+      });
+    } catch (t) {
+      return this.logger.error("Error reading model from cache by URL:", t), null;
+    }
+  }
+  /**
+   * Saves model to IndexedDB by URL (key is the URL itself)
+   */
+  async saveModelToCacheByUrl(e, t) {
+    try {
+      const i = (await this.openIndexedDB()).transaction(["modelsByUrl"], "readwrite").objectStore("modelsByUrl");
+      await new Promise((s, n) => {
+        const o = i.put({
+          url: e,
+          data: t,
+          timestamp: Date.now(),
+          size: t.length
+        });
+        o.onsuccess = () => s(), o.onerror = () => n(o.error);
+      }), this.logger.info(`Model saved to cache by URL: ${e}`);
+    } catch (r) {
+      this.logger.error("Error saving model to cache by URL:", r);
+    }
+  }
+  /**
+   * Gets list of available models with cache information
+   */
+  async getAvailableModels() {
+    const e = [...this.models];
+    if (!this.cacheEnabled)
+      return e;
+    try {
+      const t = await this.getCachedModelNames();
+      return e.map((r) => ({
+        ...r,
+        cached: t.includes(r.id)
+      }));
+    } catch (t) {
+      return this.logger.error("Error checking cache status:", t), e;
+    }
+  }
+  /**
+   * Gets list of available models without cache check (synchronously)
+   */
+  getAvailableModelsSync() {
+    return [...this.models];
+  }
+  /**
+   * Gets model by name from config
+   */
+  getModelConfig(e) {
+    return E(e);
+  }
+  /**
+   * Saves model to IndexedDB
+   */
+  async saveModelToCache(e, t) {
+    try {
+      const i = (await this.openIndexedDB()).transaction(["models"], "readwrite").objectStore("models");
+      await new Promise((s, n) => {
+        const o = i.put({
+          name: e,
+          data: t,
+          timestamp: Date.now(),
+          size: t.length
+        });
+        o.onsuccess = () => s(), o.onerror = () => n(o.error);
+      }), this.logger.info(`Model ${e} saved to cache`);
+    } catch (r) {
+      this.logger.error("Error saving model to cache:", r);
+    }
+  }
+  /**
+   * Gets model from IndexedDB cache
+   */
+  async getCachedModel(e) {
+    try {
+      const a = (await this.openIndexedDB()).transaction(["models"], "readonly").objectStore("models");
+      return new Promise((i, s) => {
+        const n = a.get(e);
+        n.onsuccess = () => {
+          const o = n.result;
+          o && o.data ? i(o.data) : i(null);
+        }, n.onerror = () => s(n.error);
+      });
+    } catch (t) {
+      return this.logger.error("Error getting cached model:", t), null;
+    }
+  }
+  /**
+   * Gets list of model names loaded in cache
+   */
+  async getCachedModelNames() {
+    try {
+      const r = (await this.openIndexedDB()).transaction(["models"], "readonly").objectStore("models");
+      return new Promise((a, i) => {
+        const s = r.getAllKeys();
+        s.onsuccess = () => {
+          const n = s.result;
+          a(n);
+        }, s.onerror = () => i(s.error);
+      });
+    } catch (e) {
+      return this.logger.error("Error getting cached model names:", e), [];
+    }
+  }
+  /**
+   * Opens IndexedDB for model caching
+   */
+  async openIndexedDB() {
+    return new Promise((e, t) => {
+      const r = indexedDB.open("WhisperModels", 2);
+      r.onerror = () => t(r.error), r.onsuccess = () => e(r.result), r.onupgradeneeded = (a) => {
+        const i = a.target.result;
+        if (!i.objectStoreNames.contains("models")) {
+          const s = i.createObjectStore("models", { keyPath: "name" });
+          s.createIndex("timestamp", "timestamp", { unique: !1 }), s.createIndex("size", "size", { unique: !1 });
+        }
+        if (!i.objectStoreNames.contains("modelsByUrl")) {
+          const s = i.createObjectStore("modelsByUrl", { keyPath: "url" });
+          s.createIndex("timestamp", "timestamp", { unique: !1 }), s.createIndex("size", "size", { unique: !1 });
+        }
+      };
+    });
+  }
+  /**
+   * Clears model cache
+   */
+  async clearCache() {
+    try {
+      const t = (await this.openIndexedDB()).transaction(["models", "modelsByUrl"], "readwrite"), r = t.objectStore("models");
+      await new Promise((i, s) => {
+        const n = r.clear();
+        n.onsuccess = () => i(), n.onerror = () => s(n.error);
+      });
+      const a = t.objectStore("modelsByUrl");
+      await new Promise((i, s) => {
+        const n = a.clear();
+        n.onsuccess = () => i(), n.onerror = () => s(n.error);
+      }), this.logger.info("Model cache cleared");
+    } catch (e) {
+      this.logger.error("Error clearing cache:", e);
+    }
+  }
+  /**
+   * Gets cache information
+   */
+  async getCacheInfo() {
+    try {
+      const r = (await this.openIndexedDB()).transaction(["models"], "readonly").objectStore("models");
+      return new Promise((a, i) => {
+        const s = r.getAll();
+        s.onsuccess = () => {
+          const n = s.result, o = n.reduce((h, d) => h + (d.size || 0), 0);
+          a({ count: n.length, totalSize: o });
+        }, s.onerror = () => i(s.error);
+      });
+    } catch (e) {
+      return this.logger.error("Error getting cache info:", e), { count: 0, totalSize: 0 };
+    }
+  }
+}
+export {
+  F as ModelManager,
+  A as WhisperWasmService,
+  W as getAllModels
+};