Add .gitignore to exclude all node packages and lock files

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/fetch/get-body-and-reader.d.ts

@@ -0,0 +1,13 @@
+import type { Reader } from '../reader';
+type ReturnType = {
+    reader: Reader;
+    contentLength: number | null;
+    needsContentRange: boolean;
+};
+export declare const getLengthAndReader: ({ canLiveWithoutContentLength, res, ownController, requestedWithoutRange, }: {
+    canLiveWithoutContentLength: boolean;
+    res: Response;
+    ownController: AbortController;
+    requestedWithoutRange: boolean;
+}) => Promise<ReturnType>;
+export {};

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/fetch/get-body-and-reader.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLengthAndReader = void 0;
+const getLengthAndReader = async ({ canLiveWithoutContentLength, res, ownController, requestedWithoutRange, }) => {
+    const length = res.headers.get('content-length');
+    const contentLength = length === null ? null : parseInt(length, 10);
+    if (requestedWithoutRange ||
+        (canLiveWithoutContentLength && contentLength === null)) {
+        const buffer = await res.arrayBuffer();
+        const encoded = new Uint8Array(buffer);
+        let streamCancelled = false;
+        const stream = new ReadableStream({
+            start(controller) {
+                if (ownController.signal.aborted) {
+                    return;
+                }
+                if (streamCancelled) {
+                    return;
+                }
+                try {
+                    controller.enqueue(encoded);
+                    controller.close();
+                }
+                catch (_a) {
+                    // sometimes on windows after aborting on node 16		: Invalid state: ReadableStreamDefaultController is not in a state where chunk can be enqueued
+                }
+            },
+            cancel() {
+                streamCancelled = true;
+            },
+        });
+        return {
+            contentLength: encoded.byteLength,
+            reader: {
+                reader: stream.getReader(),
+                abort: () => {
+                    ownController.abort();
+                    return Promise.resolve();
+                },
+            },
+            needsContentRange: false,
+        };
+    }
+    if (!res.body) {
+        throw new Error('No body');
+    }
+    const reader = res.body.getReader();
+    return {
+        reader: {
+            reader,
+            abort: () => {
+                ownController.abort();
+                return Promise.resolve();
+            },
+        },
+        contentLength,
+        needsContentRange: true,
+    };
+};
+exports.getLengthAndReader = getLengthAndReader;

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/fetch/resolve-url.d.ts

@@ -0,0 +1 @@
+export declare const resolveUrl: (src: string | URL) => string | URL;

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/fetch/resolve-url.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUrl = void 0;
+const resolveUrl = (src) => {
+    try {
+        const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
+            ? new URL(src, window.location.origin)
+            : new URL(src);
+        return resolvedUrl;
+    }
+    catch (_a) {
+        return src;
+    }
+};
+exports.resolveUrl = resolveUrl;

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/from-fetch.d.ts

