@lingui/macro 4.8.0-next.0 → 4.8.0-next.1

package/dist/shared/macro.0c5d598c.mjs

@@ -0,0 +1,1059 @@
+import { isJSXEmptyExpression } from '@babel/types';
+import { generateMessageId } from '@lingui/message-utils/generateMessageId';
+import { getConfig as getConfig$1 } from '@lingui/conf';
+
+const metaOptions = ["id", "comment", "props"];
+const escapedMetaOptionsRe = new RegExp(`^_(${metaOptions.join("|")})$`);
+class ICUMessageFormat {
+  fromTokens(tokens) {
+    return (Array.isArray(tokens) ? tokens : [tokens]).map((token) => this.processToken(token)).filter(Boolean).reduce(
+      (props, message) => ({
+        ...message,
+        message: props.message + message.message,
+        values: { ...props.values, ...message.values },
+        jsxElements: { ...props.jsxElements, ...message.jsxElements }
+      }),
+      {
+        message: "",
+        values: {},
+        jsxElements: {}
+      }
+    );
+  }
+  processToken(token) {
+    const jsxElements = {};
+    if (token.type === "text") {
+      return {
+        message: token.value
+      };
+    } else if (token.type === "arg") {
+      if (token.value !== void 0 && isJSXEmptyExpression(token.value)) {
+        return null;
+      }
+      const values = token.value !== void 0 ? { [token.name]: token.value } : {};
+      switch (token.format) {
+        case "plural":
+        case "select":
+        case "selectordinal":
+          const formatOptions = Object.keys(token.options).filter((key) => token.options[key] != null).map((key) => {
+            let value = token.options[key];
+            key = key.replace(escapedMetaOptionsRe, "$1");
+            if (key === "offset") {
+              return `offset:${value}`;
+            }
+            if (typeof value !== "string") {
+              const {
+                message,
+                values: childValues,
+                jsxElements: childJsxElements
+              } = this.fromTokens(value);
+              Object.assign(values, childValues);
+              Object.assign(jsxElements, childJsxElements);
+              value = message;
+            }
+            return `${key} {${value}}`;
+          }).join(" ");
+          return {
+            message: `{${token.name}, ${token.format}, ${formatOptions}}`,
+            values,
+            jsxElements
+          };
+        default:
+          return {
+            message: `{${token.name}}`,
+            values
+          };
+      }
+    } else if (token.type === "element") {
+      let message = "";
+      let elementValues = {};
+      Object.assign(jsxElements, { [token.name]: token.value });
+      token.children.forEach((child) => {
+        const {
+          message: childMessage,
+          values: childValues,
+          jsxElements: childJsxElements
+        } = this.fromTokens(child);
+        message += childMessage;
+        Object.assign(elementValues, childValues);
+        Object.assign(jsxElements, childJsxElements);
+      });
+      return {
+        message: token.children.length ? `<${token.name}>${message}</${token.name}>` : `<${token.name}/>`,
+        values: elementValues,
+        jsxElements
+      };
+    }
+    throw new Error(`Unknown token type ${token.type}`);
+  }
+}
+
+const makeCounter = (index = 0) => () => index++;
+
+const ID = "id";
+const MESSAGE = "message";
+const COMMENT = "comment";
+const EXTRACT_MARK = "i18n";
+const CONTEXT = "context";
+const MACRO_PACKAGE = "@lingui/macro";
+var JsMacroName = /* @__PURE__ */ ((JsMacroName2) => {
+  JsMacroName2["t"] = "t";
+  JsMacroName2["plural"] = "plural";
+  JsMacroName2["select"] = "select";
+  JsMacroName2["selectOrdinal"] = "selectOrdinal";
+  JsMacroName2["msg"] = "msg";
+  JsMacroName2["defineMessage"] = "defineMessage";
+  JsMacroName2["useLingui"] = "useLingui";
+  return JsMacroName2;
+})(JsMacroName || {});
+var JsxMacroName = /* @__PURE__ */ ((JsxMacroName2) => {
+  JsxMacroName2["Trans"] = "Trans";
+  JsxMacroName2["Plural"] = "Plural";
+  JsxMacroName2["Select"] = "Select";
+  JsxMacroName2["SelectOrdinal"] = "SelectOrdinal";
+  return JsxMacroName2;
+})(JsxMacroName || {});
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const pluralRuleRe = /(_[\d\w]+|zero|one|two|few|many|other)/;
+const jsx2icuExactChoice = (value) => value.replace(/_(\d+)/, "=$1").replace(/_(\w+)/, "$1");
+const keepSpaceRe$1 = /\s*(?:\r\n|\r|\n)+\s*/g;
+const stripAroundTagsRe = /(?:([>}])(?:\r\n|\r|\n)+\s*|(?:\r\n|\r|\n)+\s*(?=[<{]))/g;
+function maybeNodeValue(node) {
+  if (!node)
+    return null;
+  if (node.type === "StringLiteral")
+    return node.value;
+  if (node.type === "JSXAttribute")
+    return maybeNodeValue(node.value);
+  if (node.type === "JSXExpressionContainer")
+    return maybeNodeValue(node.expression);
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0)
+    return node.quasis[0].value.raw;
+  return null;
+}
+function normalizeWhitespace$1(text) {
+  return text.replace(stripAroundTagsRe, "$1").replace(keepSpaceRe$1, " ").replace(/\\n/g, "\n").replace(/\\s/g, " ").replace(/(\s+})/gm, "}").replace(/({\s+)/gm, "{").trim();
+}
+class MacroJSX {
+  constructor({ types }, opts) {
+    __publicField$1(this, "types");
+    __publicField$1(this, "expressionIndex", makeCounter());
+    __publicField$1(this, "elementIndex", makeCounter());
+    __publicField$1(this, "stripNonEssentialProps");
+    __publicField$1(this, "transImportName");
+    __publicField$1(this, "createStringJsxAttribute", (name, value) => {
+      return this.types.jsxAttribute(
+        this.types.jsxIdentifier(name),
+        this.types.jsxExpressionContainer(this.types.stringLiteral(value))
+      );
+    });
+    __publicField$1(this, "replacePath", (path) => {
+      if (!path.isJSXElement()) {
+        return false;
+      }
+      const tokens = this.tokenizeNode(path, true, true);
+      if (!tokens) {
+        return false;
+      }
+      const messageFormat = new ICUMessageFormat();
+      const {
+        message: messageRaw,
+        values,
+        jsxElements
+      } = messageFormat.fromTokens(tokens);
+      const message = normalizeWhitespace$1(messageRaw);
+      const { attributes, id, comment, context } = this.stripMacroAttributes(
+        path
+      );
+      if (!id && !message) {
+        throw new Error("Incorrect usage of Trans");
+      }
+      if (id) {
+        attributes.push(
+          this.types.jsxAttribute(
+            this.types.jsxIdentifier(ID),
+            this.types.stringLiteral(id)
+          )
+        );
+      } else {
+        attributes.push(
+          this.createStringJsxAttribute(ID, generateMessageId(message, context))
+        );
+      }
+      if (!this.stripNonEssentialProps) {
+        if (message) {
+          attributes.push(this.createStringJsxAttribute(MESSAGE, message));
+        }
+        if (comment) {
+          attributes.push(
+            this.types.jsxAttribute(
+              this.types.jsxIdentifier(COMMENT),
+              this.types.stringLiteral(comment)
+            )
+          );
+        }
+        if (context) {
+          attributes.push(
+            this.types.jsxAttribute(
+              this.types.jsxIdentifier(CONTEXT),
+              this.types.stringLiteral(context)
+            )
+          );
+        }
+      }
+      const valuesObject = Object.keys(values).map(
+        (key) => this.types.objectProperty(this.types.identifier(key), values[key])
+      );
+      if (valuesObject.length) {
+        attributes.push(
+          this.types.jsxAttribute(
+            this.types.jsxIdentifier("values"),
+            this.types.jsxExpressionContainer(
+              this.types.objectExpression(valuesObject)
+            )
+          )
+        );
+      }
+      if (Object.keys(jsxElements).length) {
+        attributes.push(
+          this.types.jsxAttribute(
+            this.types.jsxIdentifier("components"),
+            this.types.jsxExpressionContainer(
+              this.types.objectExpression(
+                Object.keys(jsxElements).map(
+                  (key) => this.types.objectProperty(
+                    this.types.identifier(key),
+                    jsxElements[key]
+                  )
+                )
+              )
+            )
+          )
+        );
+      }
+      const newNode = this.types.jsxElement(
+        this.types.jsxOpeningElement(
+          this.types.jsxIdentifier(this.transImportName),
+          attributes,
+          true
+        ),
+        null,
+        [],
+        true
+      );
+      newNode.loc = path.node.loc;
+      return newNode;
+    });
+    __publicField$1(this, "attrName", (names, exclude = false) => {
+      const namesRe = new RegExp("^(" + names.join("|") + ")$");
+      return (attr) => {
+        const name = attr.name.name;
+        return exclude ? !namesRe.test(name) : namesRe.test(name);
+      };
+    });
+    __publicField$1(this, "stripMacroAttributes", (path) => {
+      const { attributes } = path.node.openingElement;
+      const id = attributes.find(this.attrName([ID]));
+      const message = attributes.find(this.attrName([MESSAGE]));
+      const comment = attributes.find(this.attrName([COMMENT]));
+      const context = attributes.find(this.attrName([CONTEXT]));
+      let reserved = [ID, MESSAGE, COMMENT, CONTEXT];
+      if (this.isChoiceComponent(path)) {
+        reserved = [
+          ...reserved,
+          "_\\w+",
+          "_\\d+",
+          "zero",
+          "one",
+          "two",
+          "few",
+          "many",
+          "other",
+          "value",
+          "offset"
+        ];
+      }
+      return {
+        id: maybeNodeValue(id),
+        message: maybeNodeValue(message),
+        comment: maybeNodeValue(comment),
+        context: maybeNodeValue(context),
+        attributes: attributes.filter(this.attrName(reserved, true))
+      };
+    });
+    __publicField$1(this, "tokenizeNode", (path, ignoreExpression = false, ignoreElement = false) => {
+      if (this.isTransComponent(path)) {
+        return this.tokenizeTrans(path);
+      }
+      const componentName = this.isChoiceComponent(path);
+      if (componentName) {
+        return [
+          this.tokenizeChoiceComponent(
+            path,
+            componentName
+          )
+        ];
+      }
+      if (path.isJSXElement() && !ignoreElement) {
+        return [this.tokenizeElement(path)];
+      }
+      if (!ignoreExpression) {
+        return [this.tokenizeExpression(path)];
+      }
+    });
+    __publicField$1(this, "tokenizeTrans", (path) => {
+      return path.get("children").flatMap((child) => this.tokenizeChildren(child)).filter(Boolean);
+    });
+    __publicField$1(this, "tokenizeChildren", (path) => {
+      if (path.isJSXExpressionContainer()) {
+        const exp = path.get("expression");
+        if (exp.isStringLiteral()) {
+          return [this.tokenizeText(exp.node.value.replace(/\n/g, "\\n"))];
+        }
+        if (exp.isTemplateLiteral()) {
+          return this.tokenizeTemplateLiteral(exp);
+        }
+        if (exp.isConditionalExpression()) {
+          return [this.tokenizeConditionalExpression(exp)];
+        }
+        if (exp.isJSXElement()) {
+          return this.tokenizeNode(exp);
+        }
+        return [this.tokenizeExpression(exp)];
+      } else if (path.isJSXElement()) {
+        return this.tokenizeNode(path);
+      } else if (path.isJSXSpreadChild()) ; else if (path.isJSXText()) {
+        return [this.tokenizeText(path.node.value)];
+      } else ;
+    });
+    __publicField$1(this, "tokenizeChoiceComponent", (path, componentName) => {
+      const element = path.get("openingElement");
+      const format = componentName.toLowerCase();
+      const props = element.get("attributes").filter((attr) => {
+        return this.attrName(
+          [
+            ID,
+            COMMENT,
+            MESSAGE,
+            CONTEXT,
+            "key",
+            // we remove <Trans /> react props that are not useful for translation
+            "render",
+            "component",
+            "components"
+          ],
+          true
+        )(attr.node);
+      });
+      const token = {
+        type: "arg",
+        format,
+        name: null,
+        value: void 0,
+        options: {
+          offset: void 0
+        }
+      };
+      for (const _attr of props) {
+        if (_attr.isJSXSpreadAttribute()) {
+          continue;
+        }
+        const attr = _attr;
+        if (this.types.isJSXNamespacedName(attr.node.name)) {
+          continue;
+        }
+        const name = attr.node.name.name;
+        const value = attr.get("value");
+        if (name === "value") {
+          const exp = value.isLiteral() ? value : value.get("expression");
+          token.name = this.expressionToArgument(exp);
+          token.value = exp.node;
+        } else if (format !== "select" && name === "offset") {
+          token.options.offset = value.isStringLiteral() || value.isNumericLiteral() ? value.node.value : value.get(
+            "expression"
+          ).node.value;
+        } else {
+          let option;
+          if (value.isStringLiteral()) {
+            option = value.node.extra.raw.replace(
+              /(["'])(.*)\1/,
+              "$2"
+            );
+          } else {
+            option = this.tokenizeChildren(value);
+          }
+          if (pluralRuleRe.test(name)) {
+            token.options[jsx2icuExactChoice(name)] = option;
+          } else {
+            token.options[name] = option;
+          }
+        }
+      }
+      return token;
+    });
+    __publicField$1(this, "tokenizeElement", (path) => {
+      const name = this.elementIndex();
+      return {
+        type: "element",
+        name,
+        value: {
+          ...path.node,
+          children: [],
+          openingElement: {
+            ...path.node.openingElement,
+            selfClosing: true
+          }
+        },
+        children: this.tokenizeTrans(path)
+      };
+    });
+    __publicField$1(this, "tokenizeExpression", (path) => {
+      return {
+        type: "arg",
+        name: this.expressionToArgument(path),
+        value: path.node
+      };
+    });
+    __publicField$1(this, "tokenizeConditionalExpression", (exp) => {
+      exp.traverse({
+        JSXElement: (el) => {
+          if (this.isTransComponent(el) || this.isChoiceComponent(el)) {
+            this.replacePath(el);
+            el.skip();
+          }
+        }
+      });
+      return {
+        type: "arg",
+        name: this.expressionToArgument(exp),
+        value: exp.node
+      };
+    });
+    __publicField$1(this, "tokenizeText", (value) => {
+      return {
+        type: "text",
+        value
+      };
+    });
+    __publicField$1(this, "isLinguiComponent", (path, name) => {
+      return path.isJSXElement() && path.get("openingElement").get("name").referencesImport(MACRO_PACKAGE, name);
+    });
+    __publicField$1(this, "isTransComponent", (path) => {
+      return this.isLinguiComponent(path, JsxMacroName.Trans);
+    });
+    __publicField$1(this, "isChoiceComponent", (path) => {
+      if (this.isLinguiComponent(path, JsxMacroName.Plural)) {
+        return JsxMacroName.Plural;
+      }
+      if (this.isLinguiComponent(path, JsxMacroName.Select)) {
+        return JsxMacroName.Select;
+      }
+      if (this.isLinguiComponent(path, JsxMacroName.SelectOrdinal)) {
+        return JsxMacroName.SelectOrdinal;
+      }
+    });
+    __publicField$1(this, "getJsxTagName", (node) => {
+      if (this.types.isJSXIdentifier(node.openingElement.name)) {
+        return node.openingElement.name.name;
+      }
+    });
+    this.types = types;
+    this.stripNonEssentialProps = opts.stripNonEssentialProps;
+    this.transImportName = opts.transImportName;
+  }
+  tokenizeTemplateLiteral(exp) {
+    const expressions = exp.get("expressions");
+    return exp.get("quasis").flatMap(({ node: text }, i) => {
+      const value = /\\u[a-fA-F0-9]{4}|\\x[a-fA-F0-9]{2}/g.test(text.value.raw) ? text.value.cooked : text.value.raw;
+      let argTokens = [];
+      const currExp = expressions[i];
+      if (currExp) {
+        argTokens = currExp.isCallExpression() ? this.tokenizeNode(currExp) : [this.tokenizeExpression(currExp)];
+      }
+      return [
+        ...value ? [this.tokenizeText(this.clearBackslashes(value))] : [],
+        ...argTokens
+      ];
+    });
+  }
+  expressionToArgument(path) {
+    return path.isIdentifier() ? path.node.name : String(this.expressionIndex());
+  }
+  /**
+   * We clean '//\` ' to just '`'
+   **/
+  clearBackslashes(value) {
+    return value.replace(/\\`/g, "`");
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const keepSpaceRe = /(?:\\(?:\r\n|\r|\n))+\s+/g;
+const keepNewLineRe = /(?:\r\n|\r|\n)+\s+/g;
+function normalizeWhitespace(text) {
+  return text.replace(keepSpaceRe, " ").replace(keepNewLineRe, "\n").trim();
+}
+function buildICUFromTokens(tokens) {
+  const messageFormat = new ICUMessageFormat();
+  const { message, values } = messageFormat.fromTokens(tokens);
+  return { message: normalizeWhitespace(message), values };
+}
+class MacroJs {
+  constructor({ types }, opts) {
+    // Babel Types
+    __publicField(this, "types");
+    // Identifier of i18n object
+    __publicField(this, "i18nImportName");
+    __publicField(this, "useLinguiImportName");
+    __publicField(this, "stripNonEssentialProps");
+    __publicField(this, "needsUseLinguiImport", false);
+    __publicField(this, "needsI18nImport", false);
+    // Positional expressions counter (e.g. for placeholders `Hello {0}, today is {1}`)
+    __publicField(this, "_expressionIndex", makeCounter());
+    __publicField(this, "replacePathWithMessage", (path, tokens, linguiInstance) => {
+      return this.createI18nCall(
+        this.createMessageDescriptorFromTokens(tokens, path.node.loc),
+        linguiInstance
+      );
+    });
+    __publicField(this, "replacePath", (path) => {
+      this._expressionIndex = makeCounter();
+      if (
+        //
+        path.isCallExpression() && this.isDefineMessage(path.get("callee"))
+      ) {
+        return this.processDescriptor(
+          path.get("arguments")[0]
+        );
+      }
+      if (path.isTaggedTemplateExpression() && this.isDefineMessage(path.get("tag"))) {
+        const tokens2 = this.tokenizeTemplateLiteral(path.get("quasi"));
+        return this.createMessageDescriptorFromTokens(tokens2, path.node.loc);
+      }
+      if (path.isTaggedTemplateExpression()) {
+        const tag = path.get("tag");
+        if (tag.isCallExpression() && tag.get("arguments")[0].isExpression() && this.isLinguiIdentifier(tag.get("callee"), JsMacroName.t)) {
+          const i18nInstance = tag.get("arguments")[0].node;
+          const tokens2 = this.tokenizeNode(path);
+          return this.replacePathWithMessage(path, tokens2, i18nInstance);
+        }
+      }
+      if (path.isCallExpression()) {
+        const callee = path.get("callee");
+        if (callee.isCallExpression() && callee.get("arguments")[0].isExpression() && this.isLinguiIdentifier(callee.get("callee"), JsMacroName.t)) {
+          const i18nInstance = callee.node.arguments[0];
+          return this.replaceTAsFunction(
+            path,
+            i18nInstance
+          );
+        }
+      }
+      if (path.isCallExpression() && this.isLinguiIdentifier(path.get("callee"), JsMacroName.t)) {
+        this.needsI18nImport = true;
+        return this.replaceTAsFunction(path);
+      }
+      if (path.isCallExpression() && this.isLinguiIdentifier(path.get("callee"), JsMacroName.useLingui)) {
+        this.needsUseLinguiImport = true;
+        return this.processUseLingui(path);
+      }
+      const tokens = this.tokenizeNode(path, true);
+      if (tokens) {
+        this.needsI18nImport = true;
+        return this.replacePathWithMessage(path, tokens);
+      }
+      return false;
+    });
+    /**
+     * macro `t` is called with MessageDescriptor, after that
+     * we create a new node to append it to i18n._
+     */
+    __publicField(this, "replaceTAsFunction", (path, linguiInstance) => {
+      const descriptor = this.processDescriptor(
+        path.get("arguments")[0]
+      );
+      return this.createI18nCall(descriptor, linguiInstance);
+    });
+    /**
+     * `processDescriptor` expand macros inside message descriptor.
+     * Message descriptor is used in `defineMessage`.
+     *
+     * {
+     *   comment: "Description",
+     *   message: plural("value", { one: "book", other: "books" })
+     * }
+     *
+     * ↓ ↓ ↓ ↓ ↓ ↓
+     *
+     * {
+     *   comment: "Description",
+     *   id: <hash>
+     *   message: "{value, plural, one {book} other {books}}"
+     * }
+     *
+     */
+    __publicField(this, "processDescriptor", (descriptor) => {
+      const messageProperty = this.getObjectPropertyByKey(descriptor, MESSAGE);
+      const idProperty = this.getObjectPropertyByKey(descriptor, ID);
+      const contextProperty = this.getObjectPropertyByKey(descriptor, CONTEXT);
+      const commentProperty = this.getObjectPropertyByKey(descriptor, COMMENT);
+      const properties = [];
+      if (idProperty) {
+        properties.push(idProperty.node);
+      }
+      if (!this.stripNonEssentialProps && contextProperty) {
+        properties.push(contextProperty.node);
+      }
+      if (messageProperty) {
+        const messageValue = messageProperty.get("value");
+        const tokens = messageValue.isTemplateLiteral() ? this.tokenizeTemplateLiteral(messageValue) : this.tokenizeNode(messageValue, true);
+        let messageNode = messageValue.node;
+        if (tokens) {
+          const { message, values } = buildICUFromTokens(tokens);
+          messageNode = this.types.stringLiteral(message);
+          properties.push(this.createValuesProperty(values));
+        }
+        if (!this.stripNonEssentialProps) {
+          properties.push(
+            this.createObjectProperty(MESSAGE, messageNode)
+          );
+        }
+        if (!idProperty && this.types.isStringLiteral(messageNode)) {
+          const context = contextProperty && this.getTextFromExpression(
+            contextProperty.get("value").node
+          );
+          properties.push(this.createIdProperty(messageNode.value, context));
+        }
+      }
+      if (!this.stripNonEssentialProps && commentProperty) {
+        properties.push(commentProperty.node);
+      }
+      return this.createMessageDescriptor(properties, descriptor.node.loc);
+    });
+    this.types = types;
+    this.i18nImportName = opts.i18nImportName;
+    this.useLinguiImportName = opts.useLinguiImportName;
+    this.stripNonEssentialProps = opts.stripNonEssentialProps;
+  }
+  /**
+   * Receives reference to `useLingui()` call
+   *
+   * Finds every usage of { t } destructured from the call
+   * and process each reference as usual `t` macro.
+   *
+   * const { t } = useLingui()
+   * t`Message`
+   *
+   * ↓ ↓ ↓ ↓ ↓ ↓
+   *
+   * const { _: _t } = useLingui()
+   * _t({id: <hash>, message: "Message"})
+   */
+  processUseLingui(path) {
+    if (!path.parentPath.isVariableDeclarator()) {
+      throw new Error(
+        `\`useLingui\` macro must be used in variable declaration.
+
+ Example:
+
+ const { t } = useLingui()
+      `
+      );
+    }
+    const varDec = path.parentPath.node;
+    const _property = this.types.isObjectPattern(varDec.id) ? varDec.id.properties.find(
+      (property) => this.types.isObjectProperty(property) && this.types.isIdentifier(property.key) && this.types.isIdentifier(property.value) && property.key.name == "t"
+    ) : null;
+    if (!_property) {
+      throw new Error(
+        `You have to destructure \`t\` when using the \`useLingui\` macro, i.e:
+ const { t } = useLingui()
+ or
+ const { t: _ } = useLingui()
+ `
+      );
+    }
+    const uniqTIdentifier = path.scope.generateUidIdentifier("t");
+    path.scope.getBinding(_property.value.name)?.referencePaths.forEach((refPath) => {
+      const currentPath = refPath.parentPath;
+      if (currentPath.isTaggedTemplateExpression()) {
+        const tokens = this.tokenizeTemplateLiteral(currentPath);
+        const descriptor = this.createMessageDescriptorFromTokens(
+          tokens,
+          currentPath.node.loc
+        );
+        const callExpr = this.types.callExpression(
+          this.types.identifier(uniqTIdentifier.name),
+          [descriptor]
+        );
+        return currentPath.replaceWith(callExpr);
+      }
+      if (currentPath.isCallExpression() && currentPath.get("arguments")[0].isObjectExpression()) {
+        let descriptor = this.processDescriptor(
+          currentPath.get("arguments")[0]
+        );
+        const callExpr = this.types.callExpression(
+          this.types.identifier(uniqTIdentifier.name),
+          [descriptor]
+        );
+        return currentPath.replaceWith(callExpr);
+      }
+      refPath.replaceWith(this.types.identifier(uniqTIdentifier.name));
+    });
+    _property.key.name = "_";
+    _property.value.name = uniqTIdentifier.name;
+    return this.types.callExpression(
+      this.types.identifier(this.useLinguiImportName),
+      []
+    );
+  }
+  createIdProperty(message, context) {
+    return this.createObjectProperty(
+      ID,
+      this.types.stringLiteral(generateMessageId(message, context))
+    );
+  }
+  createValuesProperty(values) {
+    const valuesObject = Object.keys(values).map(
+      (key) => this.types.objectProperty(this.types.identifier(key), values[key])
+    );
+    if (!valuesObject.length)
+      return;
+    return this.types.objectProperty(
+      this.types.identifier("values"),
+      this.types.objectExpression(valuesObject)
+    );
+  }
+  tokenizeNode(path, ignoreExpression = false) {
+    const node = path.node;
+    if (this.isI18nMethod(path)) {
+      return this.tokenizeTemplateLiteral(path);
+    }
+    const choiceMethod = this.isChoiceMethod(path);
+    if (choiceMethod) {
+      return [
+        this.tokenizeChoiceComponent(
+          path,
+          choiceMethod
+        )
+      ];
+    }
+    if (!ignoreExpression) {
+      return [this.tokenizeExpression(node)];
+    }
+  }
+  /**
+   * `node` is a TemplateLiteral. node.quasi contains
+   * text chunks and node.expressions contains expressions.
+   * Both arrays must be zipped together to get the final list of tokens.
+   */
+  tokenizeTemplateLiteral(path) {
+    const tpl = path.isTaggedTemplateExpression() ? path.get("quasi") : path;
+    const expressions = tpl.get("expressions");
+    return tpl.get("quasis").flatMap((text, i) => {
+      const value = /\\u[a-fA-F0-9]{4}|\\x[a-fA-F0-9]{2}/g.test(
+        text.node.value.raw
+      ) ? text.node.value.cooked : text.node.value.raw;
+      let argTokens = [];
+      const currExp = expressions[i];
+      if (currExp) {
+        argTokens = currExp.isCallExpression() ? this.tokenizeNode(currExp) : [this.tokenizeExpression(currExp.node)];
+      }
+      const textToken = {
+        type: "text",
+        value: this.clearBackslashes(value)
+      };
+      return [...value ? [textToken] : [], ...argTokens];
+    });
+  }
+  tokenizeChoiceComponent(path, componentName) {
+    const format = componentName.toLowerCase();
+    const token = {
+      ...this.tokenizeExpression(path.node.arguments[0]),
+      format,
+      options: {
+        offset: void 0
+      }
+    };
+    const props = path.get("arguments")[1].get(
+      "properties"
+    );
+    for (const attr of props) {
+      if (!attr.isObjectProperty()) {
+        throw new Error("Expected an ObjectProperty");
+      }
+      const key = attr.get("key");
+      const attrValue = attr.get("value");
+      const name = key.isNumericLiteral() ? `=${key.node.value}` : key.node.name || key.node.value;
+      if (format !== "select" && name === "offset") {
+        token.options.offset = attrValue.node.value;
+      } else {
+        let value;
+        if (attrValue.isTemplateLiteral()) {
+          value = this.tokenizeTemplateLiteral(attrValue);
+        } else if (attrValue.isCallExpression()) {
+          value = this.tokenizeNode(attrValue);
+        } else if (attrValue.isStringLiteral()) {
+          value = attrValue.node.value;
+        } else if (attrValue.isExpression()) {
+          value = this.tokenizeExpression(attrValue.node);
+        } else {
+          value = attrValue.value;
+        }
+        token.options[name] = value;
+      }
+    }
+    return token;
+  }
+  tokenizeExpression(node) {
+    return {
+      type: "arg",
+      name: this.expressionToArgument(node),
+      value: node
+    };
+  }
+  expressionToArgument(exp) {
+    if (this.types.isIdentifier(exp)) {
+      return exp.name;
+    } else if (this.types.isStringLiteral(exp)) {
+      return exp.value;
+    } else {
+      return String(this._expressionIndex());
+    }
+  }
+  /**
+   * We clean '//\` ' to just '`'
+   */
+  clearBackslashes(value) {
+    return value.replace(/\\`/g, "`");
+  }
+  createI18nCall(messageDescriptor, linguiInstance) {
+    return this.types.callExpression(
+      this.types.memberExpression(
+        linguiInstance ?? this.types.identifier(this.i18nImportName),
+        this.types.identifier("_")
+      ),
+      [messageDescriptor]
+    );
+  }
+  createMessageDescriptorFromTokens(tokens, oldLoc) {
+    const { message, values } = buildICUFromTokens(tokens);
+    const properties = [
+      this.createIdProperty(message),
+      !this.stripNonEssentialProps ? this.createObjectProperty(MESSAGE, this.types.stringLiteral(message)) : null,
+      this.createValuesProperty(values)
+    ];
+    return this.createMessageDescriptor(
+      properties,
+      // preserve line numbers for extractor
+      oldLoc
+    );
+  }
+  createMessageDescriptor(properties, oldLoc) {
+    const newDescriptor = this.types.objectExpression(
+      properties.filter(Boolean)
+    );
+    this.types.addComment(newDescriptor, "leading", EXTRACT_MARK);
+    if (oldLoc) {
+      newDescriptor.loc = oldLoc;
+    }
+    return newDescriptor;
+  }
+  createObjectProperty(key, value) {
+    return this.types.objectProperty(this.types.identifier(key), value);
+  }
+  getObjectPropertyByKey(objectExp, key) {
+    return objectExp.get("properties").find(
+      (property) => property.isObjectProperty() && property.get("key").isIdentifier({
+        name: key
+      })
+    );
+  }
+  /**
+   * Custom matchers
+   */
+  isLinguiIdentifier(path, name) {
+    if (path.isIdentifier() && path.referencesImport(MACRO_PACKAGE, name)) {
+      return true;
+    }
+  }
+  isDefineMessage(path) {
+    return this.isLinguiIdentifier(path, JsMacroName.defineMessage) || this.isLinguiIdentifier(path, JsMacroName.msg);
+  }
+  isI18nMethod(path) {
+    if (!path.isTaggedTemplateExpression()) {
+      return;
+    }
+    const tag = path.get("tag");
+    return this.isLinguiIdentifier(tag, JsMacroName.t) || tag.isCallExpression() && this.isLinguiIdentifier(tag.get("callee"), JsMacroName.t);
+  }
+  isChoiceMethod(path) {
+    if (!path.isCallExpression()) {
+      return;
+    }
+    const callee = path.get("callee");
+    if (this.isLinguiIdentifier(callee, JsMacroName.plural)) {
+      return JsMacroName.plural;
+    }
+    if (this.isLinguiIdentifier(callee, JsMacroName.select)) {
+      return JsMacroName.select;
+    }
+    if (this.isLinguiIdentifier(callee, JsMacroName.selectOrdinal)) {
+      return JsMacroName.selectOrdinal;
+    }
+  }
+  getTextFromExpression(exp) {
+    if (this.types.isStringLiteral(exp)) {
+      return exp.value;
+    }
+    if (this.types.isTemplateLiteral(exp)) {
+      if (exp?.quasis.length === 1) {
+        return exp.quasis[0]?.value?.cooked;
+      }
+    }
+  }
+}
+
+let config;
+function getConfig(_config) {
+  if (_config) {
+    config = _config;
+  }
+  if (!config) {
+    config = getConfig$1();
+  }
+  return config;
+}
+function reportUnsupportedSyntax(path, e) {
+  throw path.buildCodeFrameError(
+    `Unsupported macro usage. Please check the examples at https://lingui.dev/ref/macro#examples-of-js-macros.
+ If you think this is a bug, fill in an issue at https://github.com/lingui/js-lingui/issues
+
+ Error: ${e.message}`
+  );
+}
+function linguiPlugin({
+  types: t
+}) {
+  function addImport(state, name) {
+    const path = state.get(
+      "macroImport"
+    );
+    const config2 = state.get("linguiConfig");
+    if (!state.get("has_import_" + name)) {
+      state.set("has_import_" + name, true);
+      const [moduleSource, importName] = config2.runtimeConfigModule[name];
+      const [newPath] = path.insertAfter(
+        t.importDeclaration(
+          [
+            t.importSpecifier(
+              getSymbolIdentifier(state, name),
+              t.identifier(importName)
+            )
+          ],
+          t.stringLiteral(moduleSource)
+        )
+      );
+      path.parentPath.scope.registerDeclaration(newPath);
+    }
+    return path.parentPath.scope.getBinding(
+      getSymbolIdentifier(state, name).name
+    );
+  }
+  function getMacroImports(path) {
+    return path.get("body").filter((statement) => {
+      return statement.isImportDeclaration() && statement.get("source").node.value === MACRO_PACKAGE;
+    });
+  }
+  function getSymbolIdentifier(state, name) {
+    return state.get("linguiIdentifiers")[name];
+  }
+  return {
+    name: "lingui-macro-plugin",
+    visitor: {
+      Program: {
+        enter(path, state) {
+          const macroImports = getMacroImports(path);
+          if (!macroImports.length) {
+            return;
+          }
+          state.set("macroImport", macroImports[0]);
+          state.set(
+            "linguiConfig",
+            getConfig(state.opts.linguiConfig)
+          );
+          state.set("linguiIdentifiers", {
+            i18n: path.scope.generateUidIdentifier("i18n"),
+            Trans: path.scope.generateUidIdentifier("Trans"),
+            useLingui: path.scope.generateUidIdentifier("useLingui")
+          });
+          path.traverse(
+            {
+              JSXElement(path2, state2) {
+                const macro = new MacroJSX(
+                  { types: t },
+                  {
+                    transImportName: getSymbolIdentifier(state2, "Trans").name,
+                    stripNonEssentialProps: process.env.NODE_ENV == "production" && !state2.opts.extract
+                  }
+                );
+                let newNode;
+                try {
+                  newNode = macro.replacePath(path2);
+                } catch (e) {
+                  reportUnsupportedSyntax(path2, e);
+                }
+                if (newNode) {
+                  const [newPath] = path2.replaceWith(newNode);
+                  addImport(state2, "Trans").reference(newPath);
+                }
+              },
+              "CallExpression|TaggedTemplateExpression"(path2, state2) {
+                const macro = new MacroJs(
+                  { types: t },
+                  {
+                    stripNonEssentialProps: process.env.NODE_ENV == "production" && !state2.opts.extract,
+                    i18nImportName: getSymbolIdentifier(state2, "i18n").name,
+                    useLinguiImportName: getSymbolIdentifier(state2, "useLingui").name
+                  }
+                );
+                let newNode;
+                try {
+                  newNode = macro.replacePath(path2);
+                } catch (e) {
+                  reportUnsupportedSyntax(path2, e);
+                }
+                if (newNode) {
+                  const [newPath] = path2.replaceWith(newNode);
+                  if (macro.needsUseLinguiImport) {
+                    addImport(state2, "useLingui").reference(newPath);
+                  }
+                  if (macro.needsI18nImport) {
+                    addImport(state2, "i18n").reference(newPath);
+                  }
+                }
+              }
+            },
+            state
+          );
+        },
+        exit(path, state) {
+          const macroImports = getMacroImports(path);
+          macroImports.forEach((path2) => path2.remove());
+        }
+      }
+    }
+  };
+}
+
+export { JsMacroName as J, JsxMacroName as a, linguiPlugin as l };