rapydscript-ng 0.8.2 → 0.8.4

package/src/lib/elementmaker.pyj

@@ -2,19 +2,111 @@
 # License: GPL v3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
 
 html_elements = {
-    'a', 'abbr', 'acronym', 'address', 'area',
-    'article', 'aside', 'audio', 'b', 'base', 'big', 'body', 'blockquote', 'br', 'button',
-    'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup',
-    'command', 'datagrid', 'datalist', 'dd', 'del', 'details', 'dfn',
-    'dialog', 'dir', 'div', 'dl', 'dt', 'em', 'event-source', 'fieldset',
-    'figcaption', 'figure', 'footer', 'font', 'form', 'header', 'h1',
-    'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'head', 'i', 'iframe', 'img', 'input', 'ins',
-    'keygen', 'kbd', 'label', 'legend', 'li', 'm', 'map', 'menu', 'meter',
-    'multicol', 'nav', 'nextid', 'ol', 'output', 'optgroup', 'option',
-    'p', 'pre', 'progress', 'q', 's', 'samp', 'script', 'section', 'select',
-    'small', 'sound', 'source', 'spacer', 'span', 'strike', 'strong', 'style',
-    'sub', 'sup', 'table', 'tbody', 'td', 'textarea', 'time', 'tfoot',
-    'th', 'thead', 'tr', 'tt', 'u', 'ul', 'var', 'video'
+    'a',
+    'abbr',
+    'acronym',
+    'address',
+    'area',
+    'article',
+    'aside',
+    'audio',
+    'b',
+    'base',
+    'big',
+    'body',
+    'blockquote',
+    'br',
+    'button',
+    'canvas',
+    'caption',
+    'center',
+    'cite',
+    'code',
+    'col',
+    'colgroup',
+    'command',
+    'datagrid',
+    'datalist',
+    'dd',
+    'del',
+    'details',
+    'dfn',
+    'dialog',
+    'dir',
+    'div',
+    'dl',
+    'dt',
+    'em',
+    'event-source',
+    'fieldset',
+    'figcaption',
+    'figure',
+    'footer',
+    'font',
+    'form',
+    'header',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'hr',
+    'head',
+    'i',
+    'iframe',
+    'img',
+    'input',
+    'ins',
+    'keygen',
+    'kbd',
+    'label',
+    'legend',
+    'li',
+    'm',
+    'map',
+    'menu',
+    'meter',
+    'multicol',
+    'nav',
+    'nextid',
+    'ol',
+    'output',
+    'optgroup',
+    'option',
+    'p',
+    'pre',
+    'progress',
+    'q',
+    's',
+    'samp',
+    'script',
+    'section',
+    'select',
+    'small',
+    'sound',
+    'source',
+    'spacer',
+    'span',
+    'strike',
+    'strong',
+    'style',
+    'sub',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'textarea',
+    'time',
+    'tfoot',
+    'th',
+    'thead',
+    'tr',
+    'tt',
+    'u',
+    'ul',
+    'var',
+    'video',
 }
 
 mathml_elements = {

package/src/lib/encodings.pyj

@@ -7,18 +7,36 @@ def base64encode(bytes, altchars, pad_char):
     l = bytes.length
     remainder = l % 3
     main_length = l - remainder
-    encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' + (altchars or '+/')
+    encodings = (
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' +
+        (altchars or '+/')
+    )
     pad_char = '=' if pad_char is undefined else pad_char
     ans = v'[]'
     for v'var i = 0; i < main_length; i += 3':
         chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]
-        ans.push(encodings[(chunk & 16515072) >> 18], encodings[(chunk & 258048) >> 12], encodings[(chunk & 4032) >> 6], encodings[chunk & 63])
+        ans.push(
+            encodings[(chunk & 16515072) >> 18],
+            encodings[(chunk & 258048) >> 12],
+            encodings[(chunk & 4032) >> 6],
+            encodings[chunk & 63]
+        )
     if remainder is 1:
         chunk = bytes[main_length]
-        ans.push(encodings[(chunk & 252) >> 2], encodings[(chunk & 3) << 4], pad_char, pad_char)
+        ans.push(
+            encodings[(chunk & 252) >> 2],
+            encodings[(chunk & 3) << 4],
+            pad_char,
+            pad_char
+        )
     elif remainder is 2:
         chunk = (bytes[main_length] << 8) | bytes[main_length + 1]
-        ans.push(encodings[(chunk & 64512) >> 10], encodings[(chunk & 1008) >> 4], encodings[(chunk & 15) << 2], pad_char)
+        ans.push(
+            encodings[(chunk & 64512) >> 10],
+            encodings[(chunk & 1008) >> 4],
+            encodings[(chunk & 15) << 2],
+            pad_char
+        )
     return ans.join('')
 
 
