@fluixi/compiler 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/analyze/expr-shape.cjs

@@ -1 +1,62 @@
-"use strict";var s=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var m=(e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})},c=(e,t,r,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let p of u(t))!l.call(e,p)&&p!==r&&s(e,p,{get:()=>t[p],enumerable:!(i=o(t,p))||i.enumerable});return e};var y=e=>c(s({},"__esModule",{value:!0}),e);var x={};m(x,{shapeOf:()=>a});module.exports=y(x);var f=new Set(["CallExpression","OptionalCallExpression"]),d=new Set(["MemberExpression","OptionalMemberExpression"]);function a(e){if(!e)return{kind:"opaque"};if(f.has(e.type))return{kind:"call"};if(d.has(e.type)){let t=e.property;return{kind:"member",property:!(e.computed===!0)&&t?.type==="Identifier"?t.name:null}}return e.type==="ConditionalExpression"?{kind:"compound",parts:[e.test,e.consequent,e.alternate].map(n)}:e.type==="LogicalExpression"||e.type==="BinaryExpression"?{kind:"compound",parts:[e.left,e.right].map(n)}:e.type==="TemplateLiteral"?{kind:"compound",parts:e.expressions.map(n)}:e.type==="ObjectExpression"?{kind:"compound",parts:e.properties.filter(r=>(r.type==="ObjectProperty"||r.type==="Property")&&r.computed!==!0).map(r=>n(r.value))}:e.type==="ArrayExpression"?{kind:"compound",parts:e.elements.filter(r=>r!=null&&r.type!=="SpreadElement").map(n)}:{kind:"opaque"}}var n=e=>a(e);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/analyze/expr-shape.ts
+var expr_shape_exports = {};
+__export(expr_shape_exports, {
+  shapeOf: () => shapeOf
+});
+module.exports = __toCommonJS(expr_shape_exports);
+var CALL = /* @__PURE__ */ new Set(["CallExpression", "OptionalCallExpression"]);
+var MEMBER = /* @__PURE__ */ new Set(["MemberExpression", "OptionalMemberExpression"]);
+function shapeOf(node) {
+  if (!node) return { kind: "opaque" };
+  if (CALL.has(node.type)) return { kind: "call" };
+  if (MEMBER.has(node.type)) {
+    const property = node.property;
+    const computed = node.computed === true;
+    return {
+      kind: "member",
+      property: !computed && property?.type === "Identifier" ? property.name : null
+    };
+  }
+  if (node.type === "ConditionalExpression") {
+    return { kind: "compound", parts: [node.test, node.consequent, node.alternate].map(part) };
+  }
+  if (node.type === "LogicalExpression" || node.type === "BinaryExpression") {
+    return { kind: "compound", parts: [node.left, node.right].map(part) };
+  }
+  if (node.type === "TemplateLiteral") {
+    return { kind: "compound", parts: node.expressions.map(part) };
+  }
+  if (node.type === "ObjectExpression") {
+    const props = node.properties.filter(
+      (p) => (p.type === "ObjectProperty" || p.type === "Property") && p.computed !== true
+    );
+    return { kind: "compound", parts: props.map((p) => part(p.value)) };
+  }
+  if (node.type === "ArrayExpression") {
+    const items = node.elements.filter(
+      (e) => e != null && e.type !== "SpreadElement"
+    );
+    return { kind: "compound", parts: items.map(part) };
+  }
+  return { kind: "opaque" };
+}
+var part = (n) => shapeOf(n);

package/dist/analyze/expr-shape.d.cts

@@ -0,0 +1,14 @@
+/**
+ * Map a parsed expression node to an `ExprShape`.
+ *
+ * Works off `node.type` strings, so it takes any ESTree-shaped AST — @babel/parser,
+ * acorn, or whatever replaces them — and accepts the few names Babel spells
+ * differently (`ObjectProperty`, `Optional*Expression`).
+ */
+import type { ExprShape } from './reactive-expr.cjs';
+interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+export declare function shapeOf(node: Node | null | undefined): ExprShape;
+export {};

