subscript 9.2.0 → 10.0.0

package/feature/collection.js

@@ -0,0 +1,40 @@
+/**
+ * Collection literals: arrays and objects (Justin feature)
+ *
+ * [a, b, c]
+ * {a: 1, b: 2}
+ * {a, b} (shorthand)
+ */
+import { group, binary, operator, compile } from '../parse.js';
+import { ACC } from './accessor.js';
+
+const ASSIGN = 20, TOKEN = 200;
+
+// [a,b,c]
+group('[]', TOKEN);
+
+// {a:1, b:2, c:3}
+group('{}', TOKEN);
+
+// a: b (colon operator for object properties)
+binary(':', ASSIGN - 1, true);
+
+// Compile
+operator('{}', (a, b) => {
+  if (b !== undefined) return;
+  a = !a ? [] : a[0] !== ',' ? [a] : a.slice(1);
+  const props = a.map(p => compile(typeof p === 'string' ? [':', p, p] : p));
+  return ctx => {
+    const obj = {}, acc = {};
+    for (const e of props.flatMap(f => f(ctx))) {
+      if (e[0] === ACC) {
+        const [, n, desc] = e;
+        acc[n] = { ...acc[n], ...desc, configurable: true, enumerable: true };
+      } else obj[e[0]] = e[1];
+    }
+    for (const n in acc) Object.defineProperty(obj, n, acc[n]);
+    return obj;
+  };
+});
+operator(':', (a, b) => (b = compile(b), Array.isArray(a) ?
+  (a = compile(a), ctx => [[a(ctx), b(ctx)]]) : ctx => [[a, b(ctx)]]));

package/feature/comment.js

@@ -1,6 +1,26 @@
-import { SPACE, STAR, PREC_TOKEN } from "../src/const.js"
-import { token, skip, next, cur, idx, expr } from "../src/parse.js"
+/** Configurable comments via parse.comment = { start: end } */
+import { parse, cur, idx, seek } from '../parse.js';
 
-// /**/, //
-token('/*', PREC_TOKEN, (a, prec) => (next(c => c !== STAR && cur.charCodeAt(idx + 1) !== 47), skip(),skip(), a || expr(prec) || []))
-token('//', PREC_TOKEN, (a, prec) => (next(c => c >= SPACE), a || expr(prec) || []))
+const SPACE = 32, space = parse.space;
+
+// Default C-style comments
+parse.comment ??= { '//': '\n', '/*': '*/' };
+
+// Cached array: [[start, end, firstCharCode], ...]
+let comments;
+
+parse.space = () => {
+  if (!comments) comments = Object.entries(parse.comment).map(([s, e]) => [s, e, s.charCodeAt(0)]);
+  for (var cc; (cc = space()); ) {
+    for (var j = 0, c; c = comments[j++]; ) {
+      if (cc === c[2] && cur.substr(idx, c[0].length) === c[0]) {
+        var i = idx + c[0].length;
+        if (c[1] === '\n') while (cur.charCodeAt(i) >= SPACE) i++;
+        else { while (cur[i] && cur.substr(i, c[1].length) !== c[1]) i++; if (cur[i]) i += c[1].length; }
+        seek(i); cc = 0; break;
+      }
+    }
+    if (cc) return cc;
+  }
+  return cc;
+};

package/feature/destruct.js

@@ -0,0 +1,33 @@
+/**
+ * Destructuring patterns and binding
+ *
+ * Handles: [a, b] = arr, {x, y} = obj, [a, ...rest] = arr, {x = default} = obj
+ */
+import { compile } from '../parse.js';
+
+// Destructure value into context
+export const destructure = (pattern, value, ctx) => {
+  if (typeof pattern === 'string') { ctx[pattern] = value; return; }
+  const [op, ...items] = pattern;
+  if (op === '{}') {
+    for (const item of items) {
+      let key, binding, def;
+      if (item[0] === '=') [, [, key, binding], def] = item;
+      else [, key, binding] = item;
+      let val = value[key];
+      if (val === undefined && def) val = compile(def)(ctx);
+      destructure(binding, val, ctx);
+    }
+  } else if (op === '[]') {
+    let i = 0;
+    for (const item of items) {
+      if (item === null) { i++; continue; }
+      if (Array.isArray(item) && item[0] === '...') { ctx[item[1]] = value.slice(i); break; }
+      let binding = item, def;
+      if (Array.isArray(item) && item[0] === '=') [, binding, def] = item;
+      let val = value[i++];
+      if (val === undefined && def) val = compile(def)(ctx);
+      destructure(binding, val, ctx);
+    }
+  }
+};

