rapydscript-ns 0.9.2 → 0.9.4

package/src/monaco-language-service/diagnostics.js

@@ -20,15 +20,20 @@ const MESSAGES = {
     'def-after-use':  'The symbol "{name}" is defined (at line {line}) after it is used',
     'dup-key':        'Duplicate key "{name}" in object literal',
     'dup-method':     'The method "{name}" was defined previously at line: {line}',
+    'infinite-loop':  'This while loop may never exit (condition is always true and there is no await in the body)',
+    // type_enforcement diagnostics
+    'type-posonly-kwarg':   '"{name}" is positional-only and cannot be passed as a keyword argument to {func}()',
+    'type-too-many-args':   '{func}() takes at most {max} positional argument{plural} but {got} were given',
+    'type-missing-kwonly':  '"{name}" is a required keyword-only argument of {func}() and must be passed by name',
 };
 
 // Built-in stdlib modules that are always available in RapydScript (bundled
 // with the compiler from src/lib/).  These should never produce 'Unknown module'
 // errors regardless of what virtualFiles or stdlibFiles are configured.
 export const STDLIB_MODULES = [
-    'abc', 'aes', 'collections', 'contextlib', 'copy', 'dataclasses', 'datetime', 'elementmaker', 'encodings', 'enum',
-    'functools', 'gettext', 'io', 'itertools', 'json', 'math', 'numpy', 'operator',
-    'pythonize', 'random', 're', 'react', 'traceback', 'typing', 'uuid',
+    'abc', 'aes', 'asyncio', 'base64', 'bisect', 'collections', 'contextlib', 'copy', 'csv', 'dataclasses', 'datetime', 'elementmaker', 'encodings', 'enum',
+    'functools', 'gettext', 'heapq', 'html', 'http', 'io', 'itertools', 'json', 'logging', 'math', 'numpy', 'operator',
+    'pprint', 'pythonize', 'random', 're', 'react', 'statistics', 'string', 'textwrap', 'traceback', 'typing', 'urllib', 'uuid',
     // Pseudo-modules for language feature flags (from __python__ import ...)
     '__python__', '__builtins__',
 ];
@@ -48,7 +53,7 @@ export const BASE_BUILTINS = (
     ' NodeList alert console Node Symbol NamedNodeMap ρσ_eslice ρσ_delslice Number' +
     ' Boolean encodeURIComponent decodeURIComponent setTimeout setInterval' +
     ' setImmediate clearTimeout clearInterval clearImmediate requestAnimationFrame' +
-    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis slice all any next __import__ ρσ_new ρσ_object_new hash ρσ_object_setattr ρσ_object_getattr ρσ_object_delattr ExceptionGroup BaseExceptionGroup tuple bytes bytearray format object vars locals globals'
+    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis slice all any next __import__ ρσ_new ρσ_object_new hash ρσ_object_setattr ρσ_object_getattr ρσ_object_delattr ExceptionGroup BaseExceptionGroup tuple bytes bytearray format object vars locals globals type'
 ).split(' ');
 
 // ---------------------------------------------------------------------------
@@ -497,6 +502,42 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
         if (node.alias) this.add_binding(node.alias.name);
     };
 
