subscript 9.2.0 → 10.0.0

package/feature/add.js

@@ -1,22 +0,0 @@
-
-import { binary, unary } from '../src/parse.js'
-import { PREC_ADD, PREC_PREFIX, PREC_ASSIGN } from '../src/const.js'
-import { compile, prop, operator } from '../src/compile.js'
-
-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)))
-
-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_ASSIGN, true)
-operator('+=', (a, b) => (
-  b = compile(b),
-  prop(a, (container, path, ctx) => container[path] += b(ctx))
-))
-
-binary('-=', PREC_ASSIGN, true)
-operator('-=', (a, b) => (
-  b = compile(b),
-  prop(a, (container, path, ctx) => (container[path] -= b(ctx)))
-))

package/feature/array.js

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

package/feature/arrow.js

@@ -1,23 +0,0 @@
-import { binary, group } from "../src/parse.js"
-import { compile, operator } from "../src/compile.js"
-import { PREC_ASSIGN, PREC_TOKEN } from "../src/const.js"
-
-// arrow functions (useful for array methods)
-binary('=>', PREC_ASSIGN, true)
-operator('=>',
-  (a, b) => (
-    a = a[0] === '()' ? a[1] : a,
-    a = !a ? [] : // () =>
-      a[0] === ',' ? (a = a.slice(1)) : // (a,c) =>
-        (a = [a]), // a =>
-
-    b = compile(b[0] === '{}' ? b[1] : b), // `=> {x}` -> `=> x`
-
-    (ctx = null) => (
-      ctx = Object.create(ctx),
-      (...args) => (a.map((a, i) => ctx[a] = args[i]), b(ctx))
-    )
-  )
-)
-
-binary('')

package/feature/assign.js

@@ -1,11 +0,0 @@
-import { binary, err } from "../src/parse.js";
-import { compile, operator, operators, prop } 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
-  prop(a, (container, path, ctx) => container[path] = b(ctx))
-))

package/feature/bitwise.js

@@ -1,11 +0,0 @@
-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)))

package/feature/bool.js

@@ -1,5 +0,0 @@
-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

@@ -1,15 +0,0 @@
-import { access } from '../src/parse.js'
-import { operator, compile, prop } from '../src/compile.js'
-import { PREC_ACCESS } from '../src/const.js'
-
-// a(b,c,d), a()
-access('()', PREC_ACCESS)
-operator('()', (a, b, args) => b !== undefined && (
-  args = !b ? () => [] : // a()
-    b[0] === ',' ? (b = b.slice(1).map(b => !b ? err() : compile(b)), 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)
-  prop(a, (obj, path, ctx) => obj[path](...args(ctx)), true)
-)
-)

package/feature/compare.js

@@ -1,11 +0,0 @@
-import { PREC_EQ, PREC_COMP } 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_COMP), operator('>', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) > b(ctx)))
-binary('<', PREC_COMP), operator('<', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) < b(ctx)))
-binary('>=', PREC_COMP), operator('>=', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) >= b(ctx)))
-binary('<=', PREC_COMP), operator('<=', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) <= b(ctx)))

package/feature/control.js