package/feature/function.js

@@ -0,0 +1,44 @@
+// Function declarations and expressions
+import { space, next, parse, parens, expr, operator, compile } from '../parse.js';
+import { RETURN } from './loop.js';
+import { keyword, block } from './block.js';
+
+const TOKEN = 200;
+
+keyword('function', TOKEN, () => {
+  space();
+  const name = next(parse.id);
+  name && space();
+  return ['function', name, parens() || null, block()];
+});
+
+// Compile
+operator('function', (name, params, body) => {
+  body = body ? compile(body) : () => undefined;
+  // Normalize params: null → [], 'x' → ['x'], [',', 'a', 'b'] → ['a', 'b']
+  const ps = !params ? [] : params[0] === ',' ? params.slice(1) : [params];
+  // Check for rest param
+  let restName = null, restIdx = -1;
+  const last = ps[ps.length - 1];
+  if (Array.isArray(last) && last[0] === '...') {
+    restIdx = ps.length - 1;
+    restName = last[1];
+    ps.length--;
+  }
+  return ctx => {
+    const fn = (...args) => {
+      const l = {};
+      ps.forEach((p, i) => l[p] = args[i]);
+      if (restName) l[restName] = args.slice(restIdx);
+      const fnCtx = new Proxy(l, {
+        get: (l, k) => k in l ? l[k] : ctx[k],
+        set: (l, k, v) => ((k in l ? l : ctx)[k] = v, true),
+        has: (l, k) => k in l || k in ctx
+      });
+      try { return body(fnCtx); }
+      catch (e) { if (e?.type === RETURN) return e.value; throw e; }
+    };
+    if (name) ctx[name] = fn;
+    return fn;
+  };
+});

package/feature/group.js

@@ -1,11 +1,41 @@
-import { err, nary, group } from '../src/parse.js'
-import { compile, operator } from '../src/compile.js'
-import { PREC_ACCESS, PREC_GROUP, PREC_SEQ, PREC_STATEMENT } from '../src/const.js'
+import { nary, group, operator, compile } from '../parse.js';
+import { BREAK, CONTINUE } from './loop.js';
+import { prop } from './access.js';
 
-// (a,b,c), (a) — uses PREC_ACCESS to avoid conflict with ?.
-group('()', PREC_ACCESS)
-operator('()', (a, b) => b === undefined && (!a && err('Empty ()'), compile(a)))
+const STATEMENT = 5, SEQ = 10, ACCESS = 170;
 
-const last = (...args) => (args = args.map(compile), ctx => args.map(arg => arg(ctx)).pop())
-nary(',', PREC_SEQ), operator(',', last)
-nary(';', PREC_STATEMENT, true), operator(';', last)
+// (a,b,c), (a) — uses ACCESS to avoid conflict with ?.
+group('()', ACCESS);
+
+// Sequences
+nary(',', SEQ);
+nary(';', STATEMENT, true);  // right-assoc to allow same-prec statements
+
+// Compile
+const err = msg => { throw Error(msg) };
+operator('()', (a, b) => {
+  // Group: (expr) - no second argument means grouping, not call
+  if (b === undefined) return a == null ? err('Empty ()') : compile(a);
+  // Validate: no sparse arguments in calls
+  const hasSparse = n => n?.[0] === ',' && n.slice(1).some(a => a == null || hasSparse(a));
+  if (hasSparse(b)) err('Empty argument');
+  const args = !b ? () => [] :
+    b[0] === ',' ? (b = b.slice(1).map(compile), ctx => b.map(arg => arg(ctx))) :
+    (b = compile(b), ctx => [b(ctx)]);
+  return prop(a, (obj, path, ctx) => obj[path](...args(ctx)), true);
+});
+
+// sequence returns last evaluated value; catches BREAK/CONTINUE and attaches result
+const seq = (...args) => (args = args.map(compile), ctx => {
+  let r;
+  for (const arg of args) {
+    try { r = arg(ctx); }
+    catch (e) {
+      if (e?.type === BREAK || e?.type === CONTINUE) { e.value = r; throw e; }
+      throw e;
+    }
+  }
+  return r;
+});
+operator(',', seq);
+operator(';', seq);

package/feature/if.js

