subscript 8.0.0 → 8.0.1

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)))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "subscript",
-  "version": "8.0.0",
+  "version": "8.0.1",
   "description": "Fast and tiny expression evaluator with minimal syntax.",
   "main": "subscript.js",
   "module": "subscript.js",
@@ -8,15 +8,15 @@
   "types": "./subscript.d.ts",
   "exports": {
     ".": "./subscript.js",
-    "./parse.js": "./parse.js",
-    "./compile.js": "./compile.js",
+    "./parse.js": "./src/parse.js",
+    "./compile.js": "./src/compile.js",
     "./subscript.js": "./subscript.js",
     "./justin.js": "./justin.js"
   },
   "type": "module",
   "files": [
-    "parse.js",
-    "compile.js",
+    "src",
+    "feature",
     "subscript.js",
     "subscript.min.js",
     "justin.js",

package/src/compile.d.ts

@@ -0,0 +1,17 @@
+export type OperatorFunction = (...args: any[]) => any;
+export type OperatorMap = {
+  [key: string]: OperatorFunction;
+};
+export type Node = string | [string | undefined, ...Node[]];
+export function compile(node: Node): ((ctx?: any) => any) | OperatorFunction;
+export const operators: OperatorMap;
+export function operator(op: string, fn: OperatorFunction): void;
+
+type AccessorFunction = (ctx: any) => any;
+export function access(
+  a: [string, ...any[]] | string,
+  fn: Function,
+  generic: boolean
+): AccessorFunction;
+
+export default compile;

package/src/compile.js

@@ -0,0 +1,26 @@
+import { err } from "./parse.js"
+
+// build optimized evaluator for the tree
+export const compile = (node) => !Array.isArray(node) ? ctx => ctx?.[node] : !node[0] ? () => node[1] : operators[node[0]](...node.slice(1)),
+
+  // registered operators
+  operators = {},
+
+  // register an operator
+  operator = (op, fn, prev = operators[op]) => (operators[op] = (...args) => fn(...args) || prev && prev(...args)),
+
+  // takes node and returns evaluator depending on the case with passed params (container, path, ctx) =>
+  access = (a, fn, generic) => (
+    // (((x))) => x
+    a[0] === '()' ? access(a[1], fn, generic) :
+      // (_, name, ctx) => ctx[path]
+      typeof a === 'string' ? fn.bind(0, ctx => ctx, () => a) :
+        // (container, path, ctx) => container(ctx)[path]
+        a[0] === '.' ? fn.bind(0, compile(a[1]), (a = a[2], () => a)) :
+          // (container, path, ctx) => container(ctx)[path(ctx)]
+          a[0] === '[' ? fn.bind(0, compile(a[1]), compile(a[2])) :
+            // (src, _, ctx) => src(ctx)
+            generic ? (a = compile(a), fn.bind(0, ctx => [a(ctx)], () => 0)) : () => err('Bad left value')
+  )
+
+export default compile

package/src/const.js

@@ -0,0 +1,40 @@
+export const
+  PERIOD = 46,
+  OPAREN = 40,
+  CPAREN = 41,
+  OBRACK = 91,
+  CBRACK = 93,
+  OBRACE = 123,
+  CBRACE = 125,
+  SPACE = 32,
+  COLON = 58,
+  DQUOTE = 34,
+  QUOTE = 39,
+  _0 = 48,
+  _9 = 57,
+  _E = 69,
+  _e = 101,
+  BSLASH = 92,
+  SLASH = 47,
+  STAR = 42
+
+// ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence
+export const
+  PREC_SEQ = 1,
+  PREC_ASSIGN = 2,
+  PREC_LOR = 3,
+  PREC_LAND = 4,
+  PREC_OR = 5,
+  PREC_XOR = 6,
+  PREC_AND = 7,
+  PREC_EQ = 8,
+  PREC_COMP = 9,
+  PREC_SHIFT = 10,
+  PREC_ADD = 11,
+  PREC_MULT = 12,
+  PREC_EXP = 13,
+  PREC_PREFIX = 14,
+  PREC_POSTFIX = 15,
+  PREC_ACCESS = 17,
+  PREC_GROUP = 18,
+  PREC_TOKEN = 20

package/src/parse.d.ts

@@ -0,0 +1,19 @@
+export let idx: any;
+export let cur: any;
+export function parse(s: string): any;
+export namespace parse {
+  function space(cc: any): any;
+  function id(n: any): any;
+}
+export function err(msg?: string, frag?: string): never;
+export function skip(is: number | ((c: number) => number)): string;
+export const lookup: ((a: any, b: any) => any)[];
+export function token(op: string, prec: number, map: (a: any, curPrec: number, from: number) => any): (a: any, curPrec: number, from?: any) => any;
+export function binary(op: string, prec: number, right?: boolean | undefined): (a: any, curPrec: number, from?: any) => any;
+export function unary(op: string, prec: number, post?: boolean | undefined): (a: any, curPrec: number, from?: any) => any;
+export function nary(op: string, prec: number, skips?: boolean | undefined): (a: any, curPrec: number, from?: any) => any;
+export function expr(prec: number, end?: string | undefined): any;
+export function isId(c: number): boolean;
+export function space(): number;
+export function id(): string;
+export default parse;

package/src/parse.js

@@ -0,0 +1,94 @@
+import { SPACE } from "./const.js"
+
+// current string, index and collected ids
+export let idx, cur,
+
+  // no handling tagged literals since easily done on user side with cache, if needed
+  parse = s => (idx = 0, cur = s, s = expr(), cur[idx] ? err() : s || ''),
+
+  err = (msg = 'Bad syntax',
+    lines = cur.slice(0, idx).split('\n'),
+    last = lines.pop()
+  ) => {
+    let before = cur.slice(idx - 108, idx).split('\n').pop()
+    let after = cur.slice(idx, idx + 108).split('\n').shift()
+    throw EvalError(`${msg} at ${lines.length}:${last.length} \`${idx >= 108 ? '…' : ''}${before}▶${after}\``, 'font-weight: bold')
+  },
+
+  skip = (is = 1, from = idx, l) => {
+    if (typeof is == 'number') idx += is
+    else while (l = is(cur.charCodeAt(idx))) idx += l
+    return cur.slice(from, idx)
+  },
+
+  // a + b - c
+  expr = (prec = 0, end, cc, token, newNode, fn) => {
+    // chunk/token parser
+    while (
+      (cc = parse.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 && parse.id()) // parse literal or quit. token seqs are forbidden: `a b`, `a "b"`, `1.32 a`
+      )
+    ) token = newNode;
+
+    // check end character
+    // FIXME: can't show "Unclosed paren", because can be unknown operator within group as well
+    if (end) cc == end ? idx++ : err()
+
+    return token
+  },
+
+  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
+
+  // parse identifier (configurable)
+  id = parse.id = n => skip(isId),
+
+  // skip space chars, return first non-space character
+  space = parse.space = cc => { while ((cc = cur.charCodeAt(idx)) <= SPACE) idx++; return cc },
+
+  // operator/token lookup table
+  // lookup[0] is id parser to let configs redefine it
+  lookup = [],
+
+
+  // create operator checker/mapper (see examples)
+  token = (
+    op,
+    prec = SPACE,
+    map,
+    c = op.charCodeAt(0),
+    l = op.length,
+    prev = lookup[c],
+    word = op.toUpperCase() !== op // make sure word boundary comes after word operator
+  ) => lookup[c] = (a, curPrec, from = idx) =>
+    (curPrec < prec && (l < 2 || cur.substr(idx, l) == op) && (!word || !isId(cur.charCodeAt(idx + l))) && (idx += l, map(a, curPrec))) ||
+    (idx = from, prev?.(a, curPrec)),
+
+  // right assoc is indicated by negative precedence (meaning go from right to left)
+  binary = (op, prec, right = 0) => token(op, prec, (a, b) => a && (b = expr(prec - right / 2)) && [op, a, b]),
+
+  // post indicates postfix rather than prefix operator
+  unary = (op, prec, post) => token(op, prec, a => post ? (a && [op, a]) : (!a && (a = expr(prec - .5)) && [op, a])),
+
+  // skips means ,,, ;;; are allowed
+  nary = (op, prec, skips) => {
+    token(op, prec, (a, b) => (
+      (a || skips) && // if lhs exists or we're ok to skip
+      (b = expr(prec), b || skips) && // either rhs exists or we're ok to skip rhs
+      (
+        (!a || a[0] !== op) && (a = [op, a]), // if beginning of sequence - init node
+        (b || skips) && a.push(b),
+        a
+      ))
+    )
+  }
+
+export default parse