@@ -354,6 +354,7 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `adfgx`: aka ADFGX Cipher (Polybius square and columnar transposition) ; `adfgvx` for its 6x6 variant
 - [X] `aer256`: aka AER-256 (toy cipher with float arithmetic, from online JavaScript tools)
 - [X] `affine`: aka Affine Cipher
+- [X] `arabica-2rs`: aka ARABICA-2RS (URI-encoded text substituted by Arabic letters, from online JavaScript tools)
 - [X] `armon64`: aka ARMON-64 (variant of AER-256 with a fourth operation)
 - [X] `atbash`: aka Atbash Cipher
 - [X] `atom128`: aka ATOM-128 (Base64 with a shuffled alphabet, from online JavaScript tools)
@@ -364,6 +365,7 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)
 - [X] `bifid`: aka Bifid Cipher (Delastelle's fractionation with a 5x5 Polybius square) ; `trifid` for its 3x3x3 cube variant
 - [X] `chaocipher`: aka Chaocipher (two alphabets permuted after each letter)
+- [X] `chinzo-72c`: aka CHINZO-72C (URI-encoded text substituted by Chinese characters, from online JavaScript tools)
 - [X] `cisco-type7`: aka Cisco IOS type 7 password encoding
 - [X] `citrix`: aka Citrix CTX1 password encoding
 - [X] `columnar`: aka Columnar Transposition Cipher (keyword-ordered columns ; a second keyword gives the double transposition)
@@ -376,6 +378,7 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `gila7`: aka GILA7 (Base64 with a shuffled alphabet, from online JavaScript tools)
 - [X] `gronsfeld`: aka Gronsfeld Cipher (variant of Vigenere Cipher with a numeric key)
 - [X] `hill`: aka Hill Cipher (blocks of letters multiplied by a key matrix modulo 26)
+- [X] `japoo-c2s`: aka JAPOO-C2S (URI-encoded text substituted by Chinese and Japanese characters, from online JavaScript tools)
 - [X] `nihilist`: aka Nihilist Cipher (sums of the Polybius coordinates of the text and of a repeated key)
 - [X] `playfair`: aka Playfair Cipher
 - [X] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
@@ -393,6 +396,7 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `vigenere`: aka Vigenere Cipher
 - [X] `xorN`: XOR with a single byte (*N* belongs to [1,255])
 - [X] `zara128`: aka ZARA-128 (variant of AER-256 with additions only and smaller blocks)
+- [X] `zong22`: aka ZONG22 (Base64 with a shuffled alphabet, from online JavaScript tools)
 
 > :warning: Crypto functions are of course definitely **NOT** encoding functions ; they are implemented for leveraging the `.encode(...)` API from `codecs`.
 
 
@@ -97,6 +97,23 @@ This codec implements the Affine monoalphabetic substitution cipher. It is param
 
 -----
 
+### ARABICA-2RS
+
+This toy cipher comes from online JavaScript encryption tools. The text is encoded like JavaScript's `encodeURIComponent()` does (e.g. a whitespace becomes `%20`), then each of its characters is substituted by an Arabic letter (or a similar character), the ciphertext ending with `ش`. The original JavaScript inserts random spaces, which are ignored when decoding ; this codec gives a ciphertext without spaces.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`arabica-2rs` | text <-> ARABICA-2RS ciphertext | `arabica2rs`, `arabica_2rs` | the left-to-right marks around `ݣ` are optional when decoding
+
+```python
+>>> codext.encode("this is a test", "arabica-2rs")
+'حرقطﺿأﺹقطﺿأﺹغﺿأﺹحبطحش'
+>>> codext.decode("حرقطﺿأﺹقطﺿأﺹغﺿأﺹحبطحش", "arabica2rs")
+'this is a test'
+```
+
+-----
+
 ### ARMON-64
 
 This toy cipher, a variant of [AER-256](#aer-256), comes from online JavaScript encryption tools. It works the same way, but with a fourth operation (the number is multiplied by 0.01 times the code of the key character) and with `+` as the separator.
@@ -298,6 +315,27 @@ The Chaocipher was invented by John F. Byrne in 1918 and only disclosed in 2010.
 
 -----
 
+### CHINZO-72C
+
+This toy cipher comes from online JavaScript encryption tools. The pairs of letters `oo`, `ii`, `ee`, `tt` and `rr` are first replaced by Chinese characters, then the text is encoded like JavaScript's `encodeURIComponent()` does and each of its characters is substituted by a Chinese character followed by a space, the ciphertext ending with `吴`.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`chinzo-72c` | text <-> CHINZO-72C ciphertext | `chinzo72c`, `chinzo_72c` | spaces ignored when decoding
+
+!!! warning "Pairs of letters"
+
+    As decoding gives back the pairs of letters, a text holding one of the 5 Chinese characters replacing them (`讲`, `邻`, `头`, `会` and `歷`) is not decoded as it was.
+
+```python
+>>> codext.encode("this is a test", "chinzo-72c")
+'岛 拉 玛 夫 题 防 呒 玛 夫 题 防 呒 法 题 防 呒 岛 伐 夫 岛 吴'
+>>> codext.decode("岛 拉 玛 夫 题 防 呒 玛 夫 题 防 呒 法 题 防 呒 岛 伐 夫 岛 吴", "chinzo72c")
+'this is a test'
+```
+
+-----
+
 ### Cisco Type 7
 
 This implements the reversible Cisco IOS type 7 password encoding: each byte is XORed with a fixed key, starting at an offset given by the salt (from 0 to 15), and the result is the salt as two decimal digits followed by the XORed bytes in hexadecimal. Decoding reads the salt from the input.
@@ -528,6 +566,23 @@ The letters (A=0, ..., Z=25) are taken in blocks of n, each block being multipli
 
 -----
 
+### JAPOO-C2S
+
+This toy cipher comes from online JavaScript encryption tools. The text is encoded like JavaScript's `encodeURIComponent()` does, then each of its characters is substituted by a Chinese or Japanese character followed by a space, some pairs of identical characters (e.g. `貴 貴 `) being then replaced by another character (e.g. `詞 `), and the ciphertext ends with `类`.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`japoo-c2s` | text <-> JAPOO-C2S ciphertext | `japooc2s`, `japoo_c2s` | spaces ignored when decoding
+
+```python
+>>> codext.encode("this is a test", "japoo-c2s")
+'徒 卵 語 簡 場 誰 貴 語 簡 場 誰 貴 是 場 誰 貴 徒 或 簡 徒 类'
+>>> codext.decode("徒 卵 語 簡 場 誰 貴 語 簡 場 誰 貴 是 場 誰 貴 徒 或 簡 徒 类", "japooc2s")
+'this is a test'
+```
+
+-----
+
 ### Nihilist Cipher
 
 Each letter of the text and of the key is replaced by its coordinates (row and column, from 1 to 5) in a 5x5 Polybius square (I and J sharing a cell), read as a two-digit number. The ciphertext is made of the sums of the numbers of the text and of the repeated key, separated by spaces. The square is filled with an optional keyword (without duplicates), then with the remaining letters of the alphabet. When encoding, whitespaces are ignored ; when decoding, the numbers are separated by whitespaces.
@@ -836,3 +891,20 @@ This toy cipher, a variant of [AER-256](#aer-256), comes from online JavaScript
 >>> codext.decode("428 413 427 428", "zara128-016359")
 'test'
 ```
+
+-----
+
+### ZONG22
+
+This toy cipher comes from online JavaScript encryption tools. It is Base64 with a shuffled alphabet, whose 65th character (`2`) is used for padding. As in the original JavaScript, the text is first escaped with JavaScript's `escape()` (e.g. a whitespace becomes `%20`), and unescaped after decoding ; ciphertexts made from the UTF-8 bytes of the text (without escaping) are decoded as well.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`zong22` | text <-> ZONG22 ciphertext | `zong-22`, `zong_22` | 
+
+```python
+>>> codext.encode("this is a test", "zong22")
+'PyglpexeXyNFwd0QIbxeXfYNpz52'
+>>> codext.decode("PyglpexeXyNFwd0QIbxeXfYNpz52", "zong-22")
+'this is a test'
+```
@@ -2,6 +2,7 @@
 from .adfgx import *
 from .aer256 import *
 from .affine import *
+from .arabica2rs import *
 from .armon64 import *
 from .atbash import *
 from .atom128 import *
@@ -10,6 +11,7 @@
 from .bazeries import *
 from .bifid import *
 from .chaocipher import *
+from .chinzo72c import *
 from .cisco import *
 from .citrix import *
 from .columnar import *
@@ -21,6 +23,7 @@
 from .fractionatedmorse import *
 from .gila7 import *
 from .hill import *
+from .japooc2s import *
 from .nihilist import *
 from .playfair import *
 from .phillips import *
@@ -36,3 +39,4 @@
 from .vigenere import *
 from .xor import *
 from .zara128 import *
+from .zong22 import *
@@ -1,11 +1,11 @@
 # -*- coding: UTF-8 -*-
 """Base64 variants, shared by the toy ciphers of online JavaScript encryption tools (ATOM-128, ESAB-46, FERON-74,
- GILA7).
+ GILA7, ZONG22).
 
 These ciphers are Base64 with a shuffled alphabet of 65 characters, whose last one is used for padding. As in the
  original JavaScript, the text is first escaped with JavaScript's escape() (e.g. " " becoming "%20" and "é" becoming
  "%E9"), and unescaped after decoding ; ciphertexts made without this escaping (i.e. from the UTF-8 bytes of the text)
- are then decoded the same way.
+ are decoded as well, except that an ASCII text holding escape sequences (e.g. "%41") is then unescaped.
 """
 import builtins
 import re
@@ -67,6 +67,13 @@ def decode(text, errors="strict"):
             r = r.replace("=", "")
             r = r[:len(r) - (len(r) % 4 == 1)]
             r = b64decode(r + "=" * (-len(r) % 4))
+        # escape() only gives ASCII characters, hence non-ASCII bytes come from a ciphertext made from the UTF-8 bytes
+        #  of the text, that is not to be unescaped
+        if not r.isascii():
+            try:
+                return r.decode("utf-8"), len(text)
+            except UnicodeDecodeError:
+                pass
         return js_unescape(r.decode("latin-1")), len(text)
 
     return encode, decode
@@ -0,0 +1,55 @@
+# -*- coding: UTF-8 -*-
+"""URI encoding, shared by the toy ciphers of online JavaScript encryption tools that substitute the characters of the
+ text encoded with JavaScript's encodeURIComponent() (ARABICA-2RS, CHINZO-72C, JAPOO-C2S).
+
+The text is encoded like encodeURIComponent() does (the UTF-8 bytes of the characters other than the letters, digits
+ and "-_.!~*'()" being written as "%XX"), hence it is made of 72 distinct characters, each one being substituted by a
+ character (or a short string) of the cipher ; decoding substitutes them back and decodes the text like
+ decodeURIComponent() does, malformed escape sequences and invalid UTF-8 being reported (or, with a non-strict errors
+ handling, replaced).
+"""
+import builtins
+import re
+from string import ascii_letters, digits
+from urllib.parse import quote, unquote
+
+from ..__common__ import ensure_str, exc_name, handle_error
+
+
+# characters left as is by encodeURIComponent(), and the characters of its output
+URI_SAFE = "-_.!~*'()"
+URI_CHARS = ascii_letters + digits + URI_SAFE + "%"
+
+
+def uri_encode(text):
+    """ Encode a string like JavaScript's encodeURIComponent(). """
+    return quote(ensure_str(text), safe=URI_SAFE)
+
+
+def uri_decode(text, ename, errors="strict"):
+    """ Decode a string like JavaScript's decodeURIComponent(), with the given errors handling. """
+    if errors == "strict":
+        if (m := re.search(r"%(?![0-9A-Fa-f]{2})", text)):
+            handle_error(ename, errors, decode=True, kind="escape sequence")(text[m.start():m.start()+3], m.start())
+        try:
+            return unquote(text, errors="strict")
+        except UnicodeDecodeError as e:
+            exc = getattr(builtins, f"{exc_name(ename)}DecodeError")
+            raise exc(f"'{ename}' codec can't decode: invalid UTF-8 ({e.reason})") from None
+    # with a non-strict errors handling, malformed escape sequences are kept as is and invalid UTF-8 is replaced
+    return unquote(text, errors="replace")
+
+
+def substitution(ename, table, decode_table=None):
+    """ Make the encoding and decoding functions of a cipher substituting the characters of the URI-encoded text, given
+         the substitutes of these characters. """
+    dtable = decode_table or {v: k for k, v in table.items()}
+
+    def encode(text):
+        return [table[c] for c in uri_encode(text)]
+
+    def decode(tokens, errors="strict"):
+        _h = handle_error(ename, errors, decode=True)
+        return uri_decode("".join(dtable[t] if t in dtable else _h(t, i) for i, t in enumerate(tokens)), ename, errors)
+
+    return encode, decode
@@ -0,0 +1,77 @@
+# -*- coding: UTF-8 -*-
+"""ARABICA-2RS Codec - ARABICA-2RS content encryption.
+
+ARABICA-2RS is a toy cipher found on online JavaScript encryption tools. The text is encoded like JavaScript's
+ encodeURIComponent() does, then each of its characters (written as 5 digits in base 3 by the original JavaScript) is
+ substituted by an Arabic letter (or a similar character), the ciphertext ending with "ش". The original JavaScript
+ reverses the text before and after the substitution (which cancel each other) and inserts random spaces, which are
+ ignored when decoding ; this codec gives a ciphertext without spaces, and encodes a text holding "ش" (that the
+ original JavaScript leaves as is). When decoding, the left-to-right marks around "ݣ" (easily lost) are optional.
+
+This codec:
+- en/decodes strings from str to str
+- en/decodes strings from bytes to bytes
+- decodes file content to str (read)
+- encodes file content from str to bytes (write)
+
+Reference: https://github.com/gungunfebrianza/Mastering-Cryptography/blob/master/ARABICA2RS/arabperkasaahaha.js
+"""
+import re
+
+from ._jsuri import substitution
+from ..__common__ import *
+
+
+__examples__ = {
+    'enc(arabica-2rs|arabica2rs|arabica_2rs)': {
+        'test': '\u062d\u0628\u0637\u062d\u0634',
+        'Hello, World!':
+            '\u06f1\u0628\u0639\u0639\u0645\ufebf\u0623\u06cc\ufebf\u0623\ufeb9\ufe9b\u0645\u064a\u0639\u062e\ufb90'
+            '\u0634',
+        '5': '\u200e\u0763\u200e\u0634',
+        '': '',
+    },
+    'dec(arabica-2rs)': {
+        '\u062d\u0628\u0637\u062d\u0634': 'test',
+        '\u06f1\u0628 \u0639 \u0639\u0645 \ufebf\u0623 \u06cc\ufebf\u0623 \ufeb9 \ufe9b\u0645\u064a\u0639\u062e\ufb90'
+        '\u0634':
+            'Hello, World!',
+        '\u0763\u0634': '5',
+        '\u062d\u0628X\u0634': None,
+        '\ufebf\u0634': None,
+    },
+    'enc-dec(arabica-2rs)': ['', 'test', 'Hello, World!', 'caf\xe9 \u20ac \U0001f600 \u0634', "0123456789-_.!~*'()%"],
+}
+__guess__ = ["arabica-2rs"]
+
+
+# substitutes of the characters of the URI-encoded text, given by their codes in base 3 (as in the original JavaScript)
+ARABICA = [
+    ("10121", "غ"), ("10122", "ظ"), ("10200", "ذ"), ("10201", "خ"), ("10202", "ب"), ("10210", "ت"),
+    ("10211", "س"), ("10212", "ر"), ("10220", "ق"), ("10221", "ض"), ("10222", "ف"), ("11000", "ع"),
+    ("11001", "ص"), ("11002", "ن"), ("11010", "م"), ("11011", "ل"), ("11012", "ك"), ("11020", "ي"),
+    ("11021", "ط"), ("11022", "ح"), ("11100", "ز"), ("11101", "و"), ("11102", "ه"), ("11110", "د"),
+    ("11111", "ج"), ("11112", "ﺵ"), ("01210", "ﺹ"), ("01211", "ﻃ"), ("01212", "أ"), ("01220", "ا"),
+    ("01221", "ـ"), ("01222", "\u200eݣ\u200e"), ("02000", "چ"), ("02001", "گ"), ("02002", "آ"), ("02010", "ة"),
+    ("02102", "ى"), ("02110", "ک"), ("02111", "ی"), ("02112", "پ"), ("02120", "۴"), ("02121", "۸"),
+    ("02122", "۶"), ("02200", "۱"), ("02201", "ﭻ"), ("02202", "ئ"), ("02210", "ە"), ("02211", "ﻼ"),
+    ("02212", "ﻻ"), ("02220", "\u0651"), ("02221", "\u0650"), ("02222", "ژ"), ("10000", "ڨ"), ("10001", "ڜ"),
+    ("10002", "ﷲ"), ("10010", "ﺑ"), ("10011", "ﭘ"), ("10012", "ﺗ"), ("10020", "ﺛ"), ("10021", "ﺟ"),
+    ("10022", "ﺣ"), ("10100", "ﺡ"), ("01101", "ﺿ"), ("01111", "ﻏ"), ("01112", "ﻓ"), ("01200", "ﻑ"),
+    ("01120", "ﻕ"), ("01020", "ﮐ"), ("10112", "ﻝ"), ("01201", "ﻡ"), ("01110", "ﻥ"), ("11200", "ﻳ"),
+]
+_TABLE = {chr(int(code, 3)): s for code, s in ARABICA}
+_encode, _decode = substitution("arabica-2rs", _TABLE, {s.strip("\u200e"): c for c, s in _TABLE.items()})
+
+
+def arabica_encode(text, errors="strict"):
+    t = ensure_str(text)
+    return "".join(_encode(t)) + "\u0634" if t else "", len(text)
+
+
+def arabica_decode(text, errors="strict"):
+    t = re.sub(r"[\s\u200e]+", "", ensure_str(text)).replace("\u0634", "")
+    return _decode(t, errors), len(text)
+
+
+add("arabica-2rs", arabica_encode, arabica_decode, r"^arabica[-_]?2rs$", examples=__examples__, guess=__guess__)