@probityrules/jsmediatags 4.0.0

package/build/NodeFileReader.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const fs = __importStar(require("fs"));
+const ChunkedFileData = require("./ChunkedFileData");
+const MediaFileReader = require("./MediaFileReader");
+class NodeFileReader extends MediaFileReader {
+    constructor(path) {
+        super();
+        this._path = path;
+        this._fileData = new ChunkedFileData();
+    }
+    static canReadFile(file) {
+        return typeof file === "string" && !/^[a-z]+:\/\//i.test(file);
+    }
+    getByteAt(offset) {
+        return this._fileData.getByteAt(offset);
+    }
+    _init(callbacks) {
+        fs.stat(this._path, (err, stats) => {
+            if (err) {
+                if (callbacks.onError) {
+                    callbacks.onError({ type: "fs", info: err });
+                }
+            }
+            else {
+                this._size = stats.size;
+                callbacks.onSuccess();
+            }
+        });
+    }
+    loadRange(range, callbacks) {
+        let fd = -1;
+        const self = this;
+        const fileData = this._fileData;
+        const length = range[1] - range[0] + 1;
+        const onSuccess = callbacks.onSuccess;
+        const onError = callbacks.onError || function (_object) { };
+        if (fileData.hasDataRange(range[0], range[1])) {
+            process.nextTick(onSuccess);
+            return;
+        }
+        const readData = function (err, _fd) {
+            if (err) {
+                onError({ type: "fs", info: err });
+                return;
+            }
+            fd = _fd;
+            const buffer = Buffer.alloc(length);
+            fs.read(_fd, buffer, 0, length, range[0], processData);
+        };
+        const processData = function (err, _bytesRead, buffer) {
+            fs.close(fd, function (err) {
+                if (err) {
+                    console.error(err);
+                }
+            });
+            if (err) {
+                onError({ type: "fs", info: err });
+                return;
+            }
+            storeBuffer(buffer);
+            onSuccess();
+        };
+        const storeBuffer = function (buffer) {
+            const data = Array.prototype.slice.call(buffer, 0, length);
+            fileData.addData(range[0], data);
+        };
+        fs.open(this._path, "r", undefined, readData);
+    }
+}
+module.exports = NodeFileReader;

package/build/ReactNativeFileReader.d.ts

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

package/build/ReactNativeFileReader.js

@@ -0,0 +1,48 @@
+"use strict";
+const RNFS = require("react-native-fs");
+const { Buffer } = require("buffer");
+const ChunkedFileData = require("./ChunkedFileData");
+const MediaFileReader = require("./MediaFileReader");
+class ReactNativeFileReader extends MediaFileReader {
+    constructor(path) {
+        super();
+        this._path = path;
+        this._fileData = new ChunkedFileData();
+    }
+    static canReadFile(file) {
+        return typeof file === "string" && !/^[a-z]+:\/\//i.test(file);
+    }
+    getByteAt(offset) {
+        return this._fileData.getByteAt(offset);
+    }
+    _init(callbacks) {
+        const self = this;
+        RNFS.stat(self._path)
+            .then((statResult) => {
+            self._size = statResult.size;
+            callbacks.onSuccess();
+        })
+            .catch((error) => {
+            if (callbacks.onError) {
+                callbacks.onError({ type: "fs", info: error });
+            }
+        });
+    }
+    loadRange(range, callbacks) {
+        const fileData = this._fileData;
+        const length = range[1] - range[0] + 1;
+        const onSuccess = callbacks.onSuccess;
+        const onError = callbacks.onError || function (_object) { };
+        RNFS.read(this._path, length, range[0], { encoding: "base64" })
+            .then((readData) => {
+            const buffer = Buffer.from(readData, "base64");
+            const data = Array.prototype.slice.call(buffer, 0, length);
+            fileData.addData(range[0], data);
+            onSuccess();
+        })
+            .catch((err) => {
+            onError({ type: "fs", info: err });
+        });
+    }
+}
+module.exports = ReactNativeFileReader;

package/build/StringUtils.d.ts

@@ -0,0 +1,7 @@
+import type { DecodedString } from "./DecodedString";
+declare const StringUtils: {
+    readUTF16String: (bytes: Array<number>, bigEndian: boolean, maxBytes?: number) => DecodedString;
+    readUTF8String: (bytes: Array<number>, maxBytes?: number) => DecodedString;
+    readNullTerminatedString: (bytes: Array<number>, maxBytes?: number) => DecodedString;
+};
+export = StringUtils;

