rapydscript-ns 0.8.3 → 0.9.0

package/release/signatures.json

@@ -1,31 +1,34 @@
 {
-    "ast": "7a1a1800d9ee7af7f7153eee38002e4e9dcfb71e",
-    "baselib-builtins": "50927b38fded9bd9dbe14c42a20dd8e930ac021f",
-    "baselib-containers": "f7ac21a4dfc6311693239ea1eb45e74fae45a3f5",
-    "baselib-errors": "f2423e1e2489bdd7fb8c8725bb76436898c8008c",
-    "baselib-internal": "1b77d40970a8ef2d886132dc7c21c9510d2eb4cd",
-    "baselib-itertools": "ab1f3257642c8d26fab1ff9d392814a459a60cdb",
-    "baselib-str": "8c396e4fae02ae34b6d3d805becf7bfdd36625ee",
-    "compiler": "cfbfceb0439fed3302f78d80b303dca713b25e7b",
+    "ast": "88027aa403dfe55fcf8d475115897d141717d17c",
+    "baselib-builtins": "284e14536cfdd0b497abeb6f110ae49a20f2a172",
+    "baselib-bytes": "057ab581c276ef03ce91fecdd4213e412198251c",
+    "baselib-containers": "d2f534e6530dfb309b074bf7fac082c65779e778",
+    "baselib-errors": "8efbb59deb88ede0995768f63f57103f2f0fd02d",
+    "baselib-internal": "bb1eff32c1c50d5d25ea3074a968e765a136108c",
+    "baselib-itertools": "268b7b7af79506e9a01023e8cd3b1741599bb6a5",
+    "baselib-str": "0e8d1ee658690412140cc138adf9681425de5084",
+    "compiler": "4c728d81b441b4b9c590f9330271f54b47cc11eb",
     "errors": "d1b33848d19b141e19cc079cf78421f29b6d2c05",
     "output/__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-    "output/classes": "d05c1992cc91b337a4e4ff137b0aa3d626e6624b",
-    "output/codegen": "0519a88c2704fe60b98fe747ca39f6be43b9abf3",
+    "output/classes": "469c47511692e04eb1bc2b079af3f65b47165865",
+    "output/codegen": "69151b2cd53ff8b3270a122c65e1a0f56735150e",
     "output/comments": "78ec38d8b34da96c078653e2d0d4049d7003906b",
-    "output/exceptions": "c7d90155694c7108e94d0940a160ae83725421d7",
-    "output/functions": "abaa81b171359eb77be6ea87cbdf9d7421d4622b",
-    "output/literals": "fdbfb744fec8dfea1e1c62cb49767c60160fd402",
-    "output/loops": "f59cc623320f57edb01953f7877d712758e9f825",
-    "output/modules": "bd3e3f3f6794fb6e401867b4d011c4e3aab98893",
-    "output/operators": "f8142836a13b75680cb4874391db9e871fad0cad",
-    "output/statements": "7d8dfdc0b43e3e430be7ce3b23ffaf1b41408d8c",
-    "output/stream": "46375cb467477ac898546e818bfdfa5be738c352",
+    "output/exceptions": "d45bc62bc6b011bae182ed7c8df8ea5e392f6fb8",
+    "output/functions": "5fe055661a45cf9de8ef024c758bb8214a87cd80",
+    "output/jsx": "0a174c39378155c19dfa669e833c14d63190127b",
+    "output/literals": "287ec4222c79f1ebfa2c6efae925e794cbb931ab",
+    "output/loops": "8a0dd93b95e1b9c2a29344e6b41cb5cec6b7afc5",
+    "output/modules": "15735b9b07260d11ba231fc3439818bd1a54947e",
+    "output/operators": "14b23f4a3ab3b1997411b8ec9f0f57d3e76a7da0",
+    "output/statements": "94ee0cd084f22aea451b96eb1a9a831084cc4267",
+    "output/stream": "2723d80bc398468e0828f50fb0837095c52f45dc",
+    "output/treeshake": "c1d65269ff21cfd046e947755a3489d0e670a74a",
     "output/utils": "595968f96f6fdcc51eb41c34d64c92bb595e3cb1",
-    "parse": "d5c1a77662dfcff841dfcd368d5dbb129a592f5d",
+    "parse": "0643834ed3c98d350ceb9ec71179f8923974c08c",
     "string_interpolation": "bff1cc76d772d24d35707f6c794f38734ca08376",
-    "tokenizer": "00fc24a41edac9f9b31735e6290348005a623cef",
+    "tokenizer": "134f46d5a10576c6a27d4fe024c63f45e111fefe",
     "unicode_aliases": "79ac6eaa5e6be44a5397d62c561f854a8fe7528e",
     "utils": "c1666db819aa7c8db38697e34e18362e3cb45869",
-    "#compiler#": "d98fcbb15d08dae74d9c7371ea28fea676642e67",
-    "#compiled_with#": "d98fcbb15d08dae74d9c7371ea28fea676642e67"
+    "#compiler#": "d41c267ea92de4937495c7d35c8d50e1b48f550c",
+    "#compiled_with#": "d41c267ea92de4937495c7d35c8d50e1b48f550c"
 }

