subscript 5.5.0 → 6.0.1

package/README.md

@@ -3,18 +3,18 @@
 <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>
 
-_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>![npm bundle size](https://img.shields.io/bundlephobia/minzip/subscript/latest?color=brightgreen&label=gzip)</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 +29,98 @@ _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.5kb](https://npmfs.com/package/subscript/5.2.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 (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`
 
-```js
-import {evaluate} from 'subscript.js'
-
-evaluate(['+', ['*', 'min', 60], '"sec"'], { min: 5 }) // min*60 + "sec" == "300sec"
-```
+Default literals:
 
-## Extending
-
-### Operators 
+* `"abc"` strings
+* `1.2e+3` numbers
 
-Default operators include common operators for the listed languages in the following precedence:
+Everything else can be extended via `parse.set(operator, precedence, fn)` for unary or binary operators (detected by number of arguments in `fn`), or via `parse.set(operator, parser, precedence)` for custom tokens.
 
-* `++ --` 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, props, groups, arrays, objects etc.
+<!--
+Operators can be extended via .
 
 ```js
-import { parse, evaluate } from 'subscript.js'
+import script from 'subscript.js'
 
-parse.operator('=>', 10) // precedence=10, type=default (0 - binary, 1 - postfix, -1 - prefix)
+script.set('|', 10, ( a, b ) => a.pipe(b))
 
-evaluate.operator('=>', ( args, body ) => evaluate(body, args))
-evaluate.operator('|', ( 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 +265,38 @@ 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: ~250 ms
+mr-parser: ~420 ms
 expr-eval: ~480 ms
-jexl: ~1200 ms
-new Function: ~1400 ms
+math-parser: ~570 ms
+jexl: ~1056 ms
+mathjs: ~1200 ms
+new Function: ~1154 ms
+```
+
+Eval 30k times:
+```
+subscript: ~15 ms
+justin: ~15 ms
+jsep (expression-eval): ~30 ms
+mr-parser: -
+expr-eval: ~72 ms
+math-parser: -
+jexl: ~110 ms
+mathjs: ~119 ms
+new Function: ~5 ms
 ```
 
-## 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 +304,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/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() // 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() : ()=>null,,
+  'true', a => a ? err() : ()=>true,,
+  'false', a => a ? err() : ()=>false,,
+  'undefined', a => a ? err() : ()=>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=0)=>a+b,
-  '-', (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=Array.isArray(o)?r(o,n):e[o]||n[o]||o,s=[],l=1;for(;l<t.length;l++)s.push(r(t[l],n));return s.length>a.length&&a.length?s.reduce(a):a.apply(o,s)}return t},e={};let t,n;r.operator=(r,t)=>e[r]=t;const o=(r,e)=>(n=r,t=0,e=i(),t<n.length?a():h(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),f=(r=1)=>n.substr(t,r),i=(r=0,e,n,s,l=0,f,i)=>{for(;(n=o.space())&&(f=(i=c[n])&&i(s,r)||!s&&p(n));)s=f;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),h(r)]:n<0?r=>!r&&[s(u),h(i(e-1))]:n:n=>{n=[r,h(n)];do{t+=u,n.push(h(i(e)))}while(o.space()==l&&(u<2||f(u)==r));return n},c[l]=(t,n)=>n<e&&(u<2||f(u)==r)&&a(t)||p&&p(t,n));const h=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(f(),s(),n="";(t=l())-r;)92===t?(s(),n+=y[f()]||f()):n+=f(),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 y={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,"@"+i(18)],"[",18,r=>(s(),[".",r,h(i(0,93))]),"]",,,"(",18,(r,e)=>(s(),e=i(0,41),Array.isArray(e)&&","===e[0]?(e[0]=r,e):e?[r,h(e)]:[r]),"(",19,(r,e)=>!r&&(s(),i(0,41)||a()),")",,,";",1,,"===",9,,"!==",9,,"**",14,,"~",15,-1,"?",3,r=>{let e;return r||a("Expected expression"),s(),o.space(),e=i(),["?:",r,e[1],e[2]]},":",10,,"in",10,r=>l(2)<=32&&[s(2),"@"+r,i(10)],"[",20,(r,e)=>!r&&(s(),(e=i(0,93))?","==e[0]?(e[0]="[",e):["[",e]:["["]),"{",20,(r,e)=>!r&&(s(),(e=i(0,125))?":"==e[0]?["{",A(e)]:","==e[0]?(e[0]="{",e.map(A)):["{",e]:["{"]),"}",,,"null",20,r=>!r&&(s(4),g(null)),"false",20,r=>!r&&(s(5),g(!1)),"true",20,r=>!r&&(s(4),g(!0)),"undefined",20,r=>!r&&(s(9),g(void 0))]);const A=r=>Array.isArray(r)?(r[1]=("@"===r[1][0]?"":"@")+r[1],r):r,g=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=0)=>r+e,"-",(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 b=e=>(e="string"==typeof e?o(e):e,t=>r(e,t));export{b as default,r as evaluate,o as parse};
+let r,e,t,l,a,o,n=(t,...l)=>(e=t.raw?String.raw(t,...l):t,r=0,!(t=i())||e[r]?f():r=>t(r||{})),d=r=>r>=48&&r<=57||r>=65&&r<=90||r>=97&&r<=122||36==r||95==r||r>=192&&215!=r&&247!=r,f=(t="Bad syntax",l=e[r])=>{throw Error(t+" `"+l+"` at "+r)},h=(t=1,l=r,a)=>{if("number"==typeof t)r+=t;else for(;t(e.charCodeAt(r));)r++;return e.slice(l,r)},i=(e=0,t,l,a,o,n)=>{for(;(l=s())&&(o=(n=c[l])&&n(a,e)||!a&&u());)a=o;return t&&(l==t?r++:f("Unclosed")),a},s=t=>{for(;(t=e.charCodeAt(r))<=32;)r++;return t},u=(r=h(d),e)=>r?((e=e=>e[r]).id=()=>r,e):0,c=[],C=n.set=(t,l,a=32,o=t.charCodeAt(0),n=t.length,f=c[o],h=a.length||([a,l]=[l,a],0),s=t.toUpperCase()!==t,u=(h>1?(r,e)=>r&&(e=i(l))&&(r.length||e.length?t=>a(r(t),e(t)):(r=a(r(),e()),()=>r)):h?r=>!r&&(r=i(l-1))&&(e=>a(r(e))):a))=>c[o]=(a,o,h=r)=>o<l&&(n<2||e.substr(r,n)==t)&&(!s||!d(e.charCodeAt(r+n)))&&(r+=n,u(a,o))||(r=h,f&&f(a,o)),A=r=>r>=48&&r<=57,g=t=>(t&&f(),t=h((r=>46==r||A(r))),(69==e.charCodeAt(r)||101==e.charCodeAt(r))&&(t+=h(2)+h(A)),(t=+t)!=t?f("Bad number"):()=>t),p=(r,e,t=r.of)=>l=>e(t?t(l):l,r.id());for(l=48;l<=57;)c[l++]=g;for(t=['"',r=>(r=r?f():h((r=>r-34)),h()||f("Bad string"),()=>r),,".",(r,e,t)=>r?(s(),e=h(d)||f(),(t=t=>r(t)[e]).id=()=>e,t.of=r,t):g(h(-1)),18,"[",(r,e,t)=>r&&(e=i(0,93)||f(),(t=t=>r(t)[e(t)]).id=e,t.of=r,t),18,"(",(r,e,t)=>(e=i(0,41),r?t=>r(t).apply(r.of?.(t),e?e.all?e.all(t):[e(t)]:[]):e||f()),18,",",(r,e,t=i(1))=>(t.all=r.all?(e,l,a=r.all(e))=>a.push(t(e))&&a:e=>[r(e),t(e)],t),1,"|",6,(r,e)=>r|e,"||",4,(r,e)=>r||e,"&",8,(r,e)=>r&e,"&&",5,(r,e)=>r&&e,"^",7,(r,e)=>r^e,"==",9,(r,e)=>r==e,"!=",9,(r,e)=>r!=e,">",10,(r,e)=>r>e,">=",10,(r,e)=>r>=e,">>",11,(r,e)=>r>>e,">>>",11,(r,e)=>r>>>e,"<",10,(r,e)=>r<e,"<=",10,(r,e)=>r<=e,"<<",11,(r,e)=>r<<e,"+",12,(r,e)=>r+e,"+",15,r=>+r,"++",r=>p(r||i(14),r?(r,e)=>r[e]++:(r,e)=>++r[e]),15,"-",12,(r,e)=>r-e,"-",15,r=>-r,"--",r=>p(r||i(14),r?(r,e)=>r[e]--:(r,e)=>--r[e]),15,"!",15,r=>!r,"*",13,(r,e)=>r*e,"/",13,(r,e)=>r/e,"%",13,(r,e)=>r%e];[l,a,o,...t]=t,l;)C(l,a,o);let b,B,m,w,y={n:"\n",r:"\r",t:"\t",b:"\b",f:"\f",v:"\v"},v=t=>(l,a,o="")=>{for(l&&f();(a=e.charCodeAt(r))-t;)92===a?(h(),a=h(),o+=y[a]||a):o+=h();return h()||f("Bad string"),()=>o};for((b=['"',v(34),,"'",v(39),,"/*",(t,l)=>(h((t=>42!==t&&47!==e.charCodeAt(r+1))),h(2),t||i(l)),,"//",(r,e)=>(h((r=>r>=32)),r||i(e)),,"null",r=>r?f():()=>null,,"true",r=>r?f():()=>!0,,"false",r=>r?f():()=>!1,,"undefined",r=>r?f():()=>{},,";",r=>i()||(()=>{}),,"===",9,(r,e)=>r===e,"!==",9,(r,e)=>r!==e,"~",15,r=>~r,"**",(r,e,t=i(13))=>e=>r(e)**t(e),14,":",3.1,(r,e)=>[r,e],"?",3,(r,e)=>r?e[2]:e[1],"?.",r=>r&&(e=>r(e)||(()=>{})),,"?.",(r,e)=>(s(),(e=h(d))&&(t=>r(t)?.[e])),,"in",10,(r,e)=>r in e,"[",(r,e)=>!r&&((r=i(0,93))?r.all?e=>r.all(e):e=>[r(e)]:r=>[]),,"{",(r,e)=>!r&&((r=i(0,125))?t=>(e=(r.all||r)(t),Object.fromEntries(r.all?e:[e])):r=>({})),,":",(r,e,t)=>(t=i(3.1)||f(),e=>[(r.id||r)(e),t(e),r(e)]),3.1]);[B,m,w,...b]=b,B;)C(B,m,w);export{n as default};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "subscript",
-  "version": "5.5.0",
+  "version": "6.0.1",
   "description": "Microlanguage with common syntax for JS/C++/Python/Rust",
   "main": "subscript.js",
   "type": "module",
@@ -45,7 +45,10 @@
     "calculator",
     "calc",
     "lisp",
-    "frisk"
+    "frisk",
+    "math.js",
+    "math-codegen",
+    "math-parser"
   ],
   "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(),