package/dist/analyze/expr-shape.mjs

@@ -1 +1,41 @@
-var n=new Set(["CallExpression","OptionalCallExpression"]),s=new Set(["MemberExpression","OptionalMemberExpression"]);function i(e){if(!e)return{kind:"opaque"};if(n.has(e.type))return{kind:"call"};if(s.has(e.type)){let p=e.property;return{kind:"member",property:!(e.computed===!0)&&p?.type==="Identifier"?p.name:null}}return e.type==="ConditionalExpression"?{kind:"compound",parts:[e.test,e.consequent,e.alternate].map(r)}:e.type==="LogicalExpression"||e.type==="BinaryExpression"?{kind:"compound",parts:[e.left,e.right].map(r)}:e.type==="TemplateLiteral"?{kind:"compound",parts:e.expressions.map(r)}:e.type==="ObjectExpression"?{kind:"compound",parts:e.properties.filter(t=>(t.type==="ObjectProperty"||t.type==="Property")&&t.computed!==!0).map(t=>r(t.value))}:e.type==="ArrayExpression"?{kind:"compound",parts:e.elements.filter(t=>t!=null&&t.type!=="SpreadElement").map(r)}:{kind:"opaque"}}var r=e=>i(e);export{i as shapeOf};
+// src/analyze/expr-shape.ts
+var CALL = /* @__PURE__ */ new Set(["CallExpression", "OptionalCallExpression"]);
+var MEMBER = /* @__PURE__ */ new Set(["MemberExpression", "OptionalMemberExpression"]);
+function shapeOf(node) {
+  if (!node) return { kind: "opaque" };
+  if (CALL.has(node.type)) return { kind: "call" };
+  if (MEMBER.has(node.type)) {
+    const property = node.property;
+    const computed = node.computed === true;
+    return {
+      kind: "member",
+      property: !computed && property?.type === "Identifier" ? property.name : null
+    };
+  }
+  if (node.type === "ConditionalExpression") {
+    return { kind: "compound", parts: [node.test, node.consequent, node.alternate].map(part) };
+  }
+  if (node.type === "LogicalExpression" || node.type === "BinaryExpression") {
+    return { kind: "compound", parts: [node.left, node.right].map(part) };
+  }
+  if (node.type === "TemplateLiteral") {
+    return { kind: "compound", parts: node.expressions.map(part) };
+  }
+  if (node.type === "ObjectExpression") {
+    const props = node.properties.filter(
+      (p) => (p.type === "ObjectProperty" || p.type === "Property") && p.computed !== true
+    );
+    return { kind: "compound", parts: props.map((p) => part(p.value)) };
+  }
+  if (node.type === "ArrayExpression") {
+    const items = node.elements.filter(
+      (e) => e != null && e.type !== "SpreadElement"
+    );
+    return { kind: "compound", parts: items.map(part) };
+  }
+  return { kind: "opaque" };
+}
+var part = (n) => shapeOf(n);
+export {
+  shapeOf
+};

package/dist/analyze/intrinsics.cjs

