valley-baileys 1.0.0

package/node_modules/music-metadata/lib/ParseError.d.ts

@@ -0,0 +1,87 @@
+export type UnionOfParseErrors = CouldNotDetermineFileTypeError | UnsupportedFileTypeError | UnexpectedFileContentError | FieldDecodingError | InternalParserError;
+export declare const makeParseError: <Name extends string>(name: Name) => {
+    new (message: string): {
+        name: Name;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare const CouldNotDetermineFileTypeError_base: {
+    new (message: string): {
+        name: "CouldNotDetermineFileTypeError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class CouldNotDetermineFileTypeError extends CouldNotDetermineFileTypeError_base {
+}
+declare const UnsupportedFileTypeError_base: {
+    new (message: string): {
+        name: "UnsupportedFileTypeError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class UnsupportedFileTypeError extends UnsupportedFileTypeError_base {
+}
+declare const UnexpectedFileContentError_base: {
+    new (message: string): {
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class UnexpectedFileContentError extends UnexpectedFileContentError_base {
+    readonly fileType: string;
+    constructor(fileType: string, message: string);
+    toString(): string;
+}
+declare const FieldDecodingError_base: {
+    new (message: string): {
+        name: "FieldDecodingError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class FieldDecodingError extends FieldDecodingError_base {
+}
+declare const InternalParserError_base: {
+    new (message: string): {
+        name: "InternalParserError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class InternalParserError extends InternalParserError_base {
+}
+export declare const makeUnexpectedFileContentError: <FileType extends string>(fileType: FileType) => {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export {};

package/node_modules/music-metadata/lib/ParseError.js

@@ -0,0 +1,38 @@
+export const makeParseError = (name) => {
+    return class ParseError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = name;
+        }
+    };
+};
+// Concrete error class representing a file type determination failure.
+export class CouldNotDetermineFileTypeError extends makeParseError('CouldNotDetermineFileTypeError') {
+}
+// Concrete error class representing an unsupported file type.
+export class UnsupportedFileTypeError extends makeParseError('UnsupportedFileTypeError') {
+}
+// Concrete error class representing unexpected file content.
+class UnexpectedFileContentError extends makeParseError('UnexpectedFileContentError') {
+    constructor(fileType, message) {
+        super(message);
+        this.fileType = fileType;
+    }
+    // Override toString to include file type information.
+    toString() {
+        return `${this.name} (FileType: ${this.fileType}): ${this.message}`;
+    }
+}
+// Concrete error class representing a field decoding error.
+export class FieldDecodingError extends makeParseError('FieldDecodingError') {
+}
+export class InternalParserError extends makeParseError('InternalParserError') {
+}
+// Factory function to create a specific type of UnexpectedFileContentError.
+export const makeUnexpectedFileContentError = (fileType) => {
+    return class extends UnexpectedFileContentError {
+        constructor(message) {
+            super(fileType, message);
+        }
+    };
+};

package/node_modules/music-metadata/lib/ParserFactory.d.ts

@@ -0,0 +1,44 @@
+import { type MediaType } from 'media-typer';
+import { type INativeMetadataCollector } from './common/MetadataCollector.js';
+import { type IAudioMetadata, type IOptions, type ParserType } from './type.js';
+import type { ITokenizer } from 'strtok3';
+export interface IParserLoader {
+    /**
+     * Returns a list of supported file extensions
+     */
+    extensions: string[];
+    mimeTypes: string[];
+    parserType: ParserType;
+    /**
+     * Lazy load the parser implementation class.
+     */
+    load(): Promise<new (metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions) => ITokenParser>;
+}
+export interface ITokenParser {
+    /**
+     * Parse audio track.
+     * Called after init(...).
+     * @returns Promise
+     */
+    parse(): Promise<void>;
+}
+interface IContentType extends MediaType {
+    parameters: {
+        [id: string]: string;
+    };
+}
+export declare function parseHttpContentType(contentType: string): IContentType;
+export declare class ParserFactory {
+    parsers: IParserLoader[];
+    constructor();
+    registerParser(parser: IParserLoader): void;
+    parse(tokenizer: ITokenizer, parserLoader: IParserLoader | undefined, opts?: IOptions): Promise<IAudioMetadata>;
+    /**
+     * @param filePath - Path, filename or extension to audio file
+     * @return Parser submodule name
+     */
+    findLoaderForExtension(filePath: string | undefined): IParserLoader | undefined;
+    findLoaderForContentType(httpContentType: string): IParserLoader | undefined;
+    getSupportedMimeTypes(): string[];
+}
+export {};

package/node_modules/music-metadata/lib/ParserFactory.js

@@ -0,0 +1,141 @@
+import { fileTypeFromBuffer } from 'file-type';
+import ContentType from 'content-type';
+import { parse as mimeTypeParse } from 'media-typer';
+import initDebug from 'debug';
+import { MetadataCollector } from './common/MetadataCollector.js';
+import { TrackType } from './type.js';
+import { mpegParserLoader } from './mpeg/MpegLoader.js';
+import { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
+import { apeParserLoader } from './apev2/Apev2Loader.js';
+import { asfParserLoader } from './asf/AsfLoader.js';
+import { dsdiffParserLoader } from './dsdiff/DsdiffLoader.js';
+import { aiffParserLoader } from './aiff/AiffLoader.js';
+import { dsfParserLoader } from './dsf/DsfLoader.js';
+import { flacParserLoader } from './flac/FlacLoader.js';
+import { matroskaParserLoader } from './matroska/MatroskaLoader.js';
+import { mp4ParserLoader } from './mp4/Mp4Loader.js';
+import { musepackParserLoader } from './musepack/MusepackLoader.js';
+import { oggParserLoader } from './ogg/OggLoader.js';
+import { wavpackParserLoader } from './wavpack/WavPackLoader.js';
+import { riffParserLoader } from './wav/WaveLoader.js';
+import { scanAppendingHeaders } from './core.js';
+const debug = initDebug('music-metadata:parser:factory');
+export function parseHttpContentType(contentType) {
+    const type = ContentType.parse(contentType);
+    const mime = mimeTypeParse(type.type);
+    return {
+        type: mime.type,
+        subtype: mime.subtype,
+        suffix: mime.suffix,
+        parameters: type.parameters
+    };
+}
+export class ParserFactory {
+    constructor() {
+        this.parsers = [];
+        [
+            flacParserLoader,
+            mpegParserLoader,
+            apeParserLoader,
+            mp4ParserLoader,
+            matroskaParserLoader,
+            riffParserLoader,
+            oggParserLoader,
+            asfParserLoader,
+            aiffParserLoader,
+            wavpackParserLoader,
+            musepackParserLoader,
+            dsfParserLoader,
+            dsdiffParserLoader
+        ].forEach(parser => { this.registerParser(parser); });
+    }
+    registerParser(parser) {
+        this.parsers.push(parser);
+    }
+    async parse(tokenizer, parserLoader, opts) {
+        if (tokenizer.supportsRandomAccess()) {
+            debug('tokenizer supports random-access, scanning for appending headers');
+            await scanAppendingHeaders(tokenizer, opts);
+        }
+        else {
+            debug('tokenizer does not support random-access, cannot scan for appending headers');
+        }
+        if (!parserLoader) {
+            const buf = new Uint8Array(4100);
+            if (tokenizer.fileInfo.mimeType) {
+                parserLoader = this.findLoaderForContentType(tokenizer.fileInfo.mimeType);
+            }
+            if (!parserLoader && tokenizer.fileInfo.path) {
+                parserLoader = this.findLoaderForExtension(tokenizer.fileInfo.path);
+            }
+            if (!parserLoader) {
+                // Parser could not be determined on MIME-type or extension
+                debug('Guess parser on content...');
+                await tokenizer.peekBuffer(buf, { mayBeLess: true });
+                const guessedType = await fileTypeFromBuffer(buf, { mpegOffsetTolerance: 10 });
+                if (!guessedType || !guessedType.mime) {
+                    throw new CouldNotDetermineFileTypeError('Failed to determine audio format');
+                }
+                debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
+                parserLoader = this.findLoaderForContentType(guessedType.mime);
+                if (!parserLoader) {
+                    throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);
+                }
+            }
+        }
+        // Parser found, execute parser
+        debug(`Loading ${parserLoader.parserType} parser...`);
+        const metadata = new MetadataCollector(opts);
+        const ParserImpl = await parserLoader.load();
+        const parser = new ParserImpl(metadata, tokenizer, opts ?? {});
+        debug(`Parser ${parserLoader.parserType} loaded`);
+        await parser.parse();
+        if (metadata.format.trackInfo) {
+            if (metadata.format.hasAudio === undefined) {
+                metadata.setFormat('hasAudio', !!metadata.format.trackInfo.find(track => track.type === TrackType.audio));
+            }
+            if (metadata.format.hasVideo === undefined) {
+                metadata.setFormat('hasVideo', !!metadata.format.trackInfo.find(track => track.type === TrackType.video));
+            }
+        }
+        return metadata.toCommonMetadata();
+    }
+    /**
+     * @param filePath - Path, filename or extension to audio file
+     * @return Parser submodule name
+     */
+    findLoaderForExtension(filePath) {
+        if (!filePath)
+            return;
+        const extension = getExtension(filePath).toLocaleLowerCase() || filePath;
+        return this.parsers.find(parser => parser.extensions.indexOf(extension) !== -1);
+    }
+    findLoaderForContentType(httpContentType) {
+        let mime;
+        if (!httpContentType)
+            return;
+        try {
+            mime = parseHttpContentType(httpContentType);
+        }
+        catch (_err) {
+            debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);
+            return;
+        }
+        const subType = mime.subtype.indexOf('x-') === 0 ? mime.subtype.substring(2) : mime.subtype;
+        return this.parsers.find(parser => parser.mimeTypes.find(loader => loader.indexOf(`${mime.type}/${subType}`) !== -1));
+    }
+    getSupportedMimeTypes() {
+        const mimeTypeSet = new Set();
+        this.parsers.forEach(loader => {
+            loader.mimeTypes.forEach(mimeType => {
+                mimeTypeSet.add(mimeType);
+                mimeTypeSet.add(mimeType.replace('/', '/x-'));
+            });
+        });
+        return Array.from(mimeTypeSet);
+    }
+}
+function getExtension(fname) {
+    const i = fname.lastIndexOf('.');
+    return i === -1 ? '' : fname.substring(i);
+}

package/node_modules/music-metadata/lib/aiff/AiffLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const aiffParserLoader: IParserLoader;

package/node_modules/music-metadata/lib/aiff/AiffLoader.js

@@ -0,0 +1,8 @@
+export const aiffParserLoader = {
+    parserType: 'aiff',
+    extensions: ['.aif', 'aiff', 'aifc'],
+    mimeTypes: ['audio/aiff', 'audio/aif', 'audio/aifc', 'application/aiff'],
+    async load() {
+        return (await import('./AiffParser.js')).AIFFParser;
+    }
+};

package/node_modules/music-metadata/lib/aiff/AiffParser.d.ts

@@ -0,0 +1,15 @@
+import { BasicParser } from '../common/BasicParser.js';
+import * as iff from '../iff/index.js';
+/**
+ * AIFF - Audio Interchange File Format
+ *
+ * Ref:
+ * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/AIFF.html
+ * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf
+ */
+export declare class AIFFParser extends BasicParser {
+    private isCompressed;
+    parse(): Promise<void>;
+    readData(header: iff.IChunkHeader): Promise<number>;
+    readTextChunk(header: iff.IChunkHeader): Promise<number>;
+}

package/node_modules/music-metadata/lib/aiff/AiffParser.js

@@ -0,0 +1,104 @@
+import * as Token from 'token-types';
+import initDebug from 'debug';
+import * as strtok3 from 'strtok3';
+import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
+import { FourCcToken } from '../common/FourCC.js';
+import { BasicParser } from '../common/BasicParser.js';
+import * as AiffToken from './AiffToken.js';
+import { AiffContentError, compressionTypes } from './AiffToken.js';
+import * as iff from '../iff/index.js';
+const debug = initDebug('music-metadata:parser:aiff');
+/**
+ * AIFF - Audio Interchange File Format
+ *
+ * Ref:
+ * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/AIFF.html
+ * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf
+ */
+export class AIFFParser extends BasicParser {
+    constructor() {
+        super(...arguments);
+        this.isCompressed = null;
+    }
+    async parse() {
+        const header = await this.tokenizer.readToken(iff.Header);
+        if (header.chunkID !== 'FORM')
+            throw new AiffContentError('Invalid Chunk-ID, expected \'FORM\''); // Not AIFF format
+        const type = await this.tokenizer.readToken(FourCcToken);
+        switch (type) {
+            case 'AIFF':
+                this.metadata.setFormat('container', type);
+                this.isCompressed = false;
+                break;
+            case 'AIFC':
+                this.metadata.setFormat('container', 'AIFF-C');
+                this.isCompressed = true;
+                break;
+            default:
+                throw new AiffContentError(`Unsupported AIFF type: ${type}`);
+        }
+        this.metadata.setFormat('lossless', !this.isCompressed);
+        this.metadata.setAudioOnly();
+        try {
+            while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= iff.Header.len) {
+                debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);
+                const chunkHeader = await this.tokenizer.readToken(iff.Header);
+                const nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2);
+                const bytesRead = await this.readData(chunkHeader);
+                await this.tokenizer.ignore(nextChunk - bytesRead);
+            }
+        }
+        catch (err) {
+            if (err instanceof strtok3.EndOfStreamError) {
+                debug("End-of-stream");
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async readData(header) {
+        switch (header.chunkID) {
+            case 'COMM': { // The Common Chunk
+                if (this.isCompressed === null) {
+                    throw new AiffContentError('Failed to parse AIFF.COMM chunk when compression type is unknown');
+                }
+                const common = await this.tokenizer.readToken(new AiffToken.Common(header, this.isCompressed));
+                this.metadata.setFormat('bitsPerSample', common.sampleSize);
+                this.metadata.setFormat('sampleRate', common.sampleRate);
+                this.metadata.setFormat('numberOfChannels', common.numChannels);
+                this.metadata.setFormat('numberOfSamples', common.numSampleFrames);
+                this.metadata.setFormat('duration', common.numSampleFrames / common.sampleRate);
+                if (common.compressionName || common.compressionType) {
+                    this.metadata.setFormat('codec', common.compressionName ?? compressionTypes[common.compressionType]);
+                }
+                return header.chunkSize;
+            }
+            case 'ID3 ': { // ID3-meta-data
+                const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(header.chunkSize));
+                const rst = strtok3.fromBuffer(id3_data);
+                await new ID3v2Parser().parse(this.metadata, rst, this.options);
+                return header.chunkSize;
+            }
+            case 'SSND': // Sound Data Chunk
+                if (this.metadata.format.duration) {
+                    this.metadata.setFormat('bitrate', 8 * header.chunkSize / this.metadata.format.duration);
+                }
+                return 0;
+            case 'NAME': // Sample name chunk
+            case 'AUTH': // Author chunk
+            case '(c) ': // Copyright chunk
+            case 'ANNO': // Annotation chunk
+                return this.readTextChunk(header);
+            default:
+                debug(`Ignore chunk id=${header.chunkID}, size=${header.chunkSize}`);
+                return 0;
+        }
+    }
+    async readTextChunk(header) {
+        const value = await this.tokenizer.readToken(new Token.StringType(header.chunkSize, 'ascii'));
+        const values = value.split('\0').map(v => v.trim()).filter(v => v?.length);
+        await Promise.all(values.map(v => this.metadata.addTag('AIFF', header.chunkID, v)));
+        return header.chunkSize;
+    }
+}

package/node_modules/music-metadata/lib/aiff/AiffTagMap.d.ts

@@ -0,0 +1,4 @@
+import { CommonTagMapper } from '../common/GenericTagMapper.js';
+export declare class AiffTagMapper extends CommonTagMapper {
+    constructor();
+}

package/node_modules/music-metadata/lib/aiff/AiffTagMap.js

@@ -0,0 +1,15 @@
+import { CommonTagMapper } from '../common/GenericTagMapper.js';
+/**
+ * ID3v1 tag mappings
+ */
+const tagMap = {
+    NAME: 'title',
+    AUTH: 'artist',
+    '(c) ': 'copyright',
+    ANNO: 'comment'
+};
+export class AiffTagMapper extends CommonTagMapper {
+    constructor() {
+        super(['AIFF'], tagMap);
+    }
+}

package/node_modules/music-metadata/lib/aiff/AiffToken.d.ts

@@ -0,0 +1,48 @@
+import type * as iff from '../iff/index.js';
+import type { IGetToken } from 'strtok3';
+export declare const compressionTypes: {
+    NONE: string;
+    sowt: string;
+    fl32: string;
+    fl64: string;
+    alaw: string;
+    ulaw: string;
+    ULAW: string;
+    ALAW: string;
+    FL32: string;
+};
+export type CompressionTypeCode = keyof typeof compressionTypes;
+declare const AiffContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class AiffContentError extends AiffContentError_base {
+}
+/**
+ * The Common Chunk.
+ * Describes fundamental parameters of the waveform data such as sample rate, bit resolution, and how many channels of
+ * digital audio are stored in the FORM AIFF.
+ */
+export interface ICommon {
+    numChannels: number;
+    numSampleFrames: number;
+    sampleSize: number;
+    sampleRate: number;
+    compressionType?: CompressionTypeCode;
+    compressionName?: string;
+}
+export declare class Common implements IGetToken<ICommon> {
+    len: number;
+    private isAifc;
+    constructor(header: iff.IChunkHeader, isAifc: boolean);
+    get(buf: Uint8Array, off: number): ICommon;
+}
+export {};

package/node_modules/music-metadata/lib/aiff/AiffToken.js

@@ -0,0 +1,58 @@
+import * as Token from 'token-types';
+import { FourCcToken } from '../common/FourCC.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+export const compressionTypes = {
+    NONE: 'not compressed	PCM	Apple Computer',
+    sowt: 'PCM (byte swapped)',
+    fl32: '32-bit floating point IEEE 32-bit float',
+    fl64: '64-bit floating point IEEE 64-bit float	Apple Computer',
+    alaw: 'ALaw 2:1	8-bit ITU-T G.711 A-law',
+    ulaw: 'µLaw 2:1	8-bit ITU-T G.711 µ-law	Apple Computer',
+    ULAW: 'CCITT G.711 u-law 8-bit ITU-T G.711 µ-law',
+    ALAW: 'CCITT G.711 A-law 8-bit ITU-T G.711 A-law',
+    FL32: 'Float 32	IEEE 32-bit float '
+};
+export class AiffContentError extends makeUnexpectedFileContentError('AIFF') {
+}
+export class Common {
+    constructor(header, isAifc) {
+        this.isAifc = isAifc;
+        const minimumChunkSize = isAifc ? 22 : 18;
+        if (header.chunkSize < minimumChunkSize)
+            throw new AiffContentError(`COMMON CHUNK size should always be at least ${minimumChunkSize}`);
+        this.len = header.chunkSize;
+    }
+    get(buf, off) {
+        // see: https://cycling74.com/forums/aiffs-80-bit-sample-rate-value
+        const shift = Token.UINT16_BE.get(buf, off + 8) - 16398;
+        const baseSampleRate = Token.UINT16_BE.get(buf, off + 8 + 2);
+        const res = {
+            numChannels: Token.UINT16_BE.get(buf, off),
+            numSampleFrames: Token.UINT32_BE.get(buf, off + 2),
+            sampleSize: Token.UINT16_BE.get(buf, off + 6),
+            sampleRate: shift < 0 ? baseSampleRate >> Math.abs(shift) : baseSampleRate << shift
+        };
+        if (this.isAifc) {
+            res.compressionType = FourCcToken.get(buf, off + 18);
+            if (this.len > 22) {
+                const strLen = Token.UINT8.get(buf, off + 22);
+                if (strLen > 0) {
+                    const padding = (strLen + 1) % 2;
+                    if (23 + strLen + padding === this.len) {
+                        res.compressionName = new Token.StringType(strLen, 'latin1').get(buf, off + 23);
+                    }
+                    else {
+                        throw new AiffContentError('Illegal pstring length');
+                    }
+                }
+                else {
+                    res.compressionName = undefined;
+                }
+            }
+        }
+        else {
+            res.compressionName = 'PCM';
+        }
+        return res;
+    }
+}

package/node_modules/music-metadata/lib/apev2/APEv2Parser.d.ts

@@ -0,0 +1,46 @@
+import * as strtok3 from 'strtok3';
+import type { IOptions, IApeHeader } from '../type.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { type IFooter, type IHeader } from './APEv2Token.js';
+import type { IRandomAccessTokenizer } from 'strtok3';
+declare const ApeContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class ApeContentError extends ApeContentError_base {
+}
+export declare function tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
+export declare class APEv2Parser extends BasicParser {
+    /**
+     * Calculate the media file duration
+     * @param ah ApeHeader
+     * @return {number} duration in seconds
+     */
+    static calculateDuration(ah: IHeader): number;
+    /**
+     * Calculates the APEv1 / APEv2 first field offset
+     * @param tokenizer
+     * @param offset
+     */
+    static findApeFooterOffset(tokenizer: IRandomAccessTokenizer, offset: number): Promise<IApeHeader | undefined>;
+    private static parseTagFooter;
+    private ape;
+    /**
+     * Parse APEv1 / APEv2 header if header signature found
+     */
+    tryParseApeHeader(): Promise<void>;
+    parse(): Promise<void>;
+    parseTags(footer: IFooter): Promise<void>;
+    private parseDescriptorExpansion;
+    private parseHeader;
+}
+export {};