valley-baileys 1.0.0

package/node_modules/music-metadata/lib/apev2/APEv2Parser.js

@@ -0,0 +1,176 @@
+import initDebug from 'debug';
+import * as strtok3 from 'strtok3';
+import { StringType } from 'token-types';
+import * as util from '../common/Util.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { DataType, DescriptorParser, Header, TagFooter, TagItemHeader } from './APEv2Token.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { textDecode } from '@borewit/text-codec';
+const debug = initDebug('music-metadata:parser:APEv2');
+const tagFormat = 'APEv2';
+const preamble = 'APETAGEX';
+export class ApeContentError extends makeUnexpectedFileContentError('APEv2') {
+}
+export function tryParseApeHeader(metadata, tokenizer, options) {
+    const apeParser = new APEv2Parser(metadata, tokenizer, options);
+    return apeParser.tryParseApeHeader();
+}
+export class APEv2Parser extends BasicParser {
+    constructor() {
+        super(...arguments);
+        this.ape = {};
+    }
+    /**
+     * Calculate the media file duration
+     * @param ah ApeHeader
+     * @return {number} duration in seconds
+     */
+    static calculateDuration(ah) {
+        let duration = ah.totalFrames > 1 ? ah.blocksPerFrame * (ah.totalFrames - 1) : 0;
+        duration += ah.finalFrameBlocks;
+        return duration / ah.sampleRate;
+    }
+    /**
+     * Calculates the APEv1 / APEv2 first field offset
+     * @param tokenizer
+     * @param offset
+     */
+    static async findApeFooterOffset(tokenizer, offset) {
+        // Search for APE footer header at the end of the file
+        const apeBuf = new Uint8Array(TagFooter.len);
+        const position = tokenizer.position;
+        if (offset <= TagFooter.len) {
+            debug(`Offset is too small to read APE footer: offset=${offset}`);
+            return undefined;
+        }
+        if (offset > TagFooter.len) {
+            await tokenizer.readBuffer(apeBuf, { position: offset - TagFooter.len });
+            tokenizer.setPosition(position);
+            const tagFooter = TagFooter.get(apeBuf, 0);
+            if (tagFooter.ID === 'APETAGEX') {
+                if (tagFooter.flags.isHeader) {
+                    debug(`APE Header found at offset=${offset - TagFooter.len}`);
+                }
+                else {
+                    debug(`APE Footer found at offset=${offset - TagFooter.len}`);
+                    offset -= tagFooter.size;
+                }
+                return { footer: tagFooter, offset };
+            }
+        }
+    }
+    static parseTagFooter(metadata, buffer, options) {
+        const footer = TagFooter.get(buffer, buffer.length - TagFooter.len);
+        if (footer.ID !== preamble)
+            throw new ApeContentError('Unexpected APEv2 Footer ID preamble value');
+        strtok3.fromBuffer(buffer);
+        const apeParser = new APEv2Parser(metadata, strtok3.fromBuffer(buffer), options);
+        return apeParser.parseTags(footer);
+    }
+    /**
+     * Parse APEv1 / APEv2 header if header signature found
+     */
+    async tryParseApeHeader() {
+        if (this.tokenizer.fileInfo.size && this.tokenizer.fileInfo.size - this.tokenizer.position < TagFooter.len) {
+            debug("No APEv2 header found, end-of-file reached");
+            return;
+        }
+        const footer = await this.tokenizer.peekToken(TagFooter);
+        if (footer.ID === preamble) {
+            await this.tokenizer.ignore(TagFooter.len);
+            return this.parseTags(footer);
+        }
+        debug(`APEv2 header not found at offset=${this.tokenizer.position}`);
+        if (this.tokenizer.fileInfo.size) {
+            // Try to read the APEv2 header using just the footer-header
+            const remaining = this.tokenizer.fileInfo.size - this.tokenizer.position; // ToDo: take ID3v1 into account
+            const buffer = new Uint8Array(remaining);
+            await this.tokenizer.readBuffer(buffer);
+            return APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
+        }
+    }
+    async parse() {
+        const descriptor = await this.tokenizer.readToken(DescriptorParser);
+        if (descriptor.ID !== 'MAC ')
+            throw new ApeContentError('Unexpected descriptor ID');
+        this.ape.descriptor = descriptor;
+        const lenExp = descriptor.descriptorBytes - DescriptorParser.len;
+        const header = await (lenExp > 0 ? this.parseDescriptorExpansion(lenExp) : this.parseHeader());
+        this.metadata.setAudioOnly();
+        await this.tokenizer.ignore(header.forwardBytes);
+        return this.tryParseApeHeader();
+    }
+    async parseTags(footer) {
+        const keyBuffer = new Uint8Array(256); // maximum tag key length
+        let bytesRemaining = footer.size - TagFooter.len;
+        debug(`Parse APE tags at offset=${this.tokenizer.position}, size=${bytesRemaining}`);
+        for (let i = 0; i < footer.fields; i++) {
+            if (bytesRemaining < TagItemHeader.len) {
+                this.metadata.addWarning(`APEv2 Tag-header: ${footer.fields - i} items remaining, but no more tag data to read.`);
+                break;
+            }
+            // Only APEv2 tag has tag item headers
+            const tagItemHeader = await this.tokenizer.readToken(TagItemHeader);
+            bytesRemaining -= TagItemHeader.len + tagItemHeader.size;
+            await this.tokenizer.peekBuffer(keyBuffer, { length: Math.min(keyBuffer.length, bytesRemaining) });
+            let zero = util.findZero(keyBuffer);
+            const key = await this.tokenizer.readToken(new StringType(zero, 'ascii'));
+            await this.tokenizer.ignore(1);
+            bytesRemaining -= key.length + 1;
+            switch (tagItemHeader.flags.dataType) {
+                case DataType.text_utf8: { // utf-8 text-string
+                    const value = await this.tokenizer.readToken(new StringType(tagItemHeader.size, 'utf8'));
+                    const values = value.split(/\x00/g);
+                    await Promise.all(values.map(val => this.metadata.addTag(tagFormat, key, val)));
+                    break;
+                }
+                case DataType.binary: // binary (probably artwork)
+                    if (this.options.skipCovers) {
+                        await this.tokenizer.ignore(tagItemHeader.size);
+                    }
+                    else {
+                        const picData = new Uint8Array(tagItemHeader.size);
+                        await this.tokenizer.readBuffer(picData);
+                        zero = util.findZero(picData);
+                        const description = textDecode(picData.subarray(0, zero), 'utf-8');
+                        const data = picData.subarray(zero + 1);
+                        await this.metadata.addTag(tagFormat, key, {
+                            description,
+                            data
+                        });
+                    }
+                    break;
+                case DataType.external_info:
+                    debug(`Ignore external info ${key}`);
+                    await this.tokenizer.ignore(tagItemHeader.size);
+                    break;
+                case DataType.reserved:
+                    debug(`Ignore external info ${key}`);
+                    this.metadata.addWarning(`APEv2 header declares a reserved datatype for "${key}"`);
+                    await this.tokenizer.ignore(tagItemHeader.size);
+                    break;
+            }
+        }
+    }
+    async parseDescriptorExpansion(lenExp) {
+        await this.tokenizer.ignore(lenExp);
+        return this.parseHeader();
+    }
+    async parseHeader() {
+        const header = await this.tokenizer.readToken(Header);
+        // ToDo before
+        this.metadata.setFormat('lossless', true);
+        this.metadata.setFormat('container', 'Monkey\'s Audio');
+        this.metadata.setFormat('bitsPerSample', header.bitsPerSample);
+        this.metadata.setFormat('sampleRate', header.sampleRate);
+        this.metadata.setFormat('numberOfChannels', header.channel);
+        this.metadata.setFormat('duration', APEv2Parser.calculateDuration(header));
+        if (!this.ape.descriptor) {
+            throw new ApeContentError('Missing APE descriptor');
+        }
+        return {
+            forwardBytes: this.ape.descriptor.seekTableBytes + this.ape.descriptor.headerDataBytes +
+                this.ape.descriptor.apeFrameDataBytes + this.ape.descriptor.terminatingDataBytes
+        };
+    }
+}

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

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

