@remotion/whisper-webgpu 4.0.518

package/README.md

@@ -0,0 +1,18 @@
+# @remotion/whisper-webgpu
+
+Transcribe audio in the browser using Whisper and WebGPU
+
+[![NPM Downloads](https://img.shields.io/npm/dm/@remotion/whisper-webgpu.svg?style=flat&color=black&label=Downloads)](https://npmcharts.com/compare/@remotion/whisper-webgpu?minimal=true)
+
+## Installation
+
+```bash
+npm install @remotion/whisper-webgpu --save-exact
+```
+
+When installing a Remotion package, make sure to align the version of all `remotion` and `@remotion/*` packages to the same version.
+Remove the `^` character from the version number to use the exact version.
+
+## Usage
+
+See the [documentation](https://www.remotion.dev/docs/whisper-webgpu) for more information.

package/dist/can-use-whisper-webgpu.d.ts

@@ -0,0 +1,13 @@
+export declare enum WhisperWebGpuUnsupportedReason {
+    WindowUndefined = "window-undefined",
+    WebGpuUnavailable = "webgpu-unavailable",
+    WebGpuRequiresSecureContext = "webgpu-requires-secure-context"
+}
+export type CanUseWhisperWebGpuResult = {
+    supported: true;
+} | {
+    supported: false;
+    reason: WhisperWebGpuUnsupportedReason;
+    detailedReason: string;
+};
+export declare const canUseWhisperWebGpu: () => Promise<CanUseWhisperWebGpuResult>;

package/dist/clear-stale-models.d.ts

@@ -0,0 +1 @@
+export declare const clearStaleModels: () => Promise<void>;

package/dist/esm/index.mjs

@@ -0,0 +1,433 @@
+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/can-use-whisper-webgpu.ts
+var WhisperWebGpuUnsupportedReason;
+((WhisperWebGpuUnsupportedReason2) => {
+  WhisperWebGpuUnsupportedReason2["WindowUndefined"] = "window-undefined";
+  WhisperWebGpuUnsupportedReason2["WebGpuUnavailable"] = "webgpu-unavailable";
+  WhisperWebGpuUnsupportedReason2["WebGpuRequiresSecureContext"] = "webgpu-requires-secure-context";
+})(WhisperWebGpuUnsupportedReason ||= {});
+var canUseWhisperWebGpu = async () => {
+  if (typeof window === "undefined") {
+    return {
+      supported: false,
+      reason: "window-undefined" /* WindowUndefined */,
+      detailedReason: "`window` is not defined. @remotion/whisper-webgpu is intended for browser environments."
+    };
+  }
+  if (typeof navigator === "undefined" || !("gpu" in navigator)) {
+    return {
+      supported: false,
+      reason: "webgpu-unavailable" /* WebGpuUnavailable */,
+      detailedReason: "WebGPU is not available in this browser."
+    };
+  }
+  if (!window.isSecureContext) {
+    return {
+      supported: false,
+      reason: "webgpu-requires-secure-context" /* WebGpuRequiresSecureContext */,
+      detailedReason: "WebGPU requires HTTPS in production or localhost during development."
+    };
+  }
+  let adapter;
+  try {
+    const { gpu } = navigator;
+    adapter = await gpu.requestAdapter();
+  } catch {
+    adapter = null;
+  }
+  if (!adapter) {
+    return {
+      supported: false,
+      reason: "webgpu-unavailable" /* WebGpuUnavailable */,
+      detailedReason: "No usable WebGPU adapter is available in this browser."
+    };
+  }
+  return { supported: true };
+};
+// src/clear-stale-models.ts
+var clearStaleModels = () => Promise.resolve();
+// src/models.ts
+var WHISPER_WEBGPU_MODELS = [
+  "tiny",
+  "tiny.en",
+  "base",
+  "base.en",
+  "small",
+  "small.en",
+  "medium",
+  "medium.en",
+  "large-v3-turbo"
+];
+var MODEL_INFO = {
+  tiny: {
+    name: "tiny",
+    modelId: "onnx-community/whisper-tiny_timestamped",
+    parameters: 39000000,
+    multilingual: true,
+    webGpuDownloadSize: 119699015
+  },
+  "tiny.en": {
+    name: "tiny.en",
+    modelId: "onnx-community/whisper-tiny.en_timestamped",
+    parameters: 39000000,
+    multilingual: false,
+    webGpuDownloadSize: 119697479
+  },
+  base: {
+    name: "base",
+    modelId: "onnx-community/whisper-base_timestamped",
+    parameters: 74000000,
+    multilingual: true,
+    webGpuDownloadSize: 206190057
+  },
+  "base.en": {
+    name: "base.en",
+    modelId: "onnx-community/whisper-base.en_timestamped",
+    parameters: 74000000,
+    multilingual: false,
+    webGpuDownloadSize: 206188009
+  },
+  small: {
+    name: "small",
+    modelId: "onnx-community/whisper-small_timestamped",
+    parameters: 244000000,
+    multilingual: true,
+    webGpuDownloadSize: 586213010
+  },
+  "small.en": {
+    name: "small.en",
+    modelId: "onnx-community/whisper-small.en_timestamped",
+    parameters: 244000000,
+    multilingual: false,
+    webGpuDownloadSize: 586209938
+  },
+  medium: {
+    name: "medium",
+    modelId: "onnx-community/whisper-medium_timestamped",
+    parameters: 769000000,
+    multilingual: true,
+    webGpuDownloadSize: 1698508143
+  },
+  "medium.en": {
+    name: "medium.en",
+    modelId: "onnx-community/whisper-medium.en_timestamped",
+    parameters: 769000000,
+    multilingual: false,
+    webGpuDownloadSize: 1698504047
+  },
+  "large-v3-turbo": {
+    name: "large-v3-turbo",
+    modelId: "onnx-community/whisper-large-v3-turbo_timestamped",
+    parameters: 809000000,
+    multilingual: true,
+    webGpuDownloadSize: 2882584170
+  }
+};
+var getAvailableModels = () => {
+  return WHISPER_WEBGPU_MODELS.map((model) => ({ ...MODEL_INFO[model] }));
+};
+var getModelInfo = (model) => {
+  return MODEL_INFO[model];
+};
+var WHISPER_WEBGPU_DTYPE = {
+  encoder_model: "fp32",
+  decoder_model_merged: "q4"
+};
+
+// src/load-whisper-model.ts
+var pipelines = new Map;
+var getOrCreateWhisperPipeline = ({
+  model,
+  onProgress
+}) => {
+  const modelInfo = getModelInfo(model);
+  const totalBytes = modelInfo.webGpuDownloadSize;
+  const existing = pipelines.get(model);
+  if (existing) {
+    return { state: existing, alreadyLoaded: true, totalBytes };
+  }
+  const loading = Promise.resolve().then(async () => {
+    const { pipeline } = await import("@huggingface/transformers");
+    onProgress?.({
+      status: "loading",
+      file: null,
+      progress: 0,
+      loadedBytes: 0,
+      totalBytes
+    });
+    const { modelId } = modelInfo;
+    const loadedByFile = new Map;
+    let lastProgress = 0;
+    let lastLoadedBytes = 0;
+    return pipeline("automatic-speech-recognition", modelId, {
+      device: "webgpu",
+      dtype: WHISPER_WEBGPU_DTYPE,
+      progress_callback: onProgress ? (event) => {
+        const record = event;
+        if (record.status === "progress" && typeof record.file === "string" && typeof record.loaded === "number" && Number.isFinite(record.loaded)) {
+          loadedByFile.set(record.file, Math.max(loadedByFile.get(record.file) ?? 0, record.loaded));
+          const loadedBytes = [...loadedByFile.values()].reduce((sum, loaded) => sum + loaded, 0);
+          lastProgress = Math.max(lastProgress, Math.min(loadedBytes / totalBytes, 0.99));
+          lastLoadedBytes = Math.max(lastLoadedBytes, loadedBytes);
+          onProgress({
+            status: "loading",
+            file: null,
+            progress: lastProgress,
+            loadedBytes: lastLoadedBytes,
+            totalBytes
+          });
+        }
+        if (record.status === "ready") {
+          onProgress({
+            status: "ready",
+            file: null,
+            progress: 1,
+            loadedBytes: Math.max(lastLoadedBytes, totalBytes),
+            totalBytes
+          });
+        }
+      } : undefined
+    });
+  });
+  const state = {
+    loading,
+    activeTranscriptions: 0,
+    onIdle: []
+  };
+  pipelines.set(model, state);
+  loading.catch(() => {
+    if (pipelines.get(model) === state) {
+      pipelines.delete(model);
+    }
+  });
+  return { state, alreadyLoaded: false, totalBytes };
+};
+var loadWhisperModel = async ({
+  model,
+  onProgress
+}) => {
+  const { state, alreadyLoaded, totalBytes } = getOrCreateWhisperPipeline({
+    model,
+    onProgress
+  });
+  await state.loading;
+  if (alreadyLoaded) {
+    onProgress?.({
+      status: "ready",
+      file: null,
+      progress: 1,
+      loadedBytes: totalBytes,
+      totalBytes
+    });
+  }
+  return { alreadyLoaded };
+};
+var withLoadedWhisperPipeline = async ({
+  model,
+  onProgress,
+  run
+}) => {
+  const { state, alreadyLoaded, totalBytes } = getOrCreateWhisperPipeline({
+    model,
+    onProgress
+  });
+  state.activeTranscriptions++;
+  try {
+    const loaded = await state.loading;
+    if (alreadyLoaded) {
+      onProgress?.({
+        status: "ready",
+        file: null,
+        progress: 1,
+        loadedBytes: totalBytes,
+        totalBytes
+      });
+    }
+    return await run(loaded);
+  } finally {
+    state.activeTranscriptions--;
+    if (state.activeTranscriptions === 0) {
+      for (const resolve of state.onIdle.splice(0)) {
+        resolve();
+      }
+    }
+  }
+};
+var disposeWhisperModel = async ({
+  model
+} = {}) => {
+  const matching = [...pipelines.entries()].filter(([loadedModel]) => {
+    return model === undefined || loadedModel === model;
+  });
+  for (const [key, state] of matching) {
+    if (pipelines.get(key) === state) {
+      pipelines.delete(key);
+    }
+  }
+  await Promise.all(matching.map(async ([, state]) => {
+    const loadedPipeline = await state.loading;
+    if (state.activeTranscriptions > 0) {
+      await new Promise((resolve) => {
+        state.onIdle.push(resolve);
+      });
+    }
+    await loadedPipeline.dispose();
+  }));
+};
+// src/is-whisper-model-cached.ts
+var isWhisperModelCached = async ({
+  model
+}) => {
+  const { ModelRegistry } = await import("@huggingface/transformers");
+  const { modelId } = getModelInfo(model);
+  return ModelRegistry.is_pipeline_cached("automatic-speech-recognition", modelId, {
+    device: "webgpu",
+    dtype: WHISPER_WEBGPU_DTYPE
+  });
+};
+// src/resample-to-16khz.ts
+var WHISPER_WEBGPU_SAMPLE_RATE = 16000;
+var resampleTo16Khz = async ({
+  file,
+  onProgress
+}) => {
+  if (typeof OfflineAudioContext === "undefined") {
+    throw new Error("OfflineAudioContext is not available in this environment.");
+  }
+  if (file.size === 0) {
+    throw new Error("The audio file is empty.");
+  }
+  onProgress?.(0);
+  const arrayBuffer = await file.arrayBuffer();
+  onProgress?.(0.25);
+  const decodingContext = new OfflineAudioContext(1, 1, 44100);
+  const decoded = await decodingContext.decodeAudioData(arrayBuffer);
+  onProgress?.(0.6);
+  const length = Math.max(1, Math.ceil(decoded.duration * WHISPER_WEBGPU_SAMPLE_RATE));
+  const offlineContext = new OfflineAudioContext(1, length, WHISPER_WEBGPU_SAMPLE_RATE);
+  const source = offlineContext.createBufferSource();
+  source.buffer = decoded;
+  source.connect(offlineContext.destination);
+  source.start();
+  const rendered = await offlineContext.startRendering();
+  onProgress?.(1);
+  return rendered.getChannelData(0).slice();
+};
+// src/to-captions.ts
+var toCaptions = ({
+  whisperWebGpuOutput
+}) => {
+  const words = Array.isArray(whisperWebGpuOutput) ? whisperWebGpuOutput : whisperWebGpuOutput.words;
+  return {
+    captions: words.map((word, index) => ({
+      text: index === 0 ? word.text.trimStart() : word.text,
+      startMs: Math.round(word.startInSeconds * 1000),
+      endMs: Math.round(word.endInSeconds * 1000),
+      timestampMs: Math.round((word.startInSeconds + word.endInSeconds) / 2 * 1000),
+      confidence: null
+    }))
+  };
+};
+// src/transcribe.ts
+var transcribe = async ({
+  channelWaveform,
+  model,
+  language,
+  chunkLengthInSeconds = 30,
+  strideLengthInSeconds = 5,
+  onModelLoadProgress
+}) => {
+  if (channelWaveform.length === 0) {
+    throw new Error("The audio waveform is empty.");
+  }
+  if (!Number.isFinite(chunkLengthInSeconds) || chunkLengthInSeconds <= 0) {
+    throw new Error("chunkLengthInSeconds must be a finite number greater than 0.");
+  }
+  if (!Number.isFinite(strideLengthInSeconds) || strideLengthInSeconds < 0 || strideLengthInSeconds * 2 >= chunkLengthInSeconds) {
+    throw new Error("strideLengthInSeconds must be a finite, non-negative number and less than half of chunkLengthInSeconds.");
+  }
+  const { multilingual } = getModelInfo(model);
+  if (multilingual && (language === undefined || language === "auto")) {
+    throw new Error(`The language option is required for the multilingual model "${model}" because automatic language detection is not supported.`);
+  }
+  if (!multilingual && language !== undefined && language !== "auto" && language !== "en" && language !== "english") {
+    throw new Error(`The English-only model "${model}" does not support the language "${language}".`);
+  }
+  const output = await withLoadedWhisperPipeline({
+    model,
+    onProgress: onModelLoadProgress,
+    run: async (transcriber) => {
+      return await transcriber(channelWaveform, {
+        return_timestamps: "word",
+        chunk_length_s: chunkLengthInSeconds,
+        stride_length_s: strideLengthInSeconds,
+        ...multilingual ? { language } : {}
+      });
+    }
+  });
+  if (!output.chunks) {
+    throw new Error("The model did not return word-level timestamps. Use one of the timestamped models returned by getAvailableModels().");
+  }
+  const audioDuration = channelWaveform.length / 16000;
+  const starts = output.chunks.map((chunk) => {
+    const start = chunk.timestamp[0];
+    if (start === null || !Number.isFinite(start)) {
+      throw new Error(`The model returned an invalid timestamp for "${chunk.text}".`);
+    }
+    return Math.max(0, Math.min(start, audioDuration));
+  });
+  const words = output.chunks.map((chunk, index) => {
+    const start = starts[index];
+    const modelEnd = chunk.timestamp[1];
+    const nextStart = starts[index + 1];
+    const fallbackEnd = nextStart === undefined || nextStart < start ? audioDuration : nextStart;
+    const end = Math.max(start, Math.min(modelEnd !== null && Number.isFinite(modelEnd) && modelEnd >= start ? modelEnd : fallbackEnd, audioDuration));
+    return {
+      text: index === 0 ? chunk.text.trimStart() : chunk.text,
+      startInSeconds: start,
+      endInSeconds: end
+    };
+  });
+  return {
+    text: output.text.trimStart(),
+    words,
+    model
+  };
+};
+export {
+  transcribe,
+  toCaptions,
+  resampleTo16Khz,
+  loadWhisperModel,
+  isWhisperModelCached,
+  getAvailableModels,
+  disposeWhisperModel,
+  clearStaleModels,
+  canUseWhisperWebGpu,
+  WhisperWebGpuUnsupportedReason,
+  WHISPER_WEBGPU_SAMPLE_RATE,
+  WHISPER_WEBGPU_MODELS
+};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { canUseWhisperWebGpu, WhisperWebGpuUnsupportedReason, } from './can-use-whisper-webgpu';
+export type { CanUseWhisperWebGpuResult } from './can-use-whisper-webgpu';
+export { clearStaleModels } from './clear-stale-models';
+export { disposeWhisperModel, loadWhisperModel } from './load-whisper-model';
+export type { DisposeWhisperModelOptions, LoadWhisperModelOptions, LoadWhisperModelResult, OnWhisperWebGpuModelLoadProgress, WhisperWebGpuModelLoadProgress, } from './load-whisper-model';
+export { isWhisperModelCached } from './is-whisper-model-cached';
+export type { IsWhisperModelCachedOptions } from './is-whisper-model-cached';
+export { getAvailableModels, WHISPER_WEBGPU_MODELS } from './models';
+export type { WhisperWebGpuModel, WhisperWebGpuModelInfo } from './models';
+export { resampleTo16Khz, WHISPER_WEBGPU_SAMPLE_RATE } from './resample-to-16khz';
+export type { ResampleTo16KhzOptions } from './resample-to-16khz';
+export { toCaptions } from './to-captions';
+export type { ToCaptionsOptions, ToCaptionsResult } from './to-captions';
+export { transcribe } from './transcribe';
+export type { TranscribeOptions, WhisperWebGpuTranscription, WhisperWebGpuWord, } from './transcribe';

package/dist/is-whisper-model-cached.d.ts

@@ -0,0 +1,5 @@
+import { type WhisperWebGpuModel } from './models';
+export type IsWhisperModelCachedOptions = {
+    model: WhisperWebGpuModel;
+};
+export declare const isWhisperModelCached: ({ model, }: IsWhisperModelCachedOptions) => Promise<boolean>;

package/dist/load-whisper-model.d.ts

@@ -0,0 +1,31 @@
+import { type WhisperWebGpuModel } from './models';
+export type WhisperWebGpuModelLoadProgress = {
+    status: string;
+    file: string | null;
+    progress: number | null;
+    loadedBytes: number | null;
+    totalBytes: number | null;
+};
+export type OnWhisperWebGpuModelLoadProgress = (progress: WhisperWebGpuModelLoadProgress) => void;
+type LoadedWhisperPipeline = {
+    (audio: Float32Array, options: Record<string, unknown>): Promise<unknown>;
+    dispose: () => Promise<void>;
+};
+export type LoadWhisperModelOptions = {
+    model: WhisperWebGpuModel;
+    onProgress?: OnWhisperWebGpuModelLoadProgress;
+};
+export type LoadWhisperModelResult = {
+    alreadyLoaded: boolean;
+};
+export declare const loadWhisperModel: ({ model, onProgress, }: LoadWhisperModelOptions) => Promise<LoadWhisperModelResult>;
+export declare const withLoadedWhisperPipeline: <ReturnValue>({ model, onProgress, run, }: {
+    model: "base" | "base.en" | "large-v3-turbo" | "medium" | "medium.en" | "small" | "small.en" | "tiny" | "tiny.en";
+    onProgress?: OnWhisperWebGpuModelLoadProgress | undefined;
+    run: (pipeline: LoadedWhisperPipeline) => Promise<ReturnValue>;
+}) => Promise<ReturnValue>;
+export type DisposeWhisperModelOptions = {
+    model?: WhisperWebGpuModel;
+};
+export declare const disposeWhisperModel: ({ model, }?: DisposeWhisperModelOptions) => Promise<void>;
+export {};

package/dist/models.d.ts

@@ -0,0 +1,15 @@
+export declare const WHISPER_WEBGPU_MODELS: readonly ["tiny", "tiny.en", "base", "base.en", "small", "small.en", "medium", "medium.en", "large-v3-turbo"];
+export type WhisperWebGpuModel = (typeof WHISPER_WEBGPU_MODELS)[number];
+export type WhisperWebGpuModelInfo = {
+    name: WhisperWebGpuModel;
+    modelId: string;
+    parameters: number;
+    multilingual: boolean;
+    webGpuDownloadSize: number;
+};
+export declare const getAvailableModels: () => WhisperWebGpuModelInfo[];
+export declare const getModelInfo: (model: "base" | "base.en" | "large-v3-turbo" | "medium" | "medium.en" | "small" | "small.en" | "tiny" | "tiny.en") => WhisperWebGpuModelInfo;
+export declare const WHISPER_WEBGPU_DTYPE: {
+    readonly encoder_model: "fp32";
+    readonly decoder_model_merged: "q4";
+};

package/dist/resample-to-16khz.d.ts

@@ -0,0 +1,6 @@
+export declare const WHISPER_WEBGPU_SAMPLE_RATE = 16000;
+export type ResampleTo16KhzOptions = {
+    file: Blob;
+    onProgress?: (progress: number) => void;
+};
+export declare const resampleTo16Khz: ({ file, onProgress, }: ResampleTo16KhzOptions) => Promise<Float32Array<ArrayBufferLike>>;

package/dist/to-captions.d.ts

@@ -0,0 +1,9 @@
+import type { Caption } from '@remotion/captions';
+import type { WhisperWebGpuTranscription, WhisperWebGpuWord } from './transcribe';
+export type ToCaptionsOptions = {
+    whisperWebGpuOutput: WhisperWebGpuTranscription | WhisperWebGpuWord[];
+};
+export type ToCaptionsResult = {
+    captions: Caption[];
+};
+export declare const toCaptions: ({ whisperWebGpuOutput, }: ToCaptionsOptions) => ToCaptionsResult;

package/dist/transcribe.d.ts

@@ -0,0 +1,21 @@
+import { type OnWhisperWebGpuModelLoadProgress } from './load-whisper-model';
+import { type WhisperWebGpuModel } from './models';
+export type WhisperWebGpuWord = {
+    text: string;
+    startInSeconds: number;
+    endInSeconds: number;
+};
+export type WhisperWebGpuTranscription = {
+    text: string;
+    words: WhisperWebGpuWord[];
+    model: WhisperWebGpuModel;
+};
+export type TranscribeOptions = {
+    channelWaveform: Float32Array;
+    model: WhisperWebGpuModel;
+    language?: string;
+    chunkLengthInSeconds?: number;
+    strideLengthInSeconds?: number;
+    onModelLoadProgress?: OnWhisperWebGpuModelLoadProgress;
+};
+export declare const transcribe: ({ channelWaveform, model, language, chunkLengthInSeconds, strideLengthInSeconds, onModelLoadProgress, }: TranscribeOptions) => Promise<WhisperWebGpuTranscription>;

package/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@remotion/whisper-webgpu",
+	"version": "4.0.518",
+	"description": "Transcribe audio in the browser using Whisper and WebGPU",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"module": "dist/esm/index.mjs",
+	"repository": {
+		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/whisper-webgpu"
+	},
+	"type": "module",
+	"scripts": {
+		"test": "bun test src/test",
+		"formatting": "oxfmt src --check",
+		"format": "oxfmt src",
+		"lint": "eslint src",
+		"watch": "tsgo -w",
+		"make": "tsgo && bun --env-file=../.env.bundle bundle.ts"
+	},
+	"author": "Jonny Burger <jonny@remotion.dev>",
+	"contributors": [],
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/remotion-dev/remotion/issues"
+	},
+	"dependencies": {
+		"@huggingface/transformers": "4.2.0",
+		"@remotion/captions": "4.0.518"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"module": "./dist/esm/index.mjs",
+			"import": "./dist/esm/index.mjs"
+		},
+		"./package.json": "./package.json"
+	},
+	"devDependencies": {
+		"@remotion/eslint-config-internal": "4.0.518",
+		"@typescript/native-preview": "7.0.0-dev.20260217.1",
+		"eslint": "9.19.0"
+	},
+	"keywords": [
+		"remotion",
+		"whisper",
+		"webgpu",
+		"captions",
+		"speech-to-text"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"homepage": "https://www.remotion.dev/docs/whisper-webgpu"
+}