rip-lang 1.3.2 → 1.3.8

package/CHANGELOG.md

@@ -5,6 +5,192 @@ All notable changes to Rip will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.8] - 2025-11-06
+
+### Changed
+- **Cleaner conditions** (#40) - Removed excessive double parentheses
+  - `if ((x > y))` → `if (x > y)` (single parens)
+  - Applied to all conditionals: if, unless, while, until, guards
+  - Used existing `unwrap()` helper for consistency
+  - Smart negation handling (keeps parens when needed for precedence)
+  - More readable, professional output
+- Test count: 901 → 907 (+6 tests)
+
+## [1.3.7] - 2025-11-06
+
+### Changed
+- **Cleaner arrow function syntax** (#38) - Remove parens around single parameters
+  - `(x) => x * 2` → `x => x * 2` (single simple param)
+  - Keeps parens for multiple params, destructuring, defaults, rest
+  - Matches ESLint/Prettier standards
+  - More idiomatic modern JavaScript
+- Test count: 893 → 901 (+8 tests)
+
+## [1.3.6] - 2025-11-06
+
+### Changed
+- **Simplified Object.hasOwn() generation** - Removed unnecessary _pregenerated pattern
+  - Direct inline generation instead of wrapper objects
+  - Cleaner code flow (~30 lines removed)
+  - No need for special handling since Object.hasOwn() is built-in ES2022
+
+## [1.3.5] - 2025-11-06
+
+### Changed
+- **Modernized to Object.hasOwn()** (#36) - Replaced hasOwnProperty with ES2022 standard
+  - All `obj.hasOwnProperty(key)` → `Object.hasOwn(obj, key)`
+  - Cannot be shadowed by instance properties
+  - Works with null-prototype objects
+  - More readable and safer
+  - Uses clean `continue` pattern like CoffeeScript
+- Test count: 891 → 893 (+2 tests)
+
+## [1.3.4] - 2025-11-06
+
+### Fixed
+- **Semicolons in all contexts** - Extended clean semicolon removal to nested blocks
+  - Function bodies now have clean blocks (no semicolons after `}`)
+  - Method bodies now have clean blocks
+  - Loop bodies and nested contexts all clean
+  - Added helper methods: `needsSemicolon()` and `addSemicolon()`
+  - Applied smart semicolon logic to all statement generation
+
+### Changed
+- Cleaner JavaScript output throughout entire codebase, not just top-level
+
+## [1.3.3] - 2025-11-06
+
+### Changed
+- **Cleaner JavaScript output** (#34) - Removed unnecessary semicolons after block statements
+  - Function and class declarations no longer have trailing semicolons
+  - Control flow blocks (if/for/while/switch/try) no longer have trailing semicolons
+  - Produces more idiomatic, professional-looking JavaScript
+  - Matches standard formatters (Prettier, ESLint)
+- Test count: 878 → 891 (+13 tests)
+
+## [1.3.2] - 2025-11-05
+
+### Changed
+- Minor code cleanup and refinements
+- Updated solar.rip indentation handling for better code generation
+
+## [1.3.1] - 2025-11-05
+
+### Added
+- **Otherwise operator (`!?`)** (#32) - Undefined-only coalescing
+  - Returns first value that is NOT `undefined`
+  - Unlike `??` (nullish), treats `null`, `false`, `0`, `""` as valid values
+  - Perfect for optional parameters with meaningful falsy values
+  - Syntax: `value1 !? value2 !? 'default'`
+  - Example: `timeout = config.timeout !? 5000` (null/0 are valid!)
+- Test count: 868 → 878 (+10 tests)
+
+## [1.3.0] - 2025-11-05
+
+### Added
+- **Script execution with proper argument passing** - `rip script.rip -h` now passes `-h` to script
+  - Arguments before script name → rip options
+  - Arguments after script name → script arguments
+  - Fixes issue where rip would consume script's flags
+- **Solar.rip synchronization** - Updated to match solar-parser 1.2.0
+  - New CLI options: `--version`, `--info`, `--sexpr`
+  - Removed `commonCode` architecture for simpler code generation
+  - Fixed file writing bug (was using `unless` incorrectly)
+
+### Changed
+- Improved CLI argument parsing for better script execution
+
+## [1.2.2] - 2025-11-04
+
+### Added
+- **Browser REPL UI improvements** - Cleaner, more intuitive interface
+  - Made "Live Compiler" the default tab
+  - Added Clear and Run buttons to Rip Source panel
+  - Converted checkboxes to toggle buttons (gray/blue states)
+  - Consistent header layout across both panes
+  - Helpful tooltips on all buttons
+
+### Fixed
+- **For-loop destructuring with defaults** (#30) - Full CoffeeScript compatibility
+  - `for [a, b = 99, c = 88] in arr` now works correctly
+  - Generates proper ES6 destructuring with defaults
+  - Previously generated invalid s-expressions in patterns
+
+### Changed
+- Test count: 867 → 868 (+1 test)
+
+## [1.2.1] - 2025-11-04
+
+### Fixed
+- **Slice syntax with nested indices** (#28) - Property access after nested brackets now works
+  - `line[_[0].length..]` now compiles correctly
+  - Fixed lexer rewriter to use bracket depth counting
+  - Previously failed with parse error
+  - Example: `arr[obj.data[0].length..]` → `arr.slice(obj.data[0].length)`
+- Test count: 865 → 867 (+2 tests)
+
+## [1.2.0] - 2025-11-04
+
+### Fixed
+- **Switch without discriminant context bug** (#26) - Statement context no longer adds returns
+  - Switch in loops now generates correct code (no invalid returns)
+  - Made `generateSwitchAsIfChain()` context-aware
+  - Value context: adds returns (switch as expression)
+  - Statement context: plain statements (side effects only)
+- **__DATA__ section generation** - Natural code emission without string surgery
+  - `var DATA;` now positioned logically before `_setDataSection()` call
+  - Removed ~50 lines of complex regex/string manipulation
+  - Clean, obvious code generation in `generateProgram()`
+- **S-expression pretty printer** - Restored missing features
+  - Fixed heregex handling (multi-line regex collapsing)
+  - Fixed program node formatting with proper indentation
+  - Faster with Set lookup for INLINE_FORMS
+  - Modern JS with optional chaining and nullish coalescing
+
+### Changed
+- Test count: 864 → 865 (+1 test)
+- Improved code generation architecture
+
+## [1.1.5] - 2025-11-03
+
+### Fixed
+- **npm package files** - Added `scripts/serve.js` for `rip -w` command
+  - Browser REPL now works for npm users
+  - Fixed missing dependency for web server functionality
+
+### Changed
+- S-expression printer improvements backported to docs/examples/sexpr.rip
+
+## [1.1.4] - 2025-11-03
+
+### Fixed
+- **S-expression printer** - Improved performance and correctness
+  - Faster Set-based INLINE_FORMS lookup
+  - Modern JavaScript features (optional chaining, nullish coalescing)
+  - Proper heregex and program node formatting
+  - All functionality restored and working
+
+## [1.1.3] - 2025-11-03
+
+### Fixed
+- **Package files** - Included `scripts/serve.js` in npm package
+  - Required for `rip -w` browser REPL command
+
+## [1.1.2] - 2025-11-02
+
+### Added
+- **npm publishing safeguards** (#24) - Professional package configuration
+  - `files` whitelist (only 51 essential files published)
+  - `prepublishOnly` script (runs tests + rebuilds browser bundle)
+  - `pack` script for previewing package contents
+- **Comprehension optimization** (#22) - Eliminated wasteful IIFEs
+  - Function-final comprehension assignments ~24% smaller
+  - Smarter context detection for when to use IIFE vs plain loop
+
+### Changed
+- Package size optimized: excludes test/, scripts/, dev files
+- Test count: 864 tests (all passing)
+
 ## [1.1.1] - 2025-11-01
 
 ### Fixed

package/README.md

@@ -55,7 +55,7 @@ function parseUsers(...inputs) {
     if ((_ = toSearchable(input).match(/^(\w+):([^@]+@[\w.]+)$/))) {
       name = (_[1] ?? "guest");
       domain = (_ = toSearchable(input).match(/@([\w.]+)/)) && _[1];
-      users.push({name, domain});
+    users.push({name, domain});
     }
   }
   return users;

package/docs/dist/rip.browser.js

@@ -3174,7 +3174,7 @@ var parserInstance = {
     lexer = Object.create(this.lexer);
     sharedState = { yy: {} };
     for (const k2 in this.yy)
-      if (this.yy.hasOwnProperty(k2)) {
+      if (Object.hasOwn(this.yy, k2)) {
         const v = this.yy[k2];
         sharedState.yy[k2] = v;
       }
@@ -3203,7 +3203,7 @@ var parserInstance = {
           expected = (() => {
             const result = [];
             for (const p2 in parseTable[state]) {
-              if (!parseTable[state].hasOwnProperty(p2))
+              if (!Object.hasOwn(parseTable[state], p2))
                 continue;
               if (this.tokenNames[p2] && p2 > TERROR)
                 result.push(`'${this.tokenNames[p2]}'`);
@@ -3970,21 +3970,23 @@ class CodeGenerator {
         const sideEffectOnly = this.nextFunctionIsVoid || false;
         this.nextFunctionIsVoid = false;
         const paramList = this.generateParamList(params);
+        const isSingleSimpleParam = params.length === 1 && typeof params[0] === "string" && !paramList.includes("=") && !paramList.includes("...") && !paramList.includes("[") && !paramList.includes("{");
+        const paramSyntax = isSingleSimpleParam ? paramList : `(${paramList})`;
         const isAsync = this.containsAwait(body);
         const asyncPrefix = isAsync ? "async " : "";
         if (!sideEffectOnly) {
           if (Array.isArray(body) && body[0] === "block" && body.length === 2) {
             const expr = body[1];
             if (!Array.isArray(expr) || expr[0] !== "return") {
-              return `${asyncPrefix}(${paramList}) => ${this.generate(expr, "value")}`;
+              return `${asyncPrefix}${paramSyntax} => ${this.generate(expr, "value")}`;
             }
           }
           if (!Array.isArray(body) || body[0] !== "block") {
-            return `${asyncPrefix}(${paramList}) => ${this.generate(body, "value")}`;
+            return `${asyncPrefix}${paramSyntax} => ${this.generate(body, "value")}`;
           }
         }
         const bodyCode = this.generateFunctionBody(body, params, sideEffectOnly);
-        return `${asyncPrefix}(${paramList}) => ${bodyCode}`;
+        return `${asyncPrefix}${paramSyntax} => ${bodyCode}`;
       }
       case "return": {
         if (rest.length === 0) {
@@ -4041,7 +4043,11 @@ ${this.indent()}}`;
           const thenExpr = this.extractExpression(body);
           return `(!${this.generate(condition, "value")} ? ${thenExpr} : undefined)`;
         }
-        let code = `if (!${this.generate(condition, "value")}) `;
+        let condCode = this.unwrap(this.generate(condition, "value"));
+        if (condCode.includes(" ") || condCode.includes("===") || condCode.includes("!==") || condCode.includes(">") || condCode.includes("<") || condCode.includes("&&") || condCode.includes("||")) {
+          condCode = `(${condCode})`;
+        }
+        let code = `if (!${condCode}) `;
         code += this.generate(body, "statement");
         return code;
       }
@@ -4108,7 +4114,7 @@ ${this.indent()}}`;
               this.indentLevel--;
               stmts.push(this.indent() + "}");
             } else {
-              stmts.push(...statements.map((s) => this.generate(s, "statement") + ";"));
+              stmts.push(...statements.map((s) => this.addSemicolon(s, this.generate(s, "statement"))));
             }
             this.indentLevel--;
             return loopHeader + `{
@@ -4148,7 +4154,7 @@ ${this.indent()}}`;
               this.indentLevel--;
               stmts.push(this.indent() + "}");
             } else {
-              stmts.push(...statements.map((s) => this.generate(s, "statement") + ";"));
+              stmts.push(...statements.map((s) => this.addSemicolon(s, this.generate(s, "statement"))));
             }
             this.indentLevel--;
             code2 += `{
@@ -4217,79 +4223,73 @@ ${this.indent()}}`;
         const [keyVar, valueVar] = Array.isArray(vars) ? vars : [vars];
         const objCode = this.generate(obj, "value");
         let code = `for (const ${keyVar} in ${objCode}) `;
-        let ownCheck = null;
-        let guardCheck = null;
-        if (own) {
-          ownCheck = [[".", obj, "hasOwnProperty"], keyVar];
-        }
-        if (guard) {
-          guardCheck = guard;
-        }
-        let combinedGuard = null;
-        if (!valueVar && ownCheck && guardCheck) {
-          combinedGuard = ["&&", ownCheck, guardCheck];
-        } else if (!valueVar && ownCheck) {
-          combinedGuard = ownCheck;
-        } else if (!valueVar && guardCheck) {
-          combinedGuard = guardCheck;
+        if (own && !valueVar && !guard) {
+          if (Array.isArray(body) && body[0] === "block") {
+            const statements = body.slice(1);
+            this.indentLevel++;
+            const stmts = [
+              `if (!Object.hasOwn(${objCode}, ${keyVar})) continue;`,
+              ...statements.map((s) => this.addSemicolon(s, this.generate(s, "statement")))
+            ];
+            this.indentLevel--;
+            code += `{
+${stmts.map((s) => this.indent() + s).join(`
+`)}
+${this.indent()}}`;
+          } else {
+            code += `{ if (!Object.hasOwn(${objCode}, ${keyVar})) continue; ${this.generate(body, "statement")}; }`;
+          }
+          return code;
         }
         if (valueVar) {
-          if (ownCheck && guardCheck) {
+          if (own && guard) {
             if (Array.isArray(body) && body[0] === "block") {
               const statements = body.slice(1);
               this.indentLevel++;
               const outerIndent = this.indent();
-              const ownCondition = this.generate(ownCheck, "value");
-              this.indentLevel++;
-              const midIndent = this.indent();
-              const guardCondition = this.generate(guardCheck, "value");
+              const guardCondition = this.generate(guard, "value");
               this.indentLevel++;
               const innerIndent = this.indent();
-              const stmts = statements.map((s) => innerIndent + this.generate(s, "statement") + ";");
-              this.indentLevel -= 3;
+              const stmts = statements.map((s) => innerIndent + this.addSemicolon(s, this.generate(s, "statement")));
+              this.indentLevel -= 2;
               code += `{
-${outerIndent}if (${ownCondition}) {
-${midIndent}const ${valueVar} = ${objCode}[${keyVar}];
-${midIndent}if (${guardCondition}) {
+${outerIndent}if (!Object.hasOwn(${objCode}, ${keyVar})) continue;
+${outerIndent}const ${valueVar} = ${objCode}[${keyVar}];
+${outerIndent}if (${guardCondition}) {
 ${stmts.join(`
 `)}
-${midIndent}}
 ${outerIndent}}
 ${this.indent()}}`;
             } else {
-              const ownCondition = this.generate(ownCheck, "value");
-              const guardCondition = this.generate(guardCheck, "value");
-              code += `{ if (${ownCondition}) { const ${valueVar} = ${objCode}[${keyVar}]; if (${guardCondition}) ${this.generate(body, "statement")}; } }`;
+              const guardCondition = this.generate(guard, "value");
+              code += `{ if (!Object.hasOwn(${objCode}, ${keyVar})) continue; const ${valueVar} = ${objCode}[${keyVar}]; if (${guardCondition}) ${this.generate(body, "statement")}; }`;
             }
-          } else if (ownCheck) {
+          } else if (own) {
             if (Array.isArray(body) && body[0] === "block") {
               const statements = body.slice(1);
               this.indentLevel++;
-              const loopBodyIndent = this.indent();
-              const condition = this.generate(ownCheck, "value");
-              this.indentLevel++;
-              const innerIndent = this.indent();
-              const stmts = statements.map((s) => innerIndent + this.generate(s, "statement") + ";");
-              this.indentLevel -= 2;
+              const stmts = [
+                `if (!Object.hasOwn(${objCode}, ${keyVar})) continue;`,
+                `const ${valueVar} = ${objCode}[${keyVar}];`,
+                ...statements.map((s) => this.addSemicolon(s, this.generate(s, "statement")))
+              ];
+              this.indentLevel--;
               code += `{
-${loopBodyIndent}if (${condition}) {
-${innerIndent}const ${valueVar} = ${objCode}[${keyVar}];
-${stmts.join(`
+${stmts.map((s) => this.indent() + s).join(`
 `)}
-${loopBodyIndent}}
 ${this.indent()}}`;
             } else {
-              code += `{ if (${this.generate(ownCheck, "value")}) { const ${valueVar} = ${objCode}[${keyVar}]; ${this.generate(body, "statement")}; } }`;
+              code += `{ if (!Object.hasOwn(${objCode}, ${keyVar})) continue; const ${valueVar} = ${objCode}[${keyVar}]; ${this.generate(body, "statement")}; }`;
             }
-          } else if (guardCheck) {
+          } else if (guard) {
             if (Array.isArray(body) && body[0] === "block") {
               const statements = body.slice(1);
               this.indentLevel++;
               const loopBodyIndent = this.indent();
-              const guardCondition = this.generate(guardCheck, "value");
+              const guardCondition = this.generate(guard, "value");
               this.indentLevel++;
               const innerIndent = this.indent();
-              const stmts = statements.map((s) => innerIndent + this.generate(s, "statement") + ";");
+              const stmts = statements.map((s) => innerIndent + this.addSemicolon(s, this.generate(s, "statement")));
               this.indentLevel -= 2;
               code += `{
 ${loopBodyIndent}const ${valueVar} = ${objCode}[${keyVar}];
@@ -4299,13 +4299,13 @@ ${stmts.join(`
 ${loopBodyIndent}}
 ${this.indent()}}`;
             } else {
-              code += `{ const ${valueVar} = ${objCode}[${keyVar}]; if (${this.generate(guardCheck, "value")}) ${this.generate(body, "statement")}; }`;
+              code += `{ const ${valueVar} = ${objCode}[${keyVar}]; if (${this.generate(guard, "value")}) ${this.generate(body, "statement")}; }`;
             }
           } else {
             if (Array.isArray(body) && body[0] === "block") {
               const statements = body.slice(1);
               this.indentLevel++;
-              const stmts = [`const ${valueVar} = ${objCode}[${keyVar}];`, ...statements.map((s) => this.generate(s, "statement") + ";")];
+              const stmts = [`const ${valueVar} = ${objCode}[${keyVar}];`, ...statements.map((s) => this.addSemicolon(s, this.generate(s, "statement")))];
               this.indentLevel--;
               code += `{
 ${stmts.map((s) => this.indent() + s).join(`
@@ -4316,8 +4316,8 @@ ${this.indent()}}`;
             }
           }
         } else {
-          if (combinedGuard) {
-            code += this.generateLoopBodyWithGuard(body, combinedGuard);
+          if (guard) {
+            code += this.generateLoopBodyWithGuard(body, guard);
           } else {
             code += this.generateLoopBody(body);
           }
@@ -4410,7 +4410,8 @@ ${this.indent()}}`;
         const condition = rest[0];
         const guard = rest.length === 3 ? rest[1] : null;
         const body = rest[rest.length - 1];
-        let code = `while (${this.generate(condition, "value")}) `;
+        const condCode = this.unwrap(this.generate(condition, "value"));
+        let code = `while (${condCode}) `;
         if (guard) {
           code += this.generateLoopBodyWithGuard(body, guard);
         } else {
@@ -4422,7 +4423,11 @@ ${this.indent()}}`;
         const condition = rest[0];
         const guard = rest.length === 3 ? rest[1] : null;
         const body = rest[rest.length - 1];
-        let code = `while (!${this.generate(condition, "value")}) `;
+        let condCode = this.unwrap(this.generate(condition, "value"));
+        if (condCode.includes(" ") || condCode.includes("===") || condCode.includes("!==") || condCode.includes(">") || condCode.includes("<") || condCode.includes("&&") || condCode.includes("||")) {
+          condCode = `(${condCode})`;
+        }
+        let code = `while (!${condCode}) `;
         if (guard) {
           code += this.generateLoopBodyWithGuard(body, guard);
         } else {
@@ -4669,7 +4674,7 @@ ${this.indent()}}`;
 `;
             this.indentLevel++;
             if (own) {
-              code += this.indent() + `if (!${objCode}.hasOwnProperty(${keyVarPattern})) continue;
+              code += this.indent() + `if (!Object.hasOwn(${objCode}, ${keyVarPattern})) continue;
 `;
             }
             if (secondVar) {
@@ -4776,7 +4781,7 @@ ${this.indent()}}`;
 `;
             this.indentLevel++;
             if (own) {
-              code += this.indent() + `if (!${iterableCode}.hasOwnProperty(${keyVar})) continue;
+              code += this.indent() + `if (!Object.hasOwn(${iterableCode}, ${keyVar})) continue;
 `;
             }
             if (valueVar) {
@@ -5326,9 +5331,9 @@ export default ${target}`;
       }
       if (generated && !generated.endsWith(";")) {
         const head = Array.isArray(stmt) ? stmt[0] : null;
-        const controlFlowStatements = ["if", "unless", "for-in", "for-of", "while", "until", "loop", "switch", "try"];
-        const isControlFlow = controlFlowStatements.includes(head);
-        if (!isControlFlow || !generated.endsWith("}")) {
+        const blockStatements = ["def", "class", "if", "unless", "for-in", "for-of", "for-from", "while", "until", "loop", "switch", "try"];
+        const isBlockStatement = blockStatements.includes(head);
+        if (!isBlockStatement || !generated.endsWith("}")) {
           return generated + ";";
         }
       }
@@ -5337,7 +5342,7 @@ export default ${target}`;
 `);
     let needsBlankLine = false;
     if (imports.length > 0) {
-      code += imports.map((stmt) => this.generate(stmt, "statement") + ";").join(`
+      code += imports.map((stmt) => this.addSemicolon(stmt, this.generate(stmt, "statement"))).join(`
 `);
       needsBlankLine = true;
     }
@@ -5406,7 +5411,7 @@ export default ${target}`;
     code += statementsCode;
     if (exports.length > 0) {
       code += `
-` + exports.map((stmt) => this.generate(stmt, "statement") + ";").join(`
+` + exports.map((stmt) => this.addSemicolon(stmt, this.generate(stmt, "statement"))).join(`
 `);
     }
     if (this.dataSection !== null && this.dataSection !== undefined) {
@@ -5606,7 +5611,7 @@ function _setDataSection() {
             code += this.indent() + "return " + stmtCode + `;
 `;
           } else {
-            code += this.indent() + stmtCode + `;
+            code += this.indent() + this.addSemicolon(stmt, stmtCode) + `
 `;
           }
         });
@@ -5655,7 +5660,7 @@ function _setDataSection() {
             code += this.indent() + "return " + stmtCode + `;
 `;
           } else {
-            code += this.indent() + stmtCode + `;
+            code += this.indent() + this.addSemicolon(stmt, stmtCode) + `
 `;
           }
         });
@@ -5748,7 +5753,7 @@ ${this.indent()}}`;
             const [, expr, iterators, guards] = stmt;
             return this.indent() + this.generateComprehensionAsLoop(expr, iterators, guards);
           }
-          return this.indent() + this.generate(stmt, "statement") + ";";
+          return this.indent() + this.addSemicolon(stmt, this.generate(stmt, "statement"));
         });
       });
       return `{
@@ -5759,15 +5764,12 @@ ${this.indent()}}`;
     return `{ ${this.generate(body, "statement")}; }`;
   }
   generateLoopBodyWithGuard(body, guard) {
+    const guardCondition = this.unwrap(this.generate(guard, "value"));
     if (!Array.isArray(body)) {
-      return `{ if (${this.generate(guard, "value")}) ${this.generate(body, "statement")}; }`;
+      return `{ if (${guardCondition}) ${this.generate(body, "statement")}; }`;
     }
     if (body[0] === "block" || Array.isArray(body[0])) {
       const statements = body[0] === "block" ? body.slice(1) : body;
-      let guardCondition = this.generate(guard, "value");
-      if (guardCondition.startsWith("(") && guardCondition.endsWith(")") && !guardCondition.includes("(", 1)) {
-        guardCondition = guardCondition.slice(1, -1);
-      }
       const loopBodyIndent = this.withIndent(() => this.indent());
       const guardCode = `if (${guardCondition}) {
 `;
@@ -5999,8 +6001,20 @@ ${this.indent()}}`;
       return body;
     return [body];
   }
+  needsSemicolon(stmt, generated) {
+    if (!generated || generated.endsWith(";"))
+      return false;
+    if (!generated.endsWith("}"))
+      return true;
+    const head = Array.isArray(stmt) ? stmt[0] : null;
+    const blockStatements = ["def", "class", "if", "unless", "for-in", "for-of", "for-from", "while", "until", "loop", "switch", "try"];
+    return !blockStatements.includes(head);
+  }
+  addSemicolon(stmt, generated) {
+    return generated + (this.needsSemicolon(stmt, generated) ? ";" : "");
+  }
   formatStatements(statements, context = "statement") {
-    return statements.map((s) => this.indent() + this.generate(s, context) + ";");
+    return statements.map((s) => this.indent() + this.addSemicolon(s, this.generate(s, context)));
   }
   hasExplicitControlFlow(body) {
     if (!Array.isArray(body))
@@ -6257,12 +6271,12 @@ ${this.indent()}}`;
 `;
         this.indentLevel++;
         if (own && !valueVar && !guards?.length) {
-          code += this.indent() + `if (!${objCode}.hasOwnProperty(${keyVar})) continue;
+          code += this.indent() + `if (!Object.hasOwn(${objCode}, ${keyVar})) continue;
 `;
           code += this.indent() + this.generate(expr, "statement") + `;
 `;
         } else if (own && valueVar && guards?.length) {
-          code += this.indent() + `if (${objCode}.hasOwnProperty(${keyVar})) {
+          code += this.indent() + `if (Object.hasOwn(${objCode}, ${keyVar})) {
 `;
           this.indentLevel++;
           code += this.indent() + `const ${valueVar} = ${objCode}[${keyVar}];
@@ -6279,7 +6293,7 @@ ${this.indent()}}`;
           code += this.indent() + `}
 `;
         } else if (own && valueVar) {
-          code += this.indent() + `if (${objCode}.hasOwnProperty(${keyVar})) {
+          code += this.indent() + `if (Object.hasOwn(${objCode}, ${keyVar})) {
 `;
           this.indentLevel++;
           code += this.indent() + `const ${valueVar} = ${objCode}[${keyVar}];
@@ -6473,7 +6487,8 @@ ${this.indent()}}`;
     return `(${condCode} ? ${thenExpr} : ${elseExpr})`;
   }
   generateIfAsStatement(condition, thenBranch, elseBranches) {
-    let code = `if (${this.generate(condition, "value")}) `;
+    const condCode = this.unwrap(this.generate(condition, "value"));
+    let code = `if (${condCode}) `;
     code += this.generate(this.unwrapIfBranch(thenBranch), "statement");
     for (const branch of elseBranches) {
       code += ` else `;
@@ -6831,8 +6846,8 @@ function compileToJS(source, options = {}) {
   return compiler.compileToJS(source);
 }
 // src/browser.js
-var VERSION = "1.3.2";
-var BUILD_DATE = "2025-11-06@04:15:20GMT";
+var VERSION = "1.3.8";
+var BUILD_DATE = "2025-11-06@21:35:45GMT";
 var dedent = (s) => {
   const m = s.match(/^[ \t]*(?=\S)/gm);
   const i = Math.min(...(m || []).map((x) => x.length));