univ-conv/commonjs/converters/Base64Converter.js

The universal binary and text converter

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Base64Converter = void 0;
const base64_arraybuffer_1 = require("base64-arraybuffer");
const AbstractConverter_1 = require("./AbstractConverter");
const core_1 = require("./core");
const Environment_1 = require("./Environment");
const StringUtil_1 = require("./StringUtil");
class Base64Converter extends AbstractConverter_1.AbstractConverter {
    constructor() {
        super(...arguments);
        this.type = "base64";
    }
    empty() {
        return "";
    }
    is(input, options) {
        return typeof input === "string" && options.inputStringType === "base64";
    }
    async _from(input, options) {
        const univConv = (0, AbstractConverter_1._)()._find(input, options);
        return await univConv.toBase64(input, options);
    }
    async _getStartEnd(input, options) {
        const size = await this.size(input);
        return (0, core_1.getStartEnd)(options, size);
    }
    _isEmpty(input) {
        return !input;
    }
    async _merge(chunks, options) {
        if (Environment_1.isBrowser) {
            const blob = await (0, AbstractConverter_1._)().merge("blob", chunks, options);
            return await this.from(blob);
        }
        else {
            const u8 = await (0, AbstractConverter_1._)().merge("uint8array", chunks, options);
            return await this.from(u8);
        }
    }
    _size(input) {
        const len = input.length;
        const baseLen = (len * 3) / 4;
        let padding = 0;
        for (let i = len - 1; input[i] === "="; i--) {
            padding++;
        }
        const size = baseLen - padding;
        return Promise.resolve(size);
    }
    async _toArrayBuffer(input, options) {
        const ab = (0, base64_arraybuffer_1.decode)(input);
        if ((0, core_1.hasNoStartLength)(options)) {
            return ab;
        }
        const { start, end } = await this._getStartEnd(input, options);
        return ab.slice(start, end);
    }
    async _toBase64(input, options) {
        if ((0, core_1.hasNoStartLength)(options)) {
            return input;
        }
        const u8 = await this._toUint8Array(input, options);
        return await this._from(u8, (0, core_1.deleteStartLength)(options));
    }
    async _toText(input, options) {
        const u8 = await this._toUint8Array(input, options);
        const textHelper = await (0, StringUtil_1.getTextHelper)();
        return await textHelper.bufferToText(u8, options);
    }
    async _toUint8Array(input, options) {
        const ab = await this._toArrayBuffer(input, options);
        return (0, Environment_1.newBufferFrom)(ab);
    }
}
exports.Base64Converter = Base64Converter;
//# sourceMappingURL=Base64Converter.js.map