@@ -1,142 +0,0 @@
-/**
- * Control flow: if/else, while, for, break, continue, return, blocks
- *
- * AST:
- *   if (c) a else b    → ['if', c, a, b?]
- *   while (c) a        → ['while', c, a]
- *   for (i;c;s) a      → ['for', i, c, s, a]
- *   { a; b }           → ['block', [';', a, b]]
- *   break/continue     → ['break'] / ['continue']
- *   return x           → ['return', x?]
- */
-import * as P from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_STATEMENT, OPAREN, CPAREN, OBRACE, CBRACE, PREC_SEQ, PREC_TOKEN } from '../src/const.js'
-
-const { token, expr, skip, space, err, parse, next } = P
-const SEMI = 59
-
-// Control signals
-class Break {}
-class Continue {}
-class Return { constructor(v) { this.value = v } }
-export const BREAK = new Break(), CONTINUE = new Continue()
-
-// Shared loop body executor
-const loop = (body, ctx) => {
-  try { return { val: body(ctx) } }
-  catch (e) {
-    if (e === BREAK) return { brk: 1 }
-    if (e === CONTINUE) return { cnt: 1 }
-    if (e instanceof Return) return { ret: 1, val: e.value }
-    throw e
-  }
-}
-
-// if (cond) body [else alt]
-token('if', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  const cond = expr(0, CPAREN), body = parseBody()
-  space()
-  // check 'else' — skip 4 chars via skip() since P.idx is read-only from module
-  const alt = P.cur.substr(P.idx, 4) === 'else' && !parse.id(P.cur.charCodeAt(P.idx + 4))
-    ? (skip(), skip(), skip(), skip(), parseBody()) : undefined
-  return alt !== undefined ? ['if', cond, body, alt] : ['if', cond, body]
-})
-
-operator('if', (cond, body, alt) => {
-  cond = compile(cond); body = compile(body); alt = alt !== undefined ? compile(alt) : null
-  return ctx => cond(ctx) ? body(ctx) : alt?.(ctx)
-})
-
-// while (cond) body
-token('while', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  return ['while', expr(0, CPAREN), parseBody()]
-})
-
-operator('while', (cond, body) => {
-  cond = compile(cond); body = compile(body)
-  return ctx => {
-    let r, res
-    while (cond(ctx)) {
-      r = loop(body, ctx)
-      if (r.brk) break
-      if (r.cnt) continue
-      if (r.ret) return r.val
-      res = r.val
-    }
-    return res
-  }
-})
-
-// for (init; cond; step) body
-token('for', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  const init = space() === SEMI ? null : expr(PREC_SEQ)
-  space() === SEMI ? skip() : err('Expected ;')
-  const cond = space() === SEMI ? null : expr(PREC_SEQ)
-  space() === SEMI ? skip() : err('Expected ;')
-  const step = space() === CPAREN ? null : expr(PREC_SEQ)
-  space() === CPAREN ? skip() : err('Expected )')
-  return ['for', init, cond, step, parseBody()]
-})
-
-operator('for', (init, cond, step, body) => {
-  init = init ? compile(init) : null
-  cond = cond ? compile(cond) : () => true
-  step = step ? compile(step) : null
-  body = compile(body)
-  return ctx => {
-    let r, res
-    for (init?.(ctx); cond(ctx); step?.(ctx)) {
-      r = loop(body, ctx)
-      if (r.brk) break
-      if (r.cnt) continue
-      if (r.ret) return r.val
-      res = r.val
-    }
-    return res
-  }
-})
-
-// Block parsing helper - only used by control structures
-const parseBody = () => {
-  if (space() === OBRACE) {
-    skip() // consume {
-    return ['block', expr(0, CBRACE)]
-  }
-  return expr(0)  // prec=0 to allow nested control structures
-}
-
-operator('block', body => {
-  if (body === undefined) return () => {}
-  body = compile(body)
-  return ctx => body(Object.create(ctx)) // new scope
-})
-
-// break / continue / return
-token('break', PREC_TOKEN, a => a ? null : ['break'])
-operator('break', () => () => { throw BREAK })
-
-token('continue', PREC_TOKEN, a => a ? null : ['continue'])
-operator('continue', () => () => { throw CONTINUE })
-
-token('return', PREC_STATEMENT, a => {
-  if (a) return
-  space()
-  const c = P.cur.charCodeAt(P.idx)
-  if (!c || c === CBRACE || c === SEMI) return ['return']
-  return ['return', expr(PREC_STATEMENT)]
-})
-
-operator('return', val => {
-  val = val !== undefined ? compile(val) : null
-  return ctx => { throw new Return(val?.(ctx)) }
-})

package/feature/increment.js

