rapydscript-ns 0.9.0 → 0.9.2

package/src/lib/json.pyj

@@ -0,0 +1,227 @@
+###########################################################
+# RapydScript Standard Library
+# Author: RapydScript-NS Contributors
+# Copyright 2024 RapydScript-NS Contributors
+# License: Apache License    2.0
+# This library is covered under Apache license, so that
+# you can distribute it with your RapydScript applications.
+###########################################################
+
+
+# Python-compatible json module backed by the JS JSON global.
+#
+# RapydScript dicts/lists map directly to JS objects/arrays, so
+# JSON.stringify / JSON.parse round-trip without conversion.
+# This wrapper provides the familiar Python json.dumps / json.loads API.
+#
+# NOTE: `default` is a JS reserved word in RapydScript; the parameter is
+# exposed as `dflt` in function signatures but documented as `default`.
+
+
+class JSONDecodeError(ValueError):
+    def __init__(self, msg, doc, pos):
+        self.msg = msg
+        self.doc = doc
+        self.pos = pos
+        self.lineno = 1
+        self.colno  = pos + 1
+        ValueError.__init__(self, msg + ': line ' + str(self.lineno) + ' column ' + str(self.colno) + ' (char ' + str(pos) + ')')
+
+
+# ---------------------------------------------------------------------------
+# Internal JS helpers
+# ---------------------------------------------------------------------------
+
+v"""
+// Convert a value to a plain JS object recursively, honouring ρσ_dict.toJSON.
+function _json_to_plain(val) {
+    if (val === null || val === undefined) return val;
+    if (Array.isArray(val)) {
+        return val.map(_json_to_plain);
+    }
+    if (typeof val === 'object') {
+        if (typeof val.toJSON === 'function') {
+            // ρσ_dict.toJSON() converts the dict to a plain {k:v} object
+            val = val.toJSON();
+        }
+        var out = {};
+        var keys = Object.keys(val);
+        for (var i = 0; i < keys.length; i++) {
+            out[keys[i]] = _json_to_plain(val[keys[i]]);
+        }
+        return out;
+    }
+    return val;
+}
+
+// Sort keys recursively.
+function _json_sort_keys(val) {
+    if (val === null || val === undefined) return val;
+    if (Array.isArray(val)) {
+        return val.map(_json_sort_keys);
+    }
+    if (typeof val === 'object') {
+        var sorted = {};
+        Object.keys(val).sort().forEach(function(k) {
+            sorted[k] = _json_sort_keys(val[k]);
+        });
+        return sorted;
+    }
+    return val;
+}
+
+// Raise ValueError if any value in the tree is NaN or non-finite.
+function _json_check_nan(val, raise_fn) {
+    if (typeof val === 'number') {
+        if (isNaN(val) || !isFinite(val)) {
+            raise_fn();
+        }
+        return;
+    }
+    if (Array.isArray(val)) {
+        for (var i = 0; i < val.length; i++) _json_check_nan(val[i], raise_fn);
+        return;
+    }
+    if (val !== null && typeof val === 'object') {
+        var keys = Object.keys(val);
+        for (var j = 0; j < keys.length; j++) _json_check_nan(val[keys[j]], raise_fn);
+    }
+}
+
+// Walk a parsed JSON tree and apply object_hook / parse_float / parse_int.
+function _json_walk(val, parse_float, parse_int, object_hook, object_pairs_hook) {
+    if (Array.isArray(val)) {
+        for (var i = 0; i < val.length; i++) {
+            val[i] = _json_walk(val[i], parse_float, parse_int, object_hook, object_pairs_hook);
+        }
+        return val;
+    }
+    if (val !== null && typeof val === 'object') {
+        var keys = Object.keys(val);
+        for (var j = 0; j < keys.length; j++) {
+            val[keys[j]] = _json_walk(val[keys[j]], parse_float, parse_int, object_hook, object_pairs_hook);
+        }
+        if (object_pairs_hook) {
+            var pairs = keys.map(function(k) { return [k, val[k]]; });
+            return object_pairs_hook(pairs);
+        }
+        if (object_hook) {
+            return object_hook(val);
+        }
+        return val;
+    }
+    if (typeof val === 'number') {
+        if (parse_int && val === Math.floor(val)) {
+            return parse_int(String(val));
+        }
+        if (parse_float && val !== Math.floor(val)) {
+            return parse_float(String(val));
+        }
+    }
+    return val;
+}
+"""
+
+
+def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
+          allow_nan=False, sort_keys=False, indent=None, separators=None,
+          dflt=None):
+    """Serialize obj to a JSON-formatted string.
+
+    Parameters:
+      indent     -- int or str; if not None, pretty-print output
+      sort_keys  -- if True, sort dict keys in the output
+      dflt       -- callable for objects that are not serializable (Python: default);
+                    should return a JSON-serializable value or raise TypeError
+      separators -- (item_sep, key_sep) pair; (',', ':') gives compact output
+      allow_nan  -- if False (default), NaN/Infinity raise ValueError
+      skipkeys, ensure_ascii, check_circular -- accepted for API compatibility
+    """
+    # Convert to plain JS (handles ρσ_dict via toJSON)
+    work = _json_to_plain(obj)
+
+    if not allow_nan:
+        def _raise_nan():
+            raise ValueError('Out of range float values are not JSON compliant')
+        _json_check_nan(work, _raise_nan)
+
+    if sort_keys:
+        work = _json_sort_keys(work)
+
+    js_indent = None
+    if indent is not None:
+        if jstype(indent) is 'number':
+            js_indent = indent
+        else:
+            js_indent = str(indent)
+
+    replacer = None
+    if dflt is not None:
+        _dflt_fn = dflt
+        def replacer(key, value):
+            if value is not None and jstype(value) is 'object' and not Array.isArray(value):
+                try:
+                    return _json_to_plain(_dflt_fn(value))
+                except TypeError:
+                    pass
+            return value
+
+    result = JSON.stringify(work, replacer, js_indent)
+
+    if result is undefined:
+        raise TypeError('Object of type ' + jstype(obj) + ' is not JSON serializable')
+
+    # Apply custom separators when not pretty-printing.
+    # JS default uses ", " between items and ": " between key and value.
+    if indent is None and separators is not None:
+        item_sep = separators[0]
+        key_sep  = separators[1]
+        result = result.split(', ').join(item_sep).split(': ').join(key_sep)
+
+    return result
+
+
+def loads(s, cls=None, object_hook=None, parse_float=None,
+          parse_int=None, parse_constant=None, object_pairs_hook=None):
+    """Deserialize s (a str) to a Python object.
+
+    Returns plain JS objects (access with obj['key'] or obj.key).
+
+    Parameters:
+      object_hook       -- callable applied to every decoded JSON object
+      object_pairs_hook -- called with [(key, value), ...] for each object
+                           (takes precedence over object_hook)
+      parse_float       -- called with the string of each float literal
+      parse_int         -- called with the string of each integer literal
+      cls, parse_constant -- accepted for API compatibility, ignored
+    """
+    try:
+        result = v'JSON.parse'(str(s))
+    except Exception as _parse_err:
+        msg = _parse_err.message if _parse_err.message else str(_parse_err)
+        raise JSONDecodeError(msg, str(s), 0)
+
+    if result is undefined:
+        raise JSONDecodeError('No JSON object could be decoded', str(s), 0)
+
+    needs_walk = (parse_float is not None or parse_int is not None or
+                  object_hook is not None or object_pairs_hook is not None)
+    if needs_walk:
+        result = _json_walk(result, parse_float, parse_int, object_hook, object_pairs_hook)
+
+    return result
+
+
+def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
+         allow_nan=False, sort_keys=False, indent=None, separators=None,
+         dflt=None):
+    """Serialize obj as a JSON stream to fp (a file-like object with .write())."""
+    fp.write(dumps(obj, skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+                   check_circular=check_circular, allow_nan=allow_nan,
+                   sort_keys=sort_keys, indent=indent, separators=separators,
+                   dflt=dflt))
+
+
+def load(fp):
+    """Deserialize fp (a file-like object with .read()) to a Python object."""
+    return loads(fp.read())