@@ -1,43 +1,28 @@
-/**
- * Conditionals: if/else
- *
- * AST:
- *   if (c) a else b    → ['if', c, a, b?]
- */
-import * as P from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_STATEMENT, OPAREN, CPAREN, OBRACE, CBRACE } from '../src/const.js'
+// If/else statement - else consumed internally
+import { space, skip, parens, word, idx, seek, operator, compile } from '../parse.js';
+import { body, keyword } from './block.js';
 
-const { token, expr, skip, space, err, parse } = P
+const STATEMENT = 5, SEMI = 59;
 
-// Block parsing helper
-const parseBody = () => {
-  if (space() === OBRACE) {
-    skip()
-    return ['block', expr(0, CBRACE)]
-  }
-  return expr(0)
-}
+// Check for `else` after optional semicolon
+const checkElse = () => {
+  const from = idx;
+  if (space() === SEMI) skip();
+  space();
+  if (word('else')) return skip(4), true;
+  return seek(from), false;
+};
 
-operator('block', body => {
-  if (body === undefined) return () => {}
-  body = compile(body)
-  return ctx => body(Object.create(ctx))
-})
-
-// 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()
-  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]
-})
+// if (cond) body [else body] - self-contained
+keyword('if', STATEMENT + 1, () => {
+  space();
+  const node = ['if', parens(), body()];
+  if (checkElse()) node.push(body());
+  return node;
+});
 
+// Compile
 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)
-})
+  cond = compile(cond); body = compile(body); alt = alt !== undefined ? compile(alt) : null;
+  return ctx => cond(ctx) ? body(ctx) : alt?.(ctx);
+});

package/feature/literal.js

@@ -0,0 +1,13 @@
+/**
+ * Literal values
+ *
+ * true, false, null, undefined, NaN, Infinity
+ */
+import { literal } from '../parse.js';
+
+literal('true', true);
+literal('false', false);
+literal('null', null);
+literal('undefined', undefined);
+literal('NaN', NaN);
+literal('Infinity', Infinity);

package/feature/loop.js

