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

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
+};

package/dist/analyze/props-destructure.cjs

@@ -1 +1,226 @@
-"use strict";var p=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var k=(s,t)=>{for(var e in t)p(s,e,{get:t[e],enumerable:!0})},v=(s,t,e,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of w(t))!b.call(s,a)&&a!==e&&p(s,a,{get:()=>t[a],enumerable:!(n=h(t,a))||n.enumerable});return s};var x=s=>v(p({},"__esModule",{value:!0}),s);var R={};k(R,{explainBail:()=>E,planPropsDestructure:()=>D});module.exports=x(R);function u(s,t){if(s)switch(s.type){case"Identifier":t.add(s.name);return;case"ObjectPattern":for(let e of s.properties)e.type==="RestElement"?u(e.argument,t):u(e.value,t);return;case"ArrayPattern":for(let e of s.elements)u(e,t);return;case"AssignmentPattern":u(s.left,t);return;case"RestElement":u(s.argument,t);return}}function m(s){switch(s.type){case"StringLiteral":case"NumericLiteral":case"BooleanLiteral":case"NullLiteral":case"BigIntLiteral":case"RegExpLiteral":case"Identifier":return!0;case"Literal":return!0;case"TemplateLiteral":return s.expressions.every(m);case"UnaryExpression":return m(s.argument);case"MemberExpression":return!1;default:return!1}}function f(s,t){if(!(!s||typeof s!="object")){t(s);for(let e of Object.keys(s)){if(e==="loc"||e==="range"||e==="leadingComments"||e==="trailingComments")continue;let n=s[e];if(Array.isArray(n))for(let a of n)a&&typeof a=="object"&&f(a,t);else n&&typeof n=="object"&&typeof n.type=="string"&&f(n,t)}}}function P(s){let t=new Set;return f(s,e=>{if(e.type==="AssignmentExpression")u(e.left,t);else if(e.type==="UpdateExpression"){let n=e.argument;n?.type==="Identifier"&&t.add(n.name)}}),t}function S(s,t){let e=new Set,n=a=>{let c=new Set;u(a,c);for(let i of c)t.has(i)&&e.add(i)};return f(s,a=>{switch(a.type){case"VariableDeclarator":n(a.id);return;case"FunctionDeclaration":case"FunctionExpression":case"ArrowFunctionExpression":n(a.id);for(let c of a.params??[])n(c);return;case"CatchClause":n(a.param);return;case"ClassDeclaration":case"ClassExpression":n(a.id);return}}),e}function N(s,t,e){for(let n of s.properties??[]){if(n.type==="RestElement"){let o=n.argument;if(o?.type!=="Identifier"||t.length>0){let l=new Set;u(o,l);for(let y of l)e.bails.push({name:y,reason:"rest"});continue}e.rest={name:o.name,keys:[]};continue}if(n.computed){let o=new Set;u(n.value,o);for(let l of o)e.bails.push({name:l,reason:"computed"});continue}let a=n.key,c=a.type==="Identifier"?a.name:a.value,i=n.value,r;i.type==="AssignmentPattern"&&(r=i.right,i=i.left);let d=[...t,c];if(i.type==="Identifier"){if(r&&!m(r)){e.bails.push({name:i.name,reason:"unsafe-default"});continue}e.reads.push({name:i.name,path:d,...r?{fallback:r}:{}});continue}if(i.type==="ObjectPattern"){if(r){let o=new Set;u(i,o);for(let l of o)e.bails.push({name:l,reason:"unsafe-default"});continue}N(i,d,e);continue}let g=new Set;u(i,g);for(let o of g)e.bails.push({name:o,reason:"computed"})}}function D(s,t){let e={reads:[],bails:[]};if(s?.type!=="ObjectPattern"||(N(s,[],e),e.rest&&(t?.type!=="BlockStatement"?(e.bails.push({name:e.rest.name,reason:"rest"}),delete e.rest):e.rest.keys=(s.properties??[]).filter(r=>r.type!=="RestElement"&&!r.computed).map(r=>{let d=r.key;return d.type==="Identifier"?d.name:d.value})),e.reads.length===0&&!e.rest))return e;let n=new Set(e.reads.map(r=>r.name));e.rest&&n.add(e.rest.name);let a=P(t),c=S(t,n),i=[];for(let r of e.reads)a.has(r.name)?e.bails.push({name:r.name,reason:"reassigned"}):c.has(r.name)?e.bails.push({name:r.name,reason:"shadowed"}):i.push(r);return e.reads=i,e.rest&&a.has(e.rest.name)?(e.bails.push({name:e.rest.name,reason:"reassigned"}),delete e.rest):e.rest&&c.has(e.rest.name)&&(e.bails.push({name:e.rest.name,reason:"shadowed"}),delete e.rest),e}function E(s){switch(s){case"rest":return"this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";case"computed":return"the property is not known until it runs";case"reassigned":return"the binding is assigned to, and props are read-only";case"shadowed":return"an inner scope binds the same name";case"unsafe-default":return"the default would have to run again on every read"}}
+"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/props-destructure.ts
+var props_destructure_exports = {};
+__export(props_destructure_exports, {
+  explainBail: () => explainBail,
+  planPropsDestructure: () => planPropsDestructure
+});
+module.exports = __toCommonJS(props_destructure_exports);
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function isSafeDefault(node) {
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "BigIntLiteral":
+    case "RegExpLiteral":
+    case "Identifier":
+      return true;
+    // ESTree spells every literal as `Literal`; both shapes reach this analysis.
+    case "Literal":
+      return true;
+    case "TemplateLiteral":
+      return node.expressions.every(isSafeDefault);
+    case "UnaryExpression":
+      return isSafeDefault(node.argument);
+    case "MemberExpression":
+      return false;
+    default:
+      return false;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "range" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (item && typeof item === "object") walk(item, visit);
+    } else if (value && typeof value === "object" && typeof value.type === "string") {
+      walk(value, visit);
+    }
+  }
+}
+function reassignedNames(body) {
+  const written = /* @__PURE__ */ new Set();
+  walk(body, (node) => {
+    if (node.type === "AssignmentExpression") patternNames(node.left, written);
+    else if (node.type === "UpdateExpression") {
+      const arg = node.argument;
+      if (arg?.type === "Identifier") written.add(arg.name);
+    }
+  });
+  return written;
+}
+function shadowedNames(body, candidates) {
+  const shadowed = /* @__PURE__ */ new Set();
+  const note = (node) => {
+    const names = /* @__PURE__ */ new Set();
+    patternNames(node, names);
+    for (const n of names) if (candidates.has(n)) shadowed.add(n);
+  };
+  walk(body, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        note(node.id);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        note(node.id);
+        for (const p of node.params ?? []) note(p);
+        return;
+      case "CatchClause":
+        note(node.param);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        note(node.id);
+        return;
+    }
+  });
+  return shadowed;
+}
+function collect(pattern, path, plan) {
+  for (const property of pattern.properties ?? []) {
+    if (property.type === "RestElement") {
+      const argument = property.argument;
+      if (argument?.type !== "Identifier" || path.length > 0) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(argument, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "rest" });
+        continue;
+      }
+      plan.rest = { name: argument.name, keys: [] };
+      continue;
+    }
+    if (property.computed) {
+      const names2 = /* @__PURE__ */ new Set();
+      patternNames(property.value, names2);
+      for (const name of names2) plan.bails.push({ name, reason: "computed" });
+      continue;
+    }
+    const key = property.key;
+    const propertyName = key.type === "Identifier" ? key.name : key.value;
+    let value = property.value;
+    let fallback;
+    if (value.type === "AssignmentPattern") {
+      fallback = value.right;
+      value = value.left;
+    }
+    const here = [...path, propertyName];
+    if (value.type === "Identifier") {
+      if (fallback && !isSafeDefault(fallback)) {
+        plan.bails.push({ name: value.name, reason: "unsafe-default" });
+        continue;
+      }
+      plan.reads.push({ name: value.name, path: here, ...fallback ? { fallback } : {} });
+      continue;
+    }
+    if (value.type === "ObjectPattern") {
+      if (fallback) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(value, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "unsafe-default" });
+        continue;
+      }
+      collect(value, here, plan);
+      continue;
+    }
+    const names = /* @__PURE__ */ new Set();
+    patternNames(value, names);
+    for (const name of names) plan.bails.push({ name, reason: "computed" });
+  }
+}
+function planPropsDestructure(pattern, body) {
+  const plan = { reads: [], bails: [] };
+  if (pattern?.type !== "ObjectPattern") return plan;
+  collect(pattern, [], plan);
+  if (plan.rest) {
+    if (body?.type !== "BlockStatement") {
+      plan.bails.push({ name: plan.rest.name, reason: "rest" });
+      delete plan.rest;
+    } else {
+      plan.rest.keys = (pattern.properties ?? []).filter((p) => p.type !== "RestElement" && !p.computed).map((p) => {
+        const key = p.key;
+        return key.type === "Identifier" ? key.name : key.value;
+      });
+    }
+  }
+  if (plan.reads.length === 0 && !plan.rest) return plan;
+  const candidates = new Set(plan.reads.map((r) => r.name));
+  if (plan.rest) candidates.add(plan.rest.name);
+  const written = reassignedNames(body);
+  const shadowed = shadowedNames(body, candidates);
+  const kept = [];
+  for (const read of plan.reads) {
+    if (written.has(read.name)) plan.bails.push({ name: read.name, reason: "reassigned" });
+    else if (shadowed.has(read.name)) plan.bails.push({ name: read.name, reason: "shadowed" });
+    else kept.push(read);
+  }
+  plan.reads = kept;
+  if (plan.rest && written.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "reassigned" });
+    delete plan.rest;
+  } else if (plan.rest && shadowed.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "shadowed" });
+    delete plan.rest;
+  }
+  return plan;
+}
+function explainBail(reason) {
+  switch (reason) {
+    case "rest":
+      return "this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";
+    case "computed":
+      return "the property is not known until it runs";
+    case "reassigned":
+      return "the binding is assigned to, and props are read-only";
+    case "shadowed":
+      return "an inner scope binds the same name";
+    case "unsafe-default":
+      return "the default would have to run again on every read";
+  }
+}

