@remotion/bundler 3.1.7 → 3.1.11

package/dist/hot-middleware/index.js

@@ -0,0 +1,180 @@
+"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) => {
+    let eventStream = createEventStream(types_1.hotMiddlewareOptions.heartbeat);
+    let latestStats = null;
+    let closed = false;
+    compiler.hooks.invalid.tap('webpack-hot-middleware', onInvalid);
+    compiler.hooks.done.tap('webpack-hot-middleware', onDone);
+    function onInvalid() {
+        if (closed)
+            return;
+        latestStats = null;
+        types_1.hotMiddlewareOptions.log('webpack building...');
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.publish({
+            action: 'building',
+        });
+    }
+    function onDone(statsResult) {
+        if (closed)
+            return;
+        // Keep hold of latest stats so they can be propagated to new clients
+        latestStats = statsResult;
+        publishStats('built', latestStats, eventStream, types_1.hotMiddlewareOptions.log);
+    }
+    const middleware = function (req, res, next) {
+        if (closed)
+            return 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, types_1.hotMiddlewareOptions.log);
+        }
+    };
+    middleware.publish = function (payload) {
+        if (closed)
+            return;
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.publish(payload);
+    };
+    middleware.close = function () {
+        if (closed)
+            return;
+        // Can't remove compiler plugins, so we just set a flag and noop if closed
+        // https://github.com/webpack/tapable/issues/32#issuecomment-350644466
+        closed = true;
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.close();
+        eventStream = null;
+    };
+    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',
+                // While behind nginx, event stream should not be buffered:
+                // http://nginx.org/docs/http/ngx_http_proxy_module.html#proxy_buffering
+                'X-Accel-Buffering': 'no',
+            };
+            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, log) {
+    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 || '';
+        }
+        if (log) {
+            log('webpack built ' +
+                (name ? name + ' ' : '') +
+                _stats.hash +
+                ' in ' +
+                _stats.time +
+                'ms');
+        }
+        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 { 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,147 @@
+"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.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') {
+        console.log('[Fast refresh] Checking for updates on the server...');
+        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 {
+            console.log('[Fast refresh] Updated modules:');
+            renewedModules.forEach((moduleId) => {
+                console.log('[Fast refresh]  - ' + (moduleMap[moduleId] || moduleId));
+            });
+        }
+        if (upToDate()) {
+            console.log('[Fast refresh] App is up to date.');
+        }
+    }
+    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,37 @@
+import webpack from '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;
+    overlay: boolean;
+    reload: boolean;
+    log: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    warn: boolean;
+    name: string;
+    autoConnect: boolean;
+    overlayStyles: {};
+    overlayWarnings: boolean;
+    ansiColors: {};
+    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,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hotMiddlewareOptions = void 0;
+exports.hotMiddlewareOptions = {
+    path: '/__webpack_hmr',
+    timeout: 20 * 1000,
+    overlay: true,
+    reload: false,
+    log: console.log.bind(console),
+    warn: true,
+    name: '',
+    autoConnect: true,
+    overlayStyles: {},
+    overlayWarnings: false,
+    ansiColors: {},
+    heartbeat: 10 * 1000,
+};

package/dist/is-path-inside.d.ts

@@ -0,0 +1 @@
+export declare const isPathInside: (thePath: string, potentialParent: string) => boolean;

package/dist/is-path-inside.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathInside = void 0;
+const path_1 = __importDefault(require("path"));
+const isPathInside = function (thePath, potentialParent) {
+    // For inside-directory checking, we want to allow trailing slashes, so normalize.
+    thePath = stripTrailingSep(thePath);
+    potentialParent = stripTrailingSep(potentialParent);
+    // Node treats only Windows as case-insensitive in its path module; we follow those conventions.
+    if (process.platform === 'win32') {
+        thePath = thePath.toLowerCase();
+        potentialParent = potentialParent.toLowerCase();
+    }
+    return (thePath.lastIndexOf(potentialParent, 0) === 0 &&
+        (thePath[potentialParent.length] === path_1.default.sep ||
+            thePath[potentialParent.length] === undefined));
+};
+exports.isPathInside = isPathInside;
+function stripTrailingSep(thePath) {
+    if (thePath[thePath.length - 1] === path_1.default.sep) {
+        return thePath.slice(0, -1);
+    }
+    return thePath;
+}

package/dist/p-limit.d.ts

@@ -0,0 +1 @@
+export declare const pLimit: (concurrency: number) => <Arguments extends unknown[], ReturnType_1>(fn: (..._arguments: Arguments) => ReturnType_1 | PromiseLike<ReturnType_1>, ...args: Arguments) => Promise<ReturnType_1>;

package/dist/p-limit.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pLimit = void 0;
+const pLimit = (concurrency) => {
+    const queue = [];
+    let activeCount = 0;
+    const next = () => {
+        var _a;
+        activeCount--;
+        if (queue.length > 0) {
+            (_a = queue.shift()) === null || _a === void 0 ? void 0 : _a();
+        }
+    };
+    const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        // eslint-disable-next-line require-await
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+            await result;
+        }
+        catch (_a) { }
+        next();
+    };
+    const enqueue = (fn, resolve, ...args) => {
+        queue.push(() => run(fn, resolve, ...args));
+        (async () => {
+            var _a;
+            // This function needs to wait until the next microtask before comparing
+            // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+            // when the run function is dequeued and called. The comparison in the if-statement
+            // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+            await Promise.resolve();
+            if (activeCount < concurrency && queue.length > 0) {
+                (_a = queue.shift()) === null || _a === void 0 ? void 0 : _a();
+            }
+        })();
+    };
+    const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+    });
+    Object.defineProperties(generator, {
+        activeCount: {
+            get: () => activeCount,
+        },
+        pendingCount: {
+            get: () => queue.length,
+        },
+        clearQueue: {
+            value: () => {
+                queue.length = 0;
+            },
+        },
+    });
+    return generator;
+};
+exports.pLimit = pLimit;

