Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.0

0.6.0 / src / engine / base64.lucb

#==============================================================================================
#
#   base64 - Base64 and hex encoding and decoding of byte buffers
#
#   DESCRIPTION:
#       Port of quickjs.c "Uint8Array base64/hex (tc39 proposal-arraybuffer-base64)"
#       helpers (lines 58966-59311): the alphabets and decoding tables, b64_encode,
#       b64_skip_ws, from_base64 (the FromBase64 abstract operation), u8a_hex_encode and
#       u8a_hex_decode. The C pointer and length pairs are spans here, so every access
#       is bounds-checked; these functions need no runtime and are unit-tested in
#       tests_typed_arrays.
#
#==============================================================================================

# mark: Alphabets and tables ====================================================================

# The alphabet option of the base64 methods.
let b64_alphabet_base64: i32 = 0
let b64_alphabet_base64url: i32 = 1

# The lastChunkHandling option of the base64 decoders.
let b64_last_loose: i32 = 0
let b64_last_strict: i32 = 1
let b64_last_stop_before_partial: i32 = 2

let b64_enc: const u8[] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

let b64url_enc: const u8[] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"

# A decoding table maps a byte to its 6-bit value, to k_ws for whitespace (skipped) or to
# k_er for a byte that is not in the alphabet.
let k_ws: u8 = 64
let k_er: u8 = 65

let b64_dec: u8[256] = [
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_ws, k_ws, k_er, k_ws, k_ws, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_ws, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, 62, k_er, k_er, k_er, 63,
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, k_er, k_er, k_er, k_er, k_er,
    k_er, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
]

let b64url_dec: u8[256] = [
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_ws, k_ws, k_er, k_ws, k_ws, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_ws, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, 62, k_er, k_er,
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, k_er, k_er, k_er, k_er, 63,
    k_er, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
    k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er, k_er,
]

# mark: Base64 ==================================================================================

## Encode `src` into `dst` (at least 4 * ((src.length + 2) / 3) bytes) with the alphabet
## `alpha`, padding with '='; answer the number of bytes written.
func b64_encode(src: const u8[], dst: u8[], alpha: const u8[]) -> usize:
    let len = src.length
    var i: usize = 0
    var j: usize = 0
    while i + 3 <= len:
        let v = 65536 * (u32)src[i] + 256 * (u32)src[i + 1] + (u32)src[i + 2]
        dst[j + 0] = alpha[(usize)((v >> 18) & 63)]
        dst[j + 1] = alpha[(usize)((v >> 12) & 63)]
        dst[j + 2] = alpha[(usize)((v >> 6) & 63)]
        dst[j + 3] = alpha[(usize)(v & 63)]
        i += 3
        j += 4

    let rem = len - i
    if rem == 1:
        let v = 65536 * (u32)src[i]
        dst[j] = alpha[(usize)((v >> 18) & 63)]
        dst[j + 1] = alpha[(usize)((v >> 12) & 63)]
        dst[j + 2] = '='
        dst[j + 3] = '='
        j += 4
    elif rem == 2:
        let v = 65536 * (u32)src[i] + 256 * (u32)src[i + 1]
        dst[j] = alpha[(usize)((v >> 18) & 63)]
        dst[j + 1] = alpha[(usize)((v >> 12) & 63)]
        dst[j + 2] = alpha[(usize)((v >> 6) & 63)]
        dst[j + 3] = '='
        j += 4
    return j

## The first index at or after `index` of `src` that is not whitespace.
func b64_skip_ws(src: const u8[], index0: usize, dec_table: const u8[]) -> usize:
    var index = index0
    while index < src.length and dec_table[(usize)src[index]] == k_ws:
        index += 1
    return index

