remotion 4.0.71 → 4.0.73

package/dist/esm/no-react.mjs

@@ -0,0 +1,748 @@
+// Taken from https://github.com/facebook/react-native/blob/0b9ea60b4fee8cacc36e7160e31b91fc114dbc0d/Libraries/Animated/src/nodes/AnimatedInterpolation.js
+function interpolateFunction(input, inputRange, outputRange, options) {
+    const { extrapolateLeft, extrapolateRight, easing } = options;
+    let result = input;
+    const [inputMin, inputMax] = inputRange;
+    const [outputMin, outputMax] = outputRange;
+    if (result < inputMin) {
+        if (extrapolateLeft === 'identity') {
+            return result;
+        }
+        if (extrapolateLeft === 'clamp') {
+            result = inputMin;
+        }
+    }
+    if (result > inputMax) {
+        if (extrapolateRight === 'identity') {
+            return result;
+        }
+        if (extrapolateRight === 'clamp') {
+            result = inputMax;
+        }
+    }
+    if (outputMin === outputMax) {
+        return outputMin;
+    }
+    // Input Range
+    result = (result - inputMin) / (inputMax - inputMin);
+    // Easing
+    result = easing(result);
+    // Output Range
+    result = result * (outputMax - outputMin) + outputMin;
+    return result;
+}
+function findRange(input, inputRange) {
+    let i;
+    for (i = 1; i < inputRange.length - 1; ++i) {
+        if (inputRange[i] >= input) {
+            break;
+        }
+    }
+    return i - 1;
+}
+function checkValidInputRange(arr) {
+    for (let i = 1; i < arr.length; ++i) {
+        if (!(arr[i] > arr[i - 1])) {
+            throw new Error(`inputRange must be strictly monotonically non-decreasing but got [${arr.join(',')}]`);
+        }
+    }
+}
+function checkInfiniteRange(name, arr) {
+    if (arr.length < 2) {
+        throw new Error(name + ' must have at least 2 elements');
+    }
+    for (const index in arr) {
+        if (typeof arr[index] !== 'number') {
+            throw new Error(`${name} must contain only numbers`);
+        }
+        if (arr[index] === -Infinity || arr[index] === Infinity) {
+            throw new Error(`${name} must contain only finite numbers, but got [${arr.join(',')}]`);
+        }
+    }
+}
+/**
+ * Map a value from an input range to an output range.
+ * @link https://www.remotion.dev/docs/interpolate
+ * @param {!number} input value to interpolate
+ * @param {!number[]} inputRange range of values that you expect the input to assume.
+ * @param {!number[]} outputRange range of output values that you want the input to map to.
+ * @param {?object} options
+ * @param {?Function} options.easing easing function which allows you to customize the input, for example to apply a certain easing function. By default, the input is left unmodified, resulting in a pure linear interpolation {@link https://www.remotion.dev/docs/easing}
+ * @param {string=} [options.extrapolateLeft="extend"] What should happen if the input value is outside left the input range, default: "extend" {@link https://www.remotion.dev/docs/interpolate#extrapolateleft}
+ * @param {string=} [options.extrapolateRight="extend"] Same as extrapolateLeft, except for values outside right the input range {@link https://www.remotion.dev/docs/interpolate#extrapolateright}
+ */
+function interpolate(input, inputRange, outputRange, options) {
+    var _a;
+    if (typeof input === 'undefined') {
+        throw new Error('input can not be undefined');
+    }
+    if (typeof inputRange === 'undefined') {
+        throw new Error('inputRange can not be undefined');
+    }
+    if (typeof outputRange === 'undefined') {
+        throw new Error('outputRange can not be undefined');
+    }
+    if (inputRange.length !== outputRange.length) {
+        throw new Error('inputRange (' +
+            inputRange.length +
+            ') and outputRange (' +
+            outputRange.length +
+            ') must have the same length');
+    }
+    checkInfiniteRange('inputRange', inputRange);
+    checkInfiniteRange('outputRange', outputRange);
+    checkValidInputRange(inputRange);
+    const easing = (_a = options === null || options === void 0 ? void 0 : options.easing) !== null && _a !== void 0 ? _a : ((num) => num);
+    let extrapolateLeft = 'extend';
+    if ((options === null || options === void 0 ? void 0 : options.extrapolateLeft) !== undefined) {
+        extrapolateLeft = options.extrapolateLeft;
+    }
+    let extrapolateRight = 'extend';
+    if ((options === null || options === void 0 ? void 0 : options.extrapolateRight) !== undefined) {
+        extrapolateRight = options.extrapolateRight;
+    }
+    if (typeof input !== 'number') {
+        throw new TypeError('Cannot interpolate an input which is not a number');
+    }
+    const range = findRange(input, inputRange);
+    return interpolateFunction(input, [inputRange[range], inputRange[range + 1]], [outputRange[range], outputRange[range + 1]], {
+        easing,
+        extrapolateLeft,
+        extrapolateRight,
+    });
+}
+
+/* eslint-disable no-bitwise */
+function mulberry32(a) {
+    let t = a + 0x6d2b79f5;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+}
+function hashCode(str) {
+    let i = 0;
+    let chr = 0;
+    let hash = 0;
+    for (i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
+/**
+ * @description A deterministic pseudo-random number generator. Pass in the same seed and get the same pseudorandom number.
+ * @see [Documentation](https://remotion.dev/docs/random)
+ */
+const random = (seed, dummy) => {
+    if (dummy !== undefined) {
+        throw new TypeError('random() takes only one argument');
+    }
+    if (seed === null) {
+        return Math.random();
+    }
+    if (typeof seed === 'string') {
+        return mulberry32(hashCode(seed));
+    }
+    if (typeof seed === 'number') {
+        return mulberry32(seed * 10000000000);
+    }
+    throw new Error('random() argument must be a number or a string');
+};
+
+function truthy(value) {
+    return Boolean(value);
+}
+
+if (typeof window !== 'undefined') {
+    window.remotion_renderReady = false;
+}
+if (typeof window !== 'undefined') {
+    window.remotion_delayRenderTimeouts = {};
+}
+const DELAY_RENDER_CALLSTACK_TOKEN = 'The delayRender was called:';
+
+const problematicCharacters = {
+    '%3A': ':',
+    '%2F': '/',
+    '%3F': '?',
+    '%23': '#',
+    '%5B': '[',
+    '%5D': ']',
+    '%40': '@',
+    '%21': '!',
+    '%24': '$',
+    '%26': '&',
+    '%27': "'",
+    '%28': '(',
+    '%29': ')',
+    '%2A': '*',
+    '%2B': '+',
+    '%2C': ',',
+    '%3B': ';',
+};
+const didWarn = {};
+const warnOnce = (message) => {
+    if (didWarn[message]) {
+        return;
+    }
+    console.warn(message);
+    didWarn[message] = true;
+};
+const includesHexOfUnsafeChar = (path) => {
+    for (const key of Object.keys(problematicCharacters)) {
+        if (path.includes(key)) {
+            return { containsHex: true, hexCode: key };
+        }
+    }
+    return { containsHex: false };
+};
+const trimLeadingSlash = (path) => {
+    if (path.startsWith('/')) {
+        return trimLeadingSlash(path.substring(1));
+    }
+    return path;
+};
+const inner = (path) => {
+    if (typeof window !== 'undefined' && window.remotion_staticBase) {
+        if (path.startsWith(window.remotion_staticBase)) {
+            throw new Error(`The value "${path}" is already prefixed with the static base ${window.remotion_staticBase}. You don't need to call staticFile() on it.`);
+        }
+        return `${window.remotion_staticBase}/${trimLeadingSlash(path)}`;
+    }
+    return `/${trimLeadingSlash(path)}`;
+};
+const encodeBySplitting = (path) => {
+    const splitBySlash = path.split('/');
+    const encodedArray = splitBySlash.map((element) => {
+        return encodeURIComponent(element);
+    });
+    const merged = encodedArray.join('/');
+    return merged;
+};
+/**
+ * @description Reference a file from the public/ folder. If the file does not appear in the autocomplete, type the path manually.
+ * @see [Documentation](https://www.remotion.dev/docs/staticfile)
+ */
+const staticFile = (path) => {
+    if (path.startsWith('http://') || path.startsWith('https://')) {
+        throw new TypeError(`staticFile() does not support remote URLs - got "${path}". Instead, pass the URL without wrapping it in staticFile(). See: https://remotion.dev/docs/staticfile-remote-urls`);
+    }
+    if (path.startsWith('..') || path.startsWith('./')) {
+        throw new TypeError(`staticFile() does not support relative paths - got "${path}". Instead, pass the name of a file that is inside the public/ folder. See: https://remotion.dev/docs/staticfile-relative-paths`);
+    }
+    if (path.startsWith('/Users') ||
+        path.startsWith('/home') ||
+        path.startsWith('/tmp') ||
+        path.startsWith('/etc') ||
+        path.startsWith('/opt') ||
+        path.startsWith('/var') ||
+        path.startsWith('C:') ||
+        path.startsWith('D:') ||
+        path.startsWith('E:')) {
+        throw new TypeError(`staticFile() does not support absolute paths - got "${path}". Instead, pass the name of a file that is inside the public/ folder. See: https://remotion.dev/docs/staticfile-relative-paths`);
+    }
+    if (path.startsWith('public/')) {
+        throw new TypeError(`Do not include the public/ prefix when using staticFile() - got "${path}". See: https://remotion.dev/docs/staticfile-relative-paths`);
+    }
+    const includesHex = includesHexOfUnsafeChar(path);
+    if (includesHex.containsHex) {
+        warnOnce(`WARNING: You seem to pass an already encoded path (path contains ${includesHex.hexCode}). Since Remotion 4.0, the encoding is done by staticFile() itself. You may want to remove a encodeURIComponent() wrapping.`);
+    }
+    const preprocessed = encodeBySplitting(path);
+    const preparsed = inner(preprocessed);
+    if (!preparsed.startsWith('/')) {
+        return `/${preparsed}`;
+    }
+    return preparsed;
+};
+
+// Must keep this file in sync with the one in packages/lambda/src/shared/serialize-props.ts!
+const DATE_TOKEN = 'remotion-date:';
+const FILE_TOKEN = 'remotion-file:';
+const serializeJSONWithDate = ({ data, indent, staticBase, }) => {
+    let customDateUsed = false;
+    let customFileUsed = false;
+    let mapUsed = false;
+    let setUsed = false;
+    const serializedString = JSON.stringify(data, function (key, value) {
+        const item = this[key];
+        if (item instanceof Date) {
+            customDateUsed = true;
+            return `${DATE_TOKEN}${item.toISOString()}`;
+        }
+        if (item instanceof Map) {
+            mapUsed = true;
+            return value;
+        }
+        if (item instanceof Set) {
+            setUsed = true;
+            return value;
+        }
+        if (typeof item === 'string' &&
+            staticBase !== null &&
+            item.startsWith(staticBase)) {
+            customFileUsed = true;
+            return `${FILE_TOKEN}${item.replace(staticBase + '/', '')}`;
+        }
+        return value;
+    }, indent);
+    return { serializedString, customDateUsed, customFileUsed, mapUsed, setUsed };
+};
+const deserializeJSONWithCustomFields = (data) => {
+    return JSON.parse(data, (_, value) => {
+        if (typeof value === 'string' && value.startsWith(DATE_TOKEN)) {
+            return new Date(value.replace(DATE_TOKEN, ''));
+        }
+        if (typeof value === 'string' && value.startsWith(FILE_TOKEN)) {
+            return staticFile(value.replace(FILE_TOKEN, ''));
+        }
+        return value;
+    });
+};
+
+/**
+ * Copied from:
+ * https://github.com/software-mansion/react-native-reanimated/blob/master/src/reanimated2/Colors.ts
+ */
+// var INTEGER = '[-+]?\\d+';
+const NUMBER = '[-+]?\\d*\\.?\\d+';
+const PERCENTAGE = NUMBER + '%';
+function call(...args) {
+    return '\\(\\s*(' + args.join(')\\s*,\\s*(') + ')\\s*\\)';
+}
+function getMatchers() {
+    const cachedMatchers = {
+        rgb: undefined,
+        rgba: undefined,
+        hsl: undefined,
+        hsla: undefined,
+        hex3: undefined,
+        hex4: undefined,
+        hex5: undefined,
+        hex6: undefined,
+        hex8: undefined,
+    };
+    if (cachedMatchers.rgb === undefined) {
+        cachedMatchers.rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER));
+        cachedMatchers.rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER));
+        cachedMatchers.hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));
+        cachedMatchers.hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));
+        cachedMatchers.hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
+        cachedMatchers.hex4 =
+            /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
+        cachedMatchers.hex6 = /^#([0-9a-fA-F]{6})$/;
+        cachedMatchers.hex8 = /^#([0-9a-fA-F]{8})$/;
+    }
+    return cachedMatchers;
+}
+function hue2rgb(p, q, t) {
+    if (t < 0) {
+        t += 1;
+    }
+    if (t > 1) {
+        t -= 1;
+    }
+    if (t < 1 / 6) {
+        return p + (q - p) * 6 * t;
+    }
+    if (t < 1 / 2) {
+        return q;
+    }
+    if (t < 2 / 3) {
+        return p + (q - p) * (2 / 3 - t) * 6;
+    }
+    return p;
+}
+function hslToRgb(h, s, l) {
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    const r = hue2rgb(p, q, h + 1 / 3);
+    const g = hue2rgb(p, q, h);
+    const b = hue2rgb(p, q, h - 1 / 3);
+    return ((Math.round(r * 255) << 24) |
+        (Math.round(g * 255) << 16) |
+        (Math.round(b * 255) << 8));
+}
+function parse255(str) {
+    const int = Number.parseInt(str, 10);
+    if (int < 0) {
+        return 0;
+    }
+    if (int > 255) {
+        return 255;
+    }
+    return int;
+}
+function parse360(str) {
+    const int = Number.parseFloat(str);
+    return (((int % 360) + 360) % 360) / 360;
+}
+function parse1(str) {
+    const num = Number.parseFloat(str);
+    if (num < 0) {
+        return 0;
+    }
+    if (num > 1) {
+        return 255;
+    }
+    return Math.round(num * 255);
+}
+function parsePercentage(str) {
+    // parseFloat conveniently ignores the final %
+    const int = Number.parseFloat(str);
+    if (int < 0) {
+        return 0;
+    }
+    if (int > 100) {
+        return 1;
+    }
+    return int / 100;
+}
+const names = {
+    transparent: 0x00000000,
+    // http://www.w3.org/TR/css3-color/#svg-color
+    aliceblue: 0xf0f8ffff,
+    antiquewhite: 0xfaebd7ff,
+    aqua: 0x00ffffff,
+    aquamarine: 0x7fffd4ff,
+    azure: 0xf0ffffff,
+    beige: 0xf5f5dcff,
+    bisque: 0xffe4c4ff,
+    black: 0x000000ff,
+    blanchedalmond: 0xffebcdff,
+    blue: 0x0000ffff,
+    blueviolet: 0x8a2be2ff,
+    brown: 0xa52a2aff,
+    burlywood: 0xdeb887ff,
+    burntsienna: 0xea7e5dff,
+    cadetblue: 0x5f9ea0ff,
+    chartreuse: 0x7fff00ff,
+    chocolate: 0xd2691eff,
+    coral: 0xff7f50ff,
+    cornflowerblue: 0x6495edff,
+    cornsilk: 0xfff8dcff,
+    crimson: 0xdc143cff,
+    cyan: 0x00ffffff,
+    darkblue: 0x00008bff,
+    darkcyan: 0x008b8bff,
+    darkgoldenrod: 0xb8860bff,
+    darkgray: 0xa9a9a9ff,
+    darkgreen: 0x006400ff,
+    darkgrey: 0xa9a9a9ff,
+    darkkhaki: 0xbdb76bff,
+    darkmagenta: 0x8b008bff,
+    darkolivegreen: 0x556b2fff,
+    darkorange: 0xff8c00ff,
+    darkorchid: 0x9932ccff,
+    darkred: 0x8b0000ff,
+    darksalmon: 0xe9967aff,
+    darkseagreen: 0x8fbc8fff,
+    darkslateblue: 0x483d8bff,
+    darkslategray: 0x2f4f4fff,
+    darkslategrey: 0x2f4f4fff,
+    darkturquoise: 0x00ced1ff,
+    darkviolet: 0x9400d3ff,
+    deeppink: 0xff1493ff,
+    deepskyblue: 0x00bfffff,
+    dimgray: 0x696969ff,
+    dimgrey: 0x696969ff,
+    dodgerblue: 0x1e90ffff,
+    firebrick: 0xb22222ff,
+    floralwhite: 0xfffaf0ff,
+    forestgreen: 0x228b22ff,
+    fuchsia: 0xff00ffff,
+    gainsboro: 0xdcdcdcff,
+    ghostwhite: 0xf8f8ffff,
+    gold: 0xffd700ff,
+    goldenrod: 0xdaa520ff,
+    gray: 0x808080ff,
+    green: 0x008000ff,
+    greenyellow: 0xadff2fff,
+    grey: 0x808080ff,
+    honeydew: 0xf0fff0ff,
+    hotpink: 0xff69b4ff,
+    indianred: 0xcd5c5cff,
+    indigo: 0x4b0082ff,
+    ivory: 0xfffff0ff,
+    khaki: 0xf0e68cff,
+    lavender: 0xe6e6faff,
+    lavenderblush: 0xfff0f5ff,
+    lawngreen: 0x7cfc00ff,
+    lemonchiffon: 0xfffacdff,
+    lightblue: 0xadd8e6ff,
+    lightcoral: 0xf08080ff,
+    lightcyan: 0xe0ffffff,
+    lightgoldenrodyellow: 0xfafad2ff,
+    lightgray: 0xd3d3d3ff,
+    lightgreen: 0x90ee90ff,
+    lightgrey: 0xd3d3d3ff,
+    lightpink: 0xffb6c1ff,
+    lightsalmon: 0xffa07aff,
+    lightseagreen: 0x20b2aaff,
+    lightskyblue: 0x87cefaff,
+    lightslategray: 0x778899ff,
+    lightslategrey: 0x778899ff,
+    lightsteelblue: 0xb0c4deff,
+    lightyellow: 0xffffe0ff,
+    lime: 0x00ff00ff,
+    limegreen: 0x32cd32ff,
+    linen: 0xfaf0e6ff,
+    magenta: 0xff00ffff,
+    maroon: 0x800000ff,
+    mediumaquamarine: 0x66cdaaff,
+    mediumblue: 0x0000cdff,
+    mediumorchid: 0xba55d3ff,
+    mediumpurple: 0x9370dbff,
+    mediumseagreen: 0x3cb371ff,
+    mediumslateblue: 0x7b68eeff,
+    mediumspringgreen: 0x00fa9aff,
+    mediumturquoise: 0x48d1ccff,
+    mediumvioletred: 0xc71585ff,
+    midnightblue: 0x191970ff,
+    mintcream: 0xf5fffaff,
+    mistyrose: 0xffe4e1ff,
+    moccasin: 0xffe4b5ff,
+    navajowhite: 0xffdeadff,
+    navy: 0x000080ff,
+    oldlace: 0xfdf5e6ff,
+    olive: 0x808000ff,
+    olivedrab: 0x6b8e23ff,
+    orange: 0xffa500ff,
+    orangered: 0xff4500ff,
+    orchid: 0xda70d6ff,
+    palegoldenrod: 0xeee8aaff,
+    palegreen: 0x98fb98ff,
+    paleturquoise: 0xafeeeeff,
+    palevioletred: 0xdb7093ff,
+    papayawhip: 0xffefd5ff,
+    peachpuff: 0xffdab9ff,
+    peru: 0xcd853fff,
+    pink: 0xffc0cbff,
+    plum: 0xdda0ddff,
+    powderblue: 0xb0e0e6ff,
+    purple: 0x800080ff,
+    rebeccapurple: 0x663399ff,
+    red: 0xff0000ff,
+    rosybrown: 0xbc8f8fff,
+    royalblue: 0x4169e1ff,
+    saddlebrown: 0x8b4513ff,
+    salmon: 0xfa8072ff,
+    sandybrown: 0xf4a460ff,
+    seagreen: 0x2e8b57ff,
+    seashell: 0xfff5eeff,
+    sienna: 0xa0522dff,
+    silver: 0xc0c0c0ff,
+    skyblue: 0x87ceebff,
+    slateblue: 0x6a5acdff,
+    slategray: 0x708090ff,
+    slategrey: 0x708090ff,
+    snow: 0xfffafaff,
+    springgreen: 0x00ff7fff,
+    steelblue: 0x4682b4ff,
+    tan: 0xd2b48cff,
+    teal: 0x008080ff,
+    thistle: 0xd8bfd8ff,
+    tomato: 0xff6347ff,
+    turquoise: 0x40e0d0ff,
+    violet: 0xee82eeff,
+    wheat: 0xf5deb3ff,
+    white: 0xffffffff,
+    whitesmoke: 0xf5f5f5ff,
+    yellow: 0xffff00ff,
+    yellowgreen: 0x9acd32ff,
+};
+function normalizeColor(color) {
+    const matchers = getMatchers();
+    let match;
+    // Ordered based on occurrences on Facebook codebase
+    if (matchers.hex6) {
+        if ((match = matchers.hex6.exec(color))) {
+            return Number.parseInt(match[1] + 'ff', 16) >>> 0;
+        }
+    }
+    if (names[color] !== undefined) {
+        return names[color];
+    }
+    if (matchers.rgb) {
+        if ((match = matchers.rgb.exec(color))) {
+            return (
+            // b
+            ((parse255(match[1]) << 24) | // r
+                (parse255(match[2]) << 16) | // g
+                (parse255(match[3]) << 8) |
+                0x000000ff) >>> // a
+                0);
+        }
+    }
+    if (matchers.rgba) {
+        if ((match = matchers.rgba.exec(color))) {
+            return (
+            // b
+            ((parse255(match[1]) << 24) | // r
+                (parse255(match[2]) << 16) | // g
+                (parse255(match[3]) << 8) |
+                parse1(match[4])) >>> // a
+                0);
+        }
+    }
+    if (matchers.hex3) {
+        if ((match = matchers.hex3.exec(color))) {
+            return (Number.parseInt(match[1] +
+                match[1] + // r
+                match[2] +
+                match[2] + // g
+                match[3] +
+                match[3] + // b
+                'ff', // a
+            16) >>> 0);
+        }
+    }
+    // https://drafts.csswg.org/css-color-4/#hex-notation
+    if (matchers.hex8) {
+        if ((match = matchers.hex8.exec(color))) {
+            return Number.parseInt(match[1], 16) >>> 0;
+        }
+    }
+    if (matchers.hex4) {
+        if ((match = matchers.hex4.exec(color))) {
+            return (Number.parseInt(match[1] +
+                match[1] + // r
+                match[2] +
+                match[2] + // g
+                match[3] +
+                match[3] + // b
+                match[4] +
+                match[4], // a
+            16) >>> 0);
+        }
+    }
+    if (matchers.hsl) {
+        if ((match = matchers.hsl.exec(color))) {
+            return ((hslToRgb(parse360(match[1]), // h
+            parsePercentage(match[2]), // s
+            parsePercentage(match[3])) |
+                0x000000ff) >>> // a
+                0);
+        }
+    }
+    if (matchers.hsla) {
+        if ((match = matchers.hsla.exec(color))) {
+            return ((hslToRgb(parse360(match[1]), // h
+            parsePercentage(match[2]), // s
+            parsePercentage(match[3])) |
+                parse1(match[4])) >>> // a
+                0);
+        }
+    }
+    throw new Error(`invalid color string ${color} provided`);
+}
+function processColor(color) {
+    const normalizedColor = normalizeColor(color);
+    return ((normalizedColor << 24) | (normalizedColor >>> 8)) >>> 0; // argb
+}
+
+const validateFrame = ({ allowFloats, durationInFrames, frame, }) => {
+    if (typeof frame === 'undefined') {
+        throw new TypeError(`Argument missing for parameter "frame"`);
+    }
+    if (typeof frame !== 'number') {
+        throw new TypeError(`Argument passed for "frame" is not a number: ${frame}`);
+    }
+    if (!Number.isFinite(frame)) {
+        throw new RangeError(`Frame ${frame} is not finite`);
+    }
+    if (frame % 1 !== 0 && !allowFloats) {
+        throw new RangeError(`Argument for frame must be an integer, but got ${frame}`);
+    }
+    if (frame < 0 && frame < -durationInFrames) {
+        throw new RangeError(`Cannot use frame ${frame}: Duration of composition is ${durationInFrames}, therefore the lowest frame that can be rendered is ${-durationInFrames}`);
+    }
+    if (frame > durationInFrames - 1) {
+        throw new RangeError(`Cannot use frame ${frame}: Duration of composition is ${durationInFrames}, therefore the highest frame that can be rendered is ${durationInFrames - 1}`);
+    }
+};
+
+const validateDefaultAndInputProps = (defaultProps, name, compositionId) => {
+    if (!defaultProps) {
+        return;
+    }
+    if (typeof defaultProps !== 'object') {
+        throw new Error(`"${name}" must be an object, but you passed a value of type ${typeof defaultProps}`);
+    }
+    if (Array.isArray(defaultProps)) {
+        throw new Error(`"${name}" must be an object, an array was passed ${compositionId ? `for composition "${compositionId}"` : ''}`);
+    }
+};
+
+function validateDimension(amount, nameOfProp, location) {
+    if (typeof amount !== 'number') {
+        throw new Error(`The "${nameOfProp}" prop ${location} must be a number, but you passed a value of type ${typeof amount}`);
+    }
+    if (isNaN(amount)) {
+        throw new TypeError(`The "${nameOfProp}" prop ${location} must not be NaN, but is NaN.`);
+    }
+    if (!Number.isFinite(amount)) {
+        throw new TypeError(`The "${nameOfProp}" prop ${location} must be finite, but is ${amount}.`);
+    }
+    if (amount % 1 !== 0) {
+        throw new TypeError(`The "${nameOfProp}" prop ${location} must be an integer, but is ${amount}.`);
+    }
+    if (amount <= 0) {
+        throw new TypeError(`The "${nameOfProp}" prop ${location} must be positive, but got ${amount}.`);
+    }
+}
+
+function validateDurationInFrames(durationInFrames, options) {
+    const { allowFloats, component } = options;
+    if (typeof durationInFrames === 'undefined') {
+        throw new Error(`The "durationInFrames" prop ${component} is missing.`);
+    }
+    if (typeof durationInFrames !== 'number') {
+        throw new Error(`The "durationInFrames" prop ${component} must be a number, but you passed a value of type ${typeof durationInFrames}`);
+    }
+    if (durationInFrames <= 0) {
+        throw new TypeError(`The "durationInFrames" prop ${component} must be positive, but got ${durationInFrames}.`);
+    }
+    if (!allowFloats && durationInFrames % 1 !== 0) {
+        throw new TypeError(`The "durationInFrames" prop ${component} must be an integer, but got ${durationInFrames}.`);
+    }
+    if (!Number.isFinite(durationInFrames)) {
+        throw new TypeError(`The "durationInFrames" prop ${component} must be finite, but got ${durationInFrames}.`);
+    }
+}
+
+function validateFps(fps, location, isGif) {
+    if (typeof fps !== 'number') {
+        throw new Error(`"fps" must be a number, but you passed a value of type ${typeof fps} ${location}`);
+    }
+    if (!Number.isFinite(fps)) {
+        throw new Error(`"fps" must be a finite, but you passed ${fps} ${location}`);
+    }
+    if (isNaN(fps)) {
+        throw new Error(`"fps" must not be NaN, but got ${fps} ${location}`);
+    }
+    if (fps <= 0) {
+        throw new TypeError(`"fps" must be positive, but got ${fps} ${location}`);
+    }
+    if (isGif && fps > 50) {
+        throw new TypeError(`The FPS for a GIF cannot be higher than 50. Use the --every-nth-frame option to lower the FPS: https://remotion.dev/docs/render-as-gif`);
+    }
+}
+
+const NoReactInternals = {
+    processColor,
+    truthy,
+    validateFps,
+    validateDimension,
+    validateDurationInFrames,
+    validateDefaultAndInputProps,
+    validateFrame,
+    serializeJSONWithDate,
+    bundleName: 'bundle.js',
+    bundleMapName: 'bundle.js.map',
+    deserializeJSONWithCustomFields,
+    DELAY_RENDER_CALLSTACK_TOKEN,
+};
+
+export { NoReactInternals, interpolate, random };