package/node_modules/music-metadata/lib/apev2/APEv2TagMapper.js

@@ -0,0 +1,83 @@
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+/**
+ * ID3v2.2 tag mappings
+ */
+const apev2TagMap = {
+    Title: 'title',
+    Artist: 'artist',
+    Artists: 'artists',
+    'Album Artist': 'albumartist',
+    Album: 'album',
+    Year: 'date',
+    Originalyear: 'originalyear',
+    Originaldate: 'originaldate',
+    Releasedate: 'releasedate',
+    Comment: 'comment',
+    Track: 'track',
+    Disc: 'disk',
+    DISCNUMBER: 'disk', // ToDo: backwards compatibility', valid tag?
+    Genre: 'genre',
+    'Cover Art (Front)': 'picture',
+    'Cover Art (Back)': 'picture',
+    Composer: 'composer',
+    Lyrics: 'lyrics',
+    ALBUMSORT: 'albumsort',
+    TITLESORT: 'titlesort',
+    WORK: 'work',
+    ARTISTSORT: 'artistsort',
+    ALBUMARTISTSORT: 'albumartistsort',
+    COMPOSERSORT: 'composersort',
+    Lyricist: 'lyricist',
+    Writer: 'writer',
+    Conductor: 'conductor',
+    // 'Performer=artist (instrument)': 'performer:instrument',
+    MixArtist: 'remixer',
+    Arranger: 'arranger',
+    Engineer: 'engineer',
+    Producer: 'producer',
+    DJMixer: 'djmixer',
+    Mixer: 'mixer',
+    Label: 'label',
+    Grouping: 'grouping',
+    Subtitle: 'subtitle',
+    DiscSubtitle: 'discsubtitle',
+    Compilation: 'compilation',
+    BPM: 'bpm',
+    Mood: 'mood',
+    Media: 'media',
+    CatalogNumber: 'catalognumber',
+    MUSICBRAINZ_ALBUMSTATUS: 'releasestatus',
+    MUSICBRAINZ_ALBUMTYPE: 'releasetype',
+    RELEASECOUNTRY: 'releasecountry',
+    Script: 'script',
+    Language: 'language',
+    Copyright: 'copyright',
+    LICENSE: 'license',
+    EncodedBy: 'encodedby',
+    EncoderSettings: 'encodersettings',
+    Barcode: 'barcode',
+    ISRC: 'isrc',
+    ASIN: 'asin',
+    musicbrainz_trackid: 'musicbrainz_recordingid',
+    musicbrainz_releasetrackid: 'musicbrainz_trackid',
+    MUSICBRAINZ_ALBUMID: 'musicbrainz_albumid',
+    MUSICBRAINZ_ARTISTID: 'musicbrainz_artistid',
+    MUSICBRAINZ_ALBUMARTISTID: 'musicbrainz_albumartistid',
+    MUSICBRAINZ_RELEASEGROUPID: 'musicbrainz_releasegroupid',
+    MUSICBRAINZ_WORKID: 'musicbrainz_workid',
+    MUSICBRAINZ_TRMID: 'musicbrainz_trmid',
+    MUSICBRAINZ_DISCID: 'musicbrainz_discid',
+    Acoustid_Id: 'acoustid_id',
+    ACOUSTID_FINGERPRINT: 'acoustid_fingerprint',
+    MUSICIP_PUID: 'musicip_puid',
+    Weblink: 'website',
+    REPLAYGAIN_TRACK_GAIN: 'replaygain_track_gain',
+    REPLAYGAIN_TRACK_PEAK: 'replaygain_track_peak',
+    MP3GAIN_MINMAX: 'replaygain_track_minmax',
+    MP3GAIN_UNDO: 'replaygain_undo'
+};
+export class APEv2TagMapper extends CaseInsensitiveTagMap {
+    constructor() {
+        super(['APEv2'], apev2TagMap);
+    }
+}

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