@@ -40,7 +58,10 @@ def urlsafe_b64encode(bytes, pad_char):
 
 
 def urlsafe_b64decode(string):
-    string = String.prototype.replace.call(string, /[_-]/g, def (m): return '+' if m is '-' else '/';)
+    string = String.prototype.replace.call(
+        string, /[_-]/g, def (m):
+            return '+' if m is '-' else '/'
+    )
     return base64decode(string)
 
 
@@ -99,13 +120,16 @@ def utf8_decode(bytes, errors, replacement):
     for v'var i = 0, l = bytes.length; i < l; i++':  # noqa
         byte = bytes[i]
         typ = utf8_decoder_table[byte]
-        codep = (byte & 0x3f) | (codep << 6) if state is not 0 else (0xff >> typ) & (byte)
+        codep = (((byte & 0x3f) | (codep << 6)) if state is not 0 else ((0xff >> typ) & (byte)))
         state = utf8_decoder_table[256 + state * 16 + typ]
         if state is 0:
             ans.push(_from_code_point(codep))
         elif state is 1:
             if not errors or errors is 'strict':
-                raise UnicodeDecodeError(str.format('The byte 0x{:02x} at position {} is not valid UTF-8', byte, i))
+                raise UnicodeDecodeError(str.format(
+                    'The byte 0x{:02x} at position {} is not valid UTF-8',
+                    byte, i
+                ))
             elif errors is 'replace':
                 ans.push(replacement or '?')
     return ans.join('')

package/src/lib/gettext.pyj

@@ -4,7 +4,8 @@
 # noqa: eol-semicolon
 
 # The Plural-Forms parser {{{
-# From: https://github.com/SlexAxton/Jed/blob/master/jed.js licensed under the WTFPL
+# From: https://github.com/SlexAxton/Jed/blob/master/jed.js
+# licensed under the WTFPL
 
 Jed = {}
 
@@ -502,7 +503,8 @@ plural_forms_parser = Jed.PF
 
 
 def _get_plural_forms_function(plural_forms_string):
-    return plural_forms_parser.compile(plural_forms_string or 'nplurals=2; plural=(n != 1);')
+    return plural_forms_parser.compile(
+        plural_forms_string or 'nplurals=2; plural=(n != 1);')
 
 _gettext = def (text): return text
 
@@ -527,7 +529,8 @@ def install(translation_data):
             pass
     return t
 
-has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty)
+has_prop = Object.prototype.hasOwnProperty.call.bind(
+    Object.prototype.hasOwnProperty)
 
 
 def register_callback(func):

package/src/lib/math.pyj

@@ -10,14 +10,15 @@
 
 # basic implementation of Python's 'math' library
 
-# NOTE: this is only meant to aid those porting lots of Python code into RapydScript,
-# if you're writing a new RapydScript application, in most cases you probably want to
-# use JavaScript's Math module directly instead
+# NOTE: this is only meant to aid those porting lots of Python code
+# into RapydScript, if you're writing a new RapydScript application,
+# in most cases you probably want to use JavaScript's Math module
+# directly instead
 
 
 pi = Math.PI
 e = Math.E
-inf = Infinity
+inf = Math.Infinity
 
 
 ########################################
@@ -57,14 +58,16 @@ def floor(x):
 
 
 def fmod(x, y):
-    # javascript's % operator isn't consistent with C fmod implementation, this function is
+    # javascript's % operator isn't consistent with C fmod
+    # implementation, this function is
     while y <= x:
         x -= y
     return x
 
 
 def fsum(iterable):
-    # like Python's fsum, this method is much more resilient to rounding errors than regular sum
+    # like Python's fsum, this method is much more resilient to
+    # rounding errors than regular sum
     partials = []  # sorted, non-overlapping partial sums
     for x in iterable:
         i = 0
@@ -107,8 +110,9 @@ def exp(x):
 
 
 def expm1(x):
-    # NOTE: Math.expm1() is currently only implemented in Firefox, this provides alternative implementation
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1
+    # NOTE: Math.expm1() is only in Firefox; this provides an alternative
+    # implementation. See MDN: https://developer.mozilla.org/en-US/docs/
+    #   Web/JavaScript/Reference/Global_Objects/Math/expm1
     # return Math.expm1(x)
     if Math.abs(x) < 1e-5:
         return x + 0.5 * x * x
@@ -121,10 +125,12 @@ def log(x, base=e):
 
 
 def log1p(x):
