@remotion/studio-shared 4.0.471 → 4.0.473

package/dist/api-requests.d.ts

@@ -1,7 +1,8 @@
 import type { AudioCodec, ChromeMode, Codec, ColorSpace, LogLevel, PixelFormat, StillImageFormat, VideoImageFormat, X264Preset } from '@remotion/renderer';
 import type { HardwareAccelerationOption } from '@remotion/renderer/client';
-import type { _InternalTypes, CannotUpdateSequenceReason, CanUpdateEffectPropsResponse, CanUpdateSequencePropsResponseFalse, CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, SequenceNodePath, SequencePropsSubscriptionKey, SequenceSchema } from 'remotion';
+import type { _InternalTypes, CannotUpdateSequenceReason, CanUpdateEffectPropsResponse, CanUpdateSequencePropsResponseFalse, CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, ExtrapolateType, SequenceNodePath, SequencePropsSubscriptionKey, SequenceSchema } from 'remotion';
 import type { RecastCodemod, VisualControlChange } from './codemods';
+import type { EffectClipboardParam, EffectClipboardPasteType, EffectClipboardSnapshot } from './effect-clipboard-data';
 import type { PackageManager } from './package-manager';
 import type { ProjectInfo } from './project-info';
 import type { CompletedClientRender, RequiredChromiumOptions } from './render-job';
@@ -163,6 +164,13 @@ export type DeleteStaticFileResponse = {
     success: boolean;
     existed: boolean;
 };
