rapydscript-ns 0.9.2 → 0.9.4

package/release/signatures.json

@@ -1,34 +1,34 @@
 {
-    "ast": "88027aa403dfe55fcf8d475115897d141717d17c",
-    "baselib-builtins": "284e14536cfdd0b497abeb6f110ae49a20f2a172",
+    "ast": "1f915bd707f37c2eca90633cbe291b6c030e68a3",
+    "baselib-builtins": "1be74e1e78642c5cbf448f8f2a94aae0f1a3d59c",
     "baselib-bytes": "057ab581c276ef03ce91fecdd4213e412198251c",
-    "baselib-containers": "d2f534e6530dfb309b074bf7fac082c65779e778",
-    "baselib-errors": "8efbb59deb88ede0995768f63f57103f2f0fd02d",
-    "baselib-internal": "bb1eff32c1c50d5d25ea3074a968e765a136108c",
+    "baselib-containers": "6c480319b9d2ba5d2ee9376e02b67fcd45375912",
+    "baselib-errors": "c7e514d89ad79f2da41fe924f5ad93fc6f2cdf8e",
+    "baselib-internal": "19a95012b2bc1d18c47262ac908a6017e5092f49",
     "baselib-itertools": "268b7b7af79506e9a01023e8cd3b1741599bb6a5",
-    "baselib-str": "0e8d1ee658690412140cc138adf9681425de5084",
-    "compiler": "bb16e915c60dc4ffb5bfe98bef411736d19fa297",
-    "errors": "257eca38b6de987e5fd80672bec9b9981847e1bd",
-    "output\\classes": "469c47511692e04eb1bc2b079af3f65b47165865",
-    "output\\codegen": "69151b2cd53ff8b3270a122c65e1a0f56735150e",
-    "output\\comments": "63b39620f9d6f407aa2d4ddb557d1c60ef296b05",
-    "output\\exceptions": "e7d9119550403e6c5730d40b9bc9c923a23d6eb7",
-    "output\\functions": "5fe055661a45cf9de8ef024c758bb8214a87cd80",
-    "output\\jsx": "14f32c048301965de7764c5b74b651bc279de937",
-    "output\\literals": "287ec4222c79f1ebfa2c6efae925e794cbb931ab",
-    "output\\loops": "4e644417e6f2dd1fe8d289eddf774be166a4d4a4",
-    "output\\modules": "15735b9b07260d11ba231fc3439818bd1a54947e",
-    "output\\operators": "14b23f4a3ab3b1997411b8ec9f0f57d3e76a7da0",
-    "output\\statements": "94ee0cd084f22aea451b96eb1a9a831084cc4267",
-    "output\\stream": "2723d80bc398468e0828f50fb0837095c52f45dc",
-    "output\\treeshake": "4a490ba097739d924db9e3cd9eb7718db5e24cae",
-    "output\\utils": "e957919bfccb9a3ab510d824a8f2ee3fc2689795",
-    "output\\__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-    "parse": "0643834ed3c98d350ceb9ec71179f8923974c08c",
-    "string_interpolation": "88dce6c2c5ee75126a6838a1506841c6531a0d15",
-    "tokenizer": "79cf9d42ec2613b409b4dc6ed0e3ce112e4bd8c0",
-    "unicode_aliases": "7fbcbc9c24adcb2e33fac8d69aaafe5047fcc2c2",
-    "utils": "35a2a707c841da851e18c64edac54e7c20b7dfc9",
-    "#compiler#": "21a89c9ec81e3f4907eba75bf4c3d8b6aade4ad6",
-    "#compiled_with#": "21a89c9ec81e3f4907eba75bf4c3d8b6aade4ad6"
+    "baselib-str": "3fa63a0bf3bcf91cba4666093c3960633c6eed2e",
+    "compiler": "4c728d81b441b4b9c590f9330271f54b47cc11eb",
+    "errors": "d1b33848d19b141e19cc079cf78421f29b6d2c05",
+    "output/__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+    "output/classes": "469c47511692e04eb1bc2b079af3f65b47165865",
+    "output/codegen": "69151b2cd53ff8b3270a122c65e1a0f56735150e",
+    "output/comments": "78ec38d8b34da96c078653e2d0d4049d7003906b",
+    "output/exceptions": "d45bc62bc6b011bae182ed7c8df8ea5e392f6fb8",
+    "output/functions": "263416b49c60c78abee42fef83ec460e886fb243",
+    "output/jsx": "0a174c39378155c19dfa669e833c14d63190127b",
+    "output/literals": "287ec4222c79f1ebfa2c6efae925e794cbb931ab",
+    "output/loops": "1c9bbd6a2772dd2fc287c0b1aebfac7f5426eb27",
+    "output/modules": "8383da8f58a79921d24e4e0261360a7d0708c4db",
+    "output/operators": "8f7b1cf4f8a91102fc04104f8a799dcd8849963e",
+    "output/statements": "94ee0cd084f22aea451b96eb1a9a831084cc4267",
+    "output/stream": "9bd250ebb7ee43374d69c24357f8c985f95397d4",
+    "output/treeshake": "c1d65269ff21cfd046e947755a3489d0e670a74a",
+    "output/utils": "595968f96f6fdcc51eb41c34d64c92bb595e3cb1",
+    "parse": "d4ad97b80e3cbf810c55285bd47281bedfe027f9",
+    "string_interpolation": "bff1cc76d772d24d35707f6c794f38734ca08376",
+    "tokenizer": "7b8fb7855dc09aeeb16f6a513ae664951dd070e1",
+    "unicode_aliases": "79ac6eaa5e6be44a5397d62c561f854a8fe7528e",
+    "utils": "c1666db819aa7c8db38697e34e18362e3cb45869",
+    "#compiler#": "ce0d8d902910ca87ffa150b4d56775144ed6ec25",
+    "#compiled_with#": "ce0d8d902910ca87ffa150b4d56775144ed6ec25"
 }

