univ-conv/lib/converters/BinaryConverter.js

The universal binary and text converter

import { encode } from "base64-arraybuffer";
import { AbstractConverter, _ } from "./AbstractConverter";
import { getStartEnd, hasNoStartLength, } from "./core";
import { handleFileReader, hasBuffer, hasReadAsBinaryStringOnBlob, } from "./Environment";
import { getTextHelper } from "./StringUtil";
export class BinaryConverter extends AbstractConverter {
    constructor() {
        super(...arguments);
        this.type = "binary";
    }
    empty() {
        return "";
    }
    is(input, options) {
        return typeof input === "string" && options.inputStringType === "binary";
    }
    async _from(input, options) {
        if (typeof input === "string" && options.inputStringType === "binary") {
            if (hasNoStartLength(options)) {
                return input;
            }
            const { start, end } = await this._getStartEnd(input, options);
            return input.substring(start, end);
        }
        if (_().is("blob", input, options) && hasReadAsBinaryStringOnBlob) {
            const startEnd = getStartEnd(options, input.size);
            let start = startEnd.start;
            const end = startEnd.end;
            const bufferSize = options.bufferSize;
            const chunks = [];
            for (; start < end; start += bufferSize) {
                const blobChunk = input.slice(start, start + bufferSize);
                const chunk = await handleFileReader((reader) => reader.readAsBinaryString(blobChunk), (data) => data);
                chunks.push(chunk);
            }
            return chunks.join("");
        }
        const u8 = await _().convert("uint8array", input, options);
        return Array.from(u8, (e) => String.fromCharCode(e)).join("");
    }
    _getStartEnd(input, options) {
        return Promise.resolve(getStartEnd(options, input.length));
    }
    _isEmpty(input) {
        return !input;
    }
    _merge(chunks) {
        return Promise.resolve(chunks.join(""));
    }
    _size(input) {
        return Promise.resolve(input.length);
    }
    async _toArrayBuffer(input, options) {
        const u8 = await this._toUint8Array(input, options);
        return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
    }
    async _toBase64(input, options) {
        const u8 = await this._toUint8Array(input, options);
        return encode(u8);
    }
    async _toText(input, options) {
        const u8 = await this._toUint8Array(input, options);
        const textHelper = await getTextHelper();
        return await textHelper.bufferToText(u8, options);
    }
    async _toUint8Array(input, options) {
        if (!hasNoStartLength(options)) {
            const startEnd = await this._getStartEnd(input, options);
            const start = startEnd.start;
            const end = startEnd.end;
            input = input.substring(start, end);
        }
        const u8 = hasBuffer
            ? Buffer.from(input, "binary")
            : Uint8Array.from(input.split(""), (e) => e.charCodeAt(0));
        return u8;
    }
}
//# sourceMappingURL=BinaryConverter.js.map