rapydscript-ns 0.9.3 → 0.9.5

package/release/signatures.json

@@ -1,34 +1,34 @@
 {
-    "ast": "1f915bd707f37c2eca90633cbe291b6c030e68a3",
+    "ast": "9c7c4c0132da3d1e4af19a00c1c0387423484a82",
     "baselib-builtins": "1be74e1e78642c5cbf448f8f2a94aae0f1a3d59c",
     "baselib-bytes": "057ab581c276ef03ce91fecdd4213e412198251c",
-    "baselib-containers": "6c480319b9d2ba5d2ee9376e02b67fcd45375912",
-    "baselib-errors": "c7e514d89ad79f2da41fe924f5ad93fc6f2cdf8e",
-    "baselib-internal": "19a95012b2bc1d18c47262ac908a6017e5092f49",
+    "baselib-containers": "b25e5a999657f3195573679b9eb544cba48c52ba",
+    "baselib-errors": "b4c055341bca1943ede820c5d179cfa7e08bb3fe",
+    "baselib-internal": "11fb673a8eef58fad100c43e83ef5274e4b6694e",
     "baselib-itertools": "268b7b7af79506e9a01023e8cd3b1741599bb6a5",
-    "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"
+    "baselib-str": "0183cdb36d8bee149e6bd50f03017e5baa1c49e6",
+    "compiler": "bb16e915c60dc4ffb5bfe98bef411736d19fa297",
+    "errors": "257eca38b6de987e5fd80672bec9b9981847e1bd",
+    "output\\classes": "fd465d02dc11e532be40d3d45d14bf57bc668ed0",
+    "output\\codegen": "aaf15f93f7ab0de23d9076cc5b1a9a415ffe5690",
+    "output\\comments": "63b39620f9d6f407aa2d4ddb557d1c60ef296b05",
+    "output\\exceptions": "e7d9119550403e6c5730d40b9bc9c923a23d6eb7",
+    "output\\functions": "263416b49c60c78abee42fef83ec460e886fb243",
+    "output\\jsx": "14f32c048301965de7764c5b74b651bc279de937",
+    "output\\literals": "287ec4222c79f1ebfa2c6efae925e794cbb931ab",
+    "output\\loops": "1c9bbd6a2772dd2fc287c0b1aebfac7f5426eb27",
+    "output\\modules": "8383da8f58a79921d24e4e0261360a7d0708c4db",
+    "output\\operators": "8f7b1cf4f8a91102fc04104f8a799dcd8849963e",
+    "output\\statements": "94ee0cd084f22aea451b96eb1a9a831084cc4267",
+    "output\\stream": "9bd250ebb7ee43374d69c24357f8c985f95397d4",
+    "output\\treeshake": "4a490ba097739d924db9e3cd9eb7718db5e24cae",
+    "output\\utils": "e957919bfccb9a3ab510d824a8f2ee3fc2689795",
+    "output\\__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+    "parse": "d3f79e2e958219ddea28d483e8b337abd16793f1",
+    "string_interpolation": "88dce6c2c5ee75126a6838a1506841c6531a0d15",
+    "tokenizer": "4a043b2805688a59a21eb99e57567c52ee7b3952",
+    "unicode_aliases": "7fbcbc9c24adcb2e33fac8d69aaafe5047fcc2c2",
+    "utils": "35a2a707c841da851e18c64edac54e7c20b7dfc9",
+    "#compiler#": "a8443467a8034f2a29d201a7264eb0cdbe61ff4e",
+    "#compiled_with#": "a8443467a8034f2a29d201a7264eb0cdbe61ff4e"
 }

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

@@ -605,6 +605,7 @@ class AST_Class(AST_Scope):
         '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], ...]",
+        'slots': "[array|null] list of __slots__ attribute names, null if not defined",
     }
 
     def _walk(self, visitor):
@@ -1280,6 +1281,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-containers.pyj

@@ -93,7 +93,10 @@ def ρσ_list_remove(value):
     raise ValueError(value + ' not in list')
 
 def ρσ_list_to_string():
