@danielx/civet 0.11.8 → 0.11.9

package/CHANGELOG.md

@@ -4,6 +4,17 @@ This changelog is generated automatically by [`build/changelog.civet`](build/cha
 For each version of Civet, it lists and links to all incorporated PRs,
 as well as a full diff and commit list.
 
+## 0.11.9 (2026-05-14, [diff](https://github.com/DanielXMoore/Civet/compare/v0.11.8...v0.11.9), [commits](https://github.com/DanielXMoore/Civet/commits/v0.11.9))
+* Browser LSP: fix `console` types in non-DOM mode [[#2047](https://github.com/DanielXMoore/Civet/pull/2047)]
+* LSP e2e: fix Linux test reliability (Wayland headless + flaky import-completion) [[#2050](https://github.com/DanielXMoore/Civet/pull/2050)]
+* Tests: force v8 coverage flush before mocha worker exit [[#2056](https://github.com/DanielXMoore/Civet/pull/2056)]
+* CI: rolling cache keys + prune stale entries [[#2057](https://github.com/DanielXMoore/Civet/pull/2057)]
+* Fix unicode property names in `@`-bind, `::` prototype access, `:` symbol shortand [[#2055](https://github.com/DanielXMoore/Civet/pull/2055)]
+* fix(coverage): eliminate flakiness from parallel mocha + dual-compile [[#2060](https://github.com/DanielXMoore/Civet/pull/2060)]
+* Restore leaf-glom fallback in `prepend` (fixes #2058) [[#2059](https://github.com/DanielXMoore/Civet/pull/2059)]
+* Upgrade Prettier, add `civet.dev` workspace [[#2063](https://github.com/DanielXMoore/Civet/pull/2063)]
+* fix: unwrap if/then/else assignment to ternary without ref (#2051) [[#2054](https://github.com/DanielXMoore/Civet/pull/2054)]
+
 ## 0.11.8 (2026-05-13, [diff](https://github.com/DanielXMoore/Civet/compare/v0.11.7...v0.11.8), [commits](https://github.com/DanielXMoore/Civet/commits/v0.11.8))
 * Dev: Autopublish vsce and ovsx from GitHub CI [[#1963](https://github.com/DanielXMoore/Civet/pull/1963)]
 * dev: show-uncovered script at root [[#1966](https://github.com/DanielXMoore/Civet/pull/1966)]

package/dist/browser.js

@@ -463,6 +463,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     braceBlock: () => braceBlock,
     bracedBlock: () => bracedBlock,
     buildExportSplitClause: () => buildExportSplitClause,
+    canExpressionizeIfAsTernary: () => canExpressionizeIfAsTernary,
     convertArrowFunctionToMethod: () => convertArrowFunctionToMethod,
     convertFunctionToMethod: () => convertFunctionToMethod,
     convertNamedImportsToObject: () => convertNamedImportsToObject,
@@ -816,10 +817,10 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     }
   }
   function prepend(prefix, node) {
-    return !prefix || Array.isArray(prefix) && len(prefix, 0) ? node : Array.isArray(node) ? [prefix, ...node] : (assert(isParent(node), "prepend: can't glom into an AST leaf"), {
+    return !prefix || Array.isArray(prefix) && len(prefix, 0) ? node : Array.isArray(node) ? [prefix, ...node] : isParent(node) ? {
       ...node,
       children: [prefix, ...node.children]
-    });
+    } : [prefix, node];
   }
   function append(node, suffix) {
     return !suffix || Array.isArray(suffix) && len(suffix, 0) ? node : Array.isArray(node) ? [...node, suffix] : isParent(node) ? {
@@ -4270,7 +4271,10 @@ ${js}`
     let { expression: exp } = initializer, ws;
     if (Array.isArray(exp) && exp.length === 2 && isWhitespaceOrEmpty(exp[0]) && (ws = exp[0], exp = exp[1]), !(typeof exp == "object" && exp != null && "type" in exp && exp.type === "StatementExpression"))
       return;
-    let statementExp = exp.statement, blockStatement = [ws || "", statementExp, ";"], pre = [blockStatement], ref;
+    let statementExp = exp.statement;
+    if (statementExp.type === "IfStatement" && canExpressionizeIfAsTernary(statementExp))
+      return;
+    let blockStatement = [ws || "", statementExp, ";"], pre = [blockStatement], ref;
     if (statementExp.type === "IterationExpression") {
       if (statementExp.async || statementExp.generator)
         return;
@@ -5524,6 +5528,21 @@ ${js}`
     } else
       return blockOrExpression;
   }
+  function canExpressionizeIfAsTernary(statement) {
+    let { then: b, else: e } = statement;
+    return canExpressionizeBlock(b) && (e ? canExpressionizeBlock(e.block) : !0);
+  }
+  function canExpressionizeBlock(blockOrExpression) {
+    if (blockOrExpression && typeof blockOrExpression == "object" && "expressions" in blockOrExpression) {
+      let { expressions } = blockOrExpression, results1 = !0;
+      for (let [, s] of expressions)
+        if (!isExpression(s)) {
+          results1 = !1;
+          break;
+        }
+      return results1;
+    }
+  }
   function expressionizeIfStatement(statement) {
     let { condition, then: b, else: e } = statement, [...condRest] = condition.children, [closeParen] = condRest.splice(-1), expressionizedBlock = expressionizeBlock(b);
     if (!expressionizedBlock)
@@ -6344,9 +6363,9 @@ ${js}`
     }
   }
   function processTypes(node) {
-    let results1 = [];
+    let results2 = [];
     for (let ref22 = gatherRecursiveAll(node, ($13) => $13.type === "TypeUnary"), i12 = 0, len11 = ref22.length; i12 < len11; i12++) {
-      let unary = ref22[i12], suffixIndex = unary.suffix.length - 1, results2 = [];
+      let unary = ref22[i12], suffixIndex = unary.suffix.length - 1, results3 = [];
       for (; suffixIndex >= 0; ) {
         let suffix = unary.suffix[suffixIndex];
         if (typeof suffix == "object" && suffix != null && "token" in suffix && suffix.token === "?") {
@@ -6395,7 +6414,7 @@ ${js}`
             prefix,
             suffix: outer,
             children: [prefix, replace, outer]
-          })), results2.push(replaceNode(unary, replace, parent));
+          })), results3.push(replaceNode(unary, replace, parent));
         } else if (typeof suffix == "object" && suffix != null && "type" in suffix && suffix.type === "NonNullAssertion") {
           let {} = suffix, m7;
           for (; m7 = unary.suffix[suffixIndex], typeof m7 == "object" && m7 != null && "type" in m7 && m7.type === "NonNullAssertion"; )
@@ -6436,13 +6455,13 @@ ${js}`
             prefix,
             suffix: outer,
             children: [prefix, replace, outer]
-          })), results2.push(replaceNode(unary, replace, parent));
+          })), results3.push(replaceNode(unary, replace, parent));
         } else
-          results2.push(suffixIndex--);
+          results3.push(suffixIndex--);
       }
-      results1.push(results2);
+      results2.push(results3);
     }
-    return results1;
+    return results2;
   }
   function processStatementExpressions(statements) {
     for (let ref24 = gatherRecursiveAll(statements, ($14) => $14.type === "StatementExpression"), i13 = 0, len12 = ref24.length; i13 < len12; i13++) {
@@ -6592,12 +6611,12 @@ ${js}`
           index + 1,
           0,
           ...(() => {
-            let results3 = [];
+            let results4 = [];
             for (let i16 = 0, len15 = autoBinds.length; i16 < len15; i16++) {
               let [, a] = autoBinds[i16];
-              results3.push([indent, ["this.", a.name, " = this.", a.name, ".bind(this)"], ";"]);
+              results4.push([indent, ["this.", a.name, " = this.", a.name, ".bind(this)"], ";"]);
             }
-            return results3;
+            return results4;
           })()
         );
       }
@@ -12107,17 +12126,21 @@ ${js}`
         children: modifier ? [modifier, dot] : [dot],
         optional: modifier?.token === "?"
       };
-      return id ? {
-        type: "PropertyAccess",
-        name: id.name,
-        dot: start,
-        children: [start, "prototype.", id]
-      } : {
-        type: "PropertyAccess",
-        name: "prototype",
-        dot: start,
-        children: [start, "prototype"]
-      };
+      if (id) {
+        let access = id.unicode ? ["prototype[", propertyKey(id), "]"] : ["prototype.", id];
+        return {
+          type: "PropertyAccess",
+          name: id.name,
+          dot: start,
+          children: [start, ...access]
+        };
+      } else
+        return {
+          type: "PropertyAccess",
+          name: "prototype",
+          dot: start,
+          children: [start, "prototype"]
+        };
     })(import_lib2.SKIP, $$loc, $$value, $$value[0], $$value[1], $$value[2], $$value[3]), $$final;
     return $$m !== import_lib2.SKIP && ($$r.value = $$m, $$final = $$r), $$final;
   }
@@ -12189,10 +12212,11 @@ ${js}`
     }
     let $$loc = $$r.loc, $$value = $$r.value, $$m = (function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var modifier = $1, dot = $3, id = $4, args = $5;
+      let children = id.unicode ? [modifier, modifier?.token === "?" ? dot : null, "[", propertyKey(id), "]"] : [modifier, dot, id];
       return {
         type: "PropertyBind",
         name: id.name,
-        children: [modifier, dot, id],
+        children,
         // omit `@` from children
         args: args?.children.slice(1, -1) ?? []
         // remove the parens from the arg list, or give an empty list
@@ -12215,10 +12239,11 @@ ${js}`
     }
     let $$loc = $$r.loc, $$value = $$r.value, $$m = (function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var modifier = $1, dot = $3, id = $4, args = $5;
+      let children = id.unicode ? [modifier, modifier?.token === "?" ? dot : null, "[", propertyKey(id), "]"] : [modifier, dot, id];
       return {
         type: "PropertyBind",
         name: id.name,
-        children: [modifier, dot, id],
+        children,
         // omit `@` from children
         args: args?.children.slice(1, -1) ?? []
         // remove the parens from the arg list, or give an empty list
@@ -14889,28 +14914,28 @@ ${js}`
     }
     let $$loc = $$r.loc, $$value = $$r.value, $$m = (function($skip, $loc, $0, $1, $2) {
       var colon = $1, id = $2;
-      let name, token;
-      return id.type === "Identifier" ? { name, children: [token] } = id : (name = literalValue({
+      let name, token, quoted;
+      return id.type === "Identifier" ? id.unicode ? (name = id.unicode, token = { $loc: id.children?.[0]?.$loc, token: `"${id.unicode}"` }, quoted = !0) : ({ name, children: [token] } = id, quoted = !1) : (name = literalValue({
         type: "Literal",
         subtype: "StringLiteral",
         raw: id.token,
         children: [id]
-      }), token = id), config.symbols.includes(name) ? {
+      }), token = id, quoted = !0), config.symbols.includes(name) ? {
         type: "SymbolLiteral",
-        children: id.type === "Identifier" ? [
-          { ...colon, token: "Symbol." },
-          token
-        ] : [
+        children: quoted ? [
           { ...colon, token: "Symbol[" },
           token,
           "]"
+        ] : [
+          { ...colon, token: "Symbol." },
+          token
         ],
         name
       } : {
         type: "SymbolLiteral",
         children: [
           { ...colon, token: "Symbol.for(" },
-          id.type === "Identifier" ? ['"', token, '"'] : token,
+          quoted ? token : ['"', token, '"'],
           ")"
         ],
         name