package/build/StringUtils.js

@@ -0,0 +1,102 @@
+"use strict";
+class InternalDecodedString {
+    constructor(value, bytesReadCount) {
+        this._value = value;
+        this.bytesReadCount = bytesReadCount;
+        this.length = value.length;
+    }
+    toString() {
+        return this._value;
+    }
+}
+const StringUtils = {
+    readUTF16String: function (bytes, bigEndian, maxBytes) {
+        let ix = 0;
+        let offset1 = 1, offset2 = 0;
+        maxBytes = Math.min(maxBytes || bytes.length, bytes.length);
+        if (bytes[0] == 0xfe && bytes[1] == 0xff) {
+            bigEndian = true;
+            ix = 2;
+        }
+        else if (bytes[0] == 0xff && bytes[1] == 0xfe) {
+            bigEndian = false;
+            ix = 2;
+        }
+        if (bigEndian) {
+            offset1 = 0;
+            offset2 = 1;
+        }
+        const arr = [];
+        for (let j = 0; ix < maxBytes; j++) {
+            const byte1 = bytes[ix + offset1];
+            const byte2 = bytes[ix + offset2];
+            const word1 = (byte1 << 8) + byte2;
+            ix += 2;
+            if (word1 == 0x0000) {
+                break;
+            }
+            else if (byte1 < 0xd8 || byte1 >= 0xe0) {
+                arr[j] = String.fromCharCode(word1);
+            }
+            else {
+                const byte3 = bytes[ix + offset1];
+                const byte4 = bytes[ix + offset2];
+                const word2 = (byte3 << 8) + byte4;
+                ix += 2;
+                arr[j] = String.fromCharCode(word1, word2);
+            }
+        }
+        return new InternalDecodedString(arr.join(""), ix);
+    },
+    readUTF8String: function (bytes, maxBytes) {
+        let ix = 0;
+        maxBytes = Math.min(maxBytes || bytes.length, bytes.length);
+        if (bytes[0] == 0xef && bytes[1] == 0xbb && bytes[2] == 0xbf) {
+            ix = 3;
+        }
+        const arr = [];
+        for (let j = 0; ix < maxBytes; j++) {
+            const byte1 = bytes[ix++];
+            if (byte1 == 0x00) {
+                break;
+            }
+            else if (byte1 < 0x80) {
+                arr[j] = String.fromCharCode(byte1);
+            }
+            else if (byte1 >= 0xc2 && byte1 < 0xe0) {
+                const byte2 = bytes[ix++];
+                arr[j] = String.fromCharCode(((byte1 & 0x1f) << 6) + (byte2 & 0x3f));
+            }
+            else if (byte1 >= 0xe0 && byte1 < 0xf0) {
+                const byte2 = bytes[ix++];
+                const byte3 = bytes[ix++];
+                arr[j] = String.fromCharCode(((byte1 & 0xff) << 12) + ((byte2 & 0x3f) << 6) + (byte3 & 0x3f));
+            }
+            else if (byte1 >= 0xf0 && byte1 < 0xf5) {
+                const byte2 = bytes[ix++];
+                const byte3 = bytes[ix++];
+                const byte4 = bytes[ix++];
+                const codepoint = ((byte1 & 0x07) << 18) +
+                    ((byte2 & 0x3f) << 12) +
+                    ((byte3 & 0x3f) << 6) +
+                    (byte4 & 0x3f) -
+                    0x10000;
+                arr[j] = String.fromCharCode((codepoint >> 10) + 0xd800, (codepoint & 0x3ff) + 0xdc00);
+            }
+        }
+        return new InternalDecodedString(arr.join(""), ix);
+    },
+    readNullTerminatedString: function (bytes, maxBytes) {
+        const arr = [];
+        maxBytes = maxBytes || bytes.length;
+        for (var i = 0; i < maxBytes;) {
+            var byte1 = bytes[i++];
+            if (byte1 == 0x00) {
+                break;
+            }
+            arr[i - 1] = String.fromCharCode(byte1);
+        }
+        return new InternalDecodedString(arr.join(""), i);
+    },
+};
+module.exports = StringUtils;

package/build/XhrFileReader.d.ts

