@dragon708/docmind-markdown 1.2.5 → 1.2.6

package/node_modules/music-metadata/lib/ogg/theora/TheoraParser.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TheoraParser = void 0;
+const debug_1 = require("debug");
+const Theora_1 = require("./Theora");
+const debug = (0, debug_1.default)('music-metadata:parser:ogg:theora');
+/**
+ * Ref:
+ * - https://theora.org/doc/Theora.pdf
+ */
+class TheoraParser {
+    constructor(metadata, options, tokenizer) {
+        this.metadata = metadata;
+        this.tokenizer = tokenizer;
+    }
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header, pageData) {
+        if (header.headerType.firstPage) {
+            this.parseFirstPage(header, pageData);
+        }
+    }
+    flush() {
+        debug('flush');
+    }
+    calculateDuration(header) {
+        debug('duration calculation not implemented');
+    }
+    /**
+     * Parse first Theora Ogg page. the initial identification header packet
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    parseFirstPage(header, pageData) {
+        debug('First Ogg/Theora page');
+        this.metadata.setFormat('codec', 'Theora');
+        const idHeader = Theora_1.IdentificationHeader.get(pageData, 0);
+        this.metadata.setFormat('bitrate', idHeader.nombr);
+    }
+}
+exports.TheoraParser = TheoraParser;

package/node_modules/music-metadata/lib/ogg/vorbis/Vorbis.d.ts

@@ -1,5 +1,6 @@
-import type { IPicture } from '../../type.js';
-import type { IGetToken } from 'strtok3';
+/// <reference types="node" />
+import { IGetToken } from 'strtok3/lib/core';
+import { IPicture } from '../../type';
 /**
  * Interface to parsed result of METADATA_BLOCK_PICTURE
  * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE
@@ -20,11 +21,11 @@ export interface IVorbisPicture extends IPicture {
  * // ToDo: move to ID3 / APIC?
  */
 export declare class VorbisPictureToken implements IGetToken<IVorbisPicture> {
+    len: any;
     static fromBase64(base64str: string): IVorbisPicture;
-    static fromBuffer(buffer: Uint8Array): IVorbisPicture;
-    len: number;
-    constructor(len: number);
-    get(buffer: Uint8Array, offset: number): IVorbisPicture;
+    static fromBuffer(buffer: Buffer): IVorbisPicture;
+    constructor(len: any);
+    get(buffer: Buffer, offset: number): IVorbisPicture;
 }
 /**
  * Vorbis 1 decoding tokens

package/node_modules/music-metadata/lib/ogg/vorbis/Vorbis.js

@@ -1,14 +1,17 @@
-import * as Token from 'token-types';
-import { AttachedPictureType } from '../../id3v2/ID3v2Token.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentificationHeader = exports.CommonHeader = exports.VorbisPictureToken = void 0;
+const Token = require("token-types");
+const ID3v2Token_1 = require("../../id3v2/ID3v2Token");
 /**
  * Parse the METADATA_BLOCK_PICTURE
  * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE
  * Ref: https://xiph.org/flac/format.html#metadata_block_picture
  * // ToDo: move to ID3 / APIC?
  */
