rapydscript-ns 0.8.3 → 0.9.0

package/src/baselib-internal.pyj

@@ -87,27 +87,24 @@ def ρσ_extends(child, parent):
     child.prototype.constructor = child
     Object.setPrototypeOf(child, parent)
 
-ρσ_in = (def ():
-    if jstype(Map) is 'function' and jstype(Set) is 'function':
-        return def(val, arr):
-            if jstype(arr) is 'string':
-                return arr.indexOf(val) is not -1
-            if jstype(arr.__contains__) is 'function':
-                return arr.__contains__(val)
-            if v'arr instanceof Map || arr instanceof Set':
-                return arr.has(val)
-            if ρσ_arraylike(arr):
-                return ρσ_list_contains.call(arr, val)
-            return Object.prototype.hasOwnProperty.call(arr, val)
-    return def(val, arr):
-        if jstype(arr) is 'string':
-            return arr.indexOf(val) is not -1
-        if jstype(arr.__contains__) is 'function':
-            return arr.__contains__(val)
-        if ρσ_arraylike(arr):
-            return ρσ_list_contains.call(arr, val)
-        return Object.prototype.hasOwnProperty.call(arr, val)
-)()
+def ρσ_object_new(cls):
+    return v'Object.create(cls.prototype)'
+
+def ρσ_new(parent, cls):
+    if parent and jstype(parent.__new__) is 'function':
+        return parent.__new__.apply(parent, v'Array.prototype.slice.call(arguments, 1)')
+    return v'Object.create(cls.prototype)'
+
+def ρσ_in(val, arr):
+    if jstype(arr) is 'string':
+        return arr.indexOf(val) is not -1
+    if jstype(arr.__contains__) is 'function':
+        return arr.__contains__(val)
+    if jstype(Map) is 'function' and (v'arr instanceof Map' or v'arr instanceof Set'):
+        return arr.has(val)
+    if ρσ_arraylike(arr):
+        return ρσ_list_contains.call(arr, val)
+    return Object.prototype.hasOwnProperty.call(arr, val)
 
 def ρσ_Iterable(iterable):
     # Once ES6 is mature, change AST_ForIn to use the iterator protocol and get
@@ -125,23 +122,20 @@ def ρσ_Iterable(iterable):
     # so we can use 'for ... in' syntax with objects, as we would with dicts in python
     return Object.keys(iterable)
 
-ρσ_desugar_kwargs = (def ():
-    if jstype(Object.assign) is 'function':
-        return def():
-            ans = Object.create(None)
-            ans[ρσ_kwargs_symbol] = True
-            for v'var i = 0; i < arguments.length; i++':
-                Object.assign(ans, arguments[i])
-            return ans
-    return def():
-        ans = Object.create(None)
-        ans[ρσ_kwargs_symbol] = True
-        for v'var i = 0; i < arguments.length; i++':
-            keys = Object.keys(arguments[i])
+def ρσ_desugar_kwargs():
+    ans = Object.create(None)
+    ans[ρσ_kwargs_symbol] = True
+    for v'var i = 0; i < arguments.length; i++':
+        arg = arguments[i]
+        if v'arg && arg.jsmap && typeof arg.jsmap.forEach === "function"':
+            v'arg.jsmap.forEach(function(v, k) { ans[k] = v; })'
+        elif jstype(Object.assign) is 'function':
+            Object.assign(ans, arg)
+        else:
+            keys = Object.keys(arg)
             for v'var j = 0; j < keys.length; j++':
-                ans[keys[j]] = arguments[i][keys[j]]
-        return ans
-)()
+                ans[keys[j]] = arg[keys[j]]
+    return ans
 
 def ρσ_interpolate_kwargs(f, supplied_args):
     if not f.__argnames__:
@@ -177,6 +171,8 @@ def ρσ_interpolate_kwargs_constructor(apply, f, supplied_args):
     return this
 
 def ρσ_getitem(obj, key):