package/src/ast.pyj

@@ -600,6 +600,9 @@ class AST_Class(AST_Scope):
         'statements': "[AST_Node*] list of statements in the class scope (excluding method definitions)",
         'dynamic_properties': '[dict] map of dynamic property names to property descriptors of the form {getter:AST_Method, setter:AST_Method',
         'classvars': '[dict] map containing all class variables as keys, to be used to easily test for existence of a class variable',
+        'has_new': "[boolean] true if the class defines a __new__ method",
+        'has_attr_dunders': "[boolean] true if the class defines any of __getattr__/__setattr__/__delattr__/__getattribute__",
+        'class_kwargs': "[array] keyword arguments from class header (e.g. class C(Base, key=val):) as [[key_node, value_node], ...]",
     }
 
     def _walk(self, visitor):
@@ -610,6 +613,9 @@ class AST_Class(AST_Scope):
             self.name._walk(visitor)
             walk_body(self, visitor)
             if (self.parent) self.parent._walk(visitor)
+            if self.class_kwargs:
+                for kw in self.class_kwargs:
+                    kw[1]._walk(visitor)
         )
 
 class AST_Method(AST_Lambda):
@@ -725,7 +731,8 @@ class AST_Except(AST_Block):
     "An `except` node for RapydScript, which resides inside the catch block"
     properties = {
         'argname': "[AST_SymbolCatch] symbol for the exception",
-        'errors': "[AST_SymbolVar*] error classes to catch in this block"
+        'errors': "[AST_SymbolVar*] error classes to catch in this block",
+        'is_star': '[bool] True for except* (exception group) clauses',
     }
 
     def _walk(self, visitor):
@@ -981,6 +988,7 @@ class AST_Binary(AST_Node):
         'operator': "[string] the operator",
         '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_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
@@ -1161,6 +1169,17 @@ class AST_ObjectSpread(AST_Node):
             self.value._walk(visitor)
         )
 
