rapydscript-ng 0.8.0 → 0.8.2

package/src/baselib-builtins.pyj

@@ -4,9 +4,11 @@
 
 # globals: exports, console, ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_list_contains
 
+
 def ρσ_bool(val):
     return v'!!val'
 
+
 def ρσ_print():
     if v'typeof console' is 'object':
         parts = v'[]'
@@ -14,8 +16,9 @@ def ρσ_print():
             parts.push(ρσ_str(v'arguments[i]'))  # noqa: undef
         console.log(parts.join(' '))
 
+
 def ρσ_int(val, base):
-    if jstype(val) is "number":
+    if jstype(val) is 'number':
         ans = val | 0
     else:
         ans = parseInt(val, base or 10)
@@ -23,8 +26,9 @@ def ρσ_int(val, base):
         raise ValueError('Invalid literal for int with base ' + (base or 10) + ': ' + val)
     return ans
 
+
 def ρσ_float(val):
-    if jstype(val) is "number":
+    if jstype(val) is 'number':
         ans = val
     else:
         ans = parseFloat(val)
@@ -32,24 +36,28 @@ def ρσ_float(val):
         raise ValueError('Could not convert string to float: ' + arguments[0])
     return ans
 
+
 def ρσ_arraylike_creator():
     names = 'Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array'.split(' ')
     if jstype(HTMLCollection) is 'function':
         names = names.concat('HTMLCollection NodeList NamedNodeMap TouchList'.split(' '))
-    return def(x):
+    return def (x):
         if Array.isArray(x) or v'typeof x' is 'string' or names.indexOf(Object.prototype.toString.call(x).slice(8, -1)) > -1:
             return True
         return False
 
+
 def options_object(f):
-    return def():
+    return def ():
         if v'typeof arguments[arguments.length - 1] === "object"':
             arguments[arguments.length - 1][ρσ_kwargs_symbol] = True
         return f.apply(this, arguments)
 
+
 def ρσ_id(x):
     return x.ρσ_object_id
 
+
 def ρσ_dir(item):
     # TODO: this isn't really representative of real Python's dir(), nor is it
     # an intuitive replacement for "for ... in" loop, need to update this logic
@@ -58,6 +66,7 @@ def ρσ_dir(item):
     for v'var i in item': arr.push(i)  # noqa:undef
     return arr
 
+
 def ρσ_ord(x):
     ans = x.charCodeAt(0)
     if 0xD800 <= ans <= 0xDBFF:
@@ -67,15 +76,18 @@ def ρσ_ord(x):
         raise TypeError('string is missing the low surrogate char')
     return ans
 
+
 def ρσ_chr(code):
     if code <= 0xFFFF:
         return String.fromCharCode(code)
     code -= 0x10000
-    return String.fromCharCode(0xD800+(code>>10), 0xDC00+(code&0x3FF))
+    return String.fromCharCode(0xD800 + (code >> 10), 0xDC00 + (code & 0x3FF))
+
 
 def ρσ_callable(x):
     return v'typeof x === "function"'
 
+
 def ρσ_bin(x):
     if jstype(x) is not 'number' or x % 1 is not 0:
         raise TypeError('integer required')
@@ -86,6 +98,7 @@ def ρσ_bin(x):
         ans = '0b' + ans
     return ans
 
+
 def ρσ_hex(x):
     if jstype(x) is not 'number' or x % 1 is not 0:
         raise TypeError('integer required')
@@ -96,21 +109,22 @@ def ρσ_hex(x):
         ans = '0x' + ans
     return ans
 
+
 def ρσ_enumerate(iterable):
     ans = v'{"_i":-1}'
-    ans[ρσ_iterator_symbol] = def():
+    ans[ρσ_iterator_symbol] = def ():
         return this
     if ρσ_arraylike(iterable):
-        ans['next'] = def():
-                this._i += 1
-                if this._i < iterable.length:
-                    return v"{'done':false, 'value':[this._i, iterable[this._i]]}"
-                return v"{'done':true}"
+        ans['next'] = def ():
+            this._i += 1
+            if this._i < iterable.length:
+                return v"{'done':false, 'value':[this._i, iterable[this._i]]}"
+            return v"{'done':true}"
         return ans
     if jstype(iterable[ρσ_iterator_symbol]) is 'function':
         iterator = iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
         ans['_iterator'] = iterator
-        ans['next'] = def():
+        ans['next'] = def ():
             r = this._iterator.next()
             if r.done:
                 return v"{'done':true}"