@@ -0,0 +1,41 @@
+declare const MediaFileReader: any;
+import type { LoadCallbackType } from "./types";
+type XhrCallbacks = {
+    onSuccess: (xhr: XMLHttpRequest) => void;
+    onError?: (error: Record<string, unknown>) => void;
+};
+type ContentRangeType = {
+    firstBytePosition: number | null | undefined;
+    lastBytePosition: number | null | undefined;
+    instanceLength: number | null | undefined;
+};
+type XhrConfig = {
+    avoidHeadRequests: boolean;
+    disallowedXhrHeaders: string[];
+    timeoutInSec: number;
+};
+declare class XhrFileReader extends MediaFileReader {
+    static _config: XhrConfig;
+    private _url;
+    private _fileData;
+    constructor(url: string);
+    static canReadFile(file: unknown): boolean;
+    static setConfig(config: Partial<XhrConfig> & Record<string, unknown>): void;
+    _init(callbacks: LoadCallbackType): void;
+    _fetchSizeWithHeadRequest(callbacks: LoadCallbackType): void;
+    _fetchSizeWithGetRequest(callbacks: LoadCallbackType): void;
+    _fetchEntireFile(callbacks: LoadCallbackType): void;
+    _getXhrResponseContent(xhr: XMLHttpRequest): string;
+    _parseContentLength(xhr: XMLHttpRequest): number | null | undefined;
+    _parseContentRange(xhr: XMLHttpRequest): ContentRangeType | null;
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+    _roundRangeToChunkMultiple(range: [number, number]): [number, number];
+    _makeXHRRequest(method: string, range: [number, number] | null, callbacks: XhrCallbacks): void;
+    _setRequestHeader(xhr: XMLHttpRequest, headerName: string, headerValue: string): void;
+    _hasResponseHeader(xhr: XMLHttpRequest, headerName: string): boolean;
+    _getResponseHeader(xhr: XMLHttpRequest, headerName: string): string | null;
+    getByteAt(offset: number): number;
+    _isWebWorker(): boolean;
+    _createXHRObject(): XMLHttpRequest;
+}
+export = XhrFileReader;

package/build/XhrFileReader.js

