@dragon708/docmind-markdown 1.2.5 → 1.2.6

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

@@ -1,31 +1,6 @@
-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 {
-}
+/// <reference types="node" />
+import { IGetToken } from 'strtok3';
+import * as iff from '../iff';
 /**
  * The Common Chunk.
  * Describes fundamental parameters of the waveform data such as sample rate, bit resolution, and how many channels of
@@ -36,13 +11,12 @@ export interface ICommon {
     numSampleFrames: number;
     sampleSize: number;
     sampleRate: number;
-    compressionType?: CompressionTypeCode;
+    compressionType?: string;
     compressionName?: string;
 }
 export declare class Common implements IGetToken<ICommon> {
-    len: number;
     private isAifc;
+    len: number;
     constructor(header: iff.IChunkHeader, isAifc: boolean);
-    get(buf: Uint8Array, off: number): ICommon;
+    get(buf: Buffer, off: number): ICommon;
 }
-export {};

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

@@ -1,48 +1,37 @@
-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 {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Common = void 0;
+const Token = require("token-types");
+const FourCC_1 = require("../common/FourCC");
+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}`);
+            throw new Error(`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 shift = buf.readUInt16BE(off + 8) - 16398;
+        const baseSampleRate = buf.readUInt16BE(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),
+            numChannels: buf.readUInt16BE(off),
+            numSampleFrames: buf.readUInt32BE(off + 2),
+            sampleSize: buf.readUInt16BE(off + 6),
             sampleRate: shift < 0 ? baseSampleRate >> Math.abs(shift) : baseSampleRate << shift
         };
         if (this.isAifc) {
-            res.compressionType = FourCcToken.get(buf, off + 18);
+            res.compressionType = FourCC_1.FourCcToken.get(buf, off + 18);
             if (this.len > 22) {
-                const strLen = Token.UINT8.get(buf, off + 22);
+                const strLen = buf.readInt8(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);
+                        res.compressionName = new Token.StringType(strLen, 'binary').get(buf, off + 23);
                     }
                     else {
-                        throw new AiffContentError('Illegal pstring length');
+                        throw new Error('Illegal pstring length');
                     }
                 }
                 else {
@@ -56,3 +45,4 @@ export class Common {
         return res;
     }
 }
+exports.Common = Common;

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

@@ -1,25 +1,10 @@
-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>;
+import * as strtok3 from 'strtok3/lib/core';
+import { IOptions, IRandomReader, IApeHeader } from '../type';
+import { INativeMetadataCollector } from '../common/MetadataCollector';
+import { BasicParser } from '../common/BasicParser';
+import { IFooter, IHeader } from './APEv2Token';
 export declare class APEv2Parser extends BasicParser {
+    static tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
     /**
      * Calculate the media file duration
      * @param ah ApeHeader
@@ -28,10 +13,10 @@ export declare class APEv2Parser extends BasicParser {
     static calculateDuration(ah: IHeader): number;
     /**
      * Calculates the APEv1 / APEv2 first field offset
-     * @param tokenizer
+     * @param reader
      * @param offset
      */
-    static findApeFooterOffset(tokenizer: IRandomAccessTokenizer, offset: number): Promise<IApeHeader | undefined>;
+    static findApeFooterOffset(reader: IRandomReader, offset: number): Promise<IApeHeader>;
     private static parseTagFooter;
     private ape;
     /**
@@ -43,4 +28,3 @@ export declare class APEv2Parser extends BasicParser {
     private parseDescriptorExpansion;
     private parseHeader;
 }
-export {};

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

@@ -1,25 +1,25 @@
-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');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APEv2Parser = void 0;
+const debug_1 = require("debug");
+const strtok3 = require("strtok3/lib/core");
+const token_types_1 = require("token-types");
+const util = require("../common/Util");
+const BasicParser_1 = require("../common/BasicParser");
+const APEv2Token_1 = require("./APEv2Token");
+const debug = (0, debug_1.default)('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 {
+class APEv2Parser extends BasicParser_1.BasicParser {
     constructor() {
         super(...arguments);
         this.ape = {};
     }
+    static tryParseApeHeader(metadata, tokenizer, options) {
+        const apeParser = new APEv2Parser();
+        apeParser.init(metadata, tokenizer, options);
+        return apeParser.tryParseApeHeader();
+    }
     /**
      * Calculate the media file duration
      * @param ah ApeHeader
@@ -32,119 +32,109 @@ export class APEv2Parser extends BasicParser {
     }
     /**
      * Calculates the APEv1 / APEv2 first field offset
-     * @param tokenizer
+     * @param reader
      * @param offset
      */