-    # NOTE: Math.log1p() is currently only implemented in Firefox, this provides alternative implementation
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p
+    # NOTE: Math.log1p() is only in Firefox; this provides an alternative
+    # implementation. See MDN: https://developer.mozilla.org/en-US/docs/
+    #   Web/JavaScript/Reference/Global_Objects/Math/log1p
     # this version has been taken from http://phpjs.org/functions/log1p/
-    # admittedly it's not as accurate as MDN version, as you can see from math.log1p(1) result
+    # admittedly it's not as accurate as MDN version, as you can see
+    # from math.log1p(1) result
     ret = 0
     n = 50
     if x <= -1:
@@ -140,9 +146,11 @@ def log1p(x):
 
 
 def log10(x):
-    # NOTE: Math.log10() is currently only implemented in Firefox, this provides alternative implementation
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10
-    # I didn't find a more accurate algorithm so I'm using the basic implementation
+    # NOTE: Math.log10() is only in Firefox; this provides an alternative
+    # implementation. See MDN: https://developer.mozilla.org/en-US/docs/
+    #   Web/JavaScript/Reference/Global_Objects/Math/log10
+    # I didn't find a more accurate algorithm so I'm using the
+    # basic implementation
     return Math.log(x) / Math.LN10
 
 
@@ -199,37 +207,43 @@ def radians(x): return x * pi / 180
 ########################################
 def acosh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/
+    #   Reference/Global_Objects/Math/acosh
     return Math.log(x + Math.sqrt(x * x - 1))
 
 
 def asinh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/
+    #   Reference/Global_Objects/Math/asinh
     return Math.log(x + Math.sqrt(x * x + 1))
 
 
 def atanh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/
+    #   Reference/Global_Objects/Math/atanh
     return 0.5 * Math.log((1 + x) / (1 - x))
 
 
 def cosh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/
+    #   Reference/Global_Objects/Math/cosh
     return (Math.exp(x) + Math.exp(-x)) / 2
 
 
 def sinh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/
+    #   Reference/Global_Objects/Math/sinh
     return (Math.exp(x) - Math.exp(-x)) / 2
 
 
 def tanh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
-    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/
+    #   Reference/Global_Objects/Math/tanh
     return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x))
 
     # import stdlib
@@ -249,6 +263,8 @@ def tanh(x):
     # print(math.log(10), math.log(10, 1000))
     # print(math.log1p(1e-15), math.log1p(1))
     # print(math.log10(1000), math.log(1000, 10))
-    # print(math.pow(1, 0), math.pow(1, NaN), math.pow(0, 0), math.pow(NaN, 0), math.pow(4,3), math.pow(100, -2))
+    # print(math.pow(1, 0), math.pow(1, NaN), math.pow(0, 0),
+    #       math.pow(NaN, 0), math.pow(4,3), math.pow(100, -2))
     # print(math.hypot(3,4))
-    # print(math.acosh(2), math.asinh(1), math.atanh(0.5), math.cosh(1), math.cosh(-1), math.sinh(1), math.tanh(1))
+    # print(math.acosh(2), math.asinh(1), math.atanh(0.5),
+    #       math.cosh(1), math.cosh(-1), math.sinh(1), math.tanh(1))

package/src/lib/pythonize.pyj

@@ -5,9 +5,11 @@
 
 def strings():
     string_funcs = set((
-        'capitalize strip lstrip rstrip islower isupper isspace lower upper swapcase'
-        ' center count endswith startswith find rfind index rindex format join ljust rjust'
-        ' partition rpartition replace split rsplit splitlines zfill').split(' '))
+        'capitalize strip lstrip rstrip islower isupper isspace'
+        ' lower upper swapcase center count endswith startswith'
+        ' find rfind index rindex format join ljust rjust'
+        ' partition rpartition replace split rsplit splitlines zfill'
+    ).split(' '))
 
     if not arguments.length:
         exclude = {'split', 'replace'}

package/src/lib/random.pyj

@@ -10,7 +10,8 @@
 
 # basic implementation of Python's 'random' library
 
-# JavaScript's Math.random() does not allow seeding its random generator, to bypass that, this module implements its own
+# JavaScript's Math.random() does not allow seeding its random
+# generator, to bypass that, this module implements its own
 # version that can be seeded. I decided on RC4 algorithm for this.
 
 # please don't mess with this from the outside
@@ -23,9 +24,14 @@
 
 ρσ_get_random_byte = def ():
     ρσ_seed_state.key_i = (ρσ_seed_state.key_i + 1) % 256
