naider 1.17.2 → 1.18.0

package/src/generator-kotlin.js

@@ -139,6 +139,8 @@ export class KotlinGenerator {
       case 'BlockchainDecl': return this.visitBlockchain(node);
       case 'EnumDecl': return this.visitEnum(node);
       case 'Swap': return this.visitSwap(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1840,6 +1842,60 @@ export class KotlinGenerator {
     this.emit(`${a} = ${b}.also { ${b} = ${a} }`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    const keyword = node.isMut ? 'var' : 'val';
+    if (node.pattern === 'array') {
+      const names = node.names.filter(n => !n.rest).map(n => n.alias || n.name);
+      this.emit(`${keyword} (${names.join(', ')}) = ${val}`);
+    } else {
+      for (const n of node.names) {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`${keyword} ${varName} = ${val}["${n.name}"] ?: ${this.expr(n.defaultValue)}`);
+          } else {
+            this.emit(`${keyword} ${varName} = ${val}["${n.name}"]`);
+          }
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` : ${node.parent}()` : '';
+    const initParams = node.init ? node.init.params.map(p => `${p.name}: Any`).join(', ') : '';
+    this.emit(`open class ${node.name}(${initParams})${ext} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`var ${field.name} = ${this.expr(field.defaultValue)}`);
+      }
+    }
+    if (node.init) {
+      this.emit(`init {`);
+      this.indent++;
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit(`}`);
+    }
+    for (const method of node.methods) {
+      const params = method.params.map(p => `${p.name}: Any`).join(', ');
+      this.emit(`fun ${method.name}(${params}): Any? {`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('return null');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit('}');
+    }
+    this.indent--;
+    this.emit('}');
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `${args[0]}.size`;
@@ -1880,6 +1936,13 @@ export class KotlinGenerator {
       case 'read': return `java.io.File(${args[0]}).readText()`;
       case 'write': return `java.io.File(${args[0]}).writeText(${args[1]})`;
       case 'ask': return `(print(${args[0] || '""'}); readLine() ?: "")`;
+      case 'map': return `${args[0]}.map { ${args[1]}(it) }`;
+      case 'filter': return `${args[0]}.filter { ${args[1]}(it) }`;
+      case 'reduce': return args.length >= 3 ? `${args[0]}.fold(${args[2]}) { acc, it -> ${args[1]}(acc, it) }` : `${args[0]}.reduce { acc, it -> ${args[1]}(acc, it) }`;
+      case 'find': return `${args[0]}.find { ${args[1]}(it) }`;
+      case 'every': return `${args[0]}.all { ${args[1]}(it) }`;
+      case 'some': return `${args[0]}.any { ${args[1]}(it) }`;
+      case 'foreach': return `${args[0]}.forEach { ${args[1]}(it) }`;
       default: return null;
     }
   }

package/src/generator-php.js

@@ -105,6 +105,8 @@ export class PhpGenerator {
       case 'BlockchainDecl': return this.visitBlockchain(node);
       case 'EnumDecl': return this.visitEnum(node);
       case 'Swap': return this.visitSwap(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1599,6 +1601,58 @@ export class PhpGenerator {
     this.emit(`[$${a.replace('$','')}, $${b.replace('$','')}] = [$${b.replace('$','')}, $${a.replace('$','')}];`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    if (node.pattern === 'array') {
+      const names = node.names.map(n => {
+        if (n.rest) return `...$${n.name}`;
+        return `$${n.alias || n.name}`;
+      });
+      this.emit(`[${names.join(', ')}] = ${val};`);
+    } else {
+      const parts = node.names.filter(n => !n.rest).map(n => {
+        const varName = n.alias || n.name;
+        return `'${n.name}' => $${varName}`;
+      });
+      this.emit(`[${parts.join(', ')}] = ${val};`);
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` extends ${node.parent}` : '';
+    this.emit(`class ${node.name}${ext} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`public $${field.name} = ${this.expr(field.defaultValue)};`);
+      }
+    }
+    if (node.init) {
+      const params = node.init.params.map(p => `$${p.name}`).join(', ');
+      this.emit(`public function __construct(${params}) {`);
+      this.indent++;
+      if (node.parent) this.emit('parent::__construct();');
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('}');
+    }
+    for (const method of node.methods) {
+      const params = method.params.map(p => `$${p.name}`).join(', ');
+      this.emit(`public function ${method.name}(${params}) {`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('// empty');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit('}');
+    }
+    this.indent--;
+    this.emit('}');
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `count(${args[0]})`;
@@ -1639,6 +1693,13 @@ export class PhpGenerator {
       case 'ask': return `readline(${args[0] || '""'})`;
       case 'chunk': return `array_chunk(${args[0]}, ${args[1]})`;
       case 'zip': return `array_map(null, ${args[0]}, ${args[1]})`;
+      case 'map': return `array_map(${args[1]}, ${args[0]})`;
+      case 'filter': return `array_values(array_filter(${args[0]}, ${args[1]}))`;
+      case 'reduce': return `array_reduce(${args[0]}, ${args[1]}, ${args[2] || 'null'})`;
+      case 'find': return `current(array_filter(${args[0]}, ${args[1]}))`;
+      case 'every': return `count(array_filter(${args[0]}, ${args[1]})) === count(${args[0]})`;
+      case 'some': return `count(array_filter(${args[0]}, ${args[1]})) > 0`;
+      case 'foreach': return `array_walk(${args[0]}, ${args[1]})`;
       default: return null;
     }
   }

package/src/generator-python.js

@@ -164,6 +164,8 @@ export class PythonGenerator {
       case 'BlockchainDecl': return this.visitBlockchain(node);
       case 'EnumDecl': return this.visitEnum(node);
       case 'Swap': return this.visitSwap(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       default:
         this.emit(`# unknown: ${node.type}`);
     }
@@ -2494,6 +2496,83 @@ export class PythonGenerator {
     this.emit(`${a}, ${b} = ${b}, ${a}`);
   }
 
+  // ===== Destructure =====
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    if (node.pattern === 'array') {
+      const names = node.names.map(n => {
+        if (n.rest) return `*${n.name}`;
+        return n.name;
+      });
+      this.emit(`${names.join(', ')} = ${val}`);
+      // Handle defaults for array destructuring
+      for (const n of node.names) {
+        if (n.defaultValue && !n.rest) {
+          this.emit(`${n.name} = ${n.name} if ${n.name} is not None else ${this.expr(n.defaultValue)}`);
+        }
+      }
+    } else {
+      // object destructuring — per-field assignment
+      for (const n of node.names) {
+        if (n.rest) {
+          this.emit(`${n.name} = {k: v for k, v in ${val}.items() if k not in {${node.names.filter(x => !x.rest).map(x => JSON.stringify(x.name)).join(', ')}}}`);
+        } else {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`${varName} = ${val}.get(${JSON.stringify(n.name)}, ${this.expr(n.defaultValue)})`);
+          } else {
+            this.emit(`${varName} = ${val}[${JSON.stringify(n.name)}]`);
+          }
+        }
+      }
+    }
+  }
+
+  // ===== ClassDecl =====
+  visitClassDecl(node) {
+    const ext = node.parent ? `(${node.parent})` : '';
+    this.emit(`class ${node.name}${ext}:`);
+    this.indent++;
+    if (node.init) {
+      const params = node.init.params.map(p => p.name).join(', ');
+      const selfParams = params ? `self, ${params}` : 'self';
+      this.emit(`def __init__(${selfParams}):`);
+      this.indent++;
+      if (node.parent) this.emit('super().__init__()');
+      if (node.init.body.length === 0 && !node.parent) {
+        this.emit('pass');
+      } else {
+        for (const stmt of node.init.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emitRaw('');
+    }
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`${field.name} = ${this.expr(field.defaultValue)}`);
+      }
+    }
+    for (const method of node.methods) {
+      const async = method.isAsync ? 'async ' : '';
+      const params = method.params.map(p => p.name).join(', ');
+      const selfParams = params ? `self, ${params}` : 'self';
+      this.emit(`${async}def ${method.name}(${selfParams}):`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('pass');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emitRaw('');
+    }
+    if (!node.init && node.fields.length === 0 && node.methods.length === 0) {
+      this.emit('pass');
+    }
+    this.indent--;
+    this.emitRaw('');
+  }
+
   // ===== Builtins =====
   generateBuiltin(name, args) {
     switch (name) {
@@ -2536,6 +2615,13 @@ export class PythonGenerator {
       case 'now': { this.addImport('time'); return `int(time.time() * 1000)`; }
       case 'time': { this.addFromImport('datetime', 'datetime'); return `datetime.now().isoformat()`; }
       case 'chunk': return `[${args[0]}[i:i+${args[1]}] for i in range(0, len(${args[0]}), ${args[1]})]`;
+      case 'map': return `list(map(${args[1]}, ${args[0]}))`;
+      case 'filter': return `list(filter(${args[1]}, ${args[0]}))`;
+      case 'reduce': { this.addFromImport('functools', 'reduce'); return args[2] ? `reduce(${args[1]}, ${args[0]}, ${args[2]})` : `reduce(${args[1]}, ${args[0]})`; }
+      case 'find': return `next((x for x in ${args[0]} if ${args[1]}(x)), None)`;
+      case 'every': return `all(${args[1]}(x) for x in ${args[0]})`;
+      case 'some': return `any(${args[1]}(x) for x in ${args[0]})`;
+      case 'foreach': return `[${args[1]}(x) for x in ${args[0]}]`;
       default: return null;
     }
   }

package/src/generator-ruby.js

@@ -113,6 +113,8 @@ export class RubyGenerator {
       case 'BlockchainDecl': return this.visitBlockchain(node);
       case 'EnumDecl': return this.visitEnum(node);
       case 'Swap': return this.visitSwap(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       default:
         this.emit(`# unknown: ${node.type}`);
     }
@@ -1553,6 +1555,51 @@ export class RubyGenerator {
     this.emit(`${a}, ${b} = ${b}, ${a}`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    if (node.pattern === 'array') {
+      const names = node.names.map(n => {
+        if (n.rest) return `*${n.name}`;
+        return n.alias || n.name;
+      });
+      this.emit(`${names.join(', ')} = ${val}`);
+    } else {
+      const keys = node.names.filter(n => !n.rest).map(n => `:${n.name}`);
+      const vars = node.names.filter(n => !n.rest).map(n => n.alias || n.name);
+      this.emit(`${vars.join(', ')} = ${val}.values_at(${keys.join(', ')})`);
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` < ${node.parent}` : '';
+    this.emit(`class ${node.name}${ext}`);
+    this.indent++;
+    if (node.init) {
+      const params = node.init.params.map(p => p.name).join(', ');
+      this.emit(`def initialize(${params})`);
+      this.indent++;
+      if (node.parent) this.emit('super()');
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('end');
+    }
+    for (const method of node.methods) {
+      const params = method.params.map(p => p.name).join(', ');
+      this.emit(`def ${method.name}(${params})`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('nil');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit('end');
+    }
+    this.indent--;
+    this.emit('end');
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `${args[0]}.length`;
@@ -1593,6 +1640,13 @@ export class RubyGenerator {
       case 'read': return `File.read(${args[0]})`;
       case 'write': return `File.write(${args[0]}, ${args[1]})`;
       case 'ask': return `(print(${args[0] || '""'}); gets.chomp)`;
+      case 'map': return `${args[0]}.map { |_x| ${args[1]}.call(_x) }`;
+      case 'filter': return `${args[0]}.select { |_x| ${args[1]}.call(_x) }`;
+      case 'reduce': return args.length >= 3 ? `${args[0]}.reduce(${args[2]}) { |_acc, _x| ${args[1]}.call(_acc, _x) }` : `${args[0]}.reduce { |_acc, _x| ${args[1]}.call(_acc, _x) }`;
+      case 'find': return `${args[0]}.find { |_x| ${args[1]}.call(_x) }`;
+      case 'every': return `${args[0]}.all? { |_x| ${args[1]}.call(_x) }`;
+      case 'some': return `${args[0]}.any? { |_x| ${args[1]}.call(_x) }`;
+      case 'foreach': return `${args[0]}.each { |_x| ${args[1]}.call(_x) }`;
       default: return null;
     }
   }

package/src/generator-rust.js

@@ -209,6 +209,8 @@ export class RustGenerator {
       case 'BlockchainDecl': return this.visitBlockchain(node);
       case 'EnumDecl': return this.visitEnum(node);
       case 'Swap': return this.visitSwap(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1911,6 +1913,71 @@ export class RustGenerator {
     this.emit(`std::mem::swap(&mut ${a}, &mut ${b});`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    const keyword = node.isMut ? 'let mut' : 'let';
+    if (node.pattern === 'array') {
+      const names = node.names.filter(n => !n.rest).map(n => n.alias || n.name);
+      const indexedVals = names.map((name, i) => `${val}[${i}]`);
+      this.emit(`${keyword} (${names.join(', ')}) = (${indexedVals.join(', ')});`);
+    } else {
+      for (const n of node.names) {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`${keyword} ${varName} = ${val}.get("${n.name}").unwrap_or(&${this.expr(n.defaultValue)});`);
+          } else {
+            this.emit(`${keyword} ${varName} = ${val}["${n.name}"];`);
+          }
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    // Rust uses struct + impl
+    this.emit(`struct ${node.name} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      this.emit(`${field.name}: Box<dyn std::any::Any>,`);
+    }
+    if (node.fields.length === 0) this.emit(`_marker: (),`);
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+    this.emit(`impl ${node.name} {`);
+    this.indent++;
+    if (node.init) {
+      const params = node.init.params.map(p => `${p.name}: impl std::any::Any`).join(', ');
+      this.emit(`fn new(${params}) -> Self {`);
+      this.indent++;
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      if (node.fields.length > 0) {
+        this.emit(`${node.name} { ${node.fields.map(f => f.name).join(', ')} }`);
+      } else {
+        this.emit(`${node.name} { _marker: () }`);
+      }
+      this.indent--;
+      this.emit(`}`);
+    }
+    for (const method of node.methods) {
+      const mutable = method.body.some(s => JSON.stringify(s).includes('"Assignment"')) ? '&mut self' : '&self';
+      const params = method.params.length > 0 ? `, ${method.params.map(p => `${p.name}: impl std::any::Any`).join(', ')}` : '';
+      this.emit(`fn ${method.name}(${mutable}${params}) {`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('// empty');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit(`}`);
+    }
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `${args[0]}.len()`;
@@ -1942,6 +2009,13 @@ export class RustGenerator {
       case 'values': return `${args[0]}.values().cloned().collect::<Vec<_>>()`;
       case 'range': return args.length >= 2 ? `(${args[0]}..${args[1]}).collect::<Vec<_>>()` : `(0..${args[0]}).collect::<Vec<_>>()`;
       case 'flat': return `${args[0]}.into_iter().flatten().collect::<Vec<_>>()`;
+      case 'map': return `${args[0]}.iter().map(${args[1]}).collect::<Vec<_>>()`;
+      case 'filter': return `${args[0]}.iter().filter(${args[1]}).collect::<Vec<_>>()`;
+      case 'reduce': return `${args[0]}.iter().fold(${args[2] || '0'}, ${args[1]})`;
+      case 'find': return `${args[0]}.iter().find(${args[1]})`;
+      case 'every': return `${args[0]}.iter().all(${args[1]})`;
+      case 'some': return `${args[0]}.iter().any(${args[1]})`;
+      case 'foreach': return `${args[0]}.iter().for_each(${args[1]})`;
       default: return null;
     }
   }

package/src/generator-swift.js

@@ -141,6 +141,8 @@ export class SwiftGenerator {
       case 'BlockchainDecl': return this.visitBlockchain(node);
       case 'EnumDecl': return this.visitEnum(node);
       case 'Swap': return this.visitSwap(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1758,6 +1760,64 @@ export class SwiftGenerator {
     this.emit(`swap(&${a}, &${b})`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    const keyword = node.isMut ? 'var' : 'let';
+    if (node.pattern === 'array') {
+      const names = node.names.filter(n => !n.rest).map(n => n.alias || n.name);
+      const indexedVals = names.map((name, i) => `${val}[${i}]`);
+      this.emit(`${keyword} (${names.join(', ')}) = (${indexedVals.join(', ')})`);
+    } else {
+      for (const n of node.names) {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`${keyword} ${varName} = ${val}["${n.name}"] ?? ${this.expr(n.defaultValue)}`);
+          } else {
+            this.emit(`${keyword} ${varName} = ${val}["${n.name}"]`);
+          }
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? `: ${node.parent}` : '';
+    this.emit(`class ${node.name}${ext ? ' ' + ext : ''} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`var ${field.name}: Any = ${this.expr(field.defaultValue)}`);
+      } else {
+        this.emit(`var ${field.name}: Any?`);
+      }
+    }
+    if (node.init) {
+      const params = node.init.params.map(p => `_ ${p.name}: Any`).join(', ');
+      this.emit(`init(${params}) {`);
+      this.indent++;
+      if (node.parent) this.emit('super.init()');
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('}');
+    }
+    for (const method of node.methods) {
+      const params = method.params.map(p => `_ ${p.name}: Any`).join(', ');
+      this.emit(`func ${method.name}(${params}) -> Any? {`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('return nil');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit('}');
+    }
+    this.indent--;
+    this.emit('}');
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `${args[0]}.count`;
@@ -1796,6 +1856,13 @@ export class SwiftGenerator {
       case 'random': return args.length >= 2 ? `Int.random(in: ${args[0]}...${args[1]})` : `Double.random(in: 0...1)`;
       case 'read': return `try! String(contentsOfFile: ${args[0]})`;
       case 'write': return `try! ${args[1]}.write(toFile: ${args[0]}, atomically: true, encoding: .utf8)`;
+      case 'map': return `${args[0]}.map { ${args[1]}($0) }`;
+      case 'filter': return `${args[0]}.filter { ${args[1]}($0) }`;
+      case 'reduce': return `${args[0]}.reduce(${args[2] || '0'}) { ${args[1]}($0, $1) }`;
+      case 'find': return `${args[0]}.first { ${args[1]}($0) }`;
+      case 'every': return `${args[0]}.allSatisfy { ${args[1]}($0) }`;
+      case 'some': return `${args[0]}.contains { ${args[1]}($0) }`;
+      case 'foreach': return `${args[0]}.forEach { ${args[1]}($0) }`;
       default: return null;
     }
   }

package/src/generator.js

@@ -94,6 +94,8 @@ export class Generator {
       case 'ReturnStatus': return this.visitReturnStatus(node);
       case 'ReturnMethod': return this.visitReturnMethod(node);
       case 'TypedVar': return this.visitTypedVar(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       case 'If': return this.visitIf(node);
       case 'Each': return this.visitEach(node);
       case 'For': return this.visitFor(node);
@@ -244,6 +246,51 @@ export class Generator {
     this.emit(`${exp}${keyword} ${node.name} = ${this.expr(node.value)};`);
   }
 
+  visitDestructure(node) {
+    const keyword = node.isMut ? 'let' : 'const';
+    const parts = node.names.map(n => {
+      if (n.rest) return `...${n.name}`;
+      let s = n.name;
+      if (n.alias) s += `: ${n.alias}`;
+      if (n.defaultValue) s += ` = ${this.expr(n.defaultValue)}`;
+      return s;
+    });
+    const open = node.pattern === 'object' ? '{ ' : '[ ';
+    const close = node.pattern === 'object' ? ' }' : ' ]';
+    this.emit(`${keyword} ${open}${parts.join(', ')}${close} = ${this.expr(node.value)};`);
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` extends ${node.parent}` : '';
+    this.emit(`class ${node.name}${ext} {`);
+    this.indent++;
+    if (node.init) {
+      const params = node.init.params.map(p => p.name).join(', ');
+      this.emit(`constructor(${params}) {`);
+      this.indent++;
+      if (node.parent) this.emit('super();');
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('}');
+    }
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`${field.name} = ${this.expr(field.defaultValue)};`);
+      }
+    }
+    for (const method of node.methods) {
+      const async = method.isAsync ? 'async ' : '';
+      const params = method.params.map(p => p.name).join(', ');
+      this.emit(`${async}${method.name}(${params}) {`);
+      this.indent++;
+      for (const stmt of method.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('}');
+    }
+    this.indent--;
+    this.emit('}');
+  }
+
   visitAssignment(node) {
     const target = this.expr(node.target);
     const value = this.expr(node.value);
@@ -2464,6 +2511,13 @@ export class Generator {
       case 'now': return `Date.now()`;
       case 'time': return `new Date().toISOString()`;
       case 'chunk': return `Array.from({length: Math.ceil(${args[0]}.length / ${args[1]})}, (_, i) => ${args[0]}.slice(i * ${args[1]}, (i + 1) * ${args[1]}))`;
+      case 'map': return `${args[0]}.map(${args[1]})`;
+      case 'filter': return `${args[0]}.filter(${args[1]})`;
+      case 'reduce': return args[2] ? `${args[0]}.reduce(${args[1]}, ${args[2]})` : `${args[0]}.reduce(${args[1]})`;
+      case 'find': return `${args[0]}.find(${args[1]})`;
+      case 'every': return `${args[0]}.every(${args[1]})`;
+      case 'some': return `${args[0]}.some(${args[1]})`;
+      case 'foreach': return `${args[0]}.forEach(${args[1]})`;
       default: return null;
     }
   }