@remotion/cli 4.0.0-fastlambda.8 → 4.0.0-forcepublish.7

package/dist/parse-command-line.d.ts

@@ -1,8 +1,9 @@
+import type { BrowserExecutable, Codec, FfmpegExecutable, ImageFormat, OpenGlRenderer, PixelFormat, ProResProfile } from '@remotion/renderer';
 import minimist from 'minimist';
-import { BrowserExecutable, Codec, FfmpegExecutable, ImageFormat, OpenGlRenderer, PixelFormat, ProResProfile } from 'remotion';
 export declare type CommandLineOptions = {
     ['browser-executable']: BrowserExecutable;
     ['ffmpeg-executable']: FfmpegExecutable;
+    ['ffprobe-executable']: FfmpegExecutable;
     ['pixel-format']: PixelFormat;
     ['image-format']: ImageFormat;
     ['prores-profile']: ProResProfile;
@@ -10,6 +11,8 @@ export declare type CommandLineOptions = {
     ['env-file']: string;
     ['ignore-certificate-errors']: string;
     ['disable-web-security']: string;
+    ['every-nth-frame']: number;
+    ['number-of-gif-loops']: number;
     codec: Codec;
     concurrency: number;
     timeout: number;
@@ -30,6 +33,8 @@ export declare type CommandLineOptions = {
     port: number;
     frame: string | number;
     ['disable-headless']: boolean;
+    muted: boolean;
+    ['enforce-audio-track']: boolean;
     gl: OpenGlRenderer;
 };
 export declare const BooleanFlags: string[];

package/dist/parse-command-line.js

@@ -4,9 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.quietFlagProvided = exports.parseCommandLine = exports.parsedCli = exports.BooleanFlags = void 0;
+const renderer_1 = require("@remotion/renderer");
 const minimist_1 = __importDefault(require("minimist"));
 const path_1 = require("path");
-const remotion_1 = require("remotion");
+const config_1 = require("./config");
 const log_1 = require("./log");
 exports.BooleanFlags = [
     'force',
@@ -15,6 +16,8 @@ exports.BooleanFlags = [
     'help',
     'quiet',
     'q',
+    'muted',
+    'enforce-audio-track',
     // Lambda flags
     'force',
     'disable-chunk-optimization',
@@ -31,87 +34,105 @@ exports.parsedCli = (0, minimist_1.default)(process.argv.slice(2), {
 });
 const parseCommandLine = (type) => {
     if (exports.parsedCli['pixel-format']) {
-        remotion_1.Config.Output.setPixelFormat(exports.parsedCli['pixel-format']);
+        config_1.Config.Output.setPixelFormat(exports.parsedCli['pixel-format']);
     }
     if (exports.parsedCli['image-format']) {
-        remotion_1.Config.Rendering.setImageFormat(exports.parsedCli['image-format']);
+        config_1.Config.Rendering.setImageFormat(exports.parsedCli['image-format']);
     }
     if (exports.parsedCli['browser-executable']) {
-        remotion_1.Config.Puppeteer.setBrowserExecutable(exports.parsedCli['browser-executable']);
+        config_1.Config.Puppeteer.setBrowserExecutable(exports.parsedCli['browser-executable']);
     }
     if (exports.parsedCli['ffmpeg-executable']) {
-        remotion_1.Config.Rendering.setFfmpegExecutable((0, path_1.resolve)(exports.parsedCli['ffmpeg-executable']));
+        config_1.Config.Rendering.setFfmpegExecutable((0, path_1.resolve)(exports.parsedCli['ffmpeg-executable']));
+    }
+    if (exports.parsedCli['number-of-gif-loops']) {
+        config_1.Config.Rendering.setNumberOfGifLoops(exports.parsedCli['number-of-gif-loops']);
+    }
+    if (exports.parsedCli['ffprobe-executable']) {
+        config_1.Config.Rendering.setFfprobeExecutable((0, path_1.resolve)(exports.parsedCli['ffprobe-executable']));
     }
     if (typeof exports.parsedCli['bundle-cache'] !== 'undefined') {
-        remotion_1.Config.Bundling.setCachingEnabled(exports.parsedCli['bundle-cache'] !== 'false');
+        config_1.Config.Bundling.setCachingEnabled(exports.parsedCli['bundle-cache'] !== 'false');
     }
     if (exports.parsedCli['disable-web-security']) {
-        remotion_1.Config.Puppeteer.setChromiumDisableWebSecurity(true);
+        config_1.Config.Puppeteer.setChromiumDisableWebSecurity(true);
     }
     if (exports.parsedCli['ignore-certificate-errors']) {
-        remotion_1.Config.Puppeteer.setChromiumIgnoreCertificateErrors(true);
+        config_1.Config.Puppeteer.setChromiumIgnoreCertificateErrors(true);
     }
     if (exports.parsedCli['disable-headless']) {
-        remotion_1.Config.Puppeteer.setChromiumHeadlessMode(false);
-    }
-    if (exports.parsedCli.gl) {
-        remotion_1.Config.Puppeteer.setChromiumOpenGlRenderer(exports.parsedCli.gl);
+        config_1.Config.Puppeteer.setChromiumHeadlessMode(false);
     }
     if (exports.parsedCli.log) {
-        if (!remotion_1.Internals.Logging.isValidLogLevel(exports.parsedCli.log)) {
+        if (!renderer_1.RenderInternals.isValidLogLevel(exports.parsedCli.log)) {
             log_1.Log.error('Invalid `--log` value passed.');
-            log_1.Log.error(`Accepted values: ${remotion_1.Internals.Logging.logLevels
+            log_1.Log.error(`Accepted values: ${renderer_1.RenderInternals.logLevels
                 .map((l) => `'${l}'`)
                 .join(', ')}.`);
             process.exit(1);
         }
-        remotion_1.Internals.Logging.setLogLevel(exports.parsedCli.log);
+        config_1.ConfigInternals.Logging.setLogLevel(exports.parsedCli.log);
     }
     if (exports.parsedCli.concurrency) {
-        remotion_1.Config.Rendering.setConcurrency(exports.parsedCli.concurrency);
+        config_1.Config.Rendering.setConcurrency(exports.parsedCli.concurrency);
     }
     if (exports.parsedCli.timeout) {
-        remotion_1.Config.Puppeteer.setTimeoutInMilliseconds(exports.parsedCli.timeout);
+        config_1.Config.Puppeteer.setTimeoutInMilliseconds(exports.parsedCli.timeout);
     }
     if (exports.parsedCli.frames) {
         if (type === 'still') {
             log_1.Log.error('--frames flag was passed to the `still` command. This flag only works with the `render` command. Did you mean `--frame`? See reference: https://www.remotion.dev/docs/cli/');
             process.exit(1);
         }
-        remotion_1.Internals.setFrameRangeFromCli(exports.parsedCli.frames);
+        config_1.ConfigInternals.setFrameRangeFromCli(exports.parsedCli.frames);
     }
     if (exports.parsedCli.frame) {
         if (type === 'sequence') {
             log_1.Log.error('--frame flag was passed to the `render` command. This flag only works with the `still` command. Did you mean `--frames`? See reference: https://www.remotion.dev/docs/cli/');
             process.exit(1);
         }
-        remotion_1.Internals.setStillFrame(Number(exports.parsedCli.frame));
+        config_1.ConfigInternals.setStillFrame(Number(exports.parsedCli.frame));
     }
     if (exports.parsedCli.png) {
         log_1.Log.warn('The --png flag has been deprecrated. Use --sequence --image-format=png from now on.');
-        remotion_1.Config.Output.setImageSequence(true);
-        remotion_1.Config.Rendering.setImageFormat('png');
+        config_1.Config.Output.setImageSequence(true);
+        config_1.Config.Rendering.setImageFormat('png');
     }
     if (exports.parsedCli.sequence) {
-        remotion_1.Config.Output.setImageSequence(true);
+        config_1.Config.Output.setImageSequence(true);
     }
     if (typeof exports.parsedCli.crf !== 'undefined') {
-        remotion_1.Config.Output.setCrf(exports.parsedCli.crf);
+        config_1.Config.Output.setCrf(exports.parsedCli.crf);
     }
     if (exports.parsedCli.codec) {
-        remotion_1.Config.Output.setCodec(exports.parsedCli.codec);
+        config_1.Config.Output.setCodec(exports.parsedCli.codec);
+    }
+    if (exports.parsedCli['every-nth-frame']) {
+        config_1.Config.Rendering.setEveryNthFrame(exports.parsedCli['every-nth-frame']);
+    }
+    if (exports.parsedCli.gl) {
+        config_1.Config.Puppeteer.setChromiumOpenGlRenderer(exports.parsedCli.gl);
     }
     if (exports.parsedCli['prores-profile']) {
-        remotion_1.Config.Output.setProResProfile(String(exports.parsedCli['prores-profile']));
+        config_1.Config.Output.setProResProfile(String(exports.parsedCli['prores-profile']));
     }
     if (exports.parsedCli.overwrite) {
-        remotion_1.Config.Output.setOverwriteOutput(exports.parsedCli.overwrite);
+        config_1.Config.Output.setOverwriteOutput(exports.parsedCli.overwrite);
     }
     if (typeof exports.parsedCli.quality !== 'undefined') {
-        remotion_1.Config.Rendering.setQuality(exports.parsedCli.quality);
+        config_1.Config.Rendering.setQuality(exports.parsedCli.quality);
     }
     if (typeof exports.parsedCli.scale !== 'undefined') {
-        remotion_1.Config.Rendering.setScale(exports.parsedCli.scale);
+        config_1.Config.Rendering.setScale(exports.parsedCli.scale);
+    }
+    if (typeof exports.parsedCli.port !== 'undefined') {
+        config_1.Config.Bundling.setPort(exports.parsedCli.port);
+    }
+    if (typeof exports.parsedCli.muted !== 'undefined') {
+        config_1.Config.Rendering.setMuted(exports.parsedCli.muted);
+    }
+    if (typeof exports.parsedCli['enforce-audio-track'] !== 'undefined') {
+        config_1.Config.Rendering.setEnforceAudioTrack(exports.parsedCli['enforce-audio-track']);
     }
 };
 exports.parseCommandLine = parseCommandLine;

package/dist/prepare-entry-point.d.ts

@@ -0,0 +1,12 @@
+import type { RenderStep } from './step';
+export declare const prepareEntryPoint: ({ file, otherSteps, publicPath, outDir, remotionRoot, }: {
+    file: string;
+    otherSteps: RenderStep[];
+    outDir: string | null;
+    publicPath: string | null;
+    remotionRoot: string;
+}) => Promise<{
+    urlOrBundle: string;
+    steps: RenderStep[];
+    shouldDelete: boolean;
+}>;

package/dist/prepare-entry-point.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareEntryPoint = void 0;
+const renderer_1 = require("@remotion/renderer");
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const process_1 = require("process");
+const log_1 = require("./log");
+const setup_cache_1 = require("./setup-cache");
+const prepareEntryPoint = async ({ file, otherSteps, publicPath, outDir, remotionRoot, }) => {
+    if (renderer_1.RenderInternals.isServeUrl(file)) {
+        return { urlOrBundle: file, steps: otherSteps, shouldDelete: false };
+    }
+    const joined = path_1.default.resolve(process.cwd(), file);
+    try {
+        const stats = await (0, promises_1.stat)(joined);
+        if (stats.isDirectory()) {
+            return { urlOrBundle: joined, steps: otherSteps, shouldDelete: false };
+        }
+    }
+    catch (err) {
+        log_1.Log.error(`No file or directory exists at ${joined}.`);
+        (0, process_1.exit)(1);
+    }
+    const urlOrBundle = await (0, setup_cache_1.bundleOnCliOrTakeServeUrl)({
+        fullPath: joined,
+        steps: ['bundling', ...otherSteps],
+        outDir,
+        publicPath,
+        remotionRoot,
+    });
+    return { urlOrBundle, steps: ['bundling', ...otherSteps], shouldDelete: true };
+};
+exports.prepareEntryPoint = prepareEntryPoint;

package/dist/preview-server/dev-middleware/compatible-api.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ReadStream } from 'fs';
+import type { IncomingMessage, ServerResponse } from 'http';
+export declare function setHeaderForResponse(res: ServerResponse, name: string, value: string | number): void;
+export declare function send(req: IncomingMessage, res: ServerResponse, bufferOtStream: ReadStream | string | Buffer, byteLength: number): void;

package/dist/preview-server/dev-middleware/compatible-api.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.send = exports.setHeaderForResponse = void 0;
+function setHeaderForResponse(res, name, value) {
+    res.setHeader(name, typeof value === 'number' ? String(value) : value);
+}
+exports.setHeaderForResponse = setHeaderForResponse;
+function send(req, res, bufferOtStream, byteLength) {
+    if (typeof bufferOtStream === 'string' || Buffer.isBuffer(bufferOtStream)) {
+        res.end(bufferOtStream);
+        return;
+    }
+    setHeaderForResponse(res, 'Content-Length', byteLength);
+    if (req.method === 'HEAD') {
+        res.end();
+        return;
+    }
+    bufferOtStream.pipe(res);
+}
+exports.send = send;

package/dist/preview-server/dev-middleware/get-paths.d.ts

@@ -0,0 +1,7 @@
+import type { DevMiddlewareContext } from './types';
+declare type PublicPath = {
+    outputPath: string;
+    publicPath: string;
+};
+export declare function getPaths(context: DevMiddlewareContext): PublicPath[];
+export {};

package/dist/preview-server/dev-middleware/get-paths.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPaths = void 0;
+function getPaths(context) {
+    const { stats } = context;
+    const publicPaths = [];
+    if (!stats) {
+        return publicPaths;
+    }
+    const { compilation } = stats;
+    // The `output.path` is always present and always absolute
+    const outputPath = compilation.getPath(compilation.outputOptions.path || '');
+    const publicPath = compilation.outputOptions.publicPath
+        ? compilation.getPath(compilation.outputOptions.publicPath)
+        : '';
+    publicPaths.push({ outputPath, publicPath });
+    return publicPaths;
+}
+exports.getPaths = getPaths;

package/dist/preview-server/dev-middleware/index.d.ts

@@ -0,0 +1,3 @@
+import type { webpack } from '@remotion/bundler';
+import type { MiddleWare } from './middleware';
+export declare const wdm: (compiler: webpack.Compiler) => MiddleWare;

package/dist/preview-server/dev-middleware/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wdm = void 0;
+const middleware_1 = require("./middleware");
+const setup_hooks_1 = require("./setup-hooks");
+const setup_output_filesystem_1 = require("./setup-output-filesystem");
+const wdm = (compiler) => {
+    const context = {
+        state: false,
+        stats: undefined,
+        callbacks: [],
+        compiler,
+        logger: compiler.getInfrastructureLogger('remotion'),
+        outputFileSystem: undefined,
+    };
+    (0, setup_hooks_1.setupHooks)(context);
+    (0, setup_output_filesystem_1.setupOutputFileSystem)(context);
+    const errorHandler = (error) => {
+        if (error) {
+            context.logger.error(error);
+        }
+    };
+    const watchOptions = context.compiler.options.watchOptions || {};
+    context.compiler.watch(watchOptions, errorHandler);
+    return (0, middleware_1.middleware)(context);
+};
+exports.wdm = wdm;

package/dist/preview-server/dev-middleware/is-color-supported.d.ts

@@ -0,0 +1 @@
+export declare const isColorSupported: boolean;

package/dist/preview-server/dev-middleware/is-color-supported.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isColorSupported = void 0;
+const tty = __importStar(require("tty"));
+const argv = process.argv || [];
+const env = process.env || {};
+const isDisabled = 'NO_COLOR' in env || argv.includes('--no-color');
+const isForced = 'FORCE_COLOR' in env || argv.includes('--color');
+const isWindows = process.platform === 'win32';
+const isCompatibleTerminal = ((_a = tty === null || tty === void 0 ? void 0 : tty.isatty) === null || _a === void 0 ? void 0 : _a.call(tty, 1)) && env.TERM && env.TERM !== 'dumb';
+const isCI = 'CI' in env &&
+    ('GITHUB_ACTIONS' in env || 'GITLAB_CI' in env || 'CIRCLECI' in env);
+exports.isColorSupported = !isDisabled && (isForced || isWindows || isCompatibleTerminal || isCI);

package/dist/preview-server/dev-middleware/middleware.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { DevMiddlewareContext } from './types';
+export declare function getFilenameFromUrl(context: DevMiddlewareContext, url: string | undefined): string | undefined;
+export declare function getValueContentRangeHeader(type: string, size: number, range?: {
+    start: number;
+    end: number;
+}): string;
+export declare type MiddleWare = (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+export declare function middleware(context: DevMiddlewareContext): (req: IncomingMessage, res: ServerResponse, next: () => void) => void;

package/dist/preview-server/dev-middleware/middleware.js

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.middleware = exports.getValueContentRangeHeader = exports.getFilenameFromUrl = void 0;
+const renderer_1 = require("@remotion/renderer");
+const path_1 = __importDefault(require("path"));
+const compatible_api_1 = require("./compatible-api");
+const range_parser_1 = require("./range-parser");
+const ready_1 = require("./ready");
+// eslint-disable-next-line no-restricted-imports
+const querystring_1 = __importDefault(require("querystring"));
+const url_1 = require("url");
+const get_paths_1 = require("./get-paths");
+const cacheStore = new WeakMap();
+const mem = (fn, { cache = new Map() } = {}) => {
+    const memoized = (...arguments_) => {
+        const [key] = arguments_;
+        const cacheItem = cache.get(key);
+        if (cacheItem) {
+            return cacheItem.data;
+        }
+        const result = fn.apply(this, arguments_);
+        cache.set(key, {
+            data: result,
+        });
+        return result;
+    };
+    cacheStore.set(memoized, cache);
+    return memoized;
+};
+const memoizedParse = mem(url_1.parse);
+function getFilenameFromUrl(context, url) {
+    var _a, _b;
+    const paths = (0, get_paths_1.getPaths)(context);
+    let foundFilename;
+    let urlObject;
+    try {
+        // The `url` property of the `request` is contains only  `pathname`, `search` and `hash`
+        urlObject = memoizedParse(url, false, true);
+    }
+    catch (_ignoreError) {
+        return;
+    }
+    for (const { publicPath, outputPath } of paths) {
+        let filename;
+        let publicPathObject;
+        try {
+            publicPathObject = memoizedParse(publicPath !== 'auto' && publicPath ? publicPath : '/', false, true);
+        }
+        catch (_ignoreError) {
+            continue;
+        }
+        if ((_a = urlObject.pathname) === null || _a === void 0 ? void 0 : _a.startsWith(publicPathObject.pathname)) {
+            filename = outputPath;
+            // Strip the `pathname` property from the `publicPath` option from the start of requested url
+            // `/complex/foo.js` => `foo.js`
+            const pathname = urlObject.pathname.substr(publicPathObject.pathname.length);
+            if (pathname) {
+                filename = path_1.default.join(outputPath, querystring_1.default.unescape(pathname));
+            }
+            if (!context.outputFileSystem) {
+                continue;
+            }
+            try {
+                let fsStats = (_b = context.outputFileSystem) === null || _b === void 0 ? void 0 : _b.statSync(filename);
+                if (fsStats.isFile()) {
+                    foundFilename = filename;
+                    break;
+                }
+                else if (fsStats.isDirectory()) {
+                    const indexValue = 'index.html';
+                    filename = path_1.default.join(filename, indexValue);
+                    // eslint-disable-next-line max-depth
+                    try {
+                        fsStats = context.outputFileSystem.statSync(filename);
+                    }
+                    catch (__ignoreError) {
+                        continue;
+                    }
+                    // eslint-disable-next-line max-depth
+                    if (fsStats.isFile()) {
+                        foundFilename = filename;
+                        break;
+                    }
+                }
+            }
+            catch (_ignoreError) {
+                continue;
+            }
+        }
+    }
+    return foundFilename;
+}
+exports.getFilenameFromUrl = getFilenameFromUrl;
+function getValueContentRangeHeader(type, size, range) {
+    return `${type} ${range ? `${range.start}-${range.end}` : '*'}/${size}`;
+}
+exports.getValueContentRangeHeader = getValueContentRangeHeader;
+function createHtmlDocument(title, body) {
+    return (`${'<!DOCTYPE html>\n' +
+        '<html lang="en">\n' +
+        '<head>\n' +
+        '<meta charset="utf-8">\n' +
+        '<title>'}${title}</title>\n` +
+        `</head>\n` +
+        `<body>\n` +
+        `<pre>${body}</pre>\n` +
+        `</body>\n` +
+        `</html>\n`);
+}
+const BYTES_RANGE_REGEXP = /^ *bytes/i;
+function middleware(context) {
+    return function (req, res, next) {
+        const acceptedMethods = ['GET', 'HEAD'];
+        if (req.method && !acceptedMethods.includes(req.method)) {
+            goNext();
+            return;
+        }
+        (0, ready_1.ready)(context, processRequest);
+        function goNext() {
+            return next();
+        }
+        async function processRequest() {
+            var _a;
+            const filename = getFilenameFromUrl(context, req.url);
+            if (!filename) {
+                goNext();
+                return;
+            }
+            /**
+             * @type {{key: string, value: string | number}[]}
+             */
+            if (!res.getHeader('Content-Type')) {
+                // content-type name(like application/javascript; charset=utf-8) or false
+                const contentType = renderer_1.RenderInternals.mimeContentType(path_1.default.extname(filename));
+                // Only set content-type header if media type is known
+                // https://tools.ietf.org/html/rfc7231#section-3.1.1.5
+                if (contentType) {
+                    (0, compatible_api_1.setHeaderForResponse)(res, 'Content-Type', contentType);
+                }
+            }
+            if (!res.getHeader('Accept-Ranges')) {
+                res.setHeader('Accept-Ranges', 'bytes');
+                (0, compatible_api_1.setHeaderForResponse)(res, 'Accept-Ranges', 'bytes');
+            }
+            const rangeHeader = req.headers.range;
+            let start;
+            let end;
+            if (rangeHeader &&
+                BYTES_RANGE_REGEXP.test(rangeHeader) &&
+                context.outputFileSystem) {
+                const size = await new Promise((resolve) => {
+                    var _a;
+                    (_a = context.outputFileSystem) === null || _a === void 0 ? void 0 : _a.lstat(filename, (error, stats) => {
+                        var _a;
+                        if (error) {
+                            context.logger.error(error);
+                            return;
+                        }
+                        resolve((_a = stats === null || stats === void 0 ? void 0 : stats.size) !== null && _a !== void 0 ? _a : 0);
+                    });
+                });
+                const parsedRanges = (0, range_parser_1.parseRange)(size, rangeHeader);
+                if (parsedRanges === -1) {
+                    const message = "Unsatisfiable range for 'Range' header.";
+                    context.logger.error(message);
+                    const existingHeaders = res.getHeaderNames();
+                    for (const header of existingHeaders) {
+                        res.removeHeader(header);
+                    }
+                    res.statusCode = 416;
+                    (0, compatible_api_1.setHeaderForResponse)(res, 'Content-Range', getValueContentRangeHeader('bytes', size));
+                    (0, compatible_api_1.setHeaderForResponse)(res, 'Content-Type', 'text/html; charset=utf-8');
+                    const document = createHtmlDocument(416, `Error: ${message}`);
+                    const _byteLength = Buffer.byteLength(document);
+                    (0, compatible_api_1.setHeaderForResponse)(res, 'Content-Length', Buffer.byteLength(document));
+                    (0, compatible_api_1.send)(req, res, document, _byteLength);
+                    return;
+                }
+                if (parsedRanges === -2) {
+                    context.logger.error("A malformed 'Range' header was provided. A regular response will be sent for this request.");
+                }
+                else if (parsedRanges.length > 1) {
+                    context.logger.error("A 'Range' header with multiple ranges was provided. Multiple ranges are not supported, so a regular response will be sent for this request.");
+                }
+                if (parsedRanges !== -2 && parsedRanges.length === 1) {
+                    // Content-Range
+                    res.statusCode = 206;
+                    (0, compatible_api_1.setHeaderForResponse)(res, 'Content-Range', getValueContentRangeHeader('bytes', size, parsedRanges[0]));
+                    [{ start, end }] = parsedRanges;
+                }
+            }
+            const isFsSupportsStream = typeof ((_a = context.outputFileSystem) === null || _a === void 0 ? void 0 : _a.createReadStream) === 'function';
+            let bufferOtStream;
+            let byteLength = 0;
+            try {
+                if (typeof start !== 'undefined' &&
+                    typeof end !== 'undefined' &&
+                    isFsSupportsStream &&
+                    context.outputFileSystem) {
+                    bufferOtStream = context.outputFileSystem.createReadStream(filename, {
+                        start,
+                        end,
+                    });
+                    byteLength = end - start + 1;
+                }
+                else if (context.outputFileSystem) {
+                    bufferOtStream = context.outputFileSystem.readFileSync(filename);
+                    byteLength = bufferOtStream.byteLength;
+                }
+            }
+            catch (_ignoreError) {
+                goNext();
+                return;
+            }
+            if (bufferOtStream) {
+                (0, compatible_api_1.send)(req, res, bufferOtStream, byteLength);
+            }
+        }
+    };
+}
+exports.middleware = middleware;

package/dist/preview-server/dev-middleware/range-parser.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+declare type Range = {
+    start: number;
+    end: number;
+};
+declare type Ranges = Range[] & {
+    type?: string;
+};
+export declare function parseRange(size: number, str: string | string[]): -1 | Ranges | -2;
+export {};