@remotion/cli 4.0.0-fastlambda.8 → 4.0.0-lambda.3

package/dist/preview-server/error-overlay/react-overlay/effects/map-error-to-react-stack.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocationFromBuildError = void 0;
+const remotion_1 = require("remotion");
+const getLocationFromBuildError = (err) => {
+    var _a;
+    if (!err.stack) {
+        return null;
+    }
+    if (!err.stack.startsWith('Error: Module build failed') &&
+        !err.stack.startsWith('Error: Cannot find module')) {
+        return null;
+    }
+    const split = err.stack.split('\n');
+    return ((_a = split
+        .map((s) => {
+        if (s.startsWith('Error')) {
+            return null;
+        }
+        const matchWebpackOrEsbuild = s.match(/(.*):([0-9]+):([0-9]+): (.*)/);
+        if (matchWebpackOrEsbuild) {
+            return {
+                fileName: matchWebpackOrEsbuild[1],
+                lineNumber: Number(matchWebpackOrEsbuild[2]),
+                columnNumber: Number(matchWebpackOrEsbuild[3]),
+                message: matchWebpackOrEsbuild[4],
+            };
+        }
+        const matchMissingModule = s.match(/\s+at(.*)\s\((.*)\)/);
+        if (!matchMissingModule) {
+            return null;
+        }
+        if (s.includes('webpackMissingModule')) {
+            return null;
+        }
+        const [, filename] = matchMissingModule;
+        return {
+            columnNumber: 0,
+            lineNumber: 1,
+            message: split[0],
+            fileName: filename.trim(),
+        };
+    })
+        .filter(remotion_1.Internals.truthy)[0]) !== null && _a !== void 0 ? _a : null);
+};
+exports.getLocationFromBuildError = getLocationFromBuildError;

package/dist/preview-server/error-overlay/react-overlay/effects/proxy-console.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare type ReactFrame = {
+    fileName: string | null;
+    lineNumber: number | null;
+    name: string | null;
+};
+declare const registerReactStack: () => void;
+declare const unregisterReactStack: () => void;
+declare type ErrorData = {
+    type: 'webpack-error';
+    message: string;
+    frames: ReactFrame[];
+} | {
+    type: 'build-error';
+    error: Error;
+};
+declare type ConsoleProxyCallback = (data: ErrorData) => void;
+declare const permanentRegister: (type: 'error', callback: ConsoleProxyCallback) => void;
+export { permanentRegister, registerReactStack, unregisterReactStack };

package/dist/preview-server/error-overlay/react-overlay/effects/proxy-console.js

@@ -0,0 +1,64 @@
+"use strict";
+/* eslint-disable no-console */
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterReactStack = exports.registerReactStack = exports.permanentRegister = void 0;
+const reactFrameStack = [];
+// This is a stripped down barebones version of this proposal:
+// https://gist.github.com/sebmarkbage/bdefa100f19345229d526d0fdd22830f
+// We're implementing just enough to get the invalid element type warnings
+// to display the component stack in React 15.6+:
+// https://github.com/facebook/react/pull/9679
+const registerReactStack = () => {
+    if (typeof console !== 'undefined') {
+        // @ts-expect-error
+        console.reactStack = (frames) => reactFrameStack.push(frames);
+        // @ts-expect-error
+        console.reactStackEnd = () => reactFrameStack.pop();
+    }
+};
+exports.registerReactStack = registerReactStack;
+const unregisterReactStack = () => {
+    if (typeof console !== 'undefined') {
+        // @ts-expect-error
+        console.reactStack = undefined;
+        // @ts-expect-error
+        console.reactStackEnd = undefined;
+    }
+};
+exports.unregisterReactStack = unregisterReactStack;
+const permanentRegister = function (type, callback) {
+    if (typeof console !== 'undefined') {
+        const orig = console[type];
+        if (typeof orig === 'function') {
+            console[type] = function (...args) {
+                try {
+                    const message = args[0];
+                    if (typeof message === 'string' && reactFrameStack.length > 0) {
+                        callback({
+                            type: 'webpack-error',
+                            message,
+                            frames: reactFrameStack[reactFrameStack.length - 1],
+                        });
+                    }
+                    if (message instanceof Error) {
+                        callback({
+                            type: 'build-error',
+                            error: message,
+                        });
+                    }
+                }
+                catch (err) {
+                    // Warnings must never crash. Rethrow with a clean stack.
+                    setTimeout(() => {
+                        throw err;
+                    });
+                }
+                return orig.apply(this, args);
+            };
+        }
+    }
+};
+exports.permanentRegister = permanentRegister;

