subscript 9.1.0 → 10.0.0

package/src/parse.js

@@ -1,114 +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
-  err = (msg = 'Bad syntax',
-    lines = cur.slice(0, idx).split('\n'),
-    last = lines.pop()
-  ) => {
-    const before = cur.slice(idx - 108, idx).split('\n').pop()
-    const after = cur.slice(idx, idx + 108).split('\n').shift()
-    throw EvalError(`${msg} at ${lines.length}:${last.length} \`${idx >= 108 ? '…' : ''}${before}┃${after}\``, 'font-weight: bold')
-  },
-
-  // advance until condition meets
-  next = (is, from = idx, l) => {
-    while (l = is(cur.charCodeAt(idx))) idx += l
-    return cur.slice(from, idx)
-  },
-
-  // consume n characters
-  skip = (n = 1, from = idx) => (idx += n, cur.slice(from, idx)),
-
-  // a + b - c
-  expr = (prec = 0, end) => {
-    let cc, token, newNode, fn
-
-    // chunk/token parser
-    while (
-      (cc = space()) && // till not end
-      // FIXME: extra work is happening here, when lookup bails out due to lower precedence -
-      // it makes extra `space` call for parent exprs on the same character to check precedence again
-      (newNode =
-        ((fn = lookup[cc]) && fn(token, prec)) ?? // if operator with higher precedence isn't found
-        (!token && 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()
-
-    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])),
-
-  // FIXME: skips means ,,, ;;; are allowed
-  nary = (op, prec, skips) => {
-    token(op, prec,
-      (a, b) => (
-        b = expr(prec),
-        (
-          (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
-  // FIXME: add "Unclosed paren" error
-  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,31 +0,0 @@
-// convert ast to code string (codegen)
-
-// FIXME: possible enhancements
-// * pairs via options
-// * custom spacing/newlines (`a.b` vs `a + b` vs `a, b` vs `a; b`)
-// * 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;
-}