@@ -1,11 +0,0 @@
-import { token, expr } from "../src/parse.js"
-import { operator, compile, prop } from "../src/compile.js"
-import { PREC_POSTFIX } from "../src/const.js"
-
-token('++', PREC_POSTFIX, a => a ? ['++', a, null,] : ['++', expr(PREC_POSTFIX - 1)])
-// ++a, ++((a)), ++a.b, ++a[b]
-operator('++', (a,b) => prop(a, b === null ? (obj, path) => obj[path]++ : (obj, path) => ++obj[path]))
-
-token('--', PREC_POSTFIX, a => a ? ['--', a, null,] : ['--', expr(PREC_POSTFIX - 1)])
-// --a, --a.b, --a[b]
-operator('--', (a, b) => prop(a, b === null ? (obj, path) => obj[path]-- : (obj, path) => --obj[path]))

package/feature/logic.js

@@ -1,11 +0,0 @@
-import { PREC_LOR, PREC_LAND, PREC_PREFIX, PREC_ASSIGN } 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_LOR)
-operator('||', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) || b(ctx)))
-
-binary('&&', PREC_LAND)
-operator('&&', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) && b(ctx)))

package/feature/mult.js

@@ -1,25 +0,0 @@
-import { binary } from '../src/parse.js'
-import { operator, compile, prop } 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),
-  prop(a, (container, path, ctx) => container[path] *= b(ctx))
-))
-
-binary('/=', PREC_ASSIGN, true)
-operator('/=', (a, b) => (
-  b = compile(b),
-  prop(a, (container, path, ctx) => container[path] /= b(ctx))
-))
-
-binary('%=', PREC_ASSIGN, true)
-operator('%=', (a, b) => (
-  b = compile(b),
-  prop(a, (container, path, ctx) => container[path] %= b(ctx))
-))

package/feature/object.js

@@ -1,17 +0,0 @@
-import { token, expr, group, binary } from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_ASSIGN, PREC_SEQ, PREC_TOKEN } from '../src/const.js'
-
-
-// {a:1, b:2, c:3}
-group('{}', PREC_TOKEN)
-operator('{}', (a, b) => b === undefined && (
-  // {}, {a:b}, {a}, {a, b}
-  a = (!a ? [] : a[0] !== ',' ? [a] : a.slice(1)),
-  a = a.map(p => compile(typeof p === 'string' ? [':', p, p] : p)),
-  ctx => Object.fromEntries(a.flatMap(frag => frag(ctx)))
-))
-
-binary(':', PREC_ASSIGN - 1, true)
-// "a": a, a: a
-operator(':', (a, b) => (b = compile(b), Array.isArray(a) ? (a = compile(a), ctx => [[a(ctx), b(ctx)]]) : ctx => [[a, b(ctx)]]))

package/feature/optional.js

@@ -1,23 +0,0 @@
-import { token, expr } from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_ACCESS, unsafe } from '../src/const.js'
-
-// a?.[, a?.( - postfix operator
-token('?.', PREC_ACCESS, a => a && ['?.', a])
-operator('?.', a => (a = compile(a), ctx => a(ctx) || (() => { })))
-
-// a?.b, a?.() - optional chain operator
-token('?.', PREC_ACCESS, (a, b) => a && (b = expr(PREC_ACCESS), !b?.map) && ['?.', a, b])
-operator('?.', (a, b) => b && (a = compile(a), unsafe(b) ? () => undefined : ctx => a(ctx)?.[b]))
-
-// a?.x() - keep context, but watch out a?.()
-operator('()', (a, b, container, args, path, optional) => b !== undefined && (a[0] === '?.') && (a[2] || Array.isArray(a[1])) && (
-  args = !b ? () => [] :
-    b[0] === ',' ? (b = b.slice(1).map(compile), ctx => b.map(a => a(ctx))) :
-      (b = compile(b), ctx => [b(ctx)]),
-  !a[2] && (optional = true, a = a[1]),
-  a[0] === '[]' && a.length === 3 ? (path = compile(a[2])) : (path = () => a[2]),
-  container = compile(a[1]), optional ?
-    ctx => { const p = path(ctx); return unsafe(p) ? undefined : container(ctx)?.[p]?.(...args(ctx)) } :
-    ctx => { const p = path(ctx); return unsafe(p) ? undefined : container(ctx)?.[p](...args(ctx)) }
-))

