@dragon708/docmind-markdown 1.2.5 → 1.2.7

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

@@ -1,45 +1,32 @@
-/**
- * Primary entry point, Node.js specific entry point is MusepackParser.ts
- */
-import { type AnyWebByteStream, type IFileInfo, type ITokenizer, type IRandomAccessTokenizer } from 'strtok3';
-import type { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, ITag } from './type.js';
-import type { Readable } from 'node:stream';
-export type { IFileInfo } from 'strtok3';
-export { type IAudioMetadata, type IOptions, type ITag, type INativeTagDict, type ICommonTagsResult, type IFormat, type IPicture, type IRatio, type IChapter, type ILyricsTag, LyricsContentType, TimestampFormat, IMetadataEventTag, IMetadataEvent } from './type.js';
-export { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
-export * from './ParseError.js';
-/**
- * Parse Web API File
- * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20
- * @param blob - Blob to parse
- * @param options - Parsing options
- * @returns Metadata
- */
-export declare function parseBlob(blob: Blob, options?: IOptions): Promise<IAudioMetadata>;
-/**
- * Parse audio from Web Stream.Readable
- * @param webStream - WebStream to read the audio track from
+/// <reference types="node" />
+import { Readable } from 'stream';
+import * as strtok3 from 'strtok3/lib/core';
+import { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, IRandomReader, ITag } from './type';
+export { IFileInfo } from 'strtok3/lib/core';
+/**
+ * Parse audio from Node Stream.Readable
+ * @param stream - Stream to read the audio track from
  * @param options - Parsing options
  * @param fileInfo - File information object or MIME-type string
  * @returns Metadata
  */
-export declare function parseWebStream(webStream: AnyWebByteStream, fileInfo?: IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseStream(stream: Readable, fileInfo?: strtok3.IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
 /**
- * Parse audio from memory
+ * Parse audio from Node Buffer
  * @param uint8Array - Uint8Array holding audio data
  * @param fileInfo - File information object or MIME-type string
  * @param options - Parsing options
  * @returns Metadata
  * Ref: https://github.com/Borewit/strtok3/blob/e6938c81ff685074d5eb3064a11c0b03ca934c1d/src/index.ts#L15
  */
-export declare function parseBuffer(uint8Array: Uint8Array, fileInfo?: IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseBuffer(uint8Array: Uint8Array, fileInfo?: strtok3.IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
 /**
  * Parse audio from ITokenizer source
  * @param tokenizer - Audio source implementing the tokenizer interface
  * @param options - Parsing options
  * @returns Metadata
  */
-export declare function parseFromTokenizer(tokenizer: ITokenizer, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseFromTokenizer(tokenizer: strtok3.ITokenizer, options?: IOptions): Promise<IAudioMetadata>;
 /**
  * Create a dictionary ordered by their tag id (key)
  * @param nativeTags list of tags
@@ -48,28 +35,14 @@ export declare function parseFromTokenizer(tokenizer: ITokenizer, options?: IOpt
 export declare function orderTags(nativeTags: ITag[]): INativeTagDict;
 /**
  * Convert rating to 1-5 star rating
- * @param rating Normalized rating [0..1] (common.rating[n].rating)
+ * @param rating: Normalized rating [0..1] (common.rating[n].rating)
  * @returns Number of stars: 1, 2, 3, 4 or 5 stars
  */
-export declare function ratingToStars(rating: number | undefined): number;
+export declare function ratingToStars(rating: number): number;
 /**
  * Select most likely cover image.
  * @param pictures Usually metadata.common.picture
  * @return Cover image, if any, otherwise null
  */
 export declare function selectCover(pictures?: IPicture[]): IPicture | null;
-export declare function scanAppendingHeaders(tokenizer: IRandomAccessTokenizer, options?: IPrivateOptions): Promise<void>;
-/**
- * Implementation only available when loaded as Node.js
- * This method will throw an Error, always.
- */
-export declare function parseFile(_filePath: string, _options?: IOptions): Promise<IAudioMetadata>;
-/**
- * Implementation only available when loaded as Node.js
- * This method will throw an Error, always.
- */
-export declare function parseStream(_stream: Readable, _fileInfo?: IFileInfo | string, _options?: IOptions): Promise<IAudioMetadata>;
-/**
- * Return a list of supported mime-types
- */
-export declare function getSupportedMimeTypes(): string[];
+export declare function scanAppendingHeaders(randomReader: IRandomReader, options?: IPrivateOptions): Promise<void>;

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

@@ -1,126 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanAppendingHeaders = exports.selectCover = exports.ratingToStars = exports.orderTags = exports.parseFromTokenizer = exports.parseBuffer = exports.parseStream = void 0;
+const strtok3 = require("strtok3/lib/core");
+const ParserFactory_1 = require("./ParserFactory");
+const RandomUint8ArrayReader_1 = require("./common/RandomUint8ArrayReader");
+const APEv2Parser_1 = require("./apev2/APEv2Parser");
+const ID3v1Parser_1 = require("./id3v1/ID3v1Parser");
+const Lyrics3_1 = require("./lyrics3/Lyrics3");
 /**
- * Primary entry point, Node.js specific entry point is MusepackParser.ts
- */
-import { fromWebStream, fromBuffer, fromBlob } from 'strtok3';
-import { ParserFactory } from './ParserFactory.js';
-import { APEv2Parser } from './apev2/APEv2Parser.js';
-import { hasID3v1Header } from './id3v1/ID3v1Parser.js';
-import { getLyricsHeaderLength } from './lyrics3/Lyrics3.js';
-export { LyricsContentType, TimestampFormat } from './type.js';
-export { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
-export * from './ParseError.js';
-/**
- * Parse Web API File
- * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20
- * @param blob - Blob to parse
- * @param options - Parsing options
- * @returns Metadata
- */
-export async function parseBlob(blob, options = {}) {
-    const tokenizer = fromBlob(blob);
-    try {
-        return await parseFromTokenizer(tokenizer, options);
-    }
-    finally {
-        await tokenizer.close();
-    }
-}
-/**
- * Parse audio from Web Stream.Readable
- * @param webStream - WebStream to read the audio track from
+ * Parse audio from Node Stream.Readable
+ * @param stream - Stream to read the audio track from
  * @param options - Parsing options
  * @param fileInfo - File information object or MIME-type string
  * @returns Metadata
  */
-export async function parseWebStream(webStream, fileInfo, options = {}) {
-    const tokenizer = fromWebStream(webStream, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
-    try {
-        return await parseFromTokenizer(tokenizer, options);
-    }
-    finally {
-        await tokenizer.close();
-    }
+function parseStream(stream, fileInfo, options = {}) {
+    return parseFromTokenizer(strtok3.fromStream(stream, typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo), options);
 }
+exports.parseStream = parseStream;
 /**
- * Parse audio from memory
+ * Parse audio from Node Buffer
  * @param uint8Array - Uint8Array holding audio data
  * @param fileInfo - File information object or MIME-type string
  * @param options - Parsing options
  * @returns Metadata
  * Ref: https://github.com/Borewit/strtok3/blob/e6938c81ff685074d5eb3064a11c0b03ca934c1d/src/index.ts#L15
  */
-export async function parseBuffer(uint8Array, fileInfo, options = {}) {
-    const tokenizer = fromBuffer(uint8Array, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
+async function parseBuffer(uint8Array, fileInfo, options = {}) {
+    const bufferReader = new RandomUint8ArrayReader_1.RandomUint8ArrayReader(uint8Array);
+    await scanAppendingHeaders(bufferReader, options);
+    const tokenizer = strtok3.fromBuffer(uint8Array, typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo);
     return parseFromTokenizer(tokenizer, options);
 }
+exports.parseBuffer = parseBuffer;
 /**
  * Parse audio from ITokenizer source
  * @param tokenizer - Audio source implementing the tokenizer interface
  * @param options - Parsing options
  * @returns Metadata
  */
-export function parseFromTokenizer(tokenizer, options) {
-    const parserFactory = new ParserFactory();
-    return parserFactory.parse(tokenizer, undefined, options);
+function parseFromTokenizer(tokenizer, options) {
+    return ParserFactory_1.ParserFactory.parseOnContentType(tokenizer, options);
 }
+exports.parseFromTokenizer = parseFromTokenizer;
 /**
  * Create a dictionary ordered by their tag id (key)
  * @param nativeTags list of tags
  * @returns tags indexed by id
  */
-export function orderTags(nativeTags) {
+function orderTags(nativeTags) {
     const tags = {};
-    for (const { id, value } of nativeTags) {
-        (tags[id] || (tags[id] = [])).push(value);
+    for (const tag of nativeTags) {
+        (tags[tag.id] = (tags[tag.id] || [])).push(tag.value);
     }
     return tags;
 }
+exports.orderTags = orderTags;
 /**
  * Convert rating to 1-5 star rating
- * @param rating Normalized rating [0..1] (common.rating[n].rating)
+ * @param rating: Normalized rating [0..1] (common.rating[n].rating)
  * @returns Number of stars: 1, 2, 3, 4 or 5 stars
  */
-export function ratingToStars(rating) {
+function ratingToStars(rating) {
     return rating === undefined ? 0 : 1 + Math.round(rating * 4);
 }
+exports.ratingToStars = ratingToStars;
 /**
  * Select most likely cover image.
  * @param pictures Usually metadata.common.picture
  * @return Cover image, if any, otherwise null
  */
-export function selectCover(pictures) {
+function selectCover(pictures) {
     return pictures ? pictures.reduce((acc, cur) => {
         if (cur.name && cur.name.toLowerCase() in ['front', 'cover', 'cover (front)'])
             return cur;
         return acc;
     }) : null;
 }
-export async function scanAppendingHeaders(tokenizer, options = {}) {
-    let apeOffset = tokenizer.fileInfo.size;
-    if (await hasID3v1Header(tokenizer)) {
+exports.selectCover = selectCover;
+async function scanAppendingHeaders(randomReader, options = {}) {
+    let apeOffset = randomReader.fileSize;
+    if (await (0, ID3v1Parser_1.hasID3v1Header)(randomReader)) {
         apeOffset -= 128;
-        const lyricsLen = await getLyricsHeaderLength(tokenizer);
+        const lyricsLen = await (0, Lyrics3_1.getLyricsHeaderLength)(randomReader);
         apeOffset -= lyricsLen;
     }
-    options.apeHeader = await APEv2Parser.findApeFooterOffset(tokenizer, apeOffset);
-}
-/**
- * Implementation only available when loaded as Node.js
- * This method will throw an Error, always.
- */
-export async function parseFile(_filePath, _options = {}) {
-    throw new Error('This function require a Node engine. To load Web API File objects use parseBlob instead.');
-}
-/**
- * Implementation only available when loaded as Node.js
- * This method will throw an Error, always.
- */
-export async function parseStream(_stream, _fileInfo, _options = {}) {
-    throw new Error('This function require a Node engine.');
-}
-/**
- * Return a list of supported mime-types
- */
-export function getSupportedMimeTypes() {
-    return new ParserFactory().getSupportedMimeTypes();
+    options.apeHeader = await APEv2Parser_1.APEv2Parser.findApeFooterOffset(randomReader, apeOffset);
 }
+exports.scanAppendingHeaders = scanAppendingHeaders;

package/node_modules/music-metadata/lib/dsdiff/DsdiffParser.d.ts

@@ -1,18 +1,4 @@
-import { BasicParser } from '../common/BasicParser.js';
-declare const DsdiffContentParseError_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 DsdiffContentParseError extends DsdiffContentParseError_base {
-}
+import { BasicParser } from '../common/BasicParser';
 /**
  * DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
  *
@@ -26,4 +12,3 @@ export declare class DsdiffParser extends BasicParser {
     private handleSoundPropertyChunks;
     private handleChannelChunks;
 }
-export {};

package/node_modules/music-metadata/lib/dsdiff/DsdiffParser.js

@@ -1,78 +1,70 @@
-import * as Token from 'token-types';
-import initDebug from 'debug';
-import * as strtok3 from 'strtok3';
-import { FourCcToken } from '../common/FourCC.js';
-import { BasicParser } from '../common/BasicParser.js';
-import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
-import { ChunkHeader64 } from './DsdiffToken.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
-const debug = initDebug('music-metadata:parser:aiff');
-export class DsdiffContentParseError extends makeUnexpectedFileContentError('DSDIFF') {
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DsdiffParser = void 0;
+const Token = require("token-types");
+const debug_1 = require("debug");
+const strtok3 = require("strtok3/lib/core");
+const FourCC_1 = require("../common/FourCC");
+const BasicParser_1 = require("../common/BasicParser");
+const ID3v2Parser_1 = require("../id3v2/ID3v2Parser");
+const DsdiffToken_1 = require("./DsdiffToken");
+const debug = (0, debug_1.default)('music-metadata:parser:aiff');
 /**
  * DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
  *
  * Ref:
  * - http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
  */
-export class DsdiffParser extends BasicParser {
+class DsdiffParser extends BasicParser_1.BasicParser {
     async parse() {
-        const header = await this.tokenizer.readToken(ChunkHeader64);
+        const header = await this.tokenizer.readToken(DsdiffToken_1.ChunkHeader64);
         if (header.chunkID !== 'FRM8')
-            throw new DsdiffContentParseError('Unexpected chunk-ID');
-        this.metadata.setAudioOnly();
-        const type = (await this.tokenizer.readToken(FourCcToken)).trim();
+            throw new Error('Unexpected chunk-ID');
+        const type = (await this.tokenizer.readToken(FourCC_1.FourCcToken)).trim();
         switch (type) {
             case 'DSD':
                 this.metadata.setFormat('container', `DSDIFF/${type}`);
                 this.metadata.setFormat('lossless', true);
-                return this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));
+                return this.readFmt8Chunks(header.chunkSize - BigInt(FourCC_1.FourCcToken.len));
             default:
-                throw new DsdiffContentParseError(`Unsupported DSDIFF type: ${type}`);
+                throw Error(`Unsupported DSDIFF type: ${type}`);
         }
     }
     async readFmt8Chunks(remainingSize) {
-        while (remainingSize >= ChunkHeader64.len) {
-            const chunkHeader = await this.tokenizer.readToken(ChunkHeader64);
+        while (remainingSize >= DsdiffToken_1.ChunkHeader64.len) {
+            const chunkHeader = await this.tokenizer.readToken(DsdiffToken_1.ChunkHeader64);
             //  If the data is an odd number of bytes in length, a pad byte must be added at the end
             debug(`Chunk id=${chunkHeader.chunkID}`);
             await this.readData(chunkHeader);
-            remainingSize -= (BigInt(ChunkHeader64.len) + chunkHeader.chunkSize);
+            remainingSize -= (BigInt(DsdiffToken_1.ChunkHeader64.len) + chunkHeader.chunkSize);
         }
     }
     async readData(header) {
         debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
         const p0 = this.tokenizer.position;
         switch (header.chunkID.trim()) {
-            case 'FVER': { // 3.1 FORMAT VERSION CHUNK
+            case 'FVER': // 3.1 FORMAT VERSION CHUNK
                 const version = await this.tokenizer.readToken(Token.UINT32_LE);
                 debug(`DSDIFF version=${version}`);
                 break;
-            }
-            case 'PROP': { // 3.2 PROPERTY CHUNK
-                const propType = await this.tokenizer.readToken(FourCcToken);
+            case 'PROP': // 3.2 PROPERTY CHUNK
+                const propType = await this.tokenizer.readToken(FourCC_1.FourCcToken);
                 if (propType !== 'SND ')
-                    throw new DsdiffContentParseError('Unexpected PROP-chunk ID');
-                await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
+                    throw new Error('Unexpected PROP-chunk ID');
+                await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCC_1.FourCcToken.len));
                 break;
-            }
-            case 'ID3': { // Unofficial ID3 tag support
+            case 'ID3': // Unofficial ID3 tag support
                 const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(Number(header.chunkSize)));
                 const rst = strtok3.fromBuffer(id3_data);
-                await new ID3v2Parser().parse(this.metadata, rst, this.options);
-                break;
-            }
-            case 'DSD':
-                if (this.metadata.format.numberOfChannels) {
-                    this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
-                }
-                if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) {
-                    this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
-                }
+                await new ID3v2Parser_1.ID3v2Parser().parse(this.metadata, rst, this.options);
                 break;
             default:
                 debug(`Ignore chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
                 break;
+            case 'DSD':
+                this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
+                this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
+                break;
         }
         const remaining = header.chunkSize - BigInt(this.tokenizer.position - p0);
         if (remaining > 0) {
@@ -83,23 +75,21 @@ export class DsdiffParser extends BasicParser {
     async handleSoundPropertyChunks(remainingSize) {
         debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
         while (remainingSize > 0) {
-            const sndPropHeader = await this.tokenizer.readToken(ChunkHeader64);
+            const sndPropHeader = await this.tokenizer.readToken(DsdiffToken_1.ChunkHeader64);
             debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
             const p0 = this.tokenizer.position;
             switch (sndPropHeader.chunkID.trim()) {
-                case 'FS': { // 3.2.1 Sample Rate Chunk
+                case 'FS': // 3.2.1 Sample Rate Chunk
                     const sampleRate = await this.tokenizer.readToken(Token.UINT32_BE);
                     this.metadata.setFormat('sampleRate', sampleRate);
                     break;
-                }
-                case 'CHNL': { // 3.2.2 Channels Chunk
+                case 'CHNL': // 3.2.2 Channels Chunk
                     const numChannels = await this.tokenizer.readToken(Token.UINT16_BE);
                     this.metadata.setFormat('numberOfChannels', numChannels);
                     await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(Token.UINT16_BE.len));
                     break;
-                }
-                case 'CMPR': { // 3.2.3 Compression Type Chunk
-                    const compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim();
+                case 'CMPR': // 3.2.3 Compression Type Chunk
+                    const compressionIdCode = (await this.tokenizer.readToken(FourCC_1.FourCcToken)).trim();
                     const count = await this.tokenizer.readToken(Token.UINT8);
                     const compressionName = await this.tokenizer.readToken(new Token.StringType(count, 'ascii'));
                     if (compressionIdCode === 'DSD') {
@@ -108,20 +98,18 @@ export class DsdiffParser extends BasicParser {
                     }
                     this.metadata.setFormat('codec', `${compressionIdCode} (${compressionName})`);
                     break;
-                }
-                case 'ABSS': { // 3.2.4 Absolute Start Time Chunk
+                case 'ABSS': // 3.2.4 Absolute Start Time Chunk
                     const hours = await this.tokenizer.readToken(Token.UINT16_BE);
                     const minutes = await this.tokenizer.readToken(Token.UINT8);
                     const seconds = await this.tokenizer.readToken(Token.UINT8);
                     const samples = await this.tokenizer.readToken(Token.UINT32_BE);
                     debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);
                     break;
-                }
-                case 'LSCO': { // 3.2.5 Loudspeaker Configuration Chunk
+                case 'LSCO': // 3.2.5 Loudspeaker Configuration Chunk
                     const lsConfig = await this.tokenizer.readToken(Token.UINT16_BE);
                     debug(`LSCO lsConfig=${lsConfig}`);
                     break;
-                }
+                case 'COMT':
                 default:
                     debug(`Unknown sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
                     await this.tokenizer.ignore(Number(sndPropHeader.chunkSize));
@@ -131,7 +119,7 @@ export class DsdiffParser extends BasicParser {
                 debug(`After Parsing sound-property-chunk ${sndPropHeader.chunkSize}, remaining ${remaining} bytes`);
                 await this.tokenizer.ignore(Number(remaining));
             }
-            remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize;
+            remainingSize -= BigInt(DsdiffToken_1.ChunkHeader64.len) + sndPropHeader.chunkSize;
             debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
         }
         if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {
@@ -142,13 +130,14 @@ export class DsdiffParser extends BasicParser {
     async handleChannelChunks(remainingSize) {
         debug(`Parsing channel-chunks, remainingSize=${remainingSize}`);
         const channels = [];
-        while (remainingSize >= FourCcToken.len) {
-            const channelId = await this.tokenizer.readToken(FourCcToken);
+        while (remainingSize >= FourCC_1.FourCcToken.len) {
+            const channelId = await this.tokenizer.readToken(FourCC_1.FourCcToken);
             debug(`Channel[ID=${channelId}]`);
             channels.push(channelId);
-            remainingSize -= BigInt(FourCcToken.len);
+            remainingSize -= BigInt(FourCC_1.FourCcToken.len);
         }
         debug(`Channels: ${channels.join(', ')}`);
         return channels;
     }
 }
+exports.DsdiffParser = DsdiffParser;

package/node_modules/music-metadata/lib/dsdiff/DsdiffToken.d.ts

@@ -1,6 +1,6 @@
-import type { IGetToken } from 'strtok3';
-import type { IChunkHeader64 } from '../iff/index.js';
-export type { IChunkHeader64 } from '../iff/index.js';
+import { IGetToken } from 'strtok3/lib/core';
+import { IChunkHeader64 } from '../iff';
+export { IChunkHeader64 } from '../iff';
 /**
  * DSDIFF chunk header
  * The data-size encoding is deviating from EA-IFF 85

package/node_modules/music-metadata/lib/dsdiff/DsdiffToken.js

@@ -1,16 +1,19 @@
-import * as Token from 'token-types';
-import { FourCcToken } from '../common/FourCC.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkHeader64 = void 0;
+const Token = require("token-types");
+const FourCC_1 = require("../common/FourCC");
 /**
  * DSDIFF chunk header
  * The data-size encoding is deviating from EA-IFF 85
  * Ref: http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
  */
-export const ChunkHeader64 = {
+exports.ChunkHeader64 = {
     len: 12,
     get: (buf, off) => {
         return {
             // Group-ID
-            chunkID: FourCcToken.get(buf, off),
+            chunkID: FourCC_1.FourCcToken.get(buf, off),
             // Size
             chunkSize: Token.INT64_BE.get(buf, off + 4)
         };

package/node_modules/music-metadata/lib/dsf/DsfChunk.d.ts

@@ -1,4 +1,4 @@
-import type { IGetToken } from 'strtok3';
+import { IGetToken } from 'strtok3/lib/core';
 /**
  * Common interface for the common chunk DSD header
  */
@@ -34,16 +34,15 @@ export interface IDsdChunk {
  * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
  */
 export declare const DsdChunk: IGetToken<IDsdChunk>;
-export declare const ChannelType: {
-    mono: number;
-    stereo: number;
-    channels: number;
-    quad: number;
-    '4 channels': number;
-    '5 channels': number;
-    '5.1 channels': number;
-};
-export type ChannelType = typeof ChannelType[keyof typeof ChannelType];
+export declare enum ChannelType {
+    mono = 1,
+    stereo = 2,
+    channels = 3,
+    quad = 4,
+    '4 channels' = 5,
+    '5 channels' = 6,
+    '5.1 channels' = 7
+}
 /**
  * Interface to format chunk payload chunk
  */

package/node_modules/music-metadata/lib/dsf/DsfChunk.js

@@ -1,18 +1,21 @@
-import * as Token from 'token-types';
-import { FourCcToken } from '../common/FourCC.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatChunk = exports.ChannelType = exports.DsdChunk = exports.ChunkHeader = void 0;
+const Token = require("token-types");
+const FourCC_1 = require("../common/FourCC");
 /**
  * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
  */
-export const ChunkHeader = {
+exports.ChunkHeader = {
     len: 12,
     get: (buf, off) => {
-        return { id: FourCcToken.get(buf, off), size: Token.UINT64_LE.get(buf, off + 4) };
+        return { id: FourCC_1.FourCcToken.get(buf, off), size: Token.UINT64_LE.get(buf, off + 4) };
     }
 };
 /**
  * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
  */
-export const DsdChunk = {
+exports.DsdChunk = {
     len: 16,
     get: (buf, off) => {
         return {
@@ -21,19 +24,20 @@ export const DsdChunk = {
         };
     }
 };
-export const ChannelType = {
-    mono: 1,
-    stereo: 2,
-    channels: 3,
-    quad: 4,
-    '4 channels': 5,
-    '5 channels': 6,
-    '5.1 channels': 7
-};
+var ChannelType;
+(function (ChannelType) {
+    ChannelType[ChannelType["mono"] = 1] = "mono";
+    ChannelType[ChannelType["stereo"] = 2] = "stereo";
+    ChannelType[ChannelType["channels"] = 3] = "channels";
+    ChannelType[ChannelType["quad"] = 4] = "quad";
+    ChannelType[ChannelType["4 channels"] = 5] = "4 channels";
+    ChannelType[ChannelType["5 channels"] = 6] = "5 channels";
+    ChannelType[ChannelType["5.1 channels"] = 7] = "5.1 channels";
+})(ChannelType = exports.ChannelType || (exports.ChannelType = {}));
 /**
  * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
  */
-export const FormatChunk = {
+exports.FormatChunk = {
     len: 40,
     get: (buf, off) => {
         return {

package/node_modules/music-metadata/lib/dsf/DsfParser.d.ts

@@ -1,18 +1,4 @@
-import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-declare const DsdContentParseError_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 DsdContentParseError extends DsdContentParseError_base {
-}
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser';
 /**
  * DSF (dsd stream file) File Parser
  * Ref: https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
@@ -21,4 +7,3 @@ export declare class DsfParser extends AbstractID3Parser {
     postId3v2Parse(): Promise<void>;
     private parseChunks;
 }
-export {};