rapydscript-ns 0.8.0 → 0.8.2

package/CONTRIBUTORS

@@ -1,11 +1,12 @@
-This project is officially supported by Kovid Goyal.
+This project is officially supported by Michael Ficocelli.
 
 Main Developers
 ---------------
-Kovid Goyal
+Michael Ficocelli
 
 Other Contributors
 ------------------
+Kovid Goyal (Previous main developer, developer of rapydscript-ng)
 Alexander Tsepkov (main developer of the original RapydScript)
 Charles Law
 Tobias Weber

package/PYTHON_FEATURE_COVERAGE.md

@@ -0,0 +1,109 @@
+# Python Feature Coverage Report — RapydScript-NS
+
+## ✅ Fully Supported
+
+| Feature | Notes |
+|---|---|
+| `super()` — 0-arg and 2-arg forms | `super().method()` and `super(Cls, self).method()` both work |
+| `except TypeA, TypeB as e:` | RapydScript comma-separated form; catches multiple exception types |
+| `except (TypeA, TypeError) as e:` | Tuple form also supported |
+| `try / else` | `else` block runs only when no exception was raised |
+| `for / else` | `else` block runs when loop completes without `break`; nested break isolation works |
+| `while / else` | `else` block runs when loop condition becomes `False` without a `break`; nested `break` isolation correct |
+| `with A() as a, B() as b:` | Multiple context managers in one statement; exits in LIFO order (Python-correct) |
+| `callable(fn)` | Works for plain functions and objects with `__call__` |
+| `round(x, ndigits=0)` | Full Python semantics including negative `ndigits` |
+| `enumerate(iterable, start=0)` | `start` parameter supported |
+| `str.isspace()`, `str.islower()`, `str.isupper()` | Working string predicates |
+| `str.isalpha()` | Regex-based; empty string returns `False` |
+| `str.isdigit()` | Regex-based (`\d+`) |
+| `str.isalnum()` | Regex-based |
+| `str.isidentifier()` | Checks `^[a-zA-Z_][a-zA-Z0-9_]*$` |
+| `str.casefold()` | Maps to `.toLowerCase()` |
+| `str.removeprefix(prefix)` | Returns unchanged string if prefix not found |
+| `str.removesuffix(suffix)` | Returns unchanged string if suffix not found |
+| `str * n` string repetition | Works when `from __python__ import overload_operators` is active |
+| `list * n` / `n * list` | Works with `overload_operators`; returns a proper RapydScript list |
+| `match / case` | Structural pattern matching (Python 3.10) fully supported |
+| Generator `.throw()` | Works via JS generator protocol |
+| Generator `.send()` | Works via `g.next(value)` |
+| `yield from` | Works; return value of sub-generator is not accessible |
+| `+=`, `-=`, `*=`, `/=`, `//=`, `**=`, `%=`, `&=`, `\|=`, `^=`, `<<=`, `>>=` | All augmented assignments work |
+| `raise X from Y` exception chaining | Sets `__cause__` on the thrown exception; `from None` also supported |
+| Starred assignment `a, *b, c = ...` | Works |
+| `@classmethod`, `@staticmethod`, `@property` / `@prop.setter` | All work |
+| `{**dict1, **dict2}` dict spread | Works as merge replacement for the missing `\|` operator |
+| `dict.fromkeys()` | Works with `dict_literals` flag |
+| Chained comparisons `a < b < c` and `a < b > c` | Same-direction and mixed-direction chains both work; middle operand evaluated once |
+| `for`, `while`, `try/except/finally`, `with`, `match/case` | All control-flow constructs work |
+| Classes, inheritance, decorators, `__dunder__` methods | Fully supported |
+| List / dict / set comprehensions, generator expressions | Fully supported |
+| f-strings, `str.format()`, all common `str.*` methods | Fully supported |
+| `abs()`, `divmod()`, `any()`, `all()`, `sum()`, `min()`, `max()` | All work |
+| `sorted()`, `reversed()`, `zip()`, `map()`, `filter()` | All work |
+| `set` with full union/intersection/difference API | Fully supported |
+| `isinstance()`, `hasattr()`, `getattr()`, `setattr()`, `dir()` | All work |
+| `bin()`, `hex()`, `oct()`, `chr()`, `ord()` | All work |
+| `int(x, base)`, `float(x)` with ValueError on bad input | Works |
+| `lambda` keyword | Full support: args, defaults, `*args`, ternary body, closures, nesting |
+| Arithmetic operator overloading — `__add__`, `__sub__`, `__mul__`, `__truediv__`, `__floordiv__`, `__mod__`, `__pow__`, `__neg__`, `__pos__`, `__abs__`, `__invert__`, `__lshift__`, `__rshift__`, `__and__`, `__or__`, `__xor__`, `__radd__`, `__iadd__` etc. | Dispatched when `from __python__ import overload_operators` is active; comparison operators (`<`, `>`, `<=`, `>=`) are **not** re-dispatched — call `obj.__lt__(other)` directly |
+| Nested comprehensions (multi-`for` clause) | `[x for row in matrix for x in row if cond]`; works for list, set, and dict comprehensions |
+| Positional-only parameters `def f(a, b, /):` | Full support — parser enforces placement; runtime passes positional args correctly |
+| Keyword-only parameters `def f(a, *, b):` | Full support — bare `*` separator enforced; `b` must be passed as keyword |
+| Walrus operator `:=` | Fully supported: hoisted in `if`/`while` conditions at any scope; comprehension filter assigns to enclosing scope (Python-correct). |
+| `__call__` dunder dispatch | `obj()` dispatches to `obj.__call__(args)` for callable objects; `callable(obj)` also returns `True`; both forms work. Requires `from __python__ import truthiness`. |
+| **Truthiness / `__bool__`** | Full Python truthiness via `from __python__ import truthiness`: empty `[]`, `{}`, `set()`, `''` are falsy; `__bool__` is dispatched; `and`/`or` return operand values; `not`, `if`, `while`, `assert`, ternary all use `ρσ_bool()`. |
+| `frozenset(iterable)` | Immutable set: construction from list/set/iterable; `in`, `len()`, iteration, `copy()`, `union()`, `intersection()`, `difference()`, `symmetric_difference()`, `issubset()`, `issuperset()`, `isdisjoint()` — all return `frozenset`. `isinstance(x, frozenset)` works. Compares equal to a `set` with the same elements via `__eq__`. No mutation methods (`add`, `remove`, etc.). |
+| `issubclass(cls, classinfo)` | Checks prototype chain; `classinfo` may be a class or tuple of classes; every class is a subclass of itself; raises `TypeError` for non-class arguments. |
+| `hash(obj)` | Numbers hash by value (int identity, float → int form if whole); strings use djb2; `None` → 0; booleans → 0/1; objects with `__hash__` dispatch to it; class instances get a stable identity hash; `list`, `set`, `dict` raise `TypeError`. |
+| `next(iterator[, default])` | Advances a JS-protocol iterator (`{done, value}`); returns `default` when exhausted if provided, otherwise raises `StopIteration`. Works with `iter()`, `range()`, `enumerate()`, generators, and any object with a `.next()` or `__next__()` method. |
+| `StopIteration` exception | Defined as a builtin exception class; raised by `next()` when an iterator is exhausted and no default is given. |
+| `dict \| dict` and `dict \|= dict` (Python 3.9+) | Dict merge via `\|` creates a new merged dict (right-side values win); `\|=` updates in-place. Requires `from __python__ import overload_operators, dict_literals`. |
+
+---
+
+## ❌ Not Supported — Missing from Baselib (runtime)
+
+| Feature                             | Priority                                                               |
+|-------------------------------------|------------------------------------------------------------------------|
+| `format(value[, spec])`             | 🟢 Low — not a builtin; `str.format()` and f-strings work              |
+| `iter(callable, sentinel)`          | 🟢 Low — two-arg form not supported; single-arg `iter(iterable)` works |
+| `slice(start, stop[, step])`        | 🟢 Low — not a builtin object; list slicing syntax `a[1:5:2]` works    |
+| `complex(real, imag)`               | 🟢 Low — no complex number type                                        |
+| `vars()` / `locals()` / `globals()` | 🟢 Low — not defined; use direct attribute access                      |
+| `str.expandtabs(tabsize)`           | 🟢 Low                                                                 |
+| `int.bit_length()`                  | 🟢 Low — useful for bit manipulation                                   |
+| `float.is_integer()`                | 🟢 Low                                                                 |
+
+---
+
+## ❌ Not Supported — Parser / Syntax Level
+
+| Feature                                       | Priority                                                             |
+|-----------------------------------------------|----------------------------------------------------------------------|
+| `zip(strict=True)`                            | 🟢 Low                                                               |
+| Nested class definitions                      | 🟢 Low — noted as not yet fully implemented                          |
+| `__slots__` enforcement                       | 🟢 Low — accepted but does not restrict attribute assignment         |
+| Complex number literals `3+4j`                | 🟢 Low — no `j` suffix; no complex type                              |
+| `b'...'` bytes literals                       | 🟢 Low — no `b` prefix; use the `encodings` module for encoding work |
+| `except*` (exception groups, Python 3.11+)    | 🟢 Low — no parser support                                           |
+| `__new__` constructor hook                    | 🟢 Low — no alternative constructor support                          |
+| `__del__` destructor / finalizer              | 🟢 Low — JS has no guaranteed finalizer                              |
+| `__hash__` dunder                             | 🟢 Low — not dispatched; set/dict use `===` object identity          |
+| `__getattr__` / `__setattr__` / `__delattr__` | 🟢 Low — no attribute-access interception                            |
+| `__getattribute__`                            | 🟢 Low — no attribute-lookup override                                |
+| `__format__` dunder                           | 🟢 Low — `format()` builtin not defined; `__format__` not dispatched |
+| `__class_getitem__`                           | 🟢 Low — no `MyClass[T]` generic subscript syntax                    |
+| `__init_subclass__` hook                      | 🟢 Low                                                               |
+
+---
+
+## Test File
+
+`test/python_features.pyj` contains runnable assertions for all features surveyed.
+Features that are not supported have their test code commented out with a `# SKIP:` label
+and an explanation. Run with:
+
+```sh
+node bin/rapydscript test python_features
+```