@@ -0,0 +1,33 @@
+import type { MediaParserController } from '../controller/media-parser-controller';
+import type { ParseMediaRange } from '../options';
+import type { CreateAdjacentFileSource, MediaParserReaderInterface, PreloadContent, ReadContent, ReadWholeAsText } from './reader';
+interface ParsedContentRange {
+    unit: string;
+    start?: number | null;
+    end?: number | null;
+    size?: number | null;
+}
+/**
+ * Parse Content-Range header.
+ * From: https://github.com/gregberge/content-range/blob/main/src/index.ts
+ */
+export declare function parseContentRange(input: string): ParsedContentRange | null;
+export declare const makeFetchRequest: ({ range, src, controller, }: {
+    range: ParseMediaRange;
+    src: string | URL;
+    controller: MediaParserController | null;
+}) => Promise<{
+    contentLength: number | null;
+    needsContentRange: boolean;
+    reader: import("./reader").Reader;
+    name: string | undefined;
+    contentType: string | null;
+    supportsContentRange: boolean;
+}>;
+export type PrefetchCache = Map<string, ReturnType<typeof makeFetchRequest>>;
+export declare const fetchReadContent: ReadContent;
+export declare const fetchPreload: PreloadContent;
+export declare const fetchReadWholeAsText: ReadWholeAsText;
+export declare const fetchCreateAdjacentFileSource: CreateAdjacentFileSource;
+export declare const fetchReader: MediaParserReaderInterface;
+export {};

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/from-fetch.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchReader = exports.fetchCreateAdjacentFileSource = exports.fetchReadWholeAsText = exports.fetchPreload = exports.fetchReadContent = exports.makeFetchRequest = void 0;
+exports.parseContentRange = parseContentRange;
+const errors_1 = require("../errors");
+const log_1 = require("../log");
+const get_body_and_reader_1 = require("./fetch/get-body-and-reader");
+const resolve_url_1 = require("./fetch/resolve-url");
+/**
+ * Parse Content-Range header.
+ * From: https://github.com/gregberge/content-range/blob/main/src/index.ts
+ */
+function parseContentRange(input) {
+    const matches = input.match(/^(\w+) ((\d+)-(\d+)|\*)\/(\d+|\*)$/);
+    if (!matches)
+        return null;
+    const [, unit, , start, end, size] = matches;
+    const range = {
+        unit,
+        start: start != null ? Number(start) : null,
+        end: end != null ? Number(end) : null,
+        size: size === '*' ? null : Number(size),
+    };
+    if (range.start === null && range.end === null && range.size === null) {
+        return null;
+    }
+    return range;
+}
+const validateContentRangeAndDetectIfSupported = ({ requestedRange, parsedContentRange, statusCode, }) => {
+    if (statusCode === 206) {
+        return { supportsContentRange: true };
+    }
+    if (typeof requestedRange === 'number' &&
+        (parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start) !== requestedRange) {
+        if (requestedRange === 0) {
+            return { supportsContentRange: false };
+        }
+        throw new Error(`Range header (${requestedRange}) does not match content-range header (${parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start})`);
+    }
+    if (requestedRange !== null &&
+        typeof requestedRange !== 'number' &&
+        ((parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start) !== requestedRange[0] ||
+            (parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.end) !== requestedRange[1])) {
+        throw new Error(`Range header (${requestedRange}) does not match content-range header (${parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start})`);
+    }
+    return { supportsContentRange: true };
+};
+const makeFetchRequest = async ({ range, src, controller, }) => {
+    var _a;
+    const resolvedUrl = (0, resolve_url_1.resolveUrl)(src);
+    const resolvedUrlString = resolvedUrl.toString();
+    if (!resolvedUrlString.startsWith('https://') &&
+        !resolvedUrlString.startsWith('blob:') &&
+        !resolvedUrlString.startsWith('data:') &&
+        !resolvedUrlString.startsWith('http://')) {
+        return Promise.reject(new Error(`${resolvedUrlString} is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass \`reader: nodeReader\` to parseMedia().`));
+    }
+    const ownController = new AbortController();
+    const cache = typeof navigator !== 'undefined' &&
+        navigator.userAgent.includes('Cloudflare-Workers')
+        ? undefined
+        : // Disable Next.js caching
+            'no-store';
+    const requestedRange = range === null ? 0 : range;
+    const asString = typeof resolvedUrl === 'string' ? resolvedUrl : resolvedUrl.pathname;
+    const requestWithoutRange = asString.endsWith('.m3u8');
+    const canLiveWithoutContentLength = asString.endsWith('.m3u8') || asString.endsWith('.ts');
+    const headers = requestedRange === 0 && requestWithoutRange
+        ? {}
+        : typeof requestedRange === 'number'
+            ? {
+                Range: `bytes=${requestedRange}-`,
+            }
+            : {
+                Range: `bytes=${`${requestedRange[0]}-${requestedRange[1]}`}`,
+            };
+    const res = await fetch(resolvedUrl, {
+        headers,
+        signal: ownController.signal,
+        cache,
+    });
+    const contentRange = res.headers.get('content-range');
+    const parsedContentRange = contentRange
+        ? parseContentRange(contentRange)
+        : null;
+    if (!res.ok) {
+        throw new Error(`Server returned status code ${res.status} for ${resolvedUrl} and range ${requestedRange}`);
+    }
+    const { supportsContentRange } = validateContentRangeAndDetectIfSupported({
+        requestedRange,
+        parsedContentRange,
+        statusCode: res.status,
+    });
+    if (controller) {
+        controller._internals.signal.addEventListener('abort', () => {
+            ownController.abort(new errors_1.MediaParserAbortError('Aborted by user'));
+        }, { once: true });
+    }
+    const contentDisposition = res.headers.get('content-disposition');
+    const name = (_a = contentDisposition === null || contentDisposition === void 0 ? void 0 : contentDisposition.match(/filename="([^"]+)"/)) === null || _a === void 0 ? void 0 : _a[1];
+    const { contentLength, needsContentRange, reader } = await (0, get_body_and_reader_1.getLengthAndReader)({
+        canLiveWithoutContentLength,
+        res,
+        ownController,
+        requestedWithoutRange: requestWithoutRange,
+    });
+    const contentType = res.headers.get('content-type');
+    return {
+        contentLength,
+        needsContentRange,
+        reader,
+        name,
+        contentType,
+        supportsContentRange,
+    };
+};
+exports.makeFetchRequest = makeFetchRequest;
+const cacheKey = ({ src, range, }) => {
+    return `${src}-${JSON.stringify(range)}`;
+};
+const makeFetchRequestOrGetCached = ({ range, src, controller, logLevel, prefetchCache, }) => {
+    const key = cacheKey({ src, range });
+    const cached = prefetchCache.get(key);
+    if (cached) {
+        log_1.Log.verbose(logLevel, `Reading from preload cache for ${key}`);
+        return cached;
+    }
+    log_1.Log.verbose(logLevel, `Fetching ${key}`);
+    const result = (0, exports.makeFetchRequest)({ range, src, controller });
+    prefetchCache.set(key, result);
+    return result;
+};
+const fetchReadContent = async ({ src, range, controller, logLevel, prefetchCache, }) => {
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string when using `fetchReader`');
+    }
+    const fallbackName = src.toString().split('/').pop();
+    const res = makeFetchRequestOrGetCached({
+        range,
+        src,
+        controller,
+        logLevel,
+        prefetchCache,
+    });
+    const key = cacheKey({ src, range });
+    prefetchCache.delete(key);
+    const { reader, contentLength, needsContentRange, name, supportsContentRange, contentType, } = await res;
+    if (controller) {
+        controller._internals.signal.addEventListener('abort', () => {
+            reader.reader.cancel().catch(() => {
+                // Prevent unhandled rejection in Firefox
+            });
+        }, { once: true });
+    }
+    return {
+        reader,
+        contentLength,
+        contentType,
+        name: name !== null && name !== void 0 ? name : fallbackName,
+        supportsContentRange,
+        needsContentRange,
+    };
+};
+exports.fetchReadContent = fetchReadContent;
+const fetchPreload = ({ src, range, logLevel, prefetchCache, }) => {
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string when using `fetchReader`');
+    }
+    const key = cacheKey({ src, range });
+    if (prefetchCache.has(key)) {
+        return prefetchCache.get(key);
+    }
+    makeFetchRequestOrGetCached({
+        range,
+        src,
+        controller: null,
+        logLevel,
+        prefetchCache,
+    });
+};
+exports.fetchPreload = fetchPreload;
+const fetchReadWholeAsText = async (src) => {
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string when using `fetchReader`');
+    }
+    const res = await fetch(src);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch ${src} (HTTP code: ${res.status})`);
+    }
+    return res.text();
+};
+exports.fetchReadWholeAsText = fetchReadWholeAsText;
+const fetchCreateAdjacentFileSource = (relativePath, src) => {
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string or URL when using `fetchReader`');
+    }
+    return new URL(relativePath, src).toString();
+};
+exports.fetchCreateAdjacentFileSource = fetchCreateAdjacentFileSource;
+exports.fetchReader = {
+    read: exports.fetchReadContent,
+    readWholeAsText: exports.fetchReadWholeAsText,
+    createAdjacentFileSource: exports.fetchCreateAdjacentFileSource,
+    preload: exports.fetchPreload,
+};

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/from-node.d.ts

@@ -0,0 +1,5 @@
+import type { CreateAdjacentFileSource, MediaParserReaderInterface, ReadContent, ReadWholeAsText } from './reader';
+export declare const nodeReadContent: ReadContent;
+export declare const nodeReadWholeAsText: ReadWholeAsText;
+export declare const nodeCreateAdjacentFileSource: CreateAdjacentFileSource;
+export declare const nodeReader: MediaParserReaderInterface;

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/from-node.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeReader = exports.nodeCreateAdjacentFileSource = exports.nodeReadWholeAsText = exports.nodeReadContent = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const nodeReadContent = async ({ src, range, controller, }) => {
+    if (typeof src !== 'string') {
+        throw new Error('src must be a string when using `nodeReader`');
+    }
+    await Promise.resolve();
+    const ownController = new AbortController();
+    try {
+        if (!(0, fs_1.existsSync)(src)) {
+            throw new Error(`File does not exist: ${src}`);
+        }
+        const stream = (0, fs_1.createReadStream)(src, {
+            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+            end: range === null
+                ? Infinity
+                : typeof range === 'number'
+                    ? Infinity
+                    : range[1],
+        });
+        controller._internals.signal.addEventListener('abort', () => {
+            ownController.abort();
+        }, { once: true });
+        const stats = (0, fs_1.statSync)(src);
+        let readerCancelled = false;
+        const reader = new ReadableStream({
+            start(c) {
+                if (readerCancelled) {
+                    return;
+                }
+                stream.on('data', (chunk) => {
+                    c.enqueue(chunk);
+                });
+                stream.on('end', () => {
+                    if (readerCancelled) {
+                        return;
+                    }
+                    c.close();
+                });
+                stream.on('error', (err) => {
+                    c.error(err);
+                });
+            },
+            cancel() {
+                readerCancelled = true;
+                stream.destroy();
+            },
+        }).getReader();
+        if (controller) {
+            controller._internals.signal.addEventListener('abort', () => {
+                reader.cancel().catch(() => { });
+            }, { once: true });
+        }
+        return Promise.resolve({
+            reader: {
+                reader,
+                abort: async () => {
+                    try {
+                        stream.destroy();
+                        ownController.abort();
+                        await reader.cancel();
+                    }
+                    catch (_a) { }
+                },
+            },
+            contentLength: stats.size,
+            contentType: null,
+            name: src.split(path_1.sep).pop(),
+            supportsContentRange: true,
+            needsContentRange: true,
+        });
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+};
+exports.nodeReadContent = nodeReadContent;
+const nodeReadWholeAsText = (src) => {
+    if (typeof src !== 'string') {
+        throw new Error('src must be a string when using `nodeReader`');
+    }
+    return fs_1.promises.readFile(src, 'utf8');
+};
+exports.nodeReadWholeAsText = nodeReadWholeAsText;
+const nodeCreateAdjacentFileSource = (relativePath, src) => {
+    if (typeof src !== 'string') {
+        throw new Error('src must be a string when using `nodeReader`');
+    }
+    const result = (0, path_1.join)((0, path_1.dirname)(src), relativePath);
+    const rel = (0, path_1.relative)((0, path_1.dirname)(src), result);
+    if (rel.startsWith('..')) {
+        throw new Error('Path is outside of the parent directory - not allowing reading of arbitrary files');
+    }
+    return result;
+};
+exports.nodeCreateAdjacentFileSource = nodeCreateAdjacentFileSource;
+exports.nodeReader = {
+    read: exports.nodeReadContent,
+    readWholeAsText: exports.nodeReadWholeAsText,
+    createAdjacentFileSource: exports.nodeCreateAdjacentFileSource,
+    preload: () => {
+        // doing nothing, it's just for when fetching over the network
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/from-web-file.d.ts

@@ -0,0 +1,5 @@
+import type { CreateAdjacentFileSource, MediaParserReaderInterface, ReadContent, ReadWholeAsText } from './reader';
+export declare const webFileReadContent: ReadContent;
+export declare const webFileReadWholeAsText: ReadWholeAsText;
+export declare const webFileCreateAdjacentFileSource: CreateAdjacentFileSource;
+export declare const webFileReader: MediaParserReaderInterface;

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/from-web-file.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFileReader = exports.webFileCreateAdjacentFileSource = exports.webFileReadWholeAsText = exports.webFileReadContent = void 0;
+const webFileReadContent = ({ src, range, controller }) => {
+    if (typeof src === 'string' || src instanceof URL) {
+        throw new Error('`inputTypeFileReader` only supports `File` objects');
+    }
+    const part = range === null
+        ? src
+        : typeof range === 'number'
+            ? src.slice(range)
+            : src.slice(range[0], range[1] + 1);
+    const stream = part.stream();
+    const streamReader = stream.getReader();
+    if (controller) {
+        controller._internals.signal.addEventListener('abort', () => {
+            streamReader.cancel();
+        }, { once: true });
+    }
+    return Promise.resolve({
+        reader: {
+            reader: streamReader,
+            async abort() {
+                try {
+                    await streamReader.cancel();
+                }
+                catch (_a) { }
+                return Promise.resolve();
+            },
+        },
+        contentLength: src.size,
+        name: src instanceof File ? src.name : src.toString(),
+        supportsContentRange: true,
+        contentType: src.type,
+        needsContentRange: true,
+    });
+};
+exports.webFileReadContent = webFileReadContent;
+const webFileReadWholeAsText = () => {
+    throw new Error('`webFileReader` cannot read auxiliary files.');
+};
+exports.webFileReadWholeAsText = webFileReadWholeAsText;
+const webFileCreateAdjacentFileSource = () => {
+    throw new Error('`webFileReader` cannot create adjacent file sources.');
+};
+exports.webFileCreateAdjacentFileSource = webFileCreateAdjacentFileSource;
+exports.webFileReader = {
+    read: exports.webFileReadContent,
+    readWholeAsText: exports.webFileReadWholeAsText,
+    createAdjacentFileSource: exports.webFileCreateAdjacentFileSource,
+    preload: () => {
+        // doing nothing, it's just for when fetching over the network
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/reader.d.ts

@@ -0,0 +1,44 @@
+import type { MediaParserController } from '../controller/media-parser-controller';
+import type { MediaParserLogLevel } from '../log';
+import type { ParseMediaRange, ParseMediaSrc } from '../options';
+import type { PrefetchCache } from './from-fetch';
+export type Reader = {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    abort: () => Promise<void>;
+};
+type ReadResult = {
+    reader: Reader;
+    contentLength: number | null;
+    contentType: string | null;
+    name: string;
+    supportsContentRange: boolean;
+    needsContentRange: boolean;
+};
+export type ReadContent = (options: {
+    src: ParseMediaSrc;
+    range: ParseMediaRange;
+    controller: MediaParserController;
+    logLevel: MediaParserLogLevel;
+    prefetchCache: PrefetchCache;
+}) => Promise<ReadResult>;
+export type ReadWholeAsText = (src: ParseMediaSrc) => Promise<string>;
+export type PreloadContent = (options: {
+    src: ParseMediaSrc;
+    range: ParseMediaRange;
+    logLevel: MediaParserLogLevel;
+    prefetchCache: PrefetchCache;
+}) => void;
+export type ClearPreloadCache = (options: {
+    src: ParseMediaSrc;
+    range: ParseMediaRange;
+    logLevel: MediaParserLogLevel;
+    prefetchCache: PrefetchCache;
+}) => void;
+export type CreateAdjacentFileSource = (relativePath: string, src: ParseMediaSrc) => string;
+export type MediaParserReaderInterface = {
+    read: ReadContent;
+    readWholeAsText: ReadWholeAsText;
+    createAdjacentFileSource: CreateAdjacentFileSource;
+    preload: PreloadContent;
+};
+export {};

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/reader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/universal.d.ts

@@ -0,0 +1,2 @@
+import type { MediaParserReaderInterface } from './reader';
+export declare const universalReader: MediaParserReaderInterface;

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/universal.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.universalReader = void 0;
+const from_fetch_1 = require("./from-fetch");
+const from_node_1 = require("./from-node");
+const from_web_file_1 = require("./from-web-file");
+exports.universalReader = {
+    read: (params) => {
+        if (params.src instanceof Blob) {
+            return (0, from_web_file_1.webFileReadContent)(params);
+        }
+        if (params.src.toString().startsWith('http') ||
+            params.src.toString().startsWith('blob:')) {
+            return (0, from_fetch_1.fetchReadContent)(params);
+        }
+        return (0, from_node_1.nodeReadContent)(params);
+    },
+    readWholeAsText: (src) => {
+        if (src instanceof Blob) {
+            return (0, from_web_file_1.webFileReadWholeAsText)(src);
+        }
+        if (src.toString().startsWith('http') ||
+            src.toString().startsWith('blob:')) {
+            return (0, from_fetch_1.fetchReadWholeAsText)(src);
+        }
+        return (0, from_node_1.nodeReadWholeAsText)(src);
+    },
+    createAdjacentFileSource: (relativePath, src) => {
+        if (src instanceof Blob) {
+            return (0, from_web_file_1.webFileCreateAdjacentFileSource)(relativePath, src);
+        }
+        if (src.toString().startsWith('http') ||
+            src.toString().startsWith('blob:')) {
+            return (0, from_fetch_1.fetchCreateAdjacentFileSource)(relativePath, src);
+        }
+        return (0, from_node_1.nodeCreateAdjacentFileSource)(relativePath, src);
+    },
+    preload: ({ src, range, logLevel, prefetchCache }) => {
+        if (src instanceof Blob) {
+            return;
+        }
+        if (src.toString().startsWith('http') ||
+            src.toString().startsWith('blob:')) {
+            return (0, from_fetch_1.fetchPreload)({ range, src, logLevel, prefetchCache });
+        }
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/web.d.ts

@@ -0,0 +1,2 @@
+import type { MediaParserReaderInterface } from './reader';
+export declare const webReader: MediaParserReaderInterface;

skills/remotion-prompt-video/node_modules/@remotion/media-parser/dist/readers/web.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webReader = void 0;
+const from_fetch_1 = require("./from-fetch");
+const from_web_file_1 = require("./from-web-file");
+exports.webReader = {
+    read: (params) => {
+        if (params.src instanceof Blob) {
+            return (0, from_web_file_1.webFileReadContent)(params);
+        }
+        return (0, from_fetch_1.fetchReadContent)(params);
+    },
+    createAdjacentFileSource: (relativePath, src) => {
+        if (src instanceof Blob) {
+            return (0, from_web_file_1.webFileCreateAdjacentFileSource)(relativePath, src);
+        }
+        return (0, from_fetch_1.fetchCreateAdjacentFileSource)(relativePath, src);
+    },
+    readWholeAsText: (src) => {
+        if (src instanceof Blob) {
+            return (0, from_web_file_1.webFileReadWholeAsText)(src);
+        }
+        return (0, from_fetch_1.fetchReadWholeAsText)(src);
+    },
+    preload: ({ range, src, logLevel, prefetchCache }) => {
+        if (src instanceof Blob) {
+            return;
+        }
+        return (0, from_fetch_1.fetchPreload)({ range, src, logLevel, prefetchCache });
+    },
+};