@remotion/whisper-web 4.0.302

package/dist/esm/index.mjs

@@ -0,0 +1,652 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/constants.ts
+var DB_NAME = "whisper-web";
+var DB_VERSION = 1;
+var DB_OBJECT_STORE_NAME = "models";
+var MODELS = [
+  "tiny",
+  "tiny.en",
+  "base",
+  "base.en",
+  "small",
+  "small.en"
+];
+var SIZES = {
+  tiny: 77691713,
+  "tiny.en": 77704715,
+  base: 147951465,
+  "base.en": 147964211,
+  small: 487601967,
+  "small.en": 487614201
+};
+
+// src/db/open-db.ts
+var openDb = (transactionMode) => {
+  return new Promise((resolve, reject) => {
+    const rq = indexedDB.open(DB_NAME, DB_VERSION);
+    rq.onupgradeneeded = (event) => {
+      try {
+        const db = rq.result;
+        if (event.oldVersion < DB_VERSION) {
+          db.createObjectStore(DB_OBJECT_STORE_NAME, { autoIncrement: false });
+        } else {
+          const { transaction } = event.currentTarget;
+          if (!transaction) {
+            throw new Error("No transaction available during upgrade");
+          }
+          const objectStore = transaction.objectStore(DB_OBJECT_STORE_NAME);
+          if (!objectStore) {
+            throw new Error("Could not access object store during upgrade");
+          }
+          objectStore.clear();
+        }
+      } catch (err) {
+        reject(new Error(`Failed to upgrade database: ${err}`));
+      }
+    };
+    rq.onsuccess = () => {
+      try {
+        const db = rq.result;
+        const transaction = db.transaction([DB_OBJECT_STORE_NAME], transactionMode);
+        transaction.onerror = () => {
+          reject(new Error("Transaction failed"));
+        };
+        transaction.onabort = () => {
+          reject(new Error("Transaction aborted"));
+        };
+        const objectStore = transaction.objectStore(DB_OBJECT_STORE_NAME);
+        resolve(objectStore);
+      } catch (err) {
+        reject(new Error(`Failed to open database: ${err}`));
+      }
+    };
+    rq.onerror = () => {
+      const error = rq.error?.message ?? "Unknown error";
+      reject(new Error(`Failed to open IndexedDB: ${error}`));
+    };
+    rq.onblocked = () => {
+      reject(new Error("Database is blocked by another connection"));
+    };
+  });
+};
+
+// src/db/delete-object.ts
+var deleteObject = async ({ key }) => {
+  const objectStore = await openDb("readwrite");
+  return new Promise((resolve, reject) => {
+    const request = objectStore.delete(key);
+    request.onsuccess = () => {
+      resolve();
+    };
+    request.onerror = () => {
+      reject(request.error);
+    };
+  });
+};
+
+// src/get-model-url.ts
+var getModelUrl = (model) => {
+  return `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-${model}.bin`;
+};
+
+// src/delete-model.ts
+var deleteModel = async (model) => {
+  const url = getModelUrl(model);
+  await deleteObject({ key: url });
+};
+// src/can-use-whisper-web.ts
+var canUseWhisperWeb = async (model) => {
+  if (typeof window === "undefined") {
+    return {
+      supported: false,
+      reason: "window-undefined" /* WindowUndefined */,
+      detailedReason: "`window` is not defined. This module can only be used in a browser environment."
+    };
+  }
+  if (!window.crossOriginIsolated) {
+    return {
+      supported: false,
+      reason: "not-cross-origin-isolated" /* NotCrossOriginIsolated */,
+      detailedReason: "The document is not cross-origin isolated (window.crossOriginIsolated = false). This prevents the usage of SharedArrayBuffer, which is required by `@remotion/whisper-web`. Make sure the document is served with the HTTP header `Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp`: https://developer.mozilla.org/en-US/docs/Web/API/Window/crossOriginIsolated"
+    };
+  }
+  if (!window.indexedDB) {
+    return {
+      supported: false,
+      reason: "indexed-db-unavailable" /* IndexedDbUnavailable */,
+      detailedReason: "IndexedDB is not available in this environment."
+    };
+  }
+  if (!navigator?.storage || !navigator?.storage.estimate) {
+    return {
+      supported: false,
+      reason: "navigator-storage-unavailable" /* NavigatorStorageUnavailable */,
+      detailedReason: "`navigator.storage.estimate()` API is not available in this environment."
+    };
+  }
+  try {
+    const estimate = await navigator.storage.estimate();
+    if (estimate.quota === undefined) {
+      return {
+        supported: false,
+        reason: "quota-undefined" /* QuotaUndefined */,
+        detailedReason: "navigator.storage.estimate() API returned undefined quota."
+      };
+    }
+    if (estimate.usage === undefined) {
+      return {
+        supported: false,
+        reason: "usage-undefined" /* UsageUndefined */,
+        detailedReason: "navigator.storage.estimate() API returned undefined usage."
+      };
+    }
+    const remaining = estimate.quota - estimate.usage;
+    const modelSize = SIZES[model];
+    if (remaining < modelSize) {
+      return {
+        supported: false,
+        reason: "not-enough-space" /* NotEnoughSpace */,
+        detailedReason: `Not enough space to download the model. Required: ${modelSize} bytes, Available: ${remaining} bytes.`
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      supported: false,
+      reason: "error-estimating-storage" /* ErrorEstimatingStorage */,
+      detailedReason: `Error estimating storage: ${errorMessage}`
+    };
+  }
+  return {
+    supported: true
+  };
+};
+
+// src/db/get-object-from-db.ts
+var getObjectFromObjectStore = ({
+  objectStore,
+  key
+}) => {
+  return new Promise((resolve, reject) => {
+    const request = objectStore.get(key);
+    request.onsuccess = () => {
+      resolve(request.result);
+    };
+    request.onerror = () => {
+      reject(request.error);
+    };
+  });
+};
+var getKeysFromObjectStore = ({
+  objectStore
+}) => {
+  return new Promise((resolve, reject) => {
+    const request = objectStore.getAllKeys();
+    request.onsuccess = () => {
+      resolve(request.result);
+    };
+    request.onerror = () => {
+      reject(request.error);
+    };
+  });
+};
+var getObject = async ({ key }) => {
+  const objectStore = await openDb("readonly");
+  return getObjectFromObjectStore({ objectStore, key });
+};
+
+// src/db/put-object.ts
+var putObject = async ({
+  key,
+  value
+}) => {
+  const objectStore = await openDb("readwrite");
+  return new Promise((resolve, reject) => {
+    try {
+      const putRq = objectStore.put(value, key);
+      putRq.onsuccess = () => {
+        resolve();
+      };
+      putRq.onerror = () => {
+        reject(new Error(`Failed to store "${key}" in IndexedDB`));
+      };
+    } catch (e) {
+      reject(new Error(`Failed to store "${key}" in IndexedDB: ${e}`));
+    }
+  });
+};
+
+// src/download-model.ts
+var fetchRemote = async ({
+  url,
+  onProgress,
+  expectedLength
+}) => {
+  const response = await fetch(url, { method: "get" });
+  if (!response.ok || !response.body) {
+    throw new Error(`failed to fetch: ${url}`);
+  }
+  const contentLength = response.headers.get("content-length");
+  const total = parseInt(contentLength, 10);
+  if (total !== expectedLength) {
+    throw new Error(`Content-Length header is ${total} for ${url} but expected ${expectedLength}`);
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let receivedLength = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    chunks.push(value);
+    receivedLength += value.length;
+    onProgress(receivedLength);
+  }
+  let position = 0;
+  const chunksAll = new Uint8Array(receivedLength);
+  for (const chunk of chunks) {
+    chunksAll.set(chunk, position);
+    position += chunk.length;
+  }
+  return chunksAll;
+};
+
+// src/download-whisper-model.ts
+var downloadWhisperModel = async ({
+  model,
+  onProgress
+}) => {
+  if (!model || !MODELS.includes(model)) {
+    throw new Error(`Invalid model name: ${model}. Supported models: ${MODELS.join(", ")}.`);
+  }
+  const usabilityCheck = await canUseWhisperWeb(model);
+  if (!usabilityCheck.supported) {
+    return Promise.reject(new Error(`Whisper.wasm is not supported in this environment. Reason: ${usabilityCheck.detailedReason}`));
+  }
+  const url = getModelUrl(model);
+  const modelSize = SIZES[model];
+  const existingModel = await getObject({ key: url });
+  if (existingModel) {
+    onProgress({
+      downloadedBytes: modelSize,
+      totalBytes: modelSize,
+      progress: 1
+    });
+    return {
+      alreadyDownloaded: true
+    };
+  }
+  const data = await fetchRemote({
+    url,
+    onProgress: (bytes) => {
+      onProgress({
+        downloadedBytes: bytes,
+        progress: bytes / modelSize,
+        totalBytes: modelSize
+      });
+    },
+    expectedLength: modelSize
+  });
+  onProgress({
+    downloadedBytes: modelSize,
+    totalBytes: modelSize,
+    progress: 1
+  });
+  await putObject({ key: url, value: data });
+  return {
+    alreadyDownloaded: false
+  };
+};
+// src/get-loaded-models.ts
+var getLoadedModels = async () => {
+  const objectStore = await openDb("readonly");
+  const loadedModels = [];
+  const result = await getKeysFromObjectStore({
+    objectStore
+  });
+  for (const model of MODELS) {
+    if (result.includes(getModelUrl(model))) {
+      loadedModels.push(model);
+    }
+  }
+  return loadedModels;
+};
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
+// src/resample-to-16khz.ts
+var EXPECTED_SAMPLE_RATE = 16000;
+var context;
+var getAudioContext = () => {
+  if (!context) {
+    context = new AudioContext({
+      sampleRate: EXPECTED_SAMPLE_RATE
+    });
+  }
+  return context;
+};
+var audioDecoder = async (audioBuffer) => {
+  const offlineContext = new OfflineAudioContext(audioBuffer.numberOfChannels, audioBuffer.length, audioBuffer.sampleRate);
+  const source = offlineContext.createBufferSource();
+  source.buffer = audioBuffer;
+  source.connect(offlineContext.destination);
+  source.start(0);
+  const renderedBuffer = await offlineContext.startRendering();
+  return renderedBuffer.getChannelData(0);
+};
+var resampleTo16Khz = async ({
+  file,
+  onProgress,
+  logLevel = "info"
+}) => {
+  Log.info(logLevel, `Starting resampling for file, size: ${file.size}`);
+  onProgress?.(0);
+  if (typeof window === "undefined") {
+    Log.error(logLevel, "Window object not found. Resampling can only be done in a browser environment.");
+    throw new Error("Window object not found. Resampling requires a browser environment.");
+  }
+  if (!file) {
+    Log.error(logLevel, "File is empty.");
+    throw new Error("File is empty");
+  }
+  const innerContext = getAudioContext();
+  const reader = new FileReader;
+  return new Promise((resolve, reject) => {
+    reader.onprogress = (event) => {
+      if (event.lengthComputable) {
+        const percentage = event.loaded / event.total * 0.5;
+        onProgress?.(Math.min(0.5, percentage));
+      }
+    };
+    reader.onload = async () => {
+      try {
+        Log.info(logLevel, "File reading complete. Decoding audio data...");
+        onProgress?.(0.5);
+        const buffer = new Uint8Array(reader.result);
+        const audioBuffer = await innerContext.decodeAudioData(buffer.buffer);
+        Log.info(logLevel, "Audio decoding complete. Starting rendering...");
+        onProgress?.(0.75);
+        const processedAudio = await audioDecoder(audioBuffer);
+        Log.info(logLevel, "Audio resampling and processing complete.");
+        onProgress?.(1);
+        resolve(processedAudio);
+      } catch (error) {
+        Log.error(logLevel, "Error during audio processing:", error);
+        reject(error);
+      }
+    };
+    reader.onerror = () => {
+      Log.error(logLevel, "File reading failed.");
+      reject(new Error("File reading failed"));
+    };
+    reader.readAsArrayBuffer(file);
+  });
+};
+// src/load-mod/load-mod.ts
+var loadMod = async () => {
+  const Mod = await import("../../main.js");
+  return Mod.default;
+};
+
+// src/print-handler.ts
+var RESULT_TOKEN = "remotion_final:";
+var PROGRESS_TOKEN = "remotion_progress:";
+var UPDATE_TOKEN = "remotion_update:";
+var BUSY_TOKEN = "remotion_busy:";
+var printHandler = ({
+  onProgress,
+  onDone,
+  onBusy,
+  onUpdate,
+  logLevel
+}) => {
+  return (text) => {
+    Log.verbose(logLevel, text);
+    if (text.startsWith(PROGRESS_TOKEN)) {
+      const value = parseInt(text.slice(PROGRESS_TOKEN.length), 10);
+      onProgress(value);
+    } else if (text.startsWith(RESULT_TOKEN)) {
+      const json = JSON.parse(text.slice(RESULT_TOKEN.length));
+      onDone(json);
+    } else if (text.startsWith(UPDATE_TOKEN)) {
+      const json = JSON.parse(text.slice(UPDATE_TOKEN.length));
+      onUpdate(json);
+    } else if (text.startsWith(BUSY_TOKEN)) {
+      onBusy();
+    }
+  };
+};
+
+// src/transcription-speed.ts
+var storeActualTranscriptionSpeed = (speed) => {
+  window.localStorage.setItem("remotion-whisper-web-transcription-speed", speed.toString());
+};
+var DEFAULT_ASSUMED_SPEED = 1;
+var NEW_PROGRESS_EVENT_EVERY_N_SECONDS = 30;
+var getActualTranscriptionSpeedInMilliseconds = () => {
+  const speed = window.localStorage.getItem("remotion-whisper-web-transcription-speed");
+  if (!speed) {
+    return DEFAULT_ASSUMED_SPEED * NEW_PROGRESS_EVENT_EVERY_N_SECONDS * 1000;
+  }
+  return parseFloat(speed);
+};
+
+// src/simulate-progress.ts
+var simulateProgress = ({
+  audioDurationInSeconds,
+  onProgress
+}) => {
+  let progress = 0;
+  const progressSteps = audioDurationInSeconds / NEW_PROGRESS_EVENT_EVERY_N_SECONDS;
+  let progressStepsReceived = 0;
+  let timer = null;
+  let lastTimerStart = null;
+  const start = () => {
+    const speed = getActualTranscriptionSpeedInMilliseconds();
+    let iterations = 0;
+    lastTimerStart = Date.now();
+    timer = setInterval(() => {
+      progress += 1 / NEW_PROGRESS_EVENT_EVERY_N_SECONDS / (progressSteps + 1);
+      progress = Math.min(progress, 0.99);
+      onProgress(progress);
+      iterations += 1;
+      if (iterations > NEW_PROGRESS_EVENT_EVERY_N_SECONDS - 1 && timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    }, speed / NEW_PROGRESS_EVENT_EVERY_N_SECONDS);
+  };
+  return {
+    start,
+    progressStepReceived: () => {
+      progressStepsReceived += 1;
+      progress = progressStepsReceived / progressSteps;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      if (lastTimerStart) {
+        const timeToProcessChunk = Date.now() - (lastTimerStart ?? Date.now());
+        storeActualTranscriptionSpeed(timeToProcessChunk);
+      }
+      start();
+    },
+    onDone: () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      progress = 1;
+      onProgress(1);
+    },
+    abort: () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    }
+  };
+};
+
+// src/transcribe.ts
+var MAX_THREADS_ALLOWED = 16;
+var DEFAULT_THREADS = 4;
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+var storeFS = (mod, fname, buf) => {
+  try {
+    mod.FS_unlink(fname);
+  } catch {}
+  mod.FS_createDataFile("/", fname, buf, true, true, undefined);
+};
+var transcribe = async ({
+  channelWaveform,
+  model,
+  language = "auto",
+  onProgress,
+  threads,
+  onTranscriptionChunk,
+  logLevel = "info"
+}) => {
+  if (!channelWaveform || channelWaveform.length === 0) {
+    Log.error(logLevel, "No audio data provided or audio data is empty.");
+    throw new Error("No audio data provided or audio data is empty.");
+  }
+  Log.info(logLevel, `Starting transcription with model: ${model}, language: ${language}, threads: ${threads ?? DEFAULT_THREADS}`);
+  if ((threads ?? DEFAULT_THREADS) > MAX_THREADS_ALLOWED) {
+    Log.warn(logLevel, `Thread limit exceeded: Used ${threads ?? DEFAULT_THREADS}, max ${MAX_THREADS_ALLOWED} allowed.`);
+    return Promise.reject(new Error(`Thread limit exceeded: max ${MAX_THREADS_ALLOWED} allowed.`));
+  }
+  const audioDurationInSeconds = channelWaveform.length / EXPECTED_SAMPLE_RATE;
+  const {
+    abort: abortProgress,
+    onDone: onProgressDone,
+    progressStepReceived,
+    start: startProgress
+  } = simulateProgress({
+    audioDurationInSeconds,
+    onProgress: (p) => {
+      onProgress?.(p);
+    }
+  });
+  const {
+    promise,
+    resolve: _resolve,
+    reject: _reject
+  } = withResolvers();
+  const resolve = (value) => {
+    _resolve(value);
+    abortProgress();
+    Log.info(logLevel, "Transcription completed successfully.");
+  };
+  const reject = (reason) => {
+    _reject(reason);
+    abortProgress();
+    Log.error("Transcription failed:", reason);
+  };
+  const handler = printHandler({
+    logLevel,
+    onProgress: (p) => {
+      if (p === 0) {
+        startProgress();
+      } else if (p === 100) {
+        onProgressDone();
+      } else {
+        progressStepReceived();
+      }
+    },
+    onDone: resolve,
+    onBusy: () => {
+      reject(new Error("Another transcription is already in progress"));
+    },
+    onUpdate: (json) => {
+      onTranscriptionChunk?.(json.transcription);
+    }
+  });
+  window.remotion_wasm_moduleOverrides = {
+    print: handler,
+    printErr: handler
+  };
+  const Mod = await loadMod();
+  delete window.remotion_wasm_moduleOverrides;
+  const url = getModelUrl(model);
+  const result = await getObject({ key: url });
+  if (!result) {
+    throw new Error(`Model ${model} is not loaded. Call downloadWhisperModel() first.`);
+  }
+  Log.info(logLevel, `Model ${model} loaded successfully.`);
+  const fileName = `${model}.bin`;
+  storeFS(Mod, fileName, result);
+  Log.info(logLevel, "Starting main transcription process...");
+  Mod.full_default(fileName, channelWaveform, model, language, threads ?? DEFAULT_THREADS, false);
+  return promise;
+};
+export {
+  transcribe,
+  resampleTo16Khz,
+  getLoadedModels,
+  downloadWhisperModel,
+  deleteModel
+};

