Add .gitignore to exclude all node packages and lock files

skills/remotion-prompt-video/node_modules/@remotion/webcodecs/dist/writers/buffer-implementation/writer.d.ts

@@ -0,0 +1,2 @@
+import type { MediaParserInternalTypes } from '@remotion/media-parser';
+export declare const createContent: MediaParserInternalTypes['CreateContent'];

skills/remotion-prompt-video/node_modules/@remotion/webcodecs/dist/writers/buffer-implementation/writer.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContent = void 0;
+const createContent = ({ filename, mimeType, }) => {
+    const buf = new ArrayBuffer(0, {
+        // TODO: Educate that the buffer is limited to 2GB
+        maxByteLength: 2000000000,
+    });
+    if (!buf.resize) {
+        throw new Error('Could not create buffer writer');
+    }
+    const write = (newData) => {
+        const oldLength = buf.byteLength;
+        const newLength = oldLength + newData.byteLength;
+        buf.resize(newLength);
+        const newArray = new Uint8Array(buf);
+        newArray.set(newData, oldLength);
+    };
+    const updateDataAt = (position, newData) => {
+        const newArray = new Uint8Array(buf);
+        newArray.set(newData, position);
+    };
+    let writPromise = Promise.resolve();
+    let removed = false;
+    const writer = {
+        write: (arr) => {
+            writPromise = writPromise.then(() => write(arr));
+            return writPromise;
+        },
+        finish: async () => {
+            await writPromise;
+            if (removed) {
+                return Promise.reject(new Error('Already called .remove() on the result'));
+            }
+            return Promise.resolve();
+        },
+        getBlob() {
+            const arr = new Uint8Array(buf);
+            return Promise.resolve(new File([arr.slice()], filename, { type: mimeType }));
+        },
+        remove() {
+            removed = true;
+            return Promise.resolve();
+        },
+        getWrittenByteCount: () => buf.byteLength,
+        updateDataAt: (position, newData) => {
+            writPromise = writPromise.then(() => updateDataAt(position, newData));
+            return writPromise;
+        },
+    };
+    return Promise.resolve(writer);
+};
+exports.createContent = createContent;

skills/remotion-prompt-video/node_modules/@remotion/webcodecs/dist/writers/buffer.d.ts

@@ -0,0 +1,2 @@
+import type { MediaParserInternalTypes } from '@remotion/media-parser';
+export declare const bufferWriter: MediaParserInternalTypes['WriterInterface'];

skills/remotion-prompt-video/node_modules/@remotion/webcodecs/dist/writers/buffer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferWriter = void 0;
+const writer_1 = require("./buffer-implementation/writer");
+exports.bufferWriter = {
+    createContent: writer_1.createContent,
+};

skills/remotion-prompt-video/node_modules/@remotion/webcodecs/dist/writers/web-fs.d.ts

@@ -0,0 +1,3 @@
+import type { MediaParserInternalTypes } from '@remotion/media-parser';
+export declare const webFsWriter: MediaParserInternalTypes['WriterInterface'];
+export declare const canUseWebFsWriter: () => Promise<boolean>;

skills/remotion-prompt-video/node_modules/@remotion/webcodecs/dist/writers/web-fs.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUseWebFsWriter = exports.webFsWriter = void 0;
+const createContent = async ({ filename, }) => {
+    const directoryHandle = await navigator.storage.getDirectory();
+    const actualFilename = `__remotion_mediaparser:${filename}`;
+    const remove = async () => {
+        try {
+            await directoryHandle.removeEntry(actualFilename, {
+                recursive: true,
+            });
+        }
+        catch { }
+    };
+    await remove();
+    const fileHandle = await directoryHandle.getFileHandle(actualFilename, {
+        create: true,
+    });
+    const writable = await fileHandle.createWritable();
+    let written = 0;
+    let writPromise = Promise.resolve();
+    const write = async (arr) => {
+        // @ts-expect-error
+        await writable.write(arr);
+        written += arr.byteLength;
+    };
+    const updateDataAt = async (position, data) => {
+        await writable.seek(position);
+        // @ts-expect-error
+        await writable.write(data);
+        await writable.seek(written);
+    };
+    const writer = {
+        write: (arr) => {
+            writPromise = writPromise.then(() => write(arr));
+            return writPromise;
+        },
+        finish: async () => {
+            await writPromise;
+            try {
+                await writable.close();
+            }
+            catch {
+                // Ignore, could already be closed
+            }
+        },
+        async getBlob() {
+            const newHandle = await directoryHandle.getFileHandle(actualFilename, {
+                create: true,
+            });
+            const newFile = await newHandle.getFile();
+            return newFile;
+        },
+        getWrittenByteCount: () => written,
+        updateDataAt: (position, data) => {
+            writPromise = writPromise.then(() => updateDataAt(position, data));
+            return writPromise;
+        },
+        remove,
+    };
+    return writer;
+};
+exports.webFsWriter = {
+    createContent,
+};
+const canUseWebFsWriter = async () => {
+    if (!('storage' in navigator)) {
+        return false;
+    }
+    if (!('getDirectory' in navigator.storage)) {
+        return false;
+    }
+    try {
+        const directoryHandle = await navigator.storage.getDirectory();
+        const fileHandle = await directoryHandle.getFileHandle('remotion-probe-web-fs-support', {
+            create: true,
+        });
+        const canUse = fileHandle.createWritable !== undefined;
+        return canUse;
+    }
+    catch {
+        return false;
+    }
+};
+exports.canUseWebFsWriter = canUseWebFsWriter;