package/dist/preview-server/error-overlay/react-overlay/effects/resolve-file-source.d.ts

@@ -0,0 +1,3 @@
+import { SymbolicatedStackFrame } from '../utils/stack-frame';
+import { ErrorLocation } from './map-error-to-react-stack';
+export declare const resolveFileSource: (location: ErrorLocation, contextLines: number) => Promise<SymbolicatedStackFrame>;

package/dist/preview-server/error-overlay/react-overlay/effects/resolve-file-source.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFileSource = void 0;
+const resolveFileSource = async (location, contextLines) => {
+    const res = await fetch(`/api/file-source?f=${encodeURIComponent(location.fileName)}`);
+    const text = await res.text();
+    const lines = text
+        .split('\n')
+        .map((l, i) => {
+        const oneIndexedLineNumber = i + 1;
+        return [oneIndexedLineNumber, l];
+    })
+        .filter(([oneIndexedLineNumber]) => {
+        return (Math.abs(oneIndexedLineNumber - location.lineNumber) <= contextLines);
+    });
+    const scriptCode = lines.map(([num, line]) => {
+        return {
+            content: line,
+            highlight: location.lineNumber === num,
+            lineNumber: num,
+        };
+    });
+    return {
+        originalColumnNumber: location.columnNumber,
+        originalFunctionName: null,
+        originalFileName: location.fileName,
+        originalLineNumber: location.lineNumber,
+        originalScriptCode: scriptCode,
+    };
+};
+exports.resolveFileSource = resolveFileSource;

package/dist/preview-server/error-overlay/react-overlay/effects/stack-trace-limit.d.ts

@@ -0,0 +1,3 @@
+declare function registerStackTraceLimit(limit?: number): void;
+declare function unregisterStackTraceLimit(): void;
+export { registerStackTraceLimit as register, unregisterStackTraceLimit as unregister, };

package/dist/preview-server/error-overlay/react-overlay/effects/stack-trace-limit.js

@@ -0,0 +1,43 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregister = exports.register = void 0;
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let stackTraceRegistered = false;
+// Default: https://docs.microsoft.com/en-us/scripting/javascript/reference/stacktracelimit-property-error-javascript
+let restoreStackTraceValue = 10;
+const MAX_STACK_LENGTH = 50;
+function registerStackTraceLimit(limit = MAX_STACK_LENGTH) {
+    if (stackTraceRegistered) {
+        return;
+    }
+    try {
+        restoreStackTraceValue = Error.stackTraceLimit;
+        Error.stackTraceLimit = limit;
+        stackTraceRegistered = true;
+    }
+    catch (e) {
+        // Not all browsers support this so we don't care if it errors
+    }
+}
+exports.register = registerStackTraceLimit;
+function unregisterStackTraceLimit() {
+    if (!stackTraceRegistered) {
+        return;
+    }
+    try {
+        Error.stackTraceLimit = restoreStackTraceValue;
+        stackTraceRegistered = false;
+    }
+    catch (e) {
+        // Not all browsers support this so we don't care if it errors
+    }
+}
+exports.unregister = unregisterStackTraceLimit;

package/dist/preview-server/error-overlay/react-overlay/effects/unhandled-error.d.ts

