langsys-js-react 0.6.7 → 0.7.0

package/dist/vite.mjs

@@ -0,0 +1,621 @@
+import { transformAsync } from '@babel/core';
+import { derivePlaceholderNames, NON_TRANSLATABLE_ELEMENTS, stripC0Controls, TRANSLATABLE_ATTRIBUTES } from 'langsys-js-typescript/pure';
+
+// src/transform/run.ts
+function unwrap(e) {
+  let n = e;
+  while (n.type === "TSAsExpression" || n.type === "TSNonNullExpression" || n.type === "TSSatisfiesExpression" || n.type === "TSTypeAssertion" || n.type === "ParenthesizedExpression") {
+    n = n.expression;
+  }
+  return n;
+}
+function segments(e) {
+  const n = unwrap(e);
+  if (n.type === "Identifier") return [n.name];
+  if (n.type === "ThisExpression") return [];
+  if (n.type === "MemberExpression" || n.type === "OptionalMemberExpression") {
+    if (n.computed || n.property.type !== "Identifier") return null;
+    const head = segments(n.object);
+    return head ? [...head, n.property.name] : null;
+  }
+  return null;
+}
+function shapeOf(e) {
+  const n = unwrap(e);
+  if (n.type === "Identifier") return { identifier: n.name };
+  if (n.type === "MemberExpression" || n.type === "OptionalMemberExpression") {
+    const segs = segments(n);
+    return segs && segs.length ? { member: segs } : { other: "computed" };
+  }
+  if (n.type === "CallExpression" || n.type === "OptionalCallExpression") {
+    const args = n.arguments;
+    if (args.some((x) => x.type === "SpreadElement" || x.type === "ArgumentPlaceholder")) return { other: "call-multi" };
+    const callee = segments(n.callee);
+    return { call: { callee: callee ? callee.join(".") : "", args: args.map((x) => shapeOf(x)) } };
+  }
+  if (n.type === "BinaryExpression" || n.type === "LogicalExpression") return { other: "binary" };
+  if (n.type === "ConditionalExpression") return { other: "conditional" };
+  if (n.type === "TemplateLiteral") return { other: "template" };
+  return { other: n.type };
+}
+function derivable(shape) {
+  if ("identifier" in shape || "member" in shape) return true;
+  if ("call" in shape) return shape.call.args.length === 1 && derivable(shape.call.args[0]);
+  return false;
+}
+function nameAll(expressions, taken = []) {
+  const explicit = [...taken];
+  const shapes = expressions.map((x) => shapeOf(x.expression));
+  const names = derivePlaceholderNames([
+    ...explicit.map((name) => ({ shape: { other: "explicit" }, explicit: name })),
+    ...shapes.map((shape) => ({ shape }))
+  ]).slice(explicit.length);
+  return expressions.map((x, i) => ({ ...x, name: names[i], unnameable: !derivable(shapes[i]) }));
+}
+
+// src/transform/babel.ts
+var SOURCE = "langsys-js-react";
+var TARGETS = /* @__PURE__ */ new Set(["Translate", "Phrase"]);
+var VERBATIM = "DontTranslate";
+var RAW_TEXT = /* @__PURE__ */ new Set(["script", "style", "plaintext"]);
+var TEXT_ONLY = /* @__PURE__ */ new Set(["textarea", "title", "option"]);
+var VALUE_ELEMENTS = /* @__PURE__ */ new Set(["button"]);
+var VALUE_INPUT_TYPES = /* @__PURE__ */ new Set(["submit", "button"]);
+var UNNAMED = "data-ls-unnamed";
+var EXPLICIT = /%([A-Za-z_][A-Za-z0-9_]*)%/g;
+var BRACED = /\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*[,}]/g;
+function langsysPlaceholders({ types: T }) {
+  const sourceOf = (state, node) => state.file.code.slice(node.start ?? 0, node.end ?? 0);
+  const warn = (state, n) => {
+    if (!n.unnameable) return;
+    const loc = n.expression.loc?.start;
+    state.meta.warnings.push({ line: loc?.line ?? null, column: loc?.column ?? null, source: n.source, name: n.name });
+  };
+  const explicitNames = (texts, params, written = EXPLICIT) => {
+    const out = /* @__PURE__ */ new Set();
+    for (const s of texts) for (const m of s.matchAll(written)) out.add(m[1]);
+    if (params && params.type === "ObjectExpression") {
+      for (const p of params.properties) {
+        if (p.type === "ObjectProperty" && !p.computed) {
+          if (p.key.type === "Identifier") out.add(p.key.name);
+          else if (p.key.type === "StringLiteral") out.add(p.key.value);
+        }
+      }
+    }
+    return out;
+  };
+  const optOut = (tag, opening) => {
+    if (NON_TRANSLATABLE_ELEMENTS.includes(tag)) return "shown";
+    let unknown = false;
+    for (const a of opening.attributes) {
+      if (a.type !== "JSXAttribute" || a.name.type !== "JSXIdentifier") continue;
+      if (a.name.name !== "translate" && a.name.name !== "data-notrans") continue;
+      const text = attributeText(a);
+      if (text === void 0) unknown = true;
+      else if (a.name.name === "translate" ? text.toLowerCase() === "no" : !["false", "0"].includes(text.trim().toLowerCase())) {
+        return "shown";
+      }
+    }
+    return unknown ? "unknown" : null;
+  };
+  const readsAsText = (tag, opening, name) => {
+    if (TRANSLATABLE_ATTRIBUTES.includes(name)) return true;
+    if (name !== "value") return false;
+    if (VALUE_ELEMENTS.has(tag)) return true;
+    if (tag !== "input") return false;
+    let type = "";
+    for (const a of opening.attributes) {
+      if (a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "type") type = attributeText(a);
+    }
+    return type === void 0 ? void 0 : VALUE_INPUT_TYPES.has(type.toLowerCase());
+  };
+  const isChildren = (e) => {
+    while (e.type === "TSAsExpression" || e.type === "TSSatisfiesExpression" || e.type === "TSNonNullExpression" || e.type === "TSTypeAssertion" || e.type === "ParenthesizedExpression") {
+      e = e.expression;
+    }
+    return e.type === "Identifier" && e.name === "children" || (e.type === "MemberExpression" || e.type === "OptionalMemberExpression") && !e.computed && e.property.type === "Identifier" && e.property.name === "children";
+  };
+  const holdsJsx = (e) => {
+    let jsx = false;
+    T.traverseFast(e, (n) => {
+      if (n.type === "JSXElement" || n.type === "JSXFragment") jsx = true;
+    });
+    return jsx;
+  };
+  const literalOf = (e) => e.type === "StringLiteral" || e.type === "NumericLiteral" ? String(e.value) : e.type === "TemplateLiteral" && !e.expressions.length ? e.quasis[0].value.cooked ?? void 0 : void 0;
+  const isFragment = (state, name) => name.type === "JSXIdentifier" && state.fragments.has(name.name) || name.type === "JSXMemberExpression" && name.object.type === "JSXIdentifier" && state.reactModules.has(name.object.name) && name.property.name === "Fragment";
+  const staticTexts = (unit) => {
+    const out = [];
+    for (const child of unit.children) {
+      T.traverseFast(child, (n) => {
+        if (n.type === "JSXText" || n.type === "StringLiteral") out.push(n.value);
+        else if (n.type === "TemplateElement") out.push(n.value.cooked ?? n.value.raw);
+      });
+    }
+    return out;
+  };
+  const holdsMarker = (node) => {
+    let found = false;
+    T.traverseFast(node, (n) => {
+      if (n.type === "JSXOpeningElement" && marks(n)) found = true;
+    });
+    return found;
+  };
+  const markedNames = (unit) => {
+    const out = /* @__PURE__ */ new Set();
+    for (const child of unit.children) {
+      T.traverseFast(child, (n) => {
+        if (n.type !== "JSXAttribute" || n.name.type !== "JSXIdentifier" || n.name.name !== "data-ls-param") return;
+        const name = n.value ? attributeText(n) : void 0;
+        if (name) out.add(name.trim());
+      });
+    }
+    return out;
+  };
+  const marks = (opening) => opening.attributes.some(
+    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "data-ls-param"
+  );
+  const attributeText = (a) => {
+    const v = a.value;
+    if (!v) return "";
+    if (v.type === "StringLiteral") return v.value;
+    if (v.type === "JSXExpressionContainer" && v.expression.type === "StringLiteral") return v.expression.value;
+    return void 0;
+  };
+  const marker = (name, expression) => T.jsxElement(
+    T.jsxOpeningElement(T.jsxIdentifier("span"), [
+      T.jsxAttribute(T.jsxIdentifier("data-ls-param"), T.stringLiteral(name))
+    ]),
+    T.jsxClosingElement(T.jsxIdentifier("span")),
+    [T.jsxExpressionContainer(expression)]
+  );
+  const asRendered = (text) => {
+    const [s] = T.react.buildChildren(
+      T.jsxElement(T.jsxOpeningElement(T.jsxIdentifier("x"), []), T.jsxClosingElement(T.jsxIdentifier("x")), [text])
+    );
+    return s?.type === "StringLiteral" ? s.value : "";
+  };
+  const placeholderAfter = (before, name) => {
+    const open = (text) => /%[A-Za-z_][A-Za-z0-9_]*$/.test(text.replace(EXPLICIT, "\0"));
+    return open(before) || open(stripC0Controls(before)) ? `{${name}}` : `%${name}%`;
+  };
+  const textNode = (value) => {
+    if (/[\r\n\t\u2028\u2029]/.test(value)) return T.jsxExpressionContainer(T.stringLiteral(value));
+    const node = T.jsxText(value);
+    node.extra = { raw: value.replace(/[&<>{}]/g, (c) => `&#${c.charCodeAt(0)};`), rawValue: value };
+    return node;
+  };
+  const placeholders = (named) => {
+    const seen = /* @__PURE__ */ new Set();
+    return named.filter((n) => !seen.has(n.name) && seen.add(n.name));
+  };
+  const mergeParams = (existing, named) => {
+    const props = named.map((n) => T.objectProperty(T.identifier(n.name), n.expression));
+    if (!existing) return T.objectExpression(props);
+    if (existing.type === "ObjectExpression") return T.objectExpression([...existing.properties, ...props]);
+    return T.objectExpression([T.spreadElement(existing), ...props]);
+  };
+  function rewriteTarget(path, state) {
+    const found = [];
+    const tag = path.node.openingElement.name;
+    const isPhrase = tag.type === "JSXIdentifier" && state.phrases.has(tag.name);
+    let unnamed = false;
+    let markAll = false;
+    const asWritten = /* @__PURE__ */ new WeakSet();
+    const placeholderNames = /* @__PURE__ */ new WeakMap();
+    const written = (value) => {
+      const node = T.jsxText(value);
+      asWritten.add(node);
+      return node;
+    };
+    const touched = /* @__PURE__ */ new Set();
+    const settle = (children) => {
+      const out = [];
+      let run = "";
+      for (const c of children) {
+        if (c.type === "JSXText") {
+          const name = placeholderNames.get(c);
+          run += name !== void 0 ? placeholderAfter(run, name) : asWritten.has(c) ? c.value : asRendered(c);
+        } else if (c.type === "JSXExpressionContainer" && c.expression.type === "JSXEmptyExpression") continue;
+        else {
+          if (run) out.push(textNode(run));
+          run = "";
+          out.push(c);
+        }
+      }
+      if (run) out.push(textNode(run));
+      children.splice(0, children.length, ...out);
+    };
+    const unwrap2 = (children) => {
+      for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === "JSXFragment" || c.type === "JSXElement" && isFragment(state, c.openingElement.name)) {
+          children.splice(i--, 1, ...c.children);
+          touched.add(children);
+        }
+      }
+    };
+    const aloneInRun = (children, i) => {
+      for (const step of [-1, 1]) {
+        for (let j = i + step; j >= 0 && j < children.length; j += step) {
+          const d = children[j];
+          if (d.type === "JSXElement" || d.type === "JSXFragment") break;
+          if (d.type === "JSXText") {
+            if ((asWritten.has(d) ? d.value : asRendered(d)).trim()) return false;
+            continue;
+          }
+          if (d.type === "JSXSpreadChild") return false;
+          const x = d.expression;
+          if (x.type === "JSXEmptyExpression") continue;
+          const literal = literalOf(x);
+          if (literal !== void 0) {
+            if (literal.trim()) return false;
+            continue;
+          }
+          if (holdsJsx(x)) break;
+          return false;
+        }
+      }
+      return true;
+    };
+    const attributes = (opening, tag2, mode) => {
+      if (mode === "shown") return;
+      for (const a of opening.attributes) {
+        if (a.type !== "JSXAttribute" || a.name.type !== "JSXIdentifier" || a.value?.type !== "JSXExpressionContainer") continue;
+        const e = a.value.expression;
+        if (e.type === "JSXEmptyExpression" || literalOf(e) !== void 0) continue;
+        if (e.type === "LogicalExpression" || e.type === "ConditionalExpression" || holdsJsx(e)) continue;
+        const reads = readsAsText(tag2, opening, a.name.name);
+        if (reads === false) continue;
+        if (reads === void 0 || mode === "unknown") {
+          unnamed = true;
+          continue;
+        }
+        const parts = pieces(e) ?? [e];
+        const inTemplate = /* @__PURE__ */ new WeakSet();
+        T.traverseFast(e, (n) => {
+          if (n.type === "TemplateLiteral") n.expressions.forEach((x) => inTemplate.add(x));
+        });
+        const names = [];
+        const attr = a;
+        parts.forEach((p, k) => {
+          if (typeof p === "string") return;
+          found.push({
+            source: sourceOf(state, p),
+            expression: p,
+            param: true,
+            bare: false,
+            text: p === e ? void 0 : inTemplate.has(p) ? T.templateLiteral([T.templateElement({ raw: "" }), T.templateElement({ raw: "" }, true)], [p]) : T.binaryExpression("+", T.stringLiteral(""), p),
+            replace: (name) => {
+              names[k] = name;
+              const value = parts.reduce((out, q, j) => out + (typeof q === "string" ? q : placeholderAfter(out, names[j] ?? "")), "");
+              attr.value = T.jsxExpressionContainer(T.stringLiteral(value));
+            }
+          });
+        });
+      }
+    };
+    const walk = (children, where) => {
+      unwrap2(children);
+      children.forEach((c, i) => {
+        if (c.type === "JSXExpressionContainer") {
+          const e = c.expression;
+          if (e.type === "JSXEmptyExpression") {
+            touched.add(children);
+            return;
+          }
+          const literal = literalOf(e);
+          if (literal !== void 0) {
+            children[i] = written(literal);
+            touched.add(children);
+            return;
+          }
+          if (e.type === "JSXElement" || e.type === "JSXFragment" || e.type === "LogicalExpression" || e.type === "ConditionalExpression" || holdsJsx(e) || where.mode === "text" && isChildren(e) && aloneInRun(children, i)) {
+            if (isPhrase && where.mode === "text" && holdsMarker(e)) markAll = true;
+            return;
+          }
+          if (where.mode !== "text" && where.markerless) {
+            if (!isPhrase) unnamed = true;
+            return;
+          }
+          touched.add(children);
+          found.push({
+            source: sourceOf(state, e),
+            expression: e,
+            param: where.mode !== "shown",
+            bare: where.mode === "text" && where.markerless,
+            replace: (name) => {
+              if (where.mode !== "text" || markAll) {
+                children[i] = marker(name, e);
+                return;
+              }
+              const text = written(`%${name}%`);
+              placeholderNames.set(text, name);
+              children[i] = text;
+            }
+          });
+        } else if (c.type === "JSXElement") {
+          const n = c.openingElement.name;
+          if (n.type !== "JSXIdentifier" || /^[A-Z]/.test(n.name) && !state.verbatim.has(n.name)) {
+            if (isPhrase && where.mode === "text" && holdsMarker(c)) markAll = true;
+            return;
+          }
+          if (/^[a-z]/.test(n.name)) {
+            if (RAW_TEXT.has(n.name)) {
+              const value = (d) => d.type === "JSXExpressionContainer" && d.expression.type !== "JSXEmptyExpression" && literalOf(d.expression) === void 0;
+              if (!isPhrase && c.children.some(value)) unnamed = true;
+              return;
+            }
+            if (marks(c.openingElement)) {
+              if (isPhrase && where.mode === "text") markAll = true;
+              return;
+            }
+            const opt = optOut(n.name, c.openingElement);
+            const mode = where.mode === "shown" || opt === "shown" ? "shown" : !isPhrase && (where.mode === "unknown" || opt === "unknown") ? "unknown" : "text";
+            const foreign = n.name === "math" || n.name === "svg" ? n.name : where.foreign === "svg" && n.name === "foreignObject" ? null : where.foreign;
+            if (!isPhrase) attributes(c.openingElement, n.name, mode);
+            walk(c.children, { mode, foreign, markerless: foreign !== null || TEXT_ONLY.has(n.name) });
+          } else if (state.verbatim.has(n.name)) walk(c.children, { ...where, mode: "shown" });
+        }
+      });
+    };
+    walk(path.node.children, { mode: "text", foreign: null, markerless: false });
+    if (markAll && found.some((f) => f.bare)) {
+      unnamed = true;
+      for (let i = found.length - 1; i >= 0; i--) if (found[i].bare) found.splice(i, 1);
+    }
+    const attrs = path.node.openingElement.attributes;
+    if (unnamed && !attrs.some((a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === UNNAMED)) {
+      attrs.push(T.jsxAttribute(T.jsxIdentifier(UNNAMED), T.stringLiteral("")));
+    }
+    if (!found.length) {
+      touched.forEach(settle);
+      if (unnamed || touched.size) state.meta.rewritten++;
+      return;
+    }
+    const existing = attrs.find(
+      (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "params"
+    );
+    const existingExpr = existing?.value?.type === "JSXExpressionContainer" && existing.value.expression.type !== "JSXEmptyExpression" ? existing.value.expression : null;
+    const named = nameAll(found, /* @__PURE__ */ new Set([...explicitNames(staticTexts(path.node), existingExpr), ...markedNames(path.node)]));
+    found.forEach((f, i) => f.replace(named[i].name));
+    placeholders(named).forEach((n) => warn(state, n));
+    const params = placeholders(named.filter((_, i) => found[i].param)).map((n) => {
+      const uses = found.filter((f, i) => f.param && named[i].name === n.name);
+      const given = uses.find((f) => !f.text);
+      return { ...n, expression: given ? given.expression : uses[0].text };
+    });
+    touched.forEach(settle);
+    if (params.length) {
+      const value = T.jsxExpressionContainer(mergeParams(existingExpr, params));
+      if (existing) existing.value = value;
+      else attrs.push(T.jsxAttribute(T.jsxIdentifier("params"), value));
+    }
+    state.meta.rewritten++;
+  }
+  function pieces(node) {
+    if (node.type === "TemplateLiteral") {
+      const out = [];
+      node.quasis.forEach((q, i) => {
+        if (q.value.cooked) out.push(q.value.cooked);
+        if (i < node.expressions.length) out.push(node.expressions[i]);
+      });
+      return node.expressions.length ? out : null;
+    }
+    if (node.type !== "BinaryExpression" || node.operator !== "+") return null;
+    const spine = [];
+    for (let n = node; n.type === "BinaryExpression" && n.operator === "+"; n = n.left) spine.push(n);
+    const operands = [spine[spine.length - 1].left, ...spine.map((s) => s.right).reverse()];
+    const first = operands.findIndex((o) => o.type === "StringLiteral" || o.type === "TemplateLiteral");
+    if (first < 0) return null;
+    const flat = [];
+    if (first === 1) flat.push(operands[0]);
+    else if (first > 1) flat.push(spine[spine.length - (first - 1)]);
+    for (const o of operands.slice(first)) {
+      if (o.type === "StringLiteral") flat.push(o.value);
+      else if (o.type === "TemplateLiteral") flat.push(...pieces(o) ?? [o.quasis[0].value.cooked ?? ""]);
+      else flat.push(o);
+    }
+    return flat.some((p) => typeof p !== "string") ? flat : null;
+  }
+  const isKeyShaped = (parts) => parts.every((p) => typeof p !== "string" || /^[A-Za-z0-9_.:-]*$/.test(p));
+  const secondArgument = (second, third) => {
+    if (!second) return "category";
+    if (second.type === "ObjectExpression" || second.type === "NullLiteral") return "params";
+    if (second.type === "StringLiteral" || second.type === "TemplateLiteral") return "category";
+    if (second.type === "Identifier" && second.name === "undefined") return "category";
+    if (second.type === "CallExpression" && second.callee.type === "Identifier" && second.callee.name === "inCategory") return "category";
+    return third ? "category" : "unknown";
+  };
+  const decidedAtRuntime = (params, second) => {
+    const a = T.identifier("a");
+    const p = T.identifier("p");
+    const isRef = T.logicalExpression(
+      "&&",
+      T.binaryExpression("!==", a, T.nullLiteral()),
+      T.binaryExpression(
+        "===",
+        T.memberExpression(a, T.callExpression(T.memberExpression(T.identifier("Symbol"), T.identifier("for")), [T.stringLiteral("langsys.category")]), true),
+        T.booleanLiteral(true)
+      )
+    );
+    const isParams = T.logicalExpression("&&", T.binaryExpression("===", T.unaryExpression("typeof", a), T.stringLiteral("object")), T.unaryExpression("!", isRef));
+    const pick = T.arrowFunctionExpression(
+      [p, a],
+      T.conditionalExpression(isParams, T.arrayExpression([T.objectExpression([T.spreadElement(a), T.spreadElement(p)])]), T.arrayExpression([a, p]))
+    );
+    return T.spreadElement(T.callExpression(pick, [params, second]));
+  };
+  function rewriteCall(path, state) {
+    const [phrase, second, third] = path.node.arguments;
+    if (!phrase || phrase.type === "SpreadElement" || phrase.type === "ArgumentPlaceholder") return;
+    const parts = pieces(phrase);
+    if (!parts || isKeyShaped(parts)) return;
+    if (second?.type === "SpreadElement" || second?.type === "ArgumentPlaceholder") return;
+    if (third?.type === "SpreadElement" || third?.type === "ArgumentPlaceholder") return;
+    const values = parts.filter((p) => typeof p !== "string").map((e) => ({ source: sourceOf(state, e), expression: e }));
+    const kind = secondArgument(second, third);
+    const paramsExpr = kind === "category" ? third ?? null : second.type === "NullLiteral" ? null : second;
+    const unread = !!paramsExpr && (paramsExpr.type !== "ObjectExpression" || paramsExpr.properties.some((p) => p.type !== "ObjectProperty" || p.computed));
+    const written = unread ? parts.filter((p) => typeof p === "string") : [];
+    const named = nameAll(values, explicitNames(written, paramsExpr, BRACED));
+    let next = 0;
+    const text = parts.map((p) => typeof p === "string" ? p : `{${named[next++].name}}`).join("");
+    const unique = placeholders(named);
+    unique.forEach((n) => warn(state, n));
+    const rest = path.node.arguments.slice(kind === "category" ? 3 : 2);
+    path.node.arguments = [
+      T.stringLiteral(text),
+      ...kind === "category" ? [second ?? T.identifier("undefined"), mergeParams(paramsExpr, unique)] : kind === "params" ? [mergeParams(paramsExpr, unique)] : [decidedAtRuntime(mergeParams(null, unique), second)],
+      ...rest
+    ];
+    state.meta.rewritten++;
+  }
+  const isBound = (path, name, bindings) => {
+    const b = path.scope.getBinding(name);
+    return !!b && bindings.has(b.identifier);
+  };
+  return {
+    name: "langsys-placeholders",
+    pre(file) {
+      this.meta = { warnings: [], rewritten: 0 };
+      file.metadata.langsys = this.meta;
+      this.targets = /* @__PURE__ */ new Set();
+      this.phrases = /* @__PURE__ */ new Set();
+      this.hooks = /* @__PURE__ */ new Set();
+      this.targetBindings = /* @__PURE__ */ new Set();
+      this.hookBindings = /* @__PURE__ */ new Set();
+      this.tBindings = /* @__PURE__ */ new Set();
+      this.verbatim = /* @__PURE__ */ new Set();
+      this.fragments = /* @__PURE__ */ new Set();
+      this.reactModules = /* @__PURE__ */ new Set();
+    },
+    visitor: {
+      Program(program, state) {
+        for (const stmt of program.node.body) {
+          if (stmt.type === "ImportDeclaration" && stmt.source.value === "react") {
+            for (const s of stmt.specifiers) {
+              if (s.type !== "ImportSpecifier") state.reactModules.add(s.local.name);
+              else if ((s.imported.type === "Identifier" ? s.imported.name : s.imported.value) === "Fragment") {
+                state.fragments.add(s.local.name);
+              }
+            }
+          }
+          if (stmt.type !== "ImportDeclaration" || stmt.source.value !== SOURCE) continue;
+          for (const s of stmt.specifiers) {
+            if (s.type !== "ImportSpecifier") continue;
+            const imported = s.imported.type === "Identifier" ? s.imported.name : s.imported.value;
+            if (TARGETS.has(imported)) state.targets.add(s.local.name);
+            if (imported === "Phrase") state.phrases.add(s.local.name);
+            if (imported === "useT") state.hooks.add(s.local.name);
+            if (imported === VERBATIM) state.verbatim.add(s.local.name);
+          }
+        }
+        if (!state.targets.size && !state.hooks.size) return;
+        const bind = (names, into) => names.forEach((name) => {
+          const b = program.scope.getBinding(name);
+          if (b) into.add(b.identifier);
+        });
+        bind(state.targets, state.targetBindings);
+        bind(state.hooks, state.hookBindings);
+        program.traverse({
+          VariableDeclarator(d) {
+            const init = d.node.init;
+            if (d.node.id.type === "Identifier" && init?.type === "CallExpression" && init.callee.type === "Identifier" && isBound(d, init.callee.name, state.hookBindings)) {
+              const b = d.scope.getBinding(d.node.id.name);
+              if (b) state.tBindings.add(b.identifier);
+            }
+          }
+        });
+      },
+      JSXElement(path, state) {
+        const n = path.node.openingElement.name;
+        if (n.type === "JSXIdentifier" && isBound(path, n.name, state.targetBindings)) rewriteTarget(path, state);
+      },
+      CallExpression(path, state) {
+        const callee = path.node.callee;
+        const isT = callee.type === "Identifier" && isBound(path, callee.name, state.tBindings) || callee.type === "CallExpression" && callee.callee.type === "Identifier" && isBound(path, callee.callee.name, state.hookBindings);
+        if (isT) rewriteCall(path, state);
+      }
+    }
+  };
+}
+
+// src/transform/run.ts
+var SCRIPT = /\.(?:[cm]?[jt]sx?)$/;
+function syntaxes(isTs, isJsx) {
+  const base = [...isJsx ? ["jsx"] : [], ...isTs ? ["typescript"] : []];
+  const out = [
+    [...base, "decorators-legacy", "decoratorAutoAccessors"],
+    [...base, ["decorators", {}], "decoratorAutoAccessors"]
+  ];
+  if (!isTs) out.push([...base, "flow", "decorators-legacy"]);
+  return out;
+}
+function wants(code, filename) {
+  const file = filename.split("?")[0];
+  return SCRIPT.test(file) && !file.includes("/node_modules/") && code.includes("langsys-js-react");
+}
+async function transformSource(code, filename, sourceMaps = true) {
+  if (!wants(code, filename)) return null;
+  const file = filename.split("?")[0];
+  const isTs = /\.[cm]?tsx?$/.test(file);
+  const isJsx = /x$/.test(file) || /\.[cm]?js$/.test(file);
+  let out = null;
+  let unparsed = null;
+  for (const plugins of syntaxes(isTs, isJsx)) {
+    try {
+      out = await transformAsync(code, {
+        filename: file,
+        babelrc: false,
+        configFile: false,
+        sourceMaps,
+        plugins: [langsysPlaceholders],
+        parserOpts: { plugins },
+        generatorOpts: { retainLines: false }
+      });
+      unparsed = null;
+      break;
+    } catch (err) {
+      if (err.code !== "BABEL_PARSE_ERROR") throw err;
+      unparsed ??= err;
+    }
+  }
+  if (unparsed) {
+    const reason = unparsed.message.replace(`${file}: `, "").split("\n")[0];
+    return {
+      code: null,
+      map: null,
+      warnings: [
+        `langsys: ${file} \u2014 Babel could not parse it (${reason}), so it is left as written and the values in its <Translate>, <Phrase> and t() calls are not made placeholders.`
+      ]
+    };
+  }
+  const meta = out?.metadata?.langsys;
+  if (!out?.code || !meta || meta.rewritten === 0) return null;
+  return {
+    code: out.code,
+    map: out.map ?? null,
+    warnings: meta.warnings.map(
+      (w) => `langsys: ${file}${w.line ? `:${w.line}:${(w.column ?? 0) + 1}` : ""} \u2014 no placeholder name can be derived from \`${w.source}\`, so it is named {${w.name}}. Give it a name with %name% and params.`
+    )
+  };
+}
+
+// src/transform/vite.ts
+function langsys() {
+  return {
+    name: "langsys-placeholders",
+    enforce: "pre",
+    async transform(code, id) {
+      const out = await transformSource(code, id);
+      if (!out) return null;
+      for (const w of out.warnings) this.warn(w);
+      return out.code === null ? null : { code: out.code, map: out.map };
+    }
+  };
+}
+
+export { langsys as default };
+//# sourceMappingURL=vite.mjs.map
+//# sourceMappingURL=vite.mjs.map