rapydscript-ns 0.8.0

package/TODO.md

@@ -0,0 +1,327 @@
+
+### libraries
+- allow var etc as property name
+- revert numpy variance method to be var
+
+- omit_function_metadata breaks imports - it needs to be changed to only affect imported modules, maybe?
+
+- variables just say (variable) on hover, not their type?
+
+- vscode plugin based on language service
+
+- export language service to npm module
+- update url links
+- make npm module
+
+
+
+I would like you to add support for [  Python's extended subscript syntax where commas inside [] implicitly form a tuple ] to rapydscript. It should have the same syntax as the Python implementation, and be transpiled into equivalent javascript. Please ensure with unit tests that it transpiles and the output JS runs correctly, and that the language service correctly handles it in parsed code. Please make sure it works in the web-repl too. Please also update the README to mention this support.
+
+
+
+
+# 1. Placeholder body (like pass)
+def todo():
+  ...
+
+class MyProtocol:
+  def method(self) -> int: ...
+
+
+# 3. Sentinel / default marker
+_MISSING = ...
+
+def greet(name=...):                                    
+  if name is ...:                                   
+    name = "World"                                                                                                                                                                           
+  print(f"Hello, {name}!")
+
+greet()           # Hello, World!                                                                                                                                                                
+greet("Alice")    # Hello, Alice!
+
+
+# 4. NumPy-style slice shorthand (all leading dimensions)
+import numpy as np                                                                                                                                                                               
+arr = np.zeros((2, 3, 4))                                                                                                                                                                        
+print(arr[..., 0] )  # shape (2, 3) — first element of last axis                                                                                                                                        
+print(arr[1, ...])   # shape (3, 4) — entire second "sheet"
+
+# 5. Identity check
+print(... is ...)        # True  (singleton)                                                                                                                                                     
+print(... is Ellipsis)   # True                                                                                                                                                                  
+print(type(...).__name__) # ellipsis
+
+
+
+
+
+
+
+Python Feature Gap Report: RapydScript-NS
+
+Summary
+
+RapydScript-NS covers the vast majority of Python 2/3 core syntax well. The gaps fall into four categories: modern Python syntax, OOP/protocol features, standard library modules, and semantic  
+differences.
+
+  ---
+1. Modern Python Syntax (Not Supported)
+
+┌───────────────────────────────────────────────┬────────────────┬──────────────────────────────────────────────────────────────┐
+│                    Feature                    │ Python Version │                            Notes                             │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ match/case (structural pattern matching)      │ 3.10+          │ -tested                                                      │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Walrus operator :=                            │ 3.8+           │ -tested                                                      │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ lambda keyword                                │ all            │ -tested                                                      │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Variable type annotations x: int = 1          │ 3.6+           │ needs testing                                                │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Positional-only parameters (def f(a, /, b):)  │ 3.8+           │ -tested                                                      │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Keyword-only parameters (def f(a, *, b):)     │ 3.0+           │ -tested                                                      │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Starred assignment a, *b, c = [1,2,3,4,5]     │ 3.0+           │ -tested                                                      │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Dict merge literal {**d1, **d2}               │ 3.5+           │ -tested                                                      │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Parenthesized with (multi-context)            │ 3.10+          │  - doesn't make sense in a web context                       │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Exception chaining raise X from Y             │ 3.0+           │ Plain raise only                                             │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ except* (exception groups)                    │ 3.11+          │ No support                                                   │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Nested comprehensions (for a in b for c in d) │ all            │ -tested                                                      │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Complex number literals 3+4j                  │ all            │ No j suffix                                                  │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ Ellipsis literal ... as expression            │ all            │ Only valid as slice (a[...])                                 │
+├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
+│ b'...' bytes literals                         │ all            │ No b prefix; encoding module exists but no native bytes type │
+└───────────────────────────────────────────────┴────────────────┴──────────────────────────────────────────────────────────────┘
+
+  ---
+2. OOP and Dunder Protocol Gaps
+
+Not Supported at All
+
+┌─────────────────────────────────────────┬─────────────────────────────────────────────────────────────────┐
+│                 Feature                 │                              Notes                              │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ super()                                 │ -tested                                                         │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __new__                                 │ No alternative constructor support                              │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __del__                                 │ No destructor/finalizer                                         │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __hash__                                │ Explicitly noted as not implemented; set/dict uses === identity │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __bool__                                │ Empty [] and {} are truthy in JS (differs from Python)          │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __call__                                │ Objects cannot be made callable via dunder                      │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __getattr__ / __setattr__ / __delattr__ │ No attribute access interception                                │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __getattribute__                        │ No attribute lookup overriding                                  │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __format__                              │ No custom format() behavior                                     │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __slots__                               │ No slot declarations                                            │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __class_getitem__                       │ No MyClass[T] generic syntax support                            │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ __init_subclass__                       │ No subclass hooks                                               │
+├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
+│ classmethod decorator                   │ Not tested/documented (may partially work via @staticmethod)    │
+└─────────────────────────────────────────┴─────────────────────────────────────────────────────────────────┘
+
+Arithmetic/Comparison Operator Overloading
+
+All of these dunder methods are not dispatched — operators always use JS native semantics:
+
+__add__, __radd__, __sub__, __mul__, __truediv__, __floordiv__, __mod__, __pow__, __lt__, __le__, __gt__, __ge__, __ne__, __neg__, __pos__, __abs__, __invert__, __lshift__, __rshift__, __and__,
+__or__, __xor__
+
+(Only __eq__, __contains__, __iter__, __len__, __enter__, __exit__, __repr__, __str__ are dispatched)
+
+Nested Classes
+
+Noted in test file (test/classes.pyj) as "not yet fully implemented."
+
+Abstract Base Classes (ABCs)
+
+No abc module, no @abstractmethod, no Protocol support.
+
+  ---
+3. Built-in Functions Missing
+
+┌──────────────────────────┬────────────────────────────────────────────────┐
+│         Function         │                     Notes                      │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ super()                  │ tested                                         │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ issubclass()             │ Not implemented                                │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ hash()                   │ Not implemented                                │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ format(value, spec)      │ Not listed; str.format() works                 │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ vars()                   │ Not listed                                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ locals()                 │ Not listed                                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ globals()                │ Not listed                                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ exec()                   │ Not listed (JS eval works directly via v'...') │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ eval()                   │ Not listed                                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ compile()                │ N/A                                            │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ __import__()             │ Not supported                                  │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ input()                  │ Not built in                                   │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ open()                   │ Not built in                                   │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ bytes() / bytearray()    │ Not built in                                   │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ memoryview()             │ N/A (browser context)                          │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ zip(..., strict=True)    │ strict kwarg not supported                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ enumerate(x, start=N)    │ start parameter may not be supported           │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ all() / any()            │ tested                                         │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ next(iter, default?)     │ Not listed                                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ iter(callable, sentinel) │ Two-arg form likely not supported              │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ round(x, ndigits?)       │ Not listed                                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ slice()                  │ Not listed as builtin object                   │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ frozenset()              │ Not listed                                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ complex()                │ Not listed                                     │
+├──────────────────────────┼────────────────────────────────────────────────┤
+│ object()                 │ Not listed                                     │
+└──────────────────────────┴────────────────────────────────────────────────┘
+
+  ---
+4. Standard Library Modules Missing
+
+These are Python stdlib modules with no equivalent in src/lib/:
+
+┌─────────────┬─────────────────────────────────────────────────────────────────────────────────┐
+│   Module    │                                 What's Missing                                  │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ collections │ tested                                                                          │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ functools   │ tested                                                                          │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ itertools   │ tested                                                                          │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ typing      │ List, Dict, Optional, Union, Tuple, Generic, TypeVar, etc.                      │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ dataclasses │ @dataclass, field(), asdict(), astuple()                                        │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ contextlib  │ contextmanager, suppress, ExitStack, asynccontextmanager                        │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ copy        │ copy(), deepcopy()                                                              │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ string      │ Character constants, Template, Formatter                                        │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ json        │ dumps, loads (JS JSON works directly, but no Python wrapper)                    │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ datetime    │ date, time, datetime, timedelta                                                 │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ inspect     │ signature, getmembers, isfunction, etc.                                         │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ asyncio     │ Event loop, gather, sleep, Queue, Task wrappers                                 │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ enum        │ Enum, IntEnum, Flag                                                             │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ abc         │ ABC, abstractmethod                                                             │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ io          │ StringIO, BytesIO                                                               │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ struct      │ Binary packing/unpacking                                                        │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ hashlib     │ MD5, SHA-256, etc.                                                              │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ hmac        │ Keyed hashing                                                                   │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ base64      │ (partial — encodings module exists)                                             │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ urllib      │ URL parsing/encoding (no urllib.parse)                                          │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ html        │ escape, unescape                                                                │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ csv         │ CSV parsing                                                                     │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ textwrap    │ wrap, fill, dedent, indent                                                      │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ pprint      │ Pretty-printing                                                                 │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ logging     │ Logging framework                                                               │
+├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ unittest    │ Test framework (custom runner used instead)                                     │
+└─────────────┴─────────────────────────────────────────────────────────────────────────────────┘
+
+  ---
+5. Semantic Differences (Traps)
+
+These features exist but behave differently from Python:
+
+┌─────────────────────────┬────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────┐
+│         Feature         │              Python Behavior               │                              RapydScript Behavior                               │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ Truthiness of []        │ False                                      │ True (JS semantics)                                                             │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ Truthiness of {}        │ False                                      │ True (JS semantics)                                                             │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ is / is not             │ Object identity                            │ Strict equality === / !==                                                       │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ // on floats            │ math.floor(a/b)                            │ Correct for integers; JS Math.floor used                                        │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ % on negative numbers   │ Python modulo (always positive)            │ JS remainder (can be negative)                                                  │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ int / float distinction │ Separate types                             │ Both are JS number                                                              │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ String * repetition     │ 'a' * 3 == 'aaa'                           │ Requires pythonize module or JS-side workaround                                 │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ sort() / pop()          │ Standard list methods                      │ Renamed to pysort() / pypop()                                                   │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ Method binding          │ Unbound by default, self passed explicitly │ Same — but differs if you store methods in variables without bound_methods flag │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ dict key ordering       │ Insertion order (3.7+)                     │ Depends on JS engine (V8: insertion order)                                      │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ global scoping          │ Full cross-scope declaration               │ Partial — interactions with nonlocal can be confusing                           │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ Exception .message      │ Not standard (Python uses .args[0])        │ .message is standard (JS style)                                                 │
+├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
+│ re module               │ Full PCRE features                         │ No lookbehind, limited unicode, no (?(1)...)                                    │
+└─────────────────────────┴────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────┘
+
+  ---
+Priority Gaps (Most Impactful)
+
+If prioritizing what to implement next, these have the highest user impact:
+
+1. super() — required for idiomatic OOP code - done
+2. Operator overloading (__add__, __lt__, etc.) — blocks numerical/scientific code - done
+3. __bool__ / truthiness fix — silent Python compatibility trap
+4. lambda keyword — commonly expected - done
+5. all() / any() — extremely common builtins - done
+6. functools.reduce / partial — core functional programming tools - done
+7. collections.defaultdict / Counter — frequently used - done
+8. Nested comprehensions — common Python pattern - done
+9. Walrus operator := — increasingly common in modern Python - done
+10. classmethod decorator — standard OOP pattern - done
+
+
+
+       

package/add-toc-to-readme

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

package/bin/export

@@ -0,0 +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');

package/bin/rapydscript

@@ -0,0 +1,70 @@
+#!/usr/bin/env node 
+// vim:ft=javascript:ts=4:et
+
+"use strict";
+
+function load(mod) {
+    return require('../tools/' + mod);
+}
+
+var utils = load('utils');
+
+// We need ES 6 generators so relaunch with the --harmony flag
+if (!utils.generators_available()) {
+    if (process.execArgv.indexOf('--harmony') != -1) {
+        console.error('RapydScript needs ES 6 generators, update your version of nodejs');
+        process.exit(1);
+    }
+    var args = ['--harmony', module.filename].concat(process.argv.slice(2));
+    require('child_process').spawn(process.execPath, args, {stdio:'inherit'}).on('exit', function(code, signal) {
+        process.exit(code);
+    });
+} else {
+
+    var start_time = new Date().getTime();
+    var path = require('path');
+
+    var argv = load('cli').argv;
+
+    var base_path = path.normalize(path.join(path.dirname(module.filename), ".."));
+    var src_path = path.join(base_path, 'src');
+    var lib_path = path.join(base_path, 'dev');
+    if (!utils.path_exists(path.join(lib_path, 'compiler.js'))) lib_path = path.join(base_path, 'release');
+
+    if (argv.mode === 'self') {
+        if (argv.files.length > 0) {
+            console.error("WARN: Ignoring input files since --self was passed");
+        }
+        load('self')(base_path, src_path, lib_path, argv.complete, argv.profile);
+        if (argv.test) {
+            console.log('\nRunning test suite...\n');
+            argv.files = [];  // Ensure all tests are run
+            load('test')(argv, base_path, src_path, path.join(base_path, 'dev'));
+        }
+        process.exit(0);
+    } else 
+
+    if (argv.mode === 'test') {
+        load('test')(argv, base_path, src_path, lib_path);
+    } else 
+
+    if (argv.mode === 'lint') {
+        load('lint').cli(argv, base_path, src_path, lib_path);
+    } else
+
+    if (argv.mode === 'repl') {
+        load('repl')({'lib_path':lib_path, 'imp_path':path.join(src_path, 'lib'), show_js:!argv.no_js});
+    } else 
+    
+    if (argv.mode === 'gettext') {
+        load('gettext').cli(argv, base_path, src_path, lib_path);
+    } else
+    
+    if (argv.mode === 'msgfmt') {
+        load('msgfmt').cli(argv, base_path, src_path, lib_path);
+    } else
+    
+    {
+        load('compile')(start_time, argv, base_path, src_path, lib_path);
+    }
+}

package/bin/web-repl-export

@@ -0,0 +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);

package/build

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