rapydscript-ns 0.9.2 → 0.9.3

package/src/lib/base64.pyj

@@ -0,0 +1,399 @@
+###########################################################
+# RapydScript Standard Library
+# Author: RapydScript-NS Contributors
+# Copyright 2024 RapydScript-NS Contributors
+# License: Apache License 2.0
+# This library is covered under Apache license, so that
+# you can distribute it with your RapydScript applications.
+###########################################################
+
+# Python-compatible base64 module.
+#
+# All encode functions accept bytes/bytearray/list-of-ints and return bytes.
+# All decode functions return bytes.
+#
+# Functions available:
+#   b64encode(s, altchars=None)
+#   b64decode(s, altchars=None, validate=False)
+#   standard_b64encode(s)
+#   standard_b64decode(s)
+#   urlsafe_b64encode(s)
+#   urlsafe_b64decode(s)
+#   b32encode(s)
+#   b32decode(s, casefold=False, map01=None)
+#   b16encode(s)
+#   b16decode(s, casefold=False)
+#   encodebytes(s)
+#   decodebytes(s)
+
+
+class Error(ValueError):
+    """Raised when invalid base64/base32/base16 data is encountered."""
+    pass
+
+
+v"""
+// ---------------------------------------------------------------------------
+// Internal helpers
+// Note: backslash sequences must be doubled inside triple-quote verbatim
+// blocks since Python processes them before passing to JS.
+// ---------------------------------------------------------------------------
+
+// Convert a bytes-like value to a plain JS Array of integers 0-255.
+function _b64_to_arr(b) {
+    if (b === null || b === undefined) return [];
+    if (b._data !== undefined && b._data !== null) return b._data;
+    if (Array.isArray(b)) return b;
+    if (b instanceof Uint8Array || b instanceof Int8Array) {
+        var r = [];
+        for (var i = 0; i < b.length; i++) r.push(b[i] & 0xFF);
+        return r;
+    }
+    if (typeof b === 'string') {
+        var r2 = [];
+        for (var j = 0; j < b.length; j++) r2.push(b.charCodeAt(j) & 0xFF);
+        return r2;
+    }
+    var r3 = [];
+    for (var k = 0; k < (b.length || 0); k++) r3.push((b[k] | 0) & 0xFF);
+    return r3;
+}
+
+// Convert a bytes-like value or string to an ASCII string.
+function _b64_to_str(b) {
+    if (typeof b === 'string') return b;
+    var arr = _b64_to_arr(b);
+    var parts = [];
+    for (var i = 0; i < arr.length; i++) parts.push(String.fromCharCode(arr[i]));
+    return parts.join('');
+}
+
+// Convert a plain JS integer array to a ρσ_bytes object.
+function _b64_arr_to_bytes(arr) {
+    return ρσ_bytes(arr);
+}
+
+// ---------------------------------------------------------------------------
+// Base64 internals
+// ---------------------------------------------------------------------------
+
+var _B64_STD  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+var _B64_SAFE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+function _b64_make_table(alpha) {
+    var t = new Uint8Array(128);
+    for (var fi = 0; fi < 128; fi++) t[fi] = 255;      // 255 = invalid
+    for (var gi = 0; gi < alpha.length; gi++) t[alpha.charCodeAt(gi)] = gi;
+    t['='.charCodeAt(0)] = 64;                           // 64 = padding sentinel
+    return t;
+}
+
+var _B64_STD_TABLE  = _b64_make_table(_B64_STD);
+var _B64_SAFE_TABLE = _b64_make_table(_B64_SAFE);
+
+// Encode a plain int array to a base64 string using the given 64-char alphabet.
+function _b64_encode_impl(data, alpha) {
+    var out = [];
+    var len = data.length;
+    for (var i = 0; i < len; i += 3) {
+        var b0 = data[i];
+        var b1 = (i + 1 < len) ? data[i + 1] : 0;
+        var b2 = (i + 2 < len) ? data[i + 2] : 0;
+        out.push(alpha.charAt((b0 >> 2) & 0x3F));
+        out.push(alpha.charAt(((b0 & 0x3) << 4) | ((b1 >> 4) & 0xF)));
+        out.push((i + 1 < len) ? alpha.charAt(((b1 & 0xF) << 2) | ((b2 >> 6) & 0x3)) : '=');
+        out.push((i + 2 < len) ? alpha.charAt(b2 & 0x3F) : '=');
+    }
+    return out.join('');
+}
+
+// Strip ASCII whitespace from a base64 string using split/join.
+function _b64_strip_ws(s) {
+    return s.split(' ').join('').split('\\t').join('').split('\\n').join('').split('\\r').join('').split('\\f').join('').split('\\v').join('');
+}
+
+// Decode a base64 string to a plain int array.
+// table     — 128-entry Uint8Array (255=invalid, 64=padding '=')
+// validate  — if true, raise on non-alphabet characters
+// Error_cls — RapydScript Error class to instantiate on bad input
+function _b64_decode_impl(s, table, validate, Error_cls) {
+    if (!validate) {
+        s = _b64_strip_ws(s);
+    }
+    var len = s.length;
+    if (len === 0) return [];
+
+    if (validate && len % 4 !== 0) {
+        throw new Error_cls('Incorrect padding');
+    }
+    // Pad to multiple of 4 (Python is lenient about missing padding).
+    // pad === 3 means 1 leftover base64 char, which can't encode any bytes.
+    var pad = (4 - (len % 4)) % 4;
+    if (pad === 3) throw new Error_cls('Incorrect padding');
+    if (pad > 0) {
+        s = s + '===='.slice(0, pad);
+        len = s.length;
+    }
+
+    var out = [];
+    for (var i = 0; i < len; i += 4) {
+        var c0 = s.charCodeAt(i),     c1 = s.charCodeAt(i + 1);
+        var c2 = s.charCodeAt(i + 2), c3 = s.charCodeAt(i + 3);
+        var v0 = c0 < 128 ? table[c0] : 255;
+        var v1 = c1 < 128 ? table[c1] : 255;
+        var v2 = c2 < 128 ? table[c2] : 255;
+        var v3 = c3 < 128 ? table[c3] : 255;
+
+        if (v0 === 255 || v1 === 255 || v2 === 255 || v3 === 255) {
+            if (validate) throw new Error_cls('Non-base64 digit found');
+            continue; // skip bad block when not validating
+        }
+        if (v0 === 64 || v1 === 64) {
+            throw new Error_cls('Incorrect padding');
+        }
+
+        out.push(((v0 << 2) | (v1 >> 4)) & 0xFF);
+        if (v2 !== 64) {
+            out.push(((v1 << 4) | (v2 >> 2)) & 0xFF);
+            if (v3 !== 64) {
+                out.push(((v2 << 6) | v3) & 0xFF);
+            }
+        }
+    }
+    return out;
+}
+
+// ---------------------------------------------------------------------------
+// Base32 internals
+// ---------------------------------------------------------------------------
+
+var _B32_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+var _B32_TABLE = (function() {
+    var t = new Uint8Array(128);
+    for (var fi = 0; fi < 128; fi++) t[fi] = 255;
+    for (var gi = 0; gi < _B32_ALPHA.length; gi++) t[_B32_ALPHA.charCodeAt(gi)] = gi;
+    t['='.charCodeAt(0)] = 32; // 32 = padding sentinel
+    return t;
+})();
+
+// Encode a plain int array to base32.
+function _b32_encode_impl(data) {
+    var out = [];
+    var len = data.length;
+    for (var i = 0; i < len; i += 5) {
+        var take = Math.min(5, len - i);
+        var b = [0, 0, 0, 0, 0];
+        for (var j = 0; j < take; j++) b[j] = data[i + j];
+
+        out.push(_B32_ALPHA.charAt((b[0] >> 3) & 0x1F));
+        out.push(_B32_ALPHA.charAt(((b[0] & 0x7) << 2) | ((b[1] >> 6) & 0x3)));
+        out.push(take >= 2 ? _B32_ALPHA.charAt((b[1] >> 1) & 0x1F) : '=');
+        out.push(take >= 2 ? _B32_ALPHA.charAt(((b[1] & 0x1) << 4) | ((b[2] >> 4) & 0xF)) : '=');
+        out.push(take >= 3 ? _B32_ALPHA.charAt(((b[2] & 0xF) << 1) | ((b[3] >> 7) & 0x1)) : '=');
+        out.push(take >= 4 ? _B32_ALPHA.charAt((b[3] >> 2) & 0x1F) : '=');
+        out.push(take >= 4 ? _B32_ALPHA.charAt(((b[3] & 0x3) << 3) | ((b[4] >> 5) & 0x7)) : '=');
+        out.push(take >= 5 ? _B32_ALPHA.charAt(b[4] & 0x1F) : '=');
+    }
+    return out.join('');
+}
+
+// Decode a base32 string to a plain int array.
+function _b32_decode_impl(s, Error_cls) {
+    // Strip padding chars and whitespace using split/join.
+    s = s.split('=').join('');
+    s = s.split(' ').join('');
+    s = s.split('\\t').join('');
+    s = s.split('\\n').join('');
+    s = s.split('\\r').join('');
+
+    var out = [];
+    var len = s.length;
+    for (var i = 0; i < len; i += 8) {
+        var v = [0, 0, 0, 0, 0, 0, 0, 0];
+        var take = Math.min(8, len - i);
+        for (var j = 0; j < take; j++) {
+            var cc = s.charCodeAt(i + j);
+            var vv = cc < 128 ? _B32_TABLE[cc] : 255;
+            if (vv >= 32) throw new Error_cls('Non-base32 digit found');
+            v[j] = vv;
+        }
+        if (take >= 2) out.push(((v[0] << 3) | (v[1] >> 2)) & 0xFF);
+        if (take >= 4) out.push(((v[1] << 6) | (v[2] << 1) | (v[3] >> 4)) & 0xFF);
+        if (take >= 5) out.push(((v[3] << 4) | (v[4] >> 1)) & 0xFF);
+        if (take >= 7) out.push(((v[4] << 7) | (v[5] << 2) | (v[6] >> 3)) & 0xFF);
+        if (take >= 8) out.push(((v[6] << 5) | v[7]) & 0xFF);
+    }
+    return out;
+}
+
+// ---------------------------------------------------------------------------
+// Base16 (hex) internals
+// ---------------------------------------------------------------------------
+
+function _b16_encode_impl(data) {
+    var out = [];
+    for (var i = 0; i < data.length; i++) {
+        var h = data[i].toString(16).toUpperCase();
+        out.push(h.length === 1 ? '0' + h : h);
+    }
+    return out.join('');
+}
+
+function _b16_decode_impl(s, Error_cls) {
+    if (s.length % 2 !== 0) throw new Error_cls('Odd-length string');
+    var out = [];
+    for (var i = 0; i < s.length; i += 2) {
+        var v = parseInt(s.slice(i, i + 2), 16);
+        if (isNaN(v)) throw new Error_cls('Non-hexadecimal digit found');
+        out.push(v);
+    }
+    return out;
+}
+"""
+
+
+# ---------------------------------------------------------------------------
+# Public API — Base64
+# ---------------------------------------------------------------------------
+
+def b64encode(s, altchars=None):
+    """Encode bytes *s* using Base64, returning a bytes object.
+
+    *altchars* is an optional 2-byte bytes-like whose two characters replace
+    ``+`` and ``/`` in the output (e.g. ``b'-_'`` for URL-safe encoding).
+    """
+    data = v'_b64_to_arr(s)'
+    if altchars is not None:
+        alt = v'_b64_to_arr(altchars)'
+        if v'alt.length' != 2:
+            raise ValueError('altchars must be a bytes-like of length 2')
+        # Build custom alphabet by replacing + and / with the altchars
+        alpha = v'_B64_STD.split("+").join(String.fromCharCode(alt[0])).split("/").join(String.fromCharCode(alt[1]))'
+    else:
+        alpha = v'_B64_STD'
+    result = v'_b64_encode_impl(data, alpha)'
+    return v'_b64_arr_to_bytes(_b64_to_arr(result))'
+
+
+def b64decode(s, altchars=None, validate=False):
+    """Decode Base64-encoded *s*, returning a bytes object.
+
+    *altchars* is an optional 2-byte bytes-like whose characters are the
+    alternatives used for ``+`` and ``/`` in the encoded data.
+    If *validate* is ``True``, characters outside the alphabet raise ``Error``.
+    Whitespace is stripped unless *validate* is ``True``.
+    """
+    s_str = v'_b64_to_str(s)'
+    if altchars is not None:
+        alt = v'_b64_to_arr(altchars)'
+        if v'alt.length' != 2:
+            raise ValueError('altchars must be a bytes-like of length 2')
+        # Replace altchars back to standard + and / before decoding
+        s_str = v's_str.split(String.fromCharCode(alt[0])).join("+").split(String.fromCharCode(alt[1])).join("/")'
+    arr = v'_b64_decode_impl(s_str, _B64_STD_TABLE, validate, Error)'
+    return bytes(arr)
+
+
+def standard_b64encode(s):
+    """Encode *s* using the standard Base64 alphabet. Alias for b64encode."""
+    return b64encode(s)
+
+
+def standard_b64decode(s):
+    """Decode standard Base64-encoded *s*. Alias for b64decode."""
+    return b64decode(s)
+
+
+def urlsafe_b64encode(s):
+    """Encode *s* using the URL-safe Base64 alphabet (- and _ instead of + and /)."""
+    data = v'_b64_to_arr(s)'
+    result = v'_b64_encode_impl(data, _B64_SAFE)'
+    return v'_b64_arr_to_bytes(_b64_to_arr(result))'
+
+
+def urlsafe_b64decode(s):
+    """Decode URL-safe Base64-encoded *s*, returning bytes."""
+    s_str = v'_b64_to_str(s)'
+    arr = v'_b64_decode_impl(s_str, _B64_SAFE_TABLE, false, Error)'
+    return bytes(arr)
+
+
+def encodebytes(s):
+    """Encode bytes *s* as Base64, inserting a newline after every 76 characters.
+
+    Matches Python's ``base64.encodebytes``. The returned bytes always ends
+    with a newline.
+    """
+    data = v'_b64_to_arr(s)'
+    encoded = v'_b64_encode_impl(data, _B64_STD)'
+    lines = []
+    i = 0
+    while i < v'encoded.length':
+        chunk = v'encoded.slice(i, i + 76)'
+        lines.append(chunk + '\n')
+        i += 76
+    if v'encoded.length' == 0:
+        lines.append('\n')
+    result_str = v'lines.join("")'
+    return v'_b64_arr_to_bytes(_b64_to_arr(result_str))'
+
+
+def decodebytes(s):
+    """Decode Base64 data from *s*, ignoring newline characters."""
+    s_str = v'_b64_to_str(s)'
+    # Strip newlines via split/join (avoids backslash-in-regex issues)
+    s_str = v's_str.split("\n").join("").split("\r").join("")'
+    arr = v'_b64_decode_impl(s_str, _B64_STD_TABLE, false, Error)'
+    return bytes(arr)
+
+
+# ---------------------------------------------------------------------------
+# Public API — Base32
+# ---------------------------------------------------------------------------
+
+def b32encode(s):
+    """Encode bytes *s* using Base32, returning a bytes object."""
+    data = v'_b64_to_arr(s)'
+    result = v'_b32_encode_impl(data)'
+    return v'_b64_arr_to_bytes(_b64_to_arr(result))'
+
+
+def b32decode(s, casefold=False, map01=None):
+    """Decode Base32-encoded *s*, returning a bytes object.
+
+    If *casefold* is ``True``, lowercase letters are accepted.
+    *map01* is an optional byte (e.g. ``b'I'``) to map the digit ``1`` to.
+    """
+    s_str = v'_b64_to_str(s)'
+    if casefold:
+        s_str = v's_str.toUpperCase()'
+    if map01 is not None:
+        target_char = v'String.fromCharCode(_b64_to_arr(map01)[0]).toUpperCase()'
+        # Replace '0' with 'O' and '1' with the target character
+        s_str = v's_str.split("0").join("O").split("1").join(target_char)'
+    arr = v'_b32_decode_impl(s_str, Error)'
+    return bytes(arr)
+
+
+# ---------------------------------------------------------------------------
+# Public API — Base16 (hex)
+# ---------------------------------------------------------------------------
+
+def b16encode(s):
+    """Encode bytes *s* as uppercase hexadecimal, returning a bytes object."""
+    data = v'_b64_to_arr(s)'
+    result = v'_b16_encode_impl(data)'
+    return v'_b64_arr_to_bytes(_b64_to_arr(result))'
+
+
+def b16decode(s, casefold=False):
+    """Decode hexadecimal-encoded *s*, returning a bytes object.
+
+    If *casefold* is ``True``, lowercase hex digits are accepted.
+    Raises ``Error`` on invalid input.
+    """
+    s_str = v'_b64_to_str(s)'
+    if casefold:
+        s_str = v's_str.toUpperCase()'
+    arr = v'_b16_decode_impl(s_str, Error)'
+    return bytes(arr)

