subscript 7.6.2 → 8.0.1

package/README.md

@@ -1,126 +1,88 @@
-# <img alt="subscript" src="/subscript2.svg" height=28/> <!--sub͘<em>script</em>--> <!--<sub>SUB͘<em>SCRIPT</em></sub>--> <a href="https://github.com/spectjs/subscript/actions/workflows/node.js.yml"><img src="https://github.com/spectjs/subscript/actions/workflows/node.js.yml/badge.svg"/></a> <a href="http://npmjs.org/subscript"><img src="https://img.shields.io/npm/v/subscript"/></a> <a href="http://microjs.com/#subscript"><img src="https://img.shields.io/badge/microjs-subscript-blue?color=darkslateblue"/></a>
+# <img alt="subscript" src="/subscript2.svg" height=28/> <!--sub͘<em>script</em>--> <!--<sub>SUB͘<em>SCRIPT</em></sub>--> <a href="https://github.com/spectjs/subscript/actions/workflows/node.js.yml"><img src="https://github.com/spectjs/subscript/actions/workflows/node.js.yml/badge.svg"/></a> <a href="https://bundlephobia.com/package/subscript"><img alt="npm bundle size" src="https://img.shields.io/bundlephobia/minzip/subscript/latest?color=brightgreen&label=gzip"/></a> <a href="http://npmjs.org/subscript"><img src="https://img.shields.io/npm/v/subscript"/></a> <a href="http://microjs.com/#subscript"><img src="https://img.shields.io/badge/microjs-subscript-blue?color=darkslateblue"/></a>
 
-_Subscript_ is expression evaluator / microlanguage with [common syntax](https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(syntax)) (JavaScript, Java, C, C++, Rust, Go, Python, Kotlin etc).<br/>
+> _Subscript_ is fast, tiny & extensible expression evaluator / microlanguage.
 