@@ -1 +1,80 @@
-"use strict";var c=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var d=(e,r)=>{for(var n in r)c(e,n,{get:r[n],enumerable:!0})},f=(e,r,n,a)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of u(r))!m.call(e,o)&&o!==n&&c(e,o,{get:()=>r[o],enumerable:!(a=l(r,o))||a.enumerable});return e};var p=e=>f(c({},"__esModule",{value:!0}),e);var h={};d(h,{INTRINSICS:()=>s,PRIMITIVE_MODULES:()=>i,REACTIVE_MODULE:()=>t,RUNTIME_PRIMITIVES:()=>x,isIntrinsicName:()=>R,isPrimitiveModule:()=>v,mayHaveIntrinsic:()=>I});module.exports=p(h);var t="@fluixi/reactive/signal",s={$signal:{export:"signal",module:t,returns:"signal-handle"},$memo:{export:"memo",module:t,returns:"memo-handle"},$effect:{export:"effect",module:t,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:t,returns:"resource-handle"},$selector:{export:"createSelector",module:t,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:t,returns:"memo-accessor"},$untrack:{export:"untrack",module:t,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}},x={signal:"signal-handle",memo:"memo-handle",effect:"effect",store:"store-handle",createSignal:["signal-accessor","signal-setter"],createMemo:"memo-accessor",createEffect:"effect",createRenderEffect:"effect",createStore:"reactive-object",resource:"resource-handle",createResource:"reactive-object",createSelector:"memo-accessor",createDeferred:"memo-accessor"},i=["@fluixi/reactive","@fluixi/reactive/signal","@fluixi/reactive/store","@fluixi/core"],g=new RegExp(`\\$(?:${Object.keys(s).map(e=>e.slice(1)).join("|")})\\s*\\(`);function I(e){return g.test(e)}function R(e){return Object.prototype.hasOwnProperty.call(s,e)}function v(e){return i.includes(e)}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/analyze/intrinsics.ts
+var intrinsics_exports = {};
+__export(intrinsics_exports, {
+  INTRINSICS: () => INTRINSICS,
+  PRIMITIVE_MODULES: () => PRIMITIVE_MODULES,
+  REACTIVE_MODULE: () => REACTIVE_MODULE,
+  RUNTIME_PRIMITIVES: () => RUNTIME_PRIMITIVES,
+  isIntrinsicName: () => isIntrinsicName,
+  isPrimitiveModule: () => isPrimitiveModule,
+  mayHaveIntrinsic: () => mayHaveIntrinsic
+});
+module.exports = __toCommonJS(intrinsics_exports);
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
+  $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
+  // No short runtime form for these yet, so the intrinsic stands for the `create*`
+  // name. Still worth having — no import to write — and when a shorter form is
+  // designed, the change is this line rather than a compiler pass.
+  $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  // Not value constructors, but the compiler has to know them: they change what a read
+  // does. `untrack` suppresses dependency collection, which is exactly the kind of thing
+  // dependency analysis must not guess at.
+  $untrack: { export: "untrack", module: REACTIVE_MODULE, returns: "plain" },
+  $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" }
+};
+var RUNTIME_PRIMITIVES = {
+  signal: "signal-handle",
+  memo: "memo-handle",
+  effect: "effect",
+  store: "store-handle",
+  createSignal: ["signal-accessor", "signal-setter"],
+  createMemo: "memo-accessor",
+  createEffect: "effect",
+  createRenderEffect: "effect",
+  createStore: "reactive-object",
+  resource: "resource-handle",
+  createResource: "reactive-object",
+  createSelector: "memo-accessor",
+  createDeferred: "memo-accessor"
+};
+var PRIMITIVE_MODULES = [
+  "@fluixi/reactive",
+  "@fluixi/reactive/signal",
+  "@fluixi/reactive/store",
+  "@fluixi/core"
+];
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+function mayHaveIntrinsic(code) {
+  return INTRINSIC_CALL.test(code);
+}
+function isIntrinsicName(name) {
+  return Object.prototype.hasOwnProperty.call(INTRINSICS, name);
+}
+function isPrimitiveModule(source) {
+  return PRIMITIVE_MODULES.includes(source);
+}

package/dist/analyze/intrinsics.d.cts

