functionalscript 0.7.0 → 0.8.0

package/README.md

@@ -19,7 +19,7 @@ Learn more about
 - [Purely Functional Programming in JavaScript](https://blog.bitsrc.io/purely-functional-programming-in-javascript-91114b1b2dff?sk=5f7132e56902f38fcf4c6164bfa681ed),
 - [FunctionalScript and I/O](https://medium.com/@sergeyshandar/functionalscript-5cf817345376?sk=30b32189a81d1a2dad16c2244f32328d).
 
-This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributed under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
+This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributed under [MIT](LICENSE).
 
 ## Getting Started
 
@@ -75,4 +75,5 @@ In FunctionalScript:
 ## Sponsors
 
 - [KirillOsenkov](https://github.com/KirillOsenkov),
-- [antkmsft](https://github.com/antkmsft).
+- [antkmsft](https://github.com/antkmsft),
+- [Mark Heyman](https://opencollective.com/body-count).

package/bnf/data/module.f.d.ts

@@ -17,9 +17,10 @@ type DispatchRule = {
 };
 type Dispatch = RangeMapArray<DispatchResult>;
 type DispatchResult = DispatchRuleCollection | null;
+type DispatchRuleOrName = DispatchRule | string;
 type DispatchRuleCollection = {
     readonly tag: string | undefined;
-    readonly rules: DispatchRule[];
+    readonly rules: DispatchRuleOrName[];
 };
 type DispatchMap = {
     readonly [id in string]: DispatchRule;
@@ -28,10 +29,14 @@ type DispatchMap = {
  * Represents a parsed Abstract Syntax Tree (AST) sequence.
  */
 export type AstSequence = readonly (AstRule | CodePoint)[];
+type AstTag = string | true | undefined;
 /**
  * Represents a parsed AST rule, consisting of a rule name and its parsed sequence.
  */
-export type AstRule = readonly [string, AstSequence];
+type AstRule = {
+    readonly tag: AstTag;
+    readonly sequence: AstSequence;
+};
 /**
  * Represents the remaining input after a match attempt, or `null` if no match is possible.
  */
@@ -39,15 +44,14 @@ export type Remainder = readonly CodePoint[] | null;
 /**
  * Represents the result of a match operation, including the parsed AST rule and the remainder of the input.
  */
-export type MatchResult = readonly [AstRule, Remainder];
+export type MatchResult = readonly [AstRule, boolean, Remainder];
 /**
  * Represents an LL(1) parser function for matching input against grammar rules.
  */
 export type Match = (name: string, s: readonly CodePoint[]) => MatchResult;
+export type MatchRule = (dr: DispatchRule, s: readonly CodePoint[]) => MatchResult;
 export declare const toData: (fr: FRule) => readonly [RuleSet, string];
 export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
 export declare const parser: (fr: FRule) => Match;
+export declare const parserRuleSet: (ruleSet: RuleSet) => Match;
 export {};
-/**
- * Either `{ variantItem: id }` or `id`.
- */

package/bnf/data/module.f.js

@@ -1,8 +1,8 @@
-import { todo } from "../../dev/module.f.js";
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { strictEqual } from "../../types/function/operator/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
 import { rangeMap } from "../../types/range_map/module.f.js";
+import { contains, set } from "../../types/string_set/module.f.js";
 import { oneEncode, rangeDecode, } from "../module.f.js";
 const { entries } = Object;
 const find = (map) => (fr) => {
@@ -91,20 +91,21 @@ const dispatchOp = rangeMap({
     def: null,
 });
 export const dispatchMap = (ruleSet) => {
-    const addRuleToDispatch = (dr, rule) => {
+    const addRuleToDispatch = (dr, name) => {
         if (dr === null)
             return null;
-        return { tag: dr.tag, rules: [...dr.rules, rule] };
+        return { tag: dr.tag, rules: [...dr.rules, name] };
     };
     const addTagToDispatch = (dr, tag) => {
         if (dr === null)
             return null;
         return { tag, rules: dr.rules };
     };
-    const dispatchRule = (dm, name) => {
+    const dispatchRule = (dm, name, current) => {
         if (name in dm) {
             return dm;
         }
+        const newCurrent = set(name)(current);
         const rule = ruleSet[name];
         if (typeof rule === 'number') {
             const range = rangeDecode(rule);
@@ -116,14 +117,20 @@ export const dispatchMap = (ruleSet) => {
             let emptyTag = true;
             let result = [];
             for (const item of rule) {
-                dm = dispatchRule(dm, item);
-                const dr = dm[item];
-                if (emptyTag === true) {
-                    result = toArray(dispatchOp.merge(result)(dr.rangeMap));
-                    emptyTag = dr.emptyTag !== undefined ? true : undefined;
+                if (contains(item)(newCurrent)) {
+                    result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
                 }
                 else {
-                    result = result.map(x => [addRuleToDispatch(x[0], dr), x[1]]);
+                    dm = dispatchRule(dm, item, newCurrent);
+                    const dr = dm[item];
+                    if (emptyTag === true) {
+                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
+                        result = toArray(dispatchOp.merge(result)(dr.rangeMap));
+                        emptyTag = dr.emptyTag !== undefined ? true : undefined;
+                    }
+                    else {
+                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
+                    }
                 }
             }
             const dr = { emptyTag, rangeMap: result };
@@ -134,7 +141,7 @@ export const dispatchMap = (ruleSet) => {
             let result = [];
             let emptyTag = undefined;
             for (const [tag, item] of entries) {
-                dm = dispatchRule(dm, item);
+                dm = dispatchRule(dm, item, newCurrent);
                 const dr = dm[item];
                 if (dr.emptyTag !== undefined) {
                     emptyTag = tag;
@@ -150,21 +157,53 @@ export const dispatchMap = (ruleSet) => {
     };
     let result = {};
     for (const k in ruleSet) {
-        result = dispatchRule(result, k);
+        result = dispatchRule(result, k, null);
     }
     return result;
 };
 export const parser = (fr) => {
     const data = toData(fr);
-    return todo();
+    return parserRuleSet(data[0]);
+};
+export const parserRuleSet = (ruleSet) => {
+    const map = dispatchMap(ruleSet);
+    const f = (rule, cp) => {
+        const mrSuccess = (tag, sequence, r) => [{ tag, sequence }, true, r];
+        const mrFail = (tag, sequence, r) => [{ tag, sequence }, false, r];
+        const { emptyTag, rangeMap } = rule;
+        if (cp.length === 0) {
+            return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp);
+        }
+        const cp0 = cp[0];
+        const dr = dispatchOp.get(cp0)(rangeMap);
+        if (dr === null) {
+            if (emptyTag === undefined) {
+                return mrFail(emptyTag, [], cp);
+            }
+            return mrSuccess(emptyTag, [], cp);
+        }
+        let seq = [cp0];
+        let r = cp;
+        const [_, ...restCp] = cp;
+        r = restCp;
+        const { tag, rules } = dr;
+        for (const i of rules) {
+            const rule = typeof i === 'string' ? map[i] : i;
+            const res = f(rule, r);
+            const [astRule, success, newR] = res;
+            if (success === false) {
+                return res;
+            }
+            seq = [...seq, astRule];
+            if (newR === null) {
+                return mrSuccess(tag, seq, null);
+            }
+            r = newR;
+        }
+        return mrSuccess(tag, seq, r);
+    };
+    const match = (name, cp) => {
+        return f(map[name], cp);
+    };
+    return match;
 };
-/**
- * Either `{ variantItem: id }` or `id`.
- */
-/*
-type DispatchRule = SingleProperty<> | string
-
-type Dispatch = RangeMapArray<DispatchRule>
-
-type DispatchMap = { readonly[id in string]: Dispatch }
-*/

package/bnf/data/test.f.d.ts

@@ -2,6 +2,9 @@ declare const _default: {
     toData: (() => void)[];
     variantTest: () => void;
     dispatch: (() => void)[];
+    parser: (() => void)[];
+    repeat: (() => void)[];
+    repeatParser: (() => void)[];
     example: () => void;
 };
 export default _default;

package/bnf/data/test.f.js

@@ -1,8 +1,11 @@
 import { stringify } from "../../json/module.f.js";
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { identity } from "../../types/function/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-import { range } from "../module.f.js";
+import { join0Plus, max, option, range, remove, repeat, repeat0Plus, set } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
-import { dispatchMap, toData } from "./module.f.js";
+import { dispatchMap, parser, parserRuleSet, toData } from "./module.f.js";
 export default {
     toData: [
         () => {
@@ -12,28 +15,28 @@ export default {
         () => {
             const stringRule = 'true';
             const result = stringify(sort)(toData(stringRule));
-            if (result != '[{"":["0","1","2","3"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917},""]') {
+            if (result !== '[{"":["0","1","2","3"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917},""]') {
                 throw result;
             }
         },
         () => {
             const terminalRangeRule = range('AF');
             const result = stringify(sort)(toData(terminalRangeRule));
-            if (result != '[{"":1090519110},""]') {
+            if (result !== '[{"":1090519110},""]') {
                 throw result;
             } //1090519110 = 65 * 2^24 + 70
         },
         () => {
             const sequenceRangeRule = [range('AF'), range('af')];
             const result = stringify(sort)(toData(sequenceRangeRule));
-            if (result != '[{"":["0","1"],"0":1090519110,"1":1627390054},""]') {
+            if (result !== '[{"":["0","1"],"0":1090519110,"1":1627390054},""]') {
                 throw result;
             }
         },
         () => {
             const lazyRule = () => 'true';
             const result = stringify(sort)(toData(lazyRule));
-            if (result != '[{"":1946157172,"0":1912602738,"1":1962934389,"2":1694498917,"lazyRule":["","0","1","2"]},"lazyRule"]') {
+            if (result !== '[{"":1946157172,"0":1912602738,"1":1962934389,"2":1694498917,"lazyRule":["","0","1","2"]},"lazyRule"]') {
                 throw result;
             }
         },
@@ -41,7 +44,7 @@ export default {
             const varintRule = { true: 'true', false: 'false' };
             const result = stringify(sort)(toData(varintRule));
             const expected = '[{"":{"false":"5","true":"0"},"0":["1","2","3","4"],"1":1946157172,"2":1912602738,"3":1962934389,"4":1694498917,"5":["6","7","8","9","4"],"6":1711276134,"7":1627390049,"8":1811939436,"9":1929379955},""]';
-            if (result != expected) {
+            if (result !== expected) {
                 throw [result, expected];
             }
         },
@@ -50,15 +53,44 @@ export default {
             const lazyRule0 = () => 'false';
             const result = stringify(sort)(toData([lazyRule, lazyRule0]));
             const expected = '[{"":["lazyRule","lazyRule0"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917,"4":1711276134,"5":1627390049,"6":1811939436,"7":1929379955,"lazyRule":["0","1","2","3"],"lazyRule0":["4","5","6","7","3"]},""]';
-            if (result != expected) {
+            if (result !== expected) {
                 throw [result, expected];
             }
         },
+        () => {
+            const emptyRule = '';
+            const result = stringify(sort)(toData(emptyRule));
+            const expected = '[{"":[]},""]';
+            if (result !== expected) {
+                throw [result, expected];
+            }
+        },
+        () => {
+            const optionRule = option('a');
+            const result = stringify(identity)(toData(optionRule));
+            if (result !== '[{"0":["1"],"1":1627390049,"2":[],"":{"some":"0","none":"2"}},""]') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatRule = repeat0Plus(option('a'));
+            const result = stringify(identity)(toData(repeatRule));
+            if (result !== '[{"0":{"some":"1","none":"3"},"1":["2"],"2":1627390049,"3":[],"":["0","r"],"r":{"some":"","none":"3"}},"r"]') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatRule = repeat0Plus(set(' \n\r\t'));
+            const result = stringify(identity)(toData(repeatRule));
+            if (result !== '[{"0":{" ":"1","\\n":"2","\\r":"3","\\t":"4"},"1":536870944,"2":167772170,"3":218103821,"4":150994953,"5":[],"":["0","r"],"r":{"some":"","none":"5"}},"r"]') {
+                throw result;
+            }
+        }
     ],
     variantTest: () => {
         const varintRule = { a: 'a', b: 'b' };
         const result = stringify(sort)(toData(varintRule));
-        if (result != '[{"":{"a":"0","b":"2"},"0":["1"],"1":1627390049,"2":["3"],"3":1644167266},""]') {
+        if (result !== '[{"":{"a":"0","b":"2"},"0":["1"],"1":1627390049,"2":["3"],"3":1644167266},""]') {
             throw result;
         }
     },
@@ -68,7 +100,7 @@ export default {
             const data = toData(terminalRangeRule);
             const dm = dispatchMap(data[0]);
             const result = JSON.stringify(dm);
-            if (result != '{"":{"rangeMap":[[null,64],[{"rules":[]},70]]}}') {
+            if (result !== '{"":{"rangeMap":[[null,64],[{"rules":[]},70]]}}') {
                 throw result;
             }
         },
@@ -77,7 +109,18 @@ export default {
             const data = toData(stringRule);
             const dm = dispatchMap(data[0]);
             const result = JSON.stringify(dm);
-            if (result != '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"rules":[{"rangeMap":[[null,65],[{"rules":[]},66]]}]},65]]}}') {
+            if (result !== '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"rules":["1"]},65]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const a = range('AA');
+            const b = range('BB');
+            const ab = [a, b];
+            const data = toData(ab);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"rules":["1"]},65]]}}') {
                 throw result;
             }
         },
@@ -86,7 +129,7 @@ export default {
             const data = toData(emptyRule);
             const dm = dispatchMap(data[0]);
             const result = JSON.stringify(dm);
-            if (result != '{"":{"emptyTag":true,"rangeMap":[]}}') {
+            if (result !== '{"":{"emptyTag":true,"rangeMap":[]}}') {
                 throw result;
             }
         },
@@ -95,7 +138,7 @@ export default {
             const data = toData(variantRule);
             const dm = dispatchMap(data[0]);
             const result = JSON.stringify(dm);
-            if (result != '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"tag":"a","rules":[]},65],[{"tag":"b","rules":[]},66]]}}') {
+            if (result !== '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"tag":"a","rules":[]},65],[{"tag":"b","rules":[]},66]]}}') {
                 throw result;
             }
         },
@@ -105,10 +148,276 @@ export default {
             const data = toData(variantRule);
             const dm = dispatchMap(data[0]);
             const result = JSON.stringify(dm);
-            if (result != '{"0":{"emptyTag":true,"rangeMap":[]},"1":{"rangeMap":[[null,64],[{"rules":[]},65]]},"":{"emptyTag":"e","rangeMap":[[null,64],[{"tag":"a","rules":[]},65]]}}') {
+            if (result !== '{"0":{"emptyTag":true,"rangeMap":[]},"1":{"rangeMap":[[null,64],[{"rules":[]},65]]},"":{"emptyTag":"e","rangeMap":[[null,64],[{"tag":"a","rules":[]},65]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minursRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const data = toData(numberRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"emptyTag":"none","rangeMap":[[null,44],[{"tag":"minus","rules":[]},45]]},"1":{"emptyTag":true,"rangeMap":[]},"2":{"rangeMap":[[null,44],[{"rules":[]},45]]},"3":{"rangeMap":[[null,47],[{"rules":[]},57]]},"":{"rangeMap":[[null,44],[{"tag":"minus","rules":["3"]},45],[null,47],[{"rules":[]},57]]}}') {
                 throw result;
             }
         },
+        () => {
+            const emptyRule = '';
+            const spaceRule = range('  ');
+            const optionalSpaceRule = { 'none': emptyRule, 'space': spaceRule };
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalSpaceRule, optionalMinusRule, digitRule];
+            const data = toData(numberRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"emptyTag":"none","rangeMap":[[null,31],[{"tag":"space","rules":[]},32]]},"1":{"emptyTag":true,"rangeMap":[]},"2":{"rangeMap":[[null,31],[{"rules":[]},32]]},"3":{"emptyTag":"none","rangeMap":[[null,44],[{"tag":"minus","rules":[]},45]]},"4":{"rangeMap":[[null,44],[{"rules":[]},45]]},"5":{"rangeMap":[[null,47],[{"rules":[]},57]]},"":{"rangeMap":[[null,31],[{"tag":"space","rules":["3","5"]},32],[null,44],[{"tag":"minus","rules":["5"]},45],[null,47],[{"rules":[]},57]]}}') {
+                throw result;
+            }
+        }
+    ],
+    parser: [
+        () => {
+            const emptyRule = '';
+            const m = parser(emptyRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":true,"sequence":[]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const m = parser(emptyRule);
+            const mr = m("", [65, 70]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":true,"sequence":[]},true,[65,70]]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const m = parser(terminalRangeRule);
+            const mr = m("", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[65]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const m = parser(terminalRangeRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const m = parser(variantRule);
+            const mr = m("", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"a","sequence":[65]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const m = parser(variantRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const m = parser(variantRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"e","sequence":[]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const m = parser(variantRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"e","sequence":[]},true,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const m = parser(stringRule);
+            const mr = m("", [65, 66]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[65,{"sequence":[66]}]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const m = parser(stringRule);
+            const mr = m("", [65, 67]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[67]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minursRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = parser(numberRule);
+            const mr = m("", [50]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[50]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = parser(numberRule);
+            const mr = m("", [45, 50]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"minus","sequence":[45,{"sequence":[50]}]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const m = parser(option('a'));
+            const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
+            const expect = (s, success) => {
+                const mr = m('', toArray(stringToCodePointList(s)));
+                if (isSuccess(mr) !== success) {
+                    throw mr;
+                }
+            };
+            expect('a', true);
+            expect('', true);
+            expect('aa', false);
+            expect('b', false);
+        },
+        () => {
+            const ws = repeat0Plus(set(' \n\r\t'));
+            const commaJoin0Plus = ([open, close], a) => [
+                open,
+                ws,
+                join0Plus([a, ws], [',', ws]),
+                close,
+            ];
+            const value = () => ({
+                object: commaJoin0Plus('{}', 'a'),
+                array: commaJoin0Plus('[]', 'a')
+            });
+            value.name; //bun will fail if no usage of name found
+            const m = parser(value);
+            const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
+            const expect = (s, success) => {
+                const mr = m('value', toArray(stringToCodePointList(s)));
+                if (isSuccess(mr) !== success) {
+                    throw mr;
+                }
+            };
+            expect('[]', true);
+            expect('[a]', true);
+            expect('[a, a]', true);
+            expect('{a}', true);
+        },
+        () => {
+            const m = parser(deterministic());
+            const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
+            const expect = (s, success) => {
+                const mr = m('', toArray(stringToCodePointList(s)));
+                if (isSuccess(mr) !== success) {
+                    throw mr;
+                }
+            };
+            expect('   true   ', true);
+            expect('   tr2ue   ', false);
+            expect('   true"   ', false);
+            expect('   "Hello"   ', true);
+            expect('   "Hello   ', false);
+            expect('   "Hello\\n\\r\\""   ', true);
+            expect('   -56.7e+5  ', true);
+            expect('   h-56.7e+5   ', false);
+            expect('   -56.7e+5   3', false);
+            expect('   [] ', true);
+            expect('   {} ', true);
+            expect('   [[[]]] ', true);
+            expect('   [1] ', true);
+            expect('   [ 12, false, "a"]  ', true);
+            expect('   [ 12, false2, "a"]  ', false);
+            expect('   { "q": [ 12, false, [{"b" : "c"}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [}], "a"] }  ', false);
+            expect('   [{ "q": [ 12, false, [{}], "a"] }]  ', true);
+            expect('   [{ "q": [ 12, false, [}], "a"] }]  ', false);
+        }
+    ],
+    repeat: [
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const dm = dispatchMap(repeatData[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"ws":{"emptyTag":true,"rangeMap":[]},"a":{"rangeMap":[[null,64],[{"rules":[]},65]]},"repa":{"rangeMap":[[null,64],[{"rules":[""]},65]]},"":{"rangeMap":[[null,64],[{"rules":[""]},65]]}}') {
+                throw result;
+            }
+        }
+    ],
+    repeatParser: [
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const m = parserRuleSet(repeatData[0]);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},true,null]') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const m = parserRuleSet(repeatData[0]);
+            const mr = m("", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[65,{"sequence":[]}]},true,null]') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const m = parserRuleSet(repeatData[0]);
+            const mr = m("", [65, 65, 65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[65,{"sequence":[65,{"sequence":[65,{"sequence":[]}]}]}]},true,null]') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const m = parserRuleSet(repeatData[0]);
+            const mr = m("", [66]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[66]]') {
+                throw result;
+            }
+        }
     ],
     example: () => {
         const grammar = {

package/bnf/module.f.d.ts

@@ -1,9 +1,10 @@
 import { type Array2 } from '../types/array/module.f.ts';
 /**
- * A range of symbols (48 bits)
+ * A range of symbols. Two 24-bit numbers are stored in one JS number (48 bits).
+ *
  * For example: 0xBBBBBB_EEEEEE
- * - 0xBBBBBB is the first symbol
- * - 0xEEEEEE is the last symbol
+ * - 0xBBBBBB is the first symbol (24 bits)
+ * - 0xEEEEEE is the last symbol (24 bits)
  */
 export type TerminalRange = number;
 /** A sequence of rules. */
@@ -34,8 +35,8 @@ export declare const remove: (range: TerminalRange, removeSet: RangeVariant) =>
 export type None = readonly [];
 export declare const none: None;
 export type Option<S> = {
-    none: None;
     some: S;
+    none: None;
 };
 export declare const option: <S extends Rule>(some: S) => Option<S>;
 export type Repeat0Plus<T> = () => Option<readonly [T, Repeat0Plus<T>]>;

package/bnf/module.f.js

@@ -69,8 +69,8 @@ export const remove = (range, removeSet) => {
 };
 export const none = [];
 export const option = (some) => ({
-    none,
     some,
+    none,
 });
 /**
  * Repeat zero or more times.