-* Tiny size <sub><a href="https://bundlephobia.com/package/subscript"><img alt="npm bundle size" src="https://img.shields.io/bundlephobia/minzip/subscript/latest?color=brightgreen&label=gzip"/></a></sub>
-* :rocket: Fast [performance](#performance)
-* Configurable & extensible
-* Trivial to use
-
-```js
-import subscript, { parse, compile } from './subscript.js'
-
-// create expression evaluator
-let fn = subscript('a.b + Math.sqrt(c - 1)')
-fn({ a: { b:1 }, c: 5, Math }) // 3
-
-// --- or ---
-// parse expression
-let tree = parse('a.b + c')
-tree // ['+', ['.', 'a', 'b'], 'c']
-
-// compile tree to evaluable function
-fn = compile(tree)
-fn({a:{b:1}, c:2}) // 3
-```
-
-## Motivation
-
-_Subscript_ is designed to be useful for:
+Used for:
 
 * templates (eg. [sprae](https://github.com/dy/sprae), [templize](https://github.com/dy/templize))
 * expressions evaluators, calculators
 * subsets of languages (eg. [justin](#justin))
-* pluggable/configurable/mock language features (eg. pipe operator)
 * sandboxes, playgrounds, safe eval
-* custom DSL (see [mell](https://github.com/dy/lino)) <!-- uneural -->
-* preprocessors (see [prepr](https://github.com/dy/prepr))
+* custom DSL (eg. [mell](https://github.com/dy/lino)) <!-- uneural -->
+* preprocessors (eg. [prepr](https://github.com/dy/prepr))
+
+_Subscript_ has [3.5kb](https://npmfs.com/package/subscript/7.4.3/subscript.min.js) footprint (compare to [11.4kb](https://npmfs.com/package/jsep/1.2.0/dist/jsep.min.js) _jsep_ + [4.5kb](https://npmfs.com/package/expression-eval/5.0.0/dist/expression-eval.module.js) _expression-eval_), good [performance](#performance) and wide test coverage.
+
+
+## Usage
+
+```js
+import subscript from './subscript.js'
 
-_Subscript_ has [3.5kb](https://npmfs.com/package/subscript/7.4.3/subscript.min.js) footprint, compared to [11.4kb](https://npmfs.com/package/jsep/1.2.0/dist/jsep.min.js) _jsep_ + [4.5kb](https://npmfs.com/package/expression-eval/5.0.0/dist/expression-eval.module.js) _expression-eval_, with better test coverage and better performance.
+// parse expression
+const fn = subscript('a.b + Math.sqrt(c - 1)')
 
+// evaluate with context
+fn({ a: { b:1 }, c: 5, Math })
+// 3
+```
 
-## Operators / literals
+## Operators
 
-<small>↑ precedence order</small>
+_Subscript_ supports [common syntax](https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(syntax)) (shared by _JavaScript_,_C_, _C++_, _Java_, _C#_, _PHP_, _Swift_, _Objective-C_, _Kotlin_, _Perl_ etc.):
 
-* `( a, b, c )`
-* `a.b`, `a[b]`, `a(b, c)`
-* `a++`, `a--` unary postfix
-* `!a`, `+a`, `-a`, `++a`, `--a` unary prefix
+* `a.b`, `a[b]`, `a(b)`
+* `a++`, `a--`, `++a`, `--a`
 * `a * b`, `a / b`, `a % b`
-* `a + b`, `a - b`
-* `a << b`, `a >> b`, `a >>> b`
-* `a < b`, `a <= b`, `a > b`, `a >= b`
-* `a == b`, `a != b`
-* `a & b`
-* `a ^ b`
-* `a | b`
-* `a && b`
-* `a || b`
-* `a , b`
-* `"abc"` strings
-* `1.2e+3` numbers
-
-## Justin
-
-_Justin_ is minimal JS subset − JSON with JS expressions (see original [thread](https://github.com/endojs/Jessie/issues/66)).<br/>
-
-It extends _subscript_ with:
-
-+ `**` exponentiation operator (right-assoc)
-+ `~` bit inversion operator
-+ `'` strings
-+ `?:` ternary operator
-+ `?.` optional chain operator
-+ `[...]` Array literal
-+ `{...}` Object literal
-+ `in` binary
-+ `;` expression separator
-+ `//`, `/* */` comments
-+ `true`, `false`, `null` literals
+* `+a`, `-a`, `a + b`, `a - b`
+* `a < b`, `a <= b`, `a > b`, `a >= b`, `a == b`, `a != b`
+* `~a`, `a & b`, `a ^ b`, `a | b`, `a << b`, `a >> b`
+* `!a`, `a && b`, `a || b`
+* `a = b`, `a += b`, `a -= b`, `a *= b`, `a /= b`, `a %= b`
+* `(a, (b))`, `a; b;`
+* `"abc"`, `'abc'`
+* `0.1`, `1.2e+3`
+
+### Justin
+
+_Justin_ is minimal JS subset, _JSON_ + _Expressions_ (see [thread](https://github.com/endojs/Jessie/issues/66)). It extends _subscript_ with:
+
++ `a ** b` (right-assoc)
++ `a ? b : c`
++ `a?.b`
++ `[a, b]` Array
++ `{a: b}` Object
++ `a in b`
++ `// foo`, `/* bar */`
++ `true`, `false`, `null`
 <!-- + `...x` unary operator -->
 <!-- + strings interpolation -->
 
 ```js
-import jstin from 'subscript/justin.js'
+import jstin from './justin.js'
 
 let xy = jstin('{ x: 1, "y": 2+2 }["x"]')
 xy()  // 1
 ```
 
-## Extending
 
-Operators/tokens can be extended via:
+## Parse / Compile
 
-* `unary(str, precedence, postfix=false)` − register unary operator, either prefix or postfix.
-* `binary(str, precedence, rightAssoc=false)` − register binary operator, optionally right-associative.
-* `nary(str, precedence, allowSkip=false)` − register n-ary (sequence) operator, optionally allowing skipping args.
-* `token(str, precedence, map)` − register custom token or literal. `map` takes last token argument and returns tree node.
-* `operator(str, fn)` − register evaluator for operator. `fn` takes node arguments and returns evaluator function.
+Subscript exposes `parse` to build AST and `compile` to create evaluators.
 
 ```js
-import script, { operator, unary, binary, token } from './subscript.js'
-
-// add ~ unary operator with precedence 15
-unary('~', 15)
-operator('~', a => ctx => ~a)
+import { parse, compile } from 'subscript'
 
-// add === binary operator with precedence 9
-binary('===', 9)
-operator('===', (a, b) => ctx => ctx[a]===ctx[b])
+// parse expression
+let tree = parse('a.b + c - 1')
+tree // ['-', ['+', ['.', 'a', 'b'], 'c'], [,1]]
 
-// add boolean literals
-token('true', 20, prev => ['',true])
-token('false', 20, prev => ['',false])
-operator('', boolNode => ctx => boolNode[1])
+// compile tree to evaluable function
+fn = compile(tree)
+fn({ a: {b: 1}, c: 2 }) // 3
 ```
 
-See [subscript.js](subscript.js) or [justin.js](./justin.js) for examples.
-
-
-## Syntax tree
-
-Subscript exposes separate `./parse.js` and `./compile.js` entries. Parser builds AST, compiler converts it to evaluable function.
+## Syntax Tree
 
 AST has simplified lispy tree structure (inspired by [frisk](https://ghub.io/frisk) / [nisp](https://github.com/ysmood/nisp)), opposed to [ESTree](https://github.com/estree/estree):
 
@@ -133,11 +95,37 @@ AST has simplified lispy tree structure (inspired by [frisk](https://ghub.io/fri
 ```js
 import { compile } from 'subscript.js'
 
-const fn = compile(['+', ['*', 'min', ['',60]], ['','sec']])
+const fn = compile(['+', ['*', 'min', [,60]], [,'sec']])
 
 fn({min: 5}) // min*60 + "sec" == "300sec"
 ```
 
+## Extending
+
+_Subscript_ provides API to customize or extend syntax:
+
+* `unary(str, precedence, postfix=false)` − register unary operator, either prefix or postfix.
+* `binary(str, precedence, rightAssoc=false)` − register binary operator, optionally right-associative.
+* `nary(str, precedence, allowSkip=false)` − register n-ary (sequence) operator, optionally allowing skipping args.
+* `token(str, precedence, prevNode => curNode)` − register custom token or literal. Function takes last token and returns tree node.
+* `operator(str, (a, b) => ctx => result)` − register evaluator for an operator. Function takes node arguments and returns evaluator function.
+
+```js
+import script, { compile, operator, unary, binary, token } from './subscript.js'
+
+// add identity operators with precedence 9
+binary('===', 9), binary('!==', 9)
+operator('===', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx)===b(ctx)))
+operator('===', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx)!==b(ctx)))
+
+// add JS literals
+token('undefined', 20, a => a ? err() : [, undefined])
+token('NaN', 20, a => a ? err() : [, NaN])
+```
+
+See [`./feature/*`](./feature) for examples.
+
+
 <!--
 ## Ideas
 
@@ -151,133 +139,31 @@ template-parts proposal
 </template>
 ```
 
-// a.b.c
-// (node, c) => c === PERIOD ? (index++, space(), ['.', node, '"'+id()+'"']) : node,
-
-// a[b][c]
-// (node, c) => c === OBRACK ? (index++, node=['.', node, expr(CBRACK)], index++, node) : node,
-
-// a(b)(c)
-// (node, c, arg) => c === OPAREN ? (
-//   index++, arg=expr(CPAREN),
-//   node = Array.isArray(arg) && arg[0]===',' ? (arg[0]=node, arg) : arg == null ? [node] : [node, arg],
-//   index++, node
-// ) : node,
-
-<details>
-  <summary>Keyed arrays <code>[a:1, b:2, c:3]</code></summary>
-
-  ```js
-
-  ```
-</details>
-
-<details>
-  <summary>`7!` (factorial)</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`5s`, `5rem` (units)</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`?`, `?.`, `??`</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`arrᵀ` - transpose,</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`int 5` (typecast)</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`$a` (param expansion)</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`1 to 10 by 2`</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`a if b else c`</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`a, b in c`</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>`a.xyz` swizzles</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>vector operators</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>set operators</summary>
-
-  ```js
-  ```
-
-</details>
-<details>
-  <summary>polynomial operators</summary>
-
-  ```js
-  ```
-
-</details>
+* Keyed arrays <code>[a:1, b:2, c:3]</code>
+* 7!` (factorial)
+* `5s`, `5rem` (units)
+* `?`, `?.`, `??`
+* `arrᵀ` - transpose
+* `int 5` (typecast)
+* `$a` (param expansion)
+* `1 to 10 by 2`
+* `a if b else c`
+* `a, b in c`
+* `a.xyz` swizzles
+* vector operators
+* set operators
+* polynomial operators
 
 like versions, units, hashes, urls, regexes etc
 
 2a as `2*a`
 
 string interpolation ` ${} 1 ${} `
-
-keyed arrays? [a:1, b:2, c:3]
-
-Examples: sonr, template-parts, neural-chunks
 -->
 
 ## Performance
 
-Subscript shows relatively good performance within other evaluators. Example expression:
+Subscript shows good performance within other evaluators. Example expression:
 
 ```
 1 + (a * b / c % d) - 2.0 + -3e-3 * +4.4e4 / f.g[0] - i.j(+k == 1)(0)
@@ -286,11 +172,10 @@ Subscript shows relatively good performance within other evaluators. Example exp
 Parse 30k times:
 
 ```
-es-module-lexer: 50ms 🥇
-subscript: ~150 ms 🥈
+subscript: ~150 ms 🥇
 justin: ~183 ms
-jsep: ~270 ms 🥉
-jexpr: ~297 ms
+jsep: ~270 ms 🥈
+jexpr: ~297 ms 🥉
 mr-parser: ~420 ms
 expr-eval: ~480 ms
 math-parser: ~570 ms

package/feature/access.js

@@ -0,0 +1,11 @@
+import { token, expr, err } from '../src/parse.js'
+import { operator, compile, access } from '../src/compile.js'
+import { CBRACK, CPAREN, PREC_ACCESS } from '../src/const.js'
+
+// a[b]
+token('[', PREC_ACCESS, a => a && ['[', a, expr(0, CBRACK) || err()])
+operator('[', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx)[b(ctx)]))
+
+// a.b
+token('.', PREC_ACCESS, (a, b) => a && (b = expr(PREC_ACCESS)) && ['.', a, b])
+operator('.', (a, b) => (a = compile(a), b = !b[0] ? b[1] : b, ctx => a(ctx)[b])) // a.true, a.1 → needs to work fine

package/feature/add.js

@@ -0,0 +1,22 @@
+
+import { binary, unary } from '../src/parse.js'
+import { PREC_ADD, PREC_PREFIX, PREC_ASSIGN } from '../src/const.js'
+import { compile, access, operator } from '../src/compile.js'
+
+unary('+', PREC_PREFIX), operator('+', (a, b) => !b && (a = compile(a), ctx => +a(ctx)))
+unary('-', PREC_PREFIX), operator('-', (a, b) => !b && (a = compile(a), ctx => -a(ctx)))
+
+binary('+', PREC_ADD), operator('+', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) + b(ctx)))
+binary('-', PREC_ADD), operator('-', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) - b(ctx)))
+
+binary('+=', PREC_ASSIGN, true)
+operator('+=', (a, b) => (
+  b = compile(b),
+  access(a, (container, path, ctx) => container(ctx)[path(ctx)] += b(ctx))
+))
+
+binary('-=', PREC_ASSIGN, true)
+operator('-=', (a, b) => (
+  b = compile(b),
+  access(a, (container, path, ctx) => (container(ctx)[path(ctx)] -= b(ctx)))
+))

package/feature/array.js

@@ -0,0 +1,11 @@
+import { token, expr } from '../src/parse.js'
+import { operator, compile } from '../src/compile.js'
+import { CBRACK, PREC_TOKEN } from '../src/const.js'
+
+// [a,b,c]
+token('[', PREC_TOKEN, (a) => !a && ['[', expr(0, CBRACK) || ''])
+operator('[', (a, b) => !b && (
+  !a ? () => [] : // []
+    a[0] === ',' ? (a = a.slice(1).map(compile), ctx => a.map(a => a(ctx))) : // [a,b,c]
+      (a = compile(a), ctx => [a(ctx)]) // [a]
+))

package/feature/assign.js

@@ -0,0 +1,11 @@
+import { binary, err } from "../src/parse.js";
+import { compile, operator, operators, access } from "../src/compile.js";
+import { PREC_ASSIGN } from "../src/const.js";
+
+// assignments
+binary('=', PREC_ASSIGN, true)
+operator('=', (a, b) => (
+  b = compile(b),
+  // a = x, ((a)) = x, a.b = x, a['b'] = x
+  access(a, (container, path, ctx) => container(ctx)[path(ctx)] = b(ctx))
+))

package/feature/bitwise.js

@@ -0,0 +1,15 @@
+import { PREC_OR, PREC_AND, PREC_SHIFT, PREC_XOR, PREC_PREFIX } from "../src/const.js"
+import { unary, binary } from "../src/parse.js"
+import { operator, compile } from "../src/compile.js"
+
+unary('~', PREC_PREFIX), operator('~', (a, b) => !b && (a = compile(a), ctx => ~a(ctx)))
+
+binary('|', PREC_OR), operator('|', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) | b(ctx)))
+
+binary('&', PREC_AND), operator('&', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) & b(ctx)))
+
+binary('^', PREC_XOR), operator('^', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) ^ b(ctx)))
+
+binary('>>', PREC_SHIFT), operator('>>', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) >> b(ctx)))
+
+binary('<<', PREC_SHIFT), operator('<<', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) << b(ctx)))

package/feature/bool.js

@@ -0,0 +1,5 @@
+import { token } from "../src/parse.js"
+import { PREC_TOKEN } from "../src/const.js"
+
+token('true', PREC_TOKEN, a => a ? err() : [, true])
+token('false', PREC_TOKEN, a => a ? err() : [, false])

package/feature/call.js

@@ -0,0 +1,15 @@
+import { token, expr, err } from '../src/parse.js'
+import { operator, compile, access } from '../src/compile.js'
+import { CBRACK, CPAREN, PREC_ACCESS } from '../src/const.js'
+
+// a(b,c,d), a()
+token('(', PREC_ACCESS, (a, b) => a && (b = expr(0, CPAREN), b ? ['(', a, b] : ['(', a, '']))
+operator('(', (a, b, args) => (
+  args = b == '' ? () => [] : // a()
+    b[0] === ',' ? (b = b.slice(1).map(compile), ctx => b.map(arg => arg(ctx))) : // a(b,c)
+      (b = compile(b), ctx => [b(ctx)]), // a(b)
+
+  // a(...args), a.b(...args), a[b](...args)
+  access(a, (obj, path, ctx) => obj(ctx)[path(ctx)](...args(ctx)), true)
+)
+)

package/feature/comment.js

@@ -0,0 +1,6 @@
+import { SPACE, STAR, PREC_TOKEN } from "../src/const.js"
+import { token, skip, cur, idx, expr } from "../src/parse.js"
+
+// /**/, //
+token('/*', PREC_TOKEN, (a, prec) => (skip(c => c !== STAR && cur.charCodeAt(idx + 1) !== 47), skip(2), a || expr(prec) || ['']))
+token('//', PREC_TOKEN, (a, prec) => (skip(c => c >= SPACE), a || expr(prec) || ['']))

package/feature/compare.js

@@ -0,0 +1,11 @@
+import { PREC_EQ } from '../src/const.js'
+import { unary, binary } from "../src/parse.js"
+import { operator, compile } from "../src/compile.js"
+
+
+binary('==', PREC_EQ), operator('==', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) == b(ctx)))
+binary('!=', PREC_EQ), operator('!=', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) != b(ctx)))
+binary('>', PREC_EQ), operator('>', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) > b(ctx)))
+binary('<', PREC_EQ), operator('<', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) < b(ctx)))
+binary('>=', PREC_EQ), operator('>=', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) >= b(ctx)))
+binary('<=', PREC_EQ), operator('<=', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) <= b(ctx)))