-export class VorbisPictureToken {
+class VorbisPictureToken {
     static fromBase64(base64str) {
-        return VorbisPictureToken.fromBuffer(Uint8Array.from(atob(base64str), c => c.charCodeAt(0)));
+        return this.fromBuffer(Buffer.from(base64str, 'base64'));
     }
     static fromBuffer(buffer) {
         const pic = new VorbisPictureToken(buffer.length);
@@ -18,27 +21,17 @@ export class VorbisPictureToken {
         this.len = len;
     }
     get(buffer, offset) {
-        const type = AttachedPictureType[Token.UINT32_BE.get(buffer, offset)];
-        offset += 4;
-        const mimeLen = Token.UINT32_BE.get(buffer, offset);
-        offset += 4;
-        const format = new Token.StringType(mimeLen, 'utf-8').get(buffer, offset);
-        offset += mimeLen;
-        const descLen = Token.UINT32_BE.get(buffer, offset);
-        offset += 4;
-        const description = new Token.StringType(descLen, 'utf-8').get(buffer, offset);
-        offset += descLen;
-        const width = Token.UINT32_BE.get(buffer, offset);
-        offset += 4;
-        const height = Token.UINT32_BE.get(buffer, offset);
-        offset += 4;
-        const colour_depth = Token.UINT32_BE.get(buffer, offset);
-        offset += 4;
-        const indexed_color = Token.UINT32_BE.get(buffer, offset);
-        offset += 4;
-        const picDataLen = Token.UINT32_BE.get(buffer, offset);
-        offset += 4;
-        const data = buffer.slice(offset, offset + picDataLen);
+        const type = ID3v2Token_1.AttachedPictureType[Token.UINT32_BE.get(buffer, offset)];
+        const mimeLen = Token.UINT32_BE.get(buffer, offset += 4);
+        const format = buffer.toString('utf-8', offset += 4, offset + mimeLen);
+        const descLen = Token.UINT32_BE.get(buffer, offset += mimeLen);
+        const description = buffer.toString('utf-8', offset += 4, offset + descLen);
+        const width = Token.UINT32_BE.get(buffer, offset += descLen);
+        const height = Token.UINT32_BE.get(buffer, offset += 4);
+        const colour_depth = Token.UINT32_BE.get(buffer, offset += 4);
+        const indexed_color = Token.UINT32_BE.get(buffer, offset += 4);
+        const picDataLen = Token.UINT32_BE.get(buffer, offset += 4);
+        const data = Buffer.from(buffer.slice(offset += 4, offset + picDataLen));
         return {
             type,
             format,
@@ -51,15 +44,16 @@ export class VorbisPictureToken {
         };
     }
 }
+exports.VorbisPictureToken = VorbisPictureToken;
 /**
  * Comment header decoder
  * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-620004.2.1
  */
-export const CommonHeader = {
+exports.CommonHeader = {
     len: 7,
     get: (buf, off) => {
         return {
-            packetType: Token.UINT8.get(buf, off),
+            packetType: buf.readUInt8(off),
             vorbis: new Token.StringType(6, 'ascii').get(buf, off + 1)
         };
     }
@@ -68,16 +62,17 @@ export const CommonHeader = {
  * Identification header decoder
  * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-630004.2.2
  */
-export const IdentificationHeader = {
+exports.IdentificationHeader = {
     len: 23,
     get: (uint8Array, off) => {
+        const dataView = new DataView(uint8Array.buffer, uint8Array.byteOffset);
         return {
-            version: Token.UINT32_LE.get(uint8Array, off + 0),
-            channelMode: Token.UINT8.get(uint8Array, off + 4),
-            sampleRate: Token.UINT32_LE.get(uint8Array, off + 5),
-            bitrateMax: Token.UINT32_LE.get(uint8Array, off + 9),
-            bitrateNominal: Token.UINT32_LE.get(uint8Array, off + 13),
-            bitrateMin: Token.UINT32_LE.get(uint8Array, off + 17)
+            version: dataView.getUint32(off + 0, true),
+            channelMode: dataView.getUint8(off + 4),
+            sampleRate: dataView.getUint32(off + 5, true),
+            bitrateMax: dataView.getUint32(off + 9, true),
+            bitrateNominal: dataView.getUint32(off + 13, true),
+            bitrateMin: dataView.getUint32(off + 17, true)
         };
     }
 };

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisDecoder.d.ts

@@ -1,7 +1,7 @@
 export declare class VorbisDecoder {
     private readonly data;
     private offset;
-    constructor(data: Uint8Array, offset: number);
+    constructor(data: Uint8Array, offset: any);
     readInt32(): number;
     readStringUtf8(): string;
     parseUserComment(): {

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisDecoder.js

@@ -1,6 +1,8 @@
-import * as Token from 'token-types';
-import { textDecode } from '@borewit/text-codec';
-export class VorbisDecoder {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VorbisDecoder = void 0;
+const Token = require("token-types");
+class VorbisDecoder {
     constructor(data, offset) {
         this.data = data;
         this.offset = offset;
@@ -12,7 +14,7 @@ export class VorbisDecoder {
     }
     readStringUtf8() {
         const len = this.readInt32();
-        const value = textDecode(this.data.subarray(this.offset, this.offset + len), 'utf-8');
+        const value = Buffer.from(this.data).toString('utf-8', this.offset, this.offset + len);
         this.offset += len;
         return value;
     }
@@ -21,9 +23,10 @@ export class VorbisDecoder {
         const v = this.readStringUtf8();
         const idx = v.indexOf('=');
         return {
-            key: v.substring(0, idx).toUpperCase(),
-            value: v.substring(idx + 1),
+            key: v.slice(0, idx).toUpperCase(),
+            value: v.slice(idx + 1),
             len: this.offset - offset0
         };
     }
 }
+exports.VorbisDecoder = VorbisDecoder;

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisParser.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { IOptions } from '../../type';
+import { INativeMetadataCollector } from '../../common/MetadataCollector';
+import * as Ogg from '../Ogg';
+import { IVorbisPicture } from './Vorbis';
+/**
+ * Vorbis 1 Parser.
+ * Used by OggParser
+ */
+export declare class VorbisParser implements Ogg.IPageConsumer {
+    protected metadata: INativeMetadataCollector;
+    protected options: IOptions;
+    private pageSegments;
+    constructor(metadata: INativeMetadataCollector, options: IOptions);
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header: Ogg.IPageHeader, pageData: Buffer): void;
+    flush(): void;
+    parseUserComment(pageData: Buffer, offset: number): number;
+    addTag(id: string, value: string | IVorbisPicture): void;
+    calculateDuration(header: Ogg.IPageHeader): void;
+    /**
+     * Parse first Ogg/Vorbis page
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    protected parseFirstPage(header: Ogg.IPageHeader, pageData: Buffer): void;
+    protected parseFullPage(pageData: Buffer): void;
+    /**
+     * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
+     */
+    protected parseUserCommentList(pageData: Buffer, offset: number): void;
+}

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisParser.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VorbisParser = void 0;
+const Token = require("token-types");
+const debug_1 = require("debug");
+const VorbisDecoder_1 = require("./VorbisDecoder");
+const Vorbis_1 = require("./Vorbis");
+const debug = (0, debug_1.default)('music-metadata:parser:ogg:vorbis1');
+/**
+ * Vorbis 1 Parser.
+ * Used by OggParser
+ */
+class VorbisParser {
+    constructor(metadata, options) {
+        this.metadata = metadata;
+        this.options = options;
+        this.pageSegments = [];
+    }
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header, pageData) {
+        if (header.headerType.firstPage) {
+            this.parseFirstPage(header, pageData);
+        }
+        else {
+            if (header.headerType.continued) {
+                if (this.pageSegments.length === 0) {
+                    throw new Error("Cannot continue on previous page");
+                }
+                this.pageSegments.push(pageData);
+            }
+            if (header.headerType.lastPage || !header.headerType.continued) {
+                // Flush page segments
+                if (this.pageSegments.length > 0) {
+                    const fullPage = Buffer.concat(this.pageSegments);
+                    this.parseFullPage(fullPage);
+                }
+                // Reset page segments
+                this.pageSegments = header.headerType.lastPage ? [] : [pageData];
+            }
+        }
+        if (header.headerType.lastPage) {
+            this.calculateDuration(header);
+        }
+    }
+    flush() {
+        this.parseFullPage(Buffer.concat(this.pageSegments));
+    }
+    parseUserComment(pageData, offset) {
+        const decoder = new VorbisDecoder_1.VorbisDecoder(pageData, offset);
+        const tag = decoder.parseUserComment();
+        this.addTag(tag.key, tag.value);
+        return tag.len;
+    }
+    addTag(id, value) {
+        if (id === 'METADATA_BLOCK_PICTURE' && (typeof value === 'string')) {
+            if (this.options.skipCovers) {
+                debug(`Ignore picture`);
+                return;
+            }
+            value = Vorbis_1.VorbisPictureToken.fromBase64(value);
+            debug(`Push picture: id=${id}, format=${value.format}`);
+        }
+        else {
+            debug(`Push tag: id=${id}, value=${value}`);
+        }
+        this.metadata.addTag('vorbis', id, value);
+    }
+    calculateDuration(header) {
+        if (this.metadata.format.sampleRate && header.absoluteGranulePosition >= 0) {
+            // Calculate duration
+            this.metadata.setFormat('numberOfSamples', header.absoluteGranulePosition);
+            this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
+        }
+    }
+    /**
+     * Parse first Ogg/Vorbis page
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    parseFirstPage(header, pageData) {
+        this.metadata.setFormat('codec', 'Vorbis I');
+        debug("Parse first page");
+        // Parse  Vorbis common header
+        const commonHeader = Vorbis_1.CommonHeader.get(pageData, 0);
+        if (commonHeader.vorbis !== 'vorbis')
+            throw new Error('Metadata does not look like Vorbis');
+        if (commonHeader.packetType === 1) {
+            const idHeader = Vorbis_1.IdentificationHeader.get(pageData, Vorbis_1.CommonHeader.len);
+            this.metadata.setFormat('sampleRate', idHeader.sampleRate);
+            this.metadata.setFormat('bitrate', idHeader.bitrateNominal);
+            this.metadata.setFormat('numberOfChannels', idHeader.channelMode);
+            debug("sample-rate=%s[hz], bitrate=%s[b/s], channel-mode=%s", idHeader.sampleRate, idHeader.bitrateNominal, idHeader.channelMode);
+        }
+        else
+            throw new Error('First Ogg page should be type 1: the identification header');
+    }
+    parseFullPage(pageData) {
+        // New page
+        const commonHeader = Vorbis_1.CommonHeader.get(pageData, 0);
+        debug("Parse full page: type=%s, byteLength=%s", commonHeader.packetType, pageData.byteLength);
+        switch (commonHeader.packetType) {
+            case 3: //  type 3: comment header
+                return this.parseUserCommentList(pageData, Vorbis_1.CommonHeader.len);
+            case 1: // type 1: the identification header
+            case 5: // type 5: setup header type
+                break; // ignore
+        }
+    }
+    /**
+     * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
+     */
+    parseUserCommentList(pageData, offset) {
+        const strLen = Token.UINT32_LE.get(pageData, offset);
+        offset += 4;
+        // const vendorString = new Token.StringType(strLen, 'utf-8').get(pageData, offset);
+        offset += strLen;
+        let userCommentListLength = Token.UINT32_LE.get(pageData, offset);
+        offset += 4;
+        while (userCommentListLength-- > 0) {
+            offset += this.parseUserComment(pageData, offset);
+        }
+    }
+}
+exports.VorbisParser = VorbisParser;

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisTagMapper.d.ts

@@ -1,7 +1,7 @@
-import { CommonTagMapper } from '../../common/GenericTagMapper.js';
-import type { IRating, ITag } from '../../type.js';
+import { CommonTagMapper } from '../../common/GenericTagMapper';
+import { IRating, ITag } from '../../type';
 export declare class VorbisTagMapper extends CommonTagMapper {
-    static toRating(email: string | undefined | null, rating: string, maxScore: number): IRating;
+    static toRating(email: string, rating: string, maxScore: number): IRating;
     constructor();
     protected postMap(tag: ITag): void;
 }

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisTagMapper.js

@@ -1,4 +1,7 @@
-import { CommonTagMapper } from '../../common/GenericTagMapper.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VorbisTagMapper = void 0;
+const GenericTagMapper_1 = require("../../common/GenericTagMapper");
 /**
  * Vorbis tag mappings
  *
@@ -16,7 +19,6 @@ const vorbisTagMap = {
     DATE: 'date',
     ORIGINALDATE: 'originaldate',
     ORIGINALYEAR: 'originalyear',
-    RELEASEDATE: 'releasedate',
     COMMENT: 'comment',
     TRACKNUMBER: 'track',
     DISCNUMBER: 'disk',
@@ -109,11 +111,11 @@ const vorbisTagMap = {
     REPLAYGAIN_ALBUM_MINMAX: 'replaygain_album_minmax',
     REPLAYGAIN_UNDO: 'replaygain_undo'
 };
-export class VorbisTagMapper extends CommonTagMapper {
+class VorbisTagMapper extends GenericTagMapper_1.CommonTagMapper {
     static toRating(email, rating, maxScore) {
         return {
-            source: email ? email.toLowerCase() : undefined,
-            rating: (Number.parseFloat(rating) / maxScore) * CommonTagMapper.maxRatingScore
+            source: email ? email.toLowerCase() : email,
+            rating: (parseFloat(rating) / maxScore) * GenericTagMapper_1.CommonTagMapper.maxRatingScore
         };
     }
     constructor() {
@@ -131,3 +133,5 @@ export class VorbisTagMapper extends CommonTagMapper {
         }
     }
 }
+exports.VorbisTagMapper = VorbisTagMapper;
+//# sourceMappingURL=VorbisTagMapper.js.map

package/node_modules/music-metadata/lib/riff/RiffChunk.d.ts

@@ -1,6 +1,6 @@
-import type { IGetToken } from 'strtok3';
-import type { IChunkHeader } from '../iff/index.js';
-export type { IChunkHeader } from '../iff/index.js';
+import { IGetToken } from 'strtok3/lib/core';
+import { IChunkHeader } from '../iff';
+export { IChunkHeader } from '../iff';
 /**
  * Common RIFF chunk header
  */
@@ -9,8 +9,8 @@ export declare const Header: IGetToken<IChunkHeader>;
  * Token to parse RIFF-INFO tag value
  */
 export declare class ListInfoTagValue implements IGetToken<string> {
-    len: number;
     private tagHeader;
+    len: number;
     constructor(tagHeader: IChunkHeader);
-    get(buf: Uint8Array, off: number): string;
+    get(buf: any, off: any): string;
 }

package/node_modules/music-metadata/lib/riff/RiffChunk.js

@@ -1,22 +1,25 @@
-import * as Token from 'token-types';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListInfoTagValue = exports.Header = void 0;
+const Token = require("token-types");
 /**
  * Common RIFF chunk header
  */
-export const Header = {
+exports.Header = {
     len: 8,
     get: (buf, off) => {
         return {
             // Group-ID
-            chunkID: new Token.StringType(4, 'latin1').get(buf, off),
+            chunkID: buf.toString('binary', off, off + 4),
             // Size
-            chunkSize: Token.UINT32_LE.get(buf, off + 4)
+            chunkSize: Token.UINT32_LE.get(buf, 4)
         };
     }
 };
 /**
  * Token to parse RIFF-INFO tag value
  */
-export class ListInfoTagValue {
+class ListInfoTagValue {
     constructor(tagHeader) {
         this.tagHeader = tagHeader;
         this.len = tagHeader.chunkSize;
@@ -26,3 +29,4 @@ export class ListInfoTagValue {
         return new Token.StringType(this.tagHeader.chunkSize, 'ascii').get(buf, off);
     }
 }
+exports.ListInfoTagValue = ListInfoTagValue;

package/node_modules/music-metadata/lib/riff/RiffInfoTagMap.d.ts

@@ -1,5 +1,5 @@
-import type { INativeTagMap } from '../common/GenericTagTypes.js';
-import { CommonTagMapper } from '../common/GenericTagMapper.js';
+import { INativeTagMap } from '../common/GenericTagTypes';
+import { CommonTagMapper } from '../common/GenericTagMapper';
 /**
  * RIFF Info Tags; part of the EXIF 2.3
  * Ref: http://owl.phy.queensu.ca/~phil/exiftool/TagNames/RIFF.html#Info

package/node_modules/music-metadata/lib/riff/RiffInfoTagMap.js

@@ -1,34 +1,39 @@
-import { CommonTagMapper } from '../common/GenericTagMapper.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiffInfoTagMapper = exports.riffInfoTagMap = void 0;
+const GenericTagMapper_1 = require("../common/GenericTagMapper");
 /**
  * RIFF Info Tags; part of the EXIF 2.3
  * Ref: http://owl.phy.queensu.ca/~phil/exiftool/TagNames/RIFF.html#Info
  */
-export const riffInfoTagMap = {
-    IART: 'artist', // Artist
-    ICRD: 'date', // DateCreated
-    INAM: 'title', // Title
+exports.riffInfoTagMap = {
+    IART: 'artist',
+    ICRD: 'date',
+    INAM: 'title',
     TITL: 'title',
-    IPRD: 'album', // Product
+    IPRD: 'album',
     ITRK: 'track',
-    IPRT: 'track', // Additional tag for track index
-    COMM: 'comment', // Comments
-    ICMT: 'comment', // Country
+    IPRT: 'track',
+    COMM: 'comment',
+    ICMT: 'comment',
     ICNT: 'releasecountry',
-    GNRE: 'genre', // Genre
-    IWRI: 'writer', // WrittenBy
+    GNRE: 'genre',
+    IWRI: 'writer',
     RATE: 'rating',
     YEAR: 'year',
-    ISFT: 'encodedby', // Software
-    CODE: 'encodedby', // EncodedBy
-    TURL: 'website', // URL,
-    IGNR: 'genre', // Genre
-    IENG: 'engineer', // Engineer
-    ITCH: 'technician', // Technician
-    IMED: 'media', // Original Media
+    ISFT: 'encodedby',
+    CODE: 'encodedby',
+    TURL: 'website',
+    IGNR: 'genre',
+    IENG: 'engineer',
+    ITCH: 'technician',
+    IMED: 'media',
     IRPD: 'album' // Product, where the file was intended for
 };
-export class RiffInfoTagMapper extends CommonTagMapper {
+class RiffInfoTagMapper extends GenericTagMapper_1.CommonTagMapper {
     constructor() {
-        super(['exif'], riffInfoTagMap);
+        super(['exif'], exports.riffInfoTagMap);
     }
 }
+exports.RiffInfoTagMapper = RiffInfoTagMapper;
+//# sourceMappingURL=RiffInfoTagMap.js.map