@probityrules/jsmediatags 4.0.0

package/build/ArrayFileReader.js

@@ -0,0 +1,30 @@
+"use strict";
+const MediaFileReader = require("./MediaFileReader");
+class ArrayFileReader extends MediaFileReader {
+    constructor(array) {
+        super();
+        this._array = array;
+        this._size = array.length;
+        this._isInitialized = true;
+    }
+    static canReadFile(file) {
+        return (Array.isArray(file) ||
+            (typeof Buffer === "function" &&
+                typeof Buffer.isBuffer === "function" &&
+                Buffer.isBuffer(file)));
+    }
+    init(callbacks) {
+        setTimeout(callbacks.onSuccess, 0);
+    }
+    loadRange(range, callbacks) {
+        void range;
+        setTimeout(callbacks.onSuccess, 0);
+    }
+    getByteAt(offset) {
+        if (offset >= this._array.length) {
+            throw new Error("Offset " + offset + " hasn't been loaded yet.");
+        }
+        return this._array[offset];
+    }
+}
+module.exports = ArrayFileReader;

package/build/BlobFileReader.d.ts

@@ -0,0 +1,12 @@
+declare const MediaFileReader: any;
+import type { LoadCallbackType } from "./types";
+declare class BlobFileReader extends MediaFileReader {
+    private _blob;
+    private _fileData;
+    constructor(blob: Blob);
+    static canReadFile(file: unknown): boolean;
+    _init(callbacks: LoadCallbackType): void;
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+    getByteAt(offset: number): number;
+}
+export = BlobFileReader;

package/build/BlobFileReader.js

@@ -0,0 +1,47 @@
+"use strict";
+const ChunkedFileData = require("./ChunkedFileData");
+const MediaFileReader = require("./MediaFileReader");
+class BlobFileReader extends MediaFileReader {
+    constructor(blob) {
+        super();
+        this._blob = blob;
+        this._fileData = new ChunkedFileData();
+    }
+    static canReadFile(file) {
+        return ((typeof Blob !== "undefined" && file instanceof Blob) ||
+            (typeof File !== "undefined" && file instanceof File));
+    }
+    _init(callbacks) {
+        this._size = this._blob.size;
+        setTimeout(callbacks.onSuccess, 1);
+    }
+    loadRange(range, callbacks) {
+        const self = this;
+        const blobSlice = this._blob.slice ||
+            this._blob.mozSlice ||
+            this._blob.webkitSlice;
+        const blob = blobSlice.call(this._blob, range[0], range[1] + 1);
+        const browserFileReader = new FileReader();
+        browserFileReader.onloadend = function () {
+            const result = browserFileReader.result;
+            const intArray = new Uint8Array(result);
+            self._fileData.addData(range[0], intArray);
+            callbacks.onSuccess();
+        };
+        browserFileReader.onerror =
+            browserFileReader.onabort =
+                function () {
+                    if (callbacks.onError) {
+                        callbacks.onError({
+                            type: "blob",
+                            info: browserFileReader.error,
+                        });
+                    }
+                };
+        browserFileReader.readAsArrayBuffer(blob);
+    }
+    getByteAt(offset) {
+        return this._fileData.getByteAt(offset);
+    }
+}
+module.exports = BlobFileReader;

package/build/ByteArrayUtils.d.ts

@@ -0,0 +1,9 @@
+import type { ByteArray } from "./types";
+declare const _default: {
+    bin: (string: string) => ByteArray;
+    pad: (array: Array<number>, size: number) => Array<number>;
+    getSynchsafeInteger32: (number: number) => ByteArray;
+    getInteger32: (number: number) => ByteArray;
+    getInteger24: (number: number) => ByteArray;
+};
+export = _default;