package/src/lib/math.pyj

@@ -1,193 +1,193 @@
-###########################################################
-# RapydScript Standard Library
-# Author: Alexander Tsepkov
-# Copyright 2013 Pyjeon Software LLC
-# License: Apache License    2.0
-# This library is covered under Apache license, so that
-# you can distribute it with your RapydScript applications.
-###########################################################
-
-
-# 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
-
-
-pi = Math.PI
-e = Math.E
-inf = Infinity
-
-########################################
-# Number-theoretic and representation functions
-########################################
-def ceil(x):
-    return Math.ceil(x)
-def copysign(x, y):
-    x = Math.abs(x)
-    if y < 0:
-        return -x
-    else:
-        return x
-def fabs(x):
-    return Math.abs(x)
-def factorial(x):
-    if Math.abs(int(x)) is not x:
-        raise ValueError("factorial() only accepts integral values")
-    factorial.cache = []
-    r = def(n):
-        if n is 0 or n is 1:
-            return 1
-        if not factorial.cache[n]:
-            factorial.cache[n] = r(n-1) * n
-        return factorial.cache[n]
-    return r(x)
-def floor(x):
-    return Math.floor(x)
-def fmod(x, y):
-    # 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
-    partials = []   # sorted, non-overlapping partial sums
-    for x in iterable:
-        i = 0
-        for y in partials:
-            if Math.abs(x) < Math.abs(y):
-                x, y = y, x
-            hi = x + y
-            lo = y - (hi - x)
-            if lo:
-                partials[i] = lo
-                i += 1
-            x = hi
-        #partials[i:] = [x]
-        partials.splice(i, partials.length-i, x)
-    return sum(partials)
-def isinf(x):
-    return not isFinite(x)
-def isnan(x):
-    return isNaN(x)
-def modf(x):
-    m = fmod(x, 1)
-    return m, x-m
-def trunc(x):
-    return x | 0
-
-########################################
-# Power and logarithmic functions
-########################################
-def exp(x):
-    return Math.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
-    #return Math.expm1(x)
-    if Math.abs(x) < 1e-5:
-        return x + 0.5*x*x
-    else:
-        return Math.exp(x) - 1
-def log(x, base=e):
-    return Math.log(x)/Math.log(base)
-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
-    # 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
-    ret = 0
-    n = 50
-    if x <= -1:
-        return Number.NEGATIVE_INFINITY
-    if x < 0 or x > 1:
-        return Math.log(1 + x)
-    for i in range(1, n):
-        if i % 2 is 0:
-            ret -= Math.pow(x, i) / i
-        else:
-            ret += Math.pow(x, i) / i
-    return ret
-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
-    return Math.log(x)/Math.LN10
-def pow(x, y):
-    if x < 0 and int(y) is not y:
-        raise ValueError('math domain error')
-    if isnan(y) and x is 1:
-        return 1
-    return Math.pow(x, y)
-def sqrt(x):
-    return Math.sqrt(x)
-
-########################################
-# Trigonometric functions
-########################################
-def acos(x):        return Math.acos(x)
-def asin(x):        return Math.asin(x)
-def atan(x):        return Math.atan(x)
-def atan2(y, x):    return Math.atan2(y, x)
-def cos(x):         return Math.cos(x)
-def sin(x):         return Math.sin(x)
-def hypot(x, y):    return Math.sqrt(x*x + y*y)
-def tan(x):         return Math.tan(x)
-
-########################################
-# Angular conversion
-########################################
-def degrees(x):     return x*180/pi
-def radians(x):     return x*pi/180
-
-########################################
-# Hyperbolic functions
-########################################
-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
-    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
-    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
-    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
-    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
-    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
-    return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x))
-
-
-
-#import stdlib
-#print(math.ceil(4.2))
-#print(math.floor(4.2))
-#print(math.fabs(-6))
-#print(math.copysign(-5, 7))
-#print(math.factorial(4))
-#print(math.fmod(-1e100, 1e100))
-#
-#d = [0.9999999, 1, 2, 3]
-#print(sum(d), math.fsum(d))
-#print(math.isinf(5), math.isinf(Infinity))
-#print(math.modf(5.5))
-#print(math.trunc(2.6), math.trunc(-2.6))
-#print(math.exp(1e-5), math.expm1(1e-5))
-#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.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))
+###########################################################
+# RapydScript Standard Library
+# Author: Alexander Tsepkov
+# Copyright 2013 Pyjeon Software LLC
+# License: Apache License    2.0
+# This library is covered under Apache license, so that
+# you can distribute it with your RapydScript applications.
+###########################################################
+
+
+# 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
+
+
+pi = Math.PI
+e = Math.E
+inf = Infinity
+
+########################################
+# Number-theoretic and representation functions
+########################################
+def ceil(x):
+    return Math.ceil(x)
+def copysign(x, y):
+    x = Math.abs(x)
+    if y < 0:
+        return -x
+    else:
+        return x
+def fabs(x):
+    return Math.abs(x)
+def factorial(x):
+    if Math.abs(int(x)) is not x:
+        raise ValueError("factorial() only accepts integral values")
+    factorial.cache = []
+    r = def(n):
+        if n is 0 or n is 1:
+            return 1
+        if not factorial.cache[n]:
+            factorial.cache[n] = r(n-1) * n
+        return factorial.cache[n]
+    return r(x)
+def floor(x):
+    return Math.floor(x)
+def fmod(x, y):
+    # 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
+    partials = []   # sorted, non-overlapping partial sums
+    for x in iterable:
+        i = 0
+        for y in partials:
+            if Math.abs(x) < Math.abs(y):
+                x, y = y, x
+            hi = x + y
+            lo = y - (hi - x)
+            if lo:
+                partials[i] = lo
+                i += 1
+            x = hi
+        #partials[i:] = [x]
+        partials.splice(i, partials.length-i, x)
+    return sum(partials)
+def isinf(x):
+    return not isFinite(x)
+def isnan(x):
+    return isNaN(x)
+def modf(x):
+    m = fmod(x, 1)
+    return m, x-m
+def trunc(x):
+    return x | 0
+
+########################################
+# Power and logarithmic functions
+########################################
+def exp(x):
+    return Math.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
+    #return Math.expm1(x)
+    if Math.abs(x) < 1e-5:
+        return x + 0.5*x*x
+    else:
+        return Math.exp(x) - 1
+def log(x, base=e):
+    return Math.log(x)/Math.log(base)
+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
+    # 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
+    ret = 0
+    n = 50
+    if x <= -1:
+        return Number.NEGATIVE_INFINITY
+    if x < 0 or x > 1:
+        return Math.log(1 + x)
+    for i in range(1, n):
+        if i % 2 is 0:
+            ret -= Math.pow(x, i) / i
+        else:
+            ret += Math.pow(x, i) / i
+    return ret
+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
+    return Math.log(x)/Math.LN10
+def pow(x, y):
+    if x < 0 and int(y) is not y:
+        raise ValueError('math domain error')
+    if isnan(y) and x is 1:
+        return 1
+    return Math.pow(x, y)
+def sqrt(x):
+    return Math.sqrt(x)
+
+########################################
+# Trigonometric functions
+########################################
+def acos(x):        return Math.acos(x)
+def asin(x):        return Math.asin(x)
+def atan(x):        return Math.atan(x)
+def atan2(y, x):    return Math.atan2(y, x)
+def cos(x):         return Math.cos(x)
+def sin(x):         return Math.sin(x)
+def hypot(x, y):    return Math.sqrt(x*x + y*y)
+def tan(x):         return Math.tan(x)
+
+########################################
+# Angular conversion
+########################################
+def degrees(x):     return x*180/pi
+def radians(x):     return x*pi/180
+
+########################################
+# Hyperbolic functions
+########################################
+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
+    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
+    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
+    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
+    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
+    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
+    return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x))
+
+
+
+#import stdlib
+#print(math.ceil(4.2))
+#print(math.floor(4.2))
+#print(math.fabs(-6))
+#print(math.copysign(-5, 7))
+#print(math.factorial(4))
+#print(math.fmod(-1e100, 1e100))
+#
+#d = [0.9999999, 1, 2, 3]
+#print(sum(d), math.fsum(d))
+#print(math.isinf(5), math.isinf(Infinity))
+#print(math.modf(5.5))
+#print(math.trunc(2.6), math.trunc(-2.6))
+#print(math.exp(1e-5), math.expm1(1e-5))
+#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.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))