+    if v'typeof obj === "function"' and obj.__class_getitem__:
+        return obj.__class_getitem__(key)
     if obj.__getitem__:
         return obj.__getitem__(key)
     if v'typeof ρσ_slice !== "undefined" && key instanceof ρσ_slice':
@@ -249,6 +245,7 @@ def ρσ_splice(arr, val, start, end):
     ,'e': def(expr, alt):
         return alt if expr is undefined or expr is None else expr
 }
+v'(typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : global)["ρσ_exists"] = ρσ_exists'
 
 def ρσ_mixin():
     # Implement a depth-first left-to-right method resolution order This is not
@@ -278,55 +275,96 @@ def ρσ_mixin():
             p = Object.getPrototypeOf(p)
     Object.defineProperties(target, resolved_props)
 
+# Returns a Python-style type name used in arithmetic TypeError messages.
+def ρσ_arith_type_name(v):
+    if v is None or v is undefined:
+        return 'NoneType'
+    t = jstype(v)
+    if t is 'boolean':
+        return 'bool'
+    if t is 'number':
+        return 'int' if Number.isInteger(v) else 'float'
+    if t is 'string' or v'v instanceof String':
+        return 'str'
+    if Array.isArray(v):
+        return 'list'
+    if v.constructor and v.constructor.__name__:
+        return v.constructor.__name__
+    return t
+
 # Arithmetic/bitwise operator overloading helpers.
 # Each checks for the forward dunder method, then the reflected one, then
-# falls back to the native JS operation (with special handling for // and **).
+# enforces Python-style type compatibility before the native JS operation.
+# Incompatible operand types raise TypeError, mirroring Python semantics.
 def ρσ_op_add(a, b):
     if a is not None and jstype(a.__add__) is 'function': return a.__add__(b)
     if b is not None and jstype(b.__radd__) is 'function': return b.__radd__(a)
