@remotion/webcodecs 4.0.245 → 4.0.247

package/dist/create/matroska/matroska-trackentry.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaTracks = exports.makeMatroskaVideoTrackEntryBytes = exports.makeMatroskaAudioTrackEntryBytes = exports.makeMatroskaVideoBytes = void 0;
+const color_1 = require("./color");
+const matroska_utils_1 = require("./matroska-utils");
+const makeMatroskaVideoBytes = ({ color, width, height, }) => {
+    return (0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'Video',
+        value: [
+            {
+                type: 'PixelWidth',
+                value: {
+                    value: width,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'PixelHeight',
+                value: {
+                    value: height,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagInterlaced',
+                value: {
+                    // https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
+                    // 5.1.4.1.28.1.
+                    value: 2, // 2 - progressive, no interlaced
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            (0, color_1.makeMatroskaColorBytes)(color),
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaVideoBytes = makeMatroskaVideoBytes;
+const makeVideoCodecId = (codecId) => {
+    if (codecId === 'vp8') {
+        return 'V_VP8';
+    }
+    if (codecId === 'vp9') {
+        return 'V_VP9';
+    }
+    if (codecId === 'h264') {
+        return 'V_MPEG4/ISO/AVC';
+    }
+    if (codecId === 'av1') {
+        return 'V_AV1';
+    }
+    if (codecId === 'h265') {
+        return 'V_MPEGH/ISO/HEVC';
+    }
+    if (codecId === 'prores') {
+        return 'V_PRORES';
+    }
+    throw new Error(`Unknown codec: ${codecId}`);
+};
+const makeAudioCodecId = (codecId) => {
+    if (codecId === 'opus') {
+        return 'A_OPUS';
+    }
+    if (codecId === 'aac') {
+        return 'A_AAC';
+    }
+    if (codecId === 'mp3') {
+        return 'A_MPEG/L3';
+    }
+    if (codecId === 'vorbis') {
+        return 'A_VORBIS';
+    }
+    if (codecId === 'pcm-u8') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'pcm-s16') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'pcm-s24') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'pcm-s32') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'pcm-f32') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'aiff') {
+        throw new Error('aiff is not supported in Matroska');
+    }
+    throw new Error(`Unknown codec: ${codecId}`);
+};
+const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codec, numberOfChannels, sampleRate, codecPrivate, }) => {
+    return (0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'TrackEntry',
+        minVintWidth: null,
+        value: [
+            {
+                type: 'TrackNumber',
+                value: {
+                    value: trackNumber,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackUID',
+                value: '0x188FEB95C8EFABA',
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackType',
+                value: {
+                    value: 2,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'CodecID',
+                value: makeAudioCodecId(codec),
+                minVintWidth: null,
+            },
+            {
+                type: 'Audio',
+                value: [
+                    {
+                        type: 'Channels',
+                        minVintWidth: null,
+                        value: {
+                            value: numberOfChannels,
+                            byteLength: null,
+                        },
+                    },
+                    {
+                        type: 'SamplingFrequency',
+                        minVintWidth: null,
+                        value: {
+                            value: sampleRate,
+                            size: '64',
+                        },
+                    },
+                    {
+                        type: 'BitDepth',
+                        minVintWidth: null,
+                        value: {
+                            value: 32,
+                            byteLength: null,
+                        },
+                    },
+                ],
+                minVintWidth: null,
+            },
+            codecPrivate
+                ? {
+                    type: 'CodecPrivate',
+                    minVintWidth: null,
+                    value: codecPrivate,
+                }
+                : null,
+        ].filter(Boolean),
+    });
+};
+exports.makeMatroskaAudioTrackEntryBytes = makeMatroskaAudioTrackEntryBytes;
+const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, trackNumber, codec, codecPrivate, }) => {
+    return (0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'TrackEntry',
+        minVintWidth: null,
+        value: [
+            {
+                type: 'TrackNumber',
+                value: {
+                    value: trackNumber,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackUID',
+                value: '0xab2171012bb9020a',
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagLacing',
+                value: {
+                    value: 0,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'Language',
+                value: 'und',
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagDefault',
+                value: {
+                    value: 0,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'CodecID',
+                value: makeVideoCodecId(codec),
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackType',
+                value: {
+                    value: 1, // 'video'
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            (0, exports.makeMatroskaVideoBytes)({
+                color,
+                width,
+                height,
+            }),
+            codecPrivate
+                ? {
+                    type: 'CodecPrivate',
+                    minVintWidth: null,
+                    value: codecPrivate,
+                }
+                : null,
+        ].filter(Boolean),
+    });
+};
+exports.makeMatroskaVideoTrackEntryBytes = makeMatroskaVideoTrackEntryBytes;
+const makeMatroskaTracks = (tracks) => {
+    const bytesArr = tracks.map((t) => {
+        const bytes = t.type === 'video'
+            ? (0, exports.makeMatroskaVideoTrackEntryBytes)(t)
+            : (0, exports.makeMatroskaAudioTrackEntryBytes)(t);
+        return bytes;
+    });
+    return (0, matroska_utils_1.padMatroskaBytes)((0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'Tracks',
+        value: bytesArr,
+        minVintWidth: null,
+    }), 500);
+};
+exports.makeMatroskaTracks = makeMatroskaTracks;

package/dist/create/matroska/matroska-utils.d.ts

@@ -0,0 +1,30 @@
+import type { Ebml, EbmlValue, Prettify } from '@remotion/media-parser';
+import { MediaParserInternals } from '@remotion/media-parser';
+export declare const getIdForName: (name: string) => EbmlMapKey;
+export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;
+export type OffsetAndChildren = {
+    offset: number;
+    children: OffsetAndChildren[];
+    field: keyof typeof MediaParserInternals.matroskaElements;
+};
+export declare const incrementOffsetAndChildren: (offset: OffsetAndChildren, increment: number) => OffsetAndChildren;
+export declare const matroskaToHex: (matrId: (typeof MediaParserInternals.matroskaElements)[keyof typeof MediaParserInternals.matroskaElements]) => Uint8Array;
+export type BytesAndOffset = {
+    bytes: Uint8Array;
+    offsets: OffsetAndChildren;
+};
+export type EbmlValueOrUint8Array<T extends Ebml> = Uint8Array | EbmlValue<T, PossibleEbmlOrUint8Array>;
+export type EbmlParsedOrUint8Array<T extends Ebml> = {
+    type: T['name'];
+    value: EbmlValueOrUint8Array<T>;
+    minVintWidth: number | null;
+};
+export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 4 | 3 | 5 | 6;
+export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;
+export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => BytesAndOffset;
+export type PossibleEbmlOrUint8Array = Prettify<{
+    [key in keyof typeof MediaParserInternals.ebmlMap]: EbmlParsedOrUint8Array<(typeof MediaParserInternals.ebmlMap)[key]>;
+}[keyof typeof MediaParserInternals.ebmlMap]> | BytesAndOffset;
+export type EbmlMapKey = keyof typeof MediaParserInternals.ebmlMap;
+export declare const padMatroskaBytes: (fields: PossibleEbmlOrUint8Array, totalLength: number) => BytesAndOffset[];
+export declare function serializeUint16(value: number): Uint8Array;

package/dist/create/matroska/matroska-utils.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padMatroskaBytes = exports.makeMatroskaBytes = exports.getVariableInt = exports.measureEBMLVarInt = exports.matroskaToHex = exports.incrementOffsetAndChildren = exports.combineUint8Arrays = exports.getIdForName = void 0;
+exports.serializeUint16 = serializeUint16;
+const media_parser_1 = require("@remotion/media-parser");
+const getIdForName = (name) => {
+    var _a;
+    const value = (_a = Object.entries(media_parser_1.MediaParserInternals.matroskaElements).find(([key]) => key === name)) === null || _a === void 0 ? void 0 : _a[1];
+    if (!value) {
+        throw new Error(`Could not find id for name ${name}`);
+    }
+    return value;
+};
+exports.getIdForName = getIdForName;
+function putUintDynamic(number, minimumLength) {
+    if (number < 0) {
+        throw new Error('This function is designed for non-negative integers only.');
+    }
+    // Calculate the minimum number of bytes needed to store the integer
+    const length = Math.max(minimumLength !== null && minimumLength !== void 0 ? minimumLength : 0, Math.ceil(Math.log2(number + 1) / 8));
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        // Extract each byte from the number
+        bytes[length - 1 - i] = (number >> (8 * i)) & 0xff;
+    }
+    return bytes;
+}
+const makeFromStructure = (fields) => {
+    if ('bytes' in fields) {
+        return fields;
+    }
+    const arrays = [];
+    const struct = media_parser_1.MediaParserInternals.ebmlMap[(0, exports.getIdForName)(fields.type)];
+    if (struct.type === 'uint8array') {
+        return {
+            bytes: fields.value,
+            offsets: { offset: 0, children: [], field: fields.type },
+        };
+    }
+    if (struct.type === 'children') {
+        const children = [];
+        let bytesWritten = 0;
+        for (const item of fields.value) {
+            const { bytes, offsets } = (0, exports.makeMatroskaBytes)(item);
+            arrays.push(bytes);
+            children.push((0, exports.incrementOffsetAndChildren)(offsets, bytesWritten));
+            bytesWritten += bytes.byteLength;
+        }
+        return {
+            bytes: (0, exports.combineUint8Arrays)(arrays),
+            offsets: { offset: 0, children, field: fields.type },
+        };
+    }
+    if (struct.type === 'string') {
+        return {
+            bytes: new TextEncoder().encode(fields.value),
+            offsets: {
+                children: [],
+                offset: 0,
+                field: fields.type,
+            },
+        };
+    }
+    if (struct.type === 'uint') {
+        return {
+            bytes: putUintDynamic(fields.value.value, fields.value.byteLength),
+            offsets: {
+                children: [],
+                offset: 0,
+                field: fields.type,
+            },
+        };
+    }
+    if (struct.type === 'hex-string') {
+        const hex = fields.value.substring(2);
+        const arr = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < hex.length; i += 2) {
+            const byte = parseInt(hex.substring(i, i + 2), 16);
+            arr[i / 2] = byte;
+        }
+        return {
+            bytes: arr,
+            offsets: {
+                children: [],
+                offset: 0,
+                field: fields.type,
+            },
+        };
+    }
+    if (struct.type === 'float') {
+        const value = fields.value;
+        if (value.size === '32') {
+            const dataView = new DataView(new ArrayBuffer(4));
+            dataView.setFloat32(0, value.value);
+            return {
+                bytes: new Uint8Array(dataView.buffer),
+                offsets: {
+                    children: [],
+                    offset: 0,
+                    field: fields.type,
+                },
+            };
+        }
+        const dataView2 = new DataView(new ArrayBuffer(8));
+        dataView2.setFloat64(0, value.value);
+        return {
+            bytes: new Uint8Array(dataView2.buffer),
+            offsets: {
+                children: [],
+                offset: 0,
+                field: fields.type,
+            },
+        };
+    }
+    throw new Error('Unexpected type');
+};
+const combineUint8Arrays = (arrays) => {
+    if (arrays.length === 0) {
+        return new Uint8Array([]);
+    }
+    if (arrays.length === 1) {
+        return arrays[0];
+    }
+    let totalLength = 0;
+    for (const array of arrays) {
+        totalLength += array.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+};
+exports.combineUint8Arrays = combineUint8Arrays;
+const incrementOffsetAndChildren = (offset, increment) => {
+    return {
+        offset: offset.offset + increment,
+        children: offset.children.map((c) => (0, exports.incrementOffsetAndChildren)(c, increment)),
+        field: offset.field,
+    };
+};
+exports.incrementOffsetAndChildren = incrementOffsetAndChildren;
+const matroskaToHex = (matrId) => {
+    const numbers = new Uint8Array((matrId.length - 2) / 2);
+    for (let i = 2; i < matrId.length; i += 2) {
+        const hex = matrId.substring(i, i + 2);
+        numbers[(i - 2) / 2] = parseInt(hex, 16);
+    }
+    return numbers;
+};
+exports.matroskaToHex = matroskaToHex;
+// https://github.com/Vanilagy/webm-muxer/blob/main/src/ebml.ts#L101
+const measureEBMLVarInt = (value) => {
+    if (value < (1 << 7) - 1) {
+        /** Top bit is set, leaving 7 bits to hold the integer, but we can't store
+         * 127 because "all bits set to one" is a reserved value. Same thing for the
+         * other cases below:
+         */
+        return 1;
+    }
+    if (value < (1 << 14) - 1) {
+        return 2;
+    }
+    if (value < (1 << 21) - 1) {
+        return 3;
+    }
+    if (value < (1 << 28) - 1) {
+        return 4;
+    }
+    if (value < 2 ** 35 - 1) {
+        return 5;
+    }
+    if (value < 2 ** 42 - 1) {
+        return 6;
+    }
+    throw new Error('EBML VINT size not supported ' + value);
+};
+exports.measureEBMLVarInt = measureEBMLVarInt;
+const getVariableInt = (value, minWidth) => {
+    const width = Math.max((0, exports.measureEBMLVarInt)(value), minWidth !== null && minWidth !== void 0 ? minWidth : 0);
+    switch (width) {
+        case 1:
+            return new Uint8Array([(1 << 7) | value]);
+        case 2:
+            return new Uint8Array([(1 << 6) | (value >> 8), value]);
+        case 3:
+            return new Uint8Array([(1 << 5) | (value >> 16), value >> 8, value]);
+        case 4:
+            return new Uint8Array([
+                (1 << 4) | (value >> 24),
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 5:
+            /**
+             * JavaScript converts its doubles to 32-bit integers for bitwise
+             * operations, so we need to do a division by 2^32 instead of a
+             * right-shift of 32 to retain those top 3 bits
+             */
+            return new Uint8Array([
+                (1 << 3) | ((value / 2 ** 32) & 0x7),
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 6:
+            return new Uint8Array([
+                (1 << 2) | ((value / 2 ** 40) & 0x3),
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 7:
+            return new Uint8Array([
+                (1 << 1) | ((value / 2 ** 48) & 0x1),
+                (value / 2 ** 40) | 0,
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 8:
+            return new Uint8Array([
+                (1 << 0) | ((value / 2 ** 56) & 0x1),
+                (value / 2 ** 48) | 0,
+                (value / 2 ** 40) | 0,
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        default:
+            throw new Error('Bad EBML VINT size ' + width);
+    }
+};
+exports.getVariableInt = getVariableInt;
+const makeMatroskaBytes = (fields) => {
+    if ('bytes' in fields) {
+        return fields;
+    }
+    const value = makeFromStructure(fields);
+    const header = (0, exports.matroskaToHex)((0, exports.getIdForName)(fields.type));
+    const size = (0, exports.getVariableInt)(value.bytes.length, fields.minVintWidth);
+    const bytes = (0, exports.combineUint8Arrays)([header, size, value.bytes]);
+    return {
+        bytes,
+        offsets: {
+            offset: value.offsets.offset,
+            field: value.offsets.field,
+            children: value.offsets.children.map((c) => {
+                return (0, exports.incrementOffsetAndChildren)(c, header.byteLength + size.byteLength);
+            }),
+        },
+    };
+};
+exports.makeMatroskaBytes = makeMatroskaBytes;
+const padMatroskaBytes = (fields, totalLength) => {
+    const regular = (0, exports.makeMatroskaBytes)(fields);
+    const paddingLength = totalLength -
+        regular.bytes.byteLength -
+        (0, exports.matroskaToHex)(media_parser_1.MediaParserInternals.matroskaElements.Void).byteLength;
+    if (paddingLength < 0) {
+        throw new Error('ooops');
+    }
+    const padding = (0, exports.makeMatroskaBytes)({
+        type: 'Void',
+        value: new Uint8Array(paddingLength).fill(0),
+        minVintWidth: null,
+    });
+    return [
+        regular,
+        {
+            bytes: padding.bytes,
+            offsets: (0, exports.incrementOffsetAndChildren)(padding.offsets, regular.bytes.length),
+        },
+    ];
+};
+exports.padMatroskaBytes = padMatroskaBytes;
+function serializeUint16(value) {
+    const buffer = new ArrayBuffer(2);
+    const view = new DataView(buffer);
+    view.setUint16(0, value);
+    return new Uint8Array(buffer);
+}

package/dist/create/media-fn.d.ts

@@ -0,0 +1,32 @@
+import type { AudioOrVideoSample } from '@remotion/media-parser';
+import type { LogLevel } from '../log';
+import type { WriterInterface } from '../writers/writer';
+import type { MakeTrackAudio, MakeTrackVideo } from './make-track-info';
+import type { ProgressTracker } from './progress-tracker';
+export type MediaFn = {
+    save: () => Promise<Blob>;
+    remove: () => Promise<void>;
+    addSample: (options: {
+        chunk: AudioOrVideoSample;
+        trackNumber: number;
+        isVideo: boolean;
+        codecPrivate: Uint8Array | null;
+    }) => Promise<void>;
+    addTrack: (track: Omit<MakeTrackAudio, 'trackNumber'> | Omit<MakeTrackVideo, 'trackNumber'>) => Promise<{
+        trackNumber: number;
+    }>;
+    addWaitForFinishPromise: (promise: () => Promise<void>) => void;
+    waitForFinish: () => Promise<void>;
+    updateTrackSampleRate: (options: {
+        trackNumber: number;
+        sampleRate: number;
+    }) => void;
+};
+export type MediaFnGeneratorInput = {
+    writer: WriterInterface;
+    onBytesProgress: (totalBytes: number) => void;
+    onMillisecondsProgress: (totalMilliseconds: number) => void;
+    logLevel: LogLevel;
+    filename: string;
+    progressTracker: ProgressTracker;
+};

package/dist/create/progress-tracker.d.ts

@@ -0,0 +1,9 @@
+export declare const makeProgressTracker: () => {
+    registerTrack: (trackNumber: number) => void;
+    getSmallestProgress: () => number;
+    updateTrackProgress: (trackNumber: number, progress: number) => void;
+    waitForProgress: () => Promise<void>;
+    getStartingTimestamp: () => number;
+    setPossibleLowestTimestamp: (timestamp: number) => void;
+};
+export type ProgressTracker = ReturnType<typeof makeProgressTracker>;

package/dist/create/progress-tracker.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeProgressTracker = void 0;
+const event_emitter_1 = require("./event-emitter");
+const with_resolvers_1 = require("./with-resolvers");
+// Make sure to distinguish null and undefined here
+const makeProgressTracker = () => {
+    const trackNumberProgresses = {};
+    const eventEmitter = new event_emitter_1.IoEventEmitter();
+    let startingTimestamp = null;
+    const setPossibleLowestTimestamp = (timestamp) => {
+        if (startingTimestamp === null) {
+            startingTimestamp = timestamp;
+        }
+        else {
+            startingTimestamp = Math.min(startingTimestamp, timestamp);
+        }
+    };
+    const getStartingTimestamp = () => {
+        if (startingTimestamp === null) {
+            throw new Error('No starting timestamp');
+        }
+        return startingTimestamp;
+    };
+    const calculateSmallestProgress = () => {
+        const progressValues = Object.values(trackNumberProgresses).map((p) => {
+            if (p !== null) {
+                return p;
+            }
+            // The starting timestamp might not be 0, it might be very huge
+            // If no sample has arrived yet, we should assume the smallest value
+            // we know as the progress
+            if (startingTimestamp === null) {
+                throw new Error('No progress values to calculate smallest progress from');
+            }
+            return startingTimestamp;
+        });
+        return Math.min(...progressValues);
+    };
+    return {
+        registerTrack: (trackNumber) => {
+            trackNumberProgresses[trackNumber] = null;
+        },
+        getSmallestProgress: calculateSmallestProgress,
+        updateTrackProgress: (trackNumber, progress) => {
+            if (trackNumberProgresses[trackNumber] === undefined) {
+                throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber}`);
+            }
+            trackNumberProgresses[trackNumber] = progress;
+            eventEmitter.dispatchEvent('progress', {
+                smallestProgress: calculateSmallestProgress(),
+            });
+        },
+        waitForProgress: () => {
+            const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+            const on = () => {
+                eventEmitter.removeEventListener('progress', on);
+                resolve();
+            };
+            eventEmitter.addEventListener('progress', on);
+            return promise;
+        },
+        getStartingTimestamp,
+        setPossibleLowestTimestamp,
+    };
+};
+exports.makeProgressTracker = makeProgressTracker;

package/dist/create/timescale.d.ts

@@ -0,0 +1 @@
+export declare const CREATE_WEBM_TIME_SCALE = 1000000;

package/dist/create/timescale.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CREATE_WEBM_TIME_SCALE = void 0;
+exports.CREATE_WEBM_TIME_SCALE = 1000000;

package/dist/create/wav/create-wav.d.ts

@@ -0,0 +1,2 @@
+import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
+export declare const createWav: ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }: MediaFnGeneratorInput) => Promise<MediaFn>;