@@ -0,0 +1,66 @@
+/**
+ * The reactive primitives the compiler knows by name, in one place.
+ *
+ * Two ways to write the same thing. The runtime call, which needs an import and works
+ * without us:
+ *
+ *   import { createSignal } from '@fluixi/reactive/signal';
+ *   const count = createSignal(0);
+ *
+ * And the intrinsic, which the compiler resolves and imports for you:
+ *
+ *   const count = $signal(0);
+ *
+ * They are not two reactive systems. `$signal` compiles to the same `createSignal` call,
+ * so there's one graph, one lifecycle, one SSR story. The `$` form is authoring sugar
+ * the compiler understands; the runtime form stays public, because a library that never
+ * runs this compiler still has to be able to write reactive code.
+ *
+ * Everything the compiler needs to know about a primitive lives in this table rather
+ * than spread across passes, so adding one is an entry, not a new code path.
+ */
+/** What a binding holds, once we know where it came from. */
+export type ReactiveKind = 'plain'
+/** `signal(0)` — one object, read with `.get()` and written with `.set()`. */
+ | 'signal-handle'
+/** `memo(fn)` — read-only, so `.get()` only. */
+ | 'memo-handle'
+/** `store(obj)` — read properties directly, `.set()` writes. */
+ | 'store-handle'
+/** `resource(fn)` — `.get()` reads, with `.loading`/`.latest`/`.refetch()` on it. */
+ | 'resource-handle'
+/** The accessor half of the tuple form, `const [count] = createSignal(0)`. */
+ | 'signal-accessor' | 'signal-setter' | 'memo-accessor' | 'effect' | 'reactive-object';
+export interface Intrinsic {
+    /** Runtime export this compiles to. */
+    export: string;
+    /** Module it comes from. */
+    module: string;
+    /**
+     * What the call yields. A tuple means the call is destructured into that many
+     * bindings — `createSignal` gives an accessor and a setter, in that order.
+     */
+    returns: ReactiveKind | readonly ReactiveKind[];
+}
+/** Module the reactive primitives are imported from when the compiler adds the import. */
+export declare const REACTIVE_MODULE = "@fluixi/reactive/signal";
+/**
+ * `$name` → the runtime it stands for.
+ *
+ * The `$` prefix is reserved. A local binding of the same name wins — it has to, or the
+ * compiler would rewrite code that means something else — and that's reported rather
+ * than done quietly.
+ */
+export declare const INTRINSICS: Readonly<Record<string, Intrinsic>>;
+/**
+ * The runtime names, for the other direction: source that imports `createSignal` gets
+ * classified the same way as source that writes `$signal`, so later passes see one
+ * vocabulary whichever form the author used.
+ */
+export declare const RUNTIME_PRIMITIVES: Readonly<Record<string, Intrinsic['returns']>>;
+/** Modules whose exports count as reactive primitives. */
+export declare const PRIMITIVE_MODULES: readonly string[];
+export declare function mayHaveIntrinsic(code: string): boolean;
+export declare function isIntrinsicName(name: string): boolean;
+/** Whether a module path exports the reactive primitives. */
+export declare function isPrimitiveModule(source: string): boolean;

package/dist/analyze/intrinsics.mjs

