async-http/bin/encoding.js

Asynchronous HTTP request API

function getByteLength(encoding, text) {
    if (encoding == undefined)
        throw new TypeError();
    if (text == undefined)
        throw new TypeError();
    text = String(text);
    switch (encoding) {
        case "utf8": return getUTF8ByteLength(text);
        default: throw new RangeError();
    }
}
exports.getByteLength = getByteLength;
function getBytes(encoding, text, buffer, byteOffset) {
    if (encoding == undefined)
        throw new TypeError();
    if (text == undefined)
        throw new TypeError();
    if (buffer == undefined)
        throw new TypeError();
    switch (encoding) {
        case "utf8": return getUTF8Bytes(text, toUint8Array(buffer, byteOffset));
        default: throw new RangeError();
    }
}
exports.getBytes = getBytes;
function getString(encoding, buffer, byteOffset, byteLength) {
    if (encoding == undefined)
        throw new TypeError();
    if (buffer == undefined)
        throw new TypeError();
    switch (encoding) {
        case "utf8": return getUTF8String(toUint8Array(buffer, byteOffset, byteLength));
        default: throw new RangeError();
    }
}
exports.getString = getString;
function toUint8Array(buffer, byteOffset, byteLength) {
    if ("BYTES_PER_ELEMENT" in buffer) {
        var array = buffer;
        return new Uint8Array(array.buffer, byteOffset, byteLength);
    }
    else {
        return new Uint8Array(buffer, byteOffset, byteLength);
    }
}
function getUTF8ByteLength(text) {
    var size = 0;
    var len = text.length;
    for (var i = 0; i < len; ++i) {
        var charCode = text.charCodeAt(i);
        size += charCode >= 0x8000 ? 4
            : charCode >= 0x800 ? 3
                : charCode >= 0x80 ? 2
                    : 1;
    }
    return size;
}
function getUTF8Bytes(text, buffer) {
    var bytesWritten = 0;
    var len = text.length;
    for (var i = 0; i < len; ++i) {
        var charCode = text.charCodeAt(i);
        if (charCode < 0x80) {
            buffer[bytesWritten + 0] = charCode;
            bytesWritten += 1;
        }
        else if (charCode < 0x800) {
            buffer[bytesWritten + 0] = 0xc0 | ((charCode >>> 6) & 0x3f);
            buffer[bytesWritten + 1] = 0x80 | ((charCode >>> 0) & 0x3f);
            bytesWritten += 2;
        }
        else if (charCode < 0x8000) {
            buffer[bytesWritten + 0] = 0xe0 | ((charCode >>> 12) & 0x3f);
            buffer[bytesWritten + 1] = 0x80 | ((charCode >>> 6) & 0x3f);
            buffer[bytesWritten + 2] = 0x80 | ((charCode >>> 0) & 0x3f);
            bytesWritten += 3;
        }
        else {
            buffer[bytesWritten + 0] = 0xf0 | ((charCode >>> 18) & 0x3f);
            buffer[bytesWritten + 1] = 0x80 | ((charCode >>> 12) & 0x3f);
            buffer[bytesWritten + 2] = 0x80 | ((charCode >>> 6) & 0x3f);
            buffer[bytesWritten + 3] = 0x80 | ((charCode >>> 0) & 0x3f);
            bytesWritten += 4;
        }
    }
    return bytesWritten;
}
function getUTF8String(buffer) {
    var text = "";
    var byteOffset = 0;
    var byteLength = buffer.byteLength;
    while (byteOffset < byteLength) {
        var charCode = buffer[byteOffset++];
        var kind = charCode & 0xf0;
        if (kind & 0x80) {
            charCode &= 0x3f;
            for (var mask = 0x10; mask <= 0x40; mask <<= 1) {
                if (kind & mask) {
                    if (byteOffset >= byteLength)
                        throw new Error("Invalid format");
                    charCode = (charCode << 6) | (buffer[byteOffset++] & 0x3f);
                }
            }
        }
        text += String.fromCharCode(charCode);
    }
    return text;
}
//# sourceMappingURL=encoding.js.map