package/src/lib/operator.pyj

@@ -1,11 +1,11 @@
-add = __add__ = def(x, y): return x + y
-sub = __sub__ = def(x, y): return x - y
-mul = __mul__ = def(x, y): return x * y
-div = __div__ = def(x, y): return x / y
-
-lt = __lt__ = def(x, y): return x < y
-le = __le__ = def(x, y): return x <= y
-eq = __eq__ = def(x, y): return x is y
-ne = __ne__ = def(x, y): return x is not y
-ge = __ge__ = def(x, y): return x >= y
-gt = __gt__ = def(x, y): return x > y
+add = __add__ = def(x, y): return x + y
+sub = __sub__ = def(x, y): return x - y
+mul = __mul__ = def(x, y): return x * y
+div = __div__ = def(x, y): return x / y
+
+lt = __lt__ = def(x, y): return x < y
+le = __le__ = def(x, y): return x <= y
+eq = __eq__ = def(x, y): return x is y
+ne = __ne__ = def(x, y): return x is not y
+ge = __ge__ = def(x, y): return x >= y
+gt = __gt__ = def(x, y): return x > y

package/src/lib/pythonize.pyj

@@ -1,20 +1,20 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: ρσ_str
-
-def strings():
-    string_funcs = set((
-        '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 replace split rsplit splitlines zfill expandtabs').split(' '))
-
-    if not arguments.length:
-        exclude = {'split', 'replace'}
-    elif arguments[0]:
-        exclude = Array.prototype.slice.call(arguments)
-    else:
-        exclude = None
-    if exclude:
-        string_funcs = string_funcs.difference(set(exclude))
-    for name in string_funcs:
-        String.prototype[name] = ρσ_str.prototype[name]
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: ρσ_str
+
+def strings():
+    string_funcs = set((
+        '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 replace split rsplit splitlines zfill expandtabs').split(' '))
+
+    if not arguments.length:
+        exclude = {'split', 'replace'}
+    elif arguments[0]:
+        exclude = Array.prototype.slice.call(arguments)
+    else:
+        exclude = None
+    if exclude:
+        string_funcs = string_funcs.difference(set(exclude))
+    for name in string_funcs:
+        String.prototype[name] = ρσ_str.prototype[name]