rapydscript-ns 0.8.4 → 0.9.0

package/release/signatures.json

@@ -1,33 +1,34 @@
 {
-    "ast": "c8f6f1be6f7f73b1b9e2bbf470f5e2e5fff879df",
-    "baselib-builtins": "ced189b19392b1f425a1a180b90bc61e5e1b022f",
+    "ast": "88027aa403dfe55fcf8d475115897d141717d17c",
+    "baselib-builtins": "284e14536cfdd0b497abeb6f110ae49a20f2a172",
+    "baselib-bytes": "057ab581c276ef03ce91fecdd4213e412198251c",
     "baselib-containers": "d2f534e6530dfb309b074bf7fac082c65779e778",
-    "baselib-errors": "a9e8c63e450360fd0bd70642d4c107672d395ccf",
-    "baselib-internal": "b020b5154a7ee023ceb5852bf35eeee31e285d87",
-    "baselib-itertools": "425f5c45bbd5de894cae891e71ba1a9e9e2063d5",
-    "baselib-str": "a00bdd267521d31d97cdc76581f955b6fafb4bae",
-    "compiler": "bb16e915c60dc4ffb5bfe98bef411736d19fa297",
-    "errors": "257eca38b6de987e5fd80672bec9b9981847e1bd",
-    "output\\classes": "a88c3c84ded9049d7a5052fb151d51bdbb600dcd",
-    "output\\codegen": "69151b2cd53ff8b3270a122c65e1a0f56735150e",
-    "output\\comments": "63b39620f9d6f407aa2d4ddb557d1c60ef296b05",
-    "output\\exceptions": "e7d9119550403e6c5730d40b9bc9c923a23d6eb7",
-    "output\\functions": "58972ccc4562ab3422317f79f68ea3e00b765279",
-    "output\\jsx": "14f32c048301965de7764c5b74b651bc279de937",
-    "output\\literals": "287ec4222c79f1ebfa2c6efae925e794cbb931ab",
-    "output\\loops": "93afeea09e81382edf1c2f6009f4811430d0ebb8",
-    "output\\modules": "15735b9b07260d11ba231fc3439818bd1a54947e",
-    "output\\operators": "d9ebb70a00cfe6be60c5d75596edf7986f619644",
-    "output\\statements": "94ee0cd084f22aea451b96eb1a9a831084cc4267",
-    "output\\stream": "2723d80bc398468e0828f50fb0837095c52f45dc",
-    "output\\treeshake": "4a490ba097739d924db9e3cd9eb7718db5e24cae",
-    "output\\utils": "e957919bfccb9a3ab510d824a8f2ee3fc2689795",
-    "output\\__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-    "parse": "1815f278b2b974ed79973f792a4dbcccfb35c2b8",
-    "string_interpolation": "88dce6c2c5ee75126a6838a1506841c6531a0d15",
-    "tokenizer": "6c06a87951cc4cfe6256dfa4f22ab3533967e856",
-    "unicode_aliases": "7fbcbc9c24adcb2e33fac8d69aaafe5047fcc2c2",
-    "utils": "35a2a707c841da851e18c64edac54e7c20b7dfc9",
-    "#compiler#": "724970153770773cd9e1ff1e588f17df9c607ee9",
-    "#compiled_with#": "724970153770773cd9e1ff1e588f17df9c607ee9"
+    "baselib-errors": "8efbb59deb88ede0995768f63f57103f2f0fd02d",
+    "baselib-internal": "bb1eff32c1c50d5d25ea3074a968e765a136108c",
+    "baselib-itertools": "268b7b7af79506e9a01023e8cd3b1741599bb6a5",
+    "baselib-str": "0e8d1ee658690412140cc138adf9681425de5084",
+    "compiler": "4c728d81b441b4b9c590f9330271f54b47cc11eb",
+    "errors": "d1b33848d19b141e19cc079cf78421f29b6d2c05",
+    "output/__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+    "output/classes": "469c47511692e04eb1bc2b079af3f65b47165865",
+    "output/codegen": "69151b2cd53ff8b3270a122c65e1a0f56735150e",
+    "output/comments": "78ec38d8b34da96c078653e2d0d4049d7003906b",
+    "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": "0643834ed3c98d350ceb9ec71179f8923974c08c",
+    "string_interpolation": "bff1cc76d772d24d35707f6c794f38734ca08376",
+    "tokenizer": "134f46d5a10576c6a27d4fe024c63f45e111fefe",
+    "unicode_aliases": "79ac6eaa5e6be44a5397d62c561f854a8fe7528e",
+    "utils": "c1666db819aa7c8db38697e34e18362e3cb45869",
+    "#compiler#": "d41c267ea92de4937495c7d35c8d50e1b48f550c",
+    "#compiled_with#": "d41c267ea92de4937495c7d35c8d50e1b48f550c"
 }

package/session.vim

@@ -1,4 +1,4 @@
-set wildignore+=*.pyj-cached
-set wildignore+=node_modules
-imap <F4> ρσ_
-cmap <F4> ρσ_
+set wildignore+=*.pyj-cached
+set wildignore+=node_modules
+imap <F4> ρσ_
+cmap <F4> ρσ_

package/setup.cfg

@@ -1,2 +1,2 @@
-[rapydscript]
-globals=assert,RapydScript
+[rapydscript]
+globals=assert,RapydScript

package/src/ast.pyj

@@ -988,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)"
     }
 

package/src/baselib-builtins.pyj

@@ -459,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'
+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; }'