-    return '[' + this.join(', ') + ']'
+    ans = v'[]'
+    for v'var i = 0; i < this.length; i++':
+        ans.push(ρσ_repr(this[i]))
+    return '[' + ans.join(', ') + ']'
 
 def ρσ_list_insert(index, val):
     if index < 0:
@@ -122,9 +125,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 +148,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++':
@@ -489,7 +514,13 @@ Object.defineProperties(ρσ_set.prototype, {
             r = iterator.next()
 
 ρσ_set.prototype.toString = ρσ_set.prototype.__repr__ = ρσ_set.prototype.__str__ = ρσ_set.prototype.inspect = def():
-    return '{' + list(this).join(', ') + '}'
+    ans = v'[]'
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        ans.push(ρσ_repr(r.value))
+        r = iterator.next()
+    return '{' + ans.join(', ') + '}'
 
 ρσ_set.prototype.__eq__ = def(other):
     if v'!other || !other.jsset':
@@ -631,7 +662,13 @@ Object.defineProperties(ρσ_frozenset.prototype, {
     return ans
 
 ρσ_frozenset.prototype.toString = ρσ_frozenset.prototype.__repr__ = ρσ_frozenset.prototype.__str__ = ρσ_frozenset.prototype.inspect = def():
-    return 'frozenset({' + list(this).join(', ') + '})'
+    ans = v'[]'
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        ans.push(ρσ_repr(r.value))
+        r = iterator.next()
+    return 'frozenset({' + ans.join(', ') + '})'
 
 ρσ_frozenset.prototype.__eq__ = def(other):
     if v'!other || !other.jsset':

package/src/baselib-errors.pyj

@@ -8,8 +8,9 @@ v'var _ρσ_NativeError = Error'
 
 class Exception(Error):
 
-    def __init__(self, message):
-        self.message = message
+    def __init__(self):
+        self.args = v'Array.prototype.slice.call(arguments)'
+        self.message = self.args[0] if self.args.length > 0 else ''
         self.stack = v'_ρσ_NativeError'().stack
         self.name = self.constructor.name
 
@@ -57,7 +58,7 @@ def _is_exc_class(obj):
 class ExceptionGroup(Exception):
 
     def __init__(self, message, exceptions):
-        Exception.__init__(self, message)
+        Exception.__init__(self, message, exceptions)
         self.exceptions = exceptions if exceptions else []
 
     def subgroup(self, condition):

package/src/baselib-internal.pyj

@@ -385,37 +385,49 @@ def ρσ_op_pow(a, 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)
-    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'
+    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'
+    raise TypeError("unsupported operand type(s) for &: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(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)
-    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'
+    ta = jstype(a)
+    tb = jstype(b)
+    if ta is 'object' and tb is 'object' and a is not None and b is not None and not Array.isArray(a) and not Array.isArray(b) and v'a.constructor === Object' and v'b.constructor === Object':
+        return Object.assign({}, a, 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'
+    raise TypeError("unsupported operand type(s) for |: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(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)
-    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'
+    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'
+    raise TypeError("unsupported operand type(s) for ^: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(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)
-    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'
+    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'
+    raise TypeError("unsupported operand type(s) for <<: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(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)
-    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'
+    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'
+    raise TypeError("unsupported operand type(s) for >>: '" + ρσ_arith_type_name(a) + "' and '" + ρσ_arith_type_name(b) + "'")
 
 # Ordered-comparison operator overloading helpers.
 # ρσ_op_lt dispatches __lt__ (forward) then __gt__ (reflected), handles lists
@@ -505,15 +517,22 @@ def ρσ_list_iadd(a, b):
 # Unary operator overloading helpers
 def ρσ_op_neg(a):
     if a is not None and jstype(a.__neg__) is 'function': return a.__neg__()
-    return -a
+    ta = jstype(a)
+    if ta is 'number' or ta is 'boolean' or ta is 'bigint': return -a
+    raise TypeError("bad operand type for unary -: '" + ρσ_arith_type_name(a) + "'")
 
 def ρσ_op_pos(a):
     if a is not None and jstype(a.__pos__) is 'function': return a.__pos__()
-    return +a
+    ta = jstype(a)
+    if ta is 'number' or ta is 'boolean': return +a
+    if ta is 'bigint': return a
+    raise TypeError("bad operand type for unary +: '" + ρσ_arith_type_name(a) + "'")
 
 def ρσ_op_invert(a):
     if a is not None and jstype(a.__invert__) is 'function': return a.__invert__()
-    return ~a
+    ta = jstype(a)
+    if ta is 'number' or ta is 'boolean' or ta is 'bigint': return ~a
+    raise TypeError("bad operand type for unary ~: '" + ρσ_arith_type_name(a) + "'")
 
 # Augmented-assignment helpers: try __i<op>__ first, fall back to binary op
 def ρσ_op_iadd(a, b):
@@ -550,6 +569,11 @@ def ρσ_op_iand(a, b):
 
 def ρσ_op_ior(a, b):
     if a is not None and jstype(a.__ior__) is 'function': return a.__ior__(b)
+    ta = jstype(a)
+    tb = jstype(b)
+    if ta is 'object' and tb is 'object' and a is not None and b is not None and not Array.isArray(a) and not Array.isArray(b) and v'a.constructor === Object' and v'b.constructor === Object':
+        Object.assign(a, b)
+        return a
     return ρσ_op_or(a, b)
 
 def ρσ_op_ixor(a, b):
@@ -766,6 +790,11 @@ v'var ρσ_proxy_target_symbol = typeof Symbol === "function" ? Symbol("ρσ_pro
         if jstype(target.__setattr__) is 'function':
             target.__setattr__.call(receiver, prop, value)
             return True
+        # __slots__ enforcement: check if the class restricts instance attributes.
+        if jstype(prop) is 'string' and prop[0] is not 'ρ':
+            slots = v'target.constructor && target.constructor.prototype.__ρσ_slots__'
+            if slots and not v'slots.hasOwnProperty(prop)':
+                raise AttributeError("'" + (target.constructor.__name__ or 'object') + "' object has no attribute '" + prop + "'")
         # Pass 'target' as receiver (not proxy) to avoid infinite recursion through the Proxy set trap.
         return v'Reflect.set(target, prop, value, target)'
     ,

package/src/baselib-str.pyj

@@ -23,7 +23,7 @@ def ρσ_repr_js_builtin(x, as_array):
         keys = Object.keys(x)
         for v'var k = 0; k < keys.length; k++':
             key = keys[k]
-            ans.push(JSON.stringify(key) + ':' + ρσ_repr(x[key]))
+            ans.push(ρσ_repr(key) + ': ' + ρσ_repr(x[key]))
     return b[0] + ans.join(', ') + b[1]
 
 def ρσ_html_element_to_string(elem):
@@ -49,6 +49,8 @@ def ρσ_repr(x):
         ans = x.__repr__()
     elif x is True or x is False:
         ans = 'True' if x else 'False'
+    elif jstype(x) is 'string':
+        ans = "'" + x.replace("\\", "\\\\").replace("'", "\\'").replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t") + "'"
     elif Array.isArray(x):
         ans = ρσ_repr_js_builtin(x, True)
     elif jstype(x) is 'function':
@@ -111,8 +113,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 ():

package/src/compiler.pyj

@@ -1,36 +1,36 @@
-# vim:fileencoding=utf-8
-# License: BSD
-# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: console
-
-from utils import DefaultsError, string_template
-from errors import ImportError, SyntaxError
-from tokenizer import ALL_KEYWORDS, IDENTIFIER_PAT, tokenizer
-from parse import parse, NATIVE_CLASSES, compile_time_decorators
-from output.stream import OutputStream
-from output.codegen import generate_code
-from output.treeshake import tree_shake
-
-generate_code()  # create the print methods on the AST nodes
-
-# The following allows this module to be used from a pure javascript, require()
-# based environment like Node.js
-if jstype(exports) is 'object':
-    exports.DefaultsError = DefaultsError
-    exports.parse = parse
-    exports.compile_time_decorators = compile_time_decorators
-    exports.OutputStream = OutputStream
-    exports.string_template = string_template  # noqa:undef
-    # Needed for REPL and linter
-    exports.ALL_KEYWORDS = ALL_KEYWORDS
-    exports.IDENTIFIER_PAT = IDENTIFIER_PAT
-    exports.NATIVE_CLASSES = NATIVE_CLASSES
-    exports.ImportError = ImportError
-    exports.SyntaxError = SyntaxError
-    exports.tokenizer = tokenizer
-    exports.tree_shake = tree_shake
-    # Magic! Export all the AST_* nodes
-    ast = ρσ_modules['ast']
-    for ast_node in ast:
-        if ast_node.substr(0, 4) is 'AST_':
-            exports[ast_node] = ast[ast_node]  # noqa:undef
+# vim:fileencoding=utf-8
+# License: BSD
+# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: console
+
+from utils import DefaultsError, string_template
+from errors import ImportError, SyntaxError
+from tokenizer import ALL_KEYWORDS, IDENTIFIER_PAT, tokenizer
+from parse import parse, NATIVE_CLASSES, compile_time_decorators
+from output.stream import OutputStream
+from output.codegen import generate_code
+from output.treeshake import tree_shake
+
+generate_code()  # create the print methods on the AST nodes
+
+# The following allows this module to be used from a pure javascript, require()
+# based environment like Node.js
+if jstype(exports) is 'object':
+    exports.DefaultsError = DefaultsError
+    exports.parse = parse
+    exports.compile_time_decorators = compile_time_decorators
+    exports.OutputStream = OutputStream
+    exports.string_template = string_template  # noqa:undef
+    # Needed for REPL and linter
+    exports.ALL_KEYWORDS = ALL_KEYWORDS
+    exports.IDENTIFIER_PAT = IDENTIFIER_PAT
+    exports.NATIVE_CLASSES = NATIVE_CLASSES
+    exports.ImportError = ImportError
+    exports.SyntaxError = SyntaxError
+    exports.tokenizer = tokenizer
+    exports.tree_shake = tree_shake
+    # Magic! Export all the AST_* nodes
+    ast = ρσ_modules['ast']
+    for ast_node in ast:
+        if ast_node.substr(0, 4) is 'AST_':
+            exports[ast_node] = ast[ast_node]  # noqa:undef

package/src/errors.pyj

@@ -1,30 +1,30 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-from __python__ import hash_literals
-
-class SyntaxError(Error):
-
-    def __init__(self, message, filename, line, col, pos, is_eof):
-        self.stack = Error().stack
-        self.message = message
-        self.line = line
-        self.col = col
-        self.pos = pos
-        self.is_eof = is_eof
-        self.filename = filename
-        # The "standard" form for these error attributes
-        self.lineNumber = line
-        self.fileName = filename
-
-    def toString(self):
-        ans = self.message + " (line: " + self.line + ", col: " + self.col + ", pos: " + self.pos + ")"
-        if self.filename:
-            ans = self.filename + ':' + ans
-        if self.stack:
-            ans += "\n\n" + self.stack
-        return ans
-
-
-class ImportError(SyntaxError):
-    pass
-
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+from __python__ import hash_literals
+
+class SyntaxError(Error):
+
+    def __init__(self, message, filename, line, col, pos, is_eof):
+        self.stack = Error().stack
+        self.message = message
+        self.line = line
+        self.col = col
+        self.pos = pos
+        self.is_eof = is_eof
+        self.filename = filename
+        # The "standard" form for these error attributes
+        self.lineNumber = line
+        self.fileName = filename
+
+    def toString(self):
+        ans = self.message + " (line: " + self.line + ", col: " + self.col + ", pos: " + self.pos + ")"
+        if self.filename:
+            ans = self.filename + ':' + ans
+        if self.stack:
+            ans += "\n\n" + self.stack
+        return ans
+
+
+class ImportError(SyntaxError):
+    pass
+