rapydscript-ns 0.9.3 → 0.9.4

package/README.md

@@ -1381,19 +1381,28 @@ ba += bytearray([7, 8])       # in-place concatenation
 
 RapydScript provides a `long` builtin backed by JavaScript's native `BigInt`,
 giving you arbitrary-precision integers beyond the safe range of JS `Number`.
+You can use the `long()` function or Python-style `n` suffix literals:
 
 ```python
+# Literal syntax (preferred)
+a = 10n
+b = 3n
+c = 0xFFn        # hex
+d = 0b1010n      # binary
+e = 0o77n        # octal
+
+# Function syntax
 a = long(10)
 b = long(3)
 
-a + b           # long(13)
-a - b           # long(7)
-a * b           # long(30)
-a // b          # long(3)   — floor division (Python semantics, not JS truncation)
-a % b           # long(1)   — Python-style modulo (result has same sign as divisor)
-a ** b          # long(1000)
-long(-7) // long(2)   # long(-4)  — floors toward −∞ (JS BigInt would give −3)
-long(-7) % long(3)    # long(2)   — result matches sign of divisor
+a + b           # 13n
+a - b           # 7n
+a * b           # 30n
+a // b          # 3n    — floor division (Python semantics, not JS truncation)
+a % b           # 1n    — Python-style modulo (result has same sign as divisor)
+a ** b          # 1000n
+long(-7) // long(2)   # -4n  — floors toward −∞ (JS BigInt would give −3)
+long(-7) % long(3)    # 2n   — result matches sign of divisor
 ```
 
 #### Precision beyond JS Number
@@ -1402,9 +1411,13 @@ The main motivation for `long` is numbers outside the safe integer range of
 JavaScript `Number` (`2^53 − 1 = 9007199254740991`):
 
 ```python
-n = long('9007199254740993')  # 2^53 + 1 — cannot be represented as a JS Number
-str(n)                        # '9007199254740993'  (exact)
-str(n + long(1))              # '9007199254740994'  (still exact)
+n = 9007199254740993n   # 2^53 + 1 — cannot be represented as a JS Number
+str(n)                  # '9007199254740993'  (exact)
+str(n + 1n)             # '9007199254740994'  (still exact)
+
+# equivalent using long():
+n = long('9007199254740993')
+str(n + long(1))
 ```
 
 #### Operator overloading
@@ -3455,7 +3468,7 @@ One of Python's main strengths is the number of libraries available to the devel
 	                    # fields(), asdict(), astuple(), replace(), is_dataclass(), frozen=True, order=True
 	abc                 # ABC base class, @abstractmethod, Protocol, @runtime_checkable;
 	                    # abstract enforcement at instantiation; ABC.register() virtual subclasses
-	collections         # namedtuple, deque, Counter, OrderedDict, defaultdict
+	collections         # namedtuple, deque, Counter, OrderedDict, defaultdict, ChainMap
 	copy                # copy (shallow), deepcopy; honours __copy__ / __deepcopy__ hooks
 	typing              # TYPE_CHECKING, Any, Union, Optional, List, Dict, Set, Tuple, TypeVar,
 	                    # Generic, Protocol, Callable, Literal, Final, TypedDict, NamedTuple,
@@ -3465,6 +3478,8 @@ One of Python's main strengths is the number of libraries available to the devel
 	                    # product, permutations, combinations, combinations_with_replacement
 	io                  # StringIO (in-memory text stream), BytesIO (in-memory binary stream)
 	base64              # b64encode/decode, urlsafe_b64encode/decode, b32encode/decode, b16encode/decode, encodebytes/decodebytes
+	statistics          # mean, median, mode, variance, stdev, quantiles, correlation,
+	                    # linear_regression, NormalDist
 
 For the most part, the logic implemented in these libraries functions identically to the Python versions. I'd be happy to include more libraries, if other members of the community want them. However, unlike most other Python-to-JavaScript compilers, RapydScript doesn't need them to be complete since there are already tons of available JavaScript libraries that it can use natively.
 
@@ -4044,6 +4059,7 @@ Python Feature Coverage
 | f-strings, `str.format()`, `format()` builtin, all common `str.*` methods                                                                                                                                                                                     | Fully supported; includes `f'{x=}'` debug format (prints `x=<value>`), format-spec (`f'{x=:.2f}'`), and conversion (`f'{x=!r}'`) |
 | `abs()`, `divmod()`, `any()`, `all()`, `sum()`, `min()`, `max()`                                                                                                                                                                                              | All work |
 | `sorted()`, `reversed()`, `zip()`, `map()`, `filter()`                                                                                                                                                                                                        | All work |