@@ -0,0 +1,99 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * APETag versionIndex history / supported formats
+ *
+ * 1.0 (1000) - Original APE tag spec.  Fully supported by this code.
+ * 2.0 (2000) - Refined APE tag spec (better streaming support, UTF StringEncoding). Fully supported by this code.
+ *
+ * Notes:
+ * - also supports reading of ID3v1.1 tags
+ * - all saving done in the APE Tag format using CURRENT_APE_TAG_VERSION
+ *
+ * APE File Format Overview: (pieces in order -- only valid for the latest versionIndex APE files)
+ *
+ * JUNK - any amount of "junk" before the APE_DESCRIPTOR (so people that put ID3v2 tags on the files aren't hosed)
+ * APE_DESCRIPTOR - defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
+ * APE_HEADER - describes all of the necessary information about the APE file
+ * SEEK TABLE - the table that represents seek offsets [optional]
+ * HEADER DATA - the pre-audio data from the original file [optional]
+ * APE FRAMES - the actual compressed audio (broken into frames for seekability)
+ * TERMINATING DATA - the post-audio data from the original file [optional]
+ * TAG - describes all the properties of the file [optional]
+ */
+export interface IDescriptor {
+    ID: string;
+    version: number;
+    descriptorBytes: number;
+    headerBytes: number;
+    seekTableBytes: number;
+    headerDataBytes: number;
+    apeFrameDataBytes: number;
+    apeFrameDataBytesHigh: number;
+    terminatingDataBytes: number;
+    fileMD5: Uint8Array;
+}
+/**
+ * APE_HEADER: describes all of the necessary information about the APE file
+ */
+export interface IHeader {
+    compressionLevel: number;
+    formatFlags: number;
+    blocksPerFrame: number;
+    finalFrameBlocks: number;
+    totalFrames: number;
+    bitsPerSample: number;
+    channel: number;
+    sampleRate: number;
+}
+export interface IFooter {
+    ID: string;
+    version: number;
+    size: number;
+    fields: number;
+    flags: ITagFlags;
+}
+export declare const DataType: {
+    text_utf8: number;
+    binary: number;
+    external_info: number;
+    reserved: number;
+};
+export type DataType = typeof DataType[keyof typeof DataType];
+/**
+ * APE_DESCRIPTOR: defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
+ */
+export declare const DescriptorParser: IGetToken<IDescriptor>;
+/**
+ * APE_HEADER: describes all of the necessary information about the APE file
+ */
+export declare const Header: IGetToken<IHeader>;
+/**
+ * APE Tag Header/Footer Version 2.0
+ * TAG: describes all the properties of the file [optional]
+ */
+export declare const TagFooter: IGetToken<IFooter>;
+/**
+ * APE Tag v2.0 Item Header
+ */
+export interface ITagItemHeader {
+    size: number;
+    flags: ITagFlags;
+}
+/**
+ * APE Tag v2.0 Item Header
+ */
+export declare const TagItemHeader: IGetToken<ITagItemHeader>;
+export interface ITagFlags {
+    containsHeader: boolean;
+    containsFooter: boolean;
+    isHeader: boolean;
+    readOnly: boolean;
+    dataType: DataType;
+}
+export declare function parseTagFlags(flags: number): ITagFlags;
+/**
+ * @param num {number}
+ * @param bit 0 is least significant bit (LSB)
+ * @return {boolean} true if bit is 1; otherwise false
+ */
+export declare function isBitSet(num: number, bit: number): boolean;

package/node_modules/music-metadata/lib/apev2/APEv2Token.js

@@ -0,0 +1,116 @@
+import * as Token from 'token-types';
+import { FourCcToken } from '../common/FourCC.js';
+export const DataType = {
+    text_utf8: 0,
+    binary: 1,
+    external_info: 2,
+    reserved: 3
+};
+/**
+ * APE_DESCRIPTOR: defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
+ */
+export const DescriptorParser = {
+    len: 52,
+    get: (buf, off) => {
+        return {
+            // should equal 'MAC '
+            ID: FourCcToken.get(buf, off),
+            // versionIndex number * 1000 (3.81 = 3810) (remember that 4-byte alignment causes this to take 4-bytes)
+            version: Token.UINT32_LE.get(buf, off + 4) / 1000,
+            // the number of descriptor bytes (allows later expansion of this header)
+            descriptorBytes: Token.UINT32_LE.get(buf, off + 8),
+            // the number of header APE_HEADER bytes
+            headerBytes: Token.UINT32_LE.get(buf, off + 12),
+            // the number of header APE_HEADER bytes
+            seekTableBytes: Token.UINT32_LE.get(buf, off + 16),
+            // the number of header data bytes (from original file)
+            headerDataBytes: Token.UINT32_LE.get(buf, off + 20),
+            // the number of bytes of APE frame data
+            apeFrameDataBytes: Token.UINT32_LE.get(buf, off + 24),
+            // the high order number of APE frame data bytes
+            apeFrameDataBytesHigh: Token.UINT32_LE.get(buf, off + 28),
+            // the terminating data of the file (not including tag data)
+            terminatingDataBytes: Token.UINT32_LE.get(buf, off + 32),
+            // the MD5 hash of the file (see notes for usage... it's a little tricky)
+            fileMD5: new Token.Uint8ArrayType(16).get(buf, off + 36)
+        };
+    }
+};
+/**
+ * APE_HEADER: describes all of the necessary information about the APE file
+ */
+export const Header = {
+    len: 24,
+    get: (buf, off) => {
+        return {
+            // the compression level (see defines I.E. COMPRESSION_LEVEL_FAST)
+            compressionLevel: Token.UINT16_LE.get(buf, off),
+            // any format flags (for future use)
+            formatFlags: Token.UINT16_LE.get(buf, off + 2),
+            // the number of audio blocks in one frame
+            blocksPerFrame: Token.UINT32_LE.get(buf, off + 4),
+            // the number of audio blocks in the final frame
+            finalFrameBlocks: Token.UINT32_LE.get(buf, off + 8),
+            // the total number of frames
+            totalFrames: Token.UINT32_LE.get(buf, off + 12),
+            // the bits per sample (typically 16)
+            bitsPerSample: Token.UINT16_LE.get(buf, off + 16),
+            // the number of channels (1 or 2)
+            channel: Token.UINT16_LE.get(buf, off + 18),
+            // the sample rate (typically 44100)
+            sampleRate: Token.UINT32_LE.get(buf, off + 20)
+        };
+    }
+};
+/**
+ * APE Tag Header/Footer Version 2.0
+ * TAG: describes all the properties of the file [optional]
+ */
+export const TagFooter = {
+    len: 32,
+    get: (buf, off) => {
+        return {
+            // should equal 'APETAGEX'
+            ID: new Token.StringType(8, 'ascii').get(buf, off),
+            // equals CURRENT_APE_TAG_VERSION
+            version: Token.UINT32_LE.get(buf, off + 8),
+            // the complete size of the tag, including this footer (excludes header)
+            size: Token.UINT32_LE.get(buf, off + 12),
+            // the number of fields in the tag
+            fields: Token.UINT32_LE.get(buf, off + 16),
+            // reserved for later use (must be zero),
+            flags: parseTagFlags(Token.UINT32_LE.get(buf, off + 20))
+        };
+    }
+};
+/**
+ * APE Tag v2.0 Item Header
+ */
+export const TagItemHeader = {
+    len: 8,
+    get: (buf, off) => {
+        return {
+            // Length of assigned value in bytes
+            size: Token.UINT32_LE.get(buf, off),
+            // reserved for later use (must be zero),
+            flags: parseTagFlags(Token.UINT32_LE.get(buf, off + 4))
+        };
+    }
+};
+export function parseTagFlags(flags) {
+    return {
+        containsHeader: isBitSet(flags, 31),
+        containsFooter: isBitSet(flags, 30),
+        isHeader: isBitSet(flags, 29),
+        readOnly: isBitSet(flags, 0),
+        dataType: (flags & 6) >> 1
+    };
+}
+/**
+ * @param num {number}
+ * @param bit 0 is least significant bit (LSB)
+ * @return {boolean} true if bit is 1; otherwise false
+ */
+export function isBitSet(num, bit) {
+    return (num & 1 << bit) !== 0;
+}

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

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

package/node_modules/music-metadata/lib/apev2/Apev2Loader.js

@@ -0,0 +1,8 @@
+export const apeParserLoader = {
+    parserType: 'apev2',
+    extensions: ['.ape'],
+    mimeTypes: ['audio/ape', 'audio/monkeys-audio'],
+    async load() {
+        return (await import('./APEv2Parser.js')).APEv2Parser;
+    }
+};

package/node_modules/music-metadata/lib/asf/AsfGuid.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Ref:
+ * - https://tools.ietf.org/html/draft-fleischman-asf-01, Appendix A: ASF GUIDs
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ *
+ * ASF File Structure:
+ * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
+ *
+ * ASF GUIDs:
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ * - https://github.com/dji-sdk/FFmpeg/blob/master/libavformat/asf.c
+ */
+export default class AsfGuid {
+    static HeaderObject: AsfGuid;
+    static DataObject: AsfGuid;
+    static SimpleIndexObject: AsfGuid;
+    static IndexObject: AsfGuid;
+    static MediaObjectIndexObject: AsfGuid;
+    static TimecodeIndexObject: AsfGuid;
+    static FilePropertiesObject: AsfGuid;
+    static StreamPropertiesObject: AsfGuid;
+    static HeaderExtensionObject: AsfGuid;
+    static CodecListObject: AsfGuid;
+    static ScriptCommandObject: AsfGuid;
+    static MarkerObject: AsfGuid;
+    static BitrateMutualExclusionObject: AsfGuid;
+    static ErrorCorrectionObject: AsfGuid;
+    static ContentDescriptionObject: AsfGuid;
+    static ExtendedContentDescriptionObject: AsfGuid;
+    static ContentBrandingObject: AsfGuid;
+    static StreamBitratePropertiesObject: AsfGuid;
+    static ContentEncryptionObject: AsfGuid;
+    static ExtendedContentEncryptionObject: AsfGuid;
+    static DigitalSignatureObject: AsfGuid;
+    static PaddingObject: AsfGuid;
+    static ExtendedStreamPropertiesObject: AsfGuid;
+    static AdvancedMutualExclusionObject: AsfGuid;
+    static GroupMutualExclusionObject: AsfGuid;
+    static StreamPrioritizationObject: AsfGuid;
+    static BandwidthSharingObject: AsfGuid;
+    static LanguageListObject: AsfGuid;
+    static MetadataObject: AsfGuid;
+    static MetadataLibraryObject: AsfGuid;
+    static IndexParametersObject: AsfGuid;
+    static MediaObjectIndexParametersObject: AsfGuid;
+    static TimecodeIndexParametersObject: AsfGuid;
+    static CompatibilityObject: AsfGuid;
+    static AdvancedContentEncryptionObject: AsfGuid;
+    static AudioMedia: AsfGuid;
+    static VideoMedia: AsfGuid;
+    static CommandMedia: AsfGuid;
+    static JFIF_Media: AsfGuid;
+    static Degradable_JPEG_Media: AsfGuid;
+    static FileTransferMedia: AsfGuid;
+    static BinaryMedia: AsfGuid;
+    static ASF_Index_Placeholder_Object: AsfGuid;
+    static fromBin(bin: Uint8Array, offset?: number): AsfGuid;
+    /**
+     * Decode GUID in format like "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+     * @param objectId Binary GUID
+     * @param offset Read offset in bytes, default 0
+     * @returns GUID as dashed hexadecimal representation
+     */
+    static decode(objectId: Uint8Array, offset?: number): string;
+    /**
+     * Decode stream type
+     * @param mediaType Media type GUID
+     * @returns Media type
+     */
+    static decodeMediaType(mediaType: AsfGuid): 'audio' | 'video' | 'command' | 'degradable-jpeg' | 'file-transfer' | 'binary' | undefined;
+    /**
+     * Encode GUID
+     * @param guid GUID like: "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+     * @returns Encoded Binary GUID
+     */
+    static encode(guid: string): Uint8Array;
+    str: string;
+    constructor(str: string);
+    equals(guid: AsfGuid): boolean;
+    toBin(): Uint8Array;
+}