rapydscript-ns 0.9.2 → 0.9.4

package/src/lib/string.pyj

@@ -0,0 +1,357 @@
+###########################################################
+# 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 string module.
+#
+# Provides:
+#   Character constants: ascii_letters, ascii_lowercase, ascii_uppercase,
+#     digits, hexdigits, octdigits, punctuation, printable, whitespace
+#   Template: $-substitution string templates (substitute, safe_substitute)
+#   Formatter: customizable str.format() foundation with subclassing support
+#
+# NOTE: Formatter.format() only accepts positional args via *args.
+# For named-field substitution use vformat(fmt, [], {'key': val}) directly.
+
+
+# ---------------------------------------------------------------------------
+# Character constants
+# ---------------------------------------------------------------------------
+
+ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
+ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+ascii_letters   = ascii_lowercase + ascii_uppercase
+digits          = '0123456789'
+hexdigits       = digits + 'abcdef' + 'ABCDEF'
+octdigits       = '01234567'
+# Build punctuation via chr() to avoid backslash (92) and backtick (96) escaping.
+punctuation     = '!"#$%&' + chr(39) + '()*+,-./:;<=>?@[' + chr(92) + ']^_' + chr(96) + '{|}~'
+# chr(11) = vertical-tab (\x0b), chr(12) = form-feed (\x0c)
+whitespace      = ' \t\n\r' + chr(11) + chr(12)
+printable       = digits + ascii_letters + punctuation + whitespace
+
+
+# ---------------------------------------------------------------------------
+# Internal JS helpers
+# ---------------------------------------------------------------------------
+
+v"""
+// ── Shared numeric-string helper ────────────────────────────────────────────
+
+function _str_is_digits_only(s) {
+    if (!s.length) return false;
+    for (var _di = 0; _di < s.length; _di++) {
+        var _dc = s.charCodeAt(_di);
+        if (_dc < 48 || _dc > 57) return false;
+    }
+    return true;
+}
+
+// ── Template helpers ─────────────────────────────────────────────────────────
+
+// Pattern groups:
+//   1: $$  (escaped dollar → literal $)
+//   2: ${identifier}
+//   3: $identifier
+//   4: $<anything-else> (invalid placeholder; [^]? also captures trailing $)
+var _tmpl_re = /\$(?:(\$)|\{([_a-zA-Z][_a-zA-Z0-9]*)\}|([_a-zA-Z][_a-zA-Z0-9]*)|([^]?))/g;
+
+// Convert a mapping to a plain JS object (handles ρσ_dict with .jsmap).
+function _tmpl_to_plain(mapping) {
+    if (mapping === null || mapping === undefined) return Object.create(null);
+    if (mapping.jsmap !== undefined && mapping.jsmap !== null) {
+        var _out = Object.create(null);
+        mapping.jsmap.forEach(function(_v, _k) { _out[_k] = _v; });
+        return _out;
+    }
+    return mapping;
+}
+
+function _tmpl_substitute_impl(template_str, mapping, safe) {
+    var _re = _tmpl_re;
+    _re.lastIndex = 0;
+    var _res = [];
+    var _last = 0;
+    var _m;
+    while ((_m = _re.exec(template_str)) !== null) {
+        _res.push(template_str.slice(_last, _m.index));
+        _last = _m.index + _m[0].length;
+        if (_m[1] !== undefined) {
+            _res.push('$');
+        } else if (_m[2] !== undefined || _m[3] !== undefined) {
+            var _key = _m[2] !== undefined ? _m[2] : _m[3];
+            var _val = mapping[_key];
+            if (_val === undefined) {
+                if (safe) { _res.push(_m[0]); }
+                else { throw new KeyError(_key); }
+            } else {
+                _res.push(ρσ_str(_val));
+            }
+        } else {
+            // m[4]: invalid placeholder char (or empty for trailing $)
+            if (safe) { _res.push(_m[0]); }
+            else { throw new ValueError('Invalid placeholder in string: ' + JSON.stringify(_m[0])); }
+        }
+    }
+    _res.push(template_str.slice(_last));
+    return _res.join('');
+}
+
+// ── Formatter helpers ────────────────────────────────────────────────────────
+
+function _fmt_get_kwarg(kwargs, key) {
+    if (!kwargs) return undefined;
+    if (kwargs.jsmap !== undefined && kwargs.jsmap !== null) return kwargs.jsmap.get(key);
+    return kwargs[key];
+}
+
+function _fmt_has_kwarg(kwargs, key) {
+    if (!kwargs) return false;
+    if (kwargs.jsmap !== undefined && kwargs.jsmap !== null) return kwargs.jsmap.has(key);
+    return Object.prototype.hasOwnProperty.call(kwargs, key);
+}
+
+// parse: walk format_string, return array of [literal, field_name, fmt_spec, conversion].
+// A trailing literal with no field has field_name === null.
+function _fmt_parse(format_string) {
+    var _items = [];
+    var _i = 0, _n = format_string.length;
+
+    while (_i <= _n) {
+        var _lit = '';
+        while (_i < _n) {
+            var _ch = format_string[_i];
+            if (_ch === '{') {
+                if (_i + 1 < _n && format_string[_i + 1] === '{') { _lit += '{'; _i += 2; }
+                else break;
+            } else if (_ch === '}') {
+                if (_i + 1 < _n && format_string[_i + 1] === '}') { _lit += '}'; _i += 2; }
+                else throw new ValueError("Single '}' encountered in format string");
+            } else { _lit += _ch; _i++; }
+        }
+
+        if (_i >= _n) { _items.push([_lit, null, null, null]); break; }
+
+        _i++; // skip '{'
+        var _j = _i, _depth = 1;
+        while (_j < _n && _depth > 0) {
+            if (format_string[_j] === '{') _depth++;
+            else if (format_string[_j] === '}') _depth--;
+            _j++;
+        }
+        if (_depth !== 0) throw new ValueError("Single '{' encountered in format string");
+
+        var _ft = format_string.slice(_i, _j - 1);
+        _i = _j;
+
+        // Locate ! (conversion) and : (format spec), skipping nested {}
+        var _bang = -1, _colon = -1;
+        for (var _k = 0; _k < _ft.length; _k++) {
+            var _fc = _ft[_k];
+            if (_fc === '{') { while (_k < _ft.length && _ft[_k] !== '}') _k++; }
+            else if (_fc === '!' && _bang === -1 && _colon === -1) _bang = _k;
+            else if (_fc === ':' && _colon === -1) { _colon = _k; break; }
+        }
+
+        var _fname, _conv, _spec;
+        if (_bang !== -1 && (_colon === -1 || _bang < _colon)) {
+            _fname = _ft.slice(0, _bang);
+            _conv  = (_bang + 1 < _ft.length) ? _ft[_bang + 1] : null;
+            _spec  = _colon !== -1 ? _ft.slice(_colon + 1) : '';
+        } else if (_colon !== -1) {
+            _fname = _ft.slice(0, _colon);
+            _conv  = null;
+            _spec  = _ft.slice(_colon + 1);
+        } else {
+            _fname = _ft;
+            _conv  = null;
+            _spec  = '';
+        }
+
+        _items.push([_lit, _fname, _spec, _conv]);
+    }
+
+    return _items;
+}
+
+// get_field: resolve dotted/bracket access chain.  Returns [value, first_key].
+function _fmt_get_field(field_name, args, kwargs, self_obj) {
+    // Find first '.' or '['
+    var _fe = -1;
+    for (var _ci = 0; _ci < field_name.length; _ci++) {
+        var _cc = field_name[_ci];
+        if (_cc === '.' || _cc === '[') { _fe = _ci; break; }
+    }
+    var _fk = _fe === -1 ? field_name : field_name.slice(0, _fe);
+    var _rest = _fe === -1 ? '' : field_name.slice(_fe);
+
+    var _lookup_key = _str_is_digits_only(_fk) ? parseInt(_fk, 10) : _fk;
+    var _value = self_obj.get_value(_lookup_key, args, kwargs);
+
+    while (_rest.length > 0) {
+        if (_rest[0] === '.') {
+            var _de = _rest.length;
+            for (var _di2 = 1; _di2 < _rest.length; _di2++) {
+                if (_rest[_di2] === '.' || _rest[_di2] === '[') { _de = _di2; break; }
+            }
+            _value = _value[_rest.slice(1, _de)];
+            _rest = _rest.slice(_de);
+        } else if (_rest[0] === '[') {
+            var _cl = _rest.indexOf(']', 1);
+            if (_cl === -1) break;
+            var _idx = _rest.slice(1, _cl);
+            _value = _str_is_digits_only(_idx) ? _value[parseInt(_idx, 10)] : _value[_idx];
+            _rest = _rest.slice(_cl + 1);
+        } else {
+            break;
+        }
+    }
+
+    return [_value, _fk];
+}
+
+// vformat: render a format string, calling self_obj's methods for each field.
+function _fmt_vformat(fmt_str, args, kwargs, self_obj) {
+    var _items = _fmt_parse(fmt_str);
+    var _result = [];
+    var _auto_idx = 0, _auto_used = false, _manual_used = false;
+
+    for (var _ii = 0; _ii < _items.length; _ii++) {
+        var _item = _items[_ii];
+        var _lit2 = _item[0], _fname2 = _item[1], _spec2 = _item[2], _conv2 = _item[3];
+
+        if (_lit2) _result.push(_lit2);
+        if (_fname2 === null) continue;
+
+        // Auto-numbering vs manual
+        var _ename;
+        if (_fname2 === '') {
+            if (_manual_used) throw new ValueError('cannot switch from manual field specification to automatic field numbering');
+            _auto_used = true;
+            _ename = _auto_idx++;
+        } else if (_str_is_digits_only(_fname2)) {
+            if (_auto_used) throw new ValueError('cannot switch from automatic field numbering to manual field specification');
+            _manual_used = true;
+            _ename = parseInt(_fname2, 10);
+        } else {
+            // Named or complex field (e.g. "obj.attr" — let get_field handle it)
+            _ename = _fname2;
+        }
+
+        var _fr = self_obj.get_field(typeof _ename === 'number' ? String(_ename) : _ename, args, kwargs);
+        var _val2 = _fr[0];
+
+        if (_conv2 !== null) _val2 = self_obj.convert_field(_val2, _conv2);
+
+        // Resolve nested format specs (e.g. {:{}f})
+        var _rspec = _spec2;
+        if (_spec2 && _spec2.indexOf('{') !== -1) {
+            _rspec = _fmt_vformat(_spec2, args, kwargs, self_obj);
+        }
+
+        _result.push(self_obj.format_field(_val2, _rspec));
+    }
+
+    return _result.join('');
+}
+"""
+
+
+# ---------------------------------------------------------------------------
+# Template
+# ---------------------------------------------------------------------------
+
+class Template:
+    """String template with $-based substitution."""
+    delimiter     = '$'
+    idpattern     = '(?-i:[_a-zA-Z][_a-zA-Z0-9]*)'
+    braceidpattern = None
+    flags         = 0  # re.IGNORECASE not used; provided for API compatibility
+
+    def __init__(self, template):
+        self.template = template
+
+    def substitute(self, mapping=None):
+        """Return a copy of the template with placeholders filled from *mapping*.
+
+        Raises KeyError for missing keys and ValueError for invalid placeholders.
+        *mapping* may be a plain dict or any object supporting key lookup.
+        """
+        m = v'_tmpl_to_plain(mapping)'
+        return v'_tmpl_substitute_impl(self.template, m, false)'
+
+    def safe_substitute(self, mapping=None):
+        """Like substitute(), but leaves unrecognised placeholders unchanged."""
+        m = v'_tmpl_to_plain(mapping)'
+        return v'_tmpl_substitute_impl(self.template, m, true)'
+
+
+# ---------------------------------------------------------------------------
+# Formatter
+# ---------------------------------------------------------------------------
+
+class Formatter:
+    """Customisable string formatter — the foundation behind str.format().
+
+    Subclass and override format_field / convert_field / get_value / get_field
+    to change formatting behaviour.
+
+    Note: format() only accepts positional *args.  For named-field substitution
+    call vformat(fmt, [], {'key': value}) directly.
+    """
+
+    def format(self, format_string, *args):
+        """Format *format_string* using positional *args*."""
+        return self.vformat(format_string, list(args), {})
+
+    def vformat(self, format_string, args, kwargs):
+        """Format *format_string* with explicit *args* list and *kwargs* dict."""
+        return v'_fmt_vformat(format_string, args, kwargs, self)'
+
+    def parse(self, format_string):
+        """Return a list of (literal_text, field_name, format_spec, conversion) tuples."""
+        return v'_fmt_parse(format_string)'
+
+    def get_value(self, key, args, kwargs):
+        """Retrieve a field value: integer key → args, string key → kwargs."""
+        is_int = jstype(key) is 'number'
+        is_int_str = not is_int and jstype(key) is 'string' and v'_str_is_digits_only(key)'
+        if is_int or is_int_str:
+            idx = key if is_int else int(key)
+            if idx < 0 or idx >= len(args):
+                raise IndexError('Replacement index ' + str(idx) + ' out of range for positional args tuple')
+            return args[idx]
+        val = v'_fmt_get_kwarg(kwargs, key)'
+        if val is undefined:
+            raise KeyError(key)
+        return val
+
+    def get_field(self, field_name, args, kwargs):
+        """Look up *field_name* (may include dotted/bracket access).
+
+        Returns (value, first_key_used).
+        """
+        return v'_fmt_get_field(field_name, args, kwargs, self)'
+
+    def convert_field(self, value, conversion):
+        """Apply a conversion specifier (!s, !r, !a) to *value*."""
+        if conversion is None or conversion is undefined:
+            return value
+        if conversion == 's':
+            return str(value)
+        if conversion == 'r':
+            return repr(value)
+        if conversion == 'a':
+            return repr(value)
+        raise ValueError('Unknown conversion specifier: ' + str(conversion))
+
+    def format_field(self, value, format_spec):
+        """Format a single *value* according to *format_spec*."""
+        if format_spec is not None and format_spec is not undefined and format_spec:
+            return format(value, format_spec)
+        return str(value)

