@fluixi/compiler 1.0.0-alpha.100

package/dist/analyze/intrinsics.js

@@ -0,0 +1,126 @@
+/**
+ * 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.
+ */
+/** Module the reactive primitives are imported from when the compiler adds the import. */
+export 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 const 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' },
+    $cachedResource: { export: 'cachedResource', module: '@fluixi/reactive/cached-resource', 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' },
+    // Scopes, scheduling and lifecycle: no value to classify, but the same authoring promise,
+    // no import to write. `$cleanup` registers a callback on the current owner (`onCleanup`).
+    $batch: { export: 'batch', module: REACTIVE_MODULE, returns: 'plain' },
+    $cleanup: { export: 'onCleanup', module: REACTIVE_MODULE, returns: 'plain' },
+    $root: { export: 'root', module: REACTIVE_MODULE, returns: 'plain' },
+    $context: { export: 'context', module: REACTIVE_MODULE, returns: 'plain' },
+    $renderEffect: { export: 'renderEffect', module: REACTIVE_MODULE, returns: 'effect' },
+    $computed: { export: 'computed', module: REACTIVE_MODULE, returns: 'effect' },
+    // Storage for where the code runs, and a signal kept in it. `$persisted` is a signal
+    // handle as far as reads go: the same accessor with `set` on it.
+    $storage: { export: 'useStorage', module: '@fluixi/core/storage', returns: 'plain' },
+    $asyncStorage: { export: 'useAsyncStorage', module: '@fluixi/core/storage', returns: 'plain' },
+    $persisted: { export: 'persisted', module: '@fluixi/core/storage', returns: 'signal-handle' },
+    // An environment variable, public or server-only; the browser build refuses a secret.
+    $env: { export: 'env', module: '@fluixi/start/env', returns: 'plain' },
+};
+/**
+ * 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 const 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',
+    renderEffect: 'effect',
+    computed: 'effect',
+    createStore: 'reactive-object',
+    resource: 'resource-handle',
+    cachedResource: 'resource-handle',
+    createResource: 'reactive-object',
+    createSelector: 'memo-accessor',
+    createDeferred: 'memo-accessor',
+};
+/** Modules whose exports count as reactive primitives. */
+export const PRIMITIVE_MODULES = [
+    '@fluixi/reactive',
+    '@fluixi/reactive/signal',
+    '@fluixi/reactive/store',
+    '@fluixi/reactive/cached-resource',
+    '@fluixi/core',
+];
+/**
+ * Cheap text check for the file-skipping fast path: a module with no `$` call never
+ * needs parsing. Non-global, so it has no lastIndex to carry between calls.
+ */
+/**
+ * Template tags an app writes without importing them. Each compiles exactly like the marker
+ * it names; a module that binds the name itself keeps its own meaning.
+ */
+export const TAG_INTRINSICS = {
+    $html: { export: 'html', module: '@fluixi/core' },
+    $svg: { export: 'svg', module: '@fluixi/core' },
+    $css: { export: 'css', module: '@fluixi/core' },
+};
+/** The `$` tags this module can use: all of them, less the ones it binds. */
+export function tagIntrinsics(bound) {
+    const tags = new Map();
+    for (const [name, tag] of Object.entries(TAG_INTRINSICS))
+        if (!bound.has(name))
+            tags.set(name, tag.export);
+    return tags;
+}
+const INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join('|')})\\s*\\(`);
+export function mayHaveIntrinsic(code) {
+    return INTRINSIC_CALL.test(code);
+}
+export function isIntrinsicName(name) {
+    return Object.prototype.hasOwnProperty.call(INTRINSICS, name);
+}
+/** Whether a module path exports the reactive primitives. */
+export function isPrimitiveModule(source) {
+    return PRIMITIVE_MODULES.includes(source);
+}

package/dist/analyze/intrinsics.mjs

@@ -0,0 +1,91 @@
+// 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" },
+  $cachedResource: { export: "cachedResource", module: "@fluixi/reactive/cached-resource", 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" },
+  // Scopes, scheduling and lifecycle: no value to classify, but the same authoring promise,
+  // no import to write. `$cleanup` registers a callback on the current owner (`onCleanup`).
+  $batch: { export: "batch", module: REACTIVE_MODULE, returns: "plain" },
+  $cleanup: { export: "onCleanup", module: REACTIVE_MODULE, returns: "plain" },
+  $root: { export: "root", module: REACTIVE_MODULE, returns: "plain" },
+  $context: { export: "context", module: REACTIVE_MODULE, returns: "plain" },
+  $renderEffect: { export: "renderEffect", module: REACTIVE_MODULE, returns: "effect" },
+  $computed: { export: "computed", module: REACTIVE_MODULE, returns: "effect" },
+  // Storage for where the code runs, and a signal kept in it. `$persisted` is a signal
+  // handle as far as reads go: the same accessor with `set` on it.
+  $storage: { export: "useStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $asyncStorage: { export: "useAsyncStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $persisted: { export: "persisted", module: "@fluixi/core/storage", returns: "signal-handle" },
+  // An environment variable, public or server-only; the browser build refuses a secret.
+  $env: { export: "env", module: "@fluixi/start/env", 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",
+  renderEffect: "effect",
+  computed: "effect",
+  createStore: "reactive-object",
+  resource: "resource-handle",
+  cachedResource: "resource-handle",
+  createResource: "reactive-object",
+  createSelector: "memo-accessor",
+  createDeferred: "memo-accessor"
+};
+var PRIMITIVE_MODULES = [
+  "@fluixi/reactive",
+  "@fluixi/reactive/signal",
+  "@fluixi/reactive/store",
+  "@fluixi/reactive/cached-resource",
+  "@fluixi/core"
+];
+var TAG_INTRINSICS = {
+  $html: { export: "html", module: "@fluixi/core" },
+  $svg: { export: "svg", module: "@fluixi/core" },
+  $css: { export: "css", module: "@fluixi/core" }
+};
+function tagIntrinsics(bound) {
+  const tags = /* @__PURE__ */ new Map();
+  for (const [name, tag] of Object.entries(TAG_INTRINSICS)) if (!bound.has(name)) tags.set(name, tag.export);
+  return tags;
+}
+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,
+  TAG_INTRINSICS,
+  isIntrinsicName,
+  isPrimitiveModule,
+  mayHaveIntrinsic,
+  tagIntrinsics
+};

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"}

package/dist/analyze/paren.js

@@ -0,0 +1,168 @@
+/**
+ * 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.
+ */
+/** Index just past the closing quote, or -1 if the literal never closes. */
+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;
+}
+/** Index just past the closing backtick. Substitutions nest, so this recurses. */
+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;
+}
+/** Index just past a regex literal's flags, or -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;
+}
+/** A `/` after one of these divides; anywhere else it opens a regex. */
+function divides(prev) {
+    return prev !== '' && /[A-Za-z0-9_$)\]]/.test(prev);
+}
+/**
+ * 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 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] === '/') {
+            // A line comment swallows whatever follows it, and a wrapper is no help.
+            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;
+}
+/** Wrap a raw expression slice only where the characters say it has to be. */
+export 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.mjs

@@ -0,0 +1,113 @@
+// src/analyze/paren.ts
+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})`;
+}
+export {
+  paren,
+  topLevelComma
+};