univ-conv/commonjs/converters/Uint8ArrayConverter.js

The universal binary and text converter

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Uint8ArrayConverter = 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 Uint8ArrayConverter extends AbstractConverter_1.AbstractConverter {
    constructor() {
        super(...arguments);
        this.type = "uint8array";
    }
    empty() {
        return core_1.EMPTY_UINT8_ARRAY;
    }
    is(input) {
        return input instanceof Uint8Array || (0, Environment_1.isBuffer)(input);
    }
    async _from(input, options) {
        if (Environment_1.hasBuffer && typeof input === "string") {
            const type = options.inputStringType;
            let buffer;
            if (type === "base64") {
                buffer = Buffer.from(input, "base64");
            }
            else if (type === "binary") {
                buffer = Buffer.from(input, "binary");
            }
            else if (type === "hex") {
                buffer = Buffer.from(input, "hex");
            }
            else if (type === "text") {
                const textHelper = await (0, StringUtil_1.getTextHelper)();
                const u8 = await textHelper.textToBuffer(input, options);
                buffer = u8;
            }
            if (buffer) {
                const { start, end } = await this._getStartEnd(buffer, options);
                return buffer.subarray(start, end);
            }
        }
        const ab = await (0, AbstractConverter_1._)().convert("arraybuffer", input, options);
        return (0, Environment_1.newBufferFrom)(ab);
    }
    _getStartEnd(input, options) {
        return Promise.resolve((0, core_1.getStartEnd)(options, input.byteLength));
    }
    _isEmpty(input) {
        return input.byteLength === 0;
    }
    _merge(chunks) {
        if (Environment_1.hasBuffer) {
            return Promise.resolve(Buffer.concat(chunks));
        }
        const byteLength = chunks.reduce((sum, chunk) => {
            return sum + chunk.byteLength;
        }, 0);
        const u8 = (0, Environment_1.newBuffer)(byteLength);
        let pos = 0;
        for (const chunk of chunks) {
            u8.set(chunk, pos);
            pos += chunk.byteLength;
        }
        return Promise.resolve(u8);
    }
    _size(input) {
        return Promise.resolve(input.byteLength);
    }
    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 (0, base64_arraybuffer_1.encode)(u8);
    }
    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) {
        if ((0, core_1.hasNoStartLength)(options)) {
            return input;
        }
        const { start, end } = await this._getStartEnd(input, options);
        return input.subarray(start, end);
    }
}
exports.Uint8ArrayConverter = Uint8ArrayConverter;
//# sourceMappingURL=Uint8ArrayConverter.js.map