rip-lang 3.6.1 → 3.7.0

package/src/compiler.js

@@ -206,7 +206,9 @@ export class CodeGenerator {
     'continue-if': 'generateContinueIf',
     '?': 'generateExistential',
     '?:': 'generateTernary',
+    '|>': 'generatePipe',
     'loop': 'generateLoop',
+    'loop-n': 'generateLoopN',
     'await': 'generateAwait',
     'yield': 'generateYield',
     'yield-from': 'generateYieldFrom',
@@ -362,9 +364,9 @@ export class CodeGenerator {
       if (typeof target === 'string' || target instanceof String) {
         let varName = str(target);
         if (!this.reactiveVars?.has(varName)) this.programVars.add(varName);
-      } else if (Array.isArray(target) && target[0] === 'array') {
+      } else if (this.is(target, 'array')) {
         this.collectVarsFromArray(target, this.programVars);
-      } else if (Array.isArray(target) && target[0] === 'object') {
+      } else if (this.is(target, 'object')) {
         this.collectVarsFromObject(target, this.programVars);
       }
       this.collectProgramVariables(value);
@@ -392,13 +394,13 @@ export class CodeGenerator {
       this.collectProgramVariables(rest[0]);
       if (rest.length >= 2 && Array.isArray(rest[1]) && rest[1].length === 2 && rest[1][0] !== 'block') {
         let [param, catchBlock] = rest[1];
-        if (param && Array.isArray(param) && param[0] === 'object') {
+        if (param && this.is(param, 'object')) {
           param.slice(1).forEach(pair => {
             if (Array.isArray(pair) && pair.length === 2 && typeof pair[1] === 'string') {
               this.programVars.add(pair[1]);
             }
           });
-        } else if (param && Array.isArray(param) && param[0] === 'array') {
+        } else if (param && this.is(param, 'array')) {
           param.slice(1).forEach(item => {
             if (typeof item === 'string') this.programVars.add(item);
           });
@@ -425,8 +427,8 @@ export class CodeGenerator {
       if (CodeGenerator.ASSIGNMENT_OPS.has(head)) {
         let [target, value] = rest;
         if (typeof target === 'string') vars.add(target);
-        else if (Array.isArray(target) && target[0] === 'array') this.collectVarsFromArray(target, vars);
-        else if (Array.isArray(target) && target[0] === 'object') this.collectVarsFromObject(target, vars);
+        else if (this.is(target, 'array')) this.collectVarsFromArray(target, vars);
+        else if (this.is(target, 'object')) this.collectVarsFromObject(target, vars);
         collect(value);
         return;
       }
@@ -435,11 +437,11 @@ export class CodeGenerator {
         collect(rest[0]);
         if (rest.length >= 2 && Array.isArray(rest[1]) && rest[1].length === 2 && rest[1][0] !== 'block') {
           let [param, catchBlock] = rest[1];
-          if (param && Array.isArray(param) && param[0] === 'object') {
+          if (param && this.is(param, 'object')) {
             param.slice(1).forEach(pair => {
               if (Array.isArray(pair) && pair.length === 2 && typeof pair[1] === 'string') vars.add(pair[1]);
             });
-          } else if (param && Array.isArray(param) && param[0] === 'array') {
+          } else if (param && this.is(param, 'array')) {
             param.slice(1).forEach(item => { if (typeof item === 'string') vars.add(item); });
           }
           collect(catchBlock);
@@ -603,7 +605,7 @@ export class CodeGenerator {
         let [obj, prop] = head.slice(1);
         let objCode = this.generate(obj, 'value');
         let needsParens = CodeGenerator.NUMBER_LITERAL_RE.test(objCode) ||
-                          (Array.isArray(obj) && (obj[0] === 'object' || obj[0] === 'await' || obj[0] === 'yield'));
+                          ((this.is(obj, 'object') || this.is(obj, 'await') || this.is(obj, 'yield')));
         let base = needsParens ? `(${objCode})` : objCode;
         calleeCode = `${base}.${str(prop)}`;
       } else {
@@ -638,9 +640,9 @@ export class CodeGenerator {
     let blockStmts = ['def', 'class', 'if', 'unless', 'for-in', 'for-of', 'for-as', 'while', 'until', 'loop', 'switch', 'try'];
     let statementsCode = other.map((stmt, index) => {
       let isSingle = other.length === 1 && imports.length === 0 && exports.length === 0;
-      let isObj = Array.isArray(stmt) && stmt[0] === 'object';
+      let isObj = this.is(stmt, 'object');
       let isObjComp = isObj && stmt.length === 2 && Array.isArray(stmt[1]) && Array.isArray(stmt[1][1]) && stmt[1][1][0] === 'comprehension';
-      let isAlreadyExpr = Array.isArray(stmt) && (stmt[0] === 'comprehension' || stmt[0] === 'object-comprehension' || stmt[0] === 'do-iife');
+      let isAlreadyExpr = (this.is(stmt, 'comprehension') || this.is(stmt, 'object-comprehension') || this.is(stmt, 'do-iife'));
       let hasNoVars = this.programVars.size === 0;
       let needsParens = isSingle && isObj && hasNoVars && !isAlreadyExpr && !isObjComp;
       let isLast = index === other.length - 1;
@@ -672,24 +674,28 @@ export class CodeGenerator {
       needsBlank = true;
     }
 
-    if (this.helpers.has('slice'))      { code += 'const slice = [].slice;\n'; needsBlank = true; }
-    if (this.helpers.has('modulo'))     { code += 'const modulo = (n, d) => { n = +n; d = +d; return (n % d + d) % d; };\n'; needsBlank = true; }
-    if (this.helpers.has('toSearchable')) {
-      code += 'const toSearchable = (v, allowNewlines) => {\n';
-      code += '  if (typeof v === "string") return !allowNewlines && /[\\n\\r]/.test(v) ? null : v;\n';
-      code += '  if (v == null) return "";\n';
-      code += '  if (typeof v === "number" || typeof v === "bigint" || typeof v === "boolean") return String(v);\n';
-      code += '  if (typeof v === "symbol") return v.description || "";\n';
-      code += '  if (v instanceof Uint8Array || v instanceof ArrayBuffer) {\n';
-      code += '    return new TextDecoder().decode(v instanceof Uint8Array ? v : new Uint8Array(v));\n';
-      code += '  }\n';
-      code += '  if (Array.isArray(v)) return v.join(",");\n';
-      code += '  if (typeof v.toString === "function" && v.toString !== Object.prototype.toString) {\n';
-      code += '    try { return v.toString(); } catch { return ""; }\n';
-      code += '  }\n';
-      code += '  return "";\n';
-      code += '};\n';
-      needsBlank = true;
+    let skip = this.options.skipPreamble;
+
+    if (!skip) {
+      if (this.helpers.has('slice'))      { code += 'const slice = [].slice;\n'; needsBlank = true; }
+      if (this.helpers.has('modulo'))     { code += 'const modulo = (n, d) => { n = +n; d = +d; return (n % d + d) % d; };\n'; needsBlank = true; }
+      if (this.helpers.has('toSearchable')) {
+        code += 'const toSearchable = (v, allowNewlines) => {\n';
+        code += '  if (typeof v === "string") return !allowNewlines && /[\\n\\r]/.test(v) ? null : v;\n';
+        code += '  if (v == null) return "";\n';
+        code += '  if (typeof v === "number" || typeof v === "bigint" || typeof v === "boolean") return String(v);\n';
+        code += '  if (typeof v === "symbol") return v.description || "";\n';
+        code += '  if (v instanceof Uint8Array || v instanceof ArrayBuffer) {\n';
+        code += '    return new TextDecoder().decode(v instanceof Uint8Array ? v : new Uint8Array(v));\n';
+        code += '  }\n';
+        code += '  if (Array.isArray(v)) return v.join(",");\n';
+        code += '  if (typeof v.toString === "function" && v.toString !== Object.prototype.toString) {\n';
+        code += '    try { return v.toString(); } catch { return ""; }\n';
+        code += '  }\n';
+        code += '  return "";\n';
+        code += '};\n';
+        needsBlank = true;
+      }
     }
 
     // Generate exports code early so component/reactivity flags are set before runtime checks
@@ -698,7 +704,7 @@ export class CodeGenerator {
       exportsCode = '\n' + exports.map(s => this.addSemicolon(s, this.generate(s, 'statement'))).join('\n');
     }
 
-    if (this.usesReactivity && !this.options.skipReactiveRuntime) {
+    if (this.usesReactivity && !skip) {
       if (typeof globalThis !== 'undefined' && globalThis.__rip) {
         code += 'const { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
       } else {
@@ -707,7 +713,7 @@ export class CodeGenerator {
       needsBlank = true;
     }
 
-    if (this.usesTemplates && !this.options.skipComponentRuntime) {
+    if (this.usesTemplates && !skip) {
       if (typeof globalThis !== 'undefined' && globalThis.__ripComponent) {
         code += 'const { isSignal, __pushComponent, __popComponent, setContext, getContext, hasContext, __cx__ } = globalThis.__ripComponent;\n';
       } else {
@@ -716,7 +722,7 @@ export class CodeGenerator {
       needsBlank = true;
     }
 
-    if (this.dataSection !== null && this.dataSection !== undefined) {
+    if (this.dataSection !== null && this.dataSection !== undefined && !skip) {
       code += 'var DATA;\n_setDataSection();\n';
       needsBlank = true;
     }
@@ -741,6 +747,24 @@ export class CodeGenerator {
       return `(${op}${this.generate(rest[0], 'value')})`;
     }
     let [left, right] = rest;
+    // String repeat: "str" * n → "str".repeat(n)
+    if (op === '*') {
+      let leftStr = left?.valueOf?.() ?? left;
+      if (typeof leftStr === 'string' && /^["']/.test(leftStr)) {
+        return `${this.generate(left, 'value')}.repeat(${this.generate(right, 'value')})`;
+      }
+    }
+    // Chained comparisons: (< (< a b) c) → ((a < b) && (b < c))
+    let COMPARE_OPS = new Set(['<', '>', '<=', '>=']);
+    if (COMPARE_OPS.has(op) && Array.isArray(left)) {
+      let leftOp = left[0]?.valueOf?.() ?? left[0];
+      if (COMPARE_OPS.has(leftOp)) {
+        let a = this.generate(left[1], 'value');
+        let b = this.generate(left[2], 'value');
+        let c = this.generate(right, 'value');
+        return `((${a} ${leftOp} ${b}) && (${b} ${op} ${c}))`;
+      }
+    }
     if (op === '!?') {
       let l = this.generate(left, 'value'), r = this.generate(right, 'value');
       return `(${l} !== undefined ? ${l} : ${r})`;
@@ -776,7 +800,7 @@ export class CodeGenerator {
     let op = head === '?=' ? '??=' : head;
 
     // Validate: no sigils in assignment targets (except void function syntax)
-    let isFnValue = Array.isArray(value) && (value[0] === '->' || value[0] === '=>' || value[0] === 'def');
+    let isFnValue = (this.is(value, '->') || this.is(value, '=>') || this.is(value, 'def'));
     if (target instanceof String && meta(target, 'await') !== undefined && !isFnValue) {
       let sigil = meta(target, 'await') === true ? '!' : '&';
       throw new Error(`Cannot use ${sigil} sigil in variable declaration '${str(target)}'.`);
@@ -787,8 +811,8 @@ export class CodeGenerator {
     }
 
     // Empty destructuring — just evaluate RHS
-    let isEmptyArr = Array.isArray(target) && target[0] === 'array' && target.length === 1;
-    let isEmptyObj = Array.isArray(target) && target[0] === 'object' && target.length === 1;
+    let isEmptyArr = this.is(target, 'array', 0);
+    let isEmptyObj = this.is(target, 'object', 0);
     if (isEmptyArr || isEmptyObj) {
       let v = this.generate(value, 'value');
       return (isEmptyObj && context === 'statement') ? `(${v})` : v;
@@ -817,8 +841,8 @@ export class CodeGenerator {
     }
 
     // Middle/leading rest in array destructuring
-    if (Array.isArray(target) && target[0] === 'array') {
-      let restIdx = target.slice(1).findIndex(el => (Array.isArray(el) && el[0] === '...') || el === '...');
+    if (this.is(target, 'array')) {
+      let restIdx = target.slice(1).findIndex(el => (this.is(el, '...')) || el === '...');
       if (restIdx !== -1 && restIdx < target.length - 2) {
         let elements = target.slice(1);
         let afterRest = elements.slice(restIdx + 1);
@@ -832,10 +856,10 @@ export class CodeGenerator {
           elements.forEach(el => {
             if (el === ',' || el === '...') return;
             if (typeof el === 'string') this.programVars.add(el);
-            else if (Array.isArray(el) && el[0] === '...' && typeof el[1] === 'string') this.programVars.add(el[1]);
+            else if (this.is(el, '...') && typeof el[1] === 'string') this.programVars.add(el[1]);
           });
           let restEl = elements[restIdx];
-          let restVar = Array.isArray(restEl) && restEl[0] === '...' ? restEl[1] : null;
+          let restVar = this.is(restEl, '...') ? restEl[1] : null;
           let stmts = [];
           if (beforePattern) stmts.push(`[${beforePattern}] = ${valueCode}`);
           if (restVar) stmts.push(`[...${restVar}] = ${valueCode}.slice(${restIdx}, -${afterCount})`);
@@ -849,7 +873,7 @@ export class CodeGenerator {
     if (context === 'statement' && head === '=' && Array.isArray(value) &&
         (value[0] === '||' || value[0] === '&&') && value.length === 3) {
       let [binOp, left, right] = value;
-      if (Array.isArray(right) && (right[0] === 'unless' || right[0] === 'if') && right.length === 3) {
+      if ((this.is(right, 'unless') || this.is(right, 'if')) && right.length === 3) {
         let [condType, condition, wrappedValue] = right;
         let unwrapped = Array.isArray(wrappedValue) && wrappedValue.length === 1 ? wrappedValue[0] : wrappedValue;
         let fullValue = [binOp, left, unwrapped];
@@ -889,11 +913,11 @@ export class CodeGenerator {
     }
 
     let valueCode = this.generate(value, 'value');
-    let isObjLit = Array.isArray(value) && value[0] === 'object';
+    let isObjLit = this.is(value, 'object');
     if (!isObjLit) valueCode = this.unwrap(valueCode);
 
     let needsParensVal = context === 'value';
-    let needsParensObj = context === 'statement' && Array.isArray(target) && target[0] === 'object';
+    let needsParensObj = context === 'statement' && this.is(target, 'object');
     if (needsParensVal || needsParensObj) return `(${targetCode} ${op} ${valueCode})`;
     return `${targetCode} ${op} ${valueCode}`;
   }
@@ -908,7 +932,7 @@ export class CodeGenerator {
     let objCode = this.generate(obj, 'value');
     this.suppressReactiveUnwrap = false;
     let needsParens = CodeGenerator.NUMBER_LITERAL_RE.test(objCode) ||
-                      (Array.isArray(obj) && (obj[0] === 'object' || obj[0] === 'await' || obj[0] === 'yield'));
+                      ((this.is(obj, 'object') || this.is(obj, 'await') || this.is(obj, 'yield')));
     let base = needsParens ? `(${objCode})` : objCode;
     if (meta(prop, 'await') === true) return `await ${base}.${str(prop)}()`;
     if (meta(prop, 'predicate')) return `(${base}.${str(prop)} != null)`;
@@ -932,27 +956,41 @@ export class CodeGenerator {
 
   generateIndexAccess(head, rest) {
     let [arr, index] = rest;
-    if (Array.isArray(index) && (index[0] === '..' || index[0] === '...')) {
+    if ((this.is(index, '..') || this.is(index, '...'))) {
       let isIncl = index[0] === '..';
       let arrCode = this.generate(arr, 'value');
       let [start, end] = index.slice(1);
       if (start === null && end === null) return `${arrCode}.slice()`;
       if (start === null) {
-        if (isIncl && this.isNegativeOneLiteral(end)) return `${arrCode}.slice(0)`;
+        if (isIncl && this.is(end, '-', 1) && (str(end[1]) ?? end[1]) == 1) return `${arrCode}.slice(0)`;
         let e = this.generate(end, 'value');
         return isIncl ? `${arrCode}.slice(0, +${e} + 1 || 9e9)` : `${arrCode}.slice(0, ${e})`;
       }
       if (end === null) return `${arrCode}.slice(${this.generate(start, 'value')})`;
       let s = this.generate(start, 'value');
-      if (isIncl && this.isNegativeOneLiteral(end)) return `${arrCode}.slice(${s})`;
+      if (isIncl && this.is(end, '-', 1) && (str(end[1]) ?? end[1]) == 1) return `${arrCode}.slice(${s})`;
       let e = this.generate(end, 'value');
       return isIncl ? `${arrCode}.slice(${s}, +${e} + 1 || 9e9)` : `${arrCode}.slice(${s}, ${e})`;
     }
+    // Negative literal index: arr[-1] → arr.at(-1)
+    if (this.is(index, '-', 1)) {
+      let n = str(index[1]) ?? index[1];
+      if (typeof n === 'number' || (typeof n === 'string' && /^\d+$/.test(n))) {
+        return `${this.generate(arr, 'value')}.at(-${n})`;
+      }
+    }
     return `${this.generate(arr, 'value')}[${this.unwrap(this.generate(index, 'value'))}]`;
   }
 
   generateOptIndex(head, rest) {
     let [arr, index] = rest;
+    // Negative literal index: arr?[-1] → arr?.at(-1)
+    if (this.is(index, '-', 1)) {
+      let n = str(index[1]) ?? index[1];
+      if (typeof n === 'number' || (typeof n === 'string' && /^\d+$/.test(n))) {
+        return `${this.generate(arr, 'value')}?.at(-${n})`;
+      }
+    }
     return `${this.generate(arr, 'value')}?.[${this.generate(index, 'value')}]`;
   }
 
@@ -978,6 +1016,7 @@ export class CodeGenerator {
 
   generateThinArrow(head, rest, context, sexpr) {
     let [params, body] = rest;
+    if ((!params || (Array.isArray(params) && params.length === 0)) && this.containsIt(body)) params = ['it'];
     let sideEffectOnly = this.nextFunctionIsVoid || false;
     this.nextFunctionIsVoid = false;
     let paramList = this.generateParamList(params);
@@ -990,6 +1029,7 @@ export class CodeGenerator {
 
   generateFatArrow(head, rest, context, sexpr) {
     let [params, body] = rest;
+    if ((!params || (Array.isArray(params) && params.length === 0)) && this.containsIt(body)) params = ['it'];
     let sideEffectOnly = this.nextFunctionIsVoid || false;
     this.nextFunctionIsVoid = false;
     let paramList = this.generateParamList(params);
@@ -1001,7 +1041,7 @@ export class CodeGenerator {
     let prefix = isAsync ? 'async ' : '';
 
     if (!sideEffectOnly) {
-      if (Array.isArray(body) && body[0] === 'block' && body.length === 2) {
+      if (this.is(body, 'block') && body.length === 2) {
         let expr = body[1];
         if (!Array.isArray(expr) || expr[0] !== 'return') {
           return `${prefix}${paramSyntax} => ${this.generate(expr, 'value')}`;
@@ -1021,19 +1061,19 @@ export class CodeGenerator {
     let [expr] = rest;
     if (this.sideEffectOnly) return 'return';
 
-    if (Array.isArray(expr) && expr[0] === 'unless') {
+    if (this.is(expr, 'unless')) {
       let [, condition, body] = expr;
       let val = Array.isArray(body) && body.length === 1 ? body[0] : body;
       return `if (!${this.generate(condition, 'value')}) return ${this.generate(val, 'value')}`;
     }
-    if (Array.isArray(expr) && expr[0] === 'if') {
+    if (this.is(expr, 'if')) {
       let [, condition, body, ...elseParts] = expr;
       if (elseParts.length === 0) {
         let val = Array.isArray(body) && body.length === 1 ? body[0] : body;
         return `if (${this.generate(condition, 'value')}) return ${this.generate(val, 'value')}`;
       }
     }
-    if (Array.isArray(expr) && expr[0] === 'new' && Array.isArray(expr[1]) && expr[1][0] === 'unless') {
+    if (this.is(expr, 'new') && Array.isArray(expr[1]) && expr[1][0] === 'unless') {
       let [, unlessNode] = expr;
       let [, condition, body] = unlessNode;
       let val = Array.isArray(body) && body.length === 1 ? body[0] : body;
@@ -1073,10 +1113,10 @@ export class CodeGenerator {
     let [target, body] = rest;
     this.usesReactivity = true;
     let bodyCode;
-    if (Array.isArray(body) && body[0] === 'block') {
+    if (this.is(body, 'block')) {
       let stmts = this.withIndent(() => this.formatStatements(body.slice(1)));
       bodyCode = `{\n${stmts.join('\n')}\n${this.indent()}}`;
-    } else if (Array.isArray(body) && (body[0] === '->' || body[0] === '=>')) {
+    } else if ((this.is(body, '->') || this.is(body, '=>'))) {
       let fnCode = this.generate(body, 'value');
       if (target) return `const ${str(target) ?? this.generate(target, 'value')} = __effect(${fnCode})`;
       return `__effect(${fnCode})`;
@@ -1101,15 +1141,49 @@ export class CodeGenerator {
     return `(${this.generate(rest[0], 'value')} != null)`;
   }
 
-  generateTernary(head, rest) {
+  generateTernary(head, rest, context) {
     let [cond, then_, else_] = rest;
+
+    // Hoist assignment: (cond ? (x = a) : b) → x = (cond ? a : b)
+    // Enables: x = "admin" if cond else "member" without parens
+    let thenHead = then_?.[0]?.valueOf?.() ?? then_?.[0];
+    if (thenHead === '=' && Array.isArray(then_)) {
+      let target = this.generate(then_[1], 'value');
+      let thenVal = this.generate(then_[2], 'value');
+      let elseVal = this.generate(else_, 'value');
+      return `${target} = (${this.unwrap(this.generate(cond, 'value'))} ? ${thenVal} : ${elseVal})`;
+    }
+
     return `(${this.unwrap(this.generate(cond, 'value'))} ? ${this.generate(then_, 'value')} : ${this.generate(else_, 'value')})`;
   }
 
+  generatePipe(head, rest) {
+    let [left, right] = rest;
+    let leftCode = this.generate(left, 'value');
+    // Detect function calls: [fn, ...args] where fn is an identifier or accessor
+    if (Array.isArray(right) && right.length > 1) {
+      let fn = right[0];
+      let isCall = Array.isArray(fn) || (typeof fn === 'string' && /^[a-zA-Z_$]/.test(fn));
+      if (isCall) {
+        let fnCode = this.generate(fn, 'value');
+        let args = right.slice(1).map(a => this.generate(a, 'value'));
+        return `${fnCode}(${leftCode}, ${args.join(', ')})`;
+      }
+    }
+    // Simple reference or property access — call with left as sole arg
+    return `${this.generate(right, 'value')}(${leftCode})`;
+  }
+
   generateLoop(head, rest) {
     return `while (true) ${this.generateLoopBody(rest[0])}`;
   }
 
+  generateLoopN(head, rest) {
+    let [count, body] = rest;
+    let n = this.generate(count, 'value');
+    return `for (let _i = 0; _i < ${n}; _i++) ${this.generateLoopBody(body)}`;
+  }
+
   generateAwait(head, rest) { return `await ${this.generate(rest[0], 'value')}`; }
 
   generateYield(head, rest) {
@@ -1154,7 +1228,7 @@ export class CodeGenerator {
     let varsArray = Array.isArray(vars) ? vars : [vars];
     let noVar = varsArray.length === 0;
     let [itemVar, indexVar] = noVar ? ['_i', null] : varsArray;
-    let itemVarPattern = (Array.isArray(itemVar) && (itemVar[0] === 'array' || itemVar[0] === 'object'))
+    let itemVarPattern = ((this.is(itemVar, 'array') || this.is(itemVar, 'object')))
       ? this.generateDestructuringPattern(itemVar) : itemVar;
 
     // Stepped iteration
@@ -1162,7 +1236,7 @@ export class CodeGenerator {
       let iterCode = this.generate(iterable, 'value');
       let idxName = indexVar || '_i';
       let stepCode = this.generate(step, 'value');
-      let isNeg = this.isNegativeStep(step);
+      let isNeg = this.is(step, '-', 1);
       let isMinus1 = isNeg && (step[1] === '1' || step[1] === 1 || str(step[1]) === '1');
       let isPlus1 = !isNeg && (step === '1' || step === 1 || str(step) === '1');
 
@@ -1172,7 +1246,7 @@ export class CodeGenerator {
       else if (isNeg) loopHeader = `for (let ${idxName} = ${iterCode}.length - 1; ${idxName} >= 0; ${idxName} += ${stepCode}) `;
       else loopHeader = `for (let ${idxName} = 0; ${idxName} < ${iterCode}.length; ${idxName} += ${stepCode}) `;
 
-      if (Array.isArray(body) && body[0] === 'block') {
+      if (this.is(body, 'block')) {
         let stmts = body.slice(1);
         this.indentLevel++;
         let lines = [];
@@ -1204,7 +1278,7 @@ export class CodeGenerator {
     if (indexVar) {
       let iterCode = this.generate(iterable, 'value');
       let code = `for (let ${indexVar} = 0; ${indexVar} < ${iterCode}.length; ${indexVar}++) `;
-      if (Array.isArray(body) && body[0] === 'block') {
+      if (this.is(body, 'block')) {
         code += '{\n';
         this.indentLevel++;
         code += this.indent() + `const ${itemVarPattern} = ${iterCode}[${indexVar}];\n`;
@@ -1234,7 +1308,7 @@ export class CodeGenerator {
       let isExcl = iterHead === '...';
       let [start, end] = iterable.slice(1);
       let isSimple = (e) => typeof e === 'number' || typeof e === 'string' && !e.includes('(') ||
-                            (e instanceof String && !str(e).includes('(')) || (Array.isArray(e) && e[0] === '.');
+                            (e instanceof String && !str(e).includes('(')) || (this.is(e, '.'));
       if (isSimple(start) && isSimple(end)) {
         let s = this.generate(start, 'value'), e = this.generate(end, 'value');
         let cmp = isExcl ? '<' : '<=';
@@ -1258,7 +1332,7 @@ export class CodeGenerator {
     let code = `for (const ${keyVar} in ${objCode}) `;
 
     if (own && !valueVar && !guard) {
-      if (Array.isArray(body) && body[0] === 'block') {
+      if (this.is(body, 'block')) {
         this.indentLevel++;
         let stmts = [`if (!Object.hasOwn(${objCode}, ${keyVar})) continue;`, ...body.slice(1).map(s => this.addSemicolon(s, this.generate(s, 'statement')))];
         this.indentLevel--;
@@ -1268,7 +1342,7 @@ export class CodeGenerator {
     }
 
     if (valueVar) {
-      if (Array.isArray(body) && body[0] === 'block') {
+      if (this.is(body, 'block')) {
         let stmts = body.slice(1);
         this.indentLevel++;
         let lines = [];
@@ -1304,15 +1378,15 @@ export class CodeGenerator {
     let iterable = rest[1], isAwait = rest[2], guard = rest[3], body = rest[4];
 
     let needsTempVar = false, destructStmts = [];
-    if (Array.isArray(firstVar) && firstVar[0] === 'array') {
+    if (this.is(firstVar, 'array')) {
       let elements = firstVar.slice(1);
-      let restIdx = elements.findIndex(el => (Array.isArray(el) && el[0] === '...') || el === '...');
+      let restIdx = elements.findIndex(el => (this.is(el, '...')) || el === '...');
       if (restIdx !== -1 && restIdx < elements.length - 1) {
         needsTempVar = true;
         let afterRest = elements.slice(restIdx + 1), afterCount = afterRest.length;
         let beforeRest = elements.slice(0, restIdx);
         let restEl = elements[restIdx];
-        let restVar = Array.isArray(restEl) && restEl[0] === '...' ? restEl[1] : '_rest';
+        let restVar = this.is(restEl, '...') ? restEl[1] : '_rest';
         let beforePattern = beforeRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.generate(el, 'value')).join(', ');
         let firstPattern = beforePattern ? `${beforePattern}, ...${restVar}` : `...${restVar}`;
         let afterPattern = afterRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.generate(el, 'value')).join(', ');
@@ -1322,7 +1396,7 @@ export class CodeGenerator {
         elements.forEach(el => {
           if (el === ',' || el === '...') return;
           if (typeof el === 'string') this.programVars.add(el);
-          else if (Array.isArray(el) && el[0] === '...' && typeof el[1] === 'string') this.programVars.add(el[1]);
+          else if (this.is(el, '...') && typeof el[1] === 'string') this.programVars.add(el[1]);
         });
       }
     }
@@ -1331,7 +1405,7 @@ export class CodeGenerator {
     let awaitKw = isAwait ? 'await ' : '';
     let itemVarPattern;
     if (needsTempVar) itemVarPattern = '_item';
-    else if (Array.isArray(firstVar) && (firstVar[0] === 'array' || firstVar[0] === 'object'))
+    else if ((this.is(firstVar, 'array') || this.is(firstVar, 'object')))
       itemVarPattern = this.generateDestructuringPattern(firstVar);
     else itemVarPattern = firstVar;
 
@@ -1410,7 +1484,7 @@ export class CodeGenerator {
     let [key, container] = rest;
     let keyCode = this.generate(key, 'value');
     let isNeg = meta(sexpr[0], 'invert');
-    if (Array.isArray(container) && container[0] === 'object') {
+    if (this.is(container, 'object')) {
       let result = `(${keyCode} in ${this.generate(container, 'value')})`;
       return isNeg ? `(!${result})` : result;
     }
@@ -1438,7 +1512,7 @@ export class CodeGenerator {
 
   generateNew(head, rest) {
     let [call] = rest;
-    if (Array.isArray(call) && (call[0] === '.' || call[0] === '?.')) {
+    if ((this.is(call, '.') || this.is(call, '?.'))) {
       let [accType, target, prop] = call;
       if (Array.isArray(target) && !target[0].startsWith) {
         return `(${this.generate(['new', target], 'value')}).${prop}`;
@@ -1479,7 +1553,7 @@ export class CodeGenerator {
     let codes = elements.map(el => {
       if (el === ',') return '';
       if (el === '...') return '';
-      if (Array.isArray(el) && el[0] === '...') return `...${this.generate(el[1], 'value')}`;
+      if (this.is(el, '...')) return `...${this.generate(el[1], 'value')}`;
       return this.generate(el, 'value');
     }).join(', ');
     return hasTrailingElision ? `[${codes},]` : `[${codes}]`;
@@ -1494,11 +1568,11 @@ export class CodeGenerator {
     }
 
     let codes = pairs.map(pair => {
-      if (Array.isArray(pair) && pair[0] === '...') return `...${this.generate(pair[1], 'value')}`;
+      if (this.is(pair, '...')) return `...${this.generate(pair[1], 'value')}`;
       let [key, value, operator] = pair;
       let keyCode;
-      if (Array.isArray(key) && key[0] === 'dynamicKey') keyCode = `[${this.generate(key[1], 'value')}]`;
-      else if (Array.isArray(key) && key[0] === 'str') keyCode = `[${this.generate(key, 'value')}]`;
+      if (this.is(key, 'dynamicKey')) keyCode = `[${this.generate(key[1], 'value')}]`;
+      else if (this.is(key, 'str')) keyCode = `[${this.generate(key, 'value')}]`;
       else keyCode = this.generate(key, 'value');
       let valCode = this.generate(value, 'value');
       if (operator === '=') return `${keyCode} = ${valCode}`;
@@ -1533,22 +1607,22 @@ export class CodeGenerator {
     let needsReturns = context === 'value';
     let tryCode = 'try ';
     let tryBlock = rest[0];
-    tryCode += (needsReturns && Array.isArray(tryBlock) && tryBlock[0] === 'block')
+    tryCode += (needsReturns && this.is(tryBlock, 'block'))
       ? this.generateBlockWithReturns(tryBlock) : this.generate(tryBlock, 'statement');
 
     if (rest.length >= 2 && Array.isArray(rest[1]) && rest[1].length === 2 && rest[1][0] !== 'block') {
       let [param, catchBlock] = rest[1];
       tryCode += ' catch';
-      if (param && Array.isArray(param) && (param[0] === 'object' || param[0] === 'array')) {
+      if (param && (this.is(param, 'object') || this.is(param, 'array'))) {
         tryCode += ' (error)';
         let destructStmt = `(${this.generate(param, 'value')} = error)`;
-        catchBlock = Array.isArray(catchBlock) && catchBlock[0] === 'block'
+        catchBlock = this.is(catchBlock, 'block')
           ? ['block', destructStmt, ...catchBlock.slice(1)]
           : ['block', destructStmt, catchBlock];
       } else if (param) {
         tryCode += ` (${param})`;
       }
-      tryCode += ' ' + ((needsReturns && Array.isArray(catchBlock) && catchBlock[0] === 'block')
+      tryCode += ' ' + ((needsReturns && this.is(catchBlock, 'block'))
         ? this.generateBlockWithReturns(catchBlock) : this.generate(catchBlock, 'statement'));
     } else if (rest.length === 2) {
       tryCode += ' finally ' + this.generate(rest[1], 'statement');
@@ -1672,7 +1746,7 @@ export class CodeGenerator {
         let va = Array.isArray(vars) ? vars : [vars];
         let noVar = va.length === 0;
         let [itemVar, indexVar] = noVar ? ['_i', null] : va;
-        let ivp = (Array.isArray(itemVar) && (itemVar[0] === 'array' || itemVar[0] === 'object'))
+        let ivp = ((this.is(itemVar, 'array') || this.is(itemVar, 'object')))
           ? this.generateDestructuringPattern(itemVar) : itemVar;
 
         if (step && step !== null) {
@@ -1687,7 +1761,7 @@ export class CodeGenerator {
             this.indentLevel++;
           } else {
             let ic = this.generate(iterable, 'value'), idxN = indexVar || '_i', stc = this.generate(step, 'value');
-            let isNeg = this.isNegativeStep(step);
+            let isNeg = this.is(step, '-', 1);
             code += isNeg
               ? this.indent() + `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${idxN} += ${stc}) {\n`
               : this.indent() + `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${idxN} += ${stc}) {\n`;
@@ -1707,7 +1781,7 @@ export class CodeGenerator {
         let own = stepOrOwn;
         let va = Array.isArray(vars) ? vars : [vars];
         let [kv, vv] = va;
-        let kvp = (Array.isArray(kv) && (kv[0] === 'array' || kv[0] === 'object'))
+        let kvp = ((this.is(kv, 'array') || this.is(kv, 'object')))
           ? this.generateDestructuringPattern(kv) : kv;
         let oc = this.generate(iterable, 'value');
         code += this.indent() + `for (const ${kvp} in ${oc}) {\n`;
@@ -1718,7 +1792,7 @@ export class CodeGenerator {
         let isAwait = iter[3];
         let va = Array.isArray(vars) ? vars : [vars];
         let [fv] = va;
-        let ivp = (Array.isArray(fv) && (fv[0] === 'array' || fv[0] === 'object'))
+        let ivp = ((this.is(fv, 'array') || this.is(fv, 'object')))
           ? this.generateDestructuringPattern(fv) : fv;
         code += this.indent() + `for ${isAwait ? 'await ' : ''}(const ${ivp} of ${this.generate(iterable, 'value')}) {\n`;
         this.indentLevel++;
@@ -1739,7 +1813,7 @@ export class CodeGenerator {
     };
 
     let loopStmts = ['for-in', 'for-of', 'for-as', 'while', 'until', 'loop'];
-    if (Array.isArray(expr) && expr[0] === 'block') {
+    if (this.is(expr, 'block')) {
       for (let i = 0; i < expr.length - 1; i++) {
         let s = expr[i + 1], isLast = i === expr.length - 2;
         if (!isLast || hasCtrl(s)) {
@@ -1818,24 +1892,24 @@ export class CodeGenerator {
           // First pass: identify bound methods
           let boundMethods = [];
           for (let [mk, mv] of members) {
-            let isStatic = this.isStaticMember(mk);
-            let isComputed = this.isComputedMember(mk);
+            let isStatic = this.is(mk, '.') && mk[1] === 'this';
+            let isComputed = this.is(mk, 'computed');
             let mName = this.extractMemberName(mk);
-            if (this.isBoundMethod(mv) && !isStatic && !isComputed && mName !== 'constructor') boundMethods.push(mName);
+            if (this.is(mv, '=>') && !isStatic && !isComputed && mName !== 'constructor') boundMethods.push(mName);
           }
 
           // Second pass: generate members
           for (let [mk, mv] of members) {
-            let isStatic = this.isStaticMember(mk);
-            let isComputed = this.isComputedMember(mk);
+            let isStatic = this.is(mk, '.') && mk[1] === 'this';
+            let isComputed = this.is(mk, 'computed');
             let mName = this.extractMemberName(mk);
-            if (Array.isArray(mv) && (mv[0] === '->' || mv[0] === '=>')) {
+            if ((this.is(mv, '->') || this.is(mv, '=>'))) {
               let [, params, body] = mv;
               let hasAwait = this.containsAwait(body), hasYield = this.containsYield(body);
               let cleanParams = params, autoAssign = [];
               if (mName === 'constructor') {
                 cleanParams = params.map(p => {
-                  if (Array.isArray(p) && p[0] === '.' && p[1] === 'this') { autoAssign.push(`this.${p[2]} = ${p[2]}`); return p[2]; }
+                  if (this.is(p, '.') && p[1] === 'this') { autoAssign.push(`this.${p[2]} = ${p[2]}`); return p[2]; }
                   return p;
                 });
                 for (let bm of boundMethods) autoAssign.unshift(`this.${bm} = this.${bm}.bind(this)`);
@@ -1859,8 +1933,8 @@ export class CodeGenerator {
           let additionalStmts = bodyStmts.slice(1);
           this.indentLevel++;
           for (let [mk, mv] of members) {
-            let isStatic = this.isStaticMember(mk), mName = this.extractMemberName(mk);
-            if (Array.isArray(mv) && (mv[0] === '->' || mv[0] === '=>')) {
+            let isStatic = this.is(mk, '.') && mk[1] === 'this', mName = this.extractMemberName(mk);
+            if ((this.is(mv, '->') || this.is(mv, '=>'))) {
               let [, params, body] = mv;
               let pList = this.generateParamList(params);
               let prefix = (isStatic ? 'static ' : '') + (this.containsAwait(body) ? 'async ' : '') + (this.containsYield(body) ? '*' : '');
@@ -1876,9 +1950,9 @@ export class CodeGenerator {
             }
           }
           for (let stmt of additionalStmts) {
-            if (Array.isArray(stmt) && stmt[0] === 'class') {
+            if (this.is(stmt, 'class')) {
               let [, nestedName, parent, ...nestedBody] = stmt;
-              if (Array.isArray(nestedName) && nestedName[0] === '.' && nestedName[1] === 'this') {
+              if (this.is(nestedName, '.') && nestedName[1] === 'this') {
                 code += this.indent() + `static ${nestedName[2]} = ${this.generate(['class', null, parent, ...nestedBody], 'value')};\n`;
               }
             } else {
@@ -1889,7 +1963,7 @@ export class CodeGenerator {
         } else {
           this.indentLevel++;
           for (let stmt of bodyStmts) {
-            if (Array.isArray(stmt) && stmt[0] === '=' && Array.isArray(stmt[1]) && stmt[1][0] === '.' && stmt[1][1] === 'this') {
+            if (this.is(stmt, '=') && Array.isArray(stmt[1]) && stmt[1][0] === '.' && stmt[1][1] === 'this') {
               code += this.indent() + `static ${stmt[1][2]} = ${this.generate(stmt[2], 'value')};\n`;
             } else {
               code += this.indent() + this.generate(stmt, 'statement') + ';\n';
@@ -1944,13 +2018,13 @@ export class CodeGenerator {
   generateExport(head, rest) {
     let [decl] = rest;
     if (Array.isArray(decl) && decl.every(i => typeof i === 'string')) return `export { ${decl.join(', ')} }`;
-    if (Array.isArray(decl) && decl[0] === '=') return `export const ${decl[1]} = ${this.generate(decl[2], 'value')}`;
+    if (this.is(decl, '=')) return `export const ${decl[1]} = ${this.generate(decl[2], 'value')}`;
     return `export ${this.generate(decl, 'statement')}`;
   }
 
   generateExportDefault(head, rest) {
     let [expr] = rest;
-    if (Array.isArray(expr) && expr[0] === '=') {
+    if (this.is(expr, '=')) {
       return `const ${expr[1]} = ${this.generate(expr[2], 'value')};\nexport default ${expr[1]}`;
     }
     return `export default ${this.generate(expr, 'statement')}`;
@@ -2042,14 +2116,14 @@ export class CodeGenerator {
   generateDestructuringPattern(pattern) { return this.formatParam(pattern); }
 
   generateParamList(params) {
-    let expIdx = params.findIndex(p => Array.isArray(p) && p[0] === 'expansion');
+    let expIdx = params.findIndex(p => this.is(p, 'expansion'));
     if (expIdx !== -1) {
       let before = params.slice(0, expIdx), after = params.slice(expIdx + 1);
       let regular = before.map(p => this.formatParam(p)).join(', ');
       this.expansionAfterParams = after;
       return regular ? `${regular}, ..._rest` : '..._rest';
     }
-    let restIdx = params.findIndex(p => Array.isArray(p) && p[0] === 'rest');
+    let restIdx = params.findIndex(p => this.is(p, 'rest'));
     if (restIdx !== -1 && restIdx < params.length - 1) {
       let before = params.slice(0, restIdx), restP = params[restIdx], after = params.slice(restIdx + 1);
       let beforeP = before.map(p => this.formatParam(p));
@@ -2064,24 +2138,24 @@ export class CodeGenerator {
   formatParam(param) {
     if (typeof param === 'string') return param;
     if (param instanceof String) return param.valueOf();
-    if (Array.isArray(param) && param[0] === 'rest') return `...${param[1]}`;
-    if (Array.isArray(param) && param[0] === 'default') return `${param[1]} = ${this.generate(param[2], 'value')}`;
-    if (Array.isArray(param) && param[0] === '.' && param[1] === 'this') return param[2];
-    if (Array.isArray(param) && param[0] === 'array') {
+    if (this.is(param, 'rest')) return `...${param[1]}`;
+    if (this.is(param, 'default')) return `${param[1]} = ${this.generate(param[2], 'value')}`;
+    if (this.is(param, '.') && param[1] === 'this') return param[2];
+    if (this.is(param, 'array')) {
       let els = param.slice(1).map(el => {
         if (el === ',') return '';
         if (el === '...') return '';
-        if (Array.isArray(el) && el[0] === '...') return `...${el[1]}`;
-        if (Array.isArray(el) && el[0] === '=' && typeof el[1] === 'string') return `${el[1]} = ${this.generate(el[2], 'value')}`;
+        if (this.is(el, '...')) return `...${el[1]}`;
+        if (this.is(el, '=') && typeof el[1] === 'string') return `${el[1]} = ${this.generate(el[2], 'value')}`;
         if (typeof el === 'string') return el;
         return this.formatParam(el);
       });
       return `[${els.join(', ')}]`;
     }
-    if (Array.isArray(param) && param[0] === 'object') {
+    if (this.is(param, 'object')) {
       let pairs = param.slice(1).map(pair => {
-        if (Array.isArray(pair) && pair[0] === '...') return `...${pair[1]}`;
-        if (Array.isArray(pair) && pair[0] === 'default') return `${pair[1]} = ${this.generate(pair[2], 'value')}`;
+        if (this.is(pair, '...')) return `...${pair[1]}`;
+        if (this.is(pair, 'default')) return `${pair[1]} = ${this.generate(pair[2], 'value')}`;
         let [key, value] = pair;
         if (key === value) return key;
         return `${key}: ${value}`;
@@ -2116,7 +2190,7 @@ export class CodeGenerator {
     let noRetStmts = ['return', 'throw', 'break', 'continue'];
     let loopStmts = ['for-in', 'for-of', 'for-as', 'while', 'until', 'loop'];
 
-    if (Array.isArray(body) && body[0] === 'block') {
+    if (this.is(body, 'block')) {
       let statements = this.unwrapBlock(body);
 
       if (hasExpansionParams && this.expansionAfterParams?.length > 0) {
@@ -2133,7 +2207,7 @@ export class CodeGenerator {
         let afterCount = afterParams.length;
         let extr = [];
         afterParams.forEach((p, i) => {
-          let pn = typeof p === 'string' ? p : (Array.isArray(p) && p[0] === 'default') ? p[1] : JSON.stringify(p);
+          let pn = typeof p === 'string' ? p : (this.is(p, 'default')) ? p[1] : JSON.stringify(p);
           extr.push(`const ${pn} = ${restName}[${restName}.length - ${afterCount - i}]`);
         });
         if (afterCount > 0) extr.push(`${restName} = ${restName}.slice(0, -${afterCount})`);
@@ -2161,7 +2235,7 @@ export class CodeGenerator {
 
           if (!isConstructor && !sideEffectOnly && isLast && (h === 'if' || h === 'unless')) {
             let [cond, thenB, ...elseB] = stmt.slice(1);
-            let hasMulti = (b) => Array.isArray(b) && b[0] === 'block' && b.length > 2;
+            let hasMulti = (b) => this.is(b, 'block') && b.length > 2;
             if (hasMulti(thenB) || elseB.some(hasMulti)) {
               code += this.generateIfElseWithEarlyReturns(stmt);
               return;
@@ -2252,7 +2326,7 @@ export class CodeGenerator {
     if (body[0] === 'block' || Array.isArray(body[0])) {
       let stmts = body[0] === 'block' ? body.slice(1) : body;
       let lines = this.withIndent(() => stmts.map(s => {
-        if (Array.isArray(s) && s[0] === 'comprehension') {
+        if (this.is(s, 'comprehension')) {
           let [, expr, iters, guards] = s;
           return this.indent() + this.generateComprehensionAsLoop(expr, iters, guards);
         }
@@ -2289,7 +2363,7 @@ export class CodeGenerator {
   generateComprehensionWithTarget(expr, iterators, guards, targetVar) {
     let code = '';
     code += this.indent() + `${targetVar} = [];\n`;
-    let unwrappedExpr = (Array.isArray(expr) && expr[0] === 'block' && expr.length === 2) ? expr[1] : expr;
+    let unwrappedExpr = (this.is(expr, 'block') && expr.length === 2) ? expr[1] : expr;
 
     if (iterators.length === 1) {
       let [iterType, vars, iterable, stepOrOwn] = iterators[0];
@@ -2298,7 +2372,7 @@ export class CodeGenerator {
         let va = Array.isArray(vars) ? vars : [vars];
         let noVar = va.length === 0;
         let [itemVar, indexVar] = noVar ? ['_i', null] : va;
-        let ivp = (Array.isArray(itemVar) && (itemVar[0] === 'array' || itemVar[0] === 'object'))
+        let ivp = ((this.is(itemVar, 'array') || this.is(itemVar, 'object')))
           ? this.generateDestructuringPattern(itemVar) : itemVar;
 
         if (step && step !== null) {
@@ -2311,7 +2385,7 @@ export class CodeGenerator {
             code += this.indent() + `for (let ${ivp} = ${this.generate(s, 'value')}; ${ivp} ${isExcl ? '<' : '<='} ${this.generate(e, 'value')}; ${ivp} += ${this.generate(step, 'value')}) {\n`;
           } else {
             let ic = this.generate(iterable, 'value'), idxN = indexVar || '_i', stc = this.generate(step, 'value');
-            let isNeg = this.isNegativeStep(step);
+            let isNeg = this.is(step, '-', 1);
             code += isNeg
               ? this.indent() + `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${idxN} += ${stc}) {\n`
               : this.indent() + `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${idxN} += ${stc}) {\n`;
@@ -2346,7 +2420,7 @@ export class CodeGenerator {
         let va = Array.isArray(vars) ? vars : [vars];
         let noVar = va.length === 0;
         let [itemVar, indexVar] = noVar ? ['_i', null] : va;
-        let ivp = (Array.isArray(itemVar) && (itemVar[0] === 'array' || itemVar[0] === 'object'))
+        let ivp = ((this.is(itemVar, 'array') || this.is(itemVar, 'object')))
           ? this.generateDestructuringPattern(itemVar) : itemVar;
 
         if (step && step !== null) {
@@ -2359,7 +2433,7 @@ export class CodeGenerator {
             code += `for (let ${ivp} = ${this.generate(s, 'value')}; ${ivp} ${isExcl ? '<' : '<='} ${this.generate(e, 'value')}; ${ivp} += ${this.generate(step, 'value')}) `;
           } else {
             let ic = this.generate(iterable, 'value'), idxN = indexVar || '_i', stc = this.generate(step, 'value');
-            let isNeg = this.isNegativeStep(step);
+            let isNeg = this.is(step, '-', 1);
             let isMinus1 = isNeg && (step[1] === '1' || step[1] === 1 || str(step[1]) === '1');
             let isPlus1 = !isNeg && (step === '1' || step === 1 || str(step) === '1');
             if (isMinus1) code += `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${idxN}--) `;
@@ -2427,7 +2501,7 @@ export class CodeGenerator {
       if (iterType === 'for-as') {
         let va = Array.isArray(vars) ? vars : [vars];
         let [fv] = va;
-        let ivp = (Array.isArray(fv) && (fv[0] === 'array' || fv[0] === 'object'))
+        let ivp = ((this.is(fv, 'array') || this.is(fv, 'object')))
           ? this.generateDestructuringPattern(fv) : fv;
         code += `for (const ${ivp} of ${this.generate(iterable, 'value')}) `;
         if (guards?.length) {
@@ -2509,7 +2583,7 @@ export class CodeGenerator {
     code += this.indent() + '}';
     for (let branch of elseBranches) {
       code += ' else ';
-      if (Array.isArray(branch) && branch[0] === 'if') {
+      if (this.is(branch, 'if')) {
         let [, nc, nt, ...ne] = branch;
         code += `if (${this.generate(nc, 'value')}) {\n`;
         code += this.withIndent(() => this.generateBranchWithReturn(nt));
@@ -2538,8 +2612,8 @@ export class CodeGenerator {
   }
 
   generateIfAsExpression(condition, thenBranch, elseBranches) {
-    let needsIIFE = this.isMultiStatementBlock(thenBranch) || this.hasStatementInBranch(thenBranch) ||
-                   elseBranches.some(b => this.isMultiStatementBlock(b) || this.hasStatementInBranch(b) || this.hasNestedMultiStatement(b));
+    let needsIIFE = this.is(thenBranch, 'block') && thenBranch.length > 2 || this.hasStatementInBranch(thenBranch) ||
+                   elseBranches.some(b => this.is(b, 'block') && b.length > 2 || this.hasStatementInBranch(b) || this.hasNestedMultiStatement(b));
     if (needsIIFE) {
       let hasAwait = this.containsAwait(condition) || this.containsAwait(thenBranch) || elseBranches.some(b => this.containsAwait(b));
       let code = `${hasAwait ? 'await ' : ''}(${hasAwait ? 'async ' : ''}() => { `;
@@ -2547,13 +2621,13 @@ export class CodeGenerator {
       code += this.generateBlockWithReturns(thenBranch);
       for (let branch of elseBranches) {
         code += ' else ';
-        if (Array.isArray(branch) && branch[0] === 'if') {
+        if (this.is(branch, 'if')) {
           let [_, nc, nt, ...ne] = branch;
           code += `if (${this.generate(nc, 'value')}) `;
           code += this.generateBlockWithReturns(nt);
           for (let nb of ne) {
             code += ' else ';
-            if (Array.isArray(nb) && nb[0] === 'if') {
+            if (this.is(nb, 'if')) {
               let [__, nnc, nnt, ...nne] = nb;
               code += `if (${this.generate(nnc, 'value')}) `;
               code += this.generateBlockWithReturns(nnt);
@@ -2571,7 +2645,7 @@ export class CodeGenerator {
     let thenExpr = this.extractExpression(this.unwrapIfBranch(thenBranch));
     let elseExpr = this.buildTernaryChain(elseBranches);
     let condCode = this.generate(condition, 'value');
-    if (Array.isArray(condition) && (condition[0] === 'yield' || condition[0] === 'await')) condCode = `(${condCode})`;
+    if ((this.is(condition, 'yield') || this.is(condition, 'await'))) condCode = `(${condCode})`;
     return `(${condCode} ? ${thenExpr} : ${elseExpr})`;
   }
 
@@ -2588,7 +2662,7 @@ export class CodeGenerator {
     if (hasFlow) {
       for (let s of this.unwrapBlock(body)) code += this.indent() + this.generate(s, 'statement') + ';\n';
     } else if (context === 'value') {
-      if (Array.isArray(body) && body[0] === 'block' && body.length > 2) {
+      if (this.is(body, 'block') && body.length > 2) {
         let stmts = body.slice(1);
         for (let i = 0; i < stmts.length; i++) {
           if (i === stmts.length - 1) code += this.indent() + `return ${this.generate(stmts[i], 'value')};\n`;
@@ -2598,7 +2672,7 @@ export class CodeGenerator {
         code += this.indent() + `return ${this.extractExpression(body)};\n`;
       }
     } else {
-      if (Array.isArray(body) && body[0] === 'block' && body.length > 1) {
+      if (this.is(body, 'block') && body.length > 1) {
         for (let s of body.slice(1)) code += this.indent() + this.generate(s, 'statement') + ';\n';
       } else {
         code += this.indent() + this.generate(body, 'statement') + ';\n';
@@ -2702,14 +2776,17 @@ export class CodeGenerator {
     return result;
   }
 
-  isNegativeStep(step) {
-    if (!Array.isArray(step) || step.length !== 2) return false;
-    return (str(step[0]) ?? step[0]) === '-';
-  }
-
-  isNegativeOneLiteral(sexpr) {
-    return Array.isArray(sexpr) && sexpr[0] === '-' && sexpr.length === 2 &&
-           (sexpr[1] === '1' || sexpr[1] === 1 || str(sexpr[1]) === '1');
+  // S-expression pattern match: is(node, op, arity?) → args or null
+  // is(node, '-', 1) on ["-", 5]         → [5]
+  // is(node, '[]', 2) on ["[]", a, b]    → [a, b]
+  // is(node, 'block') on ["block", ...]   → [...]
+  // is("x", '-', 1)                       → null
+  is(node, op, arity) {
+    if (!Array.isArray(node)) return null;
+    if ((str(node[0]) ?? node[0]) !== op) return null;
+    let args = node.slice(1);
+    if (arity != null && args.length !== arity) return null;
+    return args;
   }
 
   unwrap(code) {
@@ -2772,13 +2849,11 @@ export class CodeGenerator {
     return false;
   }
 
-  isMultiStatementBlock(branch) { return Array.isArray(branch) && branch[0] === 'block' && branch.length > 2; }
-
   hasNestedMultiStatement(branch) {
     if (!Array.isArray(branch)) return false;
     if (branch[0] === 'if') {
       let [_, cond, then_, ...elseB] = branch;
-      return this.isMultiStatementBlock(then_) || elseB.some(b => this.hasNestedMultiStatement(b));
+      return this.is(then_, 'block') && then_.length > 2 || elseB.some(b => this.hasNestedMultiStatement(b));
     }
     return false;
   }
@@ -2787,7 +2862,7 @@ export class CodeGenerator {
     if (branches.length === 0) return 'undefined';
     if (branches.length === 1) return this.extractExpression(this.unwrapIfBranch(branches[0]));
     let first = branches[0];
-    if (Array.isArray(first) && first[0] === 'if') {
+    if (this.is(first, 'if')) {
       let [_, cond, then_, ...rest] = first;
       let thenPart = this.extractExpression(this.unwrapIfBranch(then_));
       let elsePart = this.buildTernaryChain([...rest, ...branches.slice(1)]);
@@ -2886,13 +2961,22 @@ export class CodeGenerator {
     return `'${finalPath}'` + assertion;
   }
 
+  containsIt(sexpr) {
+    if (!sexpr) return false;
+    if (sexpr === 'it' || (sexpr instanceof String && str(sexpr) === 'it')) return true;
+    if (typeof sexpr !== 'object') return false;
+    if (this.is(sexpr, 'def') || this.is(sexpr, '->') || this.is(sexpr, '=>')) return false;
+    if (Array.isArray(sexpr)) return sexpr.some(item => this.containsIt(item));
+    return false;
+  }
+
   containsAwait(sexpr) {
     if (!sexpr) return false;
     if (sexpr instanceof String && meta(sexpr, 'await') === true) return true;
     if (typeof sexpr !== 'object') return false;
-    if (Array.isArray(sexpr) && sexpr[0] === 'await') return true;
-    if (Array.isArray(sexpr) && sexpr[0] === 'for-as' && sexpr[3] === true) return true;
-    if (Array.isArray(sexpr) && (sexpr[0] === 'def' || sexpr[0] === '->' || sexpr[0] === '=>' || sexpr[0] === 'class')) return false;
+    if (this.is(sexpr, 'await')) return true;
+    if (this.is(sexpr, 'for-as') && sexpr[3] === true) return true;
+    if ((this.is(sexpr, 'def') || this.is(sexpr, '->') || this.is(sexpr, '=>') || this.is(sexpr, 'class'))) return false;
     if (Array.isArray(sexpr)) return sexpr.some(item => this.containsAwait(item));
     return false;
   }
@@ -2900,21 +2984,18 @@ export class CodeGenerator {
   containsYield(sexpr) {
     if (!sexpr) return false;
     if (typeof sexpr !== 'object') return false;
-    if (Array.isArray(sexpr) && (sexpr[0] === 'yield' || sexpr[0] === 'yield-from')) return true;
-    if (Array.isArray(sexpr) && (sexpr[0] === 'def' || sexpr[0] === '->' || sexpr[0] === '=>' || sexpr[0] === 'class')) return false;
+    if ((this.is(sexpr, 'yield') || this.is(sexpr, 'yield-from'))) return true;
+    if ((this.is(sexpr, 'def') || this.is(sexpr, '->') || this.is(sexpr, '=>') || this.is(sexpr, 'class'))) return false;
     if (Array.isArray(sexpr)) return sexpr.some(item => this.containsYield(item));
     return false;
   }
 
   // Class helpers
-  isStaticMember(mk) { return Array.isArray(mk) && mk[0] === '.' && mk[1] === 'this'; }
-  isComputedMember(mk) { return Array.isArray(mk) && mk[0] === 'computed'; }
   extractMemberName(mk) {
-    if (this.isStaticMember(mk)) return mk[2];
-    if (this.isComputedMember(mk)) return `[${this.generate(mk[1], 'value')}]`;
+    if (this.is(mk, '.') && mk[1] === 'this') return mk[2];
+    if (this.is(mk, 'computed')) return `[${this.generate(mk[1], 'value')}]`;
     return mk;
   }
-  isBoundMethod(mv) { return Array.isArray(mv) && mv[0] === '=>'; }
 
   // ---------------------------------------------------------------------------
   // Reactive Runtime (injected inline when reactive operators are used)
@@ -3166,13 +3247,14 @@ export class Compiler {
       console.log();
     }
 
-    // Step 2: Emit .d.ts from annotated tokens (before parsing)
+    // Save annotated tokens for deferred .d.ts emission (after parsing)
     let dts = null;
+    let typeTokens = null;
     if (this.options.types === 'emit' || this.options.types === 'check' || this.options.types === true) {
-      dts = emitTypes(tokens);
+      typeTokens = [...tokens];
     }
 
-    // Always remove TYPE_DECL markers — the parser doesn't know about them
+    // Remove TYPE_DECL markers — the parser doesn't know about them
     tokens = tokens.filter(t => t[0] !== 'TYPE_DECL');
 
     // Strip leading terminators that may result from removed type declarations
@@ -3180,8 +3262,9 @@ export class Compiler {
       tokens.shift();
     }
 
-    // If only terminators remain (type-only source), return early
+    // If only terminators remain (type-only source), emit types and return early
     if (tokens.every(t => t[0] === 'TERMINATOR')) {
+      if (typeTokens) dts = emitTypes(typeTokens, ['program']);
       return { tokens, sexpr: ['program'], code: '', dts, data: dataSection, reactiveVars: {} };
     }
 
@@ -3229,8 +3312,7 @@ export class Compiler {
 
     let generator = new CodeGenerator({
       dataSection,
-      skipReactiveRuntime: this.options.skipReactiveRuntime,
-      skipComponentRuntime: this.options.skipComponentRuntime,
+      skipPreamble: this.options.skipPreamble,
       reactiveVars: this.options.reactiveVars,
       sourceMap,
     });
@@ -3245,6 +3327,11 @@ export class Compiler {
       code += `\n//# sourceMappingURL=${this.options.filename}.js.map`;
     }
 
+    // Step 5: Emit .d.ts from annotated tokens + parsed s-expression
+    if (typeTokens) {
+      dts = emitTypes(typeTokens, sexpr);
+    }
+
     return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars };
   }