@@ -1 +1,59 @@
-var r="@fluixi/reactive/signal",t={$signal:{export:"signal",module:r,returns:"signal-handle"},$memo:{export:"memo",module:r,returns:"memo-handle"},$effect:{export:"effect",module:r,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:r,returns:"resource-handle"},$selector:{export:"createSelector",module:r,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:r,returns:"memo-accessor"},$untrack:{export:"untrack",module:r,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}},c={signal:"signal-handle",memo:"memo-handle",effect:"effect",store:"store-handle",createSignal:["signal-accessor","signal-setter"],createMemo:"memo-accessor",createEffect:"effect",createRenderEffect:"effect",createStore:"reactive-object",resource:"resource-handle",createResource:"reactive-object",createSelector:"memo-accessor",createDeferred:"memo-accessor"},o=["@fluixi/reactive","@fluixi/reactive/signal","@fluixi/reactive/store","@fluixi/core"],n=new RegExp(`\\$(?:${Object.keys(t).map(e=>e.slice(1)).join("|")})\\s*\\(`);function s(e){return n.test(e)}function a(e){return Object.prototype.hasOwnProperty.call(t,e)}function i(e){return o.includes(e)}export{t as INTRINSICS,o as PRIMITIVE_MODULES,r as REACTIVE_MODULE,c as RUNTIME_PRIMITIVES,a as isIntrinsicName,i as isPrimitiveModule,s as mayHaveIntrinsic};
+// src/analyze/intrinsics.ts
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
+  $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
+  // No short runtime form for these yet, so the intrinsic stands for the `create*`
+  // name. Still worth having — no import to write — and when a shorter form is
+  // designed, the change is this line rather than a compiler pass.
+  $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  // Not value constructors, but the compiler has to know them: they change what a read
+  // does. `untrack` suppresses dependency collection, which is exactly the kind of thing
+  // dependency analysis must not guess at.
+  $untrack: { export: "untrack", module: REACTIVE_MODULE, returns: "plain" },
+  $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" }
+};
+var RUNTIME_PRIMITIVES = {
+  signal: "signal-handle",
+  memo: "memo-handle",
+  effect: "effect",
+  store: "store-handle",
+  createSignal: ["signal-accessor", "signal-setter"],
+  createMemo: "memo-accessor",
+  createEffect: "effect",
+  createRenderEffect: "effect",
+  createStore: "reactive-object",
+  resource: "resource-handle",
+  createResource: "reactive-object",
+  createSelector: "memo-accessor",
+  createDeferred: "memo-accessor"
+};
+var PRIMITIVE_MODULES = [
+  "@fluixi/reactive",
+  "@fluixi/reactive/signal",
+  "@fluixi/reactive/store",
+  "@fluixi/core"
+];
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+function mayHaveIntrinsic(code) {
+  return INTRINSIC_CALL.test(code);
+}
+function isIntrinsicName(name) {
+  return Object.prototype.hasOwnProperty.call(INTRINSICS, name);
+}
+function isPrimitiveModule(source) {
+  return PRIMITIVE_MODULES.includes(source);
+}
+export {
+  INTRINSICS,
+  PRIMITIVE_MODULES,
+  REACTIVE_MODULE,
+  RUNTIME_PRIMITIVES,
+  isIntrinsicName,
+  isPrimitiveModule,
+  mayHaveIntrinsic
+};

package/dist/analyze/paren.cjs

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/analyze/paren.ts
+var paren_exports = {};
+__export(paren_exports, {
+  paren: () => paren,
+  topLevelComma: () => topLevelComma
+});
+module.exports = __toCommonJS(paren_exports);
+function skipQuoted(src, start) {
+  const quote = src[start];
+  for (let i = start + 1; i < src.length; i++) {
+    const c = src[i];
+    if (c === "\\") i++;
+    else if (c === quote) return i + 1;
+    else if (c === "\n") return -1;
+  }
+  return -1;
+}
+function skipTemplate(src, start) {
+  let i = start + 1;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === "\\") {
+      i += 2;
+    } else if (c === "`") {
+      return i + 1;
+    } else if (c === "$" && src[i + 1] === "{") {
+      let depth = 1;
+      i += 2;
+      while (i < src.length && depth > 0) {
+        const k = src[i];
+        if (k === "\\") i += 2;
+        else if (k === "`") {
+          const end = skipTemplate(src, i);
+          if (end < 0) return -1;
+          i = end;
+        } else if (k === '"' || k === "'") {
+          const end = skipQuoted(src, i);
+          if (end < 0) return -1;
+          i = end;
+        } else {
+          if (k === "{") depth++;
+          else if (k === "}") depth--;
+          i++;
+        }
+      }
+    } else {
+      i++;
+    }
+  }
+  return -1;
+}
+function skipRegex(src, start) {
+  let inClass = false;
+  for (let i = start + 1; i < src.length; i++) {
+    const c = src[i];
+    if (c === "\\") i++;
+    else if (c === "[") inClass = true;
+    else if (c === "]") inClass = false;
+    else if (c === "\n") return -1;
+    else if (c === "/" && !inClass) {
+      let end = i + 1;
+      while (end < src.length && /[a-z]/i.test(src[end])) end++;
+      return end;
+    }
+  }
+  return -1;
+}
+function divides(prev) {
+  return prev !== "" && /[A-Za-z0-9_$)\]]/.test(prev);
+}
+function topLevelComma(src) {
+  let depth = 0;
+  let prev = "";
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"' || c === "'") {
+      const end = skipQuoted(src, i);
+      if (end < 0) return null;
+      i = end;
+      prev = c;
+    } else if (c === "`") {
+      const end = skipTemplate(src, i);
+      if (end < 0) return null;
+      i = end;
+      prev = c;
+    } else if (c === "/" && src[i + 1] === "/") {
+      return null;
+    } else if (c === "/" && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      if (end < 0) return null;
+      i = end + 2;
+    } else if (c === "/" && !divides(prev)) {
+      const end = skipRegex(src, i);
+      if (end < 0) return null;
+      i = end;
+      prev = "/";
+    } else {
+      if (c === "(" || c === "[" || c === "{") depth++;
+      else if (c === ")" || c === "]" || c === "}") {
+        depth--;
+        if (depth < 0) return null;
+      } else if (c === "," && depth === 0) return true;
+      if (!/\s/.test(c)) prev = c;
+      i++;
+    }
+  }
+  return depth === 0 ? false : null;
+}
+function paren(code, position) {
+  const src = code.trim();
+  if (src === "") return `(${code})`;
+  if (position === "arrowBody" && src[0] === "{") return `(${code})`;
+  return topLevelComma(src) === false ? code : `(${code})`;
+}