@@ -0,0 +1,4 @@
+declare type ErrorCallback = (error: Error) => void;
+declare function registerUnhandledError(target: EventTarget, callback: ErrorCallback): void;
+declare function unregisterUnhandledError(target: EventTarget): void;
+export { registerUnhandledError as register, unregisterUnhandledError as unregister, };

package/dist/preview-server/error-overlay/react-overlay/effects/unhandled-error.js

@@ -0,0 +1,45 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregister = exports.register = void 0;
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let boundErrorHandler = null;
+function errorHandler(callback, e) {
+    // @ts-expect-error
+    if (!e.error) {
+        return;
+    }
+    // @ts-expect-error
+    const { error } = e;
+    if (error instanceof Error) {
+        callback(error);
+    }
+    else {
+        // A non-error was thrown, we don't have a trace. :(
+        // Look in your browser's devtools for more information
+        callback(new Error(error));
+    }
+}
+function registerUnhandledError(target, callback) {
+    if (boundErrorHandler !== null) {
+        return;
+    }
+    boundErrorHandler = errorHandler.bind(undefined, callback);
+    target.addEventListener('error', boundErrorHandler);
+}
+exports.register = registerUnhandledError;
+function unregisterUnhandledError(target) {
+    if (boundErrorHandler === null) {
+        return;
+    }
+    target.removeEventListener('error', boundErrorHandler);
+    boundErrorHandler = null;
+}
+exports.unregister = unregisterUnhandledError;

package/dist/preview-server/error-overlay/react-overlay/effects/unhandled-rejection.d.ts

@@ -0,0 +1,4 @@
+declare type ErrorCallback = (error: Error) => void;
+declare function registerUnhandledRejection(target: EventTarget, callback: ErrorCallback): void;
+declare function unregisterUnhandledRejection(target: EventTarget): void;
+export { registerUnhandledRejection as register, unregisterUnhandledRejection as unregister, };

package/dist/preview-server/error-overlay/react-overlay/effects/unhandled-rejection.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregister = exports.register = void 0;
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let boundRejectionHandler = null;
+function rejectionHandler(callback, e) {
+    if (!(e === null || e === void 0 ? void 0 : e.reason)) {
+        return callback(new Error('Unknown'));
+    }
+    const { reason } = e;
+    if (reason instanceof Error) {
+        return callback(reason);
+    }
+    // A non-error was rejected, we don't have a trace :(
+    // Look in your browser's devtools for more information
+    return callback(new Error(reason));
+}
+function registerUnhandledRejection(target, callback) {
+    if (boundRejectionHandler !== null) {
+        return;
+    }
+    boundRejectionHandler = rejectionHandler.bind(undefined, callback);
+    target.addEventListener('unhandledrejection', boundRejectionHandler);
+}
+exports.register = registerUnhandledRejection;
+function unregisterUnhandledRejection(target) {
+    if (boundRejectionHandler === null) {
+        return;
+    }
+    target.removeEventListener('unhandledrejection', boundRejectionHandler);
+    boundRejectionHandler = null;
+}
+exports.unregister = unregisterUnhandledRejection;

package/dist/preview-server/error-overlay/react-overlay/index.d.ts

@@ -0,0 +1,2 @@
+export declare const didUnmountReactApp: () => boolean;
+export declare function startReportingRuntimeErrors(onError: () => void): void;

package/dist/preview-server/error-overlay/react-overlay/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startReportingRuntimeErrors = exports.didUnmountReactApp = void 0;
+const remotion_1 = require("remotion");
+const listen_to_runtime_errors_1 = require("./listen-to-runtime-errors");
+let stopListeningToRuntimeErrors = null;
+const didUnmountReactApp = () => {
+    var _a;
+    return !((_a = remotion_1.Internals.getPreviewDomElement()) === null || _a === void 0 ? void 0 : _a.hasChildNodes());
+};
+exports.didUnmountReactApp = didUnmountReactApp;
+function startReportingRuntimeErrors(onError) {
+    if (stopListeningToRuntimeErrors !== null) {
+        throw new Error('Already listening');
+    }
+    const handleRuntimeError = () => {
+        onError();
+    };
+    stopListeningToRuntimeErrors = (0, listen_to_runtime_errors_1.listenToRuntimeErrors)(handleRuntimeError);
+}
+exports.startReportingRuntimeErrors = startReportingRuntimeErrors;

