@remotion/bundler 3.3.44 → 3.3.45

package/dist/bundle-setup.d.ts

@@ -0,0 +1 @@
+import './setup-environment';

package/dist/bundle-setup.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./setup-environment");

package/dist/bundle.d.ts

@@ -1,5 +1,5 @@
-import type { WebpackOverrideFn } from 'remotion';
 import webpack from 'webpack';
+import type { WebpackOverrideFn } from './types';
 export declare type LegacyBundleOptions = {
     webpackOverride?: WebpackOverrideFn;
     outDir?: string;

package/dist/homepage/homepage.js

@@ -26,10 +26,14 @@ const pre = {
 const AvailableCompositions = () => {
     const [comps, setComps] = (0, react_1.useState)(null);
     (0, react_1.useEffect)(() => {
+        if ((0, bundle_mode_1.getBundleMode)().type !== 'evaluation') {
+            return;
+        }
         let timeout = null;
         const check = () => {
             if (window.ready === true) {
-                setComps(window.getStaticCompositions());
+                const newComps = window.getStaticCompositions();
+                setComps(newComps);
             }
             else {
                 timeout = setTimeout(check, 250);
@@ -50,7 +54,7 @@ const AvailableCompositions = () => {
         return ((0, jsx_runtime_1.jsx)("button", { type: "button", onClick: showComps, children: "Click here to see a list of available compositions." }));
     }
     return ((0, jsx_runtime_1.jsxs)("div", { children: [comps === null ? (0, jsx_runtime_1.jsx)("p", { children: "Loading compositions..." }) : null, (0, jsx_runtime_1.jsx)("ul", { children: comps === null
-                    ? null
+                    ? []
                     : comps.map((c) => {
                         return (0, jsx_runtime_1.jsx)("li", { children: c.id }, c.id);
                     }) })] }));

package/dist/hot-middleware/client.d.ts

@@ -0,0 +1,19 @@
+import type { HotMiddlewareMessage } from './types';
+declare function eventSourceWrapper(): {
+    addMessageListener(fn: (msg: MessageEvent) => void): void;
+};
+declare global {
+    interface Window {
+        __whmEventSourceWrapper: {
+            [key: string]: ReturnType<typeof eventSourceWrapper>;
+        };
+        __webpack_hot_middleware_reporter__: Reporter;
+    }
+}
+declare type Reporter = ReturnType<typeof createReporter>;
+declare function createReporter(): {
+    cleanProblemsCache(): void;
+    problems(type: 'errors' | 'warnings', obj: HotMiddlewareMessage): boolean;
+    success: () => undefined;
+};
+export {};

package/dist/hot-middleware/client.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+/**
+ * Source code is adapted from
+ * https://github.com/webpack-contrib/webpack-hot-middleware#readme
+ * and rewritten in TypeScript. This file is MIT licensed
+ */
+const process_update_1 = require("./process-update");
+const strip_ansi_1 = require("./strip-ansi");
+const types_1 = require("./types");
+if (typeof window === 'undefined') {
+    // do nothing
+}
+else if (typeof window.EventSource === 'undefined') {
+    console.warn('Unsupported browser: You need a browser that supports EventSource ');
+}
+else {
+    connect();
+}
+function eventSourceWrapper() {
+    let source;
+    let lastActivity = Date.now();
+    const listeners = [];
+    init();
+    const timer = setInterval(() => {
+        if (Date.now() - lastActivity > types_1.hotMiddlewareOptions.timeout) {
+            handleDisconnect();
+        }
+    }, types_1.hotMiddlewareOptions.timeout / 2);
+    function init() {
+        source = new window.EventSource(types_1.hotMiddlewareOptions.path);
+        source.onopen = handleOnline;
+        source.onerror = handleDisconnect;
+        source.onmessage = handleMessage;
+    }
+    function handleOnline() {
+        lastActivity = Date.now();
+    }
+    function handleMessage(event) {
+        lastActivity = Date.now();
+        for (let i = 0; i < listeners.length; i++) {
+            listeners[i](event);
+        }
+    }
+    function handleDisconnect() {
+        clearInterval(timer);
+        source.close();
+        setTimeout(init, types_1.hotMiddlewareOptions.timeout);
+    }
+    return {
+        addMessageListener(fn) {
+            listeners.push(fn);
+        },
+    };
+}
+function getEventSourceWrapper() {
+    if (!window.__whmEventSourceWrapper) {
+        window.__whmEventSourceWrapper = {};
+    }
+    if (!window.__whmEventSourceWrapper[types_1.hotMiddlewareOptions.path]) {
+        // cache the wrapper for other entries loaded on
+        // the same page with the same hotMiddlewareOptions.path
+        window.__whmEventSourceWrapper[types_1.hotMiddlewareOptions.path] =
+            eventSourceWrapper();
+    }
+    return window.__whmEventSourceWrapper[types_1.hotMiddlewareOptions.path];
+}
+function connect() {
+    getEventSourceWrapper().addMessageListener(handleMessage);
+    function handleMessage(event) {
+        if (event.data === '\uD83D\uDC93') {
+            return;
+        }
+        try {
+            processMessage(JSON.parse(event.data));
+        }
+        catch (ex) {
+            if (types_1.hotMiddlewareOptions.warn) {
+                console.warn('Invalid HMR message: ' + event.data + '\n' + ex);
+            }
+        }
+    }
+}
+// the reporter needs to be a singleton on the page
+// in case the client is being used by multiple bundles
+// we only want to report once.
+// all the errors will go to all clients
+const singletonKey = '__webpack_hot_middleware_reporter__';
+let reporter;
+if (typeof window !== 'undefined') {
+    if (!window[singletonKey]) {
+        window[singletonKey] = createReporter();
+    }
+    reporter = window[singletonKey];
+}
+function createReporter() {
+    const styles = {
+        errors: 'color: #ff0000;',
+        warnings: 'color: #999933;',
+    };
+    let previousProblems = null;
+    function log(type, obj) {
+        if (obj.action === 'building') {
+            console.log('[Fast Refresh] Building');
+            return;
+        }
+        const newProblems = obj[type]
+            .map((msg) => {
+            return (0, strip_ansi_1.stripAnsi)(msg);
+        })
+            .join('\n');
+        if (previousProblems === newProblems) {
+            return;
+        }
+        previousProblems = newProblems;
+        const style = styles[type];
+        const name = obj.name ? "'" + obj.name + "' " : '';
+        const title = '[Fast Refresh] bundle ' + name + 'has ' + obj[type].length + ' ' + type;
+        // NOTE: console.warn or console.error will print the stack trace
+        // which isn't helpful here, so using console.log to escape it.
+        if (console.group && console.groupEnd) {
+            console.group('%c' + title, style);
+            console.log('%c' + newProblems, style);
+            console.groupEnd();
+        }
+        else {
+            console.log('%c' + title + '\n\t%c' + newProblems.replace(/\n/g, '\n\t'), style + 'font-weight: bold;', style + 'font-weight: normal;');
+        }
+    }
+    return {
+        cleanProblemsCache() {
+            previousProblems = null;
+        },
+        problems(type, obj) {
+            if (types_1.hotMiddlewareOptions.warn) {
+                log(type, obj);
+            }
+            return true;
+        },
+        success: () => undefined,
+    };
+}
+function processMessage(obj) {
+    var _a, _b;
+    switch (obj.action) {
+        case 'building':
+            (_a = window.remotion_isBuilding) === null || _a === void 0 ? void 0 : _a.call(window);
+            break;
+        case 'sync':
+        case 'built': {
+            let applyUpdate = true;
+            if (obj.errors.length > 0) {
+                if (reporter)
+                    reporter.problems('errors', obj);
+                applyUpdate = false;
+            }
+            else if (obj.warnings.length > 0) {
+                if (reporter) {
+                    const overlayShown = reporter.problems('warnings', obj);
+                    applyUpdate = overlayShown;
+                }
+            }
+            else if (reporter) {
+                reporter.cleanProblemsCache();
+                reporter.success();
+            }
+            if (applyUpdate) {
+                (_b = window.remotion_finishedBuilding) === null || _b === void 0 ? void 0 : _b.call(window);
+                (0, process_update_1.processUpdate)(obj.hash, obj.modules, types_1.hotMiddlewareOptions);
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}

package/dist/hot-middleware/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Source code is adapted from
+ * https://github.com/webpack-contrib/webpack-hot-middleware#readme
+ * and rewritten in TypeScript. This file is MIT licensed
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import webpack = require('webpack');
+export declare const webpackHotMiddleware: (compiler: webpack.Compiler, logInfo: (str: string) => void) => (req: IncomingMessage, res: ServerResponse, next: () => void) => void;

package/dist/hot-middleware/index.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Source code is adapted from
+ * https://github.com/webpack-contrib/webpack-hot-middleware#readme
+ * and rewritten in TypeScript. This file is MIT licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackHotMiddleware = void 0;
+const url_1 = require("url");
+const types_1 = require("./types");
+const pathMatch = function (url, path) {
+    try {
+        return (0, url_1.parse)(url).pathname === path;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const webpackHotMiddleware = (compiler, logInfo) => {
+    const eventStream = createEventStream(types_1.hotMiddlewareOptions.heartbeat);
+    let latestStats = null;
+    compiler.hooks.invalid.tap('remotion', onInvalid);
+    compiler.hooks.done.tap('remotion', onDone);
+    function onInvalid() {
+        latestStats = null;
+        logInfo('Building...');
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.publish({
+            action: 'building',
+        });
+    }
+    function onDone(statsResult) {
+        // Keep hold of latest stats so they can be propagated to new clients
+        latestStats = statsResult;
+        publishStats('built', latestStats, eventStream);
+    }
+    const middleware = function (req, res, next) {
+        if (!pathMatch(req.url, types_1.hotMiddlewareOptions.path))
+            return next();
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.handler(req, res);
+        if (latestStats) {
+            publishStats('sync', latestStats, eventStream);
+        }
+    };
+    return middleware;
+};
+exports.webpackHotMiddleware = webpackHotMiddleware;
+function createEventStream(heartbeat) {
+    let clientId = 0;
+    let clients = {};
+    function everyClient(fn) {
+        Object.keys(clients).forEach((id) => {
+            fn(clients[id]);
+        });
+    }
+    const interval = setInterval(() => {
+        everyClient((client) => {
+            client.write('data: \uD83D\uDC93\n\n');
+        });
+    }, heartbeat).unref();
+    return {
+        close() {
+            clearInterval(interval);
+            everyClient((client) => {
+                if (!client.finished)
+                    client.end();
+            });
+            clients = {};
+        },
+        handler(req, res) {
+            const headers = {
+                'Access-Control-Allow-Origin': '*',
+                'Content-Type': 'text/event-stream;charset=utf-8',
+                'Cache-Control': 'no-cache, no-transform',
+            };
+            const isHttp1 = !(parseInt(req.httpVersion, 10) >= 2);
+            if (isHttp1) {
+                req.socket.setKeepAlive(true);
+                Object.assign(headers, {
+                    Connection: 'keep-alive',
+                });
+            }
+            res.writeHead(200, headers);
+            res.write('\n');
+            const id = clientId++;
+            clients[id] = res;
+            req.on('close', () => {
+                if (!res.finished)
+                    res.end();
+                delete clients[id];
+            });
+        },
+        publish(payload) {
+            everyClient((client) => {
+                client.write('data: ' + JSON.stringify(payload) + '\n\n');
+            });
+        },
+    };
+}
+function publishStats(action, statsResult, eventStream) {
+    const stats = statsResult.toJson({
+        all: false,
+        cached: true,
+        children: true,
+        modules: true,
+        timings: true,
+        hash: true,
+    });
+    // For multi-compiler, stats will be an object with a 'children' array of stats
+    const bundles = extractBundles(stats);
+    bundles.forEach((_stats) => {
+        let name = _stats.name || '';
+        // Fallback to compilation name in case of 1 bundle (if it exists)
+        if (bundles.length === 1 && !name && statsResult.compilation) {
+            name = statsResult.compilation.name || '';
+        }
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.publish({
+            name,
+            action,
+            time: _stats.time,
+            hash: _stats.hash,
+            warnings: _stats.warnings || [],
+            errors: _stats.errors || [],
+            modules: buildModuleMap(_stats.modules),
+        });
+    });
+}
+function extractBundles(stats) {
+    var _a;
+    // Stats has modules, single bundle
+    if (stats.modules)
+        return [stats];
+    // Stats has children, multiple bundles
+    if ((_a = stats.children) === null || _a === void 0 ? void 0 : _a.length)
+        return stats.children;
+    // Not sure, assume single
+    return [stats];
+}
+function buildModuleMap(modules) {
+    const map = {};
+    if (!modules) {
+        return map;
+    }
+    modules.forEach((module) => {
+        const id = module.id;
+        map[id] = module.name;
+    });
+    return map;
+}

package/dist/hot-middleware/process-update.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Source code is adapted from
+ * https://github.com/webpack-contrib/webpack-hot-middleware#readme
+ * and rewritten in TypeScript. This file is MIT licensed
+ */
+/**
+ * Based heavily on https://github.com/webpack/webpack/blob/
+ *  c0afdf9c6abc1dd70707c594e473802a566f7b6e/hot/only-dev-server.js
+ * Original copyright Tobias Koppers @sokra (MIT license)
+ */
+import type { HotMiddlewareOptions, ModuleMap } from './types';
+export declare const processUpdate: (hash: string | undefined, moduleMap: ModuleMap, options: HotMiddlewareOptions) => void;

package/dist/hot-middleware/process-update.js

@@ -0,0 +1,144 @@
+"use strict";
+/* eslint-disable no-console */
+/**
+ * Source code is adapted from
+ * https://github.com/webpack-contrib/webpack-hot-middleware#readme
+ * and rewritten in TypeScript. This file is MIT licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUpdate = void 0;
+/* global  __webpack_hash__ */
+if (!module.hot) {
+    throw new Error('[Fast refresh] Hot Module Replacement is disabled.');
+}
+const hmrDocsUrl = 'https://webpack.js.org/concepts/hot-module-replacement/'; // eslint-disable-line max-len
+let lastHash;
+const failureStatuses = { abort: 1, fail: 1 };
+const applyOptions = {
+    ignoreUnaccepted: true,
+    ignoreDeclined: true,
+    ignoreErrored: true,
+    onUnaccepted(data) {
+        var _a;
+        console.warn('Ignored an update to unaccepted module ' +
+            ((_a = data.chain) !== null && _a !== void 0 ? _a : []).join(' -> '));
+    },
+    onDeclined(data) {
+        var _a;
+        console.warn('Ignored an update to declined module ' + ((_a = data.chain) !== null && _a !== void 0 ? _a : []).join(' -> '));
+    },
+    onErrored(data) {
+        console.error(data.error);
+        console.warn('Ignored an error while updating module ' +
+            data.moduleId +
+            ' (' +
+            data.type +
+            ')');
+    },
+};
+function upToDate(hash) {
+    if (hash)
+        lastHash = hash;
+    return lastHash === __webpack_hash__;
+}
+const processUpdate = function (hash, moduleMap, options) {
+    var _a;
+    const { reload } = options;
+    if (!upToDate(hash) && ((_a = module.hot) === null || _a === void 0 ? void 0 : _a.status()) === 'idle') {
+        check();
+    }
+    async function check() {
+        var _a;
+        const cb = function (err, updatedModules) {
+            var _a;
+            if (err)
+                return handleError(err);
+            if (!updatedModules) {
+                if (options.warn) {
+                    console.warn('[Fast refresh] Cannot find update (Full reload needed)');
+                    console.warn('[Fast refresh] (Probably because of restarting the server)');
+                }
+                performReload();
+                return null;
+            }
+            const applyCallback = function (applyErr, renewedModules) {
+                if (applyErr)
+                    return handleError(applyErr);
+                if (!upToDate()) {
+                    check();
+                }
+                logUpdates(updatedModules, renewedModules);
+            };
+            const applyResult = (_a = module.hot) === null || _a === void 0 ? void 0 : _a.apply(applyOptions, applyCallback);
+            if (applyResult === null || applyResult === void 0 ? void 0 : applyResult.then) {
+                // HotModuleReplacement.runtime.js refers to the result as `outdatedModules`
+                applyResult
+                    .then((outdatedModules) => {
+                    applyCallback(null, outdatedModules);
+                })
+                    .catch((_err) => applyCallback(_err, []));
+            }
+        };
+        try {
+            const result = await ((_a = module.hot) === null || _a === void 0 ? void 0 : _a.check(false, cb));
+            cb(null, result);
+        }
+        catch (err) {
+            cb(err, []);
+        }
+    }
+    function logUpdates(updatedModules, renewedModules) {
+        var _a;
+        const unacceptedModules = (_a = updatedModules === null || updatedModules === void 0 ? void 0 : updatedModules.filter((moduleId) => {
+            return renewedModules && renewedModules.indexOf(moduleId) < 0;
+        })) !== null && _a !== void 0 ? _a : [];
+        if (unacceptedModules.length > 0) {
+            if (options.warn) {
+                console.warn("[Fast refresh] The following modules couldn't be hot updated: " +
+                    '(Full reload needed)\n' +
+                    'This is usually because the modules which have changed ' +
+                    '(and their parents) do not know how to hot reload themselves. ' +
+                    'See ' +
+                    hmrDocsUrl +
+                    ' for more details.');
+                unacceptedModules.forEach((moduleId) => {
+                    console.warn('[Fast refresh]  - ' + (moduleMap[moduleId] || moduleId));
+                });
+            }
+            performReload();
+            return;
+        }
+        if (!renewedModules || renewedModules.length === 0) {
+            console.log('[Fast refresh] Nothing hot updated.');
+        }
+        else {
+            renewedModules.forEach((moduleId) => {
+                console.log(`[Fast refresh] ${moduleMap[moduleId] || moduleId} fast refreshed.`);
+            });
+        }
+    }
+    function handleError(err) {
+        var _a, _b;
+        if (((_b = (_a = module.hot) === null || _a === void 0 ? void 0 : _a.status()) !== null && _b !== void 0 ? _b : 'nope') in failureStatuses) {
+            if (options.warn) {
+                console.warn('[Fast refresh] Cannot check for update (Full reload needed)');
+                console.warn('[Fast refresh] ' + (err.stack || err.message));
+            }
+            performReload();
+            return;
+        }
+        if (options.warn) {
+            console.warn('[Fast refresh] Update check failed: ' + (err.stack || err.message));
+            window.location.reload();
+        }
+    }
+    function performReload() {
+        if (!reload) {
+            return;
+        }
+        if (options.warn)
+            console.warn('[Fast refresh] Reloading page');
+        window.location.reload();
+    }
+};
+exports.processUpdate = processUpdate;

package/dist/hot-middleware/strip-ansi.d.ts

@@ -0,0 +1 @@
+export declare const stripAnsi: (str: string) => string;

package/dist/hot-middleware/strip-ansi.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = void 0;
+/**
+ * Code inlined from https://github.com/chalk/strip-ansi#readme
+ * This file is MIT licensed.
+ */
+const ansiRegex = () => {
+    const pattern = [
+        '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+        '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))',
+    ].join('|');
+    return new RegExp(pattern, 'g');
+};
+const stripAnsi = (str) => {
+    if (typeof str !== 'string') {
+        throw new TypeError(`Expected a \`string\`, got \`${typeof str}\``);
+    }
+    return str.replace(ansiRegex(), '');
+};
+exports.stripAnsi = stripAnsi;

package/dist/hot-middleware/types.d.ts

@@ -0,0 +1,27 @@
+import webpack = require('webpack');
+export declare type HotMiddlewareMessage = {
+    action: 'building';
+    name?: string;
+} | {
+    action: 'built' | 'sync';
+    name: string;
+    time: number | undefined;
+    errors: unknown[];
+    warnings: unknown[];
+    hash: string | undefined;
+    modules: {
+        [key: string]: string;
+    };
+};
+export declare const hotMiddlewareOptions: {
+    path: string;
+    timeout: number;
+    reload: boolean;
+    warn: boolean;
+    heartbeat: number;
+};
+export declare type HotMiddlewareOptions = typeof hotMiddlewareOptions;
+export declare type WebpackStats = ReturnType<webpack.Stats['toJson']>;
+export declare type ModuleMap = {
+    [key: string]: string;
+};

package/dist/hot-middleware/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hotMiddlewareOptions = void 0;
+exports.hotMiddlewareOptions = {
+    path: '/__webpack_hmr',
+    timeout: 20 * 1000,
+    reload: true,
+    warn: true,
+    heartbeat: 10 * 1000,
+};

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import type { WebpackOverrideFn } from './types';
 import esbuild = require('esbuild');
 import webpack = require('webpack');
 export declare const BundlerInternals: {
@@ -7,7 +8,7 @@ export declare const BundlerInternals: {
         userDefinedComponent: string;
         outDir: string;
         environment: "development" | "production";
-        webpackOverride: import("remotion/dist/internals").WebpackOverrideFn;
+        webpackOverride: WebpackOverrideFn;
         onProgress?: ((f: number) => void) | undefined;
         enableCaching?: boolean | undefined;
         envVariables: Record<string, string>;
@@ -48,5 +49,10 @@ export declare const BundlerInternals: {
     }) => import("remotion").StaticFile[];
 };
 export { bundle, BundleOptions, LegacyBundleOptions } from './bundle';
+export { WebpackConfiguration, WebpackOverrideFn } from './types';
 export { webpack };
-export declare type WebpackConfiguration = webpack.Configuration;
+declare global {
+    interface RemotionBundlingOptions {
+        readonly overrideWebpackConfig: (f: WebpackOverrideFn) => void;
+    }
+}

package/dist/index.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.webpack = exports.bundle = exports.BundlerInternals = void 0;
 const bundle_1 = require("./bundle");
 const index_html_1 = require("./index-html");
+const read_recursively_1 = require("./read-recursively");
 const webpack_cache_1 = require("./webpack-cache");
 const webpack_config_1 = require("./webpack-config");
 const esbuild = require("esbuild");
 const webpack = require("webpack");
 exports.webpack = webpack;
-const read_recursively_1 = require("./read-recursively");
 exports.BundlerInternals = {
     esbuild,
     webpackConfig: webpack_config_1.webpackConfig,

package/dist/preview-setup.d.ts

@@ -0,0 +1,4 @@
+import './fast-refresh/runtime';
+import './setup-environment';
+import './hot-middleware/client';
+import './error-overlay/entry-basic.js';

package/dist/preview-setup.js

@@ -0,0 +1,10 @@
+"use strict";
+// organize-imports-ignore
+Object.defineProperty(exports, "__esModule", { value: true });
+// Fast Refresh must come first,
+// because setup-environment imports ReactDOM.
+// If React DOM is imported before Fast Refresh, Fast Refresh does not work
+require("./fast-refresh/runtime");
+require("./setup-environment");
+require("./hot-middleware/client");
+require("./error-overlay/entry-basic.js");

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+import webpack = require('webpack');
+export declare type WebpackConfiguration = webpack.Configuration;
+export declare type WebpackOverrideFn = (currentConfiguration: WebpackConfiguration) => WebpackConfiguration;

package/dist/types.js

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

package/dist/webpack-config.d.ts

@@ -1,4 +1,4 @@
-import type { WebpackConfiguration, WebpackOverrideFn } from 'remotion';
+import type { WebpackConfiguration, WebpackOverrideFn } from './types';
 export declare const webpackConfig: ({ entry, userDefinedComponent, outDir, environment, webpackOverride, onProgress, enableCaching, envVariables, maxTimelineTracks, entryPoints, remotionRoot, keyboardShortcutsEnabled, poll, }: {
     entry: string;
     userDefinedComponent: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/bundler",
-	"version": "3.3.44",
+	"version": "3.3.45",
 	"description": "Bundler for Remotion",
 	"main": "dist/index.js",
 	"sideEffects": false,
@@ -26,7 +26,7 @@
 		"css-loader": "5.2.7",
 		"esbuild": "0.16.12",
 		"react-refresh": "0.9.0",
-		"remotion": "3.3.44",
+		"remotion": "3.3.45",
 		"style-loader": "2.0.0",
 		"webpack": "5.74.0"
 	},
@@ -64,5 +64,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "7ba7bbdacbda1499ecdb92f1d9581d5db458edf8"
+	"gitHead": "75c028236b43ff2fd0f3f3772f9f79cfde069e36"
 }