+export type RenameStaticFileRequest = {
+    oldRelativePath: string;
+    newRelativePath: string;
+};
+export type RenameStaticFileResponse = {
+    success: boolean;
+};
 export type CanUpdateDefaultPropsResponse = {
     canUpdate: true;
     currentDefaultProps: Record<string, unknown>;
@@ -219,8 +227,8 @@ export type SaveSequencePropEdit = {
 export type SaveSequencePropsRequest = {
     edits: SaveSequencePropEdit[];
     clientId: string;
-    undoLabel: string | null;
-    redoLabel: string | null;
+    undoLabel: string;
+    redoLabel: string;
 };
 export type SaveSequencePropsResult = {
     fileName: string;
@@ -235,16 +243,22 @@ export type SaveSequencePropsResponse = {
     canUpdate: false;
     reason: CannotUpdateSequenceReason;
 };
-export type SaveEffectPropsRequest = {
+type SaveEffectPropsRequestBase = {
     fileName: string;
     sequenceNodePath: SequencePropsSubscriptionKey;
     effectIndex: number;
     key: string;
-    value: string;
     defaultValue: string | null;
     schema: SequenceSchema;
     clientId: string;
 };
+export type SaveEffectPropsRequest = (SaveEffectPropsRequestBase & {
+    type: 'value';
+    value: string;
+}) | (SaveEffectPropsRequestBase & {
+    type: 'effect-param';
+    effectParam: EffectClipboardParam;
+});
 export type SaveEffectPropsResponse = CanUpdateEffectPropsResponse;
 export type AddEffectRequest = {
     fileName: string;
@@ -275,6 +289,21 @@ export type ReorderEffectResponse = {
     reason: string;
     stack: string;
 };
+export type ReorderSequencePosition = 'before' | 'after';
+export type ReorderSequenceRequest = {
+    fileName: string;
+    sourceNodePath: SequencePropsSubscriptionKey;
+    targetNodePath: SequencePropsSubscriptionKey;
+    position: ReorderSequencePosition;
+    clientId: string;
+};
+export type ReorderSequenceResponse = {
+    success: true;
+} | {
+    success: false;
+    reason: string;
+    stack: string;
+};
 export type DeleteSequenceKeyframe = {
     fileName: string;
     nodePath: SequencePropsSubscriptionKey;
@@ -282,6 +311,14 @@ export type DeleteSequenceKeyframe = {
     frame: number;
     schema: SequenceSchema;
 };
+export type MoveSequenceKeyframe = {
+    fileName: string;
+    nodePath: SequencePropsSubscriptionKey;
+    key: string;
+    fromFrame: number;
+    toFrame: number;
+    schema: SequenceSchema;
+};
 export type AddSequenceKeyframeRequest = {
     fileName: string;
     nodePath: SequencePropsSubscriptionKey;
@@ -300,6 +337,15 @@ export type DeleteEffectKeyframe = {
     frame: number;
     schema: SequenceSchema;
 };
+export type MoveEffectKeyframe = {
+    fileName: string;
+    sequenceNodePath: SequencePropsSubscriptionKey;
+    effectIndex: number;
+    key: string;
+    fromFrame: number;
+    toFrame: number;
+    schema: SequenceSchema;
+};
 export type DeleteKeyframesRequest = {
     sequenceKeyframes: DeleteSequenceKeyframe[];
     effectKeyframes: DeleteEffectKeyframe[];
@@ -308,6 +354,14 @@ export type DeleteKeyframesRequest = {
 export type DeleteKeyframesResponse = {
     success: true;
 };
+export type MoveKeyframesRequest = {
+    sequenceKeyframes: MoveSequenceKeyframe[];
+    effectKeyframes: MoveEffectKeyframe[];
+    clientId: string;
+};
+export type MoveKeyframesResponse = {
+    success: true;
+};
 export type AddEffectKeyframeRequest = {
     fileName: string;
     sequenceNodePath: SequencePropsSubscriptionKey;
@@ -319,6 +373,32 @@ export type AddEffectKeyframeRequest = {
     clientId: string;
 };
 export type AddEffectKeyframeResponse = SaveEffectPropsResponse;
+export type KeyframeSettings = {
+    clamping: {
+        left: ExtrapolateType;
+        right: ExtrapolateType;
+    } | undefined;
+    posterize: number | undefined;
+};
+export type UpdateSequenceKeyframeSettingsRequest = {
+    fileName: string;
+    nodePath: SequencePropsSubscriptionKey;
+    key: string;
+    settings: KeyframeSettings;
+    schema: SequenceSchema;
+    clientId: string;
+};
+export type UpdateSequenceKeyframeSettingsResponse = SaveSequencePropsResponse;
+export type UpdateEffectKeyframeSettingsRequest = {
+    fileName: string;
+    sequenceNodePath: SequencePropsSubscriptionKey;
+    effectIndex: number;
+    key: string;
+    settings: KeyframeSettings;
+    schema: SequenceSchema;
+    clientId: string;
+};
+export type UpdateEffectKeyframeSettingsResponse = SaveEffectPropsResponse;
 type BaseDeleteEffectRequestItem = {
     fileName: string;
     sequenceNodePath: SequencePropsSubscriptionKey;
@@ -337,6 +417,20 @@ export type DeleteEffectResponse = {
     reason: string;
     stack: string;
 };
+export type PasteEffectsRequest = {
+    targetFileName: string;
+    targetSequenceNodePath: SequencePropsSubscriptionKey;
+    type: EffectClipboardPasteType;
+    effects: EffectClipboardSnapshot[];
+    clientId: string;
+};
+export type PasteEffectsResponse = {
+    success: true;
+} | {
+    success: false;
+    reason: string;
+    stack: string;
+};
 export type DeleteJsxNodeRequestItem = {
     fileName: string;
     nodePath: SequenceNodePath;
@@ -366,6 +460,14 @@ export type InsertableCompositionElement = {
     type: 'solid';
     width: number;
     height: number;
+} | {
+    type: 'asset';
+    assetType: 'image' | 'video' | 'gif' | 'audio';
+    src: string;
+    dimensions: {
+        width: number;
+        height: number;
+    } | null;
 };
 export type InsertJsxElementRequest = {
     compositionFile: string;
@@ -379,6 +481,15 @@ export type InsertJsxElementResponse = {
     reason: string;
     stack: string;
 };
+export type DownloadRemoteAssetRequest = {
+    url: string;
+};
+export type DownloadRemoteAssetResponse = {
+    assetPath: string;
+    sizeInBytes: number;
+    created: boolean;
+    element: InsertableCompositionElement;
+};
 export type UpdateAvailableRequest = {};
 export type UpdateAvailableResponse = {
     currentVersion: string;
@@ -411,6 +522,13 @@ export type RedoResponse = {
     success: false;
     reason: string;
 };
+export type LogStudioErrorRequest = {
+    name: string | null;
+    message: string;
+    stack: string | null;
+    symbolicatedStackFrames: SymbolicatedStackFrame[] | null;
+};
+export type LogStudioErrorResponse = {};
 export type ApiRoutes = {
     '/api/composition-component-info': ReqAndRes<CompositionComponentInfoRequest, CompositionComponentInfoResponse>;
     '/api/cancel': ReqAndRes<CancelRenderRequest, CancelRenderResponse>;
@@ -434,20 +552,28 @@ export type ApiRoutes = {
     '/api/save-effect-props': ReqAndRes<SaveEffectPropsRequest, SaveEffectPropsResponse>;
     '/api/add-effect': ReqAndRes<AddEffectRequest, AddEffectResponse>;
     '/api/reorder-effect': ReqAndRes<ReorderEffectRequest, ReorderEffectResponse>;
+    '/api/reorder-sequence': ReqAndRes<ReorderSequenceRequest, ReorderSequenceResponse>;
     '/api/delete-keyframes': ReqAndRes<DeleteKeyframesRequest, DeleteKeyframesResponse>;
+    '/api/move-keyframes': ReqAndRes<MoveKeyframesRequest, MoveKeyframesResponse>;
     '/api/add-sequence-keyframe': ReqAndRes<AddSequenceKeyframeRequest, AddSequenceKeyframeResponse>;
     '/api/add-effect-keyframe': ReqAndRes<AddEffectKeyframeRequest, AddEffectKeyframeResponse>;
+    '/api/update-sequence-keyframe-settings': ReqAndRes<UpdateSequenceKeyframeSettingsRequest, UpdateSequenceKeyframeSettingsResponse>;
+    '/api/update-effect-keyframe-settings': ReqAndRes<UpdateEffectKeyframeSettingsRequest, UpdateEffectKeyframeSettingsResponse>;
     '/api/delete-effect': ReqAndRes<DeleteEffectRequest, DeleteEffectResponse>;
+    '/api/paste-effects': ReqAndRes<PasteEffectsRequest, PasteEffectsResponse>;
     '/api/delete-jsx-node': ReqAndRes<DeleteJsxNodeRequest, DeleteJsxNodeResponse>;
     '/api/duplicate-jsx-node': ReqAndRes<DuplicateJsxNodeRequest, DuplicateJsxNodeResponse>;
     '/api/insert-jsx-element': ReqAndRes<InsertJsxElementRequest, InsertJsxElementResponse>;
+    '/api/download-remote-asset': ReqAndRes<DownloadRemoteAssetRequest, DownloadRemoteAssetResponse>;
     '/api/update-available': ReqAndRes<UpdateAvailableRequest, UpdateAvailableResponse>;
     '/api/apply-codemod': ReqAndRes<ApplyCodemodRequest, ApplyCodemodResponse>;
     '/api/project-info': ReqAndRes<ProjectInfoRequest, ProjectInfoResponse>;
     '/api/delete-static-file': ReqAndRes<DeleteStaticFileRequest, DeleteStaticFileResponse>;
+    '/api/rename-static-file': ReqAndRes<RenameStaticFileRequest, RenameStaticFileResponse>;
     '/api/restart-studio': ReqAndRes<RestartStudioRequest, RestartStudioResponse>;
     '/api/install-package': ReqAndRes<InstallPackageRequest, InstallPackageResponse>;
     '/api/undo': ReqAndRes<UndoRequest, UndoResponse>;
     '/api/redo': ReqAndRes<RedoRequest, RedoResponse>;
+    '/api/log-studio-error': ReqAndRes<LogStudioErrorRequest, LogStudioErrorResponse>;
 };
 export {};

package/dist/asset-drag-data.d.ts

@@ -0,0 +1,8 @@
+export declare const ASSET_DRAG_MIME_TYPE = "application/vnd.remotion.asset+json";
+export type AssetDragData = {
+    type: 'remotion-asset';
+    version: 1;
+    assetPath: string;
+};
+export declare const makeAssetDragData: (assetPath: string) => AssetDragData;
+export declare const parseAssetDragData: (value: string) => AssetDragData | null;

package/dist/asset-drag-data.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAssetDragData = exports.makeAssetDragData = exports.ASSET_DRAG_MIME_TYPE = void 0;
+exports.ASSET_DRAG_MIME_TYPE = 'application/vnd.remotion.asset+json';
+const isRecord = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const makeAssetDragData = (assetPath) => {
+    return {
+        type: 'remotion-asset',
+        version: 1,
+        assetPath,
+    };
+};
+exports.makeAssetDragData = makeAssetDragData;
+const parseAssetDragData = (value) => {
+    try {
+        const parsed = JSON.parse(value);
+        if (!isRecord(parsed)) {
+            return null;
+        }
+        if (parsed.type !== 'remotion-asset' || parsed.version !== 1) {
+            return null;
+        }
+        if (typeof parsed.assetPath !== 'string' || parsed.assetPath.length === 0) {
+            return null;
+        }
+        return {
+            type: 'remotion-asset',
+            version: 1,
+            assetPath: parsed.assetPath,
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+exports.parseAssetDragData = parseAssetDragData;

package/dist/codemods.d.ts

@@ -25,4 +25,13 @@ export type RecastCodemod = {
 } | {
     type: 'delete-composition';
     idToDelete: string;
+} | {
+    type: 'rename-folder';
+    folderName: string;
+    parentName: string | null;
+    newName: string;
+} | {
+    type: 'delete-folder';
+    folderName: string;
+    parentName: string | null;
 } | ApplyVisualControlCodemod;

package/dist/detect-file-type.d.ts

@@ -0,0 +1,71 @@
+export type FileDimensions = {
+    readonly width: number;
+    readonly height: number;
+};
+export declare const matchesPattern: (pattern: Uint8Array<ArrayBufferLike>) => (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isRiffAvi: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isRiffWave: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isWebm: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isIsoBaseMedia: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isTransportStream: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isMp3: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isAac: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isFlac: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isM3u: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export type RiffType = {
+    type: 'riff';
+};
+export type WebmType = {
+    type: 'webm';
+};
+export type IsoBaseMediaType = {
+    type: 'iso-base-media';
+};
+export type TransportStreamType = {
+    type: 'transport-stream';
+};
+export type Mp3Type = {
+    type: 'mp3';
+};
+export type AacType = {
+    type: 'aac';
+};
+export type WavType = {
+    type: 'wav';
+};
+export type GifType = {
+    type: 'gif';
+    dimensions: FileDimensions | null;
+};
+export type FlacType = {
+    type: 'flac';
+};
+export type M3uType = {
+    type: 'm3u';
+};
+export type PngType = {
+    type: 'png';
+    dimensions: FileDimensions | null;
+};
+export type JpegType = {
+    type: 'jpeg';
+    dimensions: FileDimensions | null;
+};
+export type WebpType = {
+    type: 'webp';
+    dimensions: FileDimensions | null;
+};
+export type BmpType = {
+    type: 'bmp';
+    dimensions: FileDimensions | null;
+};
+export type PdfType = {
+    type: 'pdf';
+};
+export type UnknownType = {
+    type: 'unknown';
+};
+export type FileType = JpegType | WebpType | RiffType | WebmType | WavType | PdfType | AacType | IsoBaseMediaType | TransportStreamType | Mp3Type | GifType | PngType | BmpType | AacType | FlacType | M3uType | UnknownType;
+export type ImageFileType = JpegType | WebpType | GifType | PngType | BmpType;
+export declare const isImageFileType: (fileType: FileType) => fileType is ImageFileType;
+export declare const detectFileType: (data: Uint8Array<ArrayBufferLike>) => FileType;

package/dist/detect-file-type.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFileType = exports.isImageFileType = exports.isM3u = exports.isFlac = exports.isAac = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
+const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
+const matchesPattern = (pattern) => {
+    return (data) => {
+        return pattern.every((value, index) => data[index] === value);
+    };
+};
+exports.matchesPattern = matchesPattern;
+const isRiffAvi = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+        return false;
+    }
+    const fileType = data.subarray(8, 12);
+    const aviPattern = new Uint8Array([0x41, 0x56, 0x49, 0x20]);
+    return (0, exports.matchesPattern)(aviPattern)(fileType);
+};
+exports.isRiffAvi = isRiffAvi;
+const isRiffWave = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+        return false;
+    }
+    const fileType = data.subarray(8, 12);
+    const wavePattern = new Uint8Array([0x57, 0x41, 0x56, 0x45]);
+    return (0, exports.matchesPattern)(wavePattern)(fileType);
+};
+exports.isRiffWave = isRiffWave;
+const isWebm = (data) => {
+    return (0, exports.matchesPattern)(webmPattern)(data.subarray(0, 4));
+};
+exports.isWebm = isWebm;
+const isIsoBaseMedia = (data) => {
+    const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
+    return (0, exports.matchesPattern)(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+exports.isIsoBaseMedia = isIsoBaseMedia;
+const isTransportStream = (data) => {
+    return data[0] === 0x47 && data[188] === 0x47;
+};
+exports.isTransportStream = isTransportStream;
+const isMp3 = (data) => {
+    const mpegPattern = new Uint8Array([0xff, 0xf3]);
+    const mpegPattern2 = new Uint8Array([0xff, 0xfb]);
+    const id3v4Pattern = new Uint8Array([0x49, 0x44, 0x33, 4]);
+    const id3v3Pattern = new Uint8Array([0x49, 0x44, 0x33, 3]);
+    const id3v2Pattern = new Uint8Array([0x49, 0x44, 0x33, 2]);
+    const subarray = data.subarray(0, 4);
+    return ((0, exports.matchesPattern)(mpegPattern)(subarray) ||
+        (0, exports.matchesPattern)(mpegPattern2)(subarray) ||
+        (0, exports.matchesPattern)(id3v4Pattern)(subarray) ||
+        (0, exports.matchesPattern)(id3v3Pattern)(subarray) ||
+        (0, exports.matchesPattern)(id3v2Pattern)(subarray));
+};
+exports.isMp3 = isMp3;
+const isAac = (data) => {
+    const aacPattern = new Uint8Array([0xff, 0xf1]);
+    return (0, exports.matchesPattern)(aacPattern)(data.subarray(0, 2));
+};
+exports.isAac = isAac;
+const isFlac = (data) => {
+    const flacPattern = new Uint8Array([0x66, 0x4c, 0x61, 0x43]);
+    return (0, exports.matchesPattern)(flacPattern)(data.subarray(0, 4));
+};
+exports.isFlac = isFlac;
+const isM3u = (data) => {
+    return new TextDecoder('utf-8').decode(data.slice(0, 7)) === '#EXTM3U';
+};
+exports.isM3u = isM3u;
+const getPngDimensions = (pngData) => {
+    if (pngData.length < 24) {
+        return null;
+    }
+    const view = new DataView(pngData.buffer, pngData.byteOffset);
+    const pngSignature = [137, 80, 78, 71, 13, 10, 26, 10];
+    for (let i = 0; i < 8; i++) {
+        if (pngData[i] !== pngSignature[i]) {
+            return null;
+        }
+    }
+    return {
+        width: view.getUint32(16, false),
+        height: view.getUint32(20, false),
+    };
+};
+const isPng = (data) => {
+    const pngPattern = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+    if ((0, exports.matchesPattern)(pngPattern)(data.subarray(0, 4))) {
+        const png = getPngDimensions(data);
+        return { dimensions: png, type: 'png' };
+    }
+    return null;
+};
+const getJpegDimensions = (data) => {
+    let offset = 0;
+    const readUint16BE = (o) => {
+        return (data[o] << 8) | data[o + 1];
+    };
+    if (data.length < 4 || readUint16BE(offset) !== 0xffd8) {
+        return null;
+    }
+    offset += 2;
+    while (offset + 3 < data.length) {
+        if (data[offset] === 0xff) {
+            const marker = data[offset + 1];
+            if (marker === 0xc0 || marker === 0xc2) {
+                if (offset + 8 >= data.length) {
+                    return null;
+                }
+                const height = readUint16BE(offset + 5);
+                const width = readUint16BE(offset + 7);
+                return { width, height };
+            }
+            const length = readUint16BE(offset + 2);
+            if (length <= 0) {
+                return null;
+            }
+            offset += length + 2;
+        }
+        else {
+            offset++;
+        }
+    }
+    return null;
+};
+const isJpeg = (data) => {
+    const jpegPattern = new Uint8Array([0xff, 0xd8]);
+    const jpeg = (0, exports.matchesPattern)(jpegPattern)(data.subarray(0, 2));
+    if (!jpeg) {
+        return null;
+    }
+    const dim = getJpegDimensions(data);
+    return { dimensions: dim, type: 'jpeg' };
+};
+const getGifDimensions = (data) => {
+    if (data.length < 10) {
+        return null;
+    }
+    const view = new DataView(data.buffer, data.byteOffset);
+    const width = view.getUint16(6, true);
+    const height = view.getUint16(8, true);
+    return { width, height };
+};
+const isGif = (data) => {
+    const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
+    if ((0, exports.matchesPattern)(gifPattern)(data.subarray(0, 4))) {
+        return { type: 'gif', dimensions: getGifDimensions(data) };
+    }
+    return null;
+};
+const getWebPDimensions = (bytes) => {
+    if (bytes.length < 30) {
+        return null;
+    }
+    if (bytes[0] !== 0x52 ||
+        bytes[1] !== 0x49 ||
+        bytes[2] !== 0x46 ||
+        bytes[3] !== 0x46 ||
+        bytes[8] !== 0x57 ||
+        bytes[9] !== 0x45 ||
+        bytes[10] !== 0x42 ||
+        bytes[11] !== 0x50) {
+        return null;
+    }
+    if (bytes[12] === 0x56 && bytes[13] === 0x50 && bytes[14] === 0x38) {
+        if (bytes[15] === 0x20) {
+            return {
+                width: bytes[26] | ((bytes[27] << 8) & 0x3fff),
+                height: bytes[28] | ((bytes[29] << 8) & 0x3fff),
+            };
+        }
+    }
+    if (bytes[12] === 0x56 &&
+        bytes[13] === 0x50 &&
+        bytes[14] === 0x38 &&
+        bytes[15] === 0x4c) {
+        return {
+            width: 1 + (bytes[21] | ((bytes[22] & 0x3f) << 8)),
+            height: 1 +
+                (((bytes[22] & 0xc0) >> 6) |
+                    (bytes[23] << 2) |
+                    ((bytes[24] & 0x0f) << 10)),
+        };
+    }
+    if (bytes[12] === 0x56 &&
+        bytes[13] === 0x50 &&
+        bytes[14] === 0x38 &&
+        bytes[15] === 0x58) {
+        return {
+            width: 1 + (bytes[24] | (bytes[25] << 8) | (bytes[26] << 16)),
+            height: 1 + (bytes[27] | (bytes[28] << 8) | (bytes[29] << 16)),
+        };
+    }
+    return null;
+};
+const isWebp = (data) => {
+    const webpPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if ((0, exports.matchesPattern)(webpPattern)(data.subarray(0, 4))) {
+        return {
+            type: 'webp',
+            dimensions: getWebPDimensions(data),
+        };
+    }
+    return null;
+};
+const getBmpDimensions = (bmpData) => {
+    if (bmpData.length < 26) {
+        return null;
+    }
+    const view = new DataView(bmpData.buffer, bmpData.byteOffset);
+    return {
+        width: view.getUint32(18, true),
+        height: Math.abs(view.getInt32(22, true)),
+    };
+};
+const isBmp = (data) => {
+    const bmpPattern = new Uint8Array([0x42, 0x4d]);
+    if ((0, exports.matchesPattern)(bmpPattern)(data.subarray(0, 2))) {
+        const bmp = getBmpDimensions(data);
+        return { dimensions: bmp, type: 'bmp' };
+    }
+    return null;
+};
+const isPdf = (data) => {
+    if (data.length < 4) {
+        return null;
+    }
+    const pdfPattern = new Uint8Array([0x25, 0x50, 0x44, 0x46]);
+    return (0, exports.matchesPattern)(pdfPattern)(data.subarray(0, 4)) ? { type: 'pdf' } : null;
+};
+const isImageFileType = (fileType) => {
+    return (fileType.type === 'jpeg' ||
+        fileType.type === 'webp' ||
+        fileType.type === 'gif' ||
+        fileType.type === 'png' ||
+        fileType.type === 'bmp');
+};
+exports.isImageFileType = isImageFileType;
+const detectFileType = (data) => {
+    if ((0, exports.isRiffWave)(data)) {
+        return { type: 'wav' };
+    }
+    if ((0, exports.isRiffAvi)(data)) {
+        return { type: 'riff' };
+    }
+    if ((0, exports.isAac)(data)) {
+        return { type: 'aac' };
+    }
+    if ((0, exports.isFlac)(data)) {
+        return { type: 'flac' };
+    }
+    if ((0, exports.isM3u)(data)) {
+        return { type: 'm3u' };
+    }
+    const webp = isWebp(data);
+    if (webp) {
+        return webp;
+    }
+    if ((0, exports.isWebm)(data)) {
+        return { type: 'webm' };
+    }
+    if ((0, exports.isIsoBaseMedia)(data)) {
+        return { type: 'iso-base-media' };
+    }
+    if ((0, exports.isTransportStream)(data)) {
+        return { type: 'transport-stream' };
+    }
+    if ((0, exports.isMp3)(data)) {
+        return { type: 'mp3' };
+    }
+    const gif = isGif(data);
+    if (gif) {
+        return gif;
+    }
+    const png = isPng(data);
+    if (png) {
+        return png;
+    }
+    const pdf = isPdf(data);
+    if (pdf) {
+        return pdf;
+    }
+    const bmp = isBmp(data);
+    if (bmp) {
+        return bmp;
+    }
+    const jpeg = isJpeg(data);
+    if (jpeg) {
+        return jpeg;
+    }
+    return { type: 'unknown' };
+};
+exports.detectFileType = detectFileType;