package/dist/preview-server/error-overlay/react-overlay/listen-to-runtime-errors.d.ts

@@ -0,0 +1,8 @@
+import { SymbolicatedStackFrame } from './utils/stack-frame';
+export declare type ErrorRecord = {
+    error: Error;
+    contextSize: number;
+    stackFrames: SymbolicatedStackFrame[];
+};
+export declare const getErrorRecord: (error: Error) => Promise<ErrorRecord | null>;
+export declare function listenToRuntimeErrors(crash: () => void): () => void;

package/dist/preview-server/error-overlay/react-overlay/listen-to-runtime-errors.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listenToRuntimeErrors = exports.getErrorRecord = void 0;
+const Overlay_1 = require("../remotion-overlay/Overlay");
+const format_warning_1 = require("./effects/format-warning");
+const proxy_console_1 = require("./effects/proxy-console");
+const stack_trace_limit_1 = require("./effects/stack-trace-limit");
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const unhandled_error_1 = require("./effects/unhandled-error");
+const unhandled_rejection_1 = require("./effects/unhandled-rejection");
+const get_stack_frames_1 = require("./utils/get-stack-frames");
+const CONTEXT_SIZE = 3;
+const getErrorRecord = async (error) => {
+    const stackFrames = await (0, get_stack_frames_1.getStackFrames)(error, CONTEXT_SIZE);
+    if (stackFrames === null || stackFrames === undefined) {
+        return null;
+    }
+    return {
+        error,
+        contextSize: CONTEXT_SIZE,
+        stackFrames,
+    };
+};
+exports.getErrorRecord = getErrorRecord;
+const crashWithFrames = (crash) => (error) => {
+    var _a;
+    const didHookOrderChange = error.message.startsWith('Rendered fewer hooks') ||
+        error.message.startsWith('Rendered more hooks');
+    if (didHookOrderChange) {
+        // eslint-disable-next-line no-console
+        console.log('Hook order changed. Reloading app...');
+        window.location.reload();
+    }
+    else {
+        (_a = Overlay_1.setErrorsRef.current) === null || _a === void 0 ? void 0 : _a.addError(error);
+        crash();
+    }
+};
+function listenToRuntimeErrors(crash) {
+    const crashWithFramesRunTime = crashWithFrames(crash);
+    (0, unhandled_error_1.register)(window, (error) => {
+        return crashWithFramesRunTime({
+            message: error.message,
+            stack: error.stack,
+            name: error.name,
+        });
+    });
+    (0, unhandled_rejection_1.register)(window, (error) => {
+        return crashWithFramesRunTime(error);
+    });
+    (0, stack_trace_limit_1.register)();
+    (0, proxy_console_1.registerReactStack)();
+    (0, proxy_console_1.permanentRegister)('error', (d) => {
+        if (d.type === 'webpack-error') {
+            const { message, frames } = d;
+            const data = (0, format_warning_1.massageWarning)(message, frames);
+            crashWithFramesRunTime({
+                message: data.message,
+                stack: data.stack,
+                name: '',
+            });
+        }
+        if (d.type === 'build-error') {
+            crashWithFramesRunTime(d.error);
+        }
+    });
+    return function () {
+        (0, stack_trace_limit_1.unregister)();
+        (0, unhandled_rejection_1.unregister)(window);
+        (0, unhandled_error_1.unregister)(window);
+        (0, proxy_console_1.unregisterReactStack)();
+    };
+}
+exports.listenToRuntimeErrors = listenToRuntimeErrors;

package/dist/preview-server/error-overlay/react-overlay/utils/get-file-source.d.ts