package/README.md

@@ -2,15 +2,14 @@ RapydScript
 ===========
 
 
-[![Build Status](https://github.com/ebook-utils/kovidgoyal/rapydscript-ng/CI/badge.svg)](https://github.com/kovidgoyal/rapydscript-ng/actions?query=workflow%3ACI)
-[![Downloads](https://img.shields.io/npm/dm/rapydscript-ng.svg)](https://www.npmjs.com/package/rapydscript-ng)
-[![Current Release](https://img.shields.io/npm/v/rapydscript-ng.svg)](https://www.npmjs.com/package/rapydscript-ng)
-[![Known Vulnerabilities](https://snyk.io/test/github/kovidgoyal/rapydscript-ng/badge.svg)](https://snyk.io/test/github/kovidgoyal/rapydscript-ng)
+[![Build Status](https://github.com/ficocelliguy/rapydscript-ns/actions/workflows/ci.yml/badge.svg)](https://github.com/ficocelliguy/rapydscript-ns/actions?query=workflow%3ACI)
+[![Current Release](https://img.shields.io/npm/v/rapydscript-ns)](https://www.npmjs.com/package/rapydscript-ns)
+[![Known Vulnerabilities](https://snyk.io/test/github/ficocelliguy/rapydscript-ns/badge.svg)](https://snyk.io/test/github/ficocelliguy/rapydscript-ns)
 
 This is a fork of the original RapydScript that adds many new (not always
 backwards compatible) features. For more on the forking, [see the bottom of this file](#reasons-for-the-fork)
 
-[Try RapydScript-ng live via an in-browser REPL!](https://sw.kovidgoyal.net/rapydscript/repl/)
+[Try RapydScript-ns live via an in-browser REPL!](https://ficocelliguy.github.io/rapydscript-ns/)
 
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
@@ -116,22 +115,22 @@ learn a new language/framework is to dive in.
 Installation
 ------------
 
-[Try RapydScript-ng live via an in-browser REPL!](https://sw.kovidgoyal.net/rapydscript/repl/)
+[Try RapydScript-ns live via an in-browser REPL!](https://ficocelliguy.github.io/rapydscript-ns/)
 
 First make sure you have installed the latest version of [node.js](https://nodejs.org/) (You may need to restart your computer after this step). 
 
 From NPM for use as a command line app:
 
-	npm install rapydscript-ng -g
+	npm install rapydscript-ns -g
 
 From NPM for use in your own node project:
 
-	npm install rapydscript-ng
+	npm install rapydscript-ns
 
 From Git:
 
-	git clone https://github.com/kovidgoyal/rapydscript-ng.git
-	cd rapydscript-ng
+	git clone https://github.com/ficocelliguy/rapydscript-ns.git
+	cd rapydscript-ns
 	sudo npm link .
 	npm install  # This will automatically install the dependencies for RapydScript
 
@@ -727,7 +726,7 @@ Keywords:
 Operators:
 
 	RapydScript		JavaScript
-	
+
 	and				&&
 	or				||
 	not				!
@@ -736,7 +735,10 @@ Operators:
 	+=1				++
 	-=1				--
 	**				Math.pow()
-	
+	**=				x = Math.pow(x, y)
+
+All Python augmented assignment operators are supported: `+=`, `-=`, `*=`, `/=`, `//=`, `**=`, `%=`, `>>=`, `<<=`, `|=`, `^=`, `&=`.
+
 Admittedly, `is` is not exactly the same thing in Python as `===` in JavaScript, but JavaScript is quirky when it comes to comparing objects anyway.
 
 
@@ -895,6 +897,30 @@ merged = {**pd1, **pd2}   # isinstance(merged, dict) == True
 The spread items are translated using `Object.assign` for plain JS objects
 and `dict.update()` for Python dicts.
 
+### Dict merge operator `|` and `|=` (Python 3.9+)
+
+When `from __python__ import overload_operators, dict_literals` is active,
+Python dicts support the `|` (merge) and `|=` (update in-place) operators:
+
+```py
+from __python__ import overload_operators, dict_literals
+
+d1 = {'x': 1, 'y': 2}
+d2 = {'y': 99, 'z': 3}
+
+# Create a new merged dict — right-side values win on key conflict
+merged = d1 | d2   # {'x': 1, 'y': 99, 'z': 3}
+
+# Update d1 in place
+d1 |= d2           # d1 is now {'x': 1, 'y': 99, 'z': 3}
+```
+
+`d1 | d2` creates a new dict (neither operand is mutated).
+`d1 |= d2` merges `d2` into `d1` and returns `d1`.
+
+Without `overload_operators` the `|` symbol is bitwise OR — use
+`{**d1, **d2}` spread syntax as a flag-free alternative.
+
 
 ### Arithmetic operator overloading
 
@@ -949,6 +975,16 @@ to the native JavaScript operator, so plain numbers, strings, and booleans
 continue to work as expected with no performance penalty when no dunder method
 is defined.
 
+When `overload_operators` is active, string and list repetition with `*` works just like Python:
+
+```py
+from __python__ import overload_operators
+'ha' * 3      # 'hahaha'
+3 * 'ha'      # 'hahaha'
+[0] * 4       # [0, 0, 0, 0]
+[1, 2] * 2    # [1, 2, 1, 2]
+```
+
 Because the dispatch adds one or two property lookups per operation, the flag
 is **opt-in** rather than always-on. Enable it only in the files or scopes
 where you need it.
@@ -978,7 +1014,166 @@ for your own types.
 
 RapydScript does not overload the ordering operators ```(>, <, >=,
 <=)``` as doing so would be a big performance impact (function calls in
-JavaScript are very slow). So using them on containers is useless. 
+JavaScript are very slow). So using them on containers is useless.
+
+Chained comparisons work just like Python — each middle operand is evaluated only once:
+
+```py
+# All of these work correctly, including mixed-direction chains
+assert 1 < 2 < 3      # True
+assert 1 < 2 > 0      # True  (1<2 AND 2>0)
+assert 1 < 2 > 3 == False  # 1<2 AND 2>3 = True AND False = False
+```
+
+### Python Truthiness and `__bool__`
+
+By default RapydScript uses JavaScript truthiness, where empty arrays `[]` and
+empty objects `{}` are **truthy**. Activate full Python truthiness semantics
+with:
+
+```py
+from __python__ import truthiness
+```
+
+When this flag is active:
+
+- **Empty containers are falsy**: `[]`, `{}`, `set()`, `''`, `0`, `None` are all falsy.
+- **`__bool__` is dispatched**: objects with a `__bool__` method control their truthiness.
+- **`__len__` is used**: objects with `__len__` are falsy when `len(obj) == 0`.
+- **`and`/`or` return operand values** (not booleans), just like Python.
+- **All condition positions** (`if`, `while`, `assert`, `not`, ternary) use Python semantics.
+
+```py
+from __python__ import truthiness
+
+class Empty:
+    def __bool__(self): return False
+
+if not []:          # True — [] is falsy
+    print('empty')
+
+x = [] or 'default'   # x == 'default'
+y = [1] or 'default'  # y == [1]
+z = [1] and 'ok'      # z == 'ok'
+```
+
+The flag is **scoped** — it applies until the end of the enclosing
+function or class body. Use `from __python__ import no_truthiness` to
+disable it in a sub-scope.
+
+### Callable Objects (`__call__`)
+
+Any class that defines `__call__` can be invoked directly with `obj(args)`,
+just like Python callable objects. This requires `from __python__ import truthiness`:
+
+```python
+from __python__ import truthiness
+
+class Multiplier:
+    def __init__(self, factor):
+        self.factor = factor
+    def __call__(self, x):
+        return self.factor * x
+
+triple = Multiplier(3)
+triple(7)   # 21 — dispatches to triple.__call__(7)
+```
+
+`callable(obj)` returns `True` when `__call__` is defined. The dispatch is
+automatic for all direct function-call expressions that are simple names
+(i.e. not method accesses like `obj.method()`).
+
+### `frozenset`
+
+RapydScript provides a full `frozenset` builtin — an immutable, unordered
+collection of unique elements, identical to Python's `frozenset`.
+
+```python
+fs = frozenset([1, 2, 3])
+len(fs)          # 3
+2 in fs          # True
+isinstance(fs, frozenset)  # True
+
+# Set operations return new frozensets
+a = frozenset([1, 2, 3])
+b = frozenset([2, 3, 4])
+a.union(b)                 # frozenset({1, 2, 3, 4})
+a.intersection(b)          # frozenset({2, 3})
+a.difference(b)            # frozenset({1})
+a.symmetric_difference(b)  # frozenset({1, 4})
+
+a.issubset(frozenset([1, 2, 3, 4]))   # True
+a.issuperset(frozenset([1, 2]))        # True
+a.isdisjoint(frozenset([5, 6]))        # True
+
+# Compares equal to a set with the same elements
+frozenset([1, 2]).__eq__({1, 2})  # True
+```
+
+Mutation methods (`add`, `remove`, `discard`, `clear`, `update`) are not
+present on `frozenset` instances, enforcing immutability at the API level.
+`frozenset` objects can be iterated and copied with `.copy()`.
+
+### `issubclass`
+
+`issubclass(cls, classinfo)` checks whether a class is a subclass of another
+class (or any class in a tuple of classes).  Every class is considered a
+subclass of itself.
+
+```python
+class Animal: pass
+class Dog(Animal): pass
+class Poodle(Dog): pass
+class Cat(Animal): pass
+
+issubclass(Dog, Animal)            # True
+issubclass(Poodle, Animal)         # True — transitive
+issubclass(Poodle, Dog)            # True
+issubclass(Dog, Dog)               # True — a class is its own subclass
+issubclass(Cat, Dog)               # False
+issubclass(Animal, Dog)            # False — parent is not a subclass of child
+
+# tuple form — True if cls is a subclass of any entry
+issubclass(Dog, (Cat, Animal))     # True
+issubclass(Poodle, (Cat, Dog))     # True
+```
+
+`TypeError` is raised when either argument is not a class.
+
+### `hash`
+
+`hash(obj)` returns an integer hash value for an object, following Python
+semantics:
+
+| Type | Hash rule |
+|---|---|
+| `None` | `0` |
+| `bool` | `1` for `True`, `0` for `False` |
+| `int` / whole `float` | the integer value itself |
+| other `float` | derived from the bit pattern |
+| `str` | djb2 algorithm — stable within a process |
+| object with `__hash__` | dispatches to `__hash__()` |
+| class instance | stable identity hash (assigned on first call) |
+| `list` | `TypeError: unhashable type: 'list'` |
+| `set` | `TypeError: unhashable type: 'set'` |
+| `dict` | `TypeError: unhashable type: 'dict'` |
+
+```python
+hash(None)        # 0
+hash(True)        # 1
+hash(42)          # 42
+hash(3.0)         # 3   (whole float → same as int)
+hash('hello')     # stable integer
+
+class Point:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+    def __hash__(self):
+        return self.x * 31 + self.y
+
+hash(Point(1, 2))  # 33
+```
 
 Loops
 -----
@@ -1000,6 +1195,39 @@ for index, animal in enumerate(animals):
 	print("index:"+index, "animal:"+animal)
 ```
 
+`enumerate()` supports an optional `start` argument (default 0):
+
+```py
+for index, animal in enumerate(animals, 1):
+	print(str(index) + '. ' + animal)  # 1-based numbering
+```
+
+Like in Python, `for` loops support an `else` clause that runs only when the loop completes without hitting a `break`:
+
+```py
+for animal in animals:
+    if animal == 'cat':
+        print('found a cat')
+        break
+else:
+    print('no cat found')
+```
+
+This is useful for search patterns where you want to take an action only if the searched item was not found.
+
+`while` loops also support an `else` clause, which runs when the condition becomes `False` (i.e. no `break` was executed):
+
+```py
+i = 0
+while i < len(items):
+    if items[i] == target:
+        print('found at', i)
+        break
+    i += 1
+else:
+    print('not found')
+```
+
 Like in Python, if you just want the index, you can use range:
 
 ```py
@@ -1118,6 +1346,31 @@ str.format('{0:02d} {n}', 1, n=2) == '01 2'
 ...
 ```
 
+String predicate methods are also available:
+
+```py
+str.isalpha('abc')      # True — all alphabetic
+str.isdigit('123')      # True — all digits
+str.isalnum('abc123')   # True — alphanumeric
+str.isspace('   ')      # True — all whitespace
+str.isupper('ABC')      # True
+str.islower('abc')      # True
+str.isidentifier('my_var')  # True — valid Python identifier
+```
+
+Python 3.9 prefix/suffix removal:
+
+```py
+str.removeprefix('HelloWorld', 'Hello')  # 'World'
+str.removesuffix('HelloWorld', 'World')  # 'Hello'
+```
+
+Case-folding for locale-insensitive lowercase comparison:
+
+```py
+str.casefold('ÄÖÜ') == str.casefold('äöü')  # True (maps to lowercase)
+```
+
 However, if you want to make the python string methods available on string
 objects, there is a convenience method in the standard library to do so. Use
 the following code:
@@ -1756,11 +2009,25 @@ an ``__iter__`` method, just as you would in python. For example:
 	   print (x)  # Will print 1, 2, 3
 ```
 
-Note that unlike python, an iterators ``next()`` method does not return
-the next value, but instead an object with two properties: ``done and value``.
-``value`` is the next value and done will be ``True`` when the iterator is
-exhausted. No ``StopIteration`` exception is raised. These choices were
-made so that the iterator works with other JavaScript code.
+Internally, an iterator's ``.next()`` method returns a JavaScript object with
+two properties: ``done`` and ``value``. ``value`` is the next value and
+``done`` is ``True`` when the iterator is exhausted. This matches the
+JavaScript iterator protocol and allows interoperability with vanilla JS code.
+
+RapydScript also provides the Python-style ``next()`` builtin, which wraps
+this protocol transparently:
+
+```python
+it = iter([1, 2, 3])
+next(it)         # 1
+next(it)         # 2
+next(it, 'end')  # 3
+next(it, 'end')  # 'end'  (iterator exhausted, default returned)
+next(it)         # raises StopIteration
+```
+
+When the iterator is exhausted and no default is given, ``StopIteration``
+is raised — matching standard Python behaviour.
 
 Generators
 ------------
@@ -1935,7 +2202,7 @@ class MyError(Exception):
 raise MyError('This is a custom error!')
 ```
 
-You can lump multiple errors in the same except block as well:
+You can catch multiple exception types in one `except` clause. Both the comma form and the tuple form are supported:
 
 ```py
 try:
@@ -1943,9 +2210,31 @@ try:
 except ReferenceError, TypeError as e:
 	print(e.name + ':' + e.message)
 	raise # re-raise the exception
+
+# Equivalent tuple form (Python 3 style):
+try:
+    risky()
+except (ReferenceError, TypeError) as e:
+    handle(e)
+```
+
+Exception chaining with `raise X from Y` is supported. The cause is stored on the raised exception's `__cause__` attribute:
+
+```py
+try:
+    open_file('data.txt')
+except OSError as exc:
+    raise ValueError('Could not read config') from exc
 ```
 
-Basically, `try/except/finally` in RapydScript works very similar to the way it does in Python 3. 
+Use `raise X from None` to explicitly suppress the chained context:
+
+```py
+except SomeInternalError:
+    raise PublicError('something went wrong') from None
+```
+
+Basically, `try/except/finally` in RapydScript works very similar to the way it does in Python 3.
 
 Scope Control
 -------------
@@ -2114,7 +2403,7 @@ may be more verbose:
 
 You can embed the RapydScript compiler in your webpage so that you can have
 your webapp directly compile user supplied RapydScript code into JavaScript.
-To do so, simply include the [embeddable rapydscript compiler](https://sw.kovidgoyal.net/rapydscript/repl/rapydscript.js) 
+To do so, simply include the [embeddable rapydscript compiler](https://github.com/ficocelliguy/rapydscript-ns/blob/master/web-repl/rapydscript.js) 
 in your page, and use it to compile arbitrary RapydScript code. 
 
 You create the compiler by calling: `RapydScript.create_embedded_compiler()` and compile
@@ -2128,7 +2417,7 @@ HTML below for an example.
     <head>
         <meta charset="UTF-8">
         <title>Test embedded RapydScript</title>
-        <script charset="UTF-8" src="https://sw.kovidgoyal.net/rapydscript/repl/rapydscript.js"></script>
+        <script charset="UTF-8" src="https://github.com/ficocelliguy/rapydscript-ns/blob/master/web-repl/rapydscript.js"></script>
         <script>
 var compiler = RapydScript.create_embedded_compiler();
 var js = compiler.compile("def hello_world():\n a='RapydScript is cool!'\n print(a)\n alert(a)");
@@ -2496,17 +2785,14 @@ completions, signature help, hover, DTS registry, and built-in stubs).
 Reasons for the fork
 ----------------------
 
-The fork was initially created because the original developer of RapydScript
-did not have the time to keep up with the pace of development. Since then, 
-development on the original RapydScript seems to have stalled completely.
-Also, there are certain disagreements on the future direction of RapydScript.
-
-Regardless, this fork is not a hostile fork, if development on the original
-ever resumes, they are welcome to use the code from this fork. I have kept all
-new code under the same license, to make that possible.
+The fork was created because both the original developer of RapydScript
+and the developer of the prior fork rapydscript-ng both did not have 
+the time to keep up with the pace of development. Rapydscript has not had
+any npm updates since 2020, and rapydscript-ng since 2022.
 
-See the [Changelog](https://github.com/kovidgoyal/rapydscript-ng/blob/master/CHANGELOG.md)
-for a list of changes to rapydscript-ng since the fork.
+This fork is not a hostile fork - if development on the prior versions
+ever resumes, they are welcome to use the code from this fork. All the
+new code is under the same license, to make that possible.
 
-For some discussion surrounding the fork, see 
-[this bug report](https://github.com/kovidgoyal/rapydscript-ng/issues/15)
+See the [Changelog](https://github.com/ficocelliguy/rapydscript-ns/blob/master/CHANGELOG.md)
+for a list of changes to rapydscript-ns, including this fork at version 8.0