package/feature/group.js

@@ -0,0 +1,12 @@
+import { token, expr, err, nary } from '../src/parse.js'
+import { compile, operator } from '../src/compile.js'
+import { CPAREN, PREC_ACCESS, PREC_GROUP, PREC_SEQ } from '../src/const.js'
+
+// (a,b,c), (a)
+// FIXME: try raising group precedence (it causes conflict in ?. though)
+token('(', PREC_ACCESS, (a) => (!a && ['()', expr(0, CPAREN) || err('Empty group')]))
+operator('()', (a) => (compile(a)))
+
+const last = (...args) => (args = args.map(compile), ctx => args.map(arg => arg(ctx)).pop())
+nary(',', PREC_SEQ), operator(',', last)
+nary(';', PREC_SEQ, true), operator(';', last)

package/feature/in.js

@@ -0,0 +1,6 @@
+import { binary } from "../src/parse.js";
+import { compile, operator } from "../src/compile.js";
+import { PREC_COMP } from "../src/const.js";
+
+// a in b
+binary('in', PREC_COMP), operator('in', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) in b(ctx)))

package/feature/increment.js

@@ -0,0 +1,16 @@
+import { token, expr } from "../src/parse.js"
+import { operator, compile, access } from "../src/compile.js"
+import { PREC_POSTFIX } from "../src/const.js"
+
+let inc, dec
+token('++', PREC_POSTFIX, a => a ? ['-', ['++', a], [, 1]] : ['++', expr(PREC_POSTFIX - 1)])
+operator('++', inc = (a) =>
+  // ++a, ++((a)), ++a.b, ++a[b]
+  access(a, (obj, path, ctx) => ++obj(ctx)[path(ctx)])
+)
+
+token('--', PREC_POSTFIX, a => a ? ['+', ['--', a], [, 1]] : ['--', expr(PREC_POSTFIX - 1)])
+operator('--', dec = (a) => (
+  // --a, --a.b, --a[b]
+  access(a, (obj, path, ctx) => --obj(ctx)[path(ctx)])
+))