-    ρσ_seed_state.key_j = (ρσ_seed_state.key_j + ρσ_seed_state.key[ρσ_seed_state.key_i]) % 256
-    ρσ_seed_state.key[ρσ_seed_state.key_i], ρσ_seed_state.key[ρσ_seed_state.key_j] = \
-            ρσ_seed_state.key[ρσ_seed_state.key_j], ρσ_seed_state.key[ρσ_seed_state.key_i]
+    ρσ_seed_state.key_j = (
+        ρσ_seed_state.key_j + ρσ_seed_state.key[ρσ_seed_state.key_i]
+    ) % 256
+    (ρσ_seed_state.key[ρσ_seed_state.key_i],
+     ρσ_seed_state.key[ρσ_seed_state.key_j]) = (
+        ρσ_seed_state.key[ρσ_seed_state.key_j],
+        ρσ_seed_state.key[ρσ_seed_state.key_i]
+    )
     return ρσ_seed_state.key[(ρσ_seed_state.key[ρσ_seed_state.key_i] + \
             ρσ_seed_state.key[ρσ_seed_state.key_j]) % 256]
 
@@ -41,7 +47,9 @@ def seed(x=Date().getTime()):
     j = 0
     for i in range(256):
         j = (j + ρσ_seed_state.key[i] + x.charCodeAt(i % x.length)) % 256
-        ρσ_seed_state.key[i], ρσ_seed_state.key[j] = ρσ_seed_state.key[j], ρσ_seed_state.key[i]
+        (ρσ_seed_state.key[i],
+         ρσ_seed_state.key[j]) = (
+            ρσ_seed_state.key[j], ρσ_seed_state.key[i])
 seed()
 
 

package/src/lib/re.pyj

@@ -473,7 +473,15 @@ _ALIAS_MAP = {
 }
 # }}}
 
-_ASCII_CONTROL_CHARS = {'a': 7, 'b': 8, 'f': 12, 'n': 10, 'r': 13, 't': 9, 'v': 11}
+_ASCII_CONTROL_CHARS = {
+    'a': 7,
+    'b': 8,
+    'f': 12,
+    'n': 10,
+    'r': 13,
+    't': 9,
+    'v': 11,
+}
 _HEX_PAT = /^[a-fA-F0-9]/
 _NUM_PAT = /^[0-9]/
 _GROUP_PAT = /<([^>]+)>/
@@ -496,7 +504,8 @@ _re_cache_map = {}
 _re_cache_items = v'[]'
 
 error = SyntaxError  # This is the error JS throws for invalid regexps
-has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty)
+has_prop = Object.prototype.hasOwnProperty.call.bind(
+    Object.prototype.hasOwnProperty)
 
 
 def _expand(groups, repl, group_name_map):
@@ -534,7 +543,13 @@ def _expand(groups, repl, group_name_map):
         if _ASCII_CONTROL_CHARS[q]:
             return String.fromCharCode(_ASCII_CONTROL_CHARS[q])
         if '0' <= q <= '9':
-            ans = read_digits(Number.MAX_VALUE, _NUM_PAT, 10, Number.MAX_VALUE, q)
+            ans = read_digits(
+                Number.MAX_VALUE,
+                _NUM_PAT,
+                10,
+                Number.MAX_VALUE,
+                q
+            )
             if jstype(ans) is 'number':
                 return groups[ans] or ''
             return '\\' + ans
@@ -564,7 +579,10 @@ def _expand(groups, repl, group_name_map):
                 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)
+                )
             return '\\U' + code
         if q is 'N' and peek() is '{':
             next()
@@ -581,7 +599,10 @@ def _expand(groups, repl, group_name_map):
             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)
+            )
 
         return '\\' + q
 
@@ -624,7 +645,9 @@ def transform_regex(source, flags):
 
         if ch is '[':
             in_class = True
-            if source[pos] is ']':  # in python the empty set is not allowed, instead []] is the same as [\]]
+            # in python the empty set is not allowed,
+            # instead []] is the same as [\]]
+            if source[pos] is ']':
                 pos += 1
                 ch = r'[\]'
         elif ch is '(':
@@ -637,7 +660,15 @@ def transform_regex(source, flags):
                     pos = close + 1
                     continue
                 if 'aiLmsux'.indexOf(extension) is not -1:
-                    flag_map = {'a': ASCII, 'i': IGNORECASE, 'L': LOCALE, 'm': MULTILINE, 's': DOTALL, 'u': UNICODE, 'x': VERBOSE}
+                    flag_map = {
+                        'a': ASCII,
+                        'i': IGNORECASE,
+                        'L': LOCALE,
+                        'm': MULTILINE,
+                        's': DOTALL,
+                        'u': UNICODE,
+                        'x': VERBOSE,
+                    }
                     close = source.indexOf(')', pos + 1)
                     if close is -1:
                         raise SyntaxError('Expecting a closing )')