+    this.handle_while = function() {
+        const node = this.current_node;
+        const cond = node.condition;
+        const RS   = this.RS;
+
+        const is_trivially_true = (
+            (cond instanceof RS.AST_True) ||
+            (cond instanceof RS.AST_Number && cond.value !== 0)
+        );
+        if (!is_trivially_true) return;
+
+        let has_await = false;
+        const await_finder = {
+            _visit: function(n, cont) {
+                if (n instanceof RS.AST_Await) { has_await = true; return; }
+                if (cont) cont();
+            }
+        };
+        if (node.body) node.body._walk(await_finder);
+
+        if (!has_await) {
+            const sline = node.start ? node.start.line : 1;
+            const scol  = node.start ? node.start.col  : 0;
+            const eline = (node.condition && node.condition.end) ? node.condition.end.line : sline;
+            const ecol  = (node.condition && node.condition.end) ? node.condition.end.col  : scol;
+            this.messages.push({
+                start_line: sline, start_col: scol,
+                end_line:   eline, end_col:   ecol,
+                ident:   'infinite-loop',
+                message: MESSAGES['infinite-loop'],
+                level:   WARN,
+                name:    '',
+            });
+        }
+    };
+
     // The visitor function called by toplevel.walk()
     this._visit = function(node, cont) {
         if (node.lint_visited) return;
@@ -530,6 +571,7 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
         else if (node instanceof RS.AST_EmptyStatement)  this.handle_empty_statement();
         else if (node instanceof RS.AST_WithClause)      this.handle_with_clause();
         else if (node instanceof RS.AST_Object)          this.handle_object_literal();
+        else if (node instanceof RS.AST_While)           this.handle_while();
 
         if (node instanceof RS.AST_Scope) this.handle_scope();
 
@@ -580,6 +622,143 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
     };
 }
 