package/dist/get-loaded-models.d.ts

@@ -0,0 +1,2 @@
+import type { WhisperWebModel } from './constants';
+export declare const getLoadedModels: () => Promise<WhisperWebModel[]>;

package/dist/get-loaded-models.js

@@ -0,0 +1,17 @@
+import { MODELS } from './constants';
+import { getKeysFromObjectStore } from './db/get-object-from-db';
+import { openDb } from './db/open-db';
+import { getModelUrl } from './get-model-url';
+export const getLoadedModels = async () => {
+    const objectStore = await openDb('readonly');
+    const loadedModels = [];
+    const result = await getKeysFromObjectStore({
+        objectStore,
+    });
+    for (const model of MODELS) {
+        if (result.includes(getModelUrl(model))) {
+            loadedModels.push(model);
+        }
+    }
+    return loadedModels;
+};

package/dist/get-model-url.d.ts

@@ -0,0 +1,9 @@
+import type { WhisperWebModel } from './constants';
+export declare const getModelUrl: (model: WhisperWebModel) => string;
+export declare const sizes: {
+    tiny: number;
+    base: number;
+    small: number;
+    medium: number;
+    large: number;
+};

package/dist/get-model-url.js

@@ -0,0 +1,10 @@
+export const getModelUrl = (model) => {
+    return `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-${model}.bin`;
+};
+export const sizes = {
+    tiny: 74000000,
+    base: 244000000,
+    small: 769000000,
+    medium: 1550000000,
+    large: 3050000000,
+};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { CanUseWhisperWebResult, canUseWhisperWeb as originalCanUseWhisperWeb, WhisperWebUnsupportedReason } from './can-use-whisper-web';
+import type { WhisperWebLanguage, WhisperWebModel } from './constants';
+import type { deleteModel as originalDeleteModel } from './delete-model';
+import type { DownloadWhisperModelOnProgress, DownloadWhisperModelParams, DownloadWhisperModelProgress, DownloadWhisperModelResult, downloadWhisperModel as originalDownloadWhisperModel } from './download-whisper-model';
+import type { getLoadedModels as originalGetLoadedModels } from './get-loaded-models';
+import type { resampleTo16Khz as originalResampleTo16Khz, ResampleTo16KhzParams } from './resample-to-16khz';
+import type { transcribe as originalTranscribe, TranscribeParams } from './transcribe';
+export declare const transcribe: typeof originalTranscribe;
+export declare const downloadWhisperModel: typeof originalDownloadWhisperModel;
+export declare const getLoadedModels: typeof originalGetLoadedModels;
+export declare const deleteModel: typeof originalDeleteModel;
+export declare const canUseWhisperWeb: typeof originalCanUseWhisperWeb;
+export declare const resampleTo16Khz: typeof originalResampleTo16Khz;
+export type { CanUseWhisperWebResult, DownloadWhisperModelOnProgress, DownloadWhisperModelParams, DownloadWhisperModelProgress, DownloadWhisperModelResult, ResampleTo16KhzParams, TranscribeParams, WhisperWebLanguage, WhisperWebModel, WhisperWebUnsupportedReason, };