package/feature/logic.js

@@ -0,0 +1,15 @@
+import { PREC_LOR, PREC_LAND, PREC_PREFIX } from '../src/const.js';
+import { unary, binary, nary } from "../src/parse.js"
+import { operator, compile } from "../src/compile.js"
+
+unary('!', PREC_PREFIX), operator('!', (a, b) => !b && (a = compile(a), ctx => !a(ctx)))
+
+nary('||', PREC_LOR), operator('||', (...args) => (
+  args = args.map(compile),
+  ctx => { let arg, res; for (arg of args) if (res = arg(ctx)) return res; return res }
+))
+
+nary('&&', PREC_LAND), operator('&&', (...args) => (
+  args = args.map(compile),
+  ctx => { let arg, res; for (arg of args) if (!(res = arg(ctx))) return res; return res }
+))

package/feature/mult.js

@@ -0,0 +1,25 @@
+import { binary } from '../src/parse.js'
+import { operator, compile, access } from '../src/compile.js'
+import { PREC_MULT, PREC_ASSIGN } from '../src/const.js'
+
+binary('*', PREC_MULT), operator('*', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) * b(ctx)))
+binary('/', PREC_MULT), operator('/', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) / b(ctx)))
+binary('%', PREC_MULT), operator('%', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) % b(ctx)))
+
+binary('*=', PREC_ASSIGN, true)
+operator('*=', (a, b) => (
+  b = compile(b),
+  access(a, (container, path, ctx) => container(ctx)[path(ctx)] *= b(ctx))
+))
+
+binary('/=', PREC_ASSIGN, true)
+operator('/=', (a, b) => (
+  b = compile(b),
+  access(a, (container, path, ctx) => container(ctx)[path(ctx)] /= b(ctx))
+))
+
+binary('%=', PREC_ASSIGN, true)
+operator('%=', (a, b) => (
+  b = compile(b),
+  access(a, (container, path, ctx) => container(ctx)[path(ctx)] %= b(ctx))
+))