package/dist/analyze/paren.d.cts

@@ -0,0 +1,23 @@
+/**
+ * Whether a raw expression slice has to be wrapped in parens before it is dropped
+ * into an object value, an argument list, a `return`, or an arrow's concise body.
+ *
+ * The compiler holds expressions as source text: `IRExpression.code` is deliberately
+ * a string (see ir/nodes.ts), so there is no printer to ask about precedence and the
+ * decision comes from the characters.
+ *
+ * Two things bind wrong. A top-level comma reads as a sequence or as an argument
+ * separator, and a leading `{` in an arrow body reads as a block. Everything else
+ * parses the same wrapped or bare.
+ *
+ * Wrapping unconditionally was the old answer, and it reached production: esbuild's
+ * minifier keeps redundant parens. Measured on the fluixi-ui playground, 3,320 of
+ * the 3,322 bytes the native build ran over the babel one were these.
+ */
+/**
+ * True when the text has a comma outside every bracket, string and substitution.
+ * Null when the scan cannot say, which the caller reads as "assume it does".
+ */
+export declare function topLevelComma(src: string): boolean | null;
+/** Wrap a raw expression slice only where the characters say it has to be. */
+export declare function paren(code: string, position: 'value' | 'arrowBody'): string;

package/dist/analyze/paren.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Whether a raw expression slice has to be wrapped in parens before it is dropped
+ * into an object value, an argument list, a `return`, or an arrow's concise body.
+ *
+ * The compiler holds expressions as source text: `IRExpression.code` is deliberately
+ * a string (see ir/nodes.ts), so there is no printer to ask about precedence and the
+ * decision comes from the characters.
+ *
+ * Two things bind wrong. A top-level comma reads as a sequence or as an argument
+ * separator, and a leading `{` in an arrow body reads as a block. Everything else
+ * parses the same wrapped or bare.
+ *
+ * Wrapping unconditionally was the old answer, and it reached production: esbuild's
+ * minifier keeps redundant parens. Measured on the fluixi-ui playground, 3,320 of
+ * the 3,322 bytes the native build ran over the babel one were these.
+ */
+/**
+ * True when the text has a comma outside every bracket, string and substitution.
+ * Null when the scan cannot say, which the caller reads as "assume it does".
+ */
+export declare function topLevelComma(src: string): boolean | null;
+/** Wrap a raw expression slice only where the characters say it has to be. */
+export declare function paren(code: string, position: 'value' | 'arrowBody'): string;
+//# sourceMappingURL=paren.d.ts.map

package/dist/analyze/paren.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paren.d.ts","sourceRoot":"","sources":["../../src/analyze/paren.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAyEH;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAuCzD;AAED,8EAA8E;AAC9E,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,WAAW,GAAG,MAAM,CAK3E"}