package/dist/analyze/props-destructure.d.cts

@@ -0,0 +1,83 @@
+/**
+ * Props destructuring, without losing reactivity.
+ *
+ * Props come in as an object of getters, so `props.name` re-reads every time and that
+ * keeps a binding current. `const { name } = props` copies the value out once, which is
+ * why we call splitProps in about 84 components.
+ *
+ * The plan here rewrites `name` to `props.name` at each use rather than making it an
+ * accessor. `() => props.name` would change the binding's type, and then every use has
+ * to change with it: passed to a plain function, stored in an array, compared with
+ * `===`. That's a whole-program job. Substitution is one function body and a rename.
+ *
+ * It does change one thing. A read that happens later sees the current value instead of
+ * the value at destructure time, which is the reason to do this at all. Anything past
+ * that I leave as written and report, so splitProps stays correct where it's still the
+ * right answer.
+ *
+ * No babel in here (see no-babel-in-core.spec.ts), nodes are read structurally, the way
+ * transform/bindings.ts does, so either front-end can drive it.
+ */
+interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+/** Why a binding was left alone. All of these change more than when the read happens. */
+export type DestructureBail = 
+/**
+ * A rest we can't serve: destructured further (`...{ a }`), or in a function with no
+ * block to put the splitProps call in (`({ a, ...rest }) => …`).
+ */
+'rest'
+/** `const { [key]: a } = props`: we don't know the property until it runs. */
+ | 'computed'
+/** The binding gets assigned to, and props are read-only, so it can't become a member. */
+ | 'reassigned'
+/** An inner scope binds the same name, so a use site could mean either one. */
+ | 'shadowed'
+/**
+ * A default we can't re-run on every read: a function hands out a new identity each
+ * time, a call runs its side effect each time.
+ */
+ | 'unsafe-default';
+export interface PropsRead {
+    /** The local name the pattern introduced. */
+    name: string;
+    /** Property path to read through instead: `['user', 'name']` for `{ user: { name } }`. */
+    path: string[];
+    /**
+     * Default from the pattern. JS only applies one for `undefined`, not for null, so
+     * codegen has to test `=== undefined` rather than reach for `??`, and re-run it on
+     * every read.
+     */
+    fallback?: Node;
+}
+export interface DestructurePlan {
+    /** Bindings we can rewrite to a property read. */
+    reads: PropsRead[];
+    /** Bindings we left alone, with the reason to report. */
+    bails: {
+        name: string;
+        reason: DestructureBail;
+    }[];
+    /**
+     * A `...rest`, and the keys it has to exclude.
+     *
+     * This is what splitProps is for: it copies the getters across rather than reading
+     * them, which is the reason a plain `...rest` can't be rewritten. So instead of
+     * refusing the pattern, we write the splitProps call the author would have written.
+     */
+    rest?: {
+        name: string;
+        keys: string[];
+    };
+}
+/**
+ * Plan one props pattern. `pattern` is the ObjectPattern, `body` the function body its
+ * bindings live in. Every binding ends up in `reads` (rewrite it) or `bails` (leave it
+ * and say why).
+ */
+export declare function planPropsDestructure(pattern: Node, body: Node | null | undefined): DestructurePlan;
+/** Reason text for the diagnostic. */
+export declare function explainBail(reason: DestructureBail): string;
+export {};