@@ -0,0 +1,238 @@
+"use strict";
+const ChunkedFileData = require("./ChunkedFileData");
+const MediaFileReader = require("./MediaFileReader");
+const CHUNK_SIZE = 1024;
+class XhrFileReader extends MediaFileReader {
+    constructor(url) {
+        super();
+        this._url = url;
+        this._fileData = new ChunkedFileData();
+    }
+    static canReadFile(file) {
+        return typeof file === "string" && /^[a-z]+:\/\//i.test(file);
+    }
+    static setConfig(config) {
+        for (const key in config) {
+            if (Object.prototype.hasOwnProperty.call(config, key)) {
+                XhrFileReader._config[key] = config[key];
+            }
+        }
+        const disallowedXhrHeaders = XhrFileReader._config.disallowedXhrHeaders;
+        for (let i = 0; i < disallowedXhrHeaders.length; i++) {
+            disallowedXhrHeaders[i] = disallowedXhrHeaders[i].toLowerCase();
+        }
+    }
+    _init(callbacks) {
+        if (XhrFileReader._config.avoidHeadRequests) {
+            this._fetchSizeWithGetRequest(callbacks);
+        }
+        else {
+            this._fetchSizeWithHeadRequest(callbacks);
+        }
+    }
+    _fetchSizeWithHeadRequest(callbacks) {
+        const self = this;
+        this._makeXHRRequest("HEAD", null, {
+            onSuccess: function (xhr) {
+                const contentLength = self._parseContentLength(xhr);
+                if (contentLength) {
+                    self._size = contentLength;
+                    callbacks.onSuccess();
+                }
+                else {
+                    self._fetchSizeWithGetRequest(callbacks);
+                }
+            },
+            onError: callbacks.onError,
+        });
+    }
+    _fetchSizeWithGetRequest(callbacks) {
+        const self = this;
+        const range = this._roundRangeToChunkMultiple([0, 0]);
+        this._makeXHRRequest("GET", range, {
+            onSuccess: function (xhr) {
+                const contentRange = self._parseContentRange(xhr);
+                const data = self._getXhrResponseContent(xhr);
+                if (contentRange) {
+                    if (contentRange.instanceLength == null) {
+                        self._fetchEntireFile(callbacks);
+                        return;
+                    }
+                    self._size = contentRange.instanceLength;
+                }
+                else {
+                    self._size = data.length;
+                }
+                self._fileData.addData(0, data);
+                callbacks.onSuccess();
+            },
+            onError: callbacks.onError,
+        });
+    }
+    _fetchEntireFile(callbacks) {
+        const self = this;
+        this._makeXHRRequest("GET", null, {
+            onSuccess: function (xhr) {
+                const data = self._getXhrResponseContent(xhr);
+                self._size = data.length;
+                self._fileData.addData(0, data);
+                callbacks.onSuccess();
+            },
+            onError: callbacks.onError,
+        });
+    }
+    _getXhrResponseContent(xhr) {
+        const legacy = xhr;
+        return legacy.responseBody || xhr.responseText || "";
+    }
+    _parseContentLength(xhr) {
+        const contentLength = this._getResponseHeader(xhr, "Content-Length");
+        if (contentLength == null) {
+            return null;
+        }
+        return parseInt(contentLength, 10);
+    }
+    _parseContentRange(xhr) {
+        const contentRange = this._getResponseHeader(xhr, "Content-Range");
+        if (contentRange) {
+            const parsedContentRange = contentRange.match(/bytes (\d+)-(\d+)\/(?:(\d+)|\*)/i);
+            if (!parsedContentRange) {
+                throw new Error("FIXME: Unknown Content-Range syntax: " + contentRange);
+            }
+            return {
+                firstBytePosition: parseInt(parsedContentRange[1], 10),
+                lastBytePosition: parseInt(parsedContentRange[2], 10),
+                instanceLength: parsedContentRange[3]
+                    ? parseInt(parsedContentRange[3], 10)
+                    : null,
+            };
+        }
+        else {
+            return null;
+        }
+    }
+    loadRange(range, callbacks) {
+        const self = this;
+        if (self._fileData.hasDataRange(range[0], Math.min(self._size, range[1]))) {
+            setTimeout(callbacks.onSuccess, 1);
+            return;
+        }
+        range = this._roundRangeToChunkMultiple(range);
+        range[1] = Math.min(self._size, range[1]);
+        this._makeXHRRequest("GET", range, {
+            onSuccess: function (xhr) {
+                const data = self._getXhrResponseContent(xhr);
+                self._fileData.addData(range[0], data);
+                callbacks.onSuccess();
+            },
+            onError: callbacks.onError,
+        });
+    }
+    _roundRangeToChunkMultiple(range) {
+        const length = range[1] - range[0] + 1;
+        const newLength = Math.ceil(length / CHUNK_SIZE) * CHUNK_SIZE;
+        return [range[0], range[0] + newLength - 1];
+    }
+    _makeXHRRequest(method, range, callbacks) {
+        const xhr = this._createXHRObject();
+        xhr.open(method, this._url);
+        const onXHRLoad = function () {
+            if (xhr.status === 200 || xhr.status === 206) {
+                callbacks.onSuccess(xhr);
+            }
+            else if (callbacks.onError) {
+                callbacks.onError({
+                    type: "xhr",
+                    info: "Unexpected HTTP status " + xhr.status + ".",
+                    xhr: xhr,
+                });
+            }
+        };
+        if (typeof xhr.onload !== "undefined") {
+            xhr.onload = onXHRLoad;
+            xhr.onerror = function () {
+                if (callbacks.onError) {
+                    callbacks.onError({
+                        type: "xhr",
+                        info: "Generic XHR error, check xhr object.",
+                        xhr: xhr,
+                    });
+                }
+            };
+        }
+        else {
+            xhr.onreadystatechange = function () {
+                if (xhr.readyState === 4) {
+                    onXHRLoad();
+                }
+            };
+        }
+        if (XhrFileReader._config.timeoutInSec) {
+            xhr.timeout = XhrFileReader._config.timeoutInSec * 1000;
+            xhr.ontimeout = function () {
+                if (callbacks.onError) {
+                    callbacks.onError({
+                        type: "xhr",
+                        info: "Timeout after " +
+                            xhr.timeout / 1000 +
+                            "s. Use jsmediatags.Config.setXhrTimeout to override.",
+                        xhr: xhr,
+                    });
+                }
+            };
+        }
+        xhr.overrideMimeType("text/plain; charset=x-user-defined");
+        if (range) {
+            this._setRequestHeader(xhr, "Range", "bytes=" + range[0] + "-" + range[1]);
+        }
+        this._setRequestHeader(xhr, "If-Modified-Since", "Sat, 01 Jan 1970 00:00:00 GMT");
+        xhr.send(null);
+    }
+    _setRequestHeader(xhr, headerName, headerValue) {
+        if (XhrFileReader._config.disallowedXhrHeaders.indexOf(headerName.toLowerCase()) < 0) {
+            xhr.setRequestHeader(headerName, headerValue);
+        }
+    }
+    _hasResponseHeader(xhr, headerName) {
+        const allResponseHeaders = xhr.getAllResponseHeaders();
+        if (!allResponseHeaders) {
+            return false;
+        }
+        const headers = allResponseHeaders.split("\r\n");
+        const headerNames = [];
+        for (let i = 0; i < headers.length; i++) {
+            headerNames[i] = headers[i].split(":")[0].toLowerCase();
+        }
+        return headerNames.indexOf(headerName.toLowerCase()) >= 0;
+    }
+    _getResponseHeader(xhr, headerName) {
+        if (!this._hasResponseHeader(xhr, headerName)) {
+            return null;
+        }
+        return xhr.getResponseHeader(headerName);
+    }
+    getByteAt(offset) {
+        return this._fileData.getByteAt(offset) & 0xff;
+    }
+    _isWebWorker() {
+        return (typeof WorkerGlobalScope !== "undefined" &&
+            typeof self !== "undefined" &&
+            self instanceof WorkerGlobalScope);
+    }
+    _createXHRObject() {
+        if (typeof window === "undefined" && !this._isWebWorker()) {
+            const xhr2 = require("xhr2");
+            return new xhr2.XMLHttpRequest();
+        }
+        if (typeof XMLHttpRequest !== "undefined") {
+            return new XMLHttpRequest();
+        }
+        throw new Error("XMLHttpRequest is not supported");
+    }
+}
+XhrFileReader._config = {
+    avoidHeadRequests: false,
+    disallowedXhrHeaders: [],
+    timeoutInSec: 30,
+};
+module.exports = XhrFileReader;