package/build/ByteArrayUtils.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Converts a string to a binary array
+ */
+const bin = function (string) {
+    const binaryArray = new Array(string.length);
+    for (let i = 0; i < string.length; i++) {
+        binaryArray[i] = string.charCodeAt(i);
+    }
+    return binaryArray;
+};
+/**
+ * Pads an array with \0 until it is size length.
+ */
+const pad = function (array, size) {
+    for (let i = array.length; i < size; i++) {
+        array.push(0);
+    }
+    return array;
+};
+const getSynchsafeInteger32 = function (number) {
+    return [
+        (number >> 21) & 0x7f,
+        (number >> 14) & 0x7f,
+        (number >> 7) & 0x7f,
+        number & 0x7f,
+    ];
+};
+const getInteger32 = function (number) {
+    return [
+        (number >> 24) & 0xff,
+        (number >> 16) & 0xff,
+        (number >> 8) & 0xff,
+        number & 0xff,
+    ];
+};
+const getInteger24 = function (number) {
+    return [(number >> 16) & 0xff, (number >> 8) & 0xff, number & 0xff];
+};
+module.exports = {
+    bin: bin,
+    pad: pad,
+    getSynchsafeInteger32: getSynchsafeInteger32,
+    getInteger32: getInteger32,
+    getInteger24: getInteger24,
+};

package/build/ChunkedFileData.d.ts

@@ -0,0 +1,28 @@
+import type { DataType } from "./types";
+declare class ChunkedFileData {
+    static get NOT_FOUND(): number;
+    private _fileData;
+    constructor();
+    /**
+     * Adds data to the file storage at a specific offset.
+     */
+    addData(offset: number, data: DataType): void;
+    _concatData(dataA: DataType, dataB: DataType): DataType;
+    _sliceData(data: DataType, begin: number, end: number): DataType;
+    /**
+     * Finds the chunk range that overlaps the [offsetStart-1,offsetEnd+1] range.
+     * When a chunk is adjacent to the offset we still consider it part of the
+     * range (this is the situation of offsetStart-1 or offsetEnd+1).
+     * When no chunks are found `insertIx` denotes the index where the data
+     * should be inserted in the data list (startIx == NOT_FOUND and endIX ==
+     * NOT_FOUND).
+     */
+    _getChunkRange(offsetStart: number, offsetEnd: number): {
+        startIx: number;
+        endIx: number;
+        insertIx?: number;
+    };
+    hasDataRange(offsetStart: number, offsetEnd: number): boolean;
+    getByteAt(offset: number): number;
+}
+export = ChunkedFileData;

package/build/ChunkedFileData.js