@@ -1,122 +1,123 @@
-/**
- * Loops: while, for, break, continue, return
- *
- * AST:
- *   while (c) a        → ['while', c, a]
- *   for (i;c;s) a      → ['for', i, c, s, a]
- *   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'
+// Loops: while, do-while, for, for await, break, continue, return
+import { expr, skip, space, parse, word, parens, cur, idx, operator, compile } from '../parse.js';
+import { body, keyword } from './block.js';
+import { destructure } from './destruct.js';
 
-const { token, expr, skip, space, err } = P
-const SEMI = 59
+// Control flow symbols
+export const BREAK = Symbol('break'), CONTINUE = Symbol('continue'), RETURN = Symbol('return');
 
-// 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) } }
+// Loop body executor - catches control flow and returns status
+export const loop = (body, ctx) => {
+  try { return { v: 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 (e?.type === BREAK) return { b: 1 };
+    if (e?.type === CONTINUE) return { c: 1 };
+    if (e?.type === RETURN) return { r: 1, v: e.value };
+    throw e;
   }
-}
+};
 
-// Block parsing helper
-const parseBody = () => {
-  if (space() === OBRACE) {
-    skip()
-    return ['block', expr(0, CBRACE)]
-  }
-  return expr(0)
-}
+const STATEMENT = 5, CBRACE = 125, SEMI = 59;
 
-operator('block', body => {
-  if (body === undefined) return () => {}
-  body = compile(body)
-  return ctx => body(Object.create(ctx))
-})
+keyword('while', STATEMENT + 1, () => (space(), ['while', parens(), body()]));
+keyword('do', STATEMENT + 1, () => (b => (space(), skip(5), space(), ['do', b, parens()]))(body()));
+
+// for / for await
+keyword('for', STATEMENT + 1, () => {
+  space();
+  // for await (x of y)
+  if (word('await')) {
+    skip(5);
+    space();
+    return ['for await', parens(), body()];
+  }
+  return ['for', parens(), body()];
+});
 
-// while (cond) body
-token('while', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  return ['while', expr(0, CPAREN), parseBody()]
-})
+keyword('break', STATEMENT + 1, () => ['break']);
+keyword('continue', STATEMENT + 1, () => ['continue']);
+keyword('return', STATEMENT + 1, () => {
+  parse.asi && (parse.newline = false);
+  space();
+  const c = cur.charCodeAt(idx);
+  return !c || c === CBRACE || c === SEMI || parse.newline ? ['return'] : ['return', expr(STATEMENT)];
+});
 
+// Compile
 operator('while', (cond, body) => {
-  cond = compile(cond); body = compile(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
-  }
-})
+    let r, res;
+    while (cond(ctx)) if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v;
+    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)
+operator('do', (body, cond) => {
+  body = compile(body); cond = compile(cond);
   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
-  }
-})
+    let r, res;
+    do { if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v; } while (cond(ctx));
+    return res;
+  };
+});
 
-// break / continue / return
-token('break', PREC_TOKEN, a => a ? null : ['break'])
-operator('break', () => () => { throw BREAK })
+operator('for', (head, body) => {
+  // Normalize head: [';', init, cond, step] or single expr (for-in/of)
+  if (Array.isArray(head) && head[0] === ';') {
+    let [, init, cond, step] = head;
+    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))
+        if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v;
+      return res;
+    };
+  }
+  // For-in/of: head is ['in', lhs, rhs] or ['of', lhs, rhs]
+  if (Array.isArray(head) && (head[0] === 'in' || head[0] === 'of')) {
+    let [op, lhs, rhs] = head;
+    // Extract name from declaration: ['let', 'x'] → 'x'
+    if (Array.isArray(lhs) && (lhs[0] === 'let' || lhs[0] === 'const' || lhs[0] === 'var')) lhs = lhs[1];
+    if (op === 'in') return forIn(lhs, rhs, body);
+    if (op === 'of') return forOf(lhs, rhs, body);
+  }
+});
 
-token('continue', PREC_TOKEN, a => a ? null : ['continue'])
-operator('continue', () => () => { throw CONTINUE })
+const forOf = (name, iterable, body) => {
+  iterable = compile(iterable); body = compile(body);
+  const isPattern = Array.isArray(name);
+  return ctx => {
+    let r, res;
+    const prev = isPattern ? null : ctx[name];
+    for (const val of iterable(ctx)) {
+      if (isPattern) destructure(name, val, ctx); else ctx[name] = val;
+      if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v;
+    }
+    if (!isPattern) ctx[name] = prev;
+    return res;
+  };
+};
 
-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)]
-})
+const forIn = (name, obj, body) => {
+  obj = compile(obj); body = compile(body);
+  const isPattern = Array.isArray(name);
+  return ctx => {
+    let r, res;
+    const prev = isPattern ? null : ctx[name];
+    for (const key in obj(ctx)) {
+      if (isPattern) destructure(name, key, ctx); else ctx[name] = key;
+      if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v;
+    }
+    if (!isPattern) ctx[name] = prev;
+    return res;
+  };
+};
 
-operator('return', val => {
-  val = val !== undefined ? compile(val) : null
-  return ctx => { throw new Return(val?.(ctx)) }
-})
+operator('break', () => () => { throw { type: BREAK }; });
+operator('continue', () => () => { throw { type: CONTINUE }; });
+operator('return', val => (val = val !== undefined ? compile(val) : null,
+  ctx => { throw { type: RETURN, value: val?.(ctx) }; }));

package/feature/module.js

@@ -0,0 +1,42 @@
+/**
+ * Import/Export with contextual 'from' operator
+ *
+ * AST:
+ *   import './x.js'              → ['import', path]
+ *   import X from './x.js'       → ['import', ['from', 'X', path]]
+ *   import { a, b } from './x'   → ['import', ['from', ['{}', ...], path]]
+ *   import * as X from './x.js'  → ['import', ['from', ['as', '*', X], path]]
+ *   export { a } from './x'      → ['export', ['from', ['{}', ...], path]]
+ *   export const x = 1           → ['export', decl]
+ */
+import { token, expr, space, lookup, skip } from '../parse.js';
+import { keyword } from './block.js';
+
+const STATEMENT = 5, SEQ = 10, STAR = 42;
+
+// * as prefix in import context (import * as X)
+const prevStar = lookup[STAR];
+lookup[STAR] = (a, prec) => !a ? (skip(), '*') : prevStar?.(a, prec);
+
+// 'from' as contextual binary - only after import-like LHS (not = or ,), false in prefix for identifier fallback
+token('from', SEQ + 1, a => !a ? false : a[0] !== '=' && a[0] !== ',' && (space(), ['from', a, expr(SEQ + 1)]));
+
+// 'as' for aliasing: * as X, { a as b }. False in prefix for identifier fallback
+token('as', SEQ + 2, a => !a ? false : (space(), ['as', a, expr(SEQ + 2)]));
+
+// import: prefix that parses specifiers + from + path
+keyword('import', STATEMENT, () => (space(), ['import', expr(SEQ)]));
+
+// export: prefix for declarations or re-exports (use STATEMENT to capture const/let/function)
+keyword('export', STATEMENT, () => (space(), ['export', expr(STATEMENT)]));
+
+// default: prefix for export default
+keyword('default', SEQ + 1, () => (space(), ['default', expr(SEQ)]));
+
+// Compile stubs - import/export are parse-only (no runtime semantics)
+import { operator, compile } from '../parse.js';
+operator('import', () => () => undefined);
+operator('export', () => () => undefined);
+operator('from', (a, b) => () => undefined);
+operator('as', (a, b) => () => undefined);
+operator('default', (a) => compile(a));