package/feature/pow.js

@@ -1,5 +0,0 @@
-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/shift.js

@@ -1,12 +0,0 @@
-import { PREC_OR, PREC_AND, PREC_SHIFT, PREC_XOR, PREC_PREFIX, PREC_ASSIGN } from "../src/const.js"
-import { unary, binary } from "../src/parse.js"
-import { operator, compile } from "../src/compile.js"
-
-
-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)))
-
-binary('>>=', PREC_ASSIGN, true)
-operator('>>=', (a, b) => (b = compile(b), prop(a, (obj, path, ctx) => (obj[path] >>= b(ctx)))))
-binary('<<=', PREC_ASSIGN, true)
-operator('<<=', (a, b) => (b = compile(b), prop(a, (obj, path, ctx) => (obj[path] <<= b(ctx)))))

package/feature/spread.js

@@ -1,6 +0,0 @@
-import { unary } from "../src/parse.js"
-import { PREC_PREFIX } from "../src/const.js"
-import { operator, compile } from "../src/compile.js"
-
-unary('...', PREC_PREFIX)
-operator('...', (a) => (a = compile(a), ctx => Object.entries(a(ctx))))

package/feature/ternary.js

@@ -1,10 +0,0 @@
-import { token, expr, next } 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 - 1, COLON)) && (c = expr(PREC_ASSIGN - 1), ['?', a, b, c]))
-// ALT: not throwing
-token('?', PREC_ASSIGN, (a, b, c) => a && (b = expr(PREC_ASSIGN - 1)) && next(c => c === 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/src/compile.d.ts

@@ -1,17 +0,0 @@
-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

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

package/src/const.js

@@ -1,45 +0,0 @@
-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
-// we mult by 10 to leave space for extensions
-export const
-  PREC_STATEMENT = 5,
-  PREC_SEQ = 10,
-  PREC_ASSIGN = 20,
-  PREC_LOR = 30,
-  PREC_LAND = 40,
-  PREC_OR = 50,
-  PREC_XOR = 60,
-  PREC_AND = 70,
-  PREC_EQ = 80,
-  PREC_COMP = 90,
-  PREC_SHIFT = 100,
-  PREC_ADD = 110,
-  PREC_MULT = 120,
-  PREC_EXP = 130,
-  PREC_PREFIX = 140,
-  PREC_POSTFIX = 150,
-  PREC_ACCESS = 170,
-  PREC_GROUP = 180,
-  PREC_TOKEN = 200
-
-// Block prototype chain attacks: constructor, prototype, __proto__, __defineGetter__, etc.
-export const unsafe = k => k?.[0] === '_' && k[1] === '_' || k === 'constructor' || k === 'prototype'

package/src/parse.d.ts

@@ -1,22 +0,0 @@
-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(): string;
-export function next(is: ((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 access(op: string, prec: number): (a: any, curPrec: number, from?: any) => any;
-export function group(op: string, prec: number): (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

@@ -1,113 +0,0 @@
-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 || ''),
-
-  // display error with context
-  err = (msg = 'Unexpected token',
-    lines = cur.slice(0, idx).split('\n'),
-    last = lines.pop(),
-    before = cur.slice(Math.max(0, idx - 40), idx),
-    after = cur.slice(idx, idx + 20)
-  ) => {
-    throw SyntaxError(`${msg} at ${lines.length + 1}:${last.length + 1} — ${before}^${after}`)
-  },
-
-  // advance until condition meets
-  next = (is, from = idx, l) => {
-    while (l = is(cur.charCodeAt(idx))) idx += l
-    return cur.slice(from, idx)
-  },
-
-  // advance n characters
-  skip = () => cur[idx++],
-
-  // a + b - c
-  expr = (prec = 0, end) => {
-    let cc, token, newNode, fn
-
-    // chunk/token parser
-    while (
-      (cc = space()) && // till not end
-      // NOTE: when lookup bails on lower precedence, parent expr re-calls space() — acceptable overhead
-      (newNode =
-        ((fn = lookup[cc]) && fn(token, prec)) ?? // if operator with higher precedence isn't found
-        (!token && next(parse.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('Unclosed ' + String.fromCharCode(end - (end > 42 ? 2 : 1)))
-
-    return token
-  },
-
-  // skip space chars, return first non-space character
-  space = cc => { while ((cc = cur.charCodeAt(idx)) <= SPACE) idx++; return cc },
-
-  // parse identifier (configurable)
-  id = parse.id = 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
-
-  // 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, curOp, from = idx) =>
-    (
-      (curOp ?
-        op == curOp :
-        ((l < 2 || cur.substr(idx, l) == op) && (curOp = op)) // save matched op to avoid mismatches like `|` as part of `||`
-      ) &&
-      curPrec < prec && // matches precedence AFTER operator matched
-      !(word && parse.id(cur.charCodeAt(idx + l))) && // finished word, not part of bigger word
-      (idx += l, map(a) || (idx = from, !prev && err())) // throw if operator didn't detect usage pattern: (a;^b) etc
-    ) ||
-    prev?.(a, curPrec, curOp),
-
-  // right assoc is indicated by negative precedence (meaning go from right to left)
-  binary = (op, prec, right = false) => token(op, prec, (a, b) => a && (b = expr(prec - (right ? .5 : 0))) && [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])),
-
-  // NOTE: allows ;;; (valid empty statements) and ,,, (debatable but harmless)
-  // right=true allows same-precedence tokens on RHS (like statements after semicolon)
-  nary = (op, prec, right) => {
-    token(op, prec,
-      (a, b) => (
-        b = expr(prec - (right ? .5 : 0)),
-        (
-          (a?.[0] !== op) && (a = [op, a || null]), // if beginning of sequence - init node
-          b?.[0] === op ? a.push(...b.slice(1)) : a.push(b || null), // comments can return same-token expr
-          a
-        ))
-    )
-  },
-
-  // register (a), [b], {c} etc groups
-  group = (op, prec) => token(op[0], prec, a => (!a && [op, expr(0, op.charCodeAt(1))])),
-
-  // register a(b), a[b], a<b> etc,
-  // NOTE: we make sure `null` indicates placeholder
-  access = (op, prec) => token(op[0], prec, a => (a && [op, a, expr(0, op.charCodeAt(1)) || null]))
-
-
-export default parse

package/src/stringify.js

@@ -1,27 +0,0 @@
-// convert ast to code string (codegen)
-
-// NOTE: possible enhancements — pairs via options, custom spacing/newlines, custom literals
-export function stringify(node) {
-  if (!node) return ''
-
-  if (Array.isArray(node)) {
-    const [op, ...args] = node;
-
-    // 1, "x"
-    if (!op) return JSON.stringify(args[0])
-
-    // (a), a(b)
-    if (op == '[]' || op == '{}' || op == '()') return (args.length > 1 ? stringify(args.shift()) : '') + op[0] + (stringify(args[0])) + op[1]
-
-    // +a
-    if (args.length === 1) return op + stringify(args[0])
-
-    // a + b
-    if (args.length === 2) return stringify(args[0]) + (op === '.' ? op : (' ' + op + ' ')) + stringify(args[1])
-
-    // a; b; c
-    return args.filter(Boolean).map(a => stringify(a)).join(op + '\n')
-  }
-
-  return node;
-}