@@ -119,28 +133,30 @@ def ρσ_enumerate(iterable):
         return ans
     return ρσ_enumerate(Object.keys(iterable))
 
+
 def ρσ_reversed(iterable):
     if ρσ_arraylike(iterable):
         ans = v'{"_i": iterable.length}'
-        ans['next'] = def():
+        ans['next'] = def ():
             this._i -= 1
             if this._i > -1:
                 return v"{'done':false, 'value':iterable[this._i]}"
             return v"{'done':true}"
-        ans[ρσ_iterator_symbol] = def():
+        ans[ρσ_iterator_symbol] = def ():
             return this
         return ans
     raise TypeError('reversed() can only be called on arrays or strings')
 
+
 def ρσ_iter(iterable):
     # Generate a JavaScript iterator object from iterable
     if jstype(iterable[ρσ_iterator_symbol]) is 'function':
         return iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
     if ρσ_arraylike(iterable):
         ans = v'{"_i":-1}'
-        ans[ρσ_iterator_symbol] = def():
+        ans[ρσ_iterator_symbol] = def ():
             return this
-        ans['next'] = def():
+        ans['next'] = def ():
             this._i += 1
             if this._i < iterable.length:
                 return v"{'done':false, 'value':iterable[this._i]}"
@@ -148,6 +164,7 @@ def ρσ_iter(iterable):
         return ans
     return ρσ_iter(Object.keys(iterable))
 
+
 def ρσ_range_next(step, length):
     this._i += step
     this._idx += 1
@@ -156,6 +173,7 @@ def ρσ_range_next(step, length):
         return v"{'done':true}"
     return v"{'done':false, 'value':this._i}"
 
+
 def ρσ_range(start, stop, step):
     if arguments.length <= 1:
         stop = start or 0
@@ -163,28 +181,28 @@ def ρσ_range(start, stop, step):
     step = arguments[2] or 1
     length = Math.max(Math.ceil((stop - start) / step), 0)
     ans = v'{start:start, step:step, stop:stop}'
-    ans[ρσ_iterator_symbol] = def():
+    ans[ρσ_iterator_symbol] = def ():
         it = v'{"_i": start - step, "_idx": -1}'
         it.next = ρσ_range_next.bind(it, step, length)
-        it[ρσ_iterator_symbol] = def():
+        it[ρσ_iterator_symbol] = def ():
             return this
         return it
-    ans.count = def(val):
+    ans.count = def (val):
         if not this._cached:
             this._cached = list(this)
         return this._cached.count(val)
-    ans.index = def(val):
+    ans.index = def (val):
         if not this._cached:
             this._cached = list(this)
         return this._cached.index(val)
-    ans.__len__ = def():
+    ans.__len__ = def ():
         return length
-    ans.__repr__ = def():
+    ans.__repr__ = def ():
         return f'range({start}, {stop}, {step})'
     ans.__str__ = ans.toString = ans.__repr__
     if jstype(Proxy) is 'function':
         ans = new Proxy(ans, {
-            'get': def(obj, prop):
+            'get': def (obj, prop):
                 if jstype(prop) is 'string':
                     iprop = parseInt(prop)
                     if not isNaN(iprop):
@@ -197,6 +215,7 @@ def ρσ_range(start, stop, step):
         })
     return ans
 
+
 def ρσ_getattr(obj, name, defval):
     try:
         ret = obj[name]
@@ -210,37 +229,39 @@ def ρσ_getattr(obj, name, defval):
         ret = defval
     return ret
 
+
 def ρσ_setattr(obj, name, value):
     obj[name] = value
 
+
 def ρσ_hasattr(obj, name):
     return v'name in obj'
 
 ρσ_len = (def ():
-
     def len(obj):
         if ρσ_arraylike(obj): return obj.length
         if jstype(obj.__len__) is 'function': return obj.__len__()
         if v'obj instanceof Set' or v'obj instanceof Map': return obj.size
         return Object.keys(obj).length
-
     def len5(obj):
         if ρσ_arraylike(obj): return obj.length
         if jstype(obj.__len__) is 'function': return obj.__len__()
         return Object.keys(obj).length
-
     return len if v'typeof Set' is 'function' and v'typeof Map' is 'function' else len5
 )()
 
+
 def ρσ_get_module(name):
     return ρσ_modules[name]
 
+
 def ρσ_pow(x, y, z):
     ans = Math.pow(x, y)
     if z is not undefined:
         ans %= z
     return ans
 
+
 def ρσ_type(x):
     return x.constructor