package/feature/number.js

@@ -1,45 +1,48 @@
-import { lookup, next, err, skip } from "../src/parse.js"
-import { cur, idx } from "../src/parse.js"
-import { PERIOD, _0, _E, _e, _9 } from "../src/const.js"
+/**
+ * Numbers with configurable prefix notation
+ *
+ * Configurable via parse.number: { '0x': 16, '0b': 2, '0o': 8 }
+ */
+import { parse, lookup, next, err, skip, idx, cur } from '../parse.js';
 
-// Char codes for prefixes
-const _b = 98, _B = 66, _o = 111, _O = 79, _x = 120, _X = 88
-const _a = 97, _f = 102, _A = 65, _F = 70
+const PERIOD = 46, _0 = 48, _9 = 57, _E = 69, _e = 101, PLUS = 43, MINUS = 45;
+const _a = 97, _f = 102, _A = 65, _F = 70;
 
-// parse decimal number (with optional exponent)
-const num = (a, _) => [, (
-  a = +next(c => (c === PERIOD) || (c >= _0 && c <= _9) || (c === _E || c === _e ? 2 : 0))
-) != a ? err() : a]
+// Decimal number - check for .. range operator (don't consume . if followed by .)
+const num = a => [, (
+  a = +next(c =>
+    // . is decimal only if NOT followed by another . (range operator)
+    (c === PERIOD && cur.charCodeAt(idx + 1) !== PERIOD) ||
+    (c >= _0 && c <= _9) ||
+    ((c === _E || c === _e) && ((c = cur.charCodeAt(idx + 1)) >= _0 && c <= _9 || c === PLUS || c === MINUS) ? 2 : 0)
+  )
+) != a ? err() : a];
 
-// .1
-lookup[PERIOD] = a => !a && num()
+// Char test for prefix base
+const charTest = {
+  2: c => c === 48 || c === 49,
+  8: c => c >= 48 && c <= 55,
+  16: c => (c >= _0 && c <= _9) || (c >= _a && c <= _f) || (c >= _A && c <= _F)
+};
 
-// 1-9 (non-zero starts decimal)
-for (let i = _0 + 1; i <= _9; i++) lookup[i] = a => a ? err() : num()
+// Default: no prefixes
+parse.number = null;
 
-// 0 - check for prefix (0b, 0o, 0x) or plain decimal
+// .1 (but not .. range)
+lookup[PERIOD] = a => !a && cur.charCodeAt(idx + 1) !== PERIOD && num();
+
+// 0-9: check parse.number for prefix config
+for (let i = _0; i <= _9; i++) lookup[i] = a => a ? void 0 : num();
 lookup[_0] = a => {
-  if (a) return err()
-  const nextChar = cur.charCodeAt(idx + 1)
-  
-  // Binary: 0b
-  if (nextChar === _b || nextChar === _B) {
-    skip(); skip() // consume '0b'
-    const s = next(c => c === 48 || c === 49) // 0 or 1
-    return [, parseInt(s, 2)]
-  }
-  // Octal: 0o
-  if (nextChar === _o || nextChar === _O) {
-    skip(); skip() // consume '0o'
-    const s = next(c => c >= 48 && c <= 55) // 0-7
-    return [, parseInt(s, 8)]
-  }
-  // Hex: 0x
-  if (nextChar === _x || nextChar === _X) {
-    skip(); skip() // consume '0x'
-    const s = next(c => (c >= _0 && c <= _9) || (c >= _a && c <= _f) || (c >= _A && c <= _F))
-    return [, parseInt(s, 16)]
+  if (a) return;
+  const cfg = parse.number;
+  if (cfg) {
+    for (const [pre, base] of Object.entries(cfg)) {
+      if (pre[0] === '0' && cur[idx + 1]?.toLowerCase() === pre[1]) {
+        skip(2);
+        return [, parseInt(next(charTest[base]), base)];
+      }
+    }
   }
-  
-  return num()
-}
+  return num();
+};