package/src/ast.pyj

@@ -247,7 +247,8 @@ class AST_ForIn(AST_StatementWithBody):
         'init': "[AST_Node] the `for/in` initialization code",
         'name': "[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",
         'object': "[AST_Node] the object that we're looping through",
-        'belse': "[AST_Else?] the `else` clause, run when no break occurred"
+        'belse': "[AST_Else?] the `else` clause, run when no break occurred",
+        'is_async': "[bool*] True iff this is an `async for` (uses `for await ... of`)"
     }
 
     def _walk(self, visitor):
@@ -562,6 +563,7 @@ class AST_Lambda(AST_Scope):
         'is_expression': "[bool*] True iff this function is a function expression",
         'is_anonymous': "[bool*] True iff this function is an anonymous function",
         "return_annotation": "[AST_Node?] The return type annotation provided (if any)",
+        'type_enforce': "[bool*] True iff type_enforcement scoped flag is active for this function",
     }
 
     def _walk(self, visitor):
@@ -989,6 +991,7 @@ class AST_Binary(AST_Node):
         'right': "[AST_Node] right-hand side expression",
         'overloaded': "[bool] Whether to use Python-style operator overloading dispatch",
         'strict_arith': "[bool] Whether incompatible operand types raise TypeError (default True when overloaded; disable with no_strict_arithmetic)",
+        'python_mod': "[bool] Whether `%` uses Python-style modulo (sign of divisor); disable with no_python_modulo",
         'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
@@ -1277,6 +1280,12 @@ class AST_Number(AST_Constant):
         'value': "[number] the numeric value"
     }
 