@@ -0,0 +1 @@
+export declare const getFileSource: (p: string) => Promise<string>;

package/dist/preview-server/error-overlay/react-overlay/utils/get-file-source.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileSource = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const allowedFileExtensions = ['js', 'ts', 'tsx', 'jsx', 'map', 'mjs'];
+const getFileSource = (p) => {
+    if (!allowedFileExtensions.find((extension) => p.endsWith(extension))) {
+        throw new Error(`Not allowed to open ${p}`);
+    }
+    const resolved = path_1.default.resolve(process.cwd(), p);
+    const relativeToProcessCwd = path_1.default.relative(process.cwd(), resolved);
+    if (relativeToProcessCwd.startsWith('..')) {
+        throw new Error(`Not allowed to open ${relativeToProcessCwd}`);
+    }
+    return fs_1.default.promises.readFile(p, 'utf-8');
+};
+exports.getFileSource = getFileSource;

package/dist/preview-server/error-overlay/react-overlay/utils/get-lines-around.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { ScriptLine } from './stack-frame';
+/**
+ *
+ * @param {number} line The line number to provide context around.
+ * @param {number} count The number of lines you'd like for context.
+ * @param {string[] | string} lines The source code.
+ */
+export declare function getLinesAround(line: number, count: number, lines: string[]): ScriptLine[];

package/dist/preview-server/error-overlay/react-overlay/utils/get-lines-around.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLinesAround = void 0;
+/**
+ *
+ * @param {number} line The line number to provide context around.
+ * @param {number} count The number of lines you'd like for context.
+ * @param {string[] | string} lines The source code.
+ */
+function getLinesAround(line, count, lines) {
+    const result = [];
+    for (let index = Math.max(0, line - 1 - count); index <= Math.min(lines.length - 1, line - 1 + count); ++index) {
+        result.push({
+            lineNumber: index + 1,
+            content: lines[index],
+            highlight: index === line - 1,
+        });
+    }
+    return result;
+}
+exports.getLinesAround = getLinesAround;

package/dist/preview-server/error-overlay/react-overlay/utils/get-source-map.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { SourceMapConsumer } from 'source-map';
+export declare const getOriginalPosition: (source_map: SourceMapConsumer, line: number, column: number) => {
+    source: string | null;
+    line: number | null;
+    column: number | null;
+};
+export declare function getSourceMap(fileUri: string, fileContents: string): Promise<SourceMapConsumer | null>;