package/dist/analyze/props-destructure.d.ts

@@ -15,7 +15,7 @@
  * that I leave as written and report, so splitProps stays correct where it's still the
  * right answer.
  *
- * No babel in here (see no-babel-in-core.spec.ts) — nodes are read structurally, the way
+ * No babel in here (see no-babel-in-core.spec.ts), nodes are read structurally, the way
  * transform/bindings.ts does, so either front-end can drive it.
  */
 interface Node {
@@ -29,7 +29,7 @@ export type DestructureBail =
  * block to put the splitProps call in (`({ a, ...rest }) => …`).
  */
 'rest'
-/** `const { [key]: a } = props` — we don't know the property until it runs. */
+/** `const { [key]: a } = props`: we don't know the property until it runs. */
  | 'computed'
 /** The binding gets assigned to, and props are read-only, so it can't become a member. */
  | 'reassigned'
@@ -43,7 +43,7 @@ export type DestructureBail =
 export interface PropsRead {
     /** The local name the pattern introduced. */
     name: string;
-    /** Property path to read through instead — `['user', 'name']` for `{ user: { name } }`. */
+    /** Property path to read through instead: `['user', 'name']` for `{ user: { name } }`. */
     path: string[];
     /**
      * Default from the pattern. JS only applies one for `undefined`, not for null, so

package/dist/analyze/props-destructure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"props-destructure.d.ts","sourceRoot":"","sources":["../../src/analyze/props-destructure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,UAAU,IAAI;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,yFAAyF;AACzF,MAAM,MAAM,eAAe;AACzB;;;GAGG;AACD,MAAM;AACR,+EAA+E;GAC7E,UAAU;AACZ,0FAA0F;GACxF,YAAY;AACd,+EAA+E;GAC7E,UAAU;AACZ;;;GAGG;GACD,gBAAgB,CAAC;AAErB,MAAM,WAAW,SAAS;IACxB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,2FAA2F;IAC3F,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,yDAAyD;IACzD,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,eAAe,CAAA;KAAE,EAAE,CAAC;IACnD;;;;;;OAMG;IACH,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CACzC;AAoLD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,CAgDlG;AAED,sCAAsC;AACtC,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAa3D"}
+{"version":3,"file":"props-destructure.d.ts","sourceRoot":"","sources":["../../src/analyze/props-destructure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,UAAU,IAAI;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,yFAAyF;AACzF,MAAM,MAAM,eAAe;AACzB;;;GAGG;AACD,MAAM;AACR,8EAA8E;GAC5E,UAAU;AACZ,0FAA0F;GACxF,YAAY;AACd,+EAA+E;GAC7E,UAAU;AACZ;;;GAGG;GACD,gBAAgB,CAAC;AAErB,MAAM,WAAW,SAAS;IACxB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,yDAAyD;IACzD,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,eAAe,CAAA;KAAE,EAAE,CAAC;IACnD;;;;;;OAMG;IACH,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CACzC;AAoLD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,CAgDlG;AAED,sCAAsC;AACtC,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAa3D"}

package/dist/analyze/props-destructure.js

@@ -15,7 +15,7 @@
  * that I leave as written and report, so splitProps stays correct where it's still the
  * right answer.
  *
- * No babel in here (see no-babel-in-core.spec.ts) — nodes are read structurally, the way
+ * No babel in here (see no-babel-in-core.spec.ts), nodes are read structurally, the way
  * transform/bindings.ts does, so either front-end can drive it.
  */
 /** Every name a pattern introduces, so we can check each one for shadowing and writes. */
@@ -48,8 +48,8 @@ function patternNames(node, out) {
 }
 /**
  * Defaults get re-run on every read now, so they have to be cheap and stable. Literals
- * and identifiers are. A function isn't — it hands out a new identity each read, which
- * breaks anything comparing props — and neither is a call.
+ * and identifiers are. A function isn't: it hands out a new identity each read, which
+ * breaks anything comparing props: and neither is a call.
  */
 function isSafeDefault(node) {
     switch (node.type) {
@@ -94,7 +94,7 @@ function walk(root, visit) {
         }
     }
 }
-/** Anything written to in the body — `name = x`, `name++`, `[name] = …`. */
+/** Anything written to in the body: `name = x`, `name++`, `[name] = …`. */
 function reassignedNames(body) {
     const written = new Set();
     walk(body, (node) => {