+class AST_Spread(AST_Node):
+    "A *expr spread item inside a list or set literal: [1, *a, 2]"
+    properties = {
+        'expression': "[AST_Node] the expression being spread",
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
 class AST_Set(AST_Node):
     "A set literal"
     properties = {
@@ -1360,6 +1379,80 @@ class TreeWalker:
             self = p
 # }}}
 
+# JSX nodes {{{
+
+class AST_JSXElement(AST_Node):
+    "A JSX element like <div>...</div> or <Component />"
+    properties = {
+        'tag': "[string] The tag name (e.g. 'div', 'MyComponent')",
+        'props': "[AST_JSXAttribute[]] The props/attributes",
+        'children': "[AST_Node[]] The children",
+        'self_closing': "[bool] Whether self-closing (no children)"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            for prop in self.props:
+                prop._walk(visitor)
+            for child in self.children:
+                child._walk(visitor)
+        )
+
+class AST_JSXFragment(AST_Node):
+    "A JSX fragment <>...</>"
+    properties = {
+        'children': "[AST_Node[]] The children"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            for child in self.children:
+                child._walk(visitor)
+        )
+
+class AST_JSXAttribute(AST_Node):
+    "A JSX attribute like prop='val', prop={expr}, or just prop (boolean)"
+    properties = {
+        'name': "[string] The attribute name",
+        'value': "[AST_Node|null] The value (null for boolean attrs)"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            if self.value:
+                self.value._walk(visitor)
+        )
+
+class AST_JSXSpread(AST_Node):
+    "A JSX spread attribute {...expr}"
+    properties = {
+        'expression': "[AST_Node] The spread expression"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
+class AST_JSXText(AST_Node):
+    "Text content inside a JSX element"
+    properties = {
+        'value': "[string] The text content"
+    }
+
+class AST_JSXExprContainer(AST_Node):
+    "A JSX expression container {expr}"
+    properties = {
+        'expression': "[AST_Node] The expression"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
+# }}}
+
 class Found(Exception):
     pass
 

package/src/baselib-builtins.pyj

@@ -20,6 +20,7 @@ def ρσ_bool(val):
     v'if ((typeof Set === "function" && val instanceof Set) || (typeof Map === "function" && val instanceof Map)) return val.size > 0'
     v'if (!val.constructor || val.constructor === Object) return Object.keys(val).length > 0'
     return True
+ρσ_bool.__name__ = 'bool'
 
 def ρσ_print(*args, **kwargs):
     if v'typeof console' is 'object':
@@ -35,6 +36,7 @@ def ρσ_int(val, base):
     if isNaN(ans):
         raise ValueError('Invalid literal for int with base ' + (base or 10) + ': ' + val)
     return ans
+ρσ_int.__name__ = 'int'
 
 def ρσ_float(val):
     if jstype(val) is "number":
@@ -44,6 +46,7 @@ def ρσ_float(val):
     if isNaN(ans):
         raise ValueError('Could not convert string to float: ' + arguments[0])
     return ans
+ρσ_float.__name__ = 'float'
 
 def ρσ_arraylike_creator():
     names = 'Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array'.split(' ')
@@ -282,6 +285,23 @@ def ρσ_hasattr(obj, name):
 def ρσ_get_module(name):
     return ρσ_modules[name]
 
+def ρσ__import__(name, globals, locals, fromlist, level):
+    # Return the module from the already-compiled ρσ_modules registry.
+    # Like Python: without fromlist (or empty fromlist) returns the top-level
+    # package; with a non-empty fromlist returns the named (possibly dotted) module.
+    # NOTE: the module must have been statically imported elsewhere in the source;
+    # __import__ only provides a runtime reference to an already-compiled module.
+    if v'typeof ρσ_modules' is 'undefined':
+        raise ImportError('No module named \'' + name + '\'')
+    if fromlist is not undefined and fromlist is not None and fromlist.length:
+        lookup = name
+    else:
+        lookup = name.split('.')[0]
+    module = ρσ_modules[lookup]
+    if module is undefined:
+        raise ModuleNotFoundError('No module named \'' + lookup + '\'')
+    return module
+
 def ρσ_pow(x, y, z):
     ans = Math.pow(x, y)
     if z is not undefined:
@@ -322,6 +342,7 @@ def ρσ_hash(obj):
         }
         return ρσ_h;
     }'''
+    v'if (obj.__hash__ === null) throw new TypeError("unhashable type: \'" + (obj.constructor && obj.constructor.name ? obj.constructor.name : "object") + "\'")'
     v'if (typeof obj.__hash__ === "function") return obj.__hash__()'
     v'if (Array.isArray(obj)) throw new TypeError("unhashable type: \'list\'")'
     v'if (typeof ρσ_set === "function" && obj instanceof ρσ_set) throw new TypeError("unhashable type: \'set\'")'
@@ -438,12 +459,350 @@ class ρσ_slice:
         raise TypeError("unhashable type: 'slice'")
 
 
-v'var abs = Math.abs, max = ρσ_max.bind(Math.max), min = ρσ_max.bind(Math.min), bool = ρσ_bool, type = ρσ_type'
-v'var float = ρσ_float, int = ρσ_int, arraylike = ρσ_arraylike_creator(), ρσ_arraylike = arraylike'
-v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod'
+class ρσ_object:
+    def __init__(self):
+        pass
+
+    def __repr__(self):
+        v'if (this.ρσ_object_id === undefined) this.ρσ_object_id = ++ρσ_hash_id_counter'
+        return '<object object at 0x' + v'this.ρσ_object_id.toString(16)'+ '>'
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __eq__(self, other):
+        return self is other
+
+    def __hash__(self):
+        v'if (this.ρσ_object_id === undefined) this.ρσ_object_id = ++ρσ_hash_id_counter'
+        return self.ρσ_object_id
+
+ρσ_object.__name__ = 'object'
+
+
+def ρσ_exec(code, globals, locals):
+    # Execute a string of JavaScript/RapydScript-compiled code, like Python's exec.
+    # Always returns None.  Without globals/locals uses indirect eval (global scope).
+    # With globals/locals uses the Function constructor so the code can reference the
+    # supplied variables; mutable object arguments (lists, dicts) are passed by
+    # reference so side-effects (e.g. array.push) are visible in the caller.
+    # Handles both plain JS objects and Python ρσ_dict instances (jsmap-backed Map).
+    # ρσ_ helpers referenced in compiled strings are injected from the current scope.
+    if globals is undefined:
+        v'eval(code)'
+        return None
+    v'''
+    function _ρσ_to_obj(d) {
+        if (d == null) return {};
+        if (typeof ρσ_dict === "function" && d instanceof ρσ_dict) {
+            var _r = {}; d.jsmap.forEach(function(v, k) { _r[k] = v; }); return _r;
+        }
+        return Object.assign({}, d);
+    }
+    var _ctx = _ρσ_to_obj(globals);
+    if (locals !== undefined) Object.assign(_ctx, _ρσ_to_obj(locals));
+    var _rσ_refs = code.match(/ρσ_\w+/g) || [];
+    _rσ_refs.forEach(function(name) {
+        if (!Object.prototype.hasOwnProperty.call(_ctx, name)) {
+            try { var _v = eval(name); if (_v !== undefined) _ctx[name] = _v; } catch(e) {}
+        }
+    });
+    var _keys = Object.keys(_ctx);
+    var _vals = _keys.map(function(k) { return _ctx[k]; });
+    Function.apply(null, _keys.concat([code])).apply(null, _vals);
+    '''
+    return None
+ρσ_exec.__name__ = 'exec'
+
+def ρσ_eval(expr, globals, locals):
+    # Called only when 2 or 3 args are provided (scoped eval via Function constructor).
+    # The compiler emits ρσ_eval() only when globals/locals are supplied; the
+    # plain 1-arg eval(expr) stays as a native direct JS eval call.
+    # Handles both plain JS objects and Python ρσ_dict instances (jsmap-backed Map).
+    # ρσ_ helpers referenced in compiled strings are injected from the current scope.
+    v'''
+    function _ρσ_to_obj(d) {
+        if (d == null) return {};
+        if (typeof ρσ_dict === "function" && d instanceof ρσ_dict) {
+            var _r = {}; d.jsmap.forEach(function(v, k) { _r[k] = v; }); return _r;
+        }
+        return Object.assign({}, d);
+    }
+    var _ctx = (globals !== undefined) ? _ρσ_to_obj(globals) : {};
+    if (locals !== undefined) Object.assign(_ctx, _ρσ_to_obj(locals));
+    var _rσ_refs = expr.match(/ρσ_\w+/g) || [];
+    _rσ_refs.forEach(function(name) {
+        if (!Object.prototype.hasOwnProperty.call(_ctx, name)) {
+            try { var _v = eval(name); if (_v !== undefined) _ctx[name] = _v; } catch(e) {}
+        }
+    });
+    var _keys = Object.keys(_ctx);
+    var _vals = _keys.map(function(k) { return _ctx[k]; });
+    return Function.apply(null, _keys.concat(['return (' + expr + ')'])).apply(null, _vals);
+    '''
+ρσ_eval.__name__ = 'eval'
+
+def ρσ_vars(obj):
+    # vars(obj) -> dict of obj's own instance attributes (like Python's obj.__dict__)
+    # vars()    -> compiler rewrites to vars(this) — see output/functions.pyj
+    v'''
+    var _d;
+    if (typeof ρσ_dict === "function") {
+        _d = new ρσ_dict();
+        if (obj !== undefined && obj !== null) {
+            Object.keys(obj).forEach(function(k) {
+                if (k.charCodeAt(0) !== 0x03c1) { _d.jsmap.set(k, obj[k]); }
+            });
+        }
+    } else {
+        _d = Object.create(null);
+        if (obj !== undefined && obj !== null) {
+            Object.keys(obj).forEach(function(k) {
+                if (k.charCodeAt(0) !== 0x03c1) { _d[k] = obj[k]; }
+            });
+        }
+    }
+    '''
+    return v'_d'
+ρσ_vars.__name__ = 'vars'
+
+def ρσ_locals():
+    # In JavaScript, local scope cannot be introspected at runtime.
+    # Returns an empty dict as an approximation.
+    v'''
+    var _d;
+    if (typeof ρσ_dict === "function") { _d = new ρσ_dict(); } else { _d = Object.create(null); }
+    '''
+    return v'_d'
+ρσ_locals.__name__ = 'locals'
+
+def ρσ_globals():
+    # Returns a snapshot dict of the JS global object's own enumerable properties.
+    # In a browser this covers window.*; in Node.js this covers globalThis/global.*.
+    # Note: module-level RapydScript variables compiled inside an IIFE/module
+    # wrapper will NOT appear here — use a plain dict to share state instead.
+    v'''
+    var _g = (typeof globalThis !== "undefined") ? globalThis : (typeof window !== "undefined" ? window : (typeof global !== "undefined" ? global : {}));
+    var _d;
+    if (typeof ρσ_dict === "function") {
+        _d = new ρσ_dict();
+        Object.getOwnPropertyNames(_g).forEach(function(k) { _d.jsmap.set(k, _g[k]); });
+    } else {
+        _d = Object.create(null);
+        Object.getOwnPropertyNames(_g).forEach(function(k) { _d[k] = _g[k]; });
+    }
+    '''
+    return v'_d'
+ρσ_globals.__name__ = 'globals'
+
+def ρσ_abs(x):
+    if x is not None and jstype(x.__abs__) is 'function':
+        return x.__abs__()
+    return Math.abs(x)
+ρσ_abs.__name__ = 'abs'
+
+class ρσ_complex:
+    def __init__(self, real, imag):
+        nargs = arguments.length
+        if nargs is 0:
+            self.real = 0.0
+            self.imag = 0.0
+        elif nargs >= 2:
+            if jstype(real) is not 'number' and jstype(real) is not 'boolean':
+                raise TypeError("complex() first argument must be a number, not '" + jstype(real) + "'")
+            if jstype(imag) is not 'number' and jstype(imag) is not 'boolean':
+                raise TypeError("complex() second argument must be a number, not '" + jstype(imag) + "'")
+            self.real = +real
+            self.imag = +imag
+        else:
+            x = real
+            if v'x instanceof ρσ_complex':
+                self.real = x.real
+                self.imag = x.imag
+            elif jstype(x) is 'number' or jstype(x) is 'boolean':
+                self.real = +x
+                self.imag = 0.0
+            elif jstype(x) is 'string' or v'x instanceof String':
+                s = String(x).trim()
+                m_mixed = v'/^([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)([+-](?:(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)?)[jJ]$/.exec(s)'
+                m_imag  = v'/^([+-]?(?:(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)?)[jJ]$/.exec(s)'
+                m_real  = v'/^([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)$/.exec(s)'
+                if m_mixed:
+                    self.real = parseFloat(m_mixed[1])
+                    ims = m_mixed[2]
+                    if ims is '+': self.imag = 1.0
+                    elif ims is '-': self.imag = -1.0
+                    else: self.imag = parseFloat(ims)
+                elif m_imag:
+                    self.real = 0.0
+                    ims = m_imag[1]
+                    if not ims or ims is '+': self.imag = 1.0
+                    elif ims is '-': self.imag = -1.0
+                    else: self.imag = parseFloat(ims)
+                elif m_real:
+                    self.real = parseFloat(m_real[1])
+                    self.imag = 0.0
+                else:
+                    raise ValueError("complex() arg is a malformed string")
+            else:
+                raise TypeError("complex() argument must be a string or a number")
+
+    def __add__(self, other):
+        if v'other instanceof ρσ_complex':
+            return new ρσ_complex(self.real + other.real, self.imag + other.imag)
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            return new ρσ_complex(self.real + other, self.imag)
+        raise TypeError("unsupported operand type(s) for +: 'complex' and '" + jstype(other) + "'")
+
+    def __radd__(self, other):
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            return new ρσ_complex(other + self.real, self.imag)
+        if v'other instanceof ρσ_complex':
+            return new ρσ_complex(other.real + self.real, other.imag + self.imag)
+        raise TypeError("unsupported operand type(s) for +: '" + jstype(other) + "' and 'complex'")
+
+    def __sub__(self, other):
+        if v'other instanceof ρσ_complex':
+            return new ρσ_complex(self.real - other.real, self.imag - other.imag)
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            return new ρσ_complex(self.real - other, self.imag)
+        raise TypeError("unsupported operand type(s) for -: 'complex' and '" + jstype(other) + "'")
+
+    def __rsub__(self, other):
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            return new ρσ_complex(other - self.real, -self.imag)
+        if v'other instanceof ρσ_complex':
+            return new ρσ_complex(other.real - self.real, other.imag - self.imag)
+        raise TypeError("unsupported operand type(s) for -: '" + jstype(other) + "' and 'complex'")
+
+    def __mul__(self, other):
+        if v'other instanceof ρσ_complex':
+            return new ρσ_complex(
+                self.real * other.real - self.imag * other.imag,
+                self.real * other.imag + self.imag * other.real
+            )
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            return new ρσ_complex(self.real * other, self.imag * other)
+        raise TypeError("unsupported operand type(s) for *: 'complex' and '" + jstype(other) + "'")
+
+    def __rmul__(self, other):
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            return new ρσ_complex(other * self.real, other * self.imag)
+        if v'other instanceof ρσ_complex':
+            return new ρσ_complex(
+                other.real * self.real - other.imag * self.imag,
+                other.real * self.imag + other.imag * self.real
+            )
+        raise TypeError("unsupported operand type(s) for *: '" + jstype(other) + "' and 'complex'")
+
+    def __truediv__(self, other):
+        if v'other instanceof ρσ_complex':
+            denom = other.real * other.real + other.imag * other.imag
+            if denom is 0: raise ZeroDivisionError('complex division by zero')
+            return new ρσ_complex(
+                (self.real * other.real + self.imag * other.imag) / denom,
+                (self.imag * other.real - self.real * other.imag) / denom
+            )
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            if other is 0: raise ZeroDivisionError('complex division by zero')
+            return new ρσ_complex(self.real / other, self.imag / other)
+        raise TypeError("unsupported operand type(s) for /: 'complex' and '" + jstype(other) + "'")
+
+    def __rtruediv__(self, other):
+        denom = self.real * self.real + self.imag * self.imag
+        if denom is 0: raise ZeroDivisionError('complex division by zero')
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            return new ρσ_complex(other * self.real / denom, -other * self.imag / denom)
+        if v'other instanceof ρσ_complex':
+            return new ρσ_complex(
+                (other.real * self.real + other.imag * self.imag) / denom,
+                (other.imag * self.real - other.real * self.imag) / denom
+            )
+        raise TypeError("unsupported operand type(s) for /: '" + jstype(other) + "' and 'complex'")
+
+    def __pow__(self, other):
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            r = Math.sqrt(self.real * self.real + self.imag * self.imag)
+            if r is 0: return new ρσ_complex(0, 0)
+            theta = Math.atan2(self.imag, self.real)
+            rn = Math.pow(r, other)
+            return new ρσ_complex(rn * Math.cos(other * theta), rn * Math.sin(other * theta))
+        if v'other instanceof ρσ_complex':
+            r = Math.sqrt(self.real * self.real + self.imag * self.imag)
+            if r is 0: return new ρσ_complex(0, 0)
+            theta = Math.atan2(self.imag, self.real)
+            log_r = Math.log(r)
+            c = other.real
+            d = other.imag
+            re_prod = c * log_r - d * theta
+            im_prod = d * log_r + c * theta
+            exp_re = Math.exp(re_prod)
+            return new ρσ_complex(exp_re * Math.cos(im_prod), exp_re * Math.sin(im_prod))
+        raise TypeError("unsupported operand type(s) for **: 'complex' and '" + jstype(other) + "'")
+
+    def __rpow__(self, other):
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            base = new ρσ_complex(other, 0)
+            return base.__pow__(self)
+        if v'other instanceof ρσ_complex':
+            return other.__pow__(self)
+        raise TypeError("unsupported operand type(s) for **: '" + jstype(other) + "' and 'complex'")
+
+    def __neg__(self):
+        return new ρσ_complex(-self.real, -self.imag)
+
+    def __pos__(self):
+        return new ρσ_complex(self.real, self.imag)
+
+    def __abs__(self):
+        return Math.sqrt(self.real * self.real + self.imag * self.imag)
+
+    def __bool__(self):
+        return self.real is not 0 or self.imag is not 0
+
+    def __eq__(self, other):
+        if v'other instanceof ρσ_complex':
+            return self.real is other.real and self.imag is other.imag
+        if jstype(other) is 'number' or jstype(other) is 'boolean':
+            return self.imag is 0 and self.real is other
+        return False
+
+    def __hash__(self):
+        if self.imag is 0:
+            return self.real | 0
+        return v'(self.real * 1000003 ^ self.imag) | 0'
+
+    def conjugate(self):
+        return new ρσ_complex(self.real, -self.imag)
+
+    def __repr__(self):
+        r = self.real
+        i = self.imag
+        if r is 0 and i is 0: return '0j'
+        r_str = String(r)
+        i_str = String(i)
+        if r is 0:
+            return i_str + 'j'
+        if i >= 0 or isNaN(i):
+            return '(' + r_str + '+' + i_str + 'j)'
+        return '(' + r_str + i_str + 'j)'
+
+    def __str__(self):
+        return self.__repr__()
+
+ρσ_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 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'
 v'var range = ρσ_range, getattr = ρσ_getattr, setattr = ρσ_setattr, hasattr = ρσ_hasattr, issubclass = ρσ_issubclass, hash = ρσ_hash, next = ρσ_next'
+v'var exec = ρσ_exec'
+v'var vars = ρσ_vars, locals = ρσ_locals, globals = ρσ_globals'
 v'var ρσ_Ellipsis = Object.freeze({toString: function(){return "Ellipsis";}, __repr__: function(){return "Ellipsis";}})'
 v'var Ellipsis = ρσ_Ellipsis'
 v'var slice = ρσ_slice'
+v'var object = ρσ_object'
+v'Number.prototype.is_integer = function() { return isFinite(+this) && (+this) % 1 === 0; }'
+v'Number.prototype.bit_length = function() { var n = Math.abs(Math.trunc(+this)); if (n === 0) return 0; return Math.floor(Math.log2(n)) + 1; }'