-    static async findApeFooterOffset(tokenizer, offset) {
+    static async findApeFooterOffset(reader, 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 };
-            }
+        const apeBuf = Buffer.alloc(APEv2Token_1.TagFooter.len);
+        await reader.randomRead(apeBuf, 0, APEv2Token_1.TagFooter.len, offset - APEv2Token_1.TagFooter.len);
+        const tagFooter = APEv2Token_1.TagFooter.get(apeBuf, 0);
+        if (tagFooter.ID === 'APETAGEX') {
+            debug(`APE footer header at offset=${offset}`);
+            return { footer: tagFooter, offset: offset - tagFooter.size };
         }
     }
     static parseTagFooter(metadata, buffer, options) {
-        const footer = TagFooter.get(buffer, buffer.length - TagFooter.len);
+        const footer = APEv2Token_1.TagFooter.get(buffer, buffer.length - APEv2Token_1.TagFooter.len);
         if (footer.ID !== preamble)
-            throw new ApeContentError('Unexpected APEv2 Footer ID preamble value');
+            throw new Error('Unexpected APEv2 Footer ID preamble value.');
         strtok3.fromBuffer(buffer);
-        const apeParser = new APEv2Parser(metadata, strtok3.fromBuffer(buffer), options);
+        const apeParser = new APEv2Parser();
+        apeParser.init(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");
+        if (this.tokenizer.fileInfo.size && this.tokenizer.fileInfo.size - this.tokenizer.position < APEv2Token_1.TagFooter.len) {
+            debug(`No APEv2 header found, end-of-file reached`);
             return;
         }
-        const footer = await this.tokenizer.peekToken(TagFooter);
+        const footer = await this.tokenizer.peekToken(APEv2Token_1.TagFooter);
         if (footer.ID === preamble) {
-            await this.tokenizer.ignore(TagFooter.len);
+            await this.tokenizer.ignore(APEv2Token_1.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);
+        else {
+            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 = Buffer.alloc(remaining);
+                await this.tokenizer.readBuffer(buffer);
+                return APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
+            }
         }
     }
     async parse() {
-        const descriptor = await this.tokenizer.readToken(DescriptorParser);
+        const descriptor = await this.tokenizer.readToken(APEv2Token_1.DescriptorParser);
         if (descriptor.ID !== 'MAC ')
-            throw new ApeContentError('Unexpected descriptor ID');
+            throw new Error('Unexpected descriptor ID');
         this.ape.descriptor = descriptor;
-        const lenExp = descriptor.descriptorBytes - DescriptorParser.len;
+        const lenExp = descriptor.descriptorBytes - APEv2Token_1.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;
+        const keyBuffer = Buffer.alloc(256); // maximum tag key length
+        let bytesRemaining = footer.size - APEv2Token_1.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) {
+            if (bytesRemaining < APEv2Token_1.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;
+            const tagItemHeader = await this.tokenizer.readToken(APEv2Token_1.TagItemHeader);
+            bytesRemaining -= APEv2Token_1.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'));
+            let zero = util.findZero(keyBuffer, 0, keyBuffer.length);
+            const key = await this.tokenizer.readToken(new token_types_1.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'));
+                case APEv2Token_1.DataType.text_utf8: { // utf-8 text-string
+                    const value = await this.tokenizer.readToken(new token_types_1.StringType(tagItemHeader.size, 'utf8'));
                     const values = value.split(/\x00/g);
-                    await Promise.all(values.map(val => this.metadata.addTag(tagFormat, key, val)));
+                    for (const val of values) {
+                        this.metadata.addTag(tagFormat, key, val);
+                    }
                     break;
                 }
-                case DataType.binary: // binary (probably artwork)
+                case APEv2Token_1.DataType.binary: // binary (probably artwork)
                     if (this.options.skipCovers) {
                         await this.tokenizer.ignore(tagItemHeader.size);
                     }
                     else {
-                        const picData = new Uint8Array(tagItemHeader.size);
+                        const picData = Buffer.alloc(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, {
+                        zero = util.findZero(picData, 0, picData.length);
+                        const description = picData.toString('utf8', 0, zero);
+                        const data = Buffer.from(picData.slice(zero + 1));
+                        this.metadata.addTag(tagFormat, key, {
                             description,
                             data
                         });
                     }
                     break;
-                case DataType.external_info:
+                case APEv2Token_1.DataType.external_info:
                     debug(`Ignore external info ${key}`);
                     await this.tokenizer.ignore(tagItemHeader.size);
                     break;
-                case DataType.reserved:
+                case APEv2Token_1.DataType.reserved:
                     debug(`Ignore external info ${key}`);
                     this.metadata.addWarning(`APEv2 header declares a reserved datatype for "${key}"`);
                     await this.tokenizer.ignore(tagItemHeader.size);
@@ -157,7 +147,7 @@ export class APEv2Parser extends BasicParser {
         return this.parseHeader();
     }
     async parseHeader() {
-        const header = await this.tokenizer.readToken(Header);
+        const header = await this.tokenizer.readToken(APEv2Token_1.Header);
         // ToDo before
         this.metadata.setFormat('lossless', true);
         this.metadata.setFormat('container', 'Monkey\'s Audio');
@@ -165,12 +155,10 @@ export class APEv2Parser extends BasicParser {
         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
         };
     }
 }
+exports.APEv2Parser = APEv2Parser;

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

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

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

@@ -1,4 +1,7 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APEv2TagMapper = void 0;
+const CaseInsensitiveTagMap_1 = require("../common/CaseInsensitiveTagMap");
 /**
  * ID3v2.2 tag mappings
  */
@@ -11,11 +14,10 @@ const apev2TagMap = {
     Year: 'date',
     Originalyear: 'originalyear',
     Originaldate: 'originaldate',
-    Releasedate: 'releasedate',
     Comment: 'comment',
     Track: 'track',
     Disc: 'disk',
-    DISCNUMBER: 'disk', // ToDo: backwards compatibility', valid tag?
+    DISCNUMBER: 'disk',
     Genre: 'genre',
     'Cover Art (Front)': 'picture',
     'Cover Art (Back)': 'picture',
@@ -76,8 +78,10 @@ const apev2TagMap = {
     MP3GAIN_MINMAX: 'replaygain_track_minmax',
     MP3GAIN_UNDO: 'replaygain_undo'
 };
-export class APEv2TagMapper extends CaseInsensitiveTagMap {
+class APEv2TagMapper extends CaseInsensitiveTagMap_1.CaseInsensitiveTagMap {
     constructor() {
         super(['APEv2'], apev2TagMap);
     }
 }
+exports.APEv2TagMapper = APEv2TagMapper;
+//# sourceMappingURL=APEv2TagMapper.js.map

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

@@ -1,4 +1,5 @@
-import type { IGetToken } from 'strtok3';
+import * as Token from 'token-types';
+import { IGetToken } from 'strtok3/lib/core';
 /**
  * APETag versionIndex history / supported formats
  *
@@ -52,13 +53,12 @@ export interface IFooter {
     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];
+export declare enum 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
  */
@@ -83,6 +83,7 @@ export interface ITagItemHeader {
  * APE Tag v2.0 Item Header
  */
 export declare const TagItemHeader: IGetToken<ITagItemHeader>;
+export declare const TagField: (footer: any) => Token.Uint8ArrayType;
 export interface ITagFlags {
     containsHeader: boolean;
     containsFooter: boolean;
@@ -90,10 +91,10 @@ export interface ITagFlags {
     readOnly: boolean;
     dataType: DataType;
 }
-export declare function parseTagFlags(flags: number): ITagFlags;
+export declare function parseTagFlags(flags: any): 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;
+export declare function isBitSet(num: any, bit: any): boolean;

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

@@ -1,20 +1,24 @@
-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
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBitSet = exports.parseTagFlags = exports.TagField = exports.TagItemHeader = exports.TagFooter = exports.Header = exports.DescriptorParser = exports.DataType = void 0;
+const Token = require("token-types");
+const FourCC_1 = require("../common/FourCC");
+var DataType;
+(function (DataType) {
+    DataType[DataType["text_utf8"] = 0] = "text_utf8";
+    DataType[DataType["binary"] = 1] = "binary";
+    DataType[DataType["external_info"] = 2] = "external_info";
+    DataType[DataType["reserved"] = 3] = "reserved";
+})(DataType = exports.DataType || (exports.DataType = {}));
 /**
  * APE_DESCRIPTOR: defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
  */
-export const DescriptorParser = {
+exports.DescriptorParser = {
     len: 52,
     get: (buf, off) => {
         return {
             // should equal 'MAC '
-            ID: FourCcToken.get(buf, off),
+            ID: FourCC_1.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)
@@ -39,7 +43,7 @@ export const DescriptorParser = {
 /**
  * APE_HEADER: describes all of the necessary information about the APE file
  */
-export const Header = {
+exports.Header = {
     len: 24,
     get: (buf, off) => {
         return {
@@ -66,7 +70,7 @@ export const Header = {
  * APE Tag Header/Footer Version 2.0
  * TAG: describes all the properties of the file [optional]
  */
-export const TagFooter = {
+exports.TagFooter = {
     len: 32,
     get: (buf, off) => {
         return {
@@ -86,7 +90,7 @@ export const TagFooter = {
 /**
  * APE Tag v2.0 Item Header
  */
-export const TagItemHeader = {
+exports.TagItemHeader = {
     len: 8,
     get: (buf, off) => {
         return {
@@ -97,20 +101,27 @@ export const TagItemHeader = {
         };
     }
 };
-export function parseTagFlags(flags) {
+const TagField = footer => {
+    return new Token.Uint8ArrayType(footer.size - exports.TagFooter.len);
+};
+exports.TagField = TagField;
+function parseTagFlags(flags) {
     return {
         containsHeader: isBitSet(flags, 31),
         containsFooter: isBitSet(flags, 30),
-        isHeader: isBitSet(flags, 29),
+        isHeader: isBitSet(flags, 31),
         readOnly: isBitSet(flags, 0),
         dataType: (flags & 6) >> 1
     };
 }
+exports.parseTagFlags = parseTagFlags;
 /**
  * @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) {
+function isBitSet(num, bit) {
     return (num & 1 << bit) !== 0;
 }
+exports.isBitSet = isBitSet;
+//# sourceMappingURL=APEv2Token.js.map