@h3l1os/mp4vault 2.0.0

package/dist/index.d.cts

@@ -0,0 +1,261 @@
+interface IReadable {
+    isPrepared(): boolean;
+    prepare(): Promise<void>;
+    close(): Promise<void>;
+    getSlice(offset: number, length: number): Promise<Uint8Array>;
+    size(): Promise<number>;
+}
+interface IWritable {
+    size(): number;
+    prepare(): Promise<void>;
+    close(): Promise<void>;
+    write(data: Uint8Array | number[]): Promise<void>;
+    saveToFile(filename: string): Promise<void>;
+    toReadable(): Promise<IReadable>;
+}
+interface FileRecord {
+    filename: string;
+    size: number;
+    meta?: Record<string, unknown>;
+    isEncrypted?: boolean;
+    offset?: number;
+}
+
+declare class Atom {
+    readable: IReadable | null;
+    name: string;
+    start: number;
+    size: number;
+    header_size: number;
+    mother: Atom | null;
+    children: Atom[];
+    contents: number[] | null;
+    constructor(params: {
+        readable?: IReadable;
+        name: string;
+        start: number;
+        size: number;
+        header_size: number;
+        mother?: Atom | null;
+    });
+    findAtoms(atoms: Atom[] | null, name: string): Atom[];
+    unpackFromOffset(offset: number, length: number, fmt: string): Promise<number[]>;
+    isVideo(): boolean;
+    isAudio(): boolean;
+    getChunkOffsets(): Promise<number[]>;
+    writeHeader(writable: IWritable): Promise<void>;
+    writePayload(writable: IWritable): Promise<void>;
+    write(writable: IWritable): Promise<void>;
+}
+
+declare class MP4 {
+    private _analyzed;
+    _readable: IReadable | null;
+    private _embed;
+    private _key;
+    private _password;
+    _atoms: Atom[];
+    private _initialMdatStart;
+    private _initialEmbed;
+    getEmbedFiles(): FileRecord[];
+    setKey(key: Buffer): void;
+    setPassword(password: string): void;
+    loadFile(params: {
+        filename: string;
+    }): Promise<void>;
+    embedFile(params: {
+        filename?: string;
+        file?: {
+            name?: string;
+        };
+        meta?: Record<string, unknown>;
+        key?: Buffer | null;
+        password?: string | null;
+    }): Promise<void>;
+    getExpectedSize(): Promise<number>;
+    adjustSampleOffsets(offset: number): Promise<void>;
+    extractEmbedHeader(): Promise<void>;
+    extractFile(n: number, writable?: IWritable | null): Promise<IWritable>;
+    embed(writable?: IWritable): Promise<IWritable>;
+    analyzeFile(): Promise<Atom[]>;
+    printAtoms(atoms?: Atom[], level?: number): void;
+    findAtom(name: string): Atom | null;
+    findAtoms(atoms: Atom[] | null, name: string): Atom[];
+    parseAtoms(start: number, end: number, mother: Atom | null): Promise<Atom[]>;
+}
+
+interface AESParams {
+    key?: Buffer | Uint8Array;
+    password?: string;
+    iv?: Buffer;
+    salt?: Buffer;
+    authTag?: Buffer;
+}
+declare class AES {
+    static readonly ivByteLength = 12;
+    static readonly saltByteLength = 16;
+    static readonly authTagByteLength = 16;
+    private _key;
+    private _iv;
+    private _salt;
+    private _authTag;
+    private _cipher;
+    private _decipher;
+    constructor(params: AESParams);
+    private static _normalizeKey;
+    private static _algorithmForKey;
+    static deriveKey(password: string, salt: Buffer): Buffer;
+    encrypt(chunk: Buffer | null, finalize?: boolean): Buffer;
+    decrypt(chunk: Buffer | null, finalize?: boolean): Buffer;
+    getAuthTag(): Buffer;
+    getIV(): Buffer;
+    getSalt(): Buffer | null;
+}
+
+declare class Convert {
+    static randomByteIn(maxOptions: number, option: number): number;
+    static isByteIn(byte: number, maxOptions: number, option: number): boolean;
+    static objectToBuffer(object: unknown): Buffer;
+    static bufferToObject(buffer: Buffer | Uint8Array): unknown;
+    static hexStringToBuffer(str: string): Buffer;
+}
+
+declare class EmbedObject {
+    _object: Record<string, unknown> | null;
+    private _binary;
+    private _key;
+    private _password;
+    private _iv;
+    private _salt;
+    private _readBytes;
+    private _encryptor;
+    constructor(params?: {
+        object?: Record<string, unknown>;
+        key?: Buffer | null;
+        password?: string | null;
+        iv?: Buffer | null;
+        salt?: Buffer | null;
+        readBytes?: number;
+    });
+    get readBytes(): number;
+    getExpectedSize(): Promise<number>;
+    get object(): Record<string, unknown> | null;
+    getEncryptor(): AES;
+    getIV(): Buffer;
+    static restoreFromReadable(readable: IReadable, params?: {
+        key?: Buffer;
+        password?: string | null;
+        object?: Record<string, unknown>;
+        readBytes?: number;
+        iv?: Buffer;
+        salt?: Buffer;
+    }, offset?: number): Promise<EmbedObject>;
+    writeTo(writable: IWritable): Promise<void>;
+    getBinary(): Uint8Array;
+    getRaw(): Uint8Array;
+    getEncrypted(): Uint8Array;
+}
+
+declare class Embed {
+    private _files;
+    private _headerEmbed;
+    _publicHeaderEmbed: EmbedObject | null;
+    hasEncryptedFiles: boolean;
+    hasPublicFiles: boolean;
+    private _key;
+    private _password;
+    constructor(params?: {
+        mp4?: unknown;
+        key?: Buffer | null;
+        password?: string | null;
+    });
+    private basename;
+    addFile(params: {
+        file?: {
+            name?: string;
+        };
+        filename?: string | null;
+        meta?: Record<string, unknown>;
+        key?: Buffer | null;
+        password?: string | null;
+    }): Promise<void>;
+    composeHeader(): Promise<boolean>;
+    getExpectedSize(): Promise<number>;
+    writeTo(writable: IWritable): Promise<void>;
+    restoreFromReadable(readable: IReadable, params?: {
+        key?: Buffer;
+        password?: string | null;
+    }, offset?: number): Promise<void>;
+    getFilesToExtract(): FileRecord[];
+    restoreBinary(readable: IReadable, params: {
+        key?: Buffer;
+        password?: string | undefined;
+    }, n: number, offset: number, writable?: IWritable | null): Promise<IWritable>;
+}
+
+declare class EmbedBinary {
+    _readable: IReadable | null;
+    private _key;
+    private _password;
+    private _iv;
+    private _salt;
+    private _encryptor;
+    constructor(params?: {
+        readable?: IReadable;
+        filename?: string;
+        file?: {
+            name?: string;
+        };
+        key?: Buffer | null;
+        password?: string | null;
+        iv?: Buffer | null;
+        salt?: Buffer | null;
+    });
+    getExpectedSize(): Promise<number>;
+    getEncryptor(): AES;
+    getIV(): Buffer;
+    static restoreFromReadable(readable: IReadable, params?: {
+        key?: Buffer;
+        password?: string;
+    }, offset?: number, size?: number | null, writable?: IWritable | null): Promise<IWritable>;
+    writeTo(writable: IWritable): Promise<void>;
+}
+
+declare class Pack {
+    static pack(format: string, values: unknown[]): number[];
+    static unpack(format: string, buffer: Uint8Array | number[]): number[];
+}
+
+declare class Readable implements IReadable {
+    private _filename;
+    private _prepared;
+    private _size;
+    private _fp;
+    constructor(params?: {
+        filename?: string;
+    });
+    isPrepared(): boolean;
+    prepare(): Promise<void>;
+    close(): Promise<void>;
+    getSlice(offset: number, length: number): Promise<Uint8Array>;
+    size(): Promise<number>;
+}
+
+declare class Writable implements IWritable {
+    private _uint8Array;
+    private _filename;
+    private _prepared;
+    private _bytesWrote;
+    private _fp;
+    constructor(params?: {
+        filename?: string;
+    });
+    size(): number;
+    prepare(): Promise<void>;
+    close(): Promise<void>;
+    saveToFile(filename: string): Promise<void>;
+    write(append: Uint8Array | number[]): Promise<void>;
+    toReadable(): Promise<IReadable>;
+}
+
+export { AES, Atom, Convert, Embed, EmbedBinary, EmbedObject, type FileRecord, type IReadable, type IWritable, MP4, Pack, Readable, Writable };