package/dist/preview-server/error-overlay/react-overlay/utils/get-source-map.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceMap = exports.getOriginalPosition = void 0;
+/* eslint-disable no-eq-null */
+/* eslint-disable eqeqeq */
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const source_map_1 = require("source-map");
+const getOriginalPosition = (source_map, line, column) => {
+    const result = source_map.originalPositionFor({
+        line,
+        column,
+    });
+    return { line: result.line, column: result.column, source: result.source };
+};
+exports.getOriginalPosition = getOriginalPosition;
+function extractSourceMapUrl(fileContents) {
+    const regex = /\/\/[#@] ?sourceMappingURL=([^\s'"]+)\s*$/gm;
+    let match = null;
+    for (;;) {
+        const next = regex.exec(fileContents);
+        if (next == null) {
+            break;
+        }
+        match = next;
+    }
+    if (!(match === null || match === void 0 ? void 0 : match[1])) {
+        return null;
+    }
+    return match[1].toString();
+}
+async function getSourceMap(fileUri, fileContents) {
+    const sm = extractSourceMapUrl(fileContents);
+    if (sm === null) {
+        return null;
+    }
+    if (sm.indexOf('data:') === 0) {
+        const base64 = /^data:application\/json;([\w=:"-]+;)*base64,/;
+        const match2 = sm.match(base64);
+        if (!match2) {
+            throw new Error('Sorry, non-base64 inline source-map encoding is not supported.');
+        }
+        const converted = window.atob(sm.substring(match2[0].length));
+        return new source_map_1.SourceMapConsumer(JSON.parse(converted));
+    }
+    const index = fileUri.lastIndexOf('/');
+    const url = fileUri.substring(0, index + 1) + sm;
+    const obj = await fetch(url).then((res) => res.json());
+    return new source_map_1.SourceMapConsumer(obj);
+}
+exports.getSourceMap = getSourceMap;

package/dist/preview-server/error-overlay/react-overlay/utils/get-stack-frames.d.ts

@@ -0,0 +1,2 @@
+import type { SymbolicatedStackFrame } from './stack-frame';
+export declare const getStackFrames: (error: Error, contextSize: number) => Promise<SymbolicatedStackFrame[] | null>;

package/dist/preview-server/error-overlay/react-overlay/utils/get-stack-frames.js

@@ -0,0 +1,27 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStackFrames = void 0;
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const parser_1 = require("./parser");
+const unmapper_1 = require("./unmapper");
+const getStackFrames = async (error, contextSize) => {
+    const parsedFrames = await (0, parser_1.parseError)(error, contextSize);
+    const enhancedFrames = await (0, unmapper_1.unmap)(parsedFrames, contextSize);
+    if (enhancedFrames
+        .map((f) => f.originalFileName)
+        .filter((f_1) => f_1 !== null &&
+        f_1 !== undefined &&
+        f_1.indexOf('node_modules') === -1).length === 0) {
+        return null;
+    }
+    return enhancedFrames;
+};
+exports.getStackFrames = getStackFrames;

package/dist/preview-server/error-overlay/react-overlay/utils/open-in-editor.d.ts

@@ -0,0 +1,12 @@
+declare const editorNames: readonly ["atom", "/Applications/Atom Beta.app/Contents/MacOS/Atom Beta", "brackets", "/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl", "/Applications/Sublime Text Dev.app/Contents/SharedSupport/bin/subl", "/Applications/Sublime Text 2.app/Contents/SharedSupport/bin/subl", "code", "code-insiders", "vscodium", "/Applications/AppCode.app/Contents/MacOS/appcode", "/Applications/CLion.app/Contents/MacOS/clion", "/Applications/IntelliJ IDEA.app/Contents/MacOS/idea", "/Applications/PhpStorm.app/Contents/MacOS/phpstorm", "/Applications/PyCharm.app/Contents/MacOS/pycharm", "/Applications/PyCharm CE.app/Contents/MacOS/pycharm", "/Applications/RubyMine.app/Contents/MacOS/rubymine", "/Applications/WebStorm.app/Contents/MacOS/webstorm", "/Applications/GoLand.app/Contents/MacOS/goland", "/Applications/Rider.app/Contents/MacOS/rider", "mvim", "emacs", "gvim", "idea", "phpstorm", "pycharm", "rubymine", "sublime_text", "vim", "webstorm", "goland", "rider", "Brackets.exe", "Code.exe", "Code - Insiders.exe", "VSCodium.exe", "atom.exe", "sublime_text.exe", "notepad++.exe", "clion.exe", "clion64.exe", "idea.exe", "idea64.exe", "phpstorm.exe", "phpstorm64.exe", "pycharm.exe", "pycharm64.exe", "rubymine.exe", "rubymine64.exe", "webstorm.exe", "webstorm64.exe", "goland.exe", "goland64.exe", "rider.exe", "rider64.exe", "nano"];
+export declare const getDisplayNameForEditor: (editor: Editor | undefined) => string | null;
+declare type Editor = typeof editorNames[number];
+export declare function guessEditor(): Promise<Editor[]>;
+export declare function launchEditor({ colNumber, editor, fileName, lineNumber, vsCodeNewWindow, }: {
+    fileName: string;
+    lineNumber: number;
+    colNumber: number;
+    editor: Editor;
+    vsCodeNewWindow: boolean;
+}): Promise<boolean>;
+export {};