@@ -0,0 +1,171 @@
+/**
+ * This class represents a file that might not have all its data loaded yet.
+ * It is used when loading the entire file is not an option because it's too
+ * expensive. Instead, parts of the file are loaded and added only when needed.
+ * From a reading point of view is as if the entire file is loaded. The
+ * exception is when the data is not available yet, an error will be thrown.
+ * This class does not load the data, it just manages it. It provides operations
+ * to add and read data from the file.
+ */
+"use strict";
+const NOT_FOUND = -1;
+function dataLength(data) {
+    return data.length;
+}
+function isUint8(data) {
+    return data instanceof Uint8Array;
+}
+class ChunkedFileData {
+    static get NOT_FOUND() {
+        return NOT_FOUND;
+    }
+    constructor() {
+        this._fileData = [];
+    }
+    /**
+     * Adds data to the file storage at a specific offset.
+     */
+    addData(offset, data) {
+        const offsetEnd = offset + dataLength(data) - 1;
+        const chunkRange = this._getChunkRange(offset, offsetEnd);
+        if (chunkRange.startIx === NOT_FOUND) {
+            this._fileData.splice(chunkRange.insertIx || 0, 0, {
+                offset: offset,
+                data: data,
+            });
+        }
+        else {
+            const firstChunk = this._fileData[chunkRange.startIx];
+            const lastChunk = this._fileData[chunkRange.endIx];
+            const needsPrepend = offset > firstChunk.offset;
+            const needsAppend = offsetEnd < lastChunk.offset + dataLength(lastChunk.data) - 1;
+            let chunk = {
+                offset: Math.min(offset, firstChunk.offset),
+                data: data,
+            };
+            if (needsPrepend) {
+                const slicedData = this._sliceData(firstChunk.data, 0, offset - firstChunk.offset);
+                chunk.data = this._concatData(slicedData, data);
+            }
+            if (needsAppend) {
+                const slicedData = this._sliceData(chunk.data, 0, lastChunk.offset - chunk.offset);
+                chunk.data = this._concatData(slicedData, lastChunk.data);
+            }
+            this._fileData.splice(chunkRange.startIx, chunkRange.endIx - chunkRange.startIx + 1, chunk);
+        }
+    }
+    _concatData(dataA, dataB) {
+        if (isUint8(dataA) && isUint8(dataB)) {
+            const Ctor = dataA.constructor;
+            const dataAandB = new Ctor(dataA.length + dataB.length);
+            dataAandB.set(dataA, 0);
+            dataAandB.set(dataB, dataA.length);
+            return dataAandB;
+        }
+        if (Array.isArray(dataA) && Array.isArray(dataB)) {
+            return dataA.concat(dataB);
+        }
+        const sA = typeof dataA === "string" ? dataA : "";
+        const sB = typeof dataB === "string" ? dataB : "";
+        return sA + sB;
+    }
+    _sliceData(data, begin, end) {
+        if (typeof data === "string") {
+            return data.slice(begin, end);
+        }
+        if (Array.isArray(data)) {
+            return data.slice(begin, end);
+        }
+        const view = data;
+        if (typeof view.subarray === "function") {
+            return view.subarray(begin, end);
+        }
+        return view.slice(begin, end);
+    }
+    /**
+     * Finds the chunk range that overlaps the [offsetStart-1,offsetEnd+1] range.
+     * When a chunk is adjacent to the offset we still consider it part of the
+     * range (this is the situation of offsetStart-1 or offsetEnd+1).
+     * When no chunks are found `insertIx` denotes the index where the data
+     * should be inserted in the data list (startIx == NOT_FOUND and endIX ==
+     * NOT_FOUND).
+     */
+    _getChunkRange(offsetStart, offsetEnd) {
+        let startChunkIx = NOT_FOUND;
+        let endChunkIx = NOT_FOUND;
+        let insertIx = 0;
+        for (let i = 0; i < this._fileData.length; i++, insertIx = i) {
+            const chunkOffsetStart = this._fileData[i].offset;
+            const chunkOffsetEnd = chunkOffsetStart + dataLength(this._fileData[i].data);
+            if (offsetEnd < chunkOffsetStart - 1) {
+                break;
+            }
+            if (offsetStart <= chunkOffsetEnd + 1 &&
+                offsetEnd >= chunkOffsetStart - 1) {
+                startChunkIx = i;
+                break;
+            }
+        }
+        if (startChunkIx === NOT_FOUND) {
+            return {
+                startIx: NOT_FOUND,
+                endIx: NOT_FOUND,
+                insertIx: insertIx,
+            };
+        }
+        for (let i = startChunkIx; i < this._fileData.length; i++) {
+            const chunkOffsetStart = this._fileData[i].offset;
+            const chunkOffsetEnd = chunkOffsetStart + dataLength(this._fileData[i].data);
+            if (offsetEnd >= chunkOffsetStart - 1) {
+                endChunkIx = i;
+            }
+            if (offsetEnd <= chunkOffsetEnd + 1) {
+                break;
+            }
+        }
+        if (endChunkIx === NOT_FOUND) {
+            endChunkIx = startChunkIx;
+        }
+        return {
+            startIx: startChunkIx,
+            endIx: endChunkIx,
+        };
+    }
+    hasDataRange(offsetStart, offsetEnd) {
+        for (let i = 0; i < this._fileData.length; i++) {
+            const chunk = this._fileData[i];
+            if (offsetEnd < chunk.offset) {
+                return false;
+            }
+            if (offsetStart >= chunk.offset &&
+                offsetEnd < chunk.offset + dataLength(chunk.data)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getByteAt(offset) {
+        let dataChunk;
+        for (let i = 0; i < this._fileData.length; i++) {
+            const dataChunkStart = this._fileData[i].offset;
+            const dataChunkEnd = dataChunkStart + dataLength(this._fileData[i].data) - 1;
+            if (offset >= dataChunkStart && offset <= dataChunkEnd) {
+                dataChunk = this._fileData[i];
+                break;
+            }
+        }
+        if (dataChunk) {
+            const idx = offset - dataChunk.offset;
+            const d = dataChunk.data;
+            if (typeof d === "string") {
+                return d.charCodeAt(idx) & 0xff;
+            }
+            if (Array.isArray(d)) {
+                return d[idx];
+            }
+            return d[idx];
+        }
+        throw new Error("Offset " + offset + " hasn't been loaded yet.");
+    }
+}
+module.exports = ChunkedFileData;

package/build/DecodedString.d.ts

@@ -0,0 +1,6 @@
+/** Return type of StringUtils decoded-string readers */
+export interface DecodedString {
+    bytesReadCount: number;
+    length: number;
+    toString(): string;
+}

package/build/DecodedString.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/FLACTagContents.d.ts

@@ -0,0 +1,19 @@
+import type { ByteArray } from './types';
+declare class FLACTagContents {
+    _blocks: Array<MetadataBlock>;
+    constructor(blocks?: Array<MetadataBlock>);
+    toArray(): ByteArray;
+    static createBlock(type: number, data: ByteArray): MetadataBlock;
+    static createStreamBlock(): MetadataBlock;
+    static createCommentBlock(...data: Array<Array<string>>): MetadataBlock;
+    static createPictureBlock(): MetadataBlock;
+}
+declare class MetadataBlock {
+    _data: Array<number>;
+    _final: boolean;
+    _type: number;
+    constructor(type: number, data: ByteArray);
+    setFinal(): void;
+    toArray(): ByteArray;
+}
+export = FLACTagContents;

package/build/FLACTagContents.js

@@ -0,0 +1,54 @@
+"use strict";
+const bin = require('./ByteArrayUtils').bin;
+const getInteger24 = require('./ByteArrayUtils').getInteger24;
+const getInteger32 = require('./ByteArrayUtils').getInteger32;
+class FLACTagContents {
+    constructor(blocks) {
+        this._blocks = [];
+        this._blocks.push(FLACTagContents.createStreamBlock());
+        this._blocks = this._blocks.concat(blocks || []);
+    }
+    toArray() {
+        this._blocks[this._blocks.length - 1].setFinal();
+        return this._blocks.reduce(function (array, block) {
+            return array.concat(block.toArray());
+        }, bin("fLaC"));
+    }
+    static createBlock(type, data) {
+        return new MetadataBlock(type, data);
+    }
+    static createStreamBlock() {
+        let data = [].concat([0x00, 0x00, 0x22], Array(34).fill(0x00));
+        return this.createBlock(0, data);
+    }
+    static createCommentBlock(...data) {
+        let length = 12;
+        let byteArray = [];
+        for (let i = 0; i < data.length; i++) {
+            length += data[i][0].length + data[i][1].length + 5;
+            byteArray = byteArray.concat(getInteger32(data[i][0].length + data[i][1].length + 1).reverse());
+            let entry = data[i][0] + "=" + data[i][1];
+            byteArray = byteArray.concat(bin(entry));
+        }
+        let array = [].concat(getInteger24(length), [0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], getInteger32(data.length).reverse(), byteArray);
+        return this.createBlock(4, array);
+    }
+    static createPictureBlock() {
+        let data = [].concat(getInteger24(45), getInteger32(3), getInteger32(10), bin("image/jpeg"), getInteger32(9), bin("A Picture"), Array(16).fill(0x00), getInteger32(4), bin("data"));
+        return this.createBlock(6, data);
+    }
+}
+class MetadataBlock {
+    constructor(type, data) {
+        this._type = type;
+        this._data = data;
+        this._final = false;
+    }
+    setFinal() {
+        this._final = true;
+    }
+    toArray() {
+        return [this._type + (this._final ? 128 : 0)].concat(this._data);
+    }
+}
+module.exports = FLACTagContents;

package/build/FLACTagReader.d.ts

@@ -0,0 +1,103 @@
+declare const MediaTagReader: any;
+declare const MediaFileReader: any;
+type MediaReader = InstanceType<typeof MediaFileReader>;
+import type { LoadCallbackType, ByteRange, TagType } from './types';
+/**
+ * Class representing a MediaTagReader that parses FLAC tags.
+ */
+declare class FLACTagReader extends MediaTagReader {
+    _commentOffset?: number;
+    _pictureOffset?: number;
+    /**
+     * Gets the byte range for the tag identifier.
+     *
+     * Because the Vorbis comment block is not guaranteed to be in a specified
+     * location, we can only load the first 4 bytes of the file to confirm it
+     * is a FLAC first.
+     *
+     * @return {ByteRange} The byte range that identifies the tag for a FLAC.
+     */
+    static getTagIdentifierByteRange(): ByteRange;
+    /**
+     * Determines whether or not this reader can read a certain tag format.
+     *
+     * This checks that the first 4 characters in the file are fLaC, which
+     * according to the FLAC file specification should be the characters that
+     * indicate a FLAC file.
+     *
+     * @return {boolean} True if the header is fLaC, false otherwise.
+     */
+    static canReadTagFormat(tagIdentifier: Array<number>): boolean;
+    /**
+     * Function called to load the data from the file.
+     *
+     * To begin processing the blocks, the next 4 bytes after the initial 4 bytes
+     * (bytes 4 through 7) are loaded. From there, the rest of the loading process
+     * is passed on to the _loadBlock function, which will handle the rest of the
+     * parsing for the metadata blocks.
+     *
+     * @param {MediaFileReader} mediaFileReader - The MediaFileReader used to parse the file.
+     * @param {LoadCallbackType} callbacks - The callback to call once _loadData is completed.
+     */
+    _loadData(mediaFileReader: MediaReader, callbacks: LoadCallbackType): void;
+    /**
+     * Special internal function used to parse the different FLAC blocks.
+     *
+     * The FLAC specification doesn't specify a specific location for metadata to resign, but
+     * dictates that it may be in one of various blocks located throughout the file. To load the
+     * metadata, we must locate the header first. This can be done by reading the first byte of
+     * each block to determine the block type. After the block type comes a 24 bit integer that stores
+     * the length of the block as big endian. Using this, we locate the block and store the offset for
+     * parsing later.
+     *
+     * After each block has been parsed, the _nextBlock function is called in order
+     * to parse the information of the next block. All blocks need to be parsed in order to find
+     * all of the picture and comment blocks.
+     *
+     * More info on the FLAC specification may be found here:
+     * https://xiph.org/flac/format.html
+     * @param {MediaFileReader} mediaFileReader - The MediaFileReader used to parse the file.
+     * @param {number} offset - The offset to start checking the header from.
+     * @param {LoadCallbackType} callbacks - The callback to call once the header has been found.
+     */
+    _loadBlock(mediaFileReader: MediaReader, offset: number, callbacks: LoadCallbackType): void;
+    /**
+     * Internal function used to load the next range and respective block.
+     *
+     * If the metadata block that was identified is not the last block before the
+     * audio blocks, the function will continue loading the next blocks. If it is
+     * the last block (identified by any values greater than 127, see FLAC spec.),
+     * the function will determine whether a comment block had been identified.
+     *
+     * If the block does not exist, the error callback is called. Otherwise, the function
+     * will call the success callback, allowing data parsing to begin.
+     * @param {MediaFileReader} mediaFileReader - The MediaFileReader used to parse the file.
+     * @param {number} offset - The offset that the existing header was located at.
+     * @param {number} blockHeader - An integer reflecting the header type of the block.
+     * @param {number} blockSize - The size of the previously processed header.
+     * @param {LoadCallbackType} callbacks - The callback functions to be called.
+     */
+    _nextBlock(mediaFileReader: MediaReader, offset: number, blockHeader: number, blockSize: number, callbacks: LoadCallbackType): void;
+    /**
+     * Parses the data and returns the tags.
+     *
+     * This is an overview of the VorbisComment format and what this function attempts to
+     * retrieve:
+     * - First 4 bytes: a long that contains the length of the vendor string.
+     * - Next n bytes: the vendor string encoded in UTF-8.
+     * - Next 4 bytes: a long representing how many comments are in this block
+     * For each comment that exists:
+     * - First 4 bytes: a long representing the length of the comment
+     * - Next n bytes: the comment encoded in UTF-8.
+     * The comment string will usually appear in a format similar to:
+     * ARTIST=me
+     *
+     * Note that the longs and integers in this block are encoded in little endian
+     * as opposed to big endian for the rest of the FLAC spec.
+     * @param {MediaFileReader} data - The MediaFileReader to parse the file with.
+     * @param {Array<string>} [tags] - Optional tags to also be retrieved from the file.
+     * @return {TagType} - An object containing the tag information for the file.
+     */
+    _parseData(data: MediaReader, _tags: Array<string> | null): TagType;
+}
+export = FLACTagReader;