package/dist/index.d.ts

@@ -0,0 +1,261 @@
+interface IReadable {
+    isPrepared(): boolean;
+    prepare(): Promise<void>;
+    close(): Promise<void>;
+    getSlice(offset: number, length: number): Promise<Uint8Array>;
+    size(): Promise<number>;
+}
+interface IWritable {
+    size(): number;
+    prepare(): Promise<void>;
+    close(): Promise<void>;
+    write(data: Uint8Array | number[]): Promise<void>;
+    saveToFile(filename: string): Promise<void>;
+    toReadable(): Promise<IReadable>;
+}
+interface FileRecord {
+    filename: string;
+    size: number;
+    meta?: Record<string, unknown>;
+    isEncrypted?: boolean;
+    offset?: number;
+}
+
+declare class Atom {
+    readable: IReadable | null;
+    name: string;
+    start: number;
+    size: number;
+    header_size: number;
+    mother: Atom | null;
+    children: Atom[];
+    contents: number[] | null;
+    constructor(params: {
+        readable?: IReadable;
+        name: string;
+        start: number;
+        size: number;
+        header_size: number;
+        mother?: Atom | null;
+    });
+    findAtoms(atoms: Atom[] | null, name: string): Atom[];
+    unpackFromOffset(offset: number, length: number, fmt: string): Promise<number[]>;
+    isVideo(): boolean;
+    isAudio(): boolean;
+    getChunkOffsets(): Promise<number[]>;
+    writeHeader(writable: IWritable): Promise<void>;
+    writePayload(writable: IWritable): Promise<void>;
+    write(writable: IWritable): Promise<void>;
+}
+
+declare class MP4 {
+    private _analyzed;
+    _readable: IReadable | null;
+    private _embed;
+    private _key;
+    private _password;
+    _atoms: Atom[];
+    private _initialMdatStart;
+    private _initialEmbed;
+    getEmbedFiles(): FileRecord[];
+    setKey(key: Buffer): void;
+    setPassword(password: string): void;
+    loadFile(params: {
+        filename: string;
+    }): Promise<void>;
+    embedFile(params: {
+        filename?: string;
+        file?: {
+            name?: string;
+        };
+        meta?: Record<string, unknown>;
+        key?: Buffer | null;
+        password?: string | null;
+    }): Promise<void>;
+    getExpectedSize(): Promise<number>;
+    adjustSampleOffsets(offset: number): Promise<void>;
+    extractEmbedHeader(): Promise<void>;
+    extractFile(n: number, writable?: IWritable | null): Promise<IWritable>;
+    embed(writable?: IWritable): Promise<IWritable>;
+    analyzeFile(): Promise<Atom[]>;
+    printAtoms(atoms?: Atom[], level?: number): void;
+    findAtom(name: string): Atom | null;
+    findAtoms(atoms: Atom[] | null, name: string): Atom[];
+    parseAtoms(start: number, end: number, mother: Atom | null): Promise<Atom[]>;
+}
+
+interface AESParams {
+    key?: Buffer | Uint8Array;
+    password?: string;
+    iv?: Buffer;
+    salt?: Buffer;
+    authTag?: Buffer;
+}
+declare class AES {
+    static readonly ivByteLength = 12;
+    static readonly saltByteLength = 16;
+    static readonly authTagByteLength = 16;
+    private _key;
+    private _iv;
+    private _salt;
+    private _authTag;
+    private _cipher;
+    private _decipher;
+    constructor(params: AESParams);
+    private static _normalizeKey;
+    private static _algorithmForKey;
+    static deriveKey(password: string, salt: Buffer): Buffer;
+    encrypt(chunk: Buffer | null, finalize?: boolean): Buffer;
+    decrypt(chunk: Buffer | null, finalize?: boolean): Buffer;
+    getAuthTag(): Buffer;
+    getIV(): Buffer;
+    getSalt(): Buffer | null;
+}
+
+declare class Convert {
+    static randomByteIn(maxOptions: number, option: number): number;
+    static isByteIn(byte: number, maxOptions: number, option: number): boolean;
+    static objectToBuffer(object: unknown): Buffer;
+    static bufferToObject(buffer: Buffer | Uint8Array): unknown;
+    static hexStringToBuffer(str: string): Buffer;
+}
+
+declare class EmbedObject {
+    _object: Record<string, unknown> | null;
+    private _binary;
+    private _key;
+    private _password;
+    private _iv;
+    private _salt;
+    private _readBytes;
+    private _encryptor;
+    constructor(params?: {
+        object?: Record<string, unknown>;
+        key?: Buffer | null;
+        password?: string | null;
+        iv?: Buffer | null;
+        salt?: Buffer | null;
+        readBytes?: number;
+    });
+    get readBytes(): number;
+    getExpectedSize(): Promise<number>;
+    get object(): Record<string, unknown> | null;
+    getEncryptor(): AES;
+    getIV(): Buffer;
+    static restoreFromReadable(readable: IReadable, params?: {
+        key?: Buffer;
+        password?: string | null;
+        object?: Record<string, unknown>;
+        readBytes?: number;
+        iv?: Buffer;
+        salt?: Buffer;
+    }, offset?: number): Promise<EmbedObject>;
+    writeTo(writable: IWritable): Promise<void>;
+    getBinary(): Uint8Array;
+    getRaw(): Uint8Array;
+    getEncrypted(): Uint8Array;
+}
+
+declare class Embed {
+    private _files;
+    private _headerEmbed;
+    _publicHeaderEmbed: EmbedObject | null;
+    hasEncryptedFiles: boolean;
+    hasPublicFiles: boolean;
+    private _key;
+    private _password;
+    constructor(params?: {
+        mp4?: unknown;
+        key?: Buffer | null;
+        password?: string | null;
+    });
+    private basename;
+    addFile(params: {
+        file?: {
+            name?: string;
+        };
+        filename?: string | null;
+        meta?: Record<string, unknown>;
+        key?: Buffer | null;
+        password?: string | null;
+    }): Promise<void>;
+    composeHeader(): Promise<boolean>;
+    getExpectedSize(): Promise<number>;
+    writeTo(writable: IWritable): Promise<void>;
+    restoreFromReadable(readable: IReadable, params?: {
+        key?: Buffer;
+        password?: string | null;
+    }, offset?: number): Promise<void>;
+    getFilesToExtract(): FileRecord[];
+    restoreBinary(readable: IReadable, params: {
+        key?: Buffer;
+        password?: string | undefined;
+    }, n: number, offset: number, writable?: IWritable | null): Promise<IWritable>;
+}
+
+declare class EmbedBinary {
+    _readable: IReadable | null;
+    private _key;
+    private _password;
+    private _iv;
+    private _salt;
+    private _encryptor;
+    constructor(params?: {
+        readable?: IReadable;
+        filename?: string;
+        file?: {
+            name?: string;
+        };
+        key?: Buffer | null;
+        password?: string | null;
+        iv?: Buffer | null;
+        salt?: Buffer | null;
+    });
+    getExpectedSize(): Promise<number>;
+    getEncryptor(): AES;
+    getIV(): Buffer;
+    static restoreFromReadable(readable: IReadable, params?: {
+        key?: Buffer;
+        password?: string;
+    }, offset?: number, size?: number | null, writable?: IWritable | null): Promise<IWritable>;
+    writeTo(writable: IWritable): Promise<void>;
+}
+
+declare class Pack {
+    static pack(format: string, values: unknown[]): number[];
+    static unpack(format: string, buffer: Uint8Array | number[]): number[];
+}
+
+declare class Readable implements IReadable {
+    private _filename;
+    private _prepared;
+    private _size;
+    private _fp;
+    constructor(params?: {
+        filename?: string;
+    });
+    isPrepared(): boolean;
+    prepare(): Promise<void>;
+    close(): Promise<void>;
+    getSlice(offset: number, length: number): Promise<Uint8Array>;
+    size(): Promise<number>;
+}
+
+declare class Writable implements IWritable {
+    private _uint8Array;
+    private _filename;
+    private _prepared;
+    private _bytesWrote;
+    private _fp;
+    constructor(params?: {
+        filename?: string;
+    });
+    size(): number;
+    prepare(): Promise<void>;
+    close(): Promise<void>;
+    saveToFile(filename: string): Promise<void>;
+    write(append: Uint8Array | number[]): Promise<void>;
+    toReadable(): Promise<IReadable>;
+}
+
+export { AES, Atom, Convert, Embed, EmbedBinary, EmbedObject, type FileRecord, type IReadable, type IWritable, MP4, Pack, Readable, Writable };