+| `list.sort()` / `sorted()` — `key`, `reverse`, comparators, `__lt__`                                                                                                                                                                                          | `key` and `reverse` keyword arguments both work; a positional **two-argument** function is auto-detected as a comparator (JS-style `.sort((a, b) => …)` / `functools.cmp_to_key` semantics) while a one-argument function is treated as a `key`; custom objects are ordered through their `__lt__` method (with a reflected `__gt__` fallback); the sort is stable, so equal elements keep their original order even under `reverse=True` |
 | `zip(strict=True)`                                                                                                                                                                                                                                            | Raises `ValueError` when iterables have different lengths; equal-length iterables work normally |
 | `set` with full union/intersection/difference API                                                                                                                                                                                                             | Fully supported |
 | `isinstance()`, `hasattr()`, `getattr()`, `setattr()`, `dir()`                                                                                                                                                                                                | All work |
@@ -4078,7 +4094,7 @@ Python Feature Coverage
 | `float.is_integer()`                                                                                                                                                                                                                                          | Returns `True` if the float has no fractional part (i.e. is a whole number), `False` otherwise. `float('inf').is_integer()` and `float('nan').is_integer()` both return `False`, matching Python semantics. Added to `Number.prototype` in the baselib so it works on any numeric literal or variable. |
 | `int.bit_length()`                                                                                                                                                                                                                                            | Returns the number of bits needed to represent the integer in binary, excluding the sign and leading zeros. `(0).bit_length()` → `0`; `(255).bit_length()` → `8`; `(256).bit_length()` → `9`; sign is ignored (`(-5).bit_length()` → `3`). Added to `Number.prototype` in the baselib. |
 | Arithmetic type coercion — `TypeError` on incompatible operands                                                                                                                                                                                               | `1 + '1'` raises `TypeError: unsupported operand type(s) for +: 'int' and 'str'`; all arithmetic operators (`+`, `-`, `*`, `/`, `//`, `%`, `**`) enforce compatible types in their `ρσ_op_*` helpers. `bool` is treated as numeric (like Python's `int` subclass). Activated by `overload_operators` (on by default). String `+` string and numeric `+` numeric are allowed; mixed types raise `TypeError` with a Python-style message. |
-| `long(val[, base])` — arbitrary-precision integers                                                                                                                                                                                                            | Backed by JS `BigInt`. `long(42)`, `long('ff', 16)`, `long('1010', 2)`, `long(True)`. Arithmetic: `+`, `-`, `*`, `//`, `%`, `**` — `//` and `%` follow Python floor-division semantics (floor toward −∞), not JS BigInt truncation. `/` raises `TypeError` (use `//`). Bitwise: `&`, `\|`, `^`, `<<`, `>>`. Comparisons: `<`, `<=`, `>`, `>=`, `==`, `!=`. `isinstance(x, long)` works. Mixing `long` with `int` or `float` raises `TypeError`. Requires `BigInt` (Chrome 67+, Firefox 68+, Safari 14+, Node 10.3+). |
+| `long(val[, base])` and `42n` literal — arbitrary-precision integers                                                                                                                                                                                          | Backed by JS `BigInt`. Literal syntax: `42n`, `0xFFn`, `0b1010n`, `0o77n`. Function syntax: `long(42)`, `long('ff', 16)`, `long('1010', 2)`, `long(True)`. Arithmetic: `+`, `-`, `*`, `//`, `%`, `**` — `//` and `%` follow Python floor-division semantics (floor toward −∞), not JS BigInt truncation. `/` raises `TypeError` (use `//`). Bitwise: `&`, `\|`, `^`, `<<`, `>>`. Comparisons: `<`, `<=`, `>`, `>=`, `==`, `!=`. `isinstance(x, long)` works. Mixing `long` with `int` or `float` raises `TypeError`. Requires `BigInt` (Chrome 67+, Firefox 68+, Safari 14+, Node 10.3+). |
 | `complex(real=0, imag=0)` and complex literals `3+4j`                                                                                                                                                                                                         | Full complex number type via `ρσ_complex` class. `complex(real, imag)`, `complex(string)` (parses `'3+4j'`), and `j`/`J` imaginary literal suffix (e.g. `4j`, `3.5J`). Attributes: `.real`, `.imag`. Methods: `conjugate()`, `__abs__()`, `__bool__()`, `__repr__()`, `__str__()`. Arithmetic: `+`, `-`, `*`, `/`, `**` via dunder methods (or operator overloading with `overload_operators`). `abs(z)` dispatches `__abs__`. `isinstance(z, complex)` works. String representation matches Python: `(3+4j)`, `4j`, `(3-0j)`. |
 | `eval(expr[, globals[, locals]])`                                                                                                                                                                                                                             | String literals are compiled as **RapydScript source** at compile time (the compiler parses and transpiles the string, just like Python's `eval` takes Python source). `eval(expr)` maps to native JS direct `eval` for scope access. `eval(expr, globals)` / `eval(expr, globals, locals)` use `Function` constructor with explicit bindings; `locals` override `globals`. Runtime `ρσ_` helpers referenced in the compiled string are automatically injected into the Function scope. Only string *literals* are transformed at compile time; dynamic strings are passed through unchanged. |
 | `exec(code[, globals[, locals]])`                                                                                                                                                                                                                             | String literals are compiled as **RapydScript source** at compile time. Executes the compiled code string; always returns `None`. Without `globals`/`locals` uses native `eval` (scope access). With `globals`/`locals` uses `Function` constructor — mutable objects (lists, dicts) passed in `globals` are accessible by reference, so side-effects are visible after the call. `ρσ_dict` instances (created when `dict_literals` flag is active) are correctly unwrapped via their `jsmap` backing store. |
@@ -4163,7 +4179,7 @@ Modules with a `src/lib/` implementation available are marked ✅. All others ar
 | `random`      | ✅           | RC4-seeded PRNG in `src/lib/random.pyj`                                                       |
 | `re`          | ✅           | Regex wrapper in `src/lib/re.pyj`; uses the JS engine — full PCRE-level support on modern runtimes: positive/negative lookbehind (ES2018+, including variable-width), unicode via automatic `u` flag (ES2015+), `re.fullmatch()`, `re.S`/`re.NOFLAG` aliases. `MatchObject.start()`/`.end()` return exact positions on runtimes with the ES2022 `d` flag (Node 18+); heuristic fallback on older runtimes. Conditional groups `(?(id)yes\|no)` are not supported (JS limitation) and raise `re.error`. |
 | `encodings`   | ✅           | UTF-8 encode/decode helpers and low-level base64 utilities; for the standard Python API use the `base64` module instead |
-| `collections` | ✅           | `defaultdict`, `Counter`, `OrderedDict`, `deque`                                              |
+| `collections` | ✅           | `defaultdict`, `Counter`, `OrderedDict`, `deque`, `namedtuple`, `ChainMap`                     |
 | `functools`   | ✅           | `reduce`, `partial`, `wraps`, `lru_cache`                                                     |
 | `itertools`   | ✅           | Common iteration tools                                                                        |
 | `numpy`       | ✅           | Full numpy-like library in `src/lib/numpy.pyj`; `numpy.random` and `numpy.linalg` sub-modules |
@@ -4187,11 +4203,15 @@ Modules with a `src/lib/` implementation available are marked ✅. All others ar
 | `textwrap`    | ✅           | `wrap(text[, width=70[, ...]])`, `fill(text[, width=70[, ...]])`, `shorten(text, width[, ...])`, `dedent(text)`, `indent(text, prefix[, predicate])`, `TextWrapper` class in `src/lib/textwrap.pyj`; `TextWrapper` supports all standard options: `width`, `initial_indent`, `subsequent_indent`, `expand_tabs`, `tabsize`, `replace_whitespace`, `fix_sentence_endings`, `break_long_words`, `break_on_hyphens`, `drop_whitespace`, `max_lines`, `placeholder`; module-level `wrap`/`fill`/`shorten` accept the same options as explicit keyword parameters; `shorten()` normalises internal whitespace before truncating; `break_on_hyphens=True` (default) splits on em-dashes (2+ hyphens) between word characters, matching Python 3 behaviour |
 | `logging`     | ✅           | `getLogger(name)`, `basicConfig(**kwargs)`, `debug/info/warning/error/critical/exception/log()` module-level shortcuts, `disable(level)`, `addLevelName(level, name)`, `getLevelName(level)`, `captureWarnings(capture)`, `makeLogRecord(dict)`, `setLogRecordFactory(factory)`, `getLogRecordFactory()` in `src/lib/logging.pyj`; `Logger` class with `setLevel`, `isEnabledFor`, `getEffectiveLevel`, `addHandler`, `removeHandler`, `hasHandlers`, `addFilter`, `removeFilter`, `debug/info/warning/error/critical/exception/log` methods; `Handler` base class; `StreamHandler(stream=None)` (writes to `console.debug/info/warn/error` when no stream given, or to any object with `.write(s)`); `NullHandler`; `Formatter(fmt, datefmt, style)` with full `%(attr)s/d/f` record formatting and `formatTime(record, datefmt)` (supports `%Y %m %d %H %M %S %f` strftime codes); `Filter(name)` and `Filterer` mixin; `LogRecord` with `getMessage()` supporting `%s/%d/%f/%e/%g/%x/%o/%%` %-formatting; level constants `NOTSET=0`, `DEBUG=10`, `INFO=20`, `WARNING=30`, `ERROR=40`, `CRITICAL=50`; full logger hierarchy (dotted names, `propagate`, `parent`); `lastResort` handler; note: `FileHandler` raises `NotImplementedError` (no file I/O in JS); `exception()` logs at ERROR without automatic exc_info capture |
 | `heapq`       | ✅           | `heappush(heap, item)`, `heappop(heap)`, `heapify(x)`, `heapreplace(heap, item)`, `heappushpop(heap, item)`, `nsmallest(n, iterable[, key])`, `nlargest(n, iterable[, key])` in `src/lib/heapq.pyj`; min-heap operations on plain lists; heap invariant maintained by sift-up/sift-down (ported from CPython); `nsmallest`/`nlargest` support an optional `key` function; `heappop` and `heapreplace` raise `IndexError` on an empty heap; original iterable is not mutated by `nsmallest`/`nlargest` |
+| `pprint`      | ✅           | `pformat(object, ...)` → str, `pprint(object[, stream], ...)`, `pp(object, ...)` (same as `pprint` but `sort_dicts=False` by default), `saferepr(object)`, `isreadable(object)`, `isrecursive(object)`, `PrettyPrinter` class in `src/lib/pprint.pyj`; keyword options `indent` (default 1), `width` (default 80), `depth`, `compact`, `sort_dicts` (default True), `underscore_numbers` (accepted, currently a no-op); a value's `repr()` is used when it fits within `width`, otherwise lists/tuples/dicts/sets/frozensets are broken across multiple lines with Python-style indentation; recursive references are detected and rendered as `<Recursion on … with id=…>`; pretty-prints RapydScript `dict`/`set`/`frozenset`, plain JS objects, and arrays; `pprint`/`pp` write to a `stream` object's `.write()` (defaulting to stdout via `print()`) |
+| `statistics`  | ✅           | `mean`, `fmean`, `geometric_mean`, `harmonic_mean`, `median`, `median_low`, `median_high`, `median_grouped`, `mode`, `multimode`, `variance`, `pvariance`, `stdev`, `pstdev`, `quantiles`, `covariance`, `correlation`, `linear_regression` in `src/lib/statistics.pyj`; `NormalDist` class (`.mean`/`.median`/`.mode`/`.stdev`/`.variance` properties, `pdf()`, `cdf()`, `inv_cdf()`, `quantiles()`, `zscore()`, `overlap()`, `samples(n[, seed])`, `from_samples()`, plus arithmetic with scalars and other `NormalDist` instances); `StatisticsError` (a `ValueError` subclass); every data argument may be a list, a JS array, a string, or any iterable; `correlation()` supports `method='ranked'` (Spearman); `quantiles()` supports `method='inclusive'`/`'exclusive'`; `linear_regression()` returns an object with `.slope`/`.intercept`; all computation is IEEE-754 double precision (no `Fraction`/`Decimal` preservation), and `cdf()`/`overlap()` use a rational error-function approximation accurate to ~1e-7 |
+| `decimal`     | ❌           | Fixed-precision decimal arithmetic not available; JS `Number` is IEEE-754 only                |
+| `fractions`   | ❌           | Rational arithmetic (`Fraction(num, den)`) not available                                      |
+| `difflib`     | ❌           | `unified_diff`, `SequenceMatcher`, `get_close_matches` not available                          |
 | `inspect`     | ❌           | `signature`, `getmembers`, `isfunction` etc. not available                                    |
 | `struct`      | ❌           | Binary packing/unpacking not available                                                        |
 | `hashlib`     | ❌           | MD5, SHA-256 etc. not available; use Web Crypto API via verbatim JS                           |
 | `hmac`        | ❌           | Keyed hashing not available                                                                   |
-| `pprint`      | ❌           | Pretty-printing not available                                                                 |
 | `unittest`    | ❌           | Not available; RapydScript uses a custom test runner (`node bin/rapydscript test`)            |
 
 ---

package/TODO.md

@@ -1,34 +1,9 @@
 
-### libraries
-
-- The 7n literal isn't supported by the parser — use BigInt()
 
 - remove repl_mode and make repl make a new context for each "run" press
 
 - vscode plugin based on language service?
 
 
-I would like you to add support for [python async def functions with yield (async generators)] to rapydscript. It should have the same syntax as the Python implementation, and be transpiled into equivalent javascript. Ensure with unit tests that it transpiles and the output JS runs correctly, and that the language service correctly handles it in parsed code. Make sure it works in the web-repl. Update the README if it has any outdated info about this, and the PYTHON_FEATURE_COVERAGE report. Add a simple example to the bottom of the TODO document using this feature (make no other changes to that file). Remove the suggestion from PYTHON_GAPS if it is there.
-
-### Async generator example
-
-```py
-# `async def` + `yield` makes an async generator. The function returns an
-# async iterator immediately; values are pulled with `await it.next()` or
-# consumed with `async for`.
-
-from asyncio import sleep
-
-async def countdown(n):
-    while n > 0:
-        await sleep(0)            # cooperative yield to the event loop
-        yield n
-        n -= 1
-
-async def main():
-    async for x in countdown(3):
-        print(x)                  # prints 3, then 2, then 1
-
-main()
-```
+I would like you to add support for [python 7n style literal] to rapydscript. It should have the same syntax as the Python implementation, and be transpiled into equivalent javascript. Ensure with unit tests that it transpiles and the output JS runs correctly, and that the language service correctly handles it in parsed code. Make sure it works in the web-repl. Update the README if it has any outdated info about this, and the PYTHON_FEATURE_COVERAGE report. Add a simple example to the bottom of the TODO document using this feature (make no other changes to that file). Remove the suggestion from PYTHON_GAPS if it is there.
 

package/add-toc-to-readme

@@ -1,2 +1,2 @@
-#!/bin/sh
-exec node_modules/doctoc/doctoc.js --title '**Contents**' README.md
+#!/bin/sh
+exec node_modules/doctoc/doctoc.js --title '**Contents**' README.md

package/bin/export

@@ -1,75 +1,75 @@
-#!/usr/bin/env node 
-// vim:ft=javascript:ts=4:et
-
-"use strict";
-
-var fs = require('fs');
-var path = require('path');
-var crypto = require('crypto');
-
-var base = path.join(path.dirname(__dirname));
-var meta = JSON.parse(fs.readFileSync(path.join(base, 'package.json'), {'encoding':'utf-8'}));
-var compiler_dir = path.join(base, 'dev');
-if (!path_exists(path.join(compiler_dir, 'compiler.js'))) compiler_dir = path.join(base, 'release');
-
-var manifest = {}, total = 0;
-['compiler.js', 'baselib-plain-pretty.js', 'baselib-plain-ugly.js'].forEach(function(x) {
-    manifest[x] = fs.readFileSync(path.join(compiler_dir, x), {'encoding':'utf-8'});
-    total += manifest[x].length;
-});
-
-['web_repl.js', 'repl.js', 'completer.js', 'utils.js', 'gettext.js', 'msgfmt.js'].forEach(function(x) {
-    x = 'tools/' + x;
-    manifest[x] = fs.readFileSync(path.join(base, x), {'encoding':'utf-8'});
-    total += manifest[x].length;
-});
-
-
-var dedup = {};
-
-function path_exists(path) {
-    try {
-        fs.statSync(path);
-        return true;
-    } catch(e) {
-        if (e.code != 'ENOENT') throw e;
-    }
-}
-
-function sha1sum(data) { 
-    var h = crypto.createHash('sha1');
-    h.update(data);
-    return h.digest('hex');
-}
-
-function process_dir(name) {
-    var dpath = path.join(base, name);
-    var items = fs.readdirSync(dpath);
-    items.forEach(function (x) {
-        var iname = name + '/' + x;
-        var ipath = path.join(dpath, x);
-        var s = fs.statSync(ipath);
-        if (s.isDirectory()) return process_dir(iname);
-        var raw = fs.readFileSync(ipath, {'encoding':'utf-8'});
-        var sig = sha1sum(raw);
-        if (dedup.hasOwnProperty(sig)) {
-            manifest[iname] = [dedup[sig]];
-        } else {
-            manifest[iname] = raw;
-            dedup[sig] = iname;
-            total += s.size;
-        }
-    });
-}
-
-Object.keys(meta.dependencies).forEach(function (x) {
-    process_dir('node_modules/' + x);
-});
-console.log('// vim:fileencoding=utf-8');
-console.log('(function() {');
-console.log('var rs_version = ' + JSON.stringify(meta.version) + ';');
-console.log('var data = ' + JSON.stringify(manifest) + ';');
-console.log();
-console.log(fs.readFileSync(path.join(base, 'tools', 'export.js'), {'encoding':'utf-8'}));
-console.log('})()');
-console.error('RapydScript compiler (uncompressed) size: ' + (total/(1024 * 1024)).toFixed(1) + ' MB');
+#!/usr/bin/env node 
+// vim:ft=javascript:ts=4:et
+
+"use strict";
+
+var fs = require('fs');
+var path = require('path');
+var crypto = require('crypto');
+
+var base = path.join(path.dirname(__dirname));
+var meta = JSON.parse(fs.readFileSync(path.join(base, 'package.json'), {'encoding':'utf-8'}));
+var compiler_dir = path.join(base, 'dev');
+if (!path_exists(path.join(compiler_dir, 'compiler.js'))) compiler_dir = path.join(base, 'release');
+
+var manifest = {}, total = 0;
+['compiler.js', 'baselib-plain-pretty.js', 'baselib-plain-ugly.js'].forEach(function(x) {
+    manifest[x] = fs.readFileSync(path.join(compiler_dir, x), {'encoding':'utf-8'});
+    total += manifest[x].length;
+});
+
+['web_repl.js', 'repl.js', 'completer.js', 'utils.js', 'gettext.js', 'msgfmt.js'].forEach(function(x) {
+    x = 'tools/' + x;
+    manifest[x] = fs.readFileSync(path.join(base, x), {'encoding':'utf-8'});
+    total += manifest[x].length;
+});
+
+
+var dedup = {};
+
+function path_exists(path) {
+    try {
+        fs.statSync(path);
+        return true;
+    } catch(e) {
+        if (e.code != 'ENOENT') throw e;
+    }
+}
+
+function sha1sum(data) { 
+    var h = crypto.createHash('sha1');
+    h.update(data);
+    return h.digest('hex');
+}
+
+function process_dir(name) {
+    var dpath = path.join(base, name);
+    var items = fs.readdirSync(dpath);
+    items.forEach(function (x) {
+        var iname = name + '/' + x;
+        var ipath = path.join(dpath, x);
+        var s = fs.statSync(ipath);
+        if (s.isDirectory()) return process_dir(iname);
+        var raw = fs.readFileSync(ipath, {'encoding':'utf-8'});
+        var sig = sha1sum(raw);
+        if (dedup.hasOwnProperty(sig)) {
+            manifest[iname] = [dedup[sig]];
+        } else {
+            manifest[iname] = raw;
+            dedup[sig] = iname;
+            total += s.size;
+        }
+    });
+}
+
+Object.keys(meta.dependencies).forEach(function (x) {
+    process_dir('node_modules/' + x);
+});
+console.log('// vim:fileencoding=utf-8');
+console.log('(function() {');
+console.log('var rs_version = ' + JSON.stringify(meta.version) + ';');
+console.log('var data = ' + JSON.stringify(manifest) + ';');
+console.log();
+console.log(fs.readFileSync(path.join(base, 'tools', 'export.js'), {'encoding':'utf-8'}));
+console.log('})()');
+console.error('RapydScript compiler (uncompressed) size: ' + (total/(1024 * 1024)).toFixed(1) + ' MB');

package/bin/web-repl-export

@@ -1,102 +1,102 @@
-#!/usr/bin/env node 
-// vim:ft=javascript:ts=4:et
-
-"use strict";
-
-var fs = require('fs');
-var path = require('path');
-
-var base = path.normalize(path.resolve(path.join(path.dirname(__dirname))));
-var meta = JSON.parse(fs.readFileSync(path.join(base, 'package.json'), {'encoding':'utf-8'}));
-var commit_sha = fs.readFileSync(path.join(base, '.git', 'refs', 'heads', 'master'), {'encoding':'utf-8'}).trim();
-var compiler_dir = path.join(base, 'dev');
-if (!path_exists(path.join(compiler_dir, 'compiler.js'))) compiler_dir = path.join(base, 'release');
-
-var manifest = {}, total = 0;
-['compiler.js', 'baselib-plain-pretty.js'].forEach(function(x) {
-    manifest[x] = fs.readFileSync(path.join(compiler_dir, x), {'encoding':'utf-8'});
-    total += manifest[x].length;
-});
-
-['web_repl.js', 'embedded_compiler.js', 'utils.js', 'completer.js', 'msgfmt.js', 'gettext.js'].forEach(function(x) {
-    x = 'tools/' + x;
-    manifest[x] = fs.readFileSync(path.join(base, x), {'encoding':'utf-8'});
-    total += manifest[x].length;
-});
-
-var stdlib = path.join(base, 'src', 'lib');
-
-function path_exists(path) {
-    try {
-        fs.statSync(path);
-        return true;
-    } catch(e) {
-        if (e.code != 'ENOENT') throw e;
-    }
-}
-
-function process_dir(relpath) {
-    var fullpath = (relpath) ? path.join(stdlib, relpath) : stdlib;
-    fs.readdirSync(fullpath).forEach(function (x) {
-        var q = path.join(fullpath, x);
-        var s = fs.statSync(q);
-        if (s.isDirectory()) return process_dir(relpath + '/' + x);
-        if (!x.endsWith('.pyj')) return;
-        var iname = ('__stdlib__' + '/' + relpath + '/' + x).replace(/\\/g, '/').replace(/\/+/g, '/');
-        var raw = fs.readFileSync(q, {'encoding':'utf-8'});
-        manifest[iname] = raw;
-        total += s.size;
-    });
-}
-process_dir('');
-
-
-var rs = '// vim:fileencoding=utf-8\n';
-rs += '(function(external_namespace) {\n';
-rs += '"use strict;"\n';
-rs += 'var rs_version = ' + JSON.stringify(meta.version) + ';\n';
-rs += 'var rs_commit_sha = ' + JSON.stringify(commit_sha) + ';\n';
-rs += '\n// Embedded modules {{{\n';
-rs += 'var data = ' + JSON.stringify(manifest) + ';\n\n';
-rs += '// End embedded modules }}}\n\n';
-rs += fs.readFileSync(path.join(base, 'web-repl', 'env.js'));
-rs += '\n// Embedded sha1 implementation {{{\n';
-rs += '(function() {\n';
-rs += fs.readFileSync(path.join(base, 'web-repl', 'sha1.js'));
-rs += '}).call(jsSHA);\n';
-rs += '// End embedded sha1 implementation }}}\n\n';
-rs += 'var exports = namespace;\n';
-rs += fs.readFileSync(path.join(base, 'tools', 'export.js'), {'encoding':'utf-8'});
-rs += 'external_namespace.RapydScript = namespace;\n';
-rs += '})(this);\n';
-
-
-var base_dir = process.argv.slice(-1)[0];
-if (process.argv.length !== 3) {
-    console.error('Usage: web-repl-export /path/to/export/directory');
-    process.exit(1);
-}
-
-base_dir = path.normalize(path.resolve(base_dir));
-
-try {
-    fs.mkdirSync(base_dir);
-} catch(e) {
-    if (e.code !== 'EEXIST') throw e;
-}
-
-try {
-    process.chdir(base_dir);
-} catch(e) {
-    if (e.code === 'ENOTDIR') { console.error(base_dir + ' is not a directory'); process.exit(1); }
-    throw e;
-}
-fs.writeFileSync('rapydscript.js', rs, {'encoding':'utf-8'});
-var web_repl = path.join(base, 'web-repl');
-fs.readdirSync(web_repl).forEach(function(x) {
-    if (['sha1.js', 'env.js'].indexOf(x) !== -1) return;
-    var data = fs.readFileSync(path.join(web_repl, x), {'encoding':'utf-8'});
-    fs.writeFileSync(x, data, {'encoding':'utf-8'});
-});
-console.log('RapydScript compiler (uncompressed) size: ' + (total/(1024)).toFixed(1) + ' KB');
-console.log('web-repl exported to: ' + base_dir);
+#!/usr/bin/env node 
+// vim:ft=javascript:ts=4:et
+
+"use strict";
+
+var fs = require('fs');
+var path = require('path');
+
+var base = path.normalize(path.resolve(path.join(path.dirname(__dirname))));
+var meta = JSON.parse(fs.readFileSync(path.join(base, 'package.json'), {'encoding':'utf-8'}));
+var commit_sha = fs.readFileSync(path.join(base, '.git', 'refs', 'heads', 'master'), {'encoding':'utf-8'}).trim();
+var compiler_dir = path.join(base, 'dev');
+if (!path_exists(path.join(compiler_dir, 'compiler.js'))) compiler_dir = path.join(base, 'release');
+
+var manifest = {}, total = 0;
+['compiler.js', 'baselib-plain-pretty.js'].forEach(function(x) {
+    manifest[x] = fs.readFileSync(path.join(compiler_dir, x), {'encoding':'utf-8'});
+    total += manifest[x].length;
+});
+
+['web_repl.js', 'embedded_compiler.js', 'utils.js', 'completer.js', 'msgfmt.js', 'gettext.js'].forEach(function(x) {
+    x = 'tools/' + x;
+    manifest[x] = fs.readFileSync(path.join(base, x), {'encoding':'utf-8'});
+    total += manifest[x].length;
+});
+
+var stdlib = path.join(base, 'src', 'lib');
+
+function path_exists(path) {
+    try {
+        fs.statSync(path);
+        return true;
+    } catch(e) {
+        if (e.code != 'ENOENT') throw e;
+    }
+}
+
+function process_dir(relpath) {
+    var fullpath = (relpath) ? path.join(stdlib, relpath) : stdlib;
+    fs.readdirSync(fullpath).forEach(function (x) {
+        var q = path.join(fullpath, x);
+        var s = fs.statSync(q);
+        if (s.isDirectory()) return process_dir(relpath + '/' + x);
+        if (!x.endsWith('.pyj')) return;
+        var iname = ('__stdlib__' + '/' + relpath + '/' + x).replace(/\\/g, '/').replace(/\/+/g, '/');
+        var raw = fs.readFileSync(q, {'encoding':'utf-8'});
+        manifest[iname] = raw;
+        total += s.size;
+    });
+}
+process_dir('');
+
+
+var rs = '// vim:fileencoding=utf-8\n';
+rs += '(function(external_namespace) {\n';
+rs += '"use strict;"\n';
+rs += 'var rs_version = ' + JSON.stringify(meta.version) + ';\n';
+rs += 'var rs_commit_sha = ' + JSON.stringify(commit_sha) + ';\n';
+rs += '\n// Embedded modules {{{\n';
+rs += 'var data = ' + JSON.stringify(manifest) + ';\n\n';
+rs += '// End embedded modules }}}\n\n';
+rs += fs.readFileSync(path.join(base, 'web-repl', 'env.js'));
+rs += '\n// Embedded sha1 implementation {{{\n';
+rs += '(function() {\n';
+rs += fs.readFileSync(path.join(base, 'web-repl', 'sha1.js'));
+rs += '}).call(jsSHA);\n';
+rs += '// End embedded sha1 implementation }}}\n\n';
+rs += 'var exports = namespace;\n';
+rs += fs.readFileSync(path.join(base, 'tools', 'export.js'), {'encoding':'utf-8'});
+rs += 'external_namespace.RapydScript = namespace;\n';
+rs += '})(this);\n';
+
+
+var base_dir = process.argv.slice(-1)[0];
+if (process.argv.length !== 3) {
+    console.error('Usage: web-repl-export /path/to/export/directory');
+    process.exit(1);
+}
+
+base_dir = path.normalize(path.resolve(base_dir));
+
+try {
+    fs.mkdirSync(base_dir);
+} catch(e) {
+    if (e.code !== 'EEXIST') throw e;
+}
+
+try {
+    process.chdir(base_dir);
+} catch(e) {
+    if (e.code === 'ENOTDIR') { console.error(base_dir + ' is not a directory'); process.exit(1); }
+    throw e;
+}
+fs.writeFileSync('rapydscript.js', rs, {'encoding':'utf-8'});
+var web_repl = path.join(base, 'web-repl');
+fs.readdirSync(web_repl).forEach(function(x) {
+    if (['sha1.js', 'env.js'].indexOf(x) !== -1) return;
+    var data = fs.readFileSync(path.join(web_repl, x), {'encoding':'utf-8'});
+    fs.writeFileSync(x, data, {'encoding':'utf-8'});
+});
+console.log('RapydScript compiler (uncompressed) size: ' + (total/(1024)).toFixed(1) + ' KB');
+console.log('web-repl exported to: ' + base_dir);

package/build

@@ -1,3 +1,3 @@
-#!/bin/sh
-exec bin/rapydscript self --complete --test
+#!/bin/sh
+exec bin/rapydscript self --complete --test
 exec bin/web-repl-export web-repl