subscript 9.1.0 → 10.0.0

package/util/stringify.js

@@ -0,0 +1,172 @@
+/**
+ * AST → JS Source String (codegen)
+ *
+ * Simple recursive stringifier using pattern matching on AST structure.
+ */
+
+// Operator-specific overrides
+export const generators = {};
+
+// Register custom generator
+export const generator = (op, fn) => generators[op] = fn;
+
+// Stringify AST to JS source
+export const codegen = node => {
+  // Handle undefined/null
+  if (node === undefined) return 'undefined';
+  if (node === null) return 'null';
+  if (node === '') return '';
+
+  // Identifier
+  if (!Array.isArray(node)) return String(node);
+
+  const [op, ...args] = node;
+
+  // Literal: [, value]
+  if (op === undefined) return typeof args[0] === 'string' ? JSON.stringify(args[0]) : String(args[0]);
+
+  // Custom generator
+  if (generators[op]) return generators[op](...args);
+
+  // Brackets: [], {}, ()
+  if (op === '[]' || op === '{}' || op === '()') {
+    const prefix = args.length > 1 ? codegen(args.shift()) : '';
+    // Empty brackets
+    if (args[0] === undefined || args[0] === null) return prefix + op;
+    // Comma sequence: [',', a, b, c] → a, b, c  (null → empty for sparse arrays)
+    const inner = args[0]?.[0] === ','
+      ? args[0].slice(1).map(a => a === null ? '' : codegen(a)).join(', ')
+      : codegen(args[0]);
+    return prefix + op[0] + inner + op[1];
+  }
+
+  // Unary: [op, a]
+  if (args.length === 1) return op + codegen(args[0]);
+
+  // N-ary/sequence: comma, semicolon
+  if (op === ',' || op === ';') return args.filter(Boolean).map(codegen).join(op === ';' ? '; ' : ', ');
+
+  // Binary: [op, a, b]
+  if (args.length === 2) {
+    const [a, b] = args;
+    // Postfix: [op, a, null]
+    if (b === null) return codegen(a) + op;
+    // Property access: no spaces
+    if (op === '.') return codegen(a) + '.' + b;
+    return codegen(a) + ' ' + op + ' ' + codegen(b);
+  }
+
+  // Ternary: a ? b : c
+  if (op === '?' && args.length === 3) {
+    return codegen(args[0]) + ' ? ' + codegen(args[1]) + ' : ' + codegen(args[2]);
+  }
+
+  // Fallback n-ary
+  return args.filter(Boolean).map(codegen).join(op === ';' ? '; ' : ', ');
+};
+
+// --- Statement generators (need structure) ---
+
+generator('block', body => body === undefined ? '{}' : '{ ' + codegen(body) + ' }');
+
+// Variables: ['let', decl] or ['let', decl1, decl2, ...]
+const varGen = kw => (...args) => kw + ' ' + args.map(codegen).join(', ');
+generator('let', varGen('let'));
+generator('const', varGen('const'));
+generator('var', varGen('var'));
+
+// Control flow
+const wrap = s => s?.[0] === 'block' ? codegen(s) : '{ ' + (s ? codegen(s) : '') + ' }';
+generator('if', (cond, then, els) => 'if (' + codegen(cond) + ') ' + wrap(then) + (els ? ' else ' + wrap(els) : ''));
+generator('while', (cond, body) => 'while (' + codegen(cond) + ') ' + wrap(body));
+generator('do', (body, cond) => 'do ' + wrap(body) + ' while (' + codegen(cond) + ')');
+generator('for', (head, body) => {
+  if (head?.[0] === ';') {
+    const [, init, cond, step] = head;
+    return 'for (' + (init ? codegen(init) : '') + '; ' + (cond ? codegen(cond) : '') + '; ' + (step ? codegen(step) : '') + ') ' + wrap(body);
+  }
+  return 'for (' + codegen(head) + ') ' + wrap(body);
+});
+
+generator('return', a => a === undefined ? 'return' : 'return ' + codegen(a));
+generator('break', () => 'break');
+generator('continue', () => 'continue');
+generator('throw', a => 'throw ' + codegen(a));
+
+// Try/Catch - nested structure
+generator('try', body => 'try { ' + codegen(body) + ' }');
+generator('catch', (tryExpr, param, body) => codegen(tryExpr) + ' catch (' + codegen(param) + ') { ' + codegen(body) + ' }');
+generator('finally', (expr, body) => codegen(expr) + ' finally { ' + codegen(body) + ' }');
+
+// Functions
+generator('function', (name, params, body) => {
+  const args = !params ? '' : params[0] === ',' ? params.slice(1).map(codegen).join(', ') : codegen(params);
+  const b = body?.[0] === 'block' ? codegen(body) : '{ ' + (body ? codegen(body) : '') + ' }';
+  return 'function' + (name ? ' ' + name : '') + '(' + args + ') ' + b;
+});
+
+generator('=>', (params, body) => {
+  if (params?.[0] === '()') params = params[1];
+  const args = !params ? '()' : typeof params === 'string' ? params :
+    params[0] === ',' ? '(' + params.slice(1).map(codegen).join(', ') + ')' : '(' + codegen(params) + ')';
+  return args + ' => ' + codegen(body);
+});
+
+// Class
+generator('class', (name, base, body) =>
+  'class' + (name ? ' ' + name : '') + (base ? ' extends ' + codegen(base) : '') + ' { ' + (body ? codegen(body) : '') + ' }');
+
+// Async/Await/Yield
+generator('async', fn => 'async ' + codegen(fn));
+generator('await', a => 'await ' + codegen(a));
+generator('yield', a => a !== undefined ? 'yield ' + codegen(a) : 'yield');
+generator('yield*', a => 'yield* ' + codegen(a));
+
+// Switch
+generator('switch', (expr, body) => 'switch (' + codegen(expr) + ') ' + codegen(body));
+generator('case', (test, body) => 'case ' + codegen(test) + ':' + (body ? ' ' + codegen(body) : ''));
+generator('default:', body => 'default:' + (body ? ' ' + codegen(body) : ''));
+
+// Keywords
+generator('typeof', a => '(typeof ' + codegen(a) + ')');
+generator('void', a => '(void ' + codegen(a) + ')');
+generator('delete', a => '(delete ' + codegen(a) + ')');
+generator('new', a => 'new ' + codegen(a));
+generator('instanceof', (a, b) => '(' + codegen(a) + ' instanceof ' + codegen(b) + ')');
+
+// Optional chaining
+generator('?.', (a, b) => codegen(a) + '?.' + b);
+generator('?.[]', (a, b) => codegen(a) + '?.[' + codegen(b) + ']');
+generator('?.()', (a, b) => codegen(a) + '?.(' + (!b ? '' : b[0] === ',' ? b.slice(1).map(codegen).join(', ') : codegen(b)) + ')');
+
+// Object literal
+generator(':', (k, v) => (typeof k === 'string' ? k : '[' + codegen(k) + ']') + ': ' + codegen(v));
+
+// Template literals
+generator('`', (...parts) => '`' + parts.map(p => p?.[0] === undefined ? String(p[1]).replace(/`/g, '\\`').replace(/\$/g, '\\$') : '${' + codegen(p) + '}').join('') + '`');
+generator('``', (tag, ...parts) => codegen(tag) + '`' + parts.map(p => p?.[0] === undefined ? String(p[1]).replace(/`/g, '\\`').replace(/\$/g, '\\$') : '${' + codegen(p) + '}').join('') + '`');
+
+// Getter/Setter
+generator('get', (name, body) => 'get ' + name + '() { ' + (body ? codegen(body) : '') + ' }');
+generator('set', (name, param, body) => 'set ' + name + '(' + param + ') { ' + (body ? codegen(body) : '') + ' }');
+generator('static', a => 'static ' + codegen(a));
+
+// Non-JS operators (emit as helpers)
+generator('..', (a, b) => 'range(' + codegen(a) + ', ' + codegen(b) + ')');
+generator('..<', (a, b) => 'range(' + codegen(a) + ', ' + codegen(b) + ', true)');
+generator('as', (a, b) => b ? codegen(a) + ' as ' + b : codegen(a));  // import alias or type assertion
+generator('is', (a, b) => '(' + codegen(a) + ' instanceof ' + codegen(b) + ')');
+generator('defer', a => '/* defer */ ' + codegen(a));
+
+// For-in/of helper
+generator('in', (a, b) => codegen(a) + ' in ' + codegen(b));
+generator('of', (a, b) => codegen(a) + ' of ' + codegen(b));
+generator('for await', (head, body) => 'for await (' + codegen(head) + ') ' + wrap(body));
+
+// Module syntax
+generator('export', spec => 'export ' + codegen(spec));
+generator('import', spec => 'import ' + codegen(spec));
+generator('from', (what, path) => codegen(what) + ' from ' + codegen(path));
+generator('default', a => 'default ' + codegen(a));
+
+export default codegen;

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/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,30 +0,0 @@
-import { token, expr } from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_ACCESS } from '../src/const.js'
-
-// a?.[, a?.( - postfix operator
-token('?.', PREC_ACCESS, a => 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])
-// a ?. b
-operator('?.', (a, b) => b && (a = compile(a), 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 ? () => [] : // a()
-    b[0] === ',' ? (b = b.slice(1).map(compile), ctx => b.map(a => a(ctx))) : // a(b,c)
-      (b = compile(b), ctx => [b(ctx)]), // a(b)
-
-  // a?.()
-  !a[2] && (optional = true, a = a[1]),
-
-  // a?.['x']?.()
-  a[0] === '[]' && a.length === 3 ? (path = compile(a[2])) : (path = () => a[2]),
-  (container = compile(a[1]), optional ?
-    ctx => (container(ctx)?.[path(ctx)]?.(...args(ctx))) :
-    ctx => (container(ctx)?.[path(ctx)](...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,42 +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

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(n: number): 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;