subscript 5.5.2 → 6.0.3

package/README.md

@@ -1,20 +1,17 @@
-# <img alt="subscript" src="/subscript2.svg" height=42/> <!--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?color=indianred"/></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="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 micro-language with common syntax subset of C++, JS, Java, Python, Go, Rust, Swift, Objective C, Kotlin etc.<br/>
+_Subscript_ is micro-language with common syntax subset of C++, JS, Java, Python, Go, Rust etc.<br/>
 
-* Well-known syntax
-* Any _subscript_ fragment can be copy-pasted to any target language
-* It's tiny <sub><a href="https://bundlephobia.com/package/subscript@5.5.0"><img alt="npm bundle size" src="https://img.shields.io/bundlephobia/minzip/subscript/latest?color=brightgreen&label=gzip"/></a></sub>
-* It's :rocket: fast ([see performance](#performance))
+* Standard conventional syntax
+* Any fragment can be copy-pasted to any target language
+* Tiny size <sub><a href="https://bundlephobia.com/package/subscript@6.0.0"><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...
+* Trivial to use
 
 ```js
-import subscript from 'subscript.js'
-let fn = subscript(`a.b + c(d - 1)`)
+import script from 'subscript.js'
+let fn = script`a.b + c(d - 1)`
 fn({ a: { b:1 }, c: x => x * 2, d: 3 }) // 5
 ```
 
@@ -29,115 +26,114 @@ _Subscript_ is designed to be useful for:
 * sandboxes, playgrounds, safe eval
 * custom DSL
 