+// ---------------------------------------------------------------------------
+// Type-enforcement static checker
+// Runs a two-pass walk when any function in the file has type_enforce=true:
+//   Pass 1 — collect signatures of enforced functions.
+//   Pass 2 — inspect call sites and report violations.
+// ---------------------------------------------------------------------------
+
+function check_type_enforcement(RS, toplevel, messages) {
+    // Pass 1: collect signatures of functions compiled with type_enforce=true
+    const sigs = Object.create(null);
+
+    const col1 = {
+        _visit: function(node, cont) {
+            if (node instanceof RS.AST_Lambda && node.type_enforce && node.name) {
+                const a    = node.argnames;
+                const is_m = node instanceof RS.AST_Method;
+                const off  = (is_m && !node.static) ? 1 : 0;
+                const posonly_names = [];
+                const kwonly_req    = [];
+                let max_pos = 0;
+                const defs = (a.defaults) || {};
+                for (let i = off; i < a.length; i++) {
+                    const arg = a[i];
+                    if (arg.posonly) posonly_names.push(arg.name);
+                    if (arg.kwonly) {
+                        if (!has_prop(defs, arg.name)) kwonly_req.push(arg.name);
+                        continue;
+                    }
+                    max_pos++;
+                }
+                sigs[node.name.name] = {
+                    node,
+                    posonly_names,
+                    kwonly_req,
+                    max_pos,
+                    has_starargs: !!a.starargs,
+                    has_kwargs:   !!a.kwargs,
+                };
+            }
+            if (cont) cont();
+        }
+    };
+    toplevel.walk(col1);
+
+    if (Object.keys(sigs).length === 0) return;
+
+    // Pass 2: check call sites
+    const col2 = {
+        _visit: function(node, cont) {
+            if (node instanceof RS.AST_BaseCall) {
+                let fname = null;
+                const expr = node.expression;
+                if (expr instanceof RS.AST_SymbolRef) fname = expr.name;
+                else if (expr instanceof RS.AST_Dot)  fname = expr.property;
+
+                if (fname && has_prop(sigs, fname)) {
+                    const sig         = sigs[fname];
+                    const args        = node.args;
+                    const pos_count   = args ? args.length : 0;
+                    const named_kw    = (args && args.kwargs) ? args.kwargs : [];
+                    const kw_expand   = args && args.kwarg_items && args.kwarg_items.length > 0;
+
+                    // Positional-only args passed as named kwargs
+                    sig.posonly_names.forEach(argname => {
+                        for (let ki = 0; ki < named_kw.length; ki++) {
+                            const knode = named_kw[ki][0];
+                            const kname = knode.name || (knode.value !== undefined ? String(knode.value) : null);
+                            if (kname === argname) {
+                                const msg = MESSAGES['type-posonly-kwarg']
+                                    .replace('{name}', argname)
+                                    .replace('{func}', fname);
+                                messages.push({
+                                    ident:      'type-posonly-kwarg',
+                                    message:    msg,
+                                    level:      ERROR,
+                                    name:       argname,
+                                    start_line: knode.start ? knode.start.line : 1,
+                                    start_col:  knode.start ? knode.start.col  : 0,
+                                    end_line:   knode.end   ? knode.end.line   : undefined,
+                                    end_col:    knode.end   ? knode.end.col    : undefined,
+                                });
+                            }
+                        }
+                    });
+
+                    // Too many positional args (skip when *args or **expansion present)
+                    if (!sig.has_starargs && !kw_expand && pos_count > sig.max_pos) {
+                        const plural = sig.max_pos === 1 ? '' : 's';
+                        const msg = MESSAGES['type-too-many-args']
+                            .replace('{func}', fname)
+                            .replace('{max}',  String(sig.max_pos))
+                            .replace('{plural}', plural)
+                            .replace('{got}',  String(pos_count));
+                        messages.push({
+                            ident:      'type-too-many-args',
+                            message:    msg,
+                            level:      ERROR,
+                            name:       fname,
+                            start_line: node.start ? node.start.line : 1,
+                            start_col:  node.start ? node.start.col  : 0,
+                            end_line:   node.end   ? node.end.line   : undefined,
+                            end_col:    node.end   ? node.end.col    : undefined,
+                        });
+                    }
+
+                    // Required keyword-only args not provided (skip when **expansion present)
+                    if (!kw_expand) {
+                        sig.kwonly_req.forEach(argname => {
+                            const provided = named_kw.some(pair => {
+                                const kn = pair[0].name || (pair[0].value !== undefined ? String(pair[0].value) : null);
+                                return kn === argname;
+                            });
+                            if (!provided) {
+                                const msg = MESSAGES['type-missing-kwonly']
+                                    .replace('{name}', argname)
+                                    .replace('{func}', fname);
+                                messages.push({
+                                    ident:      'type-missing-kwonly',
+                                    message:    msg,
+                                    level:      ERROR,
+                                    name:       argname,
+                                    start_line: node.start ? node.start.line : 1,
+                                    start_col:  node.start ? node.start.col  : 0,
+                                    end_line:   node.end   ? node.end.line   : undefined,
+                                    end_col:    node.end   ? node.end.col    : undefined,
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+            if (cont) cont();
+        }
+    };
+    toplevel.walk(col2);
+}
+
 // ---------------------------------------------------------------------------
 // Convert lint message → Monaco IMarkerData
 // markerSeverity should be { Error, Warning, Info, Hint } numeric values
@@ -709,6 +888,26 @@ export class Diagnostics {
         toplevel.walk(linter);
         messages = linter.resolve(noqa);
 
+        // --- Type enforcement static checks ---
+        // Run when type_enforcement is active at the file level (either via
+        // pythonFlags constructor arg or from __python__ import type_enforcement).
+        const te_active =
+            (this._scoped_flags && this._scoped_flags.type_enforcement) ||
+            (toplevel.scoped_flags && toplevel.scoped_flags.type_enforcement);
+        if (te_active) {
+            const te_messages = [];
+            check_type_enforcement(RS, toplevel, te_messages);
+            // Filter noqa, then convert to markers inline
+            te_messages.forEach(m => {
+                if (noqa && has_prop(noqa, m.ident)) return;
+                messages.push(m);
+            });
+            messages.sort((a, b) => {
+                const dl = (a.start_line || 0) - (b.start_line || 0);
+                return dl !== 0 ? dl : (a.start_col || 0) - (b.start_col || 0);
+            });
+        }
+
         return messages.map(m => to_marker(m, markerSeverity));
     }
 }

package/src/monaco-language-service/scope.js

@@ -33,6 +33,7 @@ export class SymbolInfo {
         this.return_type    = opts.return_type   || null;  // annotated return type, e.g. 'list', 'str', 'MyClass'
         this.source_module  = opts.source_module || null;  // module name when kind='import' (from X import Y)
         this.original_name  = opts.original_name || null;  // pre-alias name for imports (from X import Y as Z → 'Y')
+        this.is_bare_import = opts.is_bare_import || false; // true for `import X` (vs `from X import Y`)
     }
 }
 

package/src/output/codegen.pyj

@@ -7,7 +7,7 @@ from __python__ import hash_literals
 from utils import noop
 from parse import PRECEDENCE
 from ast import (
-    AST_Array, AST_Assign, AST_BaseCall, AST_Binary, AST_BlockStatement, AST_Break,
+    AST_Array, AST_Assign, AST_BaseCall, AST_BigInt, AST_Binary, AST_BlockStatement, AST_Break,
     AST_Class, AST_Conditional, AST_Constant, AST_Continue,
     AST_Debugger, AST_Definitions, AST_Directive, AST_Do, AST_Dot, is_node_type,
     AST_EmptyStatement, AST_Exit, AST_ExpressiveObject, AST_ForIn,
@@ -530,6 +530,9 @@ def generate_code():
     DEFPRINT(AST_Number, def(self, output):
         output.print(make_num(self.value))
     )
+    DEFPRINT(AST_BigInt, def(self, output):
+        output.print(self.value + "n")
+    )
     DEFPRINT(AST_RegExp, print_regexp)
 
     # -----[ JSX ]-----

package/src/output/functions.pyj

@@ -45,11 +45,69 @@ def function_args(argnames, output, strip_first):
 
 def function_preamble(node, output, offset):
     a = node.argnames
-    if a is None or a is undefined or a.is_simple_func:
+    if a is None or a is undefined:
+        return
+    type_enforce = node.type_enforce
+    if a.is_simple_func and not type_enforce:
         return
     # If this function has optional parameters/*args/**kwargs declare it differently
     fname = node.name.name if node.name else anonfunc
     kw = 'arguments[arguments.length-1]'
+
+    # === Type enforcement: max positional-arg count check ===
+    if type_enforce:
+        max_pos = 0
+        for c, arg in enumerate(a):
+            if c >= offset and not arg.kwonly:
+                max_pos += 1
+        if a.is_simple_func:
+            # Simple function: named JS params; arguments.length gives true count
+            if not a.starargs:
+                # Strip a trailing kwargs-marker object so a `*args, **kwargs`
+                # caller does not get blamed for an extra positional argument
+                # (matches the complex-func variant below).
+                output.indent()
+                output.spaced('var', 'ρσ_nargs', '=', 'arguments.length')
+                output.end_statement()
+                output.indent()
+                output.print('if (ρσ_nargs > 0 && arguments[ρσ_nargs-1] !== null && typeof arguments[ρσ_nargs-1] === "object" && arguments[ρσ_nargs-1][ρσ_kwargs_symbol] === true) ρσ_nargs--')
+                output.end_statement()
+                max_msg = fname + '() takes ' + max_pos + ' positional argument' + ('' if max_pos == 1 else 's') + ' but '
+                output.indent()
+                output.print('if (ρσ_nargs > ' + max_pos + ') throw new TypeError(' + JSON.stringify(max_msg) + ' + ρσ_nargs + " were given")')
+                output.end_statement()
+            # Required-arg and type-annotation checks (variables are direct JS params)
+            for c, arg in enumerate(a):
+                if c < offset:
+                    continue
+                if not arg.kwonly:
+                    miss_msg = fname + '() missing required positional argument: \'' + arg.name + '\''
+                    output.indent()
+                    output.print('if (' + arg.name + ' === undefined) throw new TypeError(' + JSON.stringify(miss_msg) + ')')
+                    output.end_statement()
+                if arg.annotation:
+                    annot_name = arg.annotation.name or ''
+                    type_msg = fname + '() argument \'' + arg.name + '\' must be ' + annot_name
+                    output.indent()
+                    output.print('if (' + arg.name + ' !== undefined && !ρσ_instanceof(' + arg.name + ', ')
+                    arg.annotation.print(output)
+                    output.print(')) throw new TypeError(' + JSON.stringify(type_msg) + ')')
+                    output.end_statement()
+            return  # simple func: only enforcement, no complex preamble
+
+        # Complex function: must handle arguments object; strip trailing kwargs marker
+        if not a.starargs:
+            output.indent()
+            output.spaced('var', 'ρσ_nargs', '=', 'arguments.length')
+            output.end_statement()
+            output.indent()
+            output.print('if (ρσ_nargs > 0 && arguments[ρσ_nargs-1] !== null && typeof arguments[ρσ_nargs-1] === "object" && arguments[ρσ_nargs-1][ρσ_kwargs_symbol] === true) ρσ_nargs--')
+            output.end_statement()
+            max_msg = fname + '() takes ' + max_pos + ' positional argument' + ('' if max_pos == 1 else 's') + ' but '
+            output.indent()
+            output.print('if (ρσ_nargs > ' + max_pos + ') throw new TypeError(' + JSON.stringify(max_msg) + ' + ρσ_nargs + " were given")')
+            output.end_statement()
+
     # Define all formal parameters
     positional_count = 0
     for c, arg in enumerate(a):
@@ -89,6 +147,22 @@ def function_preamble(node, output, offset):
         output.indent()
         output.spaced('if', '(' + kw, '===', 'null', '||', 'typeof', kw, '!==', '"object"', '||', kw, '[ρσ_kwargs_symbol]', '!==', 'true)', kw, '=', '{}')
         output.end_statement()
+        # === Type enforcement: positional-only args must not appear in kwargs ===
+        if type_enforce:
+            posonly_count = a.posonly_count or 0
+            for pi in range(posonly_count):
+                if pi < offset:
+                    continue
+                parg = a[pi]
+                posonly_msg = fname + '() got some positional-only arguments passed as keyword arguments: \'' + parg.name + '\''
+                output.indent()
+                output.spaced('if', '(Object.prototype.hasOwnProperty.call(' + kw + ',', '"' + parg.name + '"))')
+                output.with_block(def():
+                    output.indent()
+                    output.print('throw new TypeError(' + JSON.stringify(posonly_msg) + ')')
+                    output.end_statement()
+                )
+                output.newline()
         # Read values from the kwargs object for non-positional-only formal parameters with defaults
         if a.has_defaults:
             for dname in Object.keys(a.defaults):
@@ -138,6 +212,29 @@ def function_preamble(node, output, offset):
                         output.end_statement()
                 )
                 output.newline()
+    elif type_enforce and (a.posonly_count or 0) > 0:
+        # No kwargs block, but function has positional-only params.
+        # A caller using foo(posonly_name=val) still passes a kwargs object as the
+        # last argument; detect and reject it here.
+        posonly_count = a.posonly_count or 0
+        posonly_names = []
+        for pi in range(posonly_count):
+            if pi >= offset:
+                posonly_names.push(a[pi].name)
+        if posonly_names.length > 0:
+            output.indent()
+            output.spaced('var', 'ρσ_kw_chk', '=', 'arguments[arguments.length-1]')
+            output.end_statement()
+            output.indent()
+            output.spaced('if', '(ρσ_kw_chk !== null && typeof ρσ_kw_chk === "object" && ρσ_kw_chk[ρσ_kwargs_symbol] === true)')
+            output.with_block(def():
+                for pname in posonly_names:
+                    posonly_msg = fname + '() got some positional-only arguments passed as keyword arguments: \'' + pname + '\''
+                    output.indent()
+                    output.print('if (Object.prototype.hasOwnProperty.call(ρσ_kw_chk, "' + pname + '")) throw new TypeError(' + JSON.stringify(posonly_msg) + ')')
+                    output.end_statement()
+            )
+            output.newline()
 
     if a.starargs is not undefined:
         # Define the *args parameter, putting in whatever is left after assigning the formal parameters and the options object
@@ -160,6 +257,44 @@ def function_preamble(node, output, offset):
         output.spaced(kw, '=', 'ρσ_kwargs_to_dict(' + kw + ')')
         output.end_statement()
 
+    # === Type enforcement: required-arg, required-kwonly, and type-annotation checks ===
+    # These run after all variable resolution (kwargs reading, starargs setup, dict conversion)
+    # so each variable holds its final value when checked.
+    if type_enforce:
+        # Required positional args (no default, not kwonly)
+        for c, arg in enumerate(a):
+            if c < offset:
+                continue
+            if arg.kwonly:
+                continue
+            if not Object.prototype.hasOwnProperty.call(a.defaults, arg.name):
+                miss_msg = fname + '() missing required positional argument: \'' + arg.name + '\''
+                output.indent()
+                output.print('if (' + arg.name + ' === undefined) throw new TypeError(' + JSON.stringify(miss_msg) + ')')
+                output.end_statement()
+        # Required keyword-only args (no default)
+        for c, arg in enumerate(a):
+            if not arg.kwonly:
+                continue
+            if not Object.prototype.hasOwnProperty.call(a.defaults, arg.name):
+                miss_kw = fname + '() missing required keyword-only argument: \'' + arg.name + '\''
+                output.indent()
+                output.print('if (' + arg.name + ' === undefined) throw new TypeError(' + JSON.stringify(miss_kw) + ')')
+                output.end_statement()
+        # Type annotation checks (skip *args and **kwargs)
+        for c, arg in enumerate(a):
+            if c < offset:
+                continue
+            if not arg.annotation:
+                continue
+            annot_name = arg.annotation.name or ''
+            type_msg = fname + '() argument \'' + arg.name + '\' must be ' + annot_name
+            output.indent()
+            output.print('if (' + arg.name + ' !== undefined && !ρσ_instanceof(' + arg.name + ', ')
+            arg.annotation.print(output)
+            output.print(')) throw new TypeError(' + JSON.stringify(type_msg) + ')')
+            output.end_statement()
+
 def has_annotations(self):
     if self.return_annotation:
         return True
@@ -169,8 +304,6 @@ def has_annotations(self):
     return False
 
 def function_annotation(self, output, strip_first, name):
-    if output.options.omit_function_metadata:
-        return
     fname = name or (self.name.name if self.name else anonfunc)
     props = Object.create(None)
 
@@ -263,27 +396,37 @@ def function_definition(self, output, strip_first, as_expression):
         output.set_indentation(output.next_indent())
         output.spaced('(function()', '{'), output.newline()
         output.indent(), output.spaced('var', anonfunc, '='), output.space()
-    if self.is_async:
+    # Async generators (async def with yield) are emitted as a sync wrapper that
+    # returns the async iterator directly (matching Python semantics, where calling
+    # an async generator function returns the iterator immediately without await).
+    # The inner js_generator is `async function*`. The outer wrapper is sync.
+    if self.is_async and not self.is_generator:
         output.print("async"), output.space()
     output.print("function"), output.space()
     if self.name:
         self.name.print(output)
 
     if self.is_generator:
+        inner_decl = 'async function* js_generator' if self.is_async else 'function* js_generator'
         output.print('()'), output.space()
         output.with_block(def():
             output.indent()
-            output.print('function* js_generator')
+            output.print(inner_decl)
             function_args(self.argnames, output, strip_first)
             print_bracketed(self, output, True, function_preamble)
             output.newline()
             output.indent()
             output.spaced('var', 'result', '=', 'js_generator.apply(this,', 'arguments)')
             output.end_statement()
-            # Python's generator objects use a separate method to send data to the generator
+            # Python's generator objects use a separate method to send data to the generator.
+            # For async generators, asend() is the async equivalent — alias it to next as well.
             output.indent()
             output.spaced('result.send', '=', 'result.next')
             output.end_statement()
+            if self.is_async:
+                output.indent()
+                output.spaced('result.asend', '=', 'result.next')
+                output.end_statement()
             output.indent()
             output.spaced('return', 'result')
             output.end_statement()
@@ -443,12 +586,15 @@ def print_function_call(self, output):
             )
         elif is_node_type(self.expression, AST_SymbolRef) and self.expression.name is 'print':
             # Bare print(...) → console.log(...) to avoid clobbering window.print
+            # Wrap each arg in ρσ_str() so type() and other objects display like Python
             output.print('console.log')
             output.with_parens(def():
                 for i, a in enumerate(self.args):
                     if i:
                         output.comma()
+                    output.print('ρσ_str(')
                     a.print(output)
+                    output.print(')')
             )
         elif (is_node_type(self.expression, AST_SymbolRef) and
               self.expression.name is 'vars' and self.args.length is 0):

package/src/output/loops.pyj

@@ -119,7 +119,10 @@ def print_for_loop_body(output):
         if not (self.simple_for_index or is_simple_for_in(self)):
             # if we're using multiple iterators, unpack them
             output.indent()
-            if output.options.js_version is 5:
+            # `async for` always emits ES6+ `for await ... of` syntax (regardless
+            # of js_version), so the loop variable holds the value directly —
+            # not an integer index into an array.
+            if output.options.js_version is 5 and not self.is_async:
                 itervar = "ρσ_Iter" + output.index_counter + "[ρσ_Index" + output.index_counter + "]"
             else:
                 itervar = "ρσ_Index" + output.index_counter
@@ -237,7 +240,19 @@ def print_for_in(self, output):
         )
     else:
         # regular loop
-        if output.options.js_version is 5:
+        if self.is_async:
+            # async for: emit native `for await ... of` regardless of js_version.
+            # Async iteration is an ES2018 feature; if the user wrote `async for`
+            # they have already opted into a modern runtime. The ρσ_Iterable
+            # bridge is skipped because async iterators don't expose .length
+            # or Map keys — the JS engine handles Symbol.asyncIterator natively.
+            itervar = "ρσ_Iter" + output.index_counter
+            output.assign("var " + itervar)
+            write_object()
+            output.end_statement()
+            output.indent()
+            output.spaced('for', 'await', '(var', 'ρσ_Index' + output.index_counter, 'of', itervar + ')')
+        elif output.options.js_version is 5:
             output.assign("var ρσ_Iter" + output.index_counter)
             output.print("ρσ_Iterable")
             output.with_parens(write_object)

package/src/output/modules.pyj

@@ -94,7 +94,7 @@ def declare_exports(module_id, exports, output, docstrings):
 def _inject_pythonize_strings(output):
     str_funcs = ('capitalize strip lstrip rstrip islower isupper isspace lower upper swapcase title'
         ' center count endswith startswith find rfind index rindex format join ljust rjust'
-        ' partition rpartition splitlines zfill').split(' ')
+        ' partition rpartition replace splitlines zfill').split(' ')
     output.newline()
     output.indent()
     output.print('(function(){var _f=' + JSON.stringify(str_funcs) + ';for(var _i=0;_i<_f.length;_i++)String.prototype[_f[_i]]=\u03c1\u03c3_str.prototype[_f[_i]];})()')

package/src/output/operators.pyj

@@ -321,6 +321,13 @@ def print_binary_op(self, output):
         self.right.print(output)
         output.print(')')
         return
+    if self.operator is '%' and self.python_mod:
+        output.print('ρσ_op_mod_ns(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
+        return
     if function_ops[self.operator]:
         output.print(function_ops[self.operator])
         output.with_parens(def():
@@ -485,6 +492,14 @@ def print_assign(self, output):
             self.right.print(output)
         )
         return
+    if self.operator is '%=' and self.python_mod:
+        output.assign(self.left)
+        output.print('ρσ_op_mod_ns(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
+        return
     if self.operator is '**=':
         output.assign(self.left)
         if output.options.js_version > 6:

package/src/output/stream.pyj

@@ -54,7 +54,6 @@ output_stream_defaults = {
     'module_cache_dir': '',
     'js_version':5,
     'write_name': True,
-    'omit_function_metadata': False,
     'pythonize_strings': False,
     'repl_mode': False,
 }