-    return a + b
+    if Array.isArray(a) and Array.isArray(b): return ρσ_list_constructor(a.concat(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 '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) + "'")
 
 def ρσ_op_sub(a, b):
     if a is not None and jstype(a.__sub__) is 'function': return a.__sub__(b)
     if b is not None and jstype(b.__rsub__) is 'function': return b.__rsub__(a)
-    return 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
+    raise TypeError("unsupported operand type(s) for -: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_mul(a, b):
     if a is not None and jstype(a.__mul__) is 'function': return a.__mul__(b)
     if b is not None and jstype(b.__rmul__) is 'function': return b.__rmul__(a)
-    if (jstype(a) is 'string' or v'a instanceof String') and jstype(b) is 'number': return a.repeat(b)
-    if (jstype(b) is 'string' or v'b instanceof String') and jstype(a) is 'number': return b.repeat(a)
-    if Array.isArray(a) and jstype(b) is 'number':
+    ta = jstype(a)
+    tb = jstype(b)
+    if (ta is 'string' or v'a instanceof String') and (tb is 'number' or tb is 'boolean'): return a.repeat(b)
+    if (tb is 'string' or v'b instanceof String') and (ta is 'number' or ta is 'boolean'): return b.repeat(a)
+    if Array.isArray(a) and (tb is 'number' or tb is 'boolean'):
         result = v'[]'
         for v'var ρσ_mi = 0; ρσ_mi < b; ρσ_mi++':
             result = result.concat(a)  # noqa:undef
         return ρσ_list_constructor(result)
-    if Array.isArray(b) and jstype(a) is 'number':
+    if Array.isArray(b) and (ta is 'number' or ta is 'boolean'):
         result = v'[]'
         for v'var ρσ_mi = 0; ρσ_mi < a; ρσ_mi++':
             result = result.concat(b)  # noqa:undef
         return ρσ_list_constructor(result)
-    return a * b
+    if (ta is 'number' or ta is 'boolean') and (tb is 'number' or tb is 'boolean'): return a * b
+    raise TypeError("unsupported operand type(s) for *: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_truediv(a, b):
     if a is not None and jstype(a.__truediv__) is 'function': return a.__truediv__(b)
     if b is not None and jstype(b.__rtruediv__) is 'function': return b.__rtruediv__(a)
-    return 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
+    raise TypeError("unsupported operand type(s) for /: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_floordiv(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)
-    return Math.floor(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)
+    raise TypeError("unsupported operand type(s) for //: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_mod(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)
-    return 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
+    raise TypeError("unsupported operand type(s) for %: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 def ρσ_op_pow(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)
-    return Math.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)
+    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)
@@ -353,12 +391,74 @@ def ρσ_op_rshift(a, b):
     if b is not None and jstype(b.__rrshift__) is 'function': return b.__rrshift__(a)
     return a >> b
 
+# Ordered-comparison operator overloading helpers.
+# ρσ_op_lt dispatches __lt__ (forward) then __gt__ (reflected), handles lists
+# lexicographically, enforces type compatibility, and raises TypeError otherwise.
+# ρσ_op_gt / ρσ_op_ge delegate to ρσ_op_lt / ρσ_op_le after dunder checks.
+def ρσ_op_lt(a, b):
+    if a is not None and jstype(a.__lt__) is 'function': return a.__lt__(b)
+    if b is not None and jstype(b.__gt__) is 'function': return b.__gt__(a)
+    if Array.isArray(a) and Array.isArray(b):
+        n = Math.min(a.length, b.length)
+        for v'var ρσ_ci = 0; ρσ_ci < n; ρσ_ci++':
+            ea = v'a[ρσ_ci]'
+            eb = v'b[ρσ_ci]'
+            if ρσ_op_lt(ea, eb): return True
+            if ρσ_op_lt(eb, ea): return False
+        return v'a.length < b.length'
+    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 '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) + "'")
+
+def ρσ_op_le(a, b):
+    if a is not None and jstype(a.__le__) is 'function': return a.__le__(b)
+    if b is not None and jstype(b.__ge__) is 'function': return b.__ge__(a)
+    if Array.isArray(a) and Array.isArray(b):
+        n = Math.min(a.length, b.length)
+        for v'var ρσ_ci = 0; ρσ_ci < n; ρσ_ci++':
+            ea = v'a[ρσ_ci]'
+            eb = v'b[ρσ_ci]'
+            if ρσ_op_lt(ea, eb): return True
+            if ρσ_op_lt(eb, ea): return False
+        return v'a.length <= b.length'
+    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 '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) + "'")
+
+def ρσ_op_gt(a, b):
+    if a is not None and jstype(a.__gt__) is 'function': return a.__gt__(b)
+    if b is not None and jstype(b.__lt__) is 'function': return b.__lt__(a)
+    if Array.isArray(a) and Array.isArray(b): return ρσ_op_lt(b, a)
+    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 '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) + "'")
+
+def ρσ_op_ge(a, b):
+    if a is not None and jstype(a.__ge__) is 'function': return a.__ge__(b)
+    if b is not None and jstype(b.__le__) is 'function': return b.__le__(a)
+    if Array.isArray(a) and Array.isArray(b): return ρσ_op_le(b, a)
+    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 '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) + "'")
+
 # List-concatenation helpers (always available, no overload_operators required).
 # ρσ_list_add: used for the + operator; creates a new list when both sides are arrays.
 # NOTE: the fallback uses v'a + b' (verbatim JS) to avoid recursive self-compilation.
 def ρσ_list_add(a, b):
     if Array.isArray(a) and Array.isArray(b):
         return ρσ_list_constructor(a.concat(b))
+    if a is not None and a is not undefined and jstype(a.__add__) is 'function':
+        return a.__add__(b)
+    if b is not None and b is not undefined and jstype(b.__radd__) is 'function':
+        return b.__radd__(a)
     return v'a + b'
 
 # ρσ_list_iadd: used for +=; extends a in-place when both sides are arrays (Python semantics).
@@ -366,6 +466,10 @@ def ρσ_list_iadd(a, b):
     if Array.isArray(a) and Array.isArray(b):
         v'Array.prototype.push.apply(a, b)'
         return a
+    if a is not None and a is not undefined and jstype(a.__iadd__) is 'function':
+        return a.__iadd__(b)
+    if a is not None and a is not undefined and jstype(a.__add__) is 'function':
+        return a.__add__(b)
     return v'a + b'
 
 # Unary operator overloading helpers
@@ -430,6 +534,126 @@ def ρσ_op_irshift(a, b):
     if a is not None and jstype(a.__irshift__) is 'function': return a.__irshift__(b)
     return ρσ_op_rshift(a, b)
 
+# No-strict (ns) variants: same dunder dispatch but JS native fallback instead of TypeError.
+# Used when overload_operators is active but strict_arithmetic is disabled
+# (from __python__ import no_strict_arithmetic).
+def ρσ_op_add_ns(a, b):
+    if a is not None and jstype(a.__add__) is 'function': return a.__add__(b)
+    if b is not None and jstype(b.__radd__) is 'function': return b.__radd__(a)
+    if Array.isArray(a) and Array.isArray(b): return ρσ_list_constructor(a.concat(b))
+    return v'a + b'
+
+def ρσ_op_sub_ns(a, b):
+    if a is not None and jstype(a.__sub__) is 'function': return a.__sub__(b)
+    if b is not None and jstype(b.__rsub__) is 'function': return b.__rsub__(a)
+    return v'a - b'
+
+def ρσ_op_mul_ns(a, b):
+    if a is not None and jstype(a.__mul__) is 'function': return a.__mul__(b)
+    if b is not None and jstype(b.__rmul__) is 'function': return b.__rmul__(a)
+    ta = jstype(a)
+    tb = jstype(b)
+    if (ta is 'string' or v'a instanceof String') and (tb is 'number' or tb is 'boolean'): return a.repeat(b)
+    if (tb is 'string' or v'b instanceof String') and (ta is 'number' or ta is 'boolean'): return b.repeat(a)
+    if Array.isArray(a) and (tb is 'number' or tb is 'boolean'):
+        result = v'[]'
+        for v'var ρσ_mi = 0; ρσ_mi < b; ρσ_mi++':
+            result = result.concat(a)  # noqa:undef
+        return ρσ_list_constructor(result)
+    if Array.isArray(b) and (ta is 'number' or ta is 'boolean'):
+        result = v'[]'
+        for v'var ρσ_mi = 0; ρσ_mi < a; ρσ_mi++':
+            result = result.concat(b)  # noqa:undef
+        return ρσ_list_constructor(result)
+    return v'a * b'
+
+def ρσ_op_truediv_ns(a, b):
+    if a is not None and jstype(a.__truediv__) is 'function': return a.__truediv__(b)
+    if b is not None and jstype(b.__rtruediv__) is 'function': return b.__rtruediv__(a)
+    return v'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)
+    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)
+    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)
+    return Math.pow(a, b)
+
+def ρσ_op_lt_ns(a, b):
+    if a is not None and jstype(a.__lt__) is 'function': return a.__lt__(b)
+    if b is not None and jstype(b.__gt__) is 'function': return b.__gt__(a)
+    if Array.isArray(a) and Array.isArray(b):
+        n = Math.min(a.length, b.length)
+        for v'var ρσ_ci = 0; ρσ_ci < n; ρσ_ci++':
+            ea = v'a[ρσ_ci]'
+            eb = v'b[ρσ_ci]'
+            if ρσ_op_lt_ns(ea, eb): return True
+            if ρσ_op_lt_ns(eb, ea): return False
+        return v'a.length < b.length'
+    return v'a < b'
+
+def ρσ_op_le_ns(a, b):
+    if a is not None and jstype(a.__le__) is 'function': return a.__le__(b)
+    if b is not None and jstype(b.__ge__) is 'function': return b.__ge__(a)
+    if Array.isArray(a) and Array.isArray(b):
+        n = Math.min(a.length, b.length)
+        for v'var ρσ_ci = 0; ρσ_ci < n; ρσ_ci++':
+            ea = v'a[ρσ_ci]'
+            eb = v'b[ρσ_ci]'
+            if ρσ_op_lt_ns(ea, eb): return True
+            if ρσ_op_lt_ns(eb, ea): return False
+        return v'a.length <= b.length'
+    return v'a <= b'
+
+def ρσ_op_gt_ns(a, b):
+    if a is not None and jstype(a.__gt__) is 'function': return a.__gt__(b)
+    if b is not None and jstype(b.__lt__) is 'function': return b.__lt__(a)
+    if Array.isArray(a) and Array.isArray(b): return ρσ_op_lt_ns(b, a)
+    return v'a > b'
+
+def ρσ_op_ge_ns(a, b):
+    if a is not None and jstype(a.__ge__) is 'function': return a.__ge__(b)
+    if b is not None and jstype(b.__le__) is 'function': return b.__le__(a)
+    if Array.isArray(a) and Array.isArray(b): return ρσ_op_le_ns(b, a)
+    return v'a >= b'
+
+# No-strict augmented-assignment helpers
+def ρσ_op_iadd_ns(a, b):
+    if a is not None and jstype(a.__iadd__) is 'function': return a.__iadd__(b)
+    return ρσ_op_add_ns(a, b)
+
+def ρσ_op_isub_ns(a, b):
+    if a is not None and jstype(a.__isub__) is 'function': return a.__isub__(b)
+    return ρσ_op_sub_ns(a, b)
+
+def ρσ_op_imul_ns(a, b):
+    if a is not None and jstype(a.__imul__) is 'function': return a.__imul__(b)
+    return ρσ_op_mul_ns(a, b)
+
+def ρσ_op_itruediv_ns(a, b):
+    if a is not None and jstype(a.__itruediv__) is 'function': return a.__itruediv__(b)
+    return ρσ_op_truediv_ns(a, b)
+
+def ρσ_op_ifloordiv_ns(a, b):
+    if a is not None and jstype(a.__ifloordiv__) is 'function': return a.__ifloordiv__(b)
+    return ρσ_op_floordiv_ns(a, b)
+
+def ρσ_op_imod_ns(a, b):
+    if a is not None and jstype(a.__imod__) is 'function': return a.__imod__(b)
+    return ρσ_op_mod_ns(a, b)
+
+def ρσ_op_ipow_ns(a, b):
+    if a is not None and jstype(a.__ipow__) is 'function': return a.__ipow__(b)
+    return ρσ_op_pow_ns(a, b)
+
 def ρσ_instanceof():
     obj = arguments[0]
     bases = ''
@@ -458,3 +682,76 @@ def ρσ_instanceof():
                         break
                     cls = p.constructor
     return False
+
+# ── Attribute-dunder support (__getattr__ / __setattr__ / __delattr__ / __getattribute__) ──
+# We use a JavaScript Proxy to intercept attribute access/assignment/deletion on class instances
+# that define any of the four attribute dunders.
+
+# Cache the JS Proxy constructor with a ρσ_ name to avoid collisions with user-defined 'Proxy' classes.
+v'var ρσ_JS_Proxy = typeof Proxy === "function" ? Proxy : null'
+
+# Symbol (or fallback string key) used to retrieve the raw underlying target from a wrapped proxy.
+v'var ρσ_proxy_target_symbol = typeof Symbol === "function" ? Symbol("ρσ_proxy_target") : "__ρσ_proxy_target__"'
+
+ρσ_attr_proxy_handler = {
+    'get': def(target, prop, receiver):
+        # Always expose the raw target via the sentinel key (used by ρσ_object_* helpers).
+        if prop is ρσ_proxy_target_symbol:
+            return target
+        # Pass through JS symbols (Symbol.iterator, Symbol.toPrimitive, etc.) unchanged.
+        if jstype(prop) is 'symbol':
+            return v'Reflect.get(target, prop, receiver)'
+        # __getattribute__ overrides every attribute lookup (except itself, to avoid infinite recursion).
+        if jstype(target.__getattribute__) is 'function' and prop is not '__getattribute__':
+            try:
+                return target.__getattribute__.call(receiver, prop)
+            except AttributeError:
+                # AttributeError from __getattribute__ → try __getattr__ fallback.
+                if jstype(target.__getattr__) is 'function':
+                    return target.__getattr__.call(receiver, prop)
+                raise
+        # Normal property lookup via prototype chain.
+        val = v'Reflect.get(target, prop, receiver)'
+        # __getattr__ is only called when the attribute is genuinely missing.
+        if val is undefined and jstype(target.__getattr__) is 'function' and not v'(prop in target)':
+            return target.__getattr__.call(receiver, prop)
+        return val
+    ,
+    'set': def(target, prop, value, receiver):
+        if jstype(target.__setattr__) is 'function':
+            target.__setattr__.call(receiver, prop, value)
+            return True
+        # Pass 'target' as receiver (not proxy) to avoid infinite recursion through the Proxy set trap.
+        return v'Reflect.set(target, prop, value, target)'
+    ,
+    'deleteProperty': def(target, prop):
+        if jstype(target.__delattr__) is 'function':
+            # deleteProperty has no receiver; pass target as 'this'.
+            # Inside __delattr__, use ρσ_object_delattr(self, name) for a direct delete.
+            target.__delattr__.call(target, prop)
+            return True
+        return v'Reflect.deleteProperty(target, prop)'
+}
+v'(typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : global)["ρσ_attr_proxy_handler"] = ρσ_attr_proxy_handler'
+
+def ρσ_object_setattr(obj, name, value):
+    # Bypass __setattr__ and set directly on the underlying object.
+    # Use this inside __setattr__ to avoid infinite recursion (like object.__setattr__ in Python).
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    v'target[name] = value'
+
+def ρσ_object_getattr(obj, name):
+    # Bypass __getattribute__ and read directly from the underlying object.
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    return target[name]
+
+def ρσ_object_delattr(obj, name):
+    # Bypass __delattr__ and delete directly from the underlying object.
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    v'delete target[name]'

package/src/baselib-itertools.pyj

@@ -2,7 +2,7 @@
 # License: BSD
 # Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
 
-# globals: ρσ_iterator_symbol, ρσ_bool
+# globals: ρσ_iterator_symbol, ρσ_bool, ρσ_kwargs_symbol
 
 def sum(iterable, start):
     if Array.isArray(iterable):
@@ -52,17 +52,30 @@ def filter(func_or_none, iterable):
     return ans
 
 def zip():
-    iterators = new Array(arguments.length)
-    for v'var i = 0; i < arguments.length; i++':
+    n = arguments.length
+    strict = False
+    if n > 0 and v'typeof arguments[n - 1] === "object" && arguments[n - 1] !== null' and arguments[n-1][ρσ_kwargs_symbol] is True:
+        strict = arguments[n-1]['strict'] or False
+        n -= 1
+    iterators = new Array(n)
+    for v'var i = 0; i < n; i++':
         iterators[i] = iter(arguments[i])  # noqa:undef
-    ans = v"{'_iterators':iterators}"
+    ans = v"{'_iterators':iterators, '_strict':strict}"
     ans[ρσ_iterator_symbol] = def():
         return this
     ans['next'] = def():
+        if not this._iterators.length:
+            return v"{'done':true}"
         args = new Array(this._iterators.length)
         for v'var i = 0; i < this._iterators.length; i++':
             r = this._iterators[i].next()
             if r.done:
+                if this._strict:
+                    for v'var j = i + 1; j < this._iterators.length; j++':
+                        if not this._iterators[j].next().done:
+                            raise ValueError('zip() has arguments with different lengths')
+                    if v'i > 0':
+                        raise ValueError('zip() has arguments with different lengths')
                 return v"{'done':true}"
             args[i] = r.value  # noqa:undef
         return v"{'done':false, 'value':args}"

package/src/baselib-str.pyj

@@ -109,7 +109,8 @@ define_str_func = def(name, func):
     if func.__argnames__:
         Object.defineProperty(f, '__argnames__', {'value':v"['string']".concat(func.__argnames__)})
 
-ρσ_orig_split, ρσ_orig_replace = String.prototype.split.call.bind(String.prototype.split), String.prototype.replace.call.bind(String.prototype.replace)
+ρσ_orig_split = String.prototype.split.call.bind(String.prototype.split)
+ρσ_orig_replace = String.prototype.replace.call.bind(String.prototype.replace)
 
 # format()  {{{
 define_str_func('format', def ():
@@ -367,9 +368,20 @@ define_str_func('format', def ():
             idx += 1
         if jstype(object) is 'function':
             object = object()
-        ans = '' + object
-        if format_spec:
-            ans = apply_formatting(ans, format_spec)
+        # Apply !-conversion (transformer) before format spec, per Python semantics
+        if transformer is 'r':
+            object = ρσ_repr(object)
+        elif transformer is 's':
+            object = ρσ_str(object)
+        elif transformer is 'a':
+            object = ρσ_repr(object)
+        # Dispatch to __format__ when defined and no transformer was applied
+        if not transformer and object is not None and object is not undefined and v'typeof object.__format__ === "function"':
+            ans = object.__format__(format_spec or '')
+        else:
+            ans = '' + object
+            if format_spec:
+                ans = apply_formatting(ans, format_spec)
         if ends_with_equal:
             ans = f'{key}={ans}'
         return ans
@@ -693,6 +705,12 @@ define_str_func('split', def(sep, maxsplit):
             ans.push(extra)
     return ρσ_list_decorate(ans)
 )
+# Patch String.prototype.split so that no-argument calls (text.split()) use Python
+# semantics (split on whitespace) rather than JS semantics (return [text]).
+String.prototype.split = def(sep, limit):
+    if sep is undefined:
+        return ρσ_str.prototype.split.call(this)
+    return ρσ_orig_split(this, sep, limit)
 
 define_str_func('rsplit', def(sep, maxsplit):
     if not maxsplit:
@@ -774,6 +792,29 @@ define_str_func('zfill', def(width):
     return string
 )
 
+define_str_func('expandtabs', def(tabsize):
+    if tabsize is undefined:
+        tabsize = 8
+    string = this
+    ans = ''
+    col = 0
+    for v'var i = 0; i < string.length; i++':
+        ch = string[i]  # noqa:undef
+        if ch is '\t':
+            if tabsize > 0:
+                spaces = tabsize - (col % tabsize)
+                ans += v'new Array(spaces + 1).join(" ")'
+                col += spaces
+            # tabsize <= 0: tab adds no spaces, col stays
+        elif ch is '\n' or ch is '\r':
+            ans += ch
+            col = 0
+        else:
+            ans += ch
+            col += 1
+    return ans
+)
+
 ρσ_str.uchrs = def(string, with_positions):
     # Return iterator over unicode chars in string. Will yield the unicode
     # replacement char U+FFFD for broken surrogate pairs
@@ -836,4 +877,5 @@ def ρσ_format(value, spec):
         return ρσ_str(value)
     return str.format('{:' + spec + '}', value)
 
+ρσ_str.__name__ = 'str'
 v'var str = ρσ_str, repr = ρσ_repr, format = ρσ_format'