@@ -650,14 +681,19 @@ def transform_regex(source, flags):
                     pos = close + 1
                     continue
                 if extension is '(':
-                    raise SyntaxError('Group existence assertions are not supported in JavaScript')
+                    raise SyntaxError(
+                        'Group existence assertions are not '
+                        + 'supported in JavaScript'
+                    )
                 if extension is 'P':
                     pos += 2
                     q = source[pos]
                     if q is '<':
                         close = source.indexOf('>', pos)
                         if close is -1:
-                            raise SyntaxError('Named group not closed, expecting >')
+                            raise SyntaxError(
+                                'Named group not closed, expecting >'
+                            )
                         name = source[pos + 1:close]
                         if not has_prop(group_map, name):
                             group_map[name] = v'[]'
@@ -666,13 +702,20 @@ def transform_regex(source, flags):
                     elif q is '=':
                         close = source.indexOf(')', pos)
                         if close is -1:
-                            raise SyntaxError('Named group back-reference not closed, expecting a )')
+                            raise SyntaxError(
+                                'Named group back-reference not closed,'
+                                + ' expecting a )'
+                            )
                         name = source[pos + 1:close]
                         if not isNaN(parseInt(name, 10)):
                             ans += '\\' + name
                         else:
                             if not has_prop(group_map, name):
-                                raise SyntaxError('Invalid back-reference. The named group: ' + name + ' has not yet been defined.')
+                                raise SyntaxError(
+                                    'Invalid back-reference. The named group: '
+                                    + name
+                                    + ' has not yet been defined.'
+                                )
                             ans += '\\' + group_map[name][-1]
                         pos = close + 1
                         continue
@@ -812,8 +855,14 @@ class MatchObject:
 
 class RegexObject:
     def __init__(self, pattern, flags):
-        self.pattern = pattern.source if isinstance(pattern, RegExp) else pattern
-        self.js_pattern, self.flags, self.group_name_map = transform_regex(self.pattern, flags)
+        self.pattern = pattern.source if isinstance(
+            pattern,
+            RegExp
+        ) else pattern
+        self.js_pattern, self.flags, self.group_name_map = transform_regex(
+            self.pattern,
+            flags
+        )
 
         modifiers = ''
         if self.flags & IGNORECASE: modifiers += 'i'
@@ -838,7 +887,12 @@ class RegexObject:
         return self._do_search(self._pattern, string, pos, endpos)
 
     def match(self, string, pos=0, endpos=None):
-        return self._do_search(RegExp('^' + self.js_pattern, self._modifiers), string, pos, endpos)
+        return self._do_search(
+            RegExp('^' + self.js_pattern, self._modifiers),
+            string,
+            pos,
+            endpos
+        )
 
     def split(self, string, maxsplit=0):
         self._pattern.lastIndex = 0
@@ -850,7 +904,10 @@ class RegexObject:
 
     def finditer(self, string):
         # We have to copy pat since lastIndex is mutable
-        pat = RegExp(this._pattern.source, this._modifiers)  # noqa: unused-local
+        pat = RegExp(  # noqa: unused-local
+            this._pattern.source,
+            this._modifiers
+        )
         ans = v"{'_string':string, '_r':pat, '_self':self}"
         ans[ρσ_iterator_symbol] = def ():
             return this
@@ -858,13 +915,15 @@ class RegexObject:
             m = this._r.exec(this._string)
             if m is None:
                 return v"{'done':true}"
-            return v"{'done':false, 'value':new MatchObject(this._self, m, 0, null)}"
+            _mo = MatchObject(this._self, m, 0, None)  # noqa: unused-local
+            return v"{'done':false, 'value':_mo}"
         return ans
 
     def subn(self, repl, string, count=0):
         expand = _expand
         if jstype(repl) is 'function':
-            expand = def (m, repl, gnm): return '' + repl(MatchObject(self, m, 0, None))
+            expand = def (m, repl, gnm):
+                return '' + repl(MatchObject(self, m, 0, None))
         this._pattern.lastIndex = 0
         num = 0
         matches = v'[]'
@@ -880,7 +939,11 @@ class RegexObject:
             m = matches[i]  # noqa:undef
             start = m.index
             end = start + m[0].length
-            string = string[:start] + expand(m, repl, self.group_name_map) + string[end:]
+            string = string[:start] + expand(
+                m,
+                repl,
+                self.group_name_map
+            ) + string[end:]
         return string, matches.length
 
     def sub(self, repl, string, count=0):