package/feature/number.js

@@ -0,0 +1,11 @@
+import { lookup, skip, err } from "../src/parse.js"
+import { PERIOD, _0, _E, _e, _9 } from "../src/const.js"
+
+// parse number
+const num = a => a ? err() : [, (a = +skip(c => c === PERIOD || (c >= _0 && c <= _9) || (c === _E || c === _e ? 2 : 0))) != a ? err() : a]
+
+// .1
+lookup[PERIOD] = a => (!a && num())
+
+// 0-9
+for (let i = _0; i <= _9; i++) lookup[i] = num

package/feature/object.js

@@ -0,0 +1,17 @@
+import { token, expr } from '../src/parse.js'
+import { operator, compile } from '../src/compile.js'
+import { CBRACE, PREC_SEQ, PREC_TOKEN } from '../src/const.js'
+
+
+// {a:1, b:2, c:3}
+token('{', PREC_TOKEN, a => !a && (['{', expr(0, CBRACE) || '']))
+operator('{', (a, b) => (
+  !a ? ctx => ({}) : // {}
+    a[0] === ',' ? (a = a.slice(1).map(compile), ctx => Object.fromEntries(a.map(a => a(ctx)))) : // {a:1,b:2}
+      a[0] === ':' ? (a = compile(a), ctx => Object.fromEntries([a(ctx)])) : // {a:1}
+        (b = compile(a), ctx => ({ [a]: b(ctx) }))
+))
+
+// FIXME: mb we don't need this seq raise
+token(':', PREC_SEQ + 0.1, (a, b) => (b = expr(PREC_SEQ + 0.1) || err(), [':', a, b]))
+operator(':', (a, b) => (b = compile(b), a = Array.isArray(a) ? compile(a) : (a => a).bind(0, a), ctx => [a(ctx), b(ctx)]))