package/src/lib/bisect.pyj

@@ -0,0 +1,73 @@
+###########################################################
+# RapydScript Standard Library
+# License: Apache License    2.0
+# This library is covered under Apache license, so that
+# you can distribute it with your RapydScript applications.
+###########################################################
+
+
+# Implementation of Python's 'bisect' module.
+# Binary search and sorted list insertion for maintaining sorted lists.
+#
+# key parameter (Python 3.10+): applied to each array element but NOT to x;
+# pass the desired comparison value as x directly when using key.
+
+
+def bisect_left(a, x, lo=0, hi=None, key=None):
+    if lo < 0:
+        raise ValueError('lo must be non-negative')
+    if hi is None:
+        hi = a.length
+    if key is None:
+        while lo < hi:
+            mid = Math.floor((lo + hi) / 2)
+            if a[mid] < x:
+                lo = mid + 1
+            else:
+                hi = mid
+    else:
+        while lo < hi:
+            mid = Math.floor((lo + hi) / 2)
+            if key(a[mid]) < x:
+                lo = mid + 1
+            else:
+                hi = mid
+    return lo
+
+
+def bisect_right(a, x, lo=0, hi=None, key=None):
+    if lo < 0:
+        raise ValueError('lo must be non-negative')
+    if hi is None:
+        hi = a.length
+    if key is None:
+        while lo < hi:
+            mid = Math.floor((lo + hi) / 2)
+            if x < a[mid]:
+                hi = mid
+            else:
+                lo = mid + 1
+    else:
+        while lo < hi:
+            mid = Math.floor((lo + hi) / 2)
+            if x < key(a[mid]):
+                hi = mid
+            else:
+                lo = mid + 1
+    return lo
+
+
+bisect = bisect_right
+
+
+def insort_left(a, x, lo=0, hi=None, key=None):
+    idx = bisect_left(a, x, lo, hi, key)
+    a.splice(idx, 0, x)
+
+
+def insort_right(a, x, lo=0, hi=None, key=None):
+    idx = bisect_right(a, x, lo, hi, key)
+    a.splice(idx, 0, x)
+
+
+insort = insort_right

package/src/lib/collections.pyj

@@ -13,7 +13,7 @@ def namedtuple(typename, field_names):
     """Return a new class with named fields, like Python's collections.namedtuple."""
     if isinstance(field_names, str):
         # Use explicit JS regex split for cross-environment safety
-        fields = v"field_names.replace(/,/g, ' ').trim().split(/\\s+/).filter(function(s){return s.length>0;})"
+        fields = v"field_names.replace(/,/g, ' ').trim().split(/\s+/).filter(function(s){return s.length>0;})"
     else:
         fields = list(field_names)
     n = fields.length