# Implements the FromBase64 abstract operation.
#   src: the input string (must be ASCII/latin1)
#   dst: output buffer (its length is the maximum output)
#   dec_table: b64_dec or b64url_dec (selects valid characters)
#   last_chunk: b64_last_loose, b64_last_strict, or b64_last_stop_before_partial
#   *p_read: set to number of input characters consumed
#   *p_err: set to true on error, false on success
#   Returns: number of bytes written to dst
func from_base64(src: const u8[], dst: u8[], dec_table: const u8[], last_chunk: i32,
                 p_read: usize*, p_err: bool*) -> usize:
    let src_len = src.length
    let max_len = dst.length
    var read: usize = 0
    var written: usize = 0
    var acc: u32 = 0
    var seen: i32 = 0
    var index: usize = 0

    *p_err = false

    if max_len == 0:
        *p_read = 0
        return 0

    while true:
        if seen == 0:
            # Fast path: decode complete groups of 4 valid characters. Breaks out on
            # whitespace, padding, invalid chars, or capacity.
            while index + 4 <= src_len and written + 3 <= max_len:
                let v0 = (u32)dec_table[(usize)src[index]]
                let v1 = (u32)dec_table[(usize)src[index + 1]]
                let v2 = (u32)dec_table[(usize)src[index + 2]]
                let v3 = (u32)dec_table[(usize)src[index + 3]]
                if (v0 | v1 | v2 | v3) >= 64:
                    break
                let v = (v0 << 18) | (v1 << 12) | (v2 << 6) | v3
                dst[written] = (u8)(v >> 16)
                dst[written + 1] = (u8)(v >> 8)
                dst[written + 2] = (u8)v
                written += 3
                index += 4
            read = index

            if written >= max_len:
                *p_read = read
                return written

        # Slow path: handle whitespace, padding, partial groups, capacity.
        index = b64_skip_ws(src, index, dec_table)

        if index == src_len:
            if seen > 0:
                if last_chunk == b64_last_stop_before_partial:
                    *p_read = read
                    return written
                if last_chunk == b64_last_strict:
                    *p_err = true
                    return 0
                # loose
                if seen == 1:
                    *p_err = true
                    return 0
                break
            *p_read = src_len
            return written

        let ch = src[index]
        index += 1

        if ch == '=':
            if seen < 2:
                *p_err = true
                return 0
            index = b64_skip_ws(src, index, dec_table)
            if seen == 2:
                if index == src_len:
                    if last_chunk == b64_last_stop_before_partial:
                        *p_read = read
                        return written
                    *p_err = true
                    return 0
                if src[index] == '=':
                    index += 1
                    index = b64_skip_ws(src, index, dec_table)
                else:
                    *p_err = true
                    return 0
            # After padding, only whitespace is allowed
            if index != src_len:
                *p_err = true
                return 0
            if last_chunk == b64_last_strict:
                let mask: u32 = 0xF if seen == 2 else 0x3
                if (acc & mask) != 0:
                    *p_err = true
                    return 0
            break

        let v = (u32)dec_table[(usize)ch]
        if v >= 64:
            *p_err = true
            return 0

        # Check remaining capacity before committing to this group
        let remaining = max_len - written
        if (remaining == 1 and seen == 2) or (remaining == 2 and seen == 3):
            *p_read = read
            return written

        acc = (acc << 6) | v
        seen += 1

        if seen == 4:
            dst[written] = (u8)(acc >> 16)
            dst[written + 1] = (u8)(acc >> 8)
            dst[written + 2] = (u8)acc
            written += 3
            acc = 0
            seen = 0
            read = index
            if written >= max_len:
                *p_read = read
                return written

    if seen == 2:
        dst[written] = (u8)(acc >> 4)
        written += 1
    elif seen == 3:
        dst[written] = (u8)(acc >> 10)
        dst[written + 1] = (u8)(acc >> 2)
        written += 2
    *p_read = src_len
    return written

# mark: Hex =====================================================================================

let u8a_hex_digits: const u8[] = b"0123456789abcdef"

## Encode `src` into `dst` (at least 2 * src.length bytes) as lowercase hex; answer the
## number of bytes written.
func u8a_hex_encode(src: const u8[], dst: u8[]) -> usize:
    for i in 0..<src.length:
        dst[i * 2] = u8a_hex_digits[(usize)(src[i] >> 4)]
        dst[i * 2 + 1] = u8a_hex_digits[(usize)(src[i] & 0xF)]
    return src.length * 2

# Decode hex string to bytes.
# Returns bytes written. Sets *p_read to chars consumed, *p_err on error.
func u8a_hex_decode(src: const u8[], dst: u8[], p_read: usize*, p_err: bool*) -> usize:
    let src_len = src.length
    let max_len = dst.length
    var written: usize = 0
    var i: usize = 0
    *p_err = false

    if (src_len & 1) != 0:
        *p_err = true
        return 0

    while i < src_len and written < max_len:
        let hi = cutils.from_hex((i32)src[i])
        let lo = cutils.from_hex((i32)src[i + 1])
        if hi < 0 or lo < 0:
            *p_err = true
            return 0
        dst[written] = (u8)((hi << 4) | lo)
        written += 1
        i += 2

    *p_read = i
    return written