package/feature/pow.js

@@ -0,0 +1,5 @@
+import { binary } from "../src/parse.js";
+import { compile, operator } from "../src/compile.js";
+import { PREC_EXP } from "../src/const.js";
+
+binary('**', PREC_EXP, true), operator('**', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) ** b(ctx)))

package/feature/string.js

@@ -0,0 +1,19 @@
+import { skip, err, cur, idx, lookup } from '../src/parse.js'
+import { DQUOTE, QUOTE, BSLASH } from '../src/const.js'
+
+const escape = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v' },
+  string = q => (qc, c, str = '') => {
+    qc && err('Unexpected string') // must not follow another token
+    skip() // first quote
+    while (c = cur.charCodeAt(idx), c - q) {
+      if (c === BSLASH) skip(), c = skip(), str += escape[c] || c
+      else str += skip()
+    }
+    skip() || err('Bad string')
+    return [, str]
+  }
+
+
+// "' with /
+lookup[DQUOTE] = string(DQUOTE)
+lookup[QUOTE] = string(QUOTE)

package/feature/ternary.js

@@ -0,0 +1,7 @@
+import { token, expr } from '../src/parse.js'
+import { operator, compile } from '../src/compile.js'
+import { PREC_ASSIGN, COLON } from '../src/const.js'
+
+// ?:
+token('?', PREC_ASSIGN, (a, b, c) => a && (b = expr(PREC_ASSIGN, COLON)) && (c = expr(PREC_ASSIGN + 1), ['?', a, b, c]))
+operator('?', (a, b, c) => (a = compile(a), b = compile(b), c = compile(c), ctx => a(ctx) ? b(ctx) : c(ctx)))