package/src/lib/textwrap.pyj

@@ -0,0 +1,329 @@
+###########################################################
+# RapydScript Standard Library
+# License: Apache License 2.0
+# This library is covered under Apache license, so that
+# you can distribute it with your RapydScript applications.
+###########################################################
+
+# Python-compatible textwrap module.
+#
+# Provides:
+#   TextWrapper class with .wrap(text), .fill(text)
+#   wrap(text[, width=70[, ...]])
+#   fill(text[, width=70[, ...]])
+#   shorten(text, width[, ...])
+#   dedent(text)
+#   indent(text, prefix[, predicate])
+#
+# All TextWrapper options supported:
+#   width, initial_indent, subsequent_indent, expand_tabs, tabsize,
+#   replace_whitespace, fix_sentence_endings, break_long_words,
+#   break_on_hyphens, drop_whitespace, max_lines, placeholder
+#
+# Notes:
+#   - break_on_hyphens=True (default) splits on em-dashes (2+ hyphens)
+#     between word characters, matching Python 3 behaviour.
+#   - shorten() normalises internal whitespace before truncating.
+
+v"""
+// ── textwrap internal helpers ────────────────────────────────────────────────
+
+function _tw_expand_tabs(text, tabsize) {
+    var _res = '';
+    var _col = 0;
+    for (var _i = 0; _i < text.length; _i++) {
+        var _c = text[_i];
+        if (_c === '\t') {
+            var _n = tabsize - (_col % tabsize);
+            for (var _j = 0; _j < _n; _j++) _res += ' ';
+            _col += _n;
+        } else {
+            _res += _c;
+            if (_c === '\n' || _c === '\r') _col = 0; else _col++;
+        }
+    }
+    return _res;
+}
+
+// Split into alternating non-whitespace / whitespace chunks.
+// break_on_hyphens: also split around em-dashes (2+ hyphens) between word chars.
+function _tw_split_chunks(text, break_on_hyphens) {
+    var _re = break_on_hyphens
+        ? /(\s+|(?<=[\w!"'&.,?])-{2,}(?=\w))/g
+        : /(\s+)/g;
+    var _chunks = [];
+    var _last = 0;
+    var _m;
+    while ((_m = _re.exec(text)) !== null) {
+        if (_m.index > _last) _chunks.push(text.slice(_last, _m.index));
+        _chunks.push(_m[0]);
+        _last = _re.lastIndex;
+    }
+    if (_last < text.length) _chunks.push(text.slice(_last));
+    return _chunks;
+}
+
+function _tw_fix_sentence_endings(chunks) {
+    var _re = /[a-z][.!?]$/;
+    for (var _i = 0; _i < chunks.length - 1; _i++) {
+        if (chunks[_i + 1] === ' ' && _re.test(chunks[_i])) {
+            chunks[_i + 1] = '  ';
+            _i++;
+        }
+    }
+}
+
+function _tw_handle_long_word(chunks, cur_line, cur_len, avail, break_long_words) {
+    var _space = avail > 0 ? avail - cur_len : 1;
+    if (break_long_words) {
+        var _word = chunks[chunks.length - 1];
+        if (_space > 0) {
+            cur_line.push(_word.slice(0, _space));
+            chunks[chunks.length - 1] = _word.slice(_space);
+        }
+        if (chunks[chunks.length - 1] === '') chunks.pop();
+    } else if (!cur_line.length) {
+        cur_line.push(chunks.pop());
+    }
+}
+
+function _tw_wrap_chunks(chunks, width, initial_indent, subsequent_indent,
+                         drop_whitespace, break_long_words, max_lines, placeholder) {
+    var _lines = [];
+    // Reverse so Array.pop() reads chunks left-to-right.
+    chunks = chunks.slice().reverse();
+
+    while (chunks.length > 0) {
+        var _cur_line = [];
+        var _cur_len  = 0;
+        var _indent   = _lines.length > 0 ? subsequent_indent : initial_indent;
+        var _avail    = width - _indent.length;
+
+        // Drop leading whitespace on continuation lines.
+        if (drop_whitespace && _lines.length > 0 &&
+            chunks.length > 0 && chunks[chunks.length - 1].trim() === '') {
+            chunks.pop();
+        }
+        if (chunks.length === 0) break;
+
+        // Fill the current line.
+        while (chunks.length > 0) {
+            var _l = chunks[chunks.length - 1].length;
+            if (_cur_len + _l <= _avail) {
+                _cur_len += _l;
+                _cur_line.push(chunks.pop());
+            } else {
+                break;
+            }
+        }
+
+        // Handle a word longer than the available width.
+        if (chunks.length > 0 && chunks[chunks.length - 1].length > _avail) {
+            _tw_handle_long_word(chunks, _cur_line, _cur_len, _avail, break_long_words);
+            _cur_len = 0;
+            for (var _ci = 0; _ci < _cur_line.length; _ci++) _cur_len += _cur_line[_ci].length;
+        }
+
+        // Drop trailing whitespace.
+        if (drop_whitespace && _cur_line.length > 0 &&
+            _cur_line[_cur_line.length - 1].trim() === '') {
+            _cur_len -= _cur_line[_cur_line.length - 1].length;
+            _cur_line.pop();
+        }
+
+        if (_cur_line.length > 0) {
+            var _will_be_last = chunks.length === 0 ||
+                (drop_whitespace && chunks.length === 1 && chunks[0].trim() === '');
+
+            if (max_lines === null || max_lines === undefined ||
+                _lines.length + 1 < max_lines ||
+                (_will_be_last && _cur_len <= _avail)) {
+                _lines.push(_indent + _cur_line.join(''));
+            } else {
+                // Truncate current line to fit placeholder.
+                var _done = false;
+                while (_cur_line.length > 0) {
+                    var _tok = _cur_line[_cur_line.length - 1];
+                    if (_tok.trim() !== '' && _cur_len + placeholder.length <= _avail) {
+                        _lines.push(_indent + _cur_line.join('') + placeholder);
+                        _done = true;
+                        break;
+                    }
+                    _cur_len -= _tok.length;
+                    _cur_line.pop();
+                }
+                if (!_done) {
+                    if (_lines.length > 0) {
+                        var _prev = _lines[_lines.length - 1].replace(/\s+$/, '');
+                        if (_prev.length + placeholder.length <= width) {
+                            _lines[_lines.length - 1] = _prev + placeholder;
+                        } else {
+                            _lines.push(_indent + placeholder.replace(/^\s+/, ''));
+                        }
+                    } else {
+                        _lines.push(_indent + placeholder.replace(/^\s+/, ''));
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return _lines;
+}
+
+function _tw_do_wrap(text, width, opts) {
+    var _ii  = opts.initial_indent    != null ? opts.initial_indent    : '';
+    var _si  = opts.subsequent_indent != null ? opts.subsequent_indent : '';
+    var _et  = opts.expand_tabs       != null ? opts.expand_tabs       : true;
+    var _ts  = opts.tabsize           != null ? opts.tabsize           : 8;
+    var _rw  = opts.replace_whitespace != null ? opts.replace_whitespace : true;
+    var _fse = opts.fix_sentence_endings != null ? opts.fix_sentence_endings : false;
+    var _blw = opts.break_long_words  != null ? opts.break_long_words  : true;
+    var _boh = opts.break_on_hyphens  != null ? opts.break_on_hyphens  : true;
+    var _dw  = opts.drop_whitespace   != null ? opts.drop_whitespace   : true;
+    var _ml  = opts.max_lines         != null ? opts.max_lines         : null;
+    var _ph  = opts.placeholder       != null ? opts.placeholder       : ' [...]';
+
+    if (_et) text = _tw_expand_tabs(text, _ts);
+    if (_rw) text = text.replace(/[\t\n\x0b\x0c\r]/g, ' ');
+
+    var _chunks = _tw_split_chunks(text, _boh);
+    if (_fse) _tw_fix_sentence_endings(_chunks);
+
+    return _tw_wrap_chunks(_chunks, width, _ii, _si, _dw, _blw, _ml, _ph);
+}
+
+function _tw_do_fill(text, width, opts) {
+    return _tw_do_wrap(text, width, opts).join('\n');
+}
+
+function _tw_shorten(text, width, opts) {
+    text = text.trim().split(/\s+/).join(' ');
+    // Build a copy of opts with max_lines forced to 1.
+    var _sopts = {};
+    for (var _k in opts) {
+        if (Object.prototype.hasOwnProperty.call(opts, _k)) _sopts[_k] = opts[_k];
+    }
+    _sopts.max_lines = 1;
+    if (_sopts.placeholder === null || _sopts.placeholder === undefined) {
+        _sopts.placeholder = ' [...]';
+    }
+    return _tw_do_fill(text, width, _sopts);
+}
+
+function _tw_dedent(text) {
+    var _lines  = text.split('\n');
+    var _margin = null;
+    for (var _i = 0; _i < _lines.length; _i++) {
+        var _line = _lines[_i];
+        if (_line.trim() === '') continue;
+        var _m = /^(\s+)\S/.exec(_line);
+        if (_m) {
+            var _ind = _m[1];
+            if (_margin === null) {
+                _margin = _ind;
+            } else {
+                var _j = 0;
+                while (_j < _margin.length && _j < _ind.length && _margin[_j] === _ind[_j]) _j++;
+                _margin = _margin.slice(0, _j);
+            }
+        } else {
+            _margin = '';
+        }
+        if (_margin === '') break;
+    }
+    if (!_margin) return text;
+    var _result = [];
+    for (var _i2 = 0; _i2 < _lines.length; _i2++) {
+        var _l = _lines[_i2];
+        _result.push(_l.slice(0, _margin.length) === _margin ? _l.slice(_margin.length) : _l);
+    }
+    return _result.join('\n');
+}
+
+function _tw_indent(text, prefix, predicate) {
+    var _lines  = text.split('\n');
+    var _result = [];
+    var _use_default = (predicate === null || predicate === undefined);
+    for (var _i = 0; _i < _lines.length; _i++) {
+        var _line = _lines[_i];
+        var _add  = _use_default ? _line.trim() !== '' : predicate(_line);
+        _result.push(_add ? prefix + _line : _line);
+    }
+    return _result.join('\n');
+}
+"""
+
+
+class TextWrapper:
+    def __init__(self, width=70, initial_indent='', subsequent_indent='',
+                 expand_tabs=True, tabsize=8, replace_whitespace=True,
+                 fix_sentence_endings=False, break_long_words=True,
+                 break_on_hyphens=True, drop_whitespace=True,
+                 max_lines=None, placeholder=' [...]'):
+        self.width                = width
+        self.initial_indent       = initial_indent
+        self.subsequent_indent    = subsequent_indent
+        self.expand_tabs          = expand_tabs
+        self.tabsize              = tabsize
+        self.replace_whitespace   = replace_whitespace
+        self.fix_sentence_endings = fix_sentence_endings
+        self.break_long_words     = break_long_words
+        self.break_on_hyphens     = break_on_hyphens
+        self.drop_whitespace      = drop_whitespace
+        self.max_lines            = max_lines
+        self.placeholder          = placeholder
+
+    def wrap(self, text):
+        return v'_tw_do_wrap(text, this.width, this)'
+
+    def fill(self, text):
+        return v'_tw_do_fill(text, this.width, this)'
+
+
+def wrap(text, width=70, initial_indent='', subsequent_indent='',
+         expand_tabs=True, tabsize=8, replace_whitespace=True,
+         fix_sentence_endings=False, break_long_words=True,
+         break_on_hyphens=True, drop_whitespace=True,
+         max_lines=None, placeholder=' [...]'):
+    return TextWrapper(
+        width, initial_indent, subsequent_indent, expand_tabs,
+        tabsize, replace_whitespace, fix_sentence_endings,
+        break_long_words, break_on_hyphens, drop_whitespace,
+        max_lines, placeholder
+    ).wrap(text)
+
+
+def fill(text, width=70, initial_indent='', subsequent_indent='',
+         expand_tabs=True, tabsize=8, replace_whitespace=True,
+         fix_sentence_endings=False, break_long_words=True,
+         break_on_hyphens=True, drop_whitespace=True,
+         max_lines=None, placeholder=' [...]'):
+    return TextWrapper(
+        width, initial_indent, subsequent_indent, expand_tabs,
+        tabsize, replace_whitespace, fix_sentence_endings,
+        break_long_words, break_on_hyphens, drop_whitespace,
+        max_lines, placeholder
+    ).fill(text)
+
+
+def shorten(text, width, initial_indent='', subsequent_indent='',
+            expand_tabs=True, tabsize=8, replace_whitespace=True,
+            fix_sentence_endings=False, break_long_words=True,
+            break_on_hyphens=True, drop_whitespace=True,
+            placeholder=' [...]'):
+    opts = TextWrapper(
+        width, initial_indent, subsequent_indent, expand_tabs,
+        tabsize, replace_whitespace, fix_sentence_endings,
+        break_long_words, break_on_hyphens, drop_whitespace,
+        None, placeholder
+    )
+    return v'_tw_shorten(text, width, opts)'
+
+
+def dedent(text):
+    return v'_tw_dedent(text)'
+
+
+def indent(text, prefix, predicate=None):
+    return v'_tw_indent(text, prefix, predicate)'

package/src/lib/urllib/__init__.pyj

@@ -0,0 +1,14 @@
+###########################################################
+# RapydScript Standard Library
+# urllib — URL handling utilities
+###########################################################
+#
+# Sub-modules:
+#   urllib.parse   — URL parsing and encoding (urlparse, quote, urlencode, …)
+#   urllib.request — HTTP requests via fetch (urlopen)
+#   urllib.error   — URLError, HTTPError exception classes
+#
+# Usage:
+#   from urllib.parse   import urlparse, quote, unquote, urlencode, urljoin
+#   from urllib.request import urlopen
+#   from urllib.error   import URLError, HTTPError