+      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():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,prec,arr=a.all(ctx)) => arr.push(b(ctx)) && arr : 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=0)=>a+b,
-  '-', (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)
-])
-
-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,o)=>(e=t,r=0,o=l(),r<e.length?n():i(o)),n=(t="Bad syntax")=>{throw Error(t+" `"+e[r]+"` at "+r)},o=(t=1,n=r)=>{if("number"==typeof t)r+=t;else for(;t(a());)r++;return e.slice(n,r)},a=(t=0)=>e.charCodeAt(r+t),s=(t=1)=>e.substr(r,t),l=(e=0,o,a,s,l=0,u,p)=>{for(;(a=t.space())&&(u=(p=h[a])&&p(s,e)||!s&&f(a));)s=u;return o&&(a!=o?n("Unclosed paren"):r++),s};t.space=e=>{for(;(e=a())<=32;)r++;return e};const u=t.token=[],f=(r,e=0,t)=>{for(;e<u.length;)if(t=u[e++](r))return t},h=[],p=t.operator=(e,n=0,a=0,u,f=e.charCodeAt(0),p=e.length,y=h[f])=>(u=a?a>0?r=>r&&[o(p),i(r)]:a<0?r=>!r&&[o(p),i(l(n-1))]:a:o=>{o=[e,i(o)];do{r+=p,o.push(i(l(n)))}while(t.space()==f&&(p<2||s(p)==e));return o},h[f]=(r,t)=>t<n&&(p<2||s(p)==e)&&u(r)||y&&y(r,t)),i=r=>Array.isArray(r)?r:(r||n()).valueOf(),y=(r,e={})=>{if("string"==typeof r)return"@"===r[0]?r.slice(1):e[r];if(Array.isArray(r)){let t=r[0],n=Array.isArray(t)?y(t,e):c[t]||e[t]||t,o=[],a=1;for(;a<r.length;a++)o.push(y(r[a],e));return o.length>n.length&&n.length?o.reduce(n):n.apply(t,o)}return r},c={},g=y.operator=(r,e)=>c[r]=e;u.push((r=>(r=o((r=>r>47&&r<58||46==r)))&&((69==a()||101==a())&&(r+=o(2)+o((r=>r>=48&&r<=57))),isNaN(r=new Number(r))?n("Bad number"):r)),((r,e,t)=>34==r&&(o(),t=o((e=>e-r)),o(),"@"+t)),(r=>o((r=>r>=48&&r<=57||r>=65&&r<=90||r>=97&&r<=122||36==r||95==r||r>=192))));const A=(r,e=2,t)=>{for(let n=0;n<t.length;n+=e)r(t[n],t[n+1],t[n+2])};A(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&&[o(),r,"@"+l(18)],"[",18,r=>(o(),[".",r,i(l(0,93))]),"]",,,"(",18,(r,e)=>(o(),e=l(0,41),Array.isArray(e)&&","===e[0]?(e[0]=r,e):e?[r,i(e)]:[r]),"(",19,(r,e)=>!r&&(o(),l(0,41)||n()),")",,,]),A(g,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=0)=>r+e,"-",(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]);var d=r=>(r="string"==typeof r?t(r):r,e=>y(r,e));export{d as default,y as evaluate,t as parse};
+let r,e,t,a,o,l,d=(t,...a)=>(e=t.raw?String.raw(t,...a):t,r=0,!(t=s())||e[r]?f():r=>t(r||{})),n=r=>r>=48&&r<=57||r>=65&&r<=90||r>=97&&r<=122||36==r||95==r||r>=192&&215!=r&&247!=r,f=(t="Bad syntax",a=e[r])=>{throw Error(t+" `"+a+"` at "+r)},h=(t=1,a=r,o)=>{if("number"==typeof t)r+=t;else for(;t(e.charCodeAt(r));)r++;return e.slice(a,r)},s=(e=0,t,a,o,l,d)=>{for(;(a=c())&&(l=(d=u[a])&&d(o,e)||!o&&i());)o=l;return t&&(a==t?r++:f("Unclosed")),o},c=t=>{for(;(t=e.charCodeAt(r))<=32;)r++;return t},i=(r=h(n),e)=>r?((e=e=>e[r]).id=()=>r,e):0,u=[],p=d.set=(t,a,o=32,l=t.charCodeAt(0),d=t.length,f=u[l],h=o.length||([o,a]=[a,o],0),c=t.toUpperCase()!==t,i=(h>1?(r,e)=>r&&(e=s(a))&&(r.length||e.length?t=>o(r(t),e(t)):(r=o(r(),e()),()=>r)):h?r=>!r&&(r=s(a-1))&&(e=>o(r(e))):o))=>u[l]=(o,l,h=r)=>l<a&&(d<2||e.substr(r,d)==t)&&(!c||!n(e.charCodeAt(r+d)))&&(r+=d,i(o,l))||(r=h,f&&f(o,l)),C=r=>r>=48&&r<=57,g=t=>(t&&f(),t=h((r=>46==r||C(r))),(69==e.charCodeAt(r)||101==e.charCodeAt(r))&&(t+=h(2)+h(C)),(t=+t)!=t?f("Bad number"):()=>t),A=(r,e,t=r.of)=>a=>e(t?t(a):a,r.id());for(a=48;a<=57;)u[a++]=g;for(t=['"',r=>(r=r?f():h((r=>r-34)),h()||f("Bad string"),()=>r),,".",(r,e,t)=>r?(c(),e=h(n)||f(),(t=t=>r(t)[e]).id=()=>e,t.of=r,t):g(h(-1)),18,"[",(r,e,t)=>r&&(e=s(0,93)||f(),(t=t=>r(t)[e(t)]).id=e,t.of=r,t),18,"(",(r,e,t)=>(e=s(0,41),r?t=>r(t).apply(r.of?.(t),e?e.all?e.all(t):[e(t)]:[]):e||f()),18,",",(r,e,t=s(1))=>(t.all=r.all?(e,a,o=r.all(e))=>o.push(t(e))&&o:e=>[r(e),t(e)],t),1,"|",6,(r,e)=>r|e,"||",4,(r,e)=>r||e,"&",8,(r,e)=>r&e,"&&",5,(r,e)=>r&&e,"^",7,(r,e)=>r^e,"==",9,(r,e)=>r==e,"!=",9,(r,e)=>r!=e,">",10,(r,e)=>r>e,">=",10,(r,e)=>r>=e,">>",11,(r,e)=>r>>e,">>>",11,(r,e)=>r>>>e,"<",10,(r,e)=>r<e,"<=",10,(r,e)=>r<=e,"<<",11,(r,e)=>r<<e,"+",12,(r,e)=>r+e,"+",15,r=>+r,"++",r=>A(r||s(14),r?(r,e)=>r[e]++:(r,e)=>++r[e]),15,"-",12,(r,e)=>r-e,"-",15,r=>-r,"--",r=>A(r||s(14),r?(r,e)=>r[e]--:(r,e)=>--r[e]),15,"!",15,r=>!r,"*",13,(r,e)=>r*e,"/",13,(r,e)=>r/e,"%",13,(r,e)=>r%e];[a,o,l,...t]=t,a;)p(a,o,l);export{d as default};

package/evaluate.js

@@ -1,21 +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], fn = Array.isArray(c) ? evaluate(c, ctx) : (lookup[c] || ctx[c] || c), args=[], i = 1
-    for (;i<node.length;i++) args.push(evaluate(node[i], ctx))
-    return args.length > fn.length && fn.length ? args.reduce(fn) : fn.apply(c,args)
-  }
-
-  return node
-},
-lookup = {},
-
-// op evaluators
-// multiple args allows shortcuts, lisp compatible, easy manual eval, functions anyways take multiple arguments
-operator = evaluate.operator = (op, fn) => lookup[op] = fn
-
-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