package/build/jsmediatags.d.ts

@@ -0,0 +1,45 @@
+declare const MediaFileReader: any;
+declare const MediaTagReader: any;
+import type { CallbackType, LoadCallbackType, TagType } from "./types";
+type MediaFileReaderClass = typeof MediaFileReader;
+type MediaTagReaderClass = typeof MediaTagReader;
+type TagReaderResolutionCallbacks = {
+    onSuccess: (reader?: MediaTagReaderClass) => void;
+    onError?: (error: Record<string, unknown>) => void;
+};
+declare function read(location: unknown, callbacks: CallbackType<TagType>): void;
+declare function read(location: unknown): Promise<TagType>;
+declare function readAsync(location: unknown): Promise<TagType>;
+declare class Reader {
+    private _file;
+    private _tagsToRead?;
+    private _fileReader?;
+    private _tagReader?;
+    constructor(file: unknown);
+    setTagsToRead(tagsToRead: string[]): this;
+    setFileReader(fileReader: MediaFileReaderClass): this;
+    setTagReader(tagReader: MediaTagReaderClass): this;
+    read(callbacks: CallbackType<TagType>): void;
+    read(): Promise<TagType>;
+    readAsync(): Promise<TagType>;
+    _getFileReader(): MediaFileReaderClass;
+    _findFileReader(): MediaFileReaderClass;
+    _getTagReader(fileReader: InstanceType<typeof MediaFileReader>, callbacks: TagReaderResolutionCallbacks): void;
+    _findTagReader(fileReader: InstanceType<typeof MediaFileReader>, callbacks: TagReaderResolutionCallbacks): void;
+    _loadTagIdentifierRanges(fileReader: InstanceType<typeof MediaFileReader>, tagReaders: MediaTagReaderClass[], callbacks: LoadCallbackType): void;
+}
+declare class Config {
+    static addFileReader(fileReader: MediaFileReaderClass): typeof Config;
+    static addTagReader(tagReader: MediaTagReaderClass): typeof Config;
+    static removeTagReader(tagReader: MediaTagReaderClass): typeof Config;
+    static EXPERIMENTAL_avoidHeadRequests(): void;
+    static setDisallowedXhrHeaders(disallowedXhrHeaders: string[]): void;
+    static setXhrTimeoutInSec(timeoutInSec: number): void;
+}
+declare const _default: {
+    read: typeof read;
+    readAsync: typeof readAsync;
+    Reader: typeof Reader;
+    Config: typeof Config;
+};
+export = _default;