-[_Jsep_](https://github.com/EricSmekens/jsep) is generally fine for the listed tasks, unless you need dependencies as small as possible.
-_Subscript_ has [2.4kb](https://npmfs.com/package/subscript/5.5.0/subscript.min.js) footprint vs [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 _jsep_ test coverage and better performance.
+_Subscript_ has [2kb](https://npmfs.com/package/subscript/6.0.0/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.
 
 
-## Evaluation
+## Design
 
-_Subscript_ parser generates lispy calltree (compatible with [frisk](https://npmjs.com/frisk)), which is compared to esprima AST has:
+Default operators are (same as JS precedence order):
 
-+ minimal possible overhead
-+ clear precedence
-+ overloading by context
-+ manual evaluation and debugging
-+ conventional form
-+ one-liner docs:
+* `( 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 + 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`
+
+Default literals:
+
+* `"abc"` strings
+* `1.2e+3` numbers
+
+Everything else can be extended via `parse.set(token, precedence, operator)` for unary or binary operators (detected by number of arguments in `operator`), or via `parse.set(token, parse, precedence)` for custom tokens.
 
 ```js
-import {evaluate} from 'subscript.js'
+import script from 'subscript.js'
 
-evaluate(['+', ['*', 'min', 60], '@sec'], { min: 5 }) // min*60 + "sec" == "300sec"
-```
+// add ~ unary operator with precedence 15
+script.set('~', 15, a => ~a)
 
-## Extending
+// add === binary operator
+script.set('===', 9, (a, b) => a===b)
 
-### Operators 
+// add literals
+script.set('true', a => ()=>true)
+script.set('false', a => ()=>false)
 
-Default operators include common operators for the listed languages in the following precedence:
+script`true === false`() // false
+```
 
-* `++ --` unary postfix
-* `! + - ++ --` unary prefix
-* `* / %`
-* `+ -`
-* `<< >> >>>`
-* `< <= > >=`
-* `== !=`
-* `&`
-* `^`
-* `|`
-* `&&`
-* `||`
+See [subscript.js](subscript.js) or [justin.js](./justin.js) for examples.
 
-Operators can be extended via `parse.operator(str, prec, type)` and `evaluate.operator(str, fn)` functions for any unary/binary/postfix operators, calls, prop chains, groups etc.
+<!--
+Operators can be extended via .
 
 ```js
-import { parse, evaluate } from 'subscript.js'
-
-parse.operator('=>', 10) // precedence=10, type=default (0 - binary, 1 - postfix, -1 - prefix)
+import script from 'subscript.js'
 
-evaluate.operator('=>', ( args, body ) => evaluate(body, args))
-evaluate.operator('|', ( a, b ) => a.pipe(b))
+script.set('|', 10, ( a, b ) => a.pipe(b))
 
-let tree = parse(`
+let evaluate = script(`
   interval(350)
   | take(25)
   | map(gaussian)
-  | map(num => "•".repeat(Math.floor(num * 65)))
+  | "•".repeat(Math.floor(it * 65)))
 `)
-evaluate(tree, { Math, map, take, interval, gaussian })
+evaluate({ Math, map, take, interval, gaussian })
 ```
 
-### Tokens
-
-Default tokens include:
-
-* `"abc"` strings
-* `1.2e+3` floats
-* `name` identifiers
-
-Tokens are extensible via `parse.token` list, can be added support of _literals_, _regexes_, _strings_, _numbers_ and others.
+Literals are extensible by providing custom parser to `lookup`, can be added support of _booleans_, function calls, prop chains, groups, _regexes_, _strings_, _numbers_ and any other constructs.
 
 ```js
-import parse, {char} from 'subscript/parse.js'
-import evaluate from 'subscript/evaluate.js'
+import script from 'subscript.js'
 
-conts ctx = {x:1}
-parse.token.unshift(c => char(4) === 'this' ? ctx : null)
-evaluate(parse(`this.x`)) // 1
+script.literal.unshift(c => skip('this') && {x:1})
+script`this.x`() // 1
 ```
 
-### Spaces/comments
+### Identifiers
+
+Identifiers include
 
-Comments can be added via extending `parse.space`. See [justin.js](./justin.js) for more examples.
+### Spaces/comments
 
+Comments can be added via extending `parse.space`.
+-->
 
 ## Justin
 
-_Justin_ extension (original [thread](https://github.com/endojs/Jessie/issues/66)) is minimal JS subset − JSON with JS expressions.<br/>
-It adds support of:
+_Justin_ is minimal JS subset − JSON with JS expressions (see original [thread](https://github.com/endojs/Jessie/issues/66)).<br/>
+
+It extends _subscript_ with:
 
 + `===`, `!==` operators
-+ `**` binary operator
-+ `~` unary operator
++ `**` exponentiation operator (right-assoc)
++ `~` bit inversion operator
 + `'` strings
 + `?:` ternary operator
++ `?.` optional chain operator
 + `[...]` Array literal
 + `{...}` Object literal
-+ `in` binary operator
++ `in` binary
 + `;` expression separator
-+ unary word operators
 + `//`, `/* */` comments
 + `true`, `false`, `null`, `undefined` literals
-<!-- + `?` chaining operator -->
 <!-- + `...x` unary operator -->
 <!-- + strings interpolation -->
 
 ```js
-import { parse, evaluate } from 'subscript/justin.js'
+import jstin from 'subscript/justin.js'
 
-let xy = parse('{ x: 1, "y": 2+2 }["x"]') // ['[', {x:1, y: ['+', 2, 2]}, '@x']
-evaluate(xy)  // 1
+let xy = jstin('{ x: 1, "y": 2+2 }["x"]')
+xy()  // 1
 ```
 
 <!--
@@ -282,19 +278,40 @@ Examples: sonr, template-parts, neural-chunks
 Subscript shows relatively good performance within other evaluators:
 
 ```
-// 1 + (a * b / c % d) - 2.0 + -3e-3 * +4.4e4 / f.g[0] - i.j(+k == 1)(0)
-// parse 30k times
+1 + (a * b / c % d) - 2.0 + -3e-3 * +4.4e4 / f.g[0] - i.j(+k == 1)(0)
+```
 
-subscript: ~230 ms
-jsep: ~280 ms
+Parse 30k times:
+
+```
+subscript: ~170 ms 🥇
+justin: ~183 ms 🥈
+jsep: ~270 ms 🥉
+mr-parser: ~420 ms
 expr-eval: ~480 ms
-jexl: ~1200 ms
-new Function: ~1400 ms
+math-parser: ~570 ms
+math-expression-evaluator: ~900ms
+jexl: ~1056 ms
+mathjs: ~1200 ms
+new Function: ~1154 ms
+```
+
+Eval 30k times:
+```
+new Function: ~7 ms 🥇
+subscript: ~17 ms 🥈
+justin: ~17 ms 🥈
+jsep (expression-eval): ~30 ms 🥉
+math-expression-evaluator: ~50ms
+expr-eval: ~72 ms
+jexl: ~110 ms
+mathjs: ~119 ms
+mr-parser: -
+math-parser: -
 ```
 
-## See also
+## Alternatives
 
-* [Jessie](https://github.com/endojs/Jessie) − Minimal JS subset.
 * [jexl](https://github.com/TomFrost/Jexl)
 * [mozjexl](https://github.com/mozilla/mozjexl)
 * [expr-eval](https://github.com/silentmatt/expr-eval)
@@ -302,5 +319,9 @@ new Function: ~1400 ms
 * [jsep](https://github.com/EricSmekens/jsep)
 * [string-math](https://github.com/devrafalko/string-math)
 * [nerdamer](https://github.com/jiggzson/nerdamer)
+* [math-codegen](https://github.com/mauriciopoppe/math-codegen)
+* [math-parser](https://www.npmjs.com/package/math-parser)
+* [math.js](https://mathjs.org/docs/expressions/parsing.html)
+* [Jessie](https://github.com/endojs/Jessie)
 
 <p align=center>🕉</p>

package/index.js

@@ -0,0 +1,71 @@
+const SPACE=32
+
+// current string & index
+export let idx, cur,
+
+parse = (s, ...fields) => !(cur=s.raw ? String.raw(s,...fields) : s, idx=0, s=expr()) || cur[idx] ? err('Unexpected end') : ctx=>s(ctx||{}),
+
+isId = c =>
+  (c >= 48 && c <= 57) || // 0..9
+  (c >= 65 && c <= 90) || // A...Z
+  (c >= 97 && c <= 122) || // a...z
+  c == 36 || c == 95 || // $, _,
+  (c >= 192 && c != 215 && c != 247), // any non-ASCII
+
+err = (msg='Unexpected token',c=cur[idx]) => { throw SyntaxError(msg + ' `' + c + '` at ' + idx) },
+
+skip = (is=1, from=idx, l) => {
+  if (typeof is == 'number') idx += is
+  else while (is(cur.charCodeAt(idx))) idx++
+  return cur.slice(from, idx)
+},
+
+// a + b - c
+expr = (prec=0, end, cc, token, newNode, fn) => {
+  // chunk/token parser
+  while (
+    ( cc=space() ) && // till not end
+    // FIXME: extra work is happening here, when lookup bails out due to lower precedence -
+    // it makes extra `space` call for parent exprs on the same character to check precedence again
+    ( newNode =
+      (fn=lookup[cc]) && fn(token, prec) || // if operator with higher precedence isn't found
+      (!token && id()) // parse literal or quit. token seqs are forbidden: `a b`, `a "b"`, `1.32 a`
+    )
+  ) token = newNode;
+
+  // check end character
+  if (end) cc==end?idx++:err('Missing', String.fromCharCode(end))
+
+  return token
+},
+
+// skip space chars, return first non-space character
+space = cc => { while ((cc = cur.charCodeAt(idx)) <= SPACE) idx++; return cc },
+
+// variable identifier
+id = (name=skip(isId), fn) => name ? (fn=ctx => ctx[name], fn.id=()=>name, fn) : 0,
+
+// operator/token lookup table
+lookup = [],
+
+// create operator checker/mapper (see examples)
+set = parse.set = (
+  op,
+  opPrec, fn=SPACE, // if opPrec & fn come in reverse order - consider them raw parse fn case, still precedence possible
+  c=op.charCodeAt(0),
+  l=op.length,
+  prev=lookup[c],
+  arity=fn.length || ([fn,opPrec]=[opPrec,fn], 0),
+  word=op.toUpperCase()!==op, // make sure word boundary comes after word operator
+  map=
+    // binary
+    arity>1 ? (a,b) => a && (b=expr(opPrec)) && (
+      !a.length && !b.length ? (a=fn(a(),b()), ()=>a) : // static pre-eval like `"a"+"b"`
+      ctx => fn(a(ctx),b(ctx))
+    ) :
+    // unary prefix (0 args)
+    arity ? a => !a && (a=expr(opPrec-1)) && (ctx => fn(a(ctx))) :
+    fn // custom parser
+) =>
+// FIXME: find out if that's possible to globalize precision and instead of passing it to map, just provide global
+lookup[c] = (a, curPrec, from=idx) => curPrec<opPrec && (l<2||cur.substr(idx,l)==op) && (!word||!isId(cur.charCodeAt(idx+l))) && (idx+=l, map(a, curPrec)) || (idx=from, prev&&prev(a, curPrec))

package/justin.js

@@ -1,212 +1,73 @@
 // justin lang https://github.com/endojs/Jessie/issues/66
-import {evaluate} from './evaluate.js'
-import {parse, code, char, skip, expr, err, val} from './parse.js'
+import {parse, set, lookup, skip, cur, idx, err, expr, isId, space} from './index.js'
+import './subscript.js'
+
+const PERIOD=46, OPAREN=40, CPAREN=41, OBRACK=91, CBRACK=93, SPACE=32, DQUOTE=34, QUOTE=39, _0=48, _9=57, BSLASH=92,
+PREC_SEQ=1, PREC_COND=3, PREC_SOME=4, PREC_EVERY=5, PREC_OR=6, PREC_XOR=7, PREC_AND=8,
+PREC_EQ=9, PREC_COMP=10, PREC_SHIFT=11, PREC_SUM=12, PREC_MULT=13, PREC_EXP=14, PREC_UNARY=15, PREC_POSTFIX=16, PREC_CALL=18, PREC_GROUP=19
+
+
+let u, list, op, prec, fn,
+    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
+      while (c=cur.charCodeAt(idx), c-q) {
+        if (c === BSLASH) skip(), c=skip(), str += escape[c] || c
+        else str += skip()
+      }
+      return skip()||err('Bad string'), () => str
+    }
 
-const PERIOD=46, OPAREN=40, CPAREN=41, CBRACK=93, SPACE=32,
+// operators
+for (list=[
+  // "' with /
+  '"', string(DQUOTE),,
+  "'", string(QUOTE),,
 
-PREC_SEQ=1, PREC_TERN=3, PREC_SOME=4, PREC_EVERY=5, PREC_OR=6, PREC_XOR=7, PREC_AND=8,
-PREC_EQ=9, PREC_COMP=10, PREC_SHIFT=11, PREC_SUM=12, PREC_MULT=13, PREC_UNARY=15, PREC_POSTFIX=16, PREC_CALL=18, PREC_GROUP=19,
-PREC_EXP=14, PREC_TOKEN=20
+  // /**/, //
+  '/*', (a, prec) => (skip(c => c !== 42 && cur.charCodeAt(idx+1) !== 47), skip(2), a||expr(prec)),,
+  '//', (a, prec) => (skip(c => c >= 32), a||expr(prec)),,
 
+  // literals
+  'null', a => a ? err('Unexpected literal') : ()=>null,,
+  'true', a => a ? err('Unexpected literal') : ()=>true,,
+  'false', a => a ? err('Unexpected literal') : ()=>false,,
+  'undefined', a => a ? err('Unexpected literal') : ()=>undefined,,
 
-// tokens
-parse.token.push(
-  // 1.2e+3, .5 - fast & small version, but consumes corrupted nums as well
-  (number) => (
-    (number = skip(c => (c > 47 && c < 58) || c == PERIOD)) && (
-      (code() == 69 || code() == 101) && (number += skip(2) + skip(c => c >= 48 && c <= 57)),
-      isNaN(number = new Number(number)) ? err('Bad number') : number
-    )
-  ),
+  ';', a => expr()||(()=>{}),,
 
-  // "' with /
-  (q, qc, c, str) => {
-    if (q !== 34 && q !== 39) return
-    qc = char(), skip(), str = ''
-    while (c=code(), c-q) {
-      if (c === 92) skip(), str += escape[char()] || char(); else str+=char()
-      skip()
-    }
-    return skip(), '@' + str
-  },
-
-  // id
-  c => skip(c =>
-    (c >= 48 && c <= 57) || // 0..9
-    (c >= 65 && c <= 90) || // A...Z
-    (c >= 97 && c <= 122) || // a...z
-    c == 36 || c == 95 || // $, _,
-    (c >= 192 && c != 215 && c != 247) // any non-ASCII
-  )
-)
-
-const escape = {n:'\n', r:'\r', t:'\t', b:'\b', f:'\f', v:'\v'}
-
-
-// /**/, //
-parse.space = cc => {
-  while (cc = code(), cc <= 32 || cc === 47) {
-    if (cc <= 32) skip()
-    else if (cc === 47)
-      // /**/
-      if (code(1) === 42) skip(2), skip(c => c !== 42 && code(1) !== 47), skip(2)
-      // //
-      else if (code(1) === 47) skip(2), skip(c => c >= 32)
-      else break
-  }
-  return cc
-}
+  // operators
+  '===', PREC_EQ, (a,b) => a===b,
+  '!==', PREC_EQ, (a,b) => a!==b,
+  '~', PREC_UNARY, (a) => ~a,
 
+  // right order
+  '**', (a,prec,b=expr(PREC_EXP-1)) => ctx=>a(ctx)**b(ctx), PREC_EXP,
+
+  // ?:
+  ':', 3.1, (a,b) => [a,b],
+  '?', 3, (a,b) => a ? b[2] : b[1],
+
+  // a?.[, a?.( - postfix operator
+  '?.', a => a && (ctx => a(ctx)||(()=>{})),,//(a) => a||(()=>{}),
+  // a?.b - optional chain operator
+  '?.', (a,id) => (space(), id=skip(isId)) && (ctx => a(ctx)?.[id]),,
+
+  'in', PREC_COMP, (a,b) => a in b,
 
-// operators
-const addOps = (add, stride=2, list) => {
-  for (let i = 0; i < list.length; i+=stride) add(list[i], list[i+1], list[i+2])
-}
-
-addOps(parse.operator, 3, [
-  // subscript ones
- ',', PREC_SEQ,,
-
-  '|', PREC_OR,,
-  '||', PREC_SOME,,
-
-  '&', PREC_AND,,
-  '&&', PREC_EVERY,,
-
-  '^', PREC_XOR,,
-
-  // ==, !=
-  '==', PREC_EQ,,
-  '!=', PREC_EQ,,
-
-  // > >= >> >>>, < <= <<
-  '>', PREC_COMP,,
-  '>=', PREC_COMP,,
-  '>>', PREC_SHIFT,,
-  '>>>', PREC_SHIFT,,
-  '<', PREC_COMP,,
-  '<=', PREC_COMP,,
-  '<<', PREC_SHIFT,,
-
-  // + ++ - --
-  '+', PREC_SUM,,
-  '+', PREC_UNARY, -1,
-  '++', PREC_UNARY, -1,
-  '++', PREC_POSTFIX, +1,
-  '-', PREC_SUM,,
-  '-', PREC_UNARY, -1,
-  '--', PREC_UNARY, -1,
-  '--', PREC_POSTFIX, +1,
-
-  // ! ~
-  '!', PREC_UNARY, -1,
-
-  // * / %
-  '*', PREC_MULT,,
-  '/', PREC_MULT,,
-  '%', PREC_MULT,,
-
-  // a.b
-  '.', PREC_CALL, (node,b) => node && [skip(), node, '@' + expr(PREC_CALL)],
-
-  // a[b]
-  '[', PREC_CALL, (node) => (skip(), node = ['.', node, val(expr(0,CBRACK))], node),
-  ']',,,
-
-  // a(b)
-  '(', PREC_CALL, (node,b) => (skip(), b=expr(0,CPAREN),
-    Array.isArray(b) && b[0]===',' ? (b[0]=node, b) : b ? [node, val(b)] : [node]
-  ),
-  // (a+b)
-  '(', PREC_GROUP, (node,b) => !node && (skip(), b=expr(0,CPAREN) || err(), b),
-  ')',,,
-
-  // justin extension
-  ';', PREC_SEQ,,
-  '===', PREC_EQ,,
-  '!==', PREC_EQ,,
-  '**', PREC_EXP,,
-  '~', PREC_UNARY, -1,
-  '?', PREC_TERN, (node) => {
-    if (!node) err('Expected expression')
-    let a, b
-    skip(), parse.space(), a = expr()
-    return ['?:', node, a[1], a[2]]
-  },
-  ':', PREC_COMP,,
-  'in', PREC_COMP, (node) => code(2)<=32 && [skip(2), '@'+node, expr(PREC_COMP)],
-
-  // as operator it's faster to lookup (no need to extra rule check), smaller and no conflict with word names
   // [a,b,c]
-  '[', PREC_TOKEN, (node,arg) => !node && (
-    skip(), arg=expr(0,93),
-    !arg ? ['['] : arg[0] == ',' ? (arg[0]='[',arg) : ['[',arg]
-  ),
+  '[', (a, args) => !a && (
+    a=expr(0,CBRACK),
+    !a ? ctx => [] : a.all ? ctx => a.all(ctx) : ctx => [a(ctx)]
+  ),,
 
-  // {a:0, b:1}
-  '{', PREC_TOKEN, (node,arg) => !node && (skip(), arg=expr(0,125),
-    !arg ? ['{'] : arg[0] == ':' ? ['{',strkey(arg)] : arg[0] == ',' ? (arg[0]='{',arg.map(strkey)) : ['{',arg]),
-  '}',,,
+  // {a:1, b:2, c:3}
+  '{', (a, args) => !a && (
+      a=expr(0,125),
+      !a ? ctx => ({}) : ctx => (args=(a.all||a)(ctx), Object.fromEntries(a.all?args:[args]))
+    ),,
+  ':', (a, prec, b) => (b=expr(3.1)||err(), ctx => [(a.id||a)(ctx), b(ctx), a(ctx)]), 3.1
 
+]; [op,prec,fn,...list]=list, op;) set(op,prec,fn)
 
-  // literals
-  'null', PREC_TOKEN, node=>!node&&(skip(4),v(null)),
-  'false', PREC_TOKEN, node=>!node&&(skip(5),v(false)),
-  'true', PREC_TOKEN, node=>!node&&(skip(4),v(true)),
-  'undefined', PREC_TOKEN, node=>!node&&(skip(9),v(undefined)),
-])
-const strkey = a => Array.isArray(a) ? (a[1]=(a[1][0]==='@'?'':'@')+a[1],a) : a
-const v = v => ({valueOf:()=>v})
-
-addOps(evaluate.operator, 2, [
-  // subscript
-  '!', a=>!a,
-  '++', a=>++a,
-  '--', a=>--a,
-
-  '.', (a,b)=>a?a[b]:a,
-
-  '%', (a,b)=>a%b,
-  '/', (a,b)=>a/b,
-  '*', (a,b)=>a*b,
-
-  '+', (a,b)=>a+(b||0),
-  '-', (a,b)=>b==null ? -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)=>a&b,
-  '^', (a,b)=>a^b,
-  '|', (a,b)=>a|b,
-  '&&', (...a)=>a.every(Boolean),
-  '||', (...a)=>a.some(Boolean),
-  ',', (a,b)=>(a,b),
-
-  // justin extension
-  '**', (...args)=>args.reduceRight((a,b)=>Math.pow(b,a)),
-  '~', a=>~a,
-  '?:', (a,b,c)=>a?b:c,
-  'in', (a,b)=>a in b,
-
-  '[', (...args) => Array(...args),
-  '{', (...args)=>Object.fromEntries(args),
-  ':', (a,b)=>[a,b]
-])
-
-// TODO ...
-// TODO: strings interpolation
-
-export { parse, evaluate }
-
-// code → evaluator
-export default s => (s = typeof s == 'string' ? parse(s) : s,  ctx => evaluate(s, ctx))
+export default parse

package/justin.min.js

@@ -1 +1 @@
-const r=(t,n={})=>{if("string"==typeof t)return"@"===t[0]?t.slice(1):n[t];if(Array.isArray(t)){let o=t[0],a=t.length,s=Array.isArray(o)?r(o,n):e[o]||n[o]||o,l=1,i=[];if(s.ab){i=r(t[l++],n);do{i=s(i,r(t[l++],n))}while(l<a)}else{for(;l<a;)i.push(r(t[l++],n));i=s.apply(o,i)}return i}return t},e={};let t,n;r.operator=(r,t)=>(e[r]=t,t.ab=2==t.length);const o=(r,e)=>(n=r,t=0,e=f(),t<n.length?a():y(e)),a=(r="Bad syntax")=>{throw Error(r+" `"+n[t]+"` at "+t)},s=(r=1,e=t)=>{if("number"==typeof r)t+=r;else for(;r(l());)t++;return n.slice(e,t)},l=(r=0)=>n.charCodeAt(t+r),i=(r=1)=>n.substr(t,r),f=(r=0,e,n,s,l=0,i,f)=>{for(;(n=o.space())&&(i=(f=c[n])&&f(s,r)||!s&&p(n));)s=i;return e&&(n!=e?a("Unclosed paren"):t++),s};o.space=r=>{for(;(r=l())<=32;)t++;return r};const u=o.token=[],p=(r,e=0,t)=>{for(;e<u.length;)if(t=u[e++](r))return t},c=[];o.operator=(r,e=0,n=0,a,l=r.charCodeAt(0),u=r.length,p=c[l])=>(a=n?n>0?r=>r&&[s(u),y(r)]:n<0?r=>!r&&[s(u),y(f(e-1))]:n:n=>{n=[r,y(n)];do{t+=u,n.push(y(f(e)))}while(o.space()==l&&(u<2||i(u)==r));return n},c[l]=(t,n)=>n<e&&(u<2||i(u)==r)&&a(t)||p&&p(t,n));const y=r=>Array.isArray(r)?r:(r||a()).valueOf();o.token.push((r=>(r=s((r=>r>47&&r<58||46==r)))&&((69==l()||101==l())&&(r+=s(2)+s((r=>r>=48&&r<=57))),isNaN(r=new Number(r))?a("Bad number"):r)),((r,e,t,n)=>{if(34===r||39===r){for(i(),s(),n="";(t=l())-r;)92===t?(s(),n+=h[i()]||i()):n+=i(),s();return s(),"@"+n}}),(r=>s((r=>r>=48&&r<=57||r>=65&&r<=90||r>=97&&r<=122||36==r||95==r||r>=192&&215!=r&&247!=r))));const h={n:"\n",r:"\r",t:"\t",b:"\b",f:"\f",v:"\v"};o.space=r=>{for(;(r=l())<=32||47===r;)if(r<=32)s();else if(47===r)if(42===l(1))s(2),s((r=>42!==r&&47!==l(1))),s(2);else{if(47!==l(1))break;s(2),s((r=>r>=32))}return r};const d=(r,e=2,t)=>{for(let n=0;n<t.length;n+=e)r(t[n],t[n+1],t[n+2])};d(o.operator,3,[",",1,,"|",6,,"||",4,,"&",8,,"&&",5,,"^",7,,"==",9,,"!=",9,,">",10,,">=",10,,">>",11,,">>>",11,,"<",10,,"<=",10,,"<<",11,,"+",12,,"+",15,-1,"++",15,-1,"++",16,1,"-",12,,"-",15,-1,"--",15,-1,"--",16,1,"!",15,-1,"*",13,,"/",13,,"%",13,,".",18,(r,e)=>r&&[s(),r,"@"+f(18)],"[",18,r=>(s(),[".",r,y(f(0,93))]),"]",,,"(",18,(r,e)=>(s(),e=f(0,41),Array.isArray(e)&&","===e[0]?(e[0]=r,e):e?[r,y(e)]:[r]),"(",19,(r,e)=>!r&&(s(),f(0,41)||a()),")",,,";",1,,"===",9,,"!==",9,,"**",14,,"~",15,-1,"?",3,r=>{let e;return r||a("Expected expression"),s(),o.space(),e=f(),["?:",r,e[1],e[2]]},":",10,,"in",10,r=>l(2)<=32&&[s(2),"@"+r,f(10)],"[",20,(r,e)=>!r&&(s(),(e=f(0,93))?","==e[0]?(e[0]="[",e):["[",e]:["["]),"{",20,(r,e)=>!r&&(s(),(e=f(0,125))?":"==e[0]?["{",A(e)]:","==e[0]?(e[0]="{",e.map(A)):["{",e]:["{"]),"}",,,"null",20,r=>!r&&(s(4),b(null)),"false",20,r=>!r&&(s(5),b(!1)),"true",20,r=>!r&&(s(4),b(!0)),"undefined",20,r=>!r&&(s(9),b(void 0))]);const A=r=>Array.isArray(r)?(r[1]=("@"===r[1][0]?"":"@")+r[1],r):r,b=r=>({valueOf:()=>r});d(r.operator,2,["!",r=>!r,"++",r=>++r,"--",r=>--r,".",(r,e)=>r?r[e]:r,"%",(r,e)=>r%e,"/",(r,e)=>r/e,"*",(r,e)=>r*e,"+",(r,e)=>r+(e||0),"-",(r,e)=>null==e?-r:r-e,">>>",(r,e)=>r>>>e,">>",(r,e)=>r>>e,"<<",(r,e)=>r<<e,">=",(r,e)=>r>=e,">",(r,e)=>r>e,"<=",(r,e)=>r<=e,"<",(r,e)=>r<e,"!=",(r,e)=>r!=e,"==",(r,e)=>r==e,"&",(r,e)=>r&e,"^",(r,e)=>r^e,"|",(r,e)=>r|e,"&&",(...r)=>r.every(Boolean),"||",(...r)=>r.some(Boolean),",",(r,e)=>e,"**",(...r)=>r.reduceRight(((r,e)=>Math.pow(e,r))),"~",r=>~r,"?:",(r,e,t)=>r?e:t,"in",(r,e)=>r in e,"[",(...r)=>Array(...r),"{",(...r)=>Object.fromEntries(r),":",(r,e)=>[r,e]]);var g=e=>(e="string"==typeof e?o(e):e,t=>r(e,t));export{g as default,r as evaluate,o as parse};
+let e,r,t,l,n,a,d=(t,...l)=>(r=t.raw?String.raw(t,...l):t,e=0,!(t=p())||r[e]?i("Unexpected end"):e=>t(e||{})),o=e=>e>=48&&e<=57||e>=65&&e<=90||e>=97&&e<=122||36==e||95==e||e>=192&&215!=e&&247!=e,i=(t="Unexpected token",l=r[e])=>{throw SyntaxError(t+" `"+l+"` at "+e)},f=(t=1,l=e,n)=>{if("number"==typeof t)e+=t;else for(;t(r.charCodeAt(e));)e++;return r.slice(l,e)},p=(r=0,t,l,n,a,d)=>{for(;(l=c())&&(a=(d=u[l])&&d(n,r)||!n&&s());)n=a;return t&&(l==t?e++:i("Missing",String.fromCharCode(t))),n},c=t=>{for(;(t=r.charCodeAt(e))<=32;)e++;return t},s=(e=f(o),r)=>e?((r=r=>r[e]).id=()=>e,r):0,u=[],h=d.set=(t,l,n=32,a=t.charCodeAt(0),d=t.length,i=u[a],f=n.length||([n,l]=[l,n],0),c=t.toUpperCase()!==t,s=(f>1?(e,r)=>e&&(r=p(l))&&(e.length||r.length?t=>n(e(t),r(t)):(e=n(e(),r()),()=>e)):f?e=>!e&&(e=p(l-1))&&(r=>n(e(r))):n))=>u[a]=(n,a,f=e)=>a<l&&(d<2||r.substr(e,d)==t)&&(!c||!o(r.charCodeAt(e+d)))&&(e+=d,s(n,a))||(e=f,i&&i(n,a)),g=e=>e>=48&&e<=57,x=t=>(t&&i("Unexpected number"),t=f((e=>46==e||g(e))),(69==r.charCodeAt(e)||101==r.charCodeAt(e))&&(t+=f(2)+f(g)),(t=+t)!=t?i("Bad number"):()=>t),C=(e,r,t=e.of)=>l=>r(t?t(l):l,e.id());for(l=48;l<=57;)u[l++]=x;for(t=['"',e=>(e=e?i("Unexpected string"):f((e=>e-34)),f()||i("Bad string"),()=>e),,".",(e,r,t)=>e?(c(),r=f(o)||i(),(t=t=>e(t)[r]).id=()=>r,t.of=e,t):x(f(-1)),18,"[",(e,r,t)=>e&&(r=p(0,93)||i("Empty group"),(t=t=>e(t)[r(t)]).id=r,t.of=e,t),18,"(",(e,r,t)=>(r=p(0,41),e?t=>e(t).apply(e.of?.(t),r?r.all?r.all(t):[r(t)]:[]):r||i("Empty group")),18,",",(e,r,t=p(1))=>(t.all=e.all?(r,l,n=e.all(r))=>n.push(t(r))&&n:r=>[e(r),t(r)],t),1,"|",6,(e,r)=>e|r,"||",4,(e,r)=>e||r,"&",8,(e,r)=>e&r,"&&",5,(e,r)=>e&&r,"^",7,(e,r)=>e^r,"==",9,(e,r)=>e==r,"!=",9,(e,r)=>e!=r,">",10,(e,r)=>e>r,">=",10,(e,r)=>e>=r,">>",11,(e,r)=>e>>r,">>>",11,(e,r)=>e>>>r,"<",10,(e,r)=>e<r,"<=",10,(e,r)=>e<=r,"<<",11,(e,r)=>e<<r,"+",12,(e,r)=>e+r,"+",15,e=>+e,"++",e=>C(e||p(14),e?(e,r)=>e[r]++:(e,r)=>++e[r]),15,"-",12,(e,r)=>e-r,"-",15,e=>-e,"--",e=>C(e||p(14),e?(e,r)=>e[r]--:(e,r)=>--e[r]),15,"!",15,e=>!e,"*",13,(e,r)=>e*r,"/",13,(e,r)=>e/r,"%",13,(e,r)=>e%r];[l,n,a,...t]=t,l;)h(l,n,a);let U,A,b,m,y={n:"\n",r:"\r",t:"\t",b:"\b",f:"\f",v:"\v"},E=t=>(l,n,a="")=>{for(l&&i("Unexpected string");(n=r.charCodeAt(e))-t;)92===n?(f(),n=f(),a+=y[n]||n):a+=f();return f()||i("Bad string"),()=>a};for((U=['"',E(34),,"'",E(39),,"/*",(t,l)=>(f((t=>42!==t&&47!==r.charCodeAt(e+1))),f(2),t||p(l)),,"//",(e,r)=>(f((e=>e>=32)),e||p(r)),,"null",e=>e?i("Unexpected literal"):()=>null,,"true",e=>e?i("Unexpected literal"):()=>!0,,"false",e=>e?i("Unexpected literal"):()=>!1,,"undefined",e=>e?i("Unexpected literal"):()=>{},,";",e=>p()||(()=>{}),,"===",9,(e,r)=>e===r,"!==",9,(e,r)=>e!==r,"~",15,e=>~e,"**",(e,r,t=p(13))=>r=>e(r)**t(r),14,":",3.1,(e,r)=>[e,r],"?",3,(e,r)=>e?r[2]:r[1],"?.",e=>e&&(r=>e(r)||(()=>{})),,"?.",(e,r)=>(c(),(r=f(o))&&(t=>e(t)?.[r])),,"in",10,(e,r)=>e in r,"[",(e,r)=>!e&&((e=p(0,93))?e.all?r=>e.all(r):r=>[e(r)]:e=>[]),,"{",(e,r)=>!e&&((e=p(0,125))?t=>(r=(e.all||e)(t),Object.fromEntries(e.all?r:[r])):e=>({})),,":",(e,r,t)=>(t=p(3.1)||i(),r=>[(e.id||e)(r),t(r),e(r)]),3.1]);[A,b,m,...U]=U,A;)h(A,b,m);export{d as default};

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "subscript",
-  "version": "5.5.2",
-  "description": "Microlanguage with common syntax for JS/C++/Python/Rust",
+  "version": "6.0.3",
+  "description": "Fast and tiny expression evaluator with common syntax microlanguage.",
   "main": "subscript.js",
   "type": "module",
   "files": [
-    "parse.js",
-    "evaluate.js",
+    "index.js",
     "subscript.js",
     "subscript.min.js",
     "justin.js",
@@ -32,11 +31,16 @@
     "jexl",
     "jsep",
     "expression",
+    "evaluator",
+    "parser",
     "evaluation",
     "math",
     "arithmetic",
-    "evaluator",
     "justin",
+    "eval",
+    "math-eval",
+    "math-evaluator",
+    "calculation",
     "jessie",
     "jessica",
     "eval",
@@ -44,8 +48,13 @@
     "json",
     "calculator",
     "calc",
-    "lisp",
-    "frisk"
+    "math.js",
+    "mathjs",
+    "math-codegen",
+    "math-parser",
+    "formula",
+    "operator",
+    "overload"
   ],
   "author": "Dmitry Iv.",
   "license": "ISC",

package/subscript.js

@@ -1,130 +1,88 @@
-import parse, {skip, expr, code, tokens, val, operator as parseOp, err} from './parse.js'
-import evaluate, {operator as evalOp} from './evaluate.js'
-
-const PERIOD=46, OPAREN=40, CPAREN=41, CBRACK=93, SPACE=32,
+import {parse, set, lookup, skip, cur, idx, err, expr, isId, space} from './index.js'
 
+const PERIOD=46, OPAREN=40, CPAREN=41, OBRACK=91, CBRACK=93, SPACE=32, DQUOTE=34, _0=48, _9=57,
 PREC_SEQ=1, PREC_SOME=4, PREC_EVERY=5, PREC_OR=6, PREC_XOR=7, PREC_AND=8,
 PREC_EQ=9, PREC_COMP=10, PREC_SHIFT=11, PREC_SUM=12, PREC_MULT=13, PREC_UNARY=15, PREC_POSTFIX=16, PREC_CALL=18, PREC_GROUP=19
 
-tokens.push(
-  // 1.2e+3, .5 - fast & small version, but consumes corrupted nums as well
-  (number) => (
-    (number = skip(c => (c > 47 && c < 58) || c == PERIOD)) && (
-      (code() == 69 || code() == 101) && (number += skip(2) + skip(c => c >= 48 && c <= 57)),
-      isNaN(number = new Number(number)) ? err('Bad number') : number
-    )
-  ),
+let u, list, op, prec, fn,
+    isNum = c => c>=_0 && c<=_9,
+    // 1.2e+3, .5
+    num = n => (
+      n&&err('Unexpected number'),
+      n = skip(c=>c==PERIOD || isNum(c)),
+      (cur.charCodeAt(idx) == 69 || cur.charCodeAt(idx) == 101) && (n += skip(2) + skip(isNum)),
+      n=+n, n!=n ? err('Bad number') : () => n // 0 args means token is static
+    ),
+
+    inc = (a,fn,c=a.of) => ctx => fn(c?c(ctx):ctx, a.id())
+
+// numbers
+for (op=_0;op<=_9;) lookup[op++] = num
+
+// operators
+for (list=[
   // "a"
-  (q, qc, v) => q == 34 && (skip(), v=skip(c => c-q), skip(), '@'+v),
-  // id
-  c => skip(c =>
-    (c >= 48 && c <= 57) || // 0..9
-    (c >= 65 && c <= 90) || // A...Z
-    (c >= 97 && c <= 122) || // a...z
-    c == 36 || c == 95 || // $, _,
-    c >= 192 // any non-ASCII
-  )
-)
+  '"', a => (a=a?err('Unexpected string'):skip(c => c-DQUOTE), skip()||err('Bad string'), ()=>a),,
+
+  // a.b, .2, 1.2 parser in one
+  '.', (a,id,fn) => !a ? num(skip(-1)) : // FIXME: .123 is not operator, so we skip back, but mb reorganizing num would be better
+    (space(), id=skip(isId)||err(), fn=ctx=>a(ctx)[id], fn.id=()=>id, fn.of=a, fn), PREC_CALL,
 
-const addOps = (add, stride=2, list) => {
-  for (let i = 0; i < list.length; i+=stride) add(list[i], list[i+1], list[i+2])
-}
+  // a[b]
+  '[', (a,b,fn) => a && (b=expr(0,CBRACK)||err(), fn=ctx=>a(ctx)[b(ctx)], fn.id=b, fn.of=a, fn), PREC_CALL,
+
+  // a(), a(b), (a,b), (a+b)
+  '(', (a,b,fn) => (
+    b=expr(0,CPAREN),
+    // a(), a(b), a(b,c,d)
+    a ? ctx => a(ctx).apply(a.of?.(ctx), b ? b.all ? b.all(ctx) : [b(ctx)] : []) :
+    // (a+b)
+    b || err()
+  ), PREC_CALL,
 
-addOps(parseOp, 3, [
-  ',', PREC_SEQ,,
+  // [a,b,c] or (a,b,c)
+  ',', (a,prec,b=expr(PREC_SEQ)) => (
+    b.all = a.all ? ctx => [...a.all(ctx), b(ctx)] : ctx => [a(ctx),b(ctx)],
+    b
+  ), PREC_SEQ,
 
-  '|', PREC_OR,,
-  '||', PREC_SOME,,
+  '|', PREC_OR, (a,b)=>a|b,
+  '||', PREC_SOME, (a,b)=>a||b,
 
-  '&', PREC_AND,,
-  '&&', PREC_EVERY,,
+  '&', PREC_AND, (a,b)=>a&b,
+  '&&', PREC_EVERY, (a,b)=>a&&b,
 
-  '^', PREC_XOR,,
+  '^', PREC_XOR, (a,b)=>a^b,
 
   // ==, !=
-  '==', PREC_EQ,,
-  '!=', PREC_EQ,,
+  '==', PREC_EQ, (a,b)=>a==b,
+  '!=', PREC_EQ, (a,b)=>a!=b,
 
   // > >= >> >>>, < <= <<
-  '>', PREC_COMP,,
-  '>=', PREC_COMP,,
-  '>>', PREC_SHIFT,,
-  '>>>', PREC_SHIFT,,
-  '<', PREC_COMP,,
-  '<=', PREC_COMP,,
-  '<<', PREC_SHIFT,,
+  '>', PREC_COMP, (a,b)=>a>b,
+  '>=', PREC_COMP, (a,b)=>a>=b,
+  '>>', PREC_SHIFT, (a,b)=>a>>b,
+  '>>>', PREC_SHIFT, (a,b)=>a>>>b,
+  '<', PREC_COMP, (a,b)=>a<b,
+  '<=', PREC_COMP, (a,b)=>a<=b,
+  '<<', PREC_SHIFT, (a,b)=>a<<b,
 
   // + ++ - --
-  '+', PREC_SUM,,
-  '+', PREC_UNARY, -1,
-  '++', PREC_UNARY, -1,
-  '++', PREC_POSTFIX, +1,
-  '-', PREC_SUM,,
-  '-', PREC_UNARY, -1,
-  '--', PREC_UNARY, -1,
-  '--', PREC_POSTFIX, +1,
+  '+', PREC_SUM, (a,b)=>a+b,
+  '+', PREC_UNARY, (a)=>+a,
+  '++', a => inc(a||expr(PREC_UNARY-1), a ? (a,b)=>a[b]++ : (a,b)=>++a[b]), PREC_UNARY,
+
+  '-', PREC_SUM, (a,b)=>a-b,
+  '-', PREC_UNARY, (a)=>-a,
+  '--', a => inc(a||expr(PREC_UNARY-1), a ? (a,b)=>a[b]-- : (a,b)=>--a[b]), PREC_UNARY,
 
   // ! ~
-  '!', PREC_UNARY, -1,
+  '!', PREC_UNARY, (a)=>!a,
 
   // * / %
-  '*', PREC_MULT,,
-  '/', PREC_MULT,,
-  '%', PREC_MULT,,
+  '*', PREC_MULT, (a,b)=>a*b,
+  '/', PREC_MULT, (a,b)=>a/b,
+  '%', PREC_MULT, (a,b)=>a%b
+]; [op,prec,fn,...list]=list, op;) set(op,prec,fn)
 
-  // a.b
-  '.', PREC_CALL, (node,b) => node && [skip(), node, '@' + expr(PREC_CALL)],
-
-  // a[b]
-  '[', PREC_CALL, (node) => (skip(), node = ['.', node, val(expr(0,CBRACK))], node),
-  ']',,,
-
-  // a(b)
-  '(', PREC_CALL, (node,b) => (skip(), b=expr(0,CPAREN),
-    Array.isArray(b) && b[0]===',' ? (b[0]=node, b) : b ? [node, val(b)] : [node]
-  ),
-  // (a+b)
-  '(', PREC_GROUP, (node,b) => !node && (skip(), b=expr(0,CPAREN) || err(), b),
-  ')',,,
-])
-
-
-// evaluators
-addOps(evalOp, 2, [
-  '!', a=>!a,
-  '++', a=>++a,
-  '--', a=>--a,
-
-  '.', (a,b)=>a?a[b]:a,
-
-  '%', (a,b)=>a%b,
-  '/', (a,b)=>a/b,
-  '*', (a,b)=>a*b,
-
-  '+', (a,b)=>a+(b||0),
-  '-', (a,b)=>b==null ? -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)=>a&b,
-  '^', (a,b)=>a^b,
-  '|', (a,b)=>a|b,
-  '&&', (a,b)=>a&&b,
-  '||', (a,b)=>a||b,
-  ',', (a,b)=>(a,b)
-])
-
-export { parse, evaluate }
-
-// code → evaluator
-export default s => (s = typeof s == 'string' ? parse(s) : s,  ctx => evaluate(s, ctx))
+export default parse

package/subscript.min.js

@@ -1 +1 @@
-let r,e;const t=(t,n)=>(e=t,r=0,n=l(),r<e.length?a():h(n)),a=(t="Bad syntax")=>{throw Error(t+" `"+e[r]+"` at "+r)},n=(t=1,a=r)=>{if("number"==typeof t)r+=t;else for(;t(o());)r++;return e.slice(a,r)},o=(t=0)=>e.charCodeAt(r+t),s=(t=1)=>e.substr(r,t),l=(e=0,n,o,s,l=0,u,p)=>{for(;(o=t.space())&&(u=(p=i[o])&&p(s,e)||!s&&f(o));)s=u;return n&&(o!=n?a("Unclosed paren"):r++),s};t.space=e=>{for(;(e=o())<=32;)r++;return e};const u=t.token=[],f=(r,e=0,t)=>{for(;e<u.length;)if(t=u[e++](r))return t},i=[],p=t.operator=(e,a=0,o=0,u,f=e.charCodeAt(0),p=e.length,y=i[f])=>(u=o?o>0?r=>r&&[n(p),h(r)]:o<0?r=>!r&&[n(p),h(l(a-1))]:o:n=>{n=[e,h(n)];do{r+=p,n.push(h(l(a)))}while(t.space()==f&&(p<2||s(p)==e));return n},i[f]=(r,t)=>t<a&&(p<2||s(p)==e)&&u(r)||y&&y(r,t)),h=r=>Array.isArray(r)?r:(r||a()).valueOf(),y=(r,e={})=>{if("string"==typeof r)return"@"===r[0]?r.slice(1):e[r];if(Array.isArray(r)){let t=r[0],a=r.length,n=Array.isArray(t)?y(t,e):c[t]||e[t]||t,o=1,s=[];if(n.ab){s=y(r[o++],e);do{s=n(s,y(r[o++],e))}while(o<a)}else{for(;o<a;)s.push(y(r[o++],e));s=n.apply(e,s)}return s}return r},c={},A=y.operator=(r,e)=>(c[r]=e).ab=2==e.length;u.push((r=>(r=n((r=>r>47&&r<58||46==r)))&&((69==o()||101==o())&&(r+=n(2)+n((r=>r>=48&&r<=57))),isNaN(r=new Number(r))?a("Bad number"):r)),((r,e,t)=>34==r&&(n(),t=n((e=>e-r)),n(),"@"+t)),(r=>n((r=>r>=48&&r<=57||r>=65&&r<=90||r>=97&&r<=122||36==r||95==r||r>=192))));const d=(r,e=2,t)=>{for(let a=0;a<t.length;a+=e)r(t[a],t[a+1],t[a+2])};d(p,3,[",",1,,"|",6,,"||",4,,"&",8,,"&&",5,,"^",7,,"==",9,,"!=",9,,">",10,,">=",10,,">>",11,,">>>",11,,"<",10,,"<=",10,,"<<",11,,"+",12,,"+",15,-1,"++",15,-1,"++",16,1,"-",12,,"-",15,-1,"--",15,-1,"--",16,1,"!",15,-1,"*",13,,"/",13,,"%",13,,".",18,(r,e)=>r&&[n(),r,"@"+l(18)],"[",18,r=>(n(),[".",r,h(l(0,93))]),"]",,,"(",18,(r,e)=>(n(),e=l(0,41),Array.isArray(e)&&","===e[0]?(e[0]=r,e):e?[r,h(e)]:[r]),"(",19,(r,e)=>!r&&(n(),l(0,41)||a()),")",,,]),d(A,2,["!",r=>!r,"++",r=>++r,"--",r=>--r,".",(r,e)=>r?r[e]:r,"%",(r,e)=>r%e,"/",(r,e)=>r/e,"*",(r,e)=>r*e,"+",(r,e)=>r+(e||0),"-",(r,e)=>null==e?-r:r-e,">>>",(r,e)=>r>>>e,">>",(r,e)=>r>>e,"<<",(r,e)=>r<<e,">=",(r,e)=>r>=e,">",(r,e)=>r>e,"<=",(r,e)=>r<=e,"<",(r,e)=>r<e,"!=",(r,e)=>r!=e,"==",(r,e)=>r==e,"&",(r,e)=>r&e,"^",(r,e)=>r^e,"|",(r,e)=>r|e,"&&",(r,e)=>r&&e,"||",(r,e)=>r||e,",",(r,e)=>e]);var g=r=>(r="string"==typeof r?t(r):r,e=>y(r,e));export{g as default,y as evaluate,t as parse};
+let e,r,t,o,a,n,d=(t,...o)=>(r=t.raw?String.raw(t,...o):t,e=0,!(t=i())||r[e]?f("Unexpected end"):e=>t(e||{})),l=e=>e>=48&&e<=57||e>=65&&e<=90||e>=97&&e<=122||36==e||95==e||e>=192&&215!=e&&247!=e,f=(t="Unexpected token",o=r[e])=>{throw SyntaxError(t+" `"+o+"` at "+e)},h=(t=1,o=e,a)=>{if("number"==typeof t)e+=t;else for(;t(r.charCodeAt(e));)e++;return r.slice(o,e)},i=(r=0,t,o,a,n,d)=>{for(;(o=c())&&(n=(d=p[o])&&d(a,r)||!a&&s());)a=n;return t&&(o==t?e++:f("Missing",String.fromCharCode(t))),a},c=t=>{for(;(t=r.charCodeAt(e))<=32;)e++;return t},s=(e=h(l),r)=>e?((r=r=>r[e]).id=()=>e,r):0,p=[],g=d.set=(t,o,a=32,n=t.charCodeAt(0),d=t.length,f=p[n],h=a.length||([a,o]=[o,a],0),c=t.toUpperCase()!==t,s=(h>1?(e,r)=>e&&(r=i(o))&&(e.length||r.length?t=>a(e(t),r(t)):(e=a(e(),r()),()=>e)):h?e=>!e&&(e=i(o-1))&&(r=>a(e(r))):a))=>p[n]=(a,n,h=e)=>n<o&&(d<2||r.substr(e,d)==t)&&(!c||!l(r.charCodeAt(e+d)))&&(e+=d,s(a,n))||(e=h,f&&f(a,n)),C=e=>e>=48&&e<=57,u=t=>(t&&f("Unexpected number"),t=h((e=>46==e||C(e))),(69==r.charCodeAt(e)||101==r.charCodeAt(e))&&(t+=h(2)+h(C)),(t=+t)!=t?f("Bad number"):()=>t),x=(e,r,t=e.of)=>o=>r(t?t(o):o,e.id());for(o=48;o<=57;)p[o++]=u;for(t=['"',e=>(e=e?f("Unexpected string"):h((e=>e-34)),h()||f("Bad string"),()=>e),,".",(e,r,t)=>e?(c(),r=h(l)||f(),(t=t=>e(t)[r]).id=()=>r,t.of=e,t):u(h(-1)),18,"[",(e,r,t)=>e&&(r=i(0,93)||f(),(t=t=>e(t)[r(t)]).id=r,t.of=e,t),18,"(",(e,r,t)=>(r=i(0,41),e?t=>e(t).apply(e.of?.(t),r?r.all?r.all(t):[r(t)]:[]):r||f()),18,",",(e,r,t=i(1))=>(t.all=e.all?r=>[...e.all(r),t(r)]:r=>[e(r),t(r)],t),1,"|",6,(e,r)=>e|r,"||",4,(e,r)=>e||r,"&",8,(e,r)=>e&r,"&&",5,(e,r)=>e&&r,"^",7,(e,r)=>e^r,"==",9,(e,r)=>e==r,"!=",9,(e,r)=>e!=r,">",10,(e,r)=>e>r,">=",10,(e,r)=>e>=r,">>",11,(e,r)=>e>>r,">>>",11,(e,r)=>e>>>r,"<",10,(e,r)=>e<r,"<=",10,(e,r)=>e<=r,"<<",11,(e,r)=>e<<r,"+",12,(e,r)=>e+r,"+",15,e=>+e,"++",e=>x(e||i(14),e?(e,r)=>e[r]++:(e,r)=>++e[r]),15,"-",12,(e,r)=>e-r,"-",15,e=>-e,"--",e=>x(e||i(14),e?(e,r)=>e[r]--:(e,r)=>--e[r]),15,"!",15,e=>!e,"*",13,(e,r)=>e*r,"/",13,(e,r)=>e/r,"%",13,(e,r)=>e%r];[o,a,n,...t]=t,o;)g(o,a,n);export{d as default};

package/evaluate.js

@@ -1,27 +0,0 @@
-// calltree → result
-export const evaluate = (node, ctx={}) => {
-  if (typeof node === 'string')
-    return node[0]==='@' ? node.slice(1) : ctx[node]
-
-  if (Array.isArray(node)) {
-    // [[a,b], c] or ['+', a, b] or ['myfn', a, b], or
-    let c = node[0], l = node.length,
-        fn = Array.isArray(c) ? evaluate(c, ctx) : (lookup[c] || ctx[c] || c),
-        i=1, res=[]
-
-    if (fn.ab) { res=evaluate(node[i++],ctx); do { res = fn(res, evaluate(node[i++],ctx)) } while ( i < l ) }
-    else { while ( i < l ) res.push(evaluate(node[i++], ctx)); res = fn.apply(ctx,res) }
-
-    return res
-  }
-
-  return node
-},
-lookup = {},
-
-// op evaluators
-// multiple args (fn.r=false) are caused by:
-// ||&& shortcuts, lisp compatiblity, manual eval, functions multiple arguments, right precedence
-operator = evaluate.operator = (op, fn) => (lookup[op] = fn).ab = fn.length==2
-
-export default evaluate

package/parse.js

@@ -1,67 +0,0 @@
-const SPACE=32
-
-// current string & index
-let idx, cur
-
-export const parse = (str, tree) => (cur=str, idx=0, tree=expr(), idx<cur.length ? err() : val(tree)),
-
-err = (msg='Bad syntax') => { throw Error(msg + ' `' + cur[idx] + '` at ' + idx) },
-
-skip = (is=1, from=idx) => {
-  if (typeof is === 'number') idx += is
-  else while (is(code())) idx++;
-  return cur.slice(from, idx)
-},
-
-code = (i=0) => cur.charCodeAt(idx+i),
-
-char = (n=1) => cur.substr(idx, n),
-
-// a + b - c
-expr = (prec=0, end, cc, node, i=0, newNode, op) => {
-  // chunk/token parser
-  while (
-    (cc=parse.space()) && (newNode = (op=lookup[cc]) && op(node, prec) || (!node && token(cc)) )
-  ) node = newNode;
-
-  // skip end character, if expected
-  if (end) cc != end ? err('Unclosed paren') : idx++
-
-  return node
-},
-
-// can be extended with comments, so we export
-space = parse.space = cc => { while (cc = code(), cc <= SPACE) idx++; return cc },
-
-// tokens
-tokens = parse.token = [],
-token = (c,i=0,node) => { while(i<tokens.length) if (node = tokens[i++](c)) return node },
-
-// operator lookup table
-lookup = [],
-
-// create operator checker/mapper (see examples)
-// @param op is operator string
-// @param prec is operator precedenc to check
-// @param map is either number +1 - postfix unary, -1 prefix unary, 0 binary, else - custom mapper function
-operator = parse.operator = (
-  op, prec=0, type=0, map, c=op.charCodeAt(0), l=op.length, prev=lookup[c]
-) => (
-  map = !type ? node => { // binary
-      node = [op, val(node)]
-      do { idx+=l, node.push(val(expr(prec))) } // consume same-op group
-      while (parse.space()==c && (l<2||char(l)==op))
-      return node
-    } :
-    type > 0 ? node => node && [skip(l), val(node)] : // postfix unary
-    type < 0 ? node => !node && [skip(l), val(expr(prec-1))] : // prefix unary
-    type,
-
-  lookup[c] = (node, curPrec) =>
-    curPrec < prec && (l<2||char(l)==op) && map(node) || (prev && prev(node, curPrec))
-),
-
-// in order to support literal tokens, we call valueOf any time we create or modify calltree node
-val = node => Array.isArray(node) ? node : (node || err()).valueOf()
-
-export default parse