package/dist/project-info.d.ts

@@ -0,0 +1,5 @@
+export declare type ProjectInfo = {
+    videoFile: string | null;
+    relativeVideoFile: string | null;
+};
+export declare const getProjectInfo: () => Promise<ProjectInfo>;

package/dist/project-info.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectInfo = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const getProjectInfo = () => {
+    var _a;
+    const pathsToLookFor = ['src/Video.tsx', 'src/Video.jsx'].map((p) => {
+        return path_1.default.join(process.cwd(), p);
+    });
+    const videoFile = (_a = pathsToLookFor.find((p) => (0, fs_1.existsSync)(p))) !== null && _a !== void 0 ? _a : null;
+    return Promise.resolve({
+        videoFile,
+        relativeVideoFile: videoFile
+            ? path_1.default.relative(process.cwd(), videoFile)
+            : null,
+    });
+};
+exports.getProjectInfo = getProjectInfo;

package/dist/routes.d.ts

@@ -0,0 +1,2 @@
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const handleRoutes: (hash: string, request: IncomingMessage, response: ServerResponse) => void | Promise<void>;

package/dist/routes.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRoutes = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const get_file_source_1 = require("./error-overlay/react-overlay/utils/get-file-source");
+const open_in_editor_1 = require("./error-overlay/react-overlay/utils/open-in-editor");
+const project_info_1 = require("./project-info");
+const serve_static_1 = require("./serve-static");
+const static_preview_1 = require("./static-preview");
+const update_available_1 = require("./update-available");
+const handleUpdate = async (_, response) => {
+    const data = await (0, update_available_1.isUpdateAvailableWithTimeout)();
+    response.setHeader('content-type', 'application/json');
+    response.writeHead(200);
+    response.end(JSON.stringify(data));
+};
+const editorGuess = (0, open_in_editor_1.guessEditor)();
+const handleFallback = async (hash, _, response) => {
+    const edit = await editorGuess;
+    const displayName = (0, open_in_editor_1.getDisplayNameForEditor)(edit[0]);
+    response.setHeader('content-type', 'text/html');
+    response.writeHead(200);
+    response.end((0, static_preview_1.indexHtml)(hash, '/', displayName));
+};
+const handleProjectInfo = async (_, response) => {
+    const data = await (0, project_info_1.getProjectInfo)();
+    response.setHeader('content-type', 'application/json');
+    response.writeHead(200);
+    response.end(JSON.stringify(data));
+};
+const handleFileSource = async (search, _, response) => {
+    if (!search.startsWith('?')) {
+        throw new Error('query must start with ?');
+    }
+    const query = new url_1.URLSearchParams(search);
+    const f = query.get('f');
+    if (typeof f !== 'string') {
+        throw new Error('must pass `f` parameter');
+    }
+    const data = await (0, get_file_source_1.getFileSource)(decodeURIComponent(f));
+    response.writeHead(200);
+    response.write(data);
+    return response.end();
+};
+const handleOpenInEditor = async (req, res) => {
+    try {
+        const b = await new Promise((_resolve) => {
+            let data = '';
+            req.on('data', (chunk) => {
+                data += chunk;
+            });
+            req.on('end', () => {
+                _resolve(data.toString());
+            });
+        });
+        const body = JSON.parse(b);
+        if (!('stack' in body)) {
+            throw new TypeError('Need to pass stack');
+        }
+        const stack = body.stack;
+        const guess = await editorGuess;
+        const didOpen = await (0, open_in_editor_1.launchEditor)({
+            colNumber: stack.originalColumnNumber,
+            editor: guess[0],
+            fileName: path_1.default.resolve(process.cwd(), stack.originalFileName),
+            lineNumber: stack.originalLineNumber,
+            vsCodeNewWindow: false,
+        });
+        res.setHeader('content-type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({
+            success: didOpen,
+        }));
+    }
+    catch (err) {
+        res.setHeader('content-type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({
+            success: false,
+        }));
+    }
+};
+const handleFavicon = (_, response) => {
+    const filePath = path_1.default.join(__dirname, '..', 'web', 'favicon.png');
+    const stat = (0, fs_1.statSync)(filePath);
+    response.writeHead(200, {
+        'Content-Type': 'image/png',
+        'Content-Length': stat.size,
+    });
+    const readStream = (0, fs_1.createReadStream)(filePath);
+    readStream.pipe(response);
+};
+const handleRoutes = (hash, request, response) => {
+    const url = new URL(request.url, 'http://localhost');
+    if (url.pathname === '/api/update') {
+        return handleUpdate(request, response);
+    }
+    if (url.pathname === '/api/project-info') {
+        return handleProjectInfo(request, response);
+    }
+    if (url.pathname === '/api/file-source') {
+        return handleFileSource(url.search, request, response);
+    }
+    if (url.pathname === '/api/open-in-editor') {
+        return handleOpenInEditor(request, response);
+    }
+    if (url.pathname === '/remotion.png') {
+        return handleFavicon(request, response);
+    }
+    if (url.pathname.startsWith(hash)) {
+        const root = path_1.default.join(process.cwd(), 'public');
+        return (0, serve_static_1.serveStatic)(root, hash, request, response);
+    }
+    return handleFallback(hash, request, response);
+};
+exports.handleRoutes = handleRoutes;

package/dist/serve-static.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * serve-static
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * Copyright(c) 2014-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const serveStatic: (root: string, hash: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;