@lingui/macro 4.8.0-next.1 → 4.8.0

package/dist/index.cjs

@@ -1,36 +1,903 @@
 'use strict';
 
 const babelPluginMacros = require('babel-plugin-macros');
-const plugin = require('./shared/macro.1cca3fdc.cjs');
-require('@babel/types');
-require('@lingui/message-utils/generateMessageId');
-require('@lingui/conf');
-
-function macro({ state, babel, config }) {
-  if (!state.get("linguiProcessed")) {
-    state.opts = config;
-    const plugin$1 = plugin.linguiPlugin(babel);
-    const { enter, exit } = plugin$1.visitor.Program;
-    enter(state.file.path, state);
-    state.file.path.traverse(plugin$1.visitor, state);
-    exit(state.file.path, state);
-    state.set("linguiProcessed", true);
-  }
-  return { keepImports: true };
-}
-[
-  plugin.JsMacroName.defineMessage,
-  plugin.JsMacroName.msg,
-  plugin.JsMacroName.t,
-  plugin.JsMacroName.useLingui,
-  plugin.JsMacroName.plural,
-  plugin.JsMacroName.select,
-  plugin.JsMacroName.selectOrdinal,
-  plugin.JsxMacroName.Trans,
-  plugin.JsxMacroName.Plural,
-  plugin.JsxMacroName.Select,
-  plugin.JsxMacroName.SelectOrdinal
-].forEach((name) => {
+const conf = require('@lingui/conf');
+const types = require('@babel/types');
+const generateMessageId = require('@lingui/message-utils/generateMessageId');
+
+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 && types.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";
+
+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 keepSpaceRe$1 = /(?:\\(?:\r\n|\r|\n))+\s+/g;
+const keepNewLineRe = /(?:\r\n|\r|\n)+\s+/g;
+function normalizeWhitespace$1(text) {
+  return text.replace(keepSpaceRe$1, " ").replace(keepNewLineRe, "\n").trim();
+}
+function buildICUFromTokens(tokens) {
+  const messageFormat = new ICUMessageFormat();
+  const { message, values } = messageFormat.fromTokens(tokens);
+  return { message: normalizeWhitespace$1(message), values };
+}
+class MacroJs {
+  constructor({ types }, opts) {
+    // Babel Types
+    __publicField$1(this, "types");
+    // Identifier of i18n object
+    __publicField$1(this, "i18nImportName");
+    __publicField$1(this, "stripNonEssentialProps");
+    __publicField$1(this, "nameMap");
+    __publicField$1(this, "nameMapReversed");
+    // Positional expressions counter (e.g. for placeholders `Hello {0}, today is {1}`)
+    __publicField$1(this, "_expressionIndex", makeCounter());
+    __publicField$1(this, "replacePathWithMessage", (path, tokens, linguiInstance) => {
+      const newNode = this.createI18nCall(
+        this.createMessageDescriptorFromTokens(tokens, path.node.loc),
+        linguiInstance
+      );
+      path.replaceWith(newNode);
+    });
+    // Returns a boolean indicating if the replacement requires i18n import
+    __publicField$1(this, "replacePath", (path) => {
+      this._expressionIndex = makeCounter();
+      if (this.types.isCallExpression(path.node) && this.isDefineMessage(path.node.callee)) {
+        let descriptor = this.processDescriptor(path.node.arguments[0]);
+        path.replaceWith(descriptor);
+        return false;
+      }
+      if (this.types.isTaggedTemplateExpression(path.node) && this.isDefineMessage(path.node.tag)) {
+        const tokens2 = this.tokenizeTemplateLiteral(path.node.quasi);
+        const descriptor = this.createMessageDescriptorFromTokens(
+          tokens2,
+          path.node.loc
+        );
+        path.replaceWith(descriptor);
+        return false;
+      }
+      if (this.types.isCallExpression(path.node) && this.types.isTaggedTemplateExpression(path.parentPath.node) && this.types.isExpression(path.node.arguments[0]) && this.isLinguiIdentifier(path.node.callee, "t")) {
+        const i18nInstance = path.node.arguments[0];
+        const tokens2 = this.tokenizeNode(path.parentPath.node);
+        this.replacePathWithMessage(path.parentPath, tokens2, i18nInstance);
+        return false;
+      }
+      if (this.types.isCallExpression(path.node) && this.types.isCallExpression(path.parentPath.node) && this.types.isExpression(path.node.arguments[0]) && path.parentPath.node.callee === path.node && this.isLinguiIdentifier(path.node.callee, "t")) {
+        const i18nInstance = path.node.arguments[0];
+        this.replaceTAsFunction(
+          path.parentPath,
+          i18nInstance
+        );
+        return false;
+      }
+      if (this.types.isCallExpression(path.node) && this.isLinguiIdentifier(path.node.callee, "t")) {
+        this.replaceTAsFunction(path);
+        return true;
+      }
+      const tokens = this.tokenizeNode(path.node);
+      this.replacePathWithMessage(path, tokens);
+      return true;
+    });
+    /**
+     * macro `t` is called with MessageDescriptor, after that
+     * we create a new node to append it to i18n._
+     */
+    __publicField$1(this, "replaceTAsFunction", (path, linguiInstance) => {
+      const descriptor = this.processDescriptor(path.node.arguments[0]);
+      path.replaceWith(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$1(this, "processDescriptor", (descriptor_) => {
+      const descriptor = descriptor_;
+      const messageProperty = this.getObjectPropertyByKey(descriptor, MESSAGE);
+      const idProperty = this.getObjectPropertyByKey(descriptor, ID);
+      const contextProperty = this.getObjectPropertyByKey(descriptor, CONTEXT);
+      const properties = [idProperty];
+      if (!this.stripNonEssentialProps) {
+        properties.push(contextProperty);
+      }
+      if (messageProperty) {
+        const tokens = this.types.isTemplateLiteral(messageProperty.value) ? this.tokenizeTemplateLiteral(messageProperty.value) : this.tokenizeNode(messageProperty.value, true);
+        let messageNode = messageProperty.value;
+        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.value);
+          properties.push(this.createIdProperty(messageNode.value, context));
+        }
+      }
+      if (!this.stripNonEssentialProps) {
+        properties.push(this.getObjectPropertyByKey(descriptor, COMMENT));
+      }
+      return this.createMessageDescriptor(properties, descriptor.loc);
+    });
+    this.types = types;
+    this.i18nImportName = opts.i18nImportName;
+    this.stripNonEssentialProps = opts.stripNonEssentialProps;
+    this.nameMap = opts.nameMap;
+    this.nameMapReversed = Array.from(opts.nameMap.entries()).reduce(
+      (map, [key, value]) => map.set(value, key),
+      /* @__PURE__ */ new Map()
+    );
+  }
+  createIdProperty(message, context) {
+    return this.createObjectProperty(
+      ID,
+      this.types.stringLiteral(generateMessageId.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(node, ignoreExpression = false) {
+    if (this.isI18nMethod(node)) {
+      return this.tokenizeTemplateLiteral(node);
+    } else if (this.isChoiceMethod(node)) {
+      return [this.tokenizeChoiceComponent(node)];
+    } else 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(node) {
+    const tpl = this.types.isTaggedTemplateExpression(node) ? node.quasi : node;
+    const expressions = tpl.expressions;
+    return tpl.quasis.flatMap((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 = this.types.isCallExpression(currExp) ? this.tokenizeNode(currExp) : [this.tokenizeExpression(currExp)];
+      }
+      const textToken = {
+        type: "text",
+        value: this.clearBackslashes(value)
+      };
+      return [...value ? [textToken] : [], ...argTokens];
+    });
+  }
+  tokenizeChoiceComponent(node) {
+    const name = node.callee.name;
+    const format = (this.nameMapReversed.get(name) || name).toLowerCase();
+    const token = {
+      ...this.tokenizeExpression(node.arguments[0]),
+      format,
+      options: {
+        offset: void 0
+      }
+    };
+    const props = node.arguments[1].properties;
+    for (const attr of props) {
+      const { key, value: attrValue } = attr;
+      const name2 = this.types.isNumericLiteral(key) ? `=${key.value}` : key.name || key.value;
+      if (format !== "select" && name2 === "offset") {
+        token.options.offset = attrValue.value;
+      } else {
+        let value;
+        if (this.types.isTemplateLiteral(attrValue)) {
+          value = this.tokenizeTemplateLiteral(attrValue);
+        } else if (this.types.isCallExpression(attrValue)) {
+          value = this.tokenizeNode(attrValue);
+        } else if (this.types.isStringLiteral(attrValue)) {
+          value = attrValue.value;
+        } else if (this.types.isExpression(attrValue)) {
+          value = this.tokenizeExpression(attrValue);
+        } else {
+          value = attrValue.value;
+        }
+        token.options[name2] = 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.properties.find(
+      (property) => types.isObjectProperty(property) && this.isLinguiIdentifier(property.key, key)
+    );
+  }
+  /**
+   * Custom matchers
+   */
+  isLinguiIdentifier(node, name) {
+    return this.types.isIdentifier(node, {
+      name: this.nameMap.get(name) || name
+    });
+  }
+  isDefineMessage(node) {
+    return this.isLinguiIdentifier(node, "defineMessage") || this.isLinguiIdentifier(node, "msg");
+  }
+  isI18nMethod(node) {
+    return this.types.isTaggedTemplateExpression(node) && (this.isLinguiIdentifier(node.tag, "t") || this.types.isCallExpression(node.tag) && this.isLinguiIdentifier(node.tag.callee, "t"));
+  }
+  isChoiceMethod(node) {
+    return this.types.isCallExpression(node) && (this.isLinguiIdentifier(node.callee, "plural") || this.isLinguiIdentifier(node.callee, "select") || this.isLinguiIdentifier(node.callee, "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;
+      }
+    }
+  }
+}
+
+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 pluralRuleRe = /(_[\d\w]+|zero|one|two|few|many|other)/;
+const jsx2icuExactChoice = (value) => value.replace(/_(\d+)/, "=$1").replace(/_(\w+)/, "$1");
+const keepSpaceRe = /\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(text) {
+  return text.replace(stripAroundTagsRe, "$1").replace(keepSpaceRe, " ").replace(/\\n/g, "\n").replace(/\\s/g, " ").replace(/(\s+})/gm, "}").replace(/({\s+)/gm, "{").trim();
+}
+class MacroJSX {
+  constructor({ types }, opts) {
+    __publicField(this, "types");
+    __publicField(this, "expressionIndex", makeCounter());
+    __publicField(this, "elementIndex", makeCounter());
+    __publicField(this, "stripNonEssentialProps");
+    __publicField(this, "nameMap");
+    __publicField(this, "nameMapReversed");
+    __publicField(this, "createStringJsxAttribute", (name, value) => {
+      return this.types.jsxAttribute(
+        this.types.jsxIdentifier(name),
+        this.types.jsxExpressionContainer(this.types.stringLiteral(value))
+      );
+    });
+    __publicField(this, "replacePath", (path) => {
+      if (!path.isJSXElement()) {
+        return path;
+      }
+      const tokens = this.tokenizeNode(path);
+      const messageFormat = new ICUMessageFormat();
+      const {
+        message: messageRaw,
+        values,
+        jsxElements
+      } = messageFormat.fromTokens(tokens);
+      const message = normalizeWhitespace(messageRaw);
+      const { attributes, id, comment, context } = this.stripMacroAttributes(
+        path
+      );
+      if (!id && !message) {
+        return;
+      }
+      if (id) {
+        attributes.push(
+          this.types.jsxAttribute(
+            this.types.jsxIdentifier(ID),
+            this.types.stringLiteral(id)
+          )
+        );
+      } else {
+        attributes.push(
+          this.createStringJsxAttribute(ID, generateMessageId.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("Trans"),
+          attributes,
+          true
+        ),
+        null,
+        [],
+        true
+      );
+      newNode.loc = path.node.loc;
+      path.replaceWith(newNode);
+    });
+    __publicField(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(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(this, "tokenizeNode", (path) => {
+      if (this.isTransComponent(path)) {
+        return this.tokenizeTrans(path);
+      } else if (this.isChoiceComponent(path)) {
+        return [this.tokenizeChoiceComponent(path)];
+      } else if (path.isJSXElement()) {
+        return [this.tokenizeElement(path)];
+      } else {
+        return [this.tokenizeExpression(path)];
+      }
+    });
+    __publicField(this, "tokenizeTrans", (path) => {
+      return path.get("children").flatMap((child) => this.tokenizeChildren(child)).filter(Boolean);
+    });
+    __publicField(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(this, "tokenizeChoiceComponent", (path) => {
+      const element = path.get("openingElement");
+      const name = this.getJsxTagName(path.node);
+      const format = (this.nameMapReversed.get(name) || name).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 name2 = attr.node.name.name;
+        const value = attr.get("value");
+        if (name2 === "value") {
+          const exp = value.isLiteral() ? value : value.get("expression");
+          token.name = this.expressionToArgument(exp);
+          token.value = exp.node;
+        } else if (format !== "select" && name2 === "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(name2)) {
+            token.options[jsx2icuExactChoice(name2)] = option;
+          } else {
+            token.options[name2] = option;
+          }
+        }
+      }
+      return token;
+    });
+    __publicField(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(this, "tokenizeExpression", (path) => {
+      return {
+        type: "arg",
+        name: this.expressionToArgument(path),
+        value: path.node
+      };
+    });
+    __publicField(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(this, "tokenizeText", (value) => {
+      return {
+        type: "text",
+        value
+      };
+    });
+    __publicField(this, "isLinguiComponent", (path, name) => {
+      return path.isJSXElement() && this.types.isJSXIdentifier(path.node.openingElement.name, {
+        name: this.nameMap.get(name) || name
+      });
+    });
+    __publicField(this, "isTransComponent", (path) => {
+      return this.isLinguiComponent(path, "Trans");
+    });
+    __publicField(this, "isChoiceComponent", (path) => {
+      return this.isLinguiComponent(path, "Plural") || this.isLinguiComponent(path, "Select") || this.isLinguiComponent(path, "SelectOrdinal");
+    });
+    __publicField(this, "getJsxTagName", (node) => {
+      if (this.types.isJSXIdentifier(node.openingElement.name)) {
+        return node.openingElement.name.name;
+      }
+    });
+    this.types = types;
+    this.stripNonEssentialProps = opts.stripNonEssentialProps;
+    this.nameMap = opts.nameMap;
+    this.nameMapReversed = Array.from(opts.nameMap.entries()).reduce(
+      (map, [key, value]) => map.set(value, key),
+      /* @__PURE__ */ new Map()
+    );
+  }
+  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, "`");
+  }
+}
+
+const jsMacroTags = /* @__PURE__ */ new Set([
+  "defineMessage",
+  "msg",
+  "arg",
+  "t",
+  "plural",
+  "select",
+  "selectOrdinal"
+]);
+const jsxMacroTags = /* @__PURE__ */ new Set(["Trans", "Plural", "Select", "SelectOrdinal"]);
+let config;
+function getConfig(_config) {
+  if (_config) {
+    config = _config;
+  }
+  if (!config) {
+    config = conf.getConfig();
+  }
+  return config;
+}
+function macro({ references, state, babel, config: config2 }) {
+  const opts = config2;
+  const {
+    i18nImportModule,
+    i18nImportName,
+    TransImportModule,
+    TransImportName
+  } = getConfig(opts.linguiConfig).runtimeConfigModule;
+  const jsxNodes = /* @__PURE__ */ new Set();
+  const jsNodes = /* @__PURE__ */ new Set();
+  let needsI18nImport = false;
+  let nameMap = /* @__PURE__ */ new Map();
+  Object.keys(references).forEach((tagName) => {
+    const nodes = references[tagName];
+    if (jsMacroTags.has(tagName)) {
+      nodes.forEach((path) => {
+        nameMap.set(tagName, path.node.name);
+        jsNodes.add(path.parentPath);
+      });
+    } else if (jsxMacroTags.has(tagName)) {
+      nodes.forEach((path) => {
+        nameMap.set(tagName, path.node.name);
+        jsxNodes.add(path.parentPath.parentPath);
+      });
+    } else {
+      throw nodes[0].buildCodeFrameError(`Unknown macro ${tagName}`);
+    }
+  });
+  const stripNonEssentialProps = process.env.NODE_ENV == "production" && !opts.extract;
+  const jsNodesArray = Array.from(jsNodes);
+  jsNodesArray.filter(isRootPath(jsNodesArray)).forEach((path) => {
+    const macro2 = new MacroJs(babel, {
+      i18nImportName,
+      stripNonEssentialProps,
+      nameMap
+    });
+    try {
+      if (macro2.replacePath(path))
+        needsI18nImport = true;
+    } catch (e) {
+      reportUnsupportedSyntax(path, e);
+    }
+  });
+  const jsxNodesArray = Array.from(jsxNodes);
+  jsxNodesArray.filter(isRootPath(jsxNodesArray)).forEach((path) => {
+    const macro2 = new MacroJSX(babel, { stripNonEssentialProps, nameMap });
+    try {
+      macro2.replacePath(path);
+    } catch (e) {
+      reportUnsupportedSyntax(path, e);
+    }
+  });
+  if (needsI18nImport) {
+    addImport(babel, state, i18nImportModule, i18nImportName);
+  }
+  if (jsxNodes.size) {
+    addImport(babel, state, TransImportModule, TransImportName);
+  }
+}
+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 addImport(babel, state, module2, importName) {
+  const { types: t } = babel;
+  const linguiImport = state.file.path.node.body.find(
+    (importNode) => t.isImportDeclaration(importNode) && importNode.source.value === module2 && // https://github.com/lingui/js-lingui/issues/777
+    importNode.importKind !== "type"
+  );
+  const tIdentifier = t.identifier(importName);
+  if (linguiImport) {
+    if (linguiImport.specifiers.findIndex(
+      (specifier) => types.isImportSpecifier(specifier) && types.isIdentifier(specifier.imported, { name: importName })
+    ) === -1) {
+      linguiImport.specifiers.push(t.importSpecifier(tIdentifier, tIdentifier));
+    }
+  } else {
+    state.file.path.node.body.unshift(
+      t.importDeclaration(
+        [t.importSpecifier(tIdentifier, tIdentifier)],
+        t.stringLiteral(module2)
+      )
+    );
+  }
+}
+function isRootPath(allPath) {
+  return (node) => function traverse(path) {
+    if (!path.parentPath) {
+      return true;
+    } else {
+      return !allPath.includes(path.parentPath) && traverse(path.parentPath);
+    }
+  }(node);
+}
+[...jsMacroTags, ...jsxMacroTags].forEach((name) => {
   Object.defineProperty(module.exports, name, {
     get() {
       throw new Error(