+class AST_BigInt(AST_Constant):
+    "A BigInt literal (e.g. 42n)"
+    properties = {
+        'value': "[string] the raw numeric string (without n suffix)"
+    }
+
 class AST_RegExp(AST_Constant):
     "A regexp literal"
     properties = {

package/src/baselib-builtins.pyj

@@ -44,10 +44,51 @@ def ρσ_float(val):
     else:
         ans = parseFloat(val)
     if isNaN(ans):
+        if jstype(val) is 'string':
+            s = val.trim().toLowerCase()
+            if s is 'inf' or s is '+inf' or s is 'infinity' or s is '+infinity':
+                return v'Infinity'
+            if s is '-inf' or s is '-infinity':
+                return v'-Infinity'
+            if s is 'nan' or s is '+nan' or s is '-nan':
+                return v'NaN'
         raise ValueError('Could not convert string to float: ' + arguments[0])
     return ans
 ρσ_float.__name__ = 'float'
 
+def ρσ_long(val, base):
+    t = jstype(val)
+    if t is 'bigint':
+        return val
+    if t is 'boolean':
+        return v'BigInt(val ? 1 : 0)'
+    if t is 'number':
+        if not Number.isInteger(val):
+            raise TypeError("long() can't convert non-integer float to long")
+        v'try { return BigInt(val); } catch(e) { throw new ValueError("long() argument out of range: " + val); }'
+    if t is 'string':
+        b = base if (base is not None and base is not undefined) else 10
+        v'var ρσ_ls = val.trim()'
+        try:
+            if b is 16:
+                if v'ρσ_ls.slice(0, 2).toLowerCase()' is not '0x':
+                    v'ρσ_ls = "0x" + ρσ_ls'
+                return v'BigInt(ρσ_ls)'
+            elif b is 2:
+                if v'ρσ_ls.slice(0, 2).toLowerCase()' is not '0b':
+                    v'ρσ_ls = "0b" + ρσ_ls'
+                return v'BigInt(ρσ_ls)'
+            elif b is 8:
+                if v'ρσ_ls.slice(0, 2).toLowerCase()' is not '0o':
+                    v'ρσ_ls = "0o" + ρσ_ls'
+                return v'BigInt(ρσ_ls)'
+            else:
+                return v'BigInt(ρσ_ls)'
+        except:
+            raise ValueError('Invalid literal for long() with base ' + b + ': ' + val)
+    raise TypeError("long() argument must be a string, a number, or a boolean, not '" + t + "'")
+ρσ_long.__name__ = 'long'
+
 def ρσ_arraylike_creator():
     names = 'Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array'.split(' ')
     if jstype(HTMLCollection) is 'function':
@@ -308,8 +349,21 @@ def ρσ_pow(x, y, z):
         ans %= z
     return ans
 
+ρσ_NoneType = v'{"__name__": "NoneType"}'
+ρσ_NoneType.toString = def(): return "<class 'NoneType'>";
+ρσ_js_builtin_names = v'{"Number": "float", "String": "str", "Boolean": "bool", "Array": "list", "Object": "object", "Function": "function", "RegExp": "RegExp", "Date": "datetime", "Map": "dict", "Set": "set", "Uint8Array": "bytes"}'
+
 def ρσ_type(x):
-    return x.constructor
+    if x is None or x is undefined:
+        return ρσ_NoneType
+    c = x.constructor
+    if not c:
+        return ρσ_NoneType
+    if not v'Object.prototype.hasOwnProperty.call(c, "__ρσ_ts")':
+        n = c.__name__ or ρσ_js_builtin_names[c.name] or c.name or 'object'
+        c.toString = def(): return "<class '" + n + "'>";
+        c.__ρσ_ts = True
+    return c
 
 
 def ρσ_issubclass(cls, base):
@@ -793,7 +847,7 @@ class ρσ_complex:
 ρσ_complex.__name__ = 'complex'
 
 v'var abs = ρσ_abs, max = ρσ_max.bind(Math.max), min = ρσ_max.bind(Math.min), bool = ρσ_bool, type = ρσ_type'
-v'var float = ρσ_float, int = ρσ_int, complex = ρσ_complex, arraylike = ρσ_arraylike_creator(), ρσ_arraylike = arraylike'
+v'var float = ρσ_float, int = ρσ_int, long = ρσ_long, complex = ρσ_complex, arraylike = ρσ_arraylike_creator(), ρσ_arraylike = arraylike'
 v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod, __import__ = ρσ__import__'
 v'var dir = ρσ_dir, ord = ρσ_ord, chr = ρσ_chr, bin = ρσ_bin, hex = ρσ_hex, callable = ρσ_callable, round = ρσ_round'
 v'var enumerate = ρσ_enumerate, iter = ρσ_iter, reversed = ρσ_reversed, len = ρσ_len'

package/src/baselib-containers.pyj

@@ -122,9 +122,22 @@ def ρσ_list_sort_key(value):
     t = jstype(value)
     if t is 'string' or t is 'number':
         return value
+    # Keep objects that define __lt__ unchanged so ρσ_list_sort_cmp can
+    # dispatch the dunder; everything else falls back to a string key.
+    if value is not None and value is not undefined and jstype(value.__lt__) is 'function':
+        return value
     return value.toString()
 
 def ρσ_list_sort_cmp(a, b, ap, bp):
+    # When the elements define __lt__, order them the Pythonic way via
+    # ρσ_op_lt (which also handles a reflected __gt__); otherwise compare
+    # the precomputed primitive keys directly.
+    if a is not None and a is not undefined and jstype(a.__lt__) is 'function':
+        if ρσ_op_lt(a, b):
+            return -1
+        if ρσ_op_lt(b, a):
+            return 1
+        return ap - bp
     if a < b:
         return -1
     if a > b:
@@ -132,8 +145,17 @@ def ρσ_list_sort_cmp(a, b, ap, bp):
     return ap - bp
 
 def ρσ_list_sort(key=None, reverse=False):
-    key = key or ρσ_list_sort_key
     mult = -1 if reverse else 1
+    if key is not None and key is not undefined and jstype(key) is 'function' and key.length is 2:
+        # A two-argument function is treated as a comparator (à la
+        # functools.cmp_to_key) rather than a key function, so a JS-style
+        # `.sort((a, b) => ...)` callback works as expected.
+        cmpposmap = dict()
+        for v'var i=0; i < this.length; i++':
+            cmpposmap.set(this[i], i)  # noqa:undef
+        Array.prototype.sort.call(this, def (a, b): return (mult * key(a, b)) or (cmpposmap.get(a) - cmpposmap.get(b));)
+        return
+    key = key or ρσ_list_sort_key
     keymap = dict()
     posmap = dict()
     for v'var i=0; i < this.length; i++':
@@ -511,6 +533,7 @@ def ρσ_set_wrap(x):
     ans.jsset = x
     return ans
 
+ρσ_set.__name__ = 'set'
 v'var set = ρσ_set, set_wrap = ρσ_set_wrap'
 # }}}
 
@@ -902,6 +925,7 @@ def ρσ_dict_wrap(x):
     ans.jsmap = x
     return ans
 
+ρσ_dict.__name__ = 'dict'
 v'var dict = ρσ_dict, dict_wrap = ρσ_dict_wrap'
 
 v'''

package/src/baselib-errors.pyj

@@ -4,12 +4,13 @@
 # globals: ρσ_str
 
 v'var NameError = ReferenceError'
+v'var _ρσ_NativeError = Error'
 
 class Exception(Error):
 
     def __init__(self, message):
         self.message = message
-        self.stack = Error().stack
+        self.stack = v'_ρσ_NativeError'().stack
         self.name = self.constructor.name
 
     def __repr__(self):
@@ -18,10 +19,13 @@ class Exception(Error):
 class AttributeError(Exception):
     pass
 
-class IndexError(Exception):
+class LookupError(Exception):
     pass
 
-class KeyError(Exception):
+class IndexError(LookupError):
+    pass
+
+class KeyError(LookupError):
     pass
 
 class ValueError(Exception):

package/src/baselib-internal.pyj

@@ -282,6 +282,8 @@ def ρσ_arith_type_name(v):
     t = jstype(v)
     if t is 'boolean':
         return 'bool'
+    if t is 'bigint':
+        return 'long'
     if t is 'number':
         return 'int' if Number.isInteger(v) else 'float'
     if t is 'string' or v'v instanceof String':
@@ -303,6 +305,7 @@ def ρσ_op_add(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return v'a + b'
+    if ta is 'bigint' and tb is 'bigint': return v'a + b'
     if (ta is 'string' or v'a instanceof String') and (tb is 'string' or v'b instanceof String'): return v'a + b'
     raise TypeError("unsupported operand type(s) for +: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
@@ -312,6 +315,7 @@ def ρσ_op_sub(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return a - b
+    if ta is 'bigint' and tb is 'bigint': return v'a - b'
     raise TypeError("unsupported operand type(s) for -: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_mul(a, b):
@@ -332,6 +336,7 @@ def ρσ_op_mul(a, b):
             result = result.concat(b)  # noqa:undef
         return ρσ_list_constructor(result)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return a * b
+    if ta is 'bigint' and tb is 'bigint': return v'a * b'
     raise TypeError("unsupported operand type(s) for *: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_truediv(a, b):
@@ -340,6 +345,8 @@ def ρσ_op_truediv(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return a / b
+    if ta is 'bigint' and tb is 'bigint':
+        raise TypeError("unsupported operand type(s) for /: 'long' and 'long' — use // for integer division of long values")
     raise TypeError("unsupported operand type(s) for /: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_floordiv(a, b):
@@ -348,6 +355,8 @@ def ρσ_op_floordiv(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return Math.floor(a / b)
+    if ta is 'bigint' and tb is 'bigint':
+        v'var ρσ_bq = a / b, ρσ_br = a % b; if (ρσ_br !== 0n && (ρσ_br < 0n) !== (b < 0n)) { return ρσ_bq - 1n; } return ρσ_bq;'
     raise TypeError("unsupported operand type(s) for //: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_mod(a, b):
@@ -355,7 +364,10 @@ def ρσ_op_mod(a, b):
     if b is not None and jstype(b.__rmod__) is 'function': return b.__rmod__(a)
     ta = jstype(a)
     tb = jstype(b)
-    if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return a % b
+    if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'):
+        v'var ρσ_mr = a % b; if (ρσ_mr !== 0 && (ρσ_mr < 0) !== (b < 0)) { return ρσ_mr + Number(b); } return ρσ_mr;'
+    if ta is 'bigint' and tb is 'bigint':
+        v'var ρσ_mr = a % b; if (ρσ_mr !== 0n && (ρσ_mr < 0n) !== (b < 0n)) { return ρσ_mr + b; } return ρσ_mr;'
     raise TypeError("unsupported operand type(s) for %: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_pow(a, b):
@@ -364,32 +376,46 @@ def ρσ_op_pow(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return Math.pow(a, b)
+    if ta is 'bigint' and tb is 'bigint':
+        if v'b < 0n':
+            raise ValueError("negative exponent not supported for long values")
+        return v'a ** b'
     raise TypeError("unsupported operand type(s) for **: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_and(a, b):
     if a is not None and jstype(a.__and__) is 'function': return a.__and__(b)
     if b is not None and jstype(b.__rand__) is 'function': return b.__rand__(a)
-    return a & b
+    if (jstype(a) is 'bigint') is not (jstype(b) is 'bigint'):
+        raise TypeError("unsupported operand type(s) for &: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
+    return v'a & b'
 
 def ρσ_op_or(a, b):
     if a is not None and jstype(a.__or__) is 'function': return a.__or__(b)
     if b is not None and jstype(b.__ror__) is 'function': return b.__ror__(a)
-    return a | b
+    if (jstype(a) is 'bigint') is not (jstype(b) is 'bigint'):
+        raise TypeError("unsupported operand type(s) for |: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
+    return v'a | b'
 
 def ρσ_op_xor(a, b):
     if a is not None and jstype(a.__xor__) is 'function': return a.__xor__(b)
     if b is not None and jstype(b.__rxor__) is 'function': return b.__rxor__(a)
-    return a ^ b
+    if (jstype(a) is 'bigint') is not (jstype(b) is 'bigint'):
+        raise TypeError("unsupported operand type(s) for ^: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
+    return v'a ^ b'
 
 def ρσ_op_lshift(a, b):
     if a is not None and jstype(a.__lshift__) is 'function': return a.__lshift__(b)
     if b is not None and jstype(b.__rlshift__) is 'function': return b.__rlshift__(a)
-    return a << b
+    if (jstype(a) is 'bigint') is not (jstype(b) is 'bigint'):
+        raise TypeError("unsupported operand type(s) for <<: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
+    return v'a << b'
 
 def ρσ_op_rshift(a, b):
     if a is not None and jstype(a.__rshift__) is 'function': return a.__rshift__(b)
     if b is not None and jstype(b.__rrshift__) is 'function': return b.__rrshift__(a)
-    return a >> b
+    if (jstype(a) is 'bigint') is not (jstype(b) is 'bigint'):
+        raise TypeError("unsupported operand type(s) for >>: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
+    return v'a >> b'
 
 # Ordered-comparison operator overloading helpers.
 # ρσ_op_lt dispatches __lt__ (forward) then __gt__ (reflected), handles lists
@@ -409,6 +435,7 @@ def ρσ_op_lt(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return v'a < b'
+    if ta is 'bigint' and tb is 'bigint': return v'a < b'
     if (ta is 'string' or v'a instanceof String') and (tb is 'string' or v'b instanceof String'): return v'a < b'
     raise TypeError("'<' not supported between instances of '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
@@ -426,6 +453,7 @@ def ρσ_op_le(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return v'a <= b'
+    if ta is 'bigint' and tb is 'bigint': return v'a <= b'
     if (ta is 'string' or v'a instanceof String') and (tb is 'string' or v'b instanceof String'): return v'a <= b'
     raise TypeError("'<=' not supported between instances of '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
@@ -436,6 +464,7 @@ def ρσ_op_gt(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return v'a > b'
+    if ta is 'bigint' and tb is 'bigint': return v'a > b'
     if (ta is 'string' or v'a instanceof String') and (tb is 'string' or v'b instanceof String'): return v'a > b'
     raise TypeError("'>' not supported between instances of '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
@@ -446,6 +475,7 @@ def ρσ_op_ge(a, b):
     ta = jstype(a)
     tb = jstype(b)
     if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return v'a >= b'
+    if ta is 'bigint' and tb is 'bigint': return v'a >= b'
     if (ta is 'string' or v'a instanceof String') and (tb is 'string' or v'b instanceof String'): return v'a >= b'
     raise TypeError("'>=' not supported between instances of '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
@@ -575,16 +605,25 @@ def ρσ_op_truediv_ns(a, b):
 def ρσ_op_floordiv_ns(a, b):
     if a is not None and jstype(a.__floordiv__) is 'function': return a.__floordiv__(b)
     if b is not None and jstype(b.__rfloordiv__) is 'function': return b.__rfloordiv__(a)
+    if jstype(a) is 'bigint' and jstype(b) is 'bigint':
+        v'var ρσ_bq = a / b, ρσ_br = a % b; if (ρσ_br !== 0n && (ρσ_br < 0n) !== (b < 0n)) { return ρσ_bq - 1n; } return ρσ_bq;'
     return Math.floor(v'a / b')
 
 def ρσ_op_mod_ns(a, b):
     if a is not None and jstype(a.__mod__) is 'function': return a.__mod__(b)
     if b is not None and jstype(b.__rmod__) is 'function': return b.__rmod__(a)
+    ta = jstype(a)
+    tb = jstype(b)
+    if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'):
+        v'var ρσ_mr = a % b; if (ρσ_mr !== 0 && (ρσ_mr < 0) !== (b < 0)) { return ρσ_mr + Number(b); } return ρσ_mr;'
+    if ta is 'bigint' and tb is 'bigint':
+        v'var ρσ_mr = a % b; if (ρσ_mr !== 0n && (ρσ_mr < 0n) !== (b < 0n)) { return ρσ_mr + b; } return ρσ_mr;'
     return v'a % b'
 
 def ρσ_op_pow_ns(a, b):
     if a is not None and jstype(a.__pow__) is 'function': return a.__pow__(b)
     if b is not None and jstype(b.__rpow__) is 'function': return b.__rpow__(a)
+    if jstype(a) is 'bigint' and jstype(b) is 'bigint': return v'a ** b'
     return Math.pow(a, b)
 
 def ρσ_op_lt_ns(a, b):
@@ -665,12 +704,18 @@ def ρσ_instanceof():
             return True
         if (q is Array or q is ρσ_list_constructor) and Array.isArray(obj):
             return True
+        if q is ρσ_tuple_constructor and Array.isArray(obj):
+            return True
         if q is ρσ_str and (jstype(obj) is 'string' or v'obj instanceof String'):
             return True
+        if q is ρσ_bool and (jstype(obj) is 'boolean' or v'obj instanceof Boolean'):
+            return True
         if q is ρσ_int and (jstype(obj) is 'number' and Number.isInteger(obj)):
             return True
         if q is ρσ_float and (jstype(obj) is 'number' and not Number.isInteger(obj)):
             return True
+        if q is ρσ_long and jstype(obj) is 'bigint':
+            return True
         if bases.length > 1:
             for v'var c = 1; c < bases.length; c++':
                 cls = bases[c]

package/src/baselib-str.pyj

@@ -78,6 +78,8 @@ def ρσ_str(x):
         return 'None'
     if x is undefined:
         return 'undefined'
+    if v'typeof x === "bigint"':
+        return v'String(x)'
     ans = x
     if v'typeof x.__str__ === "function"':
         ans = x.__str__()
@@ -109,8 +111,19 @@ define_str_func = def(name, func):
     if func.__argnames__:
         Object.defineProperty(f, '__argnames__', {'value':v"['string']".concat(func.__argnames__)})
 
-ρσ_orig_split = String.prototype.split.call.bind(String.prototype.split)
-ρσ_orig_replace = String.prototype.replace.call.bind(String.prototype.replace)
+# Guard against multiple evaluations of the baselib in the same JS context
+# (e.g. web_repl()/create_compiler() being called repeatedly).  Without this,
+# each eval captures the PREVIOUS patched String.prototype.split as ρσ_orig_split,
+# creating a chain that eventually overflows the call stack.
+if v'typeof globalThis !== "undefined" && globalThis._ρσ_orig_split':
+    ρσ_orig_split = v'globalThis._ρσ_orig_split'
+    ρσ_orig_replace = v'globalThis._ρσ_orig_replace'
+else:
+    ρσ_orig_split = String.prototype.split.call.bind(String.prototype.split)
+    ρσ_orig_replace = String.prototype.replace.call.bind(String.prototype.replace)
+    if v'typeof globalThis !== "undefined"':
+        v'globalThis._ρσ_orig_split = ρσ_orig_split'
+        v'globalThis._ρσ_orig_replace = ρσ_orig_replace'
 
 # format()  {{{
 define_str_func('format', def ():
@@ -661,11 +674,11 @@ define_str_func('rpartition', def(sep):
 
 define_str_func('replace', def(old, repl, count):
     string = this
-    if count is 1:
+    if v'old instanceof RegExp':
         return ρσ_orig_replace(string, old, repl)
-    if count < 1:
+    if count is 0:
         return string
-    count = count or Number.MAX_VALUE
+    count = count if count > 0 else Number.MAX_VALUE
     pos = 0
     while count > 0:
         count -= 1