@remotion/renderer 3.0.16 → 3.0.19

package/dist/render-gif.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGif = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const can_use_parallel_encoding_1 = require("./can-use-parallel-encoding");
+const ensure_frames_in_order_1 = require("./ensure-frames-in-order");
+const ensure_output_directory_1 = require("./ensure-output-directory");
+const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const get_extension_of_filename_1 = require("./get-extension-of-filename");
+const get_frame_to_render_1 = require("./get-frame-to-render");
+const legacy_webpack_config_1 = require("./legacy-webpack-config");
+const make_cancel_signal_1 = require("./make-cancel-signal");
+const prespawn_ffmpeg_1 = require("./prespawn-ffmpeg");
+const render_frames_1 = require("./render-frames");
+const stitch_frames_to_gif_1 = require("./stitch-frames-to-gif");
+const tmp_dir_1 = require("./tmp-dir");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+const validate_output_filename_1 = require("./validate-output-filename");
+const validate_scale_1 = require("./validate-scale");
+const renderGif = ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, loop, skipNFrames, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }) => {
+    remotion_1.Internals.validateQuality(quality);
+    if (typeof crf !== 'undefined' && crf !== null) {
+        remotion_1.Internals.validateSelectedCrfAndCodecCombination(crf, codec);
+    }
+    (0, validate_output_filename_1.validateOutputFilename)(codec, (0, get_extension_of_filename_1.getExtensionOfFilename)(outputLocation));
+    (0, validate_scale_1.validateScale)(scale);
+    const serveUrl = (0, legacy_webpack_config_1.getServeUrlWithFallback)(options);
+    let stitchStage = 'encoding';
+    let stitcherFfmpeg;
+    let preStitcher = null;
+    let encodedFrames = 0;
+    let renderedFrames = 0;
+    let renderedDoneIn = null;
+    let encodedDoneIn = null;
+    let cancelled = false;
+    const renderStart = Date.now();
+    const tmpdir = (0, tmp_dir_1.tmpDir)('pre-encode');
+    const parallelEncoding = (0, can_use_parallel_encoding_1.canUseParallelEncoding)(codec);
+    const actualImageFormat = imageFormat !== null && imageFormat !== void 0 ? imageFormat : 'jpeg';
+    const preEncodedFileLocation = parallelEncoding
+        ? path_1.default.join(tmpdir, 'pre-encode.' + (0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, 'chunk'))
+        : null;
+    const outputDir = parallelEncoding
+        ? null
+        : fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'react-motion-render'));
+    (0, validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec)({
+        codec,
+        height: composition.height,
+        scale: scale !== null && scale !== void 0 ? scale : 1,
+        width: composition.width,
+    });
+    const callUpdate = () => {
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+            encodedDoneIn,
+            encodedFrames,
+            renderedDoneIn,
+            renderedFrames,
+            stitchStage,
+        });
+    };
+    const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange !== null && frameRange !== void 0 ? frameRange : null);
+    const cancelRenderFrames = (0, make_cancel_signal_1.makeCancelSignal)();
+    const cancelPrestitcher = (0, make_cancel_signal_1.makeCancelSignal)();
+    const cancelStitcher = (0, make_cancel_signal_1.makeCancelSignal)();
+    cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+        cancelRenderFrames.cancel();
+    });
+    const { waitForRightTimeOfFrameToBeInserted, setFrameToStitch, waitForFinish } = (0, ensure_frames_in_order_1.ensureFramesInOrder)(realFrameRange);
+    const actualGifFps = Math.floor(composition.fps / (skipNFrames + 1));
+    const createPrestitcherIfNecessary = async () => {
+        if (preEncodedFileLocation) {
+            preStitcher = await (0, prespawn_ffmpeg_1.prespawnFfmpeg)({
+                width: composition.width * (scale !== null && scale !== void 0 ? scale : 1),
+                height: composition.height * (scale !== null && scale !== void 0 ? scale : 1),
+                fps: actualGifFps,
+                outputLocation: preEncodedFileLocation,
+                pixelFormat,
+                codec,
+                proResProfile,
+                crf,
+                onProgress: (frame) => {
+                    encodedFrames = frame;
+                    callUpdate();
+                },
+                verbose: remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), 'verbose'),
+                ffmpegExecutable,
+                imageFormat: actualImageFormat,
+                signal: cancelPrestitcher.cancelSignal,
+            });
+            stitcherFfmpeg = preStitcher.task;
+        }
+    };
+    const waitForPrestitcherIfNecessary = async () => {
+        var _a;
+        if (stitcherFfmpeg) {
+            await waitForFinish();
+            (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.end();
+            try {
+                await stitcherFfmpeg;
+            }
+            catch (err) {
+                throw new Error(preStitcher === null || preStitcher === void 0 ? void 0 : preStitcher.getLogs());
+            }
+        }
+    };
+    const happyPath = createPrestitcherIfNecessary()
+        .then(() => {
+        const renderFramesProc = (0, render_frames_1.renderFrames)({
+            config: composition,
+            onFrameUpdate: (frame) => {
+                stitchStage = 'gif';
+                renderedFrames = frame;
+                callUpdate();
+            },
+            parallelism,
+            outputDir,
+            skipNFrames,
+            onStart: (data) => {
+                renderedFrames = 0;
+                callUpdate();
+                onStart === null || onStart === void 0 ? void 0 : onStart(data);
+            },
+            inputProps,
+            envVariables,
+            imageFormat: actualImageFormat,
+            quality,
+            frameRange: frameRange !== null && frameRange !== void 0 ? frameRange : null,
+            puppeteerInstance,
+            onFrameBuffer: parallelEncoding
+                ? async (buffer, frame) => {
+                    var _a;
+                    await waitForRightTimeOfFrameToBeInserted(frame);
+                    if (cancelled) {
+                        return;
+                    }
+                    (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.write(buffer);
+                    setFrameToStitch(frame + 1);
+                }
+                : undefined,
+            serveUrl,
+            dumpBrowserLogs,
+            onBrowserLog,
+            onDownload,
+            timeoutInMilliseconds,
+            chromiumOptions,
+            scale,
+            ffmpegExecutable,
+            browserExecutable,
+            port,
+            cancelSignal: cancelRenderFrames.cancelSignal,
+        });
+        return renderFramesProc;
+    })
+        .then((renderFramesReturn) => {
+        return Promise.all([renderFramesReturn, waitForPrestitcherIfNecessary()]);
+    })
+        .then(([{ assetsInfo }]) => {
+        renderedDoneIn = Date.now() - renderStart;
+        callUpdate();
+        (0, ensure_output_directory_1.ensureOutputDirectory)(outputLocation);
+        const stitchStart = Date.now();
+        return Promise.all([
+            (0, stitch_frames_to_gif_1.stitchFramesToGif)({
+                width: composition.width * (scale !== null && scale !== void 0 ? scale : 1),
+                height: composition.height * (scale !== null && scale !== void 0 ? scale : 1),
+                fps: actualGifFps,
+                outputLocation,
+                internalOptions: {
+                    preEncodedFileLocation,
+                    imageFormat: actualImageFormat,
+                },
+                force: overwrite !== null && overwrite !== void 0 ? overwrite : remotion_1.Internals.DEFAULT_OVERWRITE,
+                pixelFormat,
+                codec,
+                proResProfile,
+                crf,
+                loop,
+                assetsInfo,
+                ffmpegExecutable,
+                onProgress: (frame) => {
+                    stitchStage = 'gif';
+                    encodedFrames = frame;
+                    callUpdate();
+                },
+                verbose: remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), 'verbose'),
+                dir: outputDir !== null && outputDir !== void 0 ? outputDir : undefined,
+                cancelSignal: cancelStitcher.cancelSignal,
+            }),
+            stitchStart,
+        ]);
+    })
+        .then(([, stitchStart]) => {
+        encodedFrames = (0, get_duration_from_frame_range_1.getDurationFromFrameRange)(frameRange !== null && frameRange !== void 0 ? frameRange : null, composition.durationInFrames, skipNFrames);
+        encodedDoneIn = Date.now() - stitchStart;
+        callUpdate();
+    })
+        .catch((err) => {
+        /**
+         * When an error is thrown in renderFrames(...) (e.g., when delayRender() is used incorrectly), fs.unlinkSync(...) throws an error that the file is locked because ffmpeg is still running, and renderMedia returns it.
+         * Therefore we first kill the FFMPEG process before deleting the file
+         */
+        cancelled = true;
+        cancelRenderFrames.cancel();
+        cancelStitcher.cancel();
+        cancelPrestitcher.cancel();
+        if (stitcherFfmpeg !== undefined && stitcherFfmpeg.exitCode === null) {
+            const promise = new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                }, 2000);
+                stitcherFfmpeg.on('close', resolve);
+            });
+            stitcherFfmpeg.kill();
+            return promise.then(() => {
+                throw err;
+            });
+        }
+        throw err;
+    })
+        .finally(() => {
+        if (preEncodedFileLocation !== null &&
+            fs_1.default.existsSync(preEncodedFileLocation)) {
+            fs_1.default.unlinkSync(preEncodedFileLocation);
+        }
+    });
+    return Promise.race([
+        happyPath,
+        new Promise((_resolve, reject) => {
+            cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+                reject(new Error('renderMedia() got cancelled'));
+            });
+        }),
+    ]);
+};
+exports.renderGif = renderGif;

package/dist/render-media.d.ts

@@ -23,6 +23,7 @@ export declare type RenderMediaOptions = {
     crf?: number | null;
     imageFormat?: 'png' | 'jpeg' | 'none';
     ffmpegExecutable?: FfmpegExecutable;
+    ffprobeExecutable?: FfmpegExecutable;
     pixelFormat?: PixelFormat;
     envVariables?: Record<string, string>;
     quality?: number;
@@ -42,4 +43,9 @@ export declare type RenderMediaOptions = {
     cancelSignal?: CancelSignal;
     browserExecutable?: BrowserExecutable;
 } & ServeUrlOrWebpackBundle;
-export declare const renderMedia: ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }: RenderMediaOptions) => Promise<void>;
+/**
+ *
+ * @description Render a video from a composition
+ * @link https://www.remotion.dev/docs/renderer/render-media
+ */
+export declare const renderMedia: ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }: RenderMediaOptions) => Promise<void>;

package/dist/render-media.js

@@ -24,7 +24,12 @@ const tmp_dir_1 = require("./tmp-dir");
 const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
 const validate_output_filename_1 = require("./validate-output-filename");
 const validate_scale_1 = require("./validate-scale");
-const renderMedia = ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }) => {
+/**
+ *
+ * @description Render a video from a composition
+ * @link https://www.remotion.dev/docs/renderer/render-media
+ */
+const renderMedia = ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }) => {
     remotion_1.Internals.validateQuality(quality);
     if (typeof crf !== 'undefined' && crf !== null) {
         remotion_1.Internals.validateSelectedCrfAndCodecCombination(crf, codec);
@@ -137,7 +142,9 @@ const renderMedia = ({ parallelism, proResProfile, crf, composition, imageFormat
                     if (cancelled) {
                         return;
                     }
+                    const id = remotion_1.Internals.perf.startPerfMeasure('piping');
                     (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.write(buffer);
+                    remotion_1.Internals.perf.stopPerfMeasure(id);
                     setFrameToStitch(frame + 1);
                 }
                 : undefined,
@@ -149,6 +156,7 @@ const renderMedia = ({ parallelism, proResProfile, crf, composition, imageFormat
             chromiumOptions,
             scale,
             ffmpegExecutable,
+            ffprobeExecutable,
             browserExecutable,
             port,
             cancelSignal: cancelRenderFrames.cancelSignal,
@@ -180,6 +188,7 @@ const renderMedia = ({ parallelism, proResProfile, crf, composition, imageFormat
                 crf,
                 assetsInfo,
                 ffmpegExecutable,
+                ffprobeExecutable,
                 onProgress: (frame) => {
                     stitchStage = 'muxing';
                     encodedFrames = frame;

package/dist/render-still.d.ts

@@ -22,12 +22,15 @@ declare type InnerStillOptions = {
     onDownload?: RenderMediaOnDownload;
     cancelSignal?: CancelSignal;
     ffmpegExecutable?: FfmpegExecutable;
+    ffprobeExecutable?: FfmpegExecutable;
 };
 declare type RenderStillOptions = InnerStillOptions & ServeUrlOrWebpackBundle & {
     port?: number | null;
 };
 /**
- * @description Render a still frame from a composition and returns an image path
+ *
+ * @description Render a still frame from a composition
+ * @link https://www.remotion.dev/docs/renderer/render-still
  */
 export declare const renderStill: (options: RenderStillOptions) => Promise<void>;
 export {};

package/dist/render-still.js

@@ -76,7 +76,7 @@ const innerRenderStill = async ({ composition, quality, imageFormat = 'png', ser
         forceDeviceScaleFactor: scale !== null && scale !== void 0 ? scale : 1,
     }));
     const page = await browserInstance.newPage();
-    page.setViewport({
+    await page.setViewport({
         width: composition.width,
         height: composition.height,
         deviceScaleFactor: scale !== null && scale !== void 0 ? scale : 1,
@@ -138,7 +138,9 @@ const innerRenderStill = async ({ composition, quality, imageFormat = 'png', ser
     await cleanup();
 };
 /**
- * @description Render a still frame from a composition and returns an image path
+ *
+ * @description Render a still frame from a composition
+ * @link https://www.remotion.dev/docs/renderer/render-still
  */
 const renderStill = (options) => {
     var _a;
@@ -146,7 +148,7 @@ const renderStill = (options) => {
     const downloadDir = (0, make_assets_download_dir_1.makeAssetsDownloadTmpDir)();
     const onDownload = (_a = options.onDownload) !== null && _a !== void 0 ? _a : (() => () => undefined);
     const happyPath = new Promise((resolve, reject) => {
-        var _a, _b;
+        var _a, _b, _c;
         const onError = (err) => reject(err);
         let close = null;
         (0, prepare_server_1.prepareServer)({
@@ -155,7 +157,8 @@ const renderStill = (options) => {
             onDownload,
             onError,
             ffmpegExecutable: (_a = options.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
-            port: (_b = options.port) !== null && _b !== void 0 ? _b : null,
+            ffprobeExecutable: (_b = options.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
+            port: (_c = options.port) !== null && _c !== void 0 ? _c : null,
         })
             .then(({ serveUrl, closeServer, offthreadPort }) => {
             close = closeServer;

package/dist/serve-handler/glob-slash.d.ts

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

package/dist/serve-handler/glob-slash.js

@@ -0,0 +1,12 @@
+"use strict";
+/* ! The MIT License (MIT) Copyright (c) 2014 Scott Corgan */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slasher = void 0;
+// This is adopted from https://github.com/scottcorgan/glob-slash/
+const path_1 = __importDefault(require("path"));
+const normalize = (value) => path_1.default.posix.normalize(path_1.default.posix.join('/', value));
+const slasher = (value) => value.charAt(0) === '!' ? `!${normalize(value.substr(1))}` : normalize(value);
+exports.slasher = slasher;

package/dist/serve-handler/index.d.ts

@@ -0,0 +1,4 @@
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const serveHandler: (request: IncomingMessage, response: ServerResponse, config: {
+    public: string;
+}) => Promise<void>;

package/dist/serve-handler/index.js

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveHandler = void 0;
+// Native
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+// Packages
+const mime_types_1 = __importDefault(require("mime-types"));
+const is_path_inside_1 = require("./is-path-inside");
+const range_parser_1 = require("./range-parser");
+const getHeaders = (absolutePath, stats) => {
+    const related = {};
+    const { base } = path_1.default.parse(absolutePath);
+    let defaultHeaders = {};
+    if (stats) {
+        defaultHeaders = {
+            'Content-Length': String(stats.size),
+            'Accept-Ranges': 'bytes',
+        };
+        defaultHeaders['Last-Modified'] = stats.mtime.toUTCString();
+        const contentType = mime_types_1.default.contentType(base);
+        if (contentType) {
+            defaultHeaders['Content-Type'] = contentType;
+        }
+    }
+    const headers = Object.assign(defaultHeaders, related);
+    for (const key in headers) {
+        if (headers[key] === null) {
+            delete headers[key];
+        }
+    }
+    return headers;
+};
+const getPossiblePaths = (relativePath, extension) => [
+    path_1.default.join(relativePath, `index${extension}`),
+    relativePath.endsWith('/')
+        ? relativePath.replace(/\/$/g, extension)
+        : relativePath + extension,
+].filter((item) => path_1.default.basename(item) !== extension);
+const findRelated = async (current, relativePath) => {
+    const possible = getPossiblePaths(relativePath, '.html');
+    let stats = null;
+    for (let index = 0; index < possible.length; index++) {
+        const related = possible[index];
+        const absolutePath = path_1.default.join(current, related);
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                throw err;
+            }
+        }
+        if (stats) {
+            return {
+                stats,
+                absolutePath,
+            };
+        }
+    }
+    return null;
+};
+const sendError = (absolutePath, response, spec) => {
+    const { message, statusCode } = spec;
+    response.statusCode = statusCode;
+    const headers = getHeaders(absolutePath, null);
+    response.writeHead(statusCode, headers);
+    response.setHeader('content-type', 'application/json');
+    response.end(JSON.stringify({ statusCode, message }));
+};
+const internalError = (absolutePath, response) => {
+    return sendError(absolutePath, response, {
+        statusCode: 500,
+        code: 'internal_server_error',
+        message: 'A server error has occurred',
+    });
+};
+const serveHandler = async (request, response, config) => {
+    const cwd = process.cwd();
+    const current = path_1.default.resolve(cwd, config.public);
+    let relativePath = null;
+    try {
+        relativePath = decodeURIComponent(url_1.default.parse(request.url).pathname);
+    }
+    catch (err) {
+        return sendError('/', response, {
+            statusCode: 400,
+            code: 'bad_request',
+            message: 'Bad Request',
+        });
+    }
+    let absolutePath = path_1.default.join(current, relativePath);
+    // Prevent path traversal vulnerabilities. We could do this
+    // by ourselves, but using the package covers all the edge cases.
+    if (!(0, is_path_inside_1.isPathInside)(absolutePath, current)) {
+        return sendError(absolutePath, response, {
+            statusCode: 400,
+            code: 'bad_request',
+            message: 'Bad Request',
+        });
+    }
+    let stats = null;
+    // It's extremely important that we're doing multiple stat calls. This one
+    // right here could technically be removed, but then the program
+    // would be slower. Because for directories, we always want to see if a related file
+    // exists and then (after that), fetch the directory itself if no
+    // related file was found. However (for files, of which most have extensions), we should
+    // always stat right away.
+    //
+    // When simulating a file system without directory indexes, calculating whether a
+    // directory exists requires loading all the file paths and then checking if
+    // one of them includes the path of the directory. As that's a very
+    // performance-expensive thing to do, we need to ensure it's not happening if not really necessary.
+    if (path_1.default.extname(relativePath) !== '') {
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+    }
+    if (!stats) {
+        try {
+            const related = await findRelated(current, relativePath);
+            if (related) {
+                ({ stats, absolutePath } = related);
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+    }
+    if (stats === null || stats === void 0 ? void 0 : stats.isDirectory()) {
+        const directory = null;
+        const singleFile = null;
+        if (directory) {
+            const contentType = 'text/html; charset=utf-8';
+            response.statusCode = 200;
+            response.setHeader('Content-Type', contentType);
+            response.end('Is a directory');
+            return;
+        }
+        if (!singleFile) {
+            // The directory listing is disabled, so we want to
+            // render a 404 error.
+            stats = null;
+        }
+    }
+    const isSymLink = stats === null || stats === void 0 ? void 0 : stats.isSymbolicLink();
+    // There are two scenarios in which we want to reply with
+    // a 404 error: Either the path does not exist, or it is a
+    // symlink while the `symlinks` option is disabled (which it is by default).
+    if (!stats || isSymLink) {
+        // allow for custom 404 handling
+        return sendError(absolutePath, response, {
+            statusCode: 404,
+            code: 'not_found',
+            message: 'The requested path could not be found',
+        });
+    }
+    let streamOpts = null;
+    if (request.headers.range && stats.size) {
+        const range = (0, range_parser_1.rangeParser)(stats.size, request.headers.range);
+        if (typeof range === 'object' && range.type === 'bytes') {
+            const { start, end } = range.ranges[0];
+            streamOpts = {
+                start,
+                end,
+            };
+            response.statusCode = 206;
+        }
+        else {
+            response.statusCode = 416;
+            response.setHeader('Content-Range', `bytes */${stats.size}`);
+        }
+    }
+    let stream = null;
+    try {
+        stream = (0, fs_1.createReadStream)(absolutePath, streamOpts !== null && streamOpts !== void 0 ? streamOpts : {});
+    }
+    catch (err) {
+        return internalError(absolutePath, response);
+    }
+    const headers = getHeaders(absolutePath, stats);
+    if (streamOpts !== null) {
+        headers['Content-Range'] = `bytes ${streamOpts.start}-${streamOpts.end}/${stats.size}`;
+        headers['Content-Length'] = String(streamOpts.end - streamOpts.start + 1);
+    }
+    response.writeHead(response.statusCode || 200, headers);
+    stream.pipe(response);
+};
+exports.serveHandler = serveHandler;

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

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

package/dist/serve-handler/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/serve-handler/range-parser.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+export declare const rangeParser: (size: number, str: string) => -1 | {
+    type: string;
+    ranges: {
+        start: number;
+        end: number;
+    }[];
+} | -2;