@stylexjs/babel-plugin 0.1.0-beta.3 → 0.1.0-beta.4

package/lib/index.js

@@ -0,0 +1,2968 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var t = require('@babel/types');
+var require$$0 = require('postcss-value-parser');
+var path = require('path');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var t__namespace = /*#__PURE__*/_interopNamespaceDefault(t);
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+var name = "@stylexjs/stylex";
+
+class StateManager {
+  // Imports
+
+  // `stylex.create` calls
+
+  // resuls of `stylex.create` calls that should be kept
+
+  constructor(state) {
+    _defineProperty(this, "_state", void 0);
+    _defineProperty(this, "stylexImport", new Set());
+    _defineProperty(this, "stylexCreateImport", new Set());
+    _defineProperty(this, "stylexIncludeImport", new Set());
+    _defineProperty(this, "stylexFirstThatWorksImport", new Set());
+    _defineProperty(this, "stylexKeyframesImport", new Set());
+    _defineProperty(this, "styleMap", new Map());
+    _defineProperty(this, "styleVars", new Map());
+    _defineProperty(this, "styleVarsToKeep", new Set());
+    this._state = state;
+    state.file.metadata.stylex = [];
+  }
+  get options() {
+    const options = this._state.opts || {};
+    this._state.opts = {
+      ...options,
+      dev: !!options.dev,
+      test: !!options.test,
+      stylexSheetName: options.stylexSheetName ?? undefined,
+      classNamePrefix: options.classNamePrefix ?? 'x',
+      importSources: options.importSources ?? [name, 'stylex'],
+      definedStylexCSSVariables: options.definedStylexCSSVariables ?? {}
+    };
+    return this._state.opts;
+  }
+  get metadata() {
+    return this._state.file.metadata;
+  }
+  get stylexSheetName() {
+    return this.options.stylexSheetName ?? undefined;
+  }
+  get isDev() {
+    return !!this.options.dev;
+  }
+  get isTest() {
+    return !!this.options.test;
+  }
+  get filename() {
+    return this._state.filename;
+  }
+  get cssVars() {
+    return this.options.definedStylexCSSVariables;
+  }
+  addStyle(style) {
+    this.metadata.stylex.push(style);
+  }
+  markComposedNamespace(memberExpression) {
+    this.styleVarsToKeep.add(memberExpression);
+  }
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * @flow strict
+ */
+
+// Read imports of react and remember the name of the local varsiables for later
+function readImportDeclarations(path, state) {
+  const {
+    node
+  } = path;
+  if ((node === null || node === void 0 ? void 0 : node.importKind) === 'type' || (node === null || node === void 0 ? void 0 : node.importKind) === 'typeof') {
+    return;
+  }
+  if (state.options.importSources.includes(node.source.value)) {
+    for (const specifier of node.specifiers) {
+      if (specifier.type === 'ImportDefaultSpecifier') {
+        state.stylexImport.add(specifier.local.name);
+      }
+      if (specifier.type === 'ImportNamespaceSpecifier') {
+        state.stylexImport.add(specifier.local.name);
+      }
+      if (specifier.type === 'ImportSpecifier') {
+        if (specifier.imported.type === 'Identifier') {
+          if (specifier.imported.name === 'create') {
+            state.stylexCreateImport.add(specifier.local.name);
+          }
+          if (specifier.imported.name === 'keyframes') {
+            state.stylexKeyframesImport.add(specifier.local.name);
+          }
+          if (specifier.imported.name === 'include') {
+            state.stylexIncludeImport.add(specifier.local.name);
+          }
+          if (specifier.imported.name === 'firstThatWorks') {
+            state.stylexFirstThatWorksImport.add(specifier.local.name);
+          }
+        }
+        if (specifier.imported.type === 'StringLiteral') {
+          if (specifier.imported.value === 'create') {
+            state.stylexCreateImport.add(specifier.local.name);
+          }
+          if (specifier.imported.value === 'keyframes') {
+            state.stylexKeyframesImport.add(specifier.local.name);
+          }
+          if (specifier.imported.value === 'include') {
+            state.stylexIncludeImport.add(specifier.local.name);
+          }
+          if (specifier.imported.value === 'firstThatWorks') {
+            state.stylexFirstThatWorksImport.add(specifier.local.name);
+          }
+        }
+      }
+    }
+  }
+}
+
+// Read require calls and remember the names of the variables for later
+function readRequires(path, state) {
+  var _node$init, _node$init2, _node$init2$callee, _node$init3, _node$init3$callee, _node$init4, _node$init4$arguments, _node$init5, _node$init5$arguments, _node$init6, _node$init6$arguments, _node$init7, _node$init7$arguments;
+  const {
+    node
+  } = path;
+  if (((_node$init = node.init) === null || _node$init === void 0 ? void 0 : _node$init.type) === 'CallExpression' && ((_node$init2 = node.init) === null || _node$init2 === void 0 ? void 0 : (_node$init2$callee = _node$init2.callee) === null || _node$init2$callee === void 0 ? void 0 : _node$init2$callee.type) === 'Identifier' && ((_node$init3 = node.init) === null || _node$init3 === void 0 ? void 0 : (_node$init3$callee = _node$init3.callee) === null || _node$init3$callee === void 0 ? void 0 : _node$init3$callee.name) === 'require' && ((_node$init4 = node.init) === null || _node$init4 === void 0 ? void 0 : (_node$init4$arguments = _node$init4.arguments) === null || _node$init4$arguments === void 0 ? void 0 : _node$init4$arguments.length) === 1 && ((_node$init5 = node.init) === null || _node$init5 === void 0 ? void 0 : (_node$init5$arguments = _node$init5.arguments) === null || _node$init5$arguments === void 0 ? void 0 : _node$init5$arguments[0].type) === 'StringLiteral' && (((_node$init6 = node.init) === null || _node$init6 === void 0 ? void 0 : (_node$init6$arguments = _node$init6.arguments) === null || _node$init6$arguments === void 0 ? void 0 : _node$init6$arguments[0].value) === 'stylex' || state.options.importSources.includes((_node$init7 = node.init) === null || _node$init7 === void 0 ? void 0 : (_node$init7$arguments = _node$init7.arguments) === null || _node$init7$arguments === void 0 ? void 0 : _node$init7$arguments[0].value))) {
+    if (node.id.type === 'Identifier') {
+      state.stylexImport.add(node.id.name);
+    }
+    if (node.id.type === 'ObjectPattern') {
+      for (const prop of node.id.properties) {
+        if (prop.type === 'ObjectProperty' && prop.key.type === 'Identifier' && prop.value.type === 'Identifier') {
+          if (prop.key.name === 'create') {
+            state.stylexCreateImport.add(prop.value.name);
+          }
+          if (prop.key.name === 'keyframes') {
+            state.stylexKeyframesImport.add(prop.value.name);
+          }
+          if (prop.key.name === 'include') {
+            state.stylexIncludeImport.add(prop.value.name);
+          }
+          if (prop.key.name === 'firstThatWorks') {
+            state.stylexFirstThatWorksImport.add(prop.value.name);
+          }
+        }
+      }
+    }
+  }
+}
+
+var lib = {};
+
+var stylexCreate = {};
+
+var convertToClassName$1 = {};
+
+var hash$1 = {};
+
+Object.defineProperty(hash$1, "__esModule", {
+  value: true
+});
+hash$1.default = void 0;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+/* eslint-disable default-case */
+/* eslint-disable no-fallthrough */
+
+/**
+ * JS Implementation of MurmurHash2
+ *
+ * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
+ * @see http://github.com/garycourt/murmurhash-js
+ * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
+ * @see http://sites.google.com/site/murmurhash/
+ *
+ * @param {string} str ASCII only
+ * @param {number} seed Positive integer only
+ * @return {number} 32-bit positive integer hash
+ */
+function murmurhash2_32_gc(str, seed) {
+  let l = str.length,
+    h = seed ^ l,
+    i = 0,
+    k;
+  while (l >= 4) {
+    k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
+    k = (k & 0xffff) * 0x5bd1e995 + (((k >>> 16) * 0x5bd1e995 & 0xffff) << 16);
+    k ^= k >>> 24;
+    k = (k & 0xffff) * 0x5bd1e995 + (((k >>> 16) * 0x5bd1e995 & 0xffff) << 16);
+    h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16) ^ k;
+    l -= 4;
+    ++i;
+  }
+  switch (l) {
+    case 3:
+      h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
+    case 2:
+      h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
+    case 1:
+      h ^= str.charCodeAt(i) & 0xff;
+      h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16);
+  }
+  h ^= h >>> 13;
+  h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16);
+  h ^= h >>> 15;
+  return h >>> 0;
+}
+const hash = str => murmurhash2_32_gc(str, 1).toString(36);
+var _default = hash;
+hash$1.default = _default;
+
+var dashify$1 = {};
+
+Object.defineProperty(dashify$1, "__esModule", {
+  value: true
+});
+dashify$1.default = dashify;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * 
+ */
+
+function dashify(str) {
+  return str.replace(/(^|[a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+var transformValue$1 = {};
+
+var normalizeValue$1 = {};
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+const parser = require$$0;
+const ROOT_FONT_SIZE = 16;
+
+/**
+ * Convert font sizes from absolute unit `px` to relative unit `rem`.
+ * This will allow developers to continue thinking and using what's familiar
+ * while we output font sizes that are adjustable
+ */
+var fontSizePxToRem = function convertFontSizeToRem(ast, key) {
+  if (key !== 'fontSize') {
+    return ast;
+  }
+  ast.walk(node => {
+    if (node.type !== 'word') {
+      return;
+    }
+    const dimension = parser.unit(node.value);
+    if (dimension && dimension.unit === 'px') {
+      node.value = `${parseFloat(dimension.number) / ROOT_FONT_SIZE}rem`;
+    }
+  });
+  return ast;
+};
+
+var leadingZero = {};
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+Object.defineProperty(leadingZero, "__esModule", {
+  value: true
+});
+leadingZero.default = normalizeLeadingZero;
+var _postcssValueParser$5 = _interopRequireDefault$b(require$$0);
+function _interopRequireDefault$b(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Remove leading zeros from numbers
+ */
+function normalizeLeadingZero(ast, _) {
+  ast.walk(node => {
+    if (node.type !== 'word') {
+      return;
+    }
+    const value = Number.parseFloat(node.value);
+    if (Number.isNaN(value)) {
+      return;
+    }
+    const dimension = _postcssValueParser$5.default.unit(node.value);
+    if (value < 1 && value >= 0) {
+      node.value = value.toString().replace('0.', '.') + (dimension ? dimension.unit : '');
+    }
+  });
+  return ast;
+}
+
+var quotes = {};
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+/**
+ * Make empty strings use consistent double quotes
+ */
+Object.defineProperty(quotes, "__esModule", {
+  value: true
+});
+quotes.default = normalizeQuotes;
+function normalizeQuotes(ast, _) {
+  ast.walk(node => {
+    if (node.type !== 'string') {
+      return;
+    }
+    if (node.value === '') {
+      node.quote = '"';
+    }
+  });
+  return ast;
+}
+
+var timings$1 = {};
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+Object.defineProperty(timings$1, "__esModule", {
+  value: true
+});
+timings$1.default = normalizeTimings;
+var _postcssValueParser$4 = _interopRequireDefault$a(require$$0);
+function _interopRequireDefault$a(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Turn millisecond values to seconds (shorter), except when < 10ms
+ */
+
+function normalizeTimings(ast, _) {
+  ast.walk(node => {
+    if (node.type !== 'word') {
+      return;
+    }
+    const value = Number.parseFloat(node.value);
+    if (Number.isNaN(value)) {
+      return;
+    }
+    const dimension = _postcssValueParser$4.default.unit(node.value);
+    if (!dimension || dimension.unit !== 'ms' || value < 10) {
+      return;
+    }
+    node.value = value / 1000 + 's';
+  });
+  return ast;
+}
+
+var whitespace = {};
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+/**
+ * Use single spaces and remove spaces when not needed: around functions,
+ * commas. But preserve spece around + and - as they are required in calc()
+ */
+Object.defineProperty(whitespace, "__esModule", {
+  value: true
+});
+whitespace.default = normalizeWhitespace;
+function normalizeWhitespace(ast, _) {
+  // trim
+  if (ast.nodes[0].type === 'space') {
+    ast.nodes.shift();
+  }
+  if (ast.nodes[ast.nodes.length - 1].type === 'space') {
+    ast.nodes.pop();
+  }
+  ast.walk((node, idx) => {
+    switch (node.type) {
+      case 'space':
+        {
+          node.value = ' ';
+          break;
+        }
+      case 'div':
+      case 'function':
+        {
+          node.before = '';
+          node.after = '';
+          break;
+        }
+      case 'word':
+        {
+          if (node.value === '!important') {
+            if (ast.nodes[idx - 1] && ast.nodes[idx - 1].type === 'space') {
+              ast.nodes.splice(idx - 1, 1);
+            }
+          }
+          break;
+        }
+    }
+  });
+  return ast;
+}
+
+var zeroDimensions = {};
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+Object.defineProperty(zeroDimensions, "__esModule", {
+  value: true
+});
+zeroDimensions.default = normalizeZeroDimensions;
+var _postcssValueParser$3 = _interopRequireDefault$9(require$$0);
+function _interopRequireDefault$9(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const angles = ['deg', 'grad', 'turn', 'rad'];
+const timings = ['ms', 's'];
+
+/**
+ * Remove units in zero values, except when required: in angles and timings,
+ * in which case make them consistent 0deg and 0s.
+ */
+
+function normalizeZeroDimensions(ast, _) {
+  ast.walk(node => {
+    if (node.type !== 'word') {
+      return;
+    }
+    const dimension = _postcssValueParser$3.default.unit(node.value);
+    if (!dimension || dimension.number !== '0') {
+      return;
+    }
+    if (angles.indexOf(dimension.unit) !== -1) {
+      node.value = '0deg';
+    } else if (timings.indexOf(dimension.unit) !== -1) {
+      node.value = '0s';
+    } else {
+      node.value = '0';
+    }
+  });
+  return ast;
+}
+
+var detectUnclosedFns$1 = {};
+
+var messages$4 = {};
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * 
+ */
+
+// This file contains constants to be used within Error messages.
+// The URLs within will eventually be replaced by links to the documenation website for Stylex.
+Object.defineProperty(messages$4, "__esModule", {
+  value: true
+});
+messages$4.UNKNOWN_PROP_KEY = messages$4.UNKNOWN_NAMESPACE = messages$4.UNEXPECTED_ARGUMENT = messages$4.UNBOUND_STYLEX_CALL_VALUE = messages$4.ONLY_TOP_LEVEL = messages$4.NO_PARENT_PATH = messages$4.NON_STATIC_VALUE = messages$4.NON_OBJECT_FOR_STYLEX_CALL = messages$4.LOCAL_ONLY = messages$4.LINT_UNCLOSED_FUNCTION = messages$4.INVALID_SPREAD = messages$4.INVALID_PSEUDO = messages$4.ILLEGAL_PROP_VALUE = messages$4.ILLEGAL_PROP_ARRAY_VALUE = messages$4.ILLEGAL_NESTED_PSEUDO = messages$4.ILLEGAL_NAMESPACE_VALUE = messages$4.ILLEGAL_NAMESPACE_TYPE = messages$4.ILLEGAL_ARGUMENT_LENGTH = messages$4.EXPECTED_FUNCTION_CALL = messages$4.ESCAPED_STYLEX_VALUE = void 0;
+const ILLEGAL_ARGUMENT_LENGTH = 'stylex() should have 1 argument.';
+messages$4.ILLEGAL_ARGUMENT_LENGTH = ILLEGAL_ARGUMENT_LENGTH;
+const NON_STATIC_VALUE = 'Only static values are allowed inside of a stylex.create() call.';
+messages$4.NON_STATIC_VALUE = NON_STATIC_VALUE;
+const ESCAPED_STYLEX_VALUE = 'Escaping a stylex.create() value is not allowed.';
+messages$4.ESCAPED_STYLEX_VALUE = ESCAPED_STYLEX_VALUE;
+const UNBOUND_STYLEX_CALL_VALUE = 'stylex.create calls must be bound to a bare variable.';
+messages$4.UNBOUND_STYLEX_CALL_VALUE = UNBOUND_STYLEX_CALL_VALUE;
+const ONLY_TOP_LEVEL = 'stylex.create() is only allowed at the root of a program.';
+messages$4.ONLY_TOP_LEVEL = ONLY_TOP_LEVEL;
+const NON_OBJECT_FOR_STYLEX_CALL = 'stylex.create() can only accept a style object.';
+messages$4.NON_OBJECT_FOR_STYLEX_CALL = NON_OBJECT_FOR_STYLEX_CALL;
+const UNKNOWN_PROP_KEY = 'Unknown property key';
+messages$4.UNKNOWN_PROP_KEY = UNKNOWN_PROP_KEY;
+const INVALID_PSEUDO = 'Invalid pseudo selector, not on the whitelist.';
+messages$4.INVALID_PSEUDO = INVALID_PSEUDO;
+const ILLEGAL_NAMESPACE_TYPE = 'Only a string literal namespace is allowed here.';
+messages$4.ILLEGAL_NAMESPACE_TYPE = ILLEGAL_NAMESPACE_TYPE;
+const UNKNOWN_NAMESPACE = 'Unknown namespace';
+messages$4.UNKNOWN_NAMESPACE = UNKNOWN_NAMESPACE;
+const ILLEGAL_NESTED_PSEUDO = "Pseudo objects can't be nested.";
+messages$4.ILLEGAL_NESTED_PSEUDO = ILLEGAL_NESTED_PSEUDO;
+const ILLEGAL_PROP_VALUE = 'A style value can only contain an array, string or number.';
+messages$4.ILLEGAL_PROP_VALUE = ILLEGAL_PROP_VALUE;
+const ILLEGAL_PROP_ARRAY_VALUE = 'A style array value can only contain strings or numbers.';
+messages$4.ILLEGAL_PROP_ARRAY_VALUE = ILLEGAL_PROP_ARRAY_VALUE;
+const ILLEGAL_NAMESPACE_VALUE = 'A stylex namespace must be an object.';
+messages$4.ILLEGAL_NAMESPACE_VALUE = ILLEGAL_NAMESPACE_VALUE;
+const INVALID_SPREAD = 'Imported styles spread with a stylex.create call must be type cast as `XStyle<>` to verify their type.';
+messages$4.INVALID_SPREAD = INVALID_SPREAD;
+const LINT_UNCLOSED_FUNCTION = 'Rule contains an unclosed function';
+messages$4.LINT_UNCLOSED_FUNCTION = LINT_UNCLOSED_FUNCTION;
+const LOCAL_ONLY = 'The return value of stylex.create() should not be exported.';
+messages$4.LOCAL_ONLY = LOCAL_ONLY;
+const UNEXPECTED_ARGUMENT = 'Unexpected argument passed to the stylex() function.';
+messages$4.UNEXPECTED_ARGUMENT = UNEXPECTED_ARGUMENT;
+const EXPECTED_FUNCTION_CALL = 'Expected a simple function call but found something else.';
+messages$4.EXPECTED_FUNCTION_CALL = EXPECTED_FUNCTION_CALL;
+const NO_PARENT_PATH = 'Unexpected AST node without a parent path.';
+messages$4.NO_PARENT_PATH = NO_PARENT_PATH;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+Object.defineProperty(detectUnclosedFns$1, "__esModule", {
+  value: true
+});
+detectUnclosedFns$1.default = detectUnclosedFns;
+var messages$3 = _interopRequireWildcard$3(messages$4);
+function _getRequireWildcardCache$3(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache$3 = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard$3(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache$3(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * Remove leading zeros from numbers
+ */
+function detectUnclosedFns(ast, _) {
+  ast.walk(node => {
+    if (node.type === 'function' && node.unclosed) {
+      throw new Error(messages$3.LINT_UNCLOSED_FUNCTION);
+    }
+  });
+  return ast;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+Object.defineProperty(normalizeValue$1, "__esModule", {
+  value: true
+});
+normalizeValue$1.default = normalizeValue;
+var _fontSizePxToRem = _interopRequireDefault$8(fontSizePxToRem);
+var _leadingZero = _interopRequireDefault$8(leadingZero);
+var _quotes = _interopRequireDefault$8(quotes);
+var _timings = _interopRequireDefault$8(timings$1);
+var _whitespace = _interopRequireDefault$8(whitespace);
+var _zeroDimensions = _interopRequireDefault$8(zeroDimensions);
+var _detectUnclosedFns = _interopRequireDefault$8(detectUnclosedFns$1);
+var _postcssValueParser$2 = _interopRequireDefault$8(require$$0);
+function _interopRequireDefault$8(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// `Timings` should be before `LeadingZero`, because it
+// changes 500ms to 0.5s, then `LeadingZero` makes it .5s
+const normalizers = [_detectUnclosedFns.default, _whitespace.default, _timings.default, _zeroDimensions.default, _leadingZero.default, _quotes.default, _fontSizePxToRem.default];
+function normalizeValue(value, key) {
+  const parsedAST = (0, _postcssValueParser$2.default)(value);
+  return normalizers.reduce((ast, fn) => fn(ast, key), parsedAST).toString();
+}
+
+Object.defineProperty(transformValue$1, "__esModule", {
+  value: true
+});
+transformValue$1.default = transformValue;
+var _normalizeValue = _interopRequireDefault$7(normalizeValue$1);
+function _interopRequireDefault$7(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * 
+ */
+
+/**
+ * Convert a CSS value in JS to the final CSS string value
+ */
+function transformValue(key, rawValue) {
+  const value = typeof rawValue === 'number' ? String(Math.round(rawValue * 10000) / 10000) + getNumberSuffix(key) : rawValue;
+
+  // content is one of the values that needs to wrapped in quotes.
+  // Users may write `''` without thinking about it, so we fix that.
+  if (key === 'content' && typeof value === 'string') {
+    const val = value.trim();
+    if (val.match(/^attr\([a-zA-Z0-9-]+\)$/)) {
+      return val;
+    }
+    if (!(val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'"))) {
+      return `"${val}"`;
+    }
+  }
+  return (0, _normalizeValue.default)(value, key);
+}
+function getNumberSuffix(key) {
+  if (unitlessNumberProperties.has(key)) {
+    return '';
+  }
+  const suffix = numberPropertySuffixes[key];
+  if (suffix == null) {
+    return 'px';
+  } else {
+    return suffix;
+  }
+}
+const unitlessNumberProperties = new Set(['animationIterationCount', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'columnCount', 'flex',
+// Unsupported
+'flexGrow', 'flexPositive', 'flexShrink', 'flexOrder', 'gridRow', 'gridColumn', 'fontWeight', 'lineClamp', 'lineHeight', 'opacity', 'order', 'orphans', 'tabSize', 'widows', 'zIndex', 'fillOpacity', 'floodOpacity', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth']);
+
+// List of properties that have custom suffixes for numbers
+const numberPropertySuffixes = {
+  animationDelay: 'ms',
+  animationDuration: 'ms',
+  transitionDelay: 'ms',
+  transitionDuration: 'ms',
+  voiceDuration: 'ms'
+};
+
+var generateCssRule = {};
+
+var generateLtr = {};
+
+Object.defineProperty(generateLtr, "__esModule", {
+  value: true
+});
+generateLtr.default = generateLTR;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+const logicalToPhysical$1 = {
+  start: 'left',
+  end: 'right'
+};
+const propertyToLTR = {
+  'margin-start': _ref => {
+    let [key, val] = _ref;
+    return ['margin-left', val];
+  },
+  // 'margin-inline-start': ([key, val]) => ['margin-left', val],
+  'margin-end': _ref2 => {
+    let [key, val] = _ref2;
+    return ['margin-right', val];
+  },
+  // 'margin-inline-end': ([key, val]: [string, string]) => ['margin-right', val],
+  'padding-start': _ref3 => {
+    let [key, val] = _ref3;
+    return ['padding-left', val];
+  },
+  // 'padding-inline-start': ([key, val]: [string, string]) => ['padding-left', val],
+  'padding-end': _ref4 => {
+    let [key, val] = _ref4;
+    return ['padding-right', val];
+  },
+  // 'padding-inline-end': ([key, val]: [string, string]) => ['padding-right', val],
+  'border-start': _ref5 => {
+    let [key, val] = _ref5;
+    return ['border-left', val];
+  },
+  // 'border-inline-start': ([key, val]: [string, string]) => ['border-left', val],
+  'border-end': _ref6 => {
+    let [key, val] = _ref6;
+    return ['border-right', val];
+  },
+  // 'border-inline-end': ([key, val]: [string, string]) => ['border-right', val],
+  'border-start-width': _ref7 => {
+    let [key, val] = _ref7;
+    return ['border-left-width', val];
+  },
+  // 'border-inline-start-width': ([key, val]: [string, string]) => ['border-left-width', val],
+  'border-end-width': _ref8 => {
+    let [key, val] = _ref8;
+    return ['border-right-width', val];
+  },
+  // 'border-inline-end-width': ([key, val]: [string, string]) => ['border-right-width', val],
+  'border-start-color': _ref9 => {
+    let [key, val] = _ref9;
+    return ['border-left-color', val];
+  },
+  // 'border-inline-start-color': ([key, val]: [string, string]) => ['border-left-color', val],
+  'border-end-color': _ref10 => {
+    let [key, val] = _ref10;
+    return ['border-right-color', val];
+  },
+  // 'border-inline-end-color': ([key, val]: [string, string]) => ['border-right-color', val],
+  'border-start-style': _ref11 => {
+    let [key, val] = _ref11;
+    return ['border-left-style', val];
+  },
+  // 'border-inline-start-style': ([key, val]: [string, string]) => ['border-left-style', val],
+  'border-end-style': _ref12 => {
+    let [key, val] = _ref12;
+    return ['border-right-style', val];
+  },
+  // 'border-inline-end-style': ([key, val]: [string, string]) => ['border-right-style', val],
+  'border-top-start-radius': _ref13 => {
+    let [key, val] = _ref13;
+    return ['border-top-left-radius', val];
+  },
+  // 'border-start-start-radius': ([key, val]: [string, string]) => ['border-top-left-radius', val],
+  'border-bottom-start-radius': _ref14 => {
+    let [key, val] = _ref14;
+    return ['border-bottom-left-radius', val];
+  },
+  // 'border-end-start-radius': ([key, val]: [string, string]) => ['border-bottom-left-radius', val],
+  'border-top-end-radius': _ref15 => {
+    let [key, val] = _ref15;
+    return ['border-top-right-radius', val];
+  },
+  // 'border-start-end-radius': ([key, val]: [string, string]) => ['border-top-right-radius', val],
+  'border-bottom-end-radius': _ref16 => {
+    let [key, val] = _ref16;
+    return ['border-bottom-right-radius', val];
+  },
+  // 'border-end-end-radius': ([key, val]: [string, string]) => ['border-bottom-right-radius', val],
+  'text-align': _ref17 => {
+    let [key, val] = _ref17;
+    return [key, logicalToPhysical$1[val] ?? val];
+  },
+  float: _ref18 => {
+    let [key, val] = _ref18;
+    return [key, logicalToPhysical$1[val] ?? val];
+  },
+  clear: _ref19 => {
+    let [key, val] = _ref19;
+    return [key, logicalToPhysical$1[val] ?? val];
+  },
+  start: _ref20 => {
+    let [key, val] = _ref20;
+    return ['left', val];
+  },
+  // 'inset-inline-start': ([key, val]: [string, string]) => ['left', val],
+  end: _ref21 => {
+    let [key, val] = _ref21;
+    return ['right', val];
+  },
+  // 'inset-inline-end': ([key, val]) => ['right', val],
+  'background-position': _ref22 => {
+    let [key, val] = _ref22;
+    return [key, val.split(' ').map(word => word === 'start' ? 'left' : word === 'end' ? 'right' : word).join(' ')];
+  }
+};
+function generateLTR(pair) {
+  const [key] = pair;
+  if (propertyToLTR[key]) {
+    return propertyToLTR[key](pair);
+  }
+  return pair;
+}
+
+var generateRtl = {};
+
+Object.defineProperty(generateRtl, "__esModule", {
+  value: true
+});
+generateRtl.default = generateRTL;
+var _postcssValueParser$1 = _interopRequireDefault$6(require$$0);
+function _interopRequireDefault$6(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+const cursorFlip = {
+  'e-resize': 'w-resize',
+  'w-resize': 'e-resize',
+  'ne-resize': 'nw-resize',
+  'nesw-resize': 'nwse-resize',
+  'nw-resize': 'ne-resize',
+  'nwse-resize': 'nesw-resize',
+  'se-resize': 'sw-resize',
+  'sw-resize': 'se-resize'
+};
+function splitByDivisor(value) {
+  const ast = (0, _postcssValueParser$1.default)(value);
+  const groups = [];
+  let currGroup = [];
+  function push() {
+    if (currGroup.length === 0) {
+      return;
+    }
+    groups.push(_postcssValueParser$1.default.stringify(currGroup));
+    currGroup = [];
+  }
+  for (const node of ast.nodes) {
+    if (node.type === 'div') {
+      push();
+    } else {
+      currGroup.push(node);
+    }
+  }
+  push();
+  return groups;
+}
+function flipSign(value) {
+  if (value === '0') {
+    return value;
+  } else {
+    return value[0] === '-' ? value.slice(1) : '-' + value;
+  }
+}
+function flipShadow(value) {
+  const defs = splitByDivisor(value);
+  const builtDefs = [];
+  for (const def of defs) {
+    const parts = def.split(' ');
+    const index = _postcssValueParser$1.default.unit(parts[0]) === false ? 1 : 0;
+    if (index < parts.length) {
+      parts[index] = flipSign(parts[index]);
+    }
+    builtDefs.push(parts.join(' '));
+  }
+  const rtl = builtDefs.join(', ');
+  if (rtl !== value) {
+    return rtl;
+  }
+}
+
+// Should we be flipping shadows at all?
+// I think the better approach would be to let engineers use
+// CSS-vars directly.
+const shadowsFlip = {
+  'box-shadow': _ref => {
+    let [key, val] = _ref;
+    const rtlVal = flipShadow(val);
+    return rtlVal ? [key, rtlVal] : null;
+  },
+  'text-shadow': _ref2 => {
+    let [key, val] = _ref2;
+    const rtlVal = flipShadow(val);
+    return rtlVal ? [key, rtlVal] : null;
+  }
+};
+const logicalToPhysical = {
+  start: 'right',
+  end: 'left'
+};
+const propertyToRTL = {
+  'margin-start': _ref3 => {
+    let [key, val] = _ref3;
+    return ['margin-right', val];
+  },
+  // 'margin-inline-start': ([key, val]: [string, string]) => ['margin-right', val],
+  'margin-end': _ref4 => {
+    let [key, val] = _ref4;
+    return ['margin-left', val];
+  },
+  // 'margin-inline-end': ([key, val]: [string, string]) => ['margin-left', val],
+  'padding-start': _ref5 => {
+    let [key, val] = _ref5;
+    return ['padding-right', val];
+  },
+  // 'padding-inline-start': ([key, val]: [string, string]) => ['padding-right', val],
+  'padding-end': _ref6 => {
+    let [key, val] = _ref6;
+    return ['padding-left', val];
+  },
+  // 'padding-inline-end': ([key, val]: [string, string]) => ['padding-left', val],
+  'border-start': _ref7 => {
+    let [key, val] = _ref7;
+    return ['border-right', val];
+  },
+  // 'border-inline-start': ([key, val]: [string, string]) => ['border-right', val],
+  'border-end': _ref8 => {
+    let [key, val] = _ref8;
+    return ['border-left', val];
+  },
+  // 'border-inline-end': ([key, val]: [string, string]) => ['border-left', val],
+  'border-start-width': _ref9 => {
+    let [key, val] = _ref9;
+    return ['border-right-width', val];
+  },
+  // 'border-inline-start-width': ([key, val]: [string, string]) => ['border-right-width', val],
+  'border-end-width': _ref10 => {
+    let [key, val] = _ref10;
+    return ['border-left-width', val];
+  },
+  // 'border-inline-end-width': ([key, val]: [string, string]) => ['border-left-width', val],
+  'border-start-color': _ref11 => {
+    let [key, val] = _ref11;
+    return ['border-right-color', val];
+  },
+  // 'border-inline-start-color': ([key, val]: [string, string]) => ['border-right-color', val],
+  'border-end-color': _ref12 => {
+    let [key, val] = _ref12;
+    return ['border-left-color', val];
+  },
+  // 'border-inline-end-color': ([key, val]: [string, string]) => ['border-left-color', val],
+  'border-start-style': _ref13 => {
+    let [key, val] = _ref13;
+    return ['border-right-style', val];
+  },
+  // 'border-inline-start-style': ([key, val]: [string, string]) => ['border-right-style', val],
+  'border-end-style': _ref14 => {
+    let [key, val] = _ref14;
+    return ['border-left-style', val];
+  },
+  // 'border-inline-end-style': ([key, val]: [string, string]) => ['border-left-style', val],
+  'border-top-start-radius': _ref15 => {
+    let [key, val] = _ref15;
+    return ['border-top-right-radius', val];
+  },
+  // 'border-start-start-radius': ([key, val]: [string, string]) => ['border-top-right-radius', val],
+  'border-bottom-start-radius': _ref16 => {
+    let [key, val] = _ref16;
+    return ['border-bottom-right-radius', val];
+  },
+  // 'border-end-start-radius': ([key, val]: [string, string]) => ['border-bottom-right-radius', val],
+  'border-top-end-radius': _ref17 => {
+    let [key, val] = _ref17;
+    return ['border-top-left-radius', val];
+  },
+  // 'border-start-end-radius': ([key, val]: [string, string]) => ['border-top-left-radius', val],
+  'border-bottom-end-radius': _ref18 => {
+    let [key, val] = _ref18;
+    return ['border-bottom-left-radius', val];
+  },
+  // 'border-end-end-radius': ([key, val]: [string, string]) => ['border-bottom-left-radius', val],
+  'text-align': _ref19 => {
+    let [key, val] = _ref19;
+    return logicalToPhysical[val] != null ? [key, logicalToPhysical[val]] : null;
+  },
+  float: _ref20 => {
+    let [key, val] = _ref20;
+    return logicalToPhysical[val] != null ? [key, logicalToPhysical[val]] : null;
+  },
+  clear: _ref21 => {
+    let [key, val] = _ref21;
+    return logicalToPhysical[val] != null ? [key, logicalToPhysical[val]] : null;
+  },
+  start: _ref22 => {
+    let [key, val] = _ref22;
+    return ['right', val];
+  },
+  // 'inset-inline-start': ([key, val]: [string, string]) => ['right', val],
+  end: _ref23 => {
+    let [key, val] = _ref23;
+    return ['left', val];
+  },
+  // 'inset-inline-end': ([key, val]: [string, string]) => ['left', val],
+  'background-position': _ref24 => {
+    let [key, val] = _ref24;
+    const words = val.split(' ');
+    if (!words.includes('start') && !words.includes('end')) {
+      return null;
+    }
+    return [key, words.map(word => word === 'start' ? 'right' : word === 'end' ? 'left' : word).join(' ')];
+  },
+  cursor: _ref25 => {
+    let [key, val] = _ref25;
+    return cursorFlip[val] != null ? [key, cursorFlip[val]] : null;
+  },
+  ...shadowsFlip
+};
+function generateRTL(_ref26) {
+  let [key, value] = _ref26;
+  if (propertyToRTL[key]) {
+    return propertyToRTL[key]([key, value]);
+  }
+  return null;
+}
+
+var genCSSRule = {};
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+Object.defineProperty(genCSSRule, "__esModule", {
+  value: true
+});
+genCSSRule.default = generateCSSRule$1;
+function generateCSSRule$1(className, decls, pseudo) {
+  if (pseudo === '::thumb') {
+    const selector = THUMB_VARIANTS.map(suffix => '.' + className + suffix).join(', ');
+    return `${selector}{${decls}}`;
+  }
+  return pseudo != null && pseudo[0] === '@' ? `${pseudo}{.${className}.${className}{${decls}}}` : pseudo != null && pseudo[0] === ':' ? `.${className}${pseudo}{${decls}}` : `.${className}{${decls}}`;
+}
+const THUMB_VARIANTS = ['::-webkit-slider-thumb', '::-moz-range-thumb', '::-ms-thumb'];
+
+Object.defineProperty(generateCssRule, "__esModule", {
+  value: true
+});
+generateCssRule.default = generateCSSRule;
+var _generateLtr$1 = _interopRequireDefault$5(generateLtr);
+var _generateRtl$1 = _interopRequireDefault$5(generateRtl);
+var _genCSSRule = _interopRequireDefault$5(genCSSRule);
+function _interopRequireDefault$5(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function generateCSSRule(className, key, value, pseudo) {
+  const pairs = Array.isArray(value) ? value.map(eachValue => [key, eachValue]) : [[key, value]];
+  const ltrPairs = pairs.map(_generateLtr$1.default);
+  const ltrDecls = ltrPairs.map(pair => pair.join(':')).join(';');
+  const rtlDecls = pairs.map(_generateRtl$1.default).filter(Boolean).map(pair => pair.join(':')).join(';');
+  const ltrRule = (0, _genCSSRule.default)(className, ltrDecls, pseudo);
+  const rtlRule = !rtlDecls ? null : (0, _genCSSRule.default)(className, rtlDecls, pseudo);
+  let priority = 1;
+  if (pseudo != null) {
+    if (pseudo[0] === '@') {
+      priority = 2;
+    } else if (pseudo[0] === ':') {
+      priority = pseudoPriorities[pseudo] ?? 2;
+      if (pseudo.startsWith(':nth-child')) {
+        priority = 6;
+      }
+      if (pseudo.startsWith(':nth-of-type')) {
+        priority = 7;
+      }
+    }
+  }
+  if (key.toLowerCase().includes('left') || key.toLowerCase().includes('right')) {
+    // Bump priority for physical left/right values.
+    priority += 0.1;
+  }
+  return {
+    priority,
+    ltr: ltrRule,
+    rtl: rtlRule
+  };
+}
+const pseudoPriorities = {
+  // Might become unsupported:
+  ':first-child': 3,
+  ':last-child': 4,
+  ':only-child': 5,
+  ':nth-child': 6,
+  ':nth-of-type': 7,
+  ':hover': 8,
+  ':focus': 9,
+  ':active': 10,
+  ':disabled': 11,
+  '::placeholder': 12,
+  '::thumb': 13
+};
+
+Object.defineProperty(convertToClassName$1, "__esModule", {
+  value: true
+});
+convertToClassName$1.default = convertToClassName;
+var _hash$1 = _interopRequireDefault$4(hash$1);
+var _dashify$1 = _interopRequireDefault$4(dashify$1);
+var _transformValue$1 = _interopRequireDefault$4(transformValue$1);
+var _generateCssRule = _interopRequireDefault$4(generateCssRule);
+function _interopRequireDefault$4(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+// This function takes a single style rule and transforms it into a CSS rule.
+// [color: 'red'] => ['color', 'classname-for-color-red', CSSRULE{ltr, rtl, priority}]
+//
+// It converts the camelCased style key to a dash-separated key.
+// Handles RTL-flipping
+// Hashes to get a className
+// Returns the final key, className a CSS Rule
+function convertToClassName(objEntry, pseudo) {
+  let {
+    stylexSheetName = '<>',
+    classNamePrefix = 'x'
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const [key, rawValue] = objEntry;
+  const dashedKey = (0, _dashify$1.default)(key);
+  const value = Array.isArray(rawValue) ? rawValue.map(eachValue => (0, _transformValue$1.default)(key, eachValue)) : (0, _transformValue$1.default)(key, rawValue);
+  const stringToHash = Array.isArray(value) ? dashedKey + value.join(', ') + (pseudo ?? 'null') : dashedKey + value + (pseudo ?? 'null');
+  const className = classNamePrefix + (0, _hash$1.default)(stylexSheetName + stringToHash);
+  const cssRules = (0, _generateCssRule.default)(className, dashedKey, value, pseudo);
+  return [key, className, cssRules];
+}
+
+var expandShorthands = {};
+
+Object.defineProperty(expandShorthands, "__esModule", {
+  value: true
+});
+expandShorthands.default = flatMapExpandedShorthands;
+var _postcssValueParser = _interopRequireDefault$3(require$$0);
+function _interopRequireDefault$3(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function printNode(node) {
+  switch (node.type) {
+    case 'word':
+    case 'string':
+      return `${node.value}`;
+    case 'function':
+      return `${node.value}(${node.nodes.map(printNode).join('')})`;
+    default:
+      return node.value;
+  }
+}
+
+// Using split(' ') Isn't enough bcause of values like calc.
+function splitValue(str) {
+  if (Array.isArray(str)) {
+    return str;
+  }
+  const parsed = (0, _postcssValueParser.default)(str.trim());
+  const nodes = parsed.nodes.filter(node => node.type !== 'space' && node.type !== 'div').map(printNode);
+  if (nodes.length > 1 && nodes[nodes.length - 1].toLowerCase() === '!important') {
+    return nodes.slice(0, nodes.length - 1).map(node => node + ' !important');
+  }
+  return nodes;
+}
+
+// TODO: to be added later.
+// const aliases = {
+//   marginInlineStart: (rawValue) => [['marginStart', rawValue]],
+//   marginInlineEnd: (rawValue) => [['marginEnd', rawValue]],
+//   marginInline: (rawValue) => [
+//     ['marginStart', rawValue],
+//     ['marginEnd', rawValue],
+//   ],
+//   paddingInlineStart: (rawValue) => [['paddingStart', rawValue]],
+//   paddingInlineEnd: (rawValue) => [['paddingEnd', rawValue]],
+//   paddingInline: (rawValue) => [
+//     ['paddingStart', rawValue],
+//     ['paddingEnd', rawValue],
+//   ],
+//   // 'borderInlineStart': (rawValue) => [['borderStart', rawValue]],
+//   // 'borderInlineEnd': (rawValue) => [['borderEnd', rawValue]],
+//   // // This will need to change.
+//   // 'borderInline': (rawValue) => [
+//   //   ['borderStart', rawValue],
+//   //   ['borderEnd', rawValue],
+//   // ],
+// };
+
+/**
+ * Shorthand properties:
+ * - [x] all - Should be banned
+ * - [ ] animation
+ * - [ ] background
+ * - [-] border
+ * - [x] border-block-end
+ * - [x] border-block-start
+ * - [ ] border-bottom
+ * - [x] border-color
+ * - [x] border-image
+ * - [x] border-inline-end
+ * - [x] border-inline-start
+ * - [ ] border-left
+ * - [x] border-radius
+ * - [ ] border-right
+ * - [x] border-style
+ * - [ ] border-top
+ * - [x] border-width
+ * - [ ] column-rule
+ * - [ ] columns
+ * - [ ] flex
+ * - [ ] flex-flow
+ * - [ ] font
+ * - [ ] gap
+ * - [ ] grid
+ * - [ ] grid-area
+ * - [ ] grid-column
+ * - [ ] grid-row
+ * - [ ] grid-template
+ * - [ ] list-style
+ * - [x] margin
+ * - [ ] mask
+ * - [ ] offset
+ * - [ ] outline
+ * - [x] overflow
+ * - [x] padding
+ * - [ ] place-content
+ * - [ ] place-items
+ * - [ ] place-self
+ * - [ ] scroll-margin
+ * - [ ] scroll-padding
+ * - [ ] text-decoration
+ * - [ ] text-emphasis
+ * - [ ] transition
+ */
+
+const expansions = {
+  // ...aliases,
+  border: rawValue => {
+    return [['borderTop', rawValue], ['borderEnd', rawValue], ['borderBottom', rawValue], ['borderStart', rawValue]];
+  },
+  /*
+  // Add this later, as this will be a breaking change
+  border: (rawValue: string) => {
+    if (typeof rawValue === 'number') {
+      return expansions.borderWidth(rawValue);
+    }
+    const [width, style, color] = splitValue(rawValue);
+    return [
+      ...expansions.borderWidth(width),
+      ...expansions.borderStyle(style),
+      ...expansions.borderColor(color),
+    ];
+  }
+  */
+  borderColor: rawValue => {
+    const [top, right = top, bottom = top, left = right] = splitValue(rawValue);
+    return [['borderTopColor', top], ['borderEndColor', right], ['borderBottomColor', bottom], ['borderStartColor', left]];
+  },
+  borderHorizontal: rawValue => {
+    return [['borderStart', rawValue], ['borderEnd', rawValue]];
+  },
+  borderStyle: rawValue => {
+    const [top, right = top, bottom = top, left = right] = splitValue(rawValue);
+    return [['borderTopStyle', top], ['borderEndStyle', right], ['borderBottomStyle', bottom], ['borderStartStyle', left]];
+  },
+  borderVertical: rawValue => {
+    return [['borderTop', rawValue], ['borderBottom', rawValue]];
+  },
+  borderWidth: rawValue => {
+    const [top, right = top, bottom = top, left = right] = typeof rawValue === 'number' ? [rawValue] : splitValue(rawValue);
+    return [['borderTopWidth', top], ['borderEndWidth', right], ['borderBottomWidth', bottom], ['borderStartWidth', left]];
+  },
+  borderRadius: rawValue => {
+    const [top, right = top, bottom = top, left = right] = typeof rawValue === 'string' ? splitValue(rawValue) : typeof rawValue === 'number' ? [rawValue] : rawValue; // remove
+
+    return [['borderTopStartRadius', top], ['borderTopEndRadius', right], ['borderBottomEndRadius', bottom], ['borderBottomStartRadius', left]];
+  },
+  margin: rawValue => {
+    const [top, right = top, bottom = top, left = right] = typeof rawValue === 'number' ? [rawValue] : splitValue(rawValue);
+    return [['marginTop', top], ['marginEnd', right], ['marginBottom', bottom], ['marginStart', left]];
+  },
+  marginHorizontal: rawValue => {
+    return [['marginStart', rawValue], ['marginEnd', rawValue]];
+  },
+  marginVertical: rawValue => {
+    return [['marginTop', rawValue], ['marginBottom', rawValue]];
+  },
+  overflow: rawValue => {
+    const [x, y = x] = splitValue(rawValue);
+    return [['overflowX', x], ['overflowY', y]];
+  },
+  padding: rawValue => {
+    const [top, right = top, bottom = top, left = right] = typeof rawValue === 'number' ? [rawValue] : splitValue(rawValue);
+    return [['paddingTop', top], ['paddingEnd', right], ['paddingBottom', bottom], ['paddingStart', left]];
+  },
+  paddingHorizontal: rawValue => {
+    return [['paddingStart', rawValue], ['paddingEnd', rawValue]];
+  },
+  paddingVertical: rawValue => {
+    return [['paddingTop', rawValue], ['paddingBottom', rawValue]];
+  }
+};
+function flatMapExpandedShorthands(objEntry) {
+  const [key, value] = objEntry;
+  const expansion = expansions[key];
+  if (expansion) {
+    if (Array.isArray(value)) {
+      throw new Error('Cannot use fallbacks for shorthands. Use the expansion instead.');
+    }
+    return expansion(value);
+  }
+  return [objEntry];
+}
+
+var objectUtils = {};
+
+var stylexInclude$1 = {};
+
+Object.defineProperty(stylexInclude$1, "__esModule", {
+  value: true
+});
+stylexInclude$1.IncludedStyles = void 0;
+stylexInclude$1.default = stylexInclude;
+var messages$2 = _interopRequireWildcard$2(messages$4);
+function _getRequireWildcardCache$2(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache$2 = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard$2(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache$2(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+let number = 0;
+function uuid() {
+  return `__included_${++number}__`;
+}
+let IncludedStyles$1 = class IncludedStyles {
+  constructor(astNode) {
+    this.astNode = astNode;
+  }
+};
+stylexInclude$1.IncludedStyles = IncludedStyles$1;
+function stylexInclude(firstArg) {
+  if ((arguments.length <= 1 ? 0 : arguments.length - 1) > 0) {
+    throw new Error(messages$2.ILLEGAL_ARGUMENT_LENGTH);
+  }
+  return {
+    [uuid()]: new IncludedStyles$1(firstArg.node)
+  };
+}
+
+Object.defineProperty(objectUtils, "__esModule", {
+  value: true
+});
+objectUtils.Pipe = void 0;
+objectUtils.flattenObject = flattenObject$1;
+objectUtils.objEntries = objEntries;
+objectUtils.objFromEntries = objFromEntries;
+objectUtils.objMap = objMap;
+objectUtils.objMapEntry = objMapEntry;
+objectUtils.objMapKeys = objMapKeys;
+objectUtils.objValues = objValues;
+var _stylexInclude$2 = stylexInclude$1;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+// A bunch of object utils with better Flow types
+
+function flattenObject$1(obj) {
+  const result = {};
+  for (const [key, value] of objEntries(obj)) {
+    if (typeof value === 'string') {
+      result[key] = value;
+    } else if (value instanceof _stylexInclude$2.IncludedStyles) {
+      result[key] = value;
+    } else {
+      for (const [subKey, subValue] of objEntries(value)) {
+        result[`${key}_${subKey}`] = subValue;
+      }
+    }
+  }
+  return result;
+}
+function objEntries(obj) {
+  const retVal = [];
+  for (const key of Object.keys(obj)) {
+    retVal.push([key, obj[key]]);
+  }
+  return retVal;
+}
+function objValues(obj) {
+  const retVal = [];
+  for (const key of Object.keys(obj)) {
+    retVal.push(obj[key]);
+  }
+  return retVal;
+}
+function objFromEntries(entries) {
+  const retVal = {};
+  for (const [key, value] of entries) {
+    retVal[key] = value;
+  }
+  return retVal;
+}
+function objMapKeys(obj, mapper) {
+  return objFromEntries(objEntries(obj).map(_ref => {
+    let [key, value] = _ref;
+    return [mapper(key), value];
+  }));
+}
+function objMapEntry(obj, mapper) {
+  return objFromEntries(objEntries(obj).map(_ref2 => {
+    let [key, value] = _ref2;
+    return mapper([key, value]);
+  }));
+}
+function objMap(obj, mapper) {
+  return objFromEntries(objEntries(obj).map(_ref3 => {
+    let [key, value] = _ref3;
+    return [key, mapper(value, key)];
+  }));
+}
+class Pipe {
+  constructor(val) {
+    this.value = val;
+  }
+  pipe(mapper) {
+    return new Pipe(mapper(this.value));
+  }
+  done() {
+    return this.value;
+  }
+  static create(val) {
+    return new Pipe(val);
+  }
+}
+objectUtils.Pipe = Pipe;
+
+Object.defineProperty(stylexCreate, "__esModule", {
+  value: true
+});
+stylexCreate.default = styleXCreateSet;
+var _convertToClassName = _interopRequireDefault$2(convertToClassName$1);
+var _expandShorthands$1 = _interopRequireDefault$2(expandShorthands);
+var _objectUtils$1 = objectUtils;
+var messages$1 = _interopRequireWildcard$1(messages$4);
+var _stylexInclude$1 = stylexInclude$1;
+function _getRequireWildcardCache$1(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache$1 = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard$1(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache$1(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault$2(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+// This takes the object of styles passed to `stylex.create` and transforms it.
+//   The transformation replaces style values with classNames.
+//
+// It also collects all injected styles along the way.
+// It then returns a tuple of the transformed style Object and an object of injected styles.
+//
+// This function does some basic validation, and then uses `styleXCreateNamespace` to transform
+// each namespace within,
+//
+// Before returning, it ensures that there are no duplicate styles being injected.
+function styleXCreateSet(namespaces) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const resolvedNamespaces = {};
+  const injectedStyles = {};
+  for (const namespaceName of Object.keys(namespaces)) {
+    const namespace = namespaces[namespaceName];
+    if (typeof namespace !== 'object' || Array.isArray(namespace)) {
+      throw new Error(messages$1.ILLEGAL_NAMESPACE_VALUE);
+    }
+    const [resolvedNamespace, injected] = styleXCreateNamespace(namespace, options);
+    resolvedNamespaces[namespaceName] = (0, _objectUtils$1.flattenObject)(resolvedNamespace);
+    for (const cn of Object.keys(injected)) {
+      if (injectedStyles[cn] == null) {
+        injectedStyles[cn] = injected[cn];
+      }
+    }
+  }
+  return [resolvedNamespaces, injectedStyles];
+}
+
+// Transforms a single style namespace.
+// e.g. Something along the lines of:
+//  {color: 'red', margin: '10px'} =>
+//  {
+//    color: 'color-red',
+//    marginTop: 'margin-top-10px',
+//    marginBottom: 'margin-bottom-10px',
+//    marginStart: 'margin-start-10px',
+//    marginEnd: 'margin-end-10px'
+//  }
+//
+// First, it expands shorthand properties. (margin => marginTop, marginBottom, marginStart, marginEnd)
+// Then, it converts each style value to a className.
+// Then, it returns the transformed style Object and an object of injected styles.
+function styleXCreateNamespace(style, options) {
+  const namespaceEntries = (0, _objectUtils$1.objEntries)(style);
+
+  // First the shorthand properties are expanded.
+  // e.g. `margin` gets expanded to `marginTop`, `marginBottom`, `marginStart`, `marginEnd`.
+  // `entries` is an array of [key, value] pairs.
+  const entries = namespaceEntries.flatMap(_ref => {
+    let [key, value] = _ref;
+    if (value instanceof _stylexInclude$1.IncludedStyles) {
+      return [[key, value]];
+    }
+    if (value != null && typeof value === 'object' && !Array.isArray(value)) {
+      if (!key.startsWith(':') && !key.startsWith('@')) {
+        throw new Error(messages$1.INVALID_PSEUDO);
+      }
+      return [[key, (0, _objectUtils$1.objFromEntries)((0, _objectUtils$1.objEntries)(value).flatMap(_ref2 => {
+        let [innerKey, innerValue] = _ref2;
+        if (innerValue != null && typeof innerValue === 'object' && !Array.isArray(innerValue)) {
+          throw new Error(messages$1.ILLEGAL_NESTED_PSEUDO);
+        }
+        return (0, _expandShorthands$1.default)([innerKey, innerValue]);
+      }))]];
+    } else {
+      if (typeof value !== 'string' && typeof value !== 'number' && !Array.isArray(value)) {
+        throw new Error(messages$1.ILLEGAL_PROP_VALUE);
+      }
+      if (Array.isArray(value) && value.some(val => typeof val === 'object')) {
+        throw new Error(messages$1.ILLEGAL_PROP_ARRAY_VALUE);
+      }
+      return (0, _expandShorthands$1.default)([key, value]);
+    }
+  });
+
+  // Now each [key, value] pair is considered a single atomic style.
+  // This atomic style is converted to a className by hashing
+  //
+  // The [key, className] pair is then added to the output Object: `resolvedNamespace`.
+  // While hashing, the CSS rule that the className is generated from is also added to the output Object: `injectedStyles`.
+  const resolvedNamespace = {};
+  const injectedStyles = {};
+  for (const [key, val] of entries) {
+    if (val instanceof _stylexInclude$1.IncludedStyles) {
+      resolvedNamespace[key] = val;
+    } else if (val != null && typeof val === 'object' && !Array.isArray(val)) {
+      const pseudo = key;
+      const innerObj = {};
+      for (const [innerKey, innerVal] of (0, _objectUtils$1.objEntries)(val)) {
+        const [updatedKey, className, cssRule] = (0, _convertToClassName.default)([innerKey, innerVal], pseudo, options);
+        innerObj[updatedKey] = className;
+        injectedStyles[updatedKey + pseudo] = [className, cssRule];
+      }
+      resolvedNamespace[key] = innerObj;
+    } else {
+      const [updatedKey, className, cssRule] = (0, _convertToClassName.default)([key, val], undefined, options);
+      resolvedNamespace[updatedKey] = className;
+      injectedStyles[updatedKey] = [className, cssRule];
+    }
+  }
+  const finalInjectedStyles = (0, _objectUtils$1.objFromEntries)((0, _objectUtils$1.objValues)(injectedStyles));
+  return [resolvedNamespace, finalInjectedStyles];
+}
+
+var stylexKeyframes = {};
+
+Object.defineProperty(stylexKeyframes, "__esModule", {
+  value: true
+});
+stylexKeyframes.default = styleXKeyframes;
+var _hash = _interopRequireDefault$1(hash$1);
+var _expandShorthands = _interopRequireDefault$1(expandShorthands);
+var _generateLtr = _interopRequireDefault$1(generateLtr);
+var _generateRtl = _interopRequireDefault$1(generateRtl);
+var _transformValue = _interopRequireDefault$1(transformValue$1);
+var _dashify = _interopRequireDefault$1(dashify$1);
+var _objectUtils = objectUtils;
+function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+// Similar to `stylex.create` it takes an object of keyframes
+// and returns a string after hashing it.
+//
+// It also expands shorthand properties to maintain parity with
+// `stylex.create`.
+function styleXKeyframes(frames) {
+  let {
+    stylexSheetName = '<>',
+    classNamePrefix = 'x'
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const expandedObject = (0, _objectUtils.objMap)(frames, frame => _objectUtils.Pipe.create(frame).pipe(expandFrameShorthands).pipe(x => (0, _objectUtils.objMapKeys)(x, _dashify.default)).pipe(x => (0, _objectUtils.objMap)(x, (value, key) => (0, _transformValue.default)(key, value))).done());
+  const ltrStyles = (0, _objectUtils.objMap)(expandedObject, frame => (0, _objectUtils.objMapEntry)(frame, _generateLtr.default));
+  const rtlStyles = (0, _objectUtils.objMap)(expandedObject, frame => (0, _objectUtils.objMapEntry)(frame, entry => (0, _generateRtl.default)(entry) ?? entry));
+  const ltrString = constructKeyframesObj(ltrStyles);
+  const rtlString = constructKeyframesObj(rtlStyles);
+
+  // This extra `-B` is kept for some idiosyncratic legacy compatibility for now.
+  const animationName = classNamePrefix + (0, _hash.default)(stylexSheetName + ltrString) + '-B';
+  const ltr = `@keyframes ${animationName}{${ltrString}}`;
+  const rtl = ltrString === rtlString ? null : `@keyframes ${animationName}{${rtlString}}`;
+  return [animationName, {
+    ltr,
+    rtl,
+    priority: 1
+  }];
+}
+function expandFrameShorthands(frame) {
+  return (0, _objectUtils.objFromEntries)((0, _objectUtils.objEntries)(frame).flatMap(pair => (0, _expandShorthands.default)(pair)));
+}
+
+// Create t
+function constructKeyframesObj(frames) {
+  return (0, _objectUtils.objEntries)(frames).map(_ref => {
+    let [key, value] = _ref;
+    return `${key}{${(0, _objectUtils.objEntries)(value).map(_ref2 => {
+      let [k, v] = _ref2;
+      return `${k}:${v};`;
+    }).join('')}}`;
+  }).join('');
+}
+
+var stylexFirstThatWorks$1 = {};
+
+Object.defineProperty(stylexFirstThatWorks$1, "__esModule", {
+  value: true
+});
+stylexFirstThatWorks$1.default = stylexFirstThatWorks;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ *
+ */
+
+function stylexFirstThatWorks() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return [...args].reverse();
+}
+
+Object.defineProperty(lib, "__esModule", {
+  value: true
+});
+var messages_1 = lib.messages = keyframes_1 = lib.keyframes = include_1 = lib.include = firstThatWorks_1 = lib.firstThatWorks = create_1 = lib.create = IncludedStyles_1 = lib.IncludedStyles = void 0;
+var _stylexCreate = _interopRequireDefault(stylexCreate);
+var _stylexKeyframes = _interopRequireDefault(stylexKeyframes);
+var _stylexInclude = _interopRequireWildcard(stylexInclude$1);
+var _stylexFirstThatWorks = _interopRequireDefault(stylexFirstThatWorks$1);
+var m = _interopRequireWildcard(messages$4);
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+// All functions exposed from `stylex` are defined in a way that can be run
+// entirely in the browser.
+
+// These are the implementations of those functions.
+
+const create = _stylexCreate.default;
+var create_1 = lib.create = create;
+const keyframes = _stylexKeyframes.default;
+var keyframes_1 = lib.keyframes = keyframes;
+const include = _stylexInclude.default;
+var include_1 = lib.include = include;
+const messages = m;
+messages_1 = lib.messages = messages;
+const IncludedStyles = _stylexInclude.IncludedStyles;
+var IncludedStyles_1 = lib.IncludedStyles = IncludedStyles;
+const firstThatWorks = _stylexFirstThatWorks.default;
+var firstThatWorks_1 = lib.firstThatWorks = firstThatWorks;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// TODO: We will need to maintain the full path to the file eventually
+// Perhaps this can be an option that is passed in.
+function namespaceToDevClassName(namespace, varName, filename) {
+  // Get the basename of the file without the extension
+  const basename = path.basename(filename).split('.')[0];
+
+  // Build up the class name, and sanitize it of disallowed characters
+  const className = `${basename}__${varName ? `${varName}.` : ''}${namespace}`;
+  return className.replace(/[^.a-zA-Z0-9_-]/g, '');
+}
+function injectDevClassNames(obj, varName, state) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const devClassName = namespaceToDevClassName(key, varName, state.filename ?? 'UnkownFile');
+    result[key] = {
+      [devClassName]: devClassName,
+      ...value
+    };
+  }
+  return result;
+}
+function convertToTestStyles(obj, varName, state) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const devClassName = namespaceToDevClassName(key, varName, state.filename ?? 'UnkownFile');
+    result[key] = {
+      [devClassName]: devClassName
+    };
+  }
+  return result;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function convertObjectToAST(obj) {
+  return t__namespace.objectExpression(Object.entries(obj).map(_ref => {
+    let [key, value] = _ref;
+    return value instanceof IncludedStyles_1 ? t__namespace.spreadElement(value.astNode) : t__namespace.objectProperty(canBeIdentifier(key) ? t__namespace.identifier(key) : t__namespace.stringLiteral(key), typeof value === 'string' ? t__namespace.stringLiteral(value) : convertObjectToAST(value));
+  }));
+}
+function canBeIdentifier(str) {
+  return str.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/) != null;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * This is a extended version of the path evaluation code from Babel.
+ *
+ * The original can be found at:
+ * https://github.com/babel/babel/blob/main/packages/babel-traverse/src/path/evaluation.ts
+ *
+ * The following extensions were made:
+ * - It can accept a mapping from variable names to functions
+ *   which when encountered will be evaluated instead of deopting.
+ *   - The functions can be configured to accept the raw path instead of
+ *     static values to handle dynamic values.
+ * - It can handle object spreads when the spread value itself is statically evaluated.
+ */
+
+// This file contains Babels metainterpreter that can evaluate static code.
+
+const VALID_CALLEES = ['String', 'Number', 'Math'];
+const INVALID_METHODS = ['random'];
+function isValidCallee(val) {
+  return VALID_CALLEES.includes(
+  // @ts-expect-error
+  val);
+}
+function isInvalidMethod(val) {
+  return INVALID_METHODS.includes(
+  // @ts-expect-error
+  val);
+}
+/**
+ * Deopts the evaluation
+ */
+function deopt(path, state) {
+  if (!state.confident) return;
+  state.deoptPath = path;
+  state.confident = false;
+}
+
+/**
+ * We wrap the _evaluate method so we can track `seen` nodes, we push an item
+ * to the map before we actually evaluate it so we can deopt on self recursive
+ * nodes such as:
+ *
+ *   var g = a ? 1 : 2,
+ *       a = g * this.foo
+ */
+function evaluateCached(path, state) {
+  const {
+    node
+  } = path;
+  const {
+    seen
+  } = state;
+  if (seen.has(node)) {
+    const existing = seen.get(node);
+    if (existing.resolved) {
+      return existing.value;
+    } else {
+      deopt(path, state);
+      return;
+    }
+  } else {
+    const item = {
+      resolved: false
+    };
+    seen.set(node, item);
+    const val = _evaluate(path, state);
+    if (state.confident) {
+      item.resolved = true;
+      item.value = val;
+    }
+    return val;
+  }
+}
+function _evaluate(path, state) {
+  if (!state.confident) return;
+  if (path.isSequenceExpression()) {
+    const exprs = path.get('expressions');
+    return evaluateCached(exprs[exprs.length - 1], state);
+  }
+  if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
+    return path.node.value;
+  }
+  if (path.isNullLiteral()) {
+    return null;
+  }
+  if (path.isTemplateLiteral()) {
+    return evaluateQuasis(path, path.node.quasis, state);
+  }
+  if (path.isTaggedTemplateExpression() && path.get('tag').isMemberExpression()) {
+    const object = path.get('tag.object');
+    const {
+      // @ts-expect-error todo(flow->ts): possible bug, object is can be any expression and so name might be undefined
+      node: {
+        name
+      }
+    } = object;
+    const property = path.get('tag.property');
+    if (object.isIdentifier() && name === 'String' &&
+    // todo(flow->ts): was changed from getBinding(name, true)
+    //  should this be hasBinding(name, true) as the binding is never used later?
+    !path.scope.getBinding(name) && property.isIdentifier() && property.node.name === 'raw') {
+      return evaluateQuasis(path, path.node.quasi.quasis, state, true);
+    }
+  }
+  if (path.isConditionalExpression()) {
+    const testResult = evaluateCached(path.get('test'), state);
+    if (!state.confident) return;
+    if (testResult) {
+      return evaluateCached(path.get('consequent'), state);
+    } else {
+      return evaluateCached(path.get('alternate'), state);
+    }
+  }
+  if (path.isExpressionWrapper()) {
+    // TypeCastExpression, ExpressionStatement etc
+    return evaluateCached(path.get('expression'), state);
+  }
+
+  // "foo".length
+  if (path.isMemberExpression() && !path.parentPath.isCallExpression({
+    callee: path.node
+  })) {
+    const property = path.get('property');
+    const object = path.get('object');
+    if (object.isLiteral() && property.isIdentifier()) {
+      // @ts-expect-error todo(flow->ts): instead of typeof - would it be better to check type of ast node?
+      const value = object.node.value;
+      const type = typeof value;
+      if (type === 'number' || type === 'string') {
+        return value[property.node.name];
+      }
+    }
+  }
+  if (path.isReferencedIdentifier()) {
+    const binding = path.scope.getBinding(path.node.name);
+    if (binding && binding.constantViolations.length > 0) {
+      return deopt(binding.path, state);
+    }
+    if (binding && path.node.start < binding.path.node.end) {
+      return deopt(binding.path, state);
+    }
+    if (binding !== null && binding !== void 0 && binding.hasValue) {
+      return binding.value;
+    } else {
+      if (path.node.name === 'undefined') {
+        return binding ? deopt(binding.path, state) : undefined;
+      } else if (path.node.name === 'Infinity') {
+        return binding ? deopt(binding.path, state) : Infinity;
+      } else if (path.node.name === 'NaN') {
+        return binding ? deopt(binding.path, state) : NaN;
+      }
+      const resolved = path.resolve();
+      if (resolved === path) {
+        return deopt(path, state);
+      } else {
+        return evaluateCached(resolved, state);
+      }
+    }
+  }
+  if (path.isUnaryExpression({
+    prefix: true
+  })) {
+    if (path.node.operator === 'void') {
+      // we don't need to evaluate the argument to know what this will return
+      return undefined;
+    }
+    const argument = path.get('argument');
+    if (path.node.operator === 'typeof' && (argument.isFunction() || argument.isClass())) {
+      return 'function';
+    }
+    const arg = evaluateCached(argument, state);
+    if (!state.confident) return;
+    switch (path.node.operator) {
+      case '!':
+        return !arg;
+      case '+':
+        return +arg;
+      case '-':
+        return -arg;
+      case '~':
+        return ~arg;
+      case 'typeof':
+        return typeof arg;
+    }
+  }
+  if (path.isArrayExpression()) {
+    const arr = [];
+    const elems = path.get('elements');
+    for (const elem of elems) {
+      const elemValue = evaluate(elem, state.functions);
+      if (elemValue.confident) {
+        arr.push(elemValue.value);
+      } else {
+        return deopt(elemValue.deopt, state);
+      }
+    }
+    return arr;
+  }
+  if (path.isObjectExpression()) {
+    const obj = {};
+    const props = path.get('properties');
+    for (const prop of props) {
+      if (prop.isObjectMethod()) {
+        return deopt(prop, state);
+      }
+      if (prop.isSpreadElement()) {
+        const spreadExpression = evaluateCached(prop.get('argument'), state);
+        if (!state.confident) {
+          return deopt(prop, state);
+        }
+        Object.assign(obj, spreadExpression);
+        continue;
+      }
+      const keyPath = prop.get('key');
+      let key = keyPath;
+      if (prop.node.computed) {
+        key = evaluate(key);
+        if (!key.confident) {
+          return deopt(key.deopt, state);
+        }
+        key = key.value;
+      } else if (key.isIdentifier()) {
+        key = key.node.name;
+      } else {
+        key = key.node.value;
+      }
+      // todo(flow->ts): remove typecast
+      const valuePath = prop.get('value');
+      let value = evaluate(valuePath, state.functions);
+      if (!value.confident) {
+        return deopt(value.deopt, state);
+      }
+      value = value.value;
+      // @ts-expect-error
+      obj[key] = value;
+    }
+    return obj;
+  }
+  if (path.isLogicalExpression()) {
+    // If we are confident that the left side of an && is false, or the left
+    // side of an || is true, we can be confident about the entire expression
+    const wasConfident = state.confident;
+    const left = evaluateCached(path.get('left'), state);
+    const leftConfident = state.confident;
+    state.confident = wasConfident;
+    const right = evaluateCached(path.get('right'), state);
+    const rightConfident = state.confident;
+    switch (path.node.operator) {
+      case '||':
+        // TODO consider having a "truthy type" that doesn't bail on
+        // left uncertainty but can still evaluate to truthy.
+        state.confident = leftConfident && (!!left || rightConfident);
+        if (!state.confident) return;
+        return left || right;
+      case '&&':
+        state.confident = leftConfident && (!left || rightConfident);
+        if (!state.confident) return;
+        return left && right;
+    }
+  }
+  if (path.isBinaryExpression()) {
+    const left = evaluateCached(path.get('left'), state);
+    if (!state.confident) return;
+    const right = evaluateCached(path.get('right'), state);
+    if (!state.confident) return;
+    switch (path.node.operator) {
+      case '-':
+        return left - right;
+      case '+':
+        return left + right;
+      case '/':
+        return left / right;
+      case '*':
+        return left * right;
+      case '%':
+        return left % right;
+      case '**':
+        return left ** right;
+      case '<':
+        return left < right;
+      case '>':
+        return left > right;
+      case '<=':
+        return left <= right;
+      case '>=':
+        return left >= right;
+      case '==':
+        return left == right;
+      // eslint-disable-line eqeqeq
+      case '!=':
+        return left != right;
+      case '===':
+        return left === right;
+      case '!==':
+        return left !== right;
+      case '|':
+        return left | right;
+      case '&':
+        return left & right;
+      case '^':
+        return left ^ right;
+      case '<<':
+        return left << right;
+      case '>>':
+        return left >> right;
+      case '>>>':
+        return left >>> right;
+    }
+  }
+  if (path.isCallExpression()) {
+    const callee = path.get('callee');
+    let context;
+    let func;
+
+    // Number(1);
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && isValidCallee(callee.node.name)) {
+      func = global[callee.node.name];
+    } else if (callee.isIdentifier() && state.functions.identifiers[callee.node.name]) {
+      func = state.functions.identifiers[callee.node.name];
+    }
+    if (callee.isMemberExpression()) {
+      const object = callee.get('object');
+      const property = callee.get('property');
+
+      // Math.min(1, 2)
+      if (object.isIdentifier() && property.isIdentifier()) {
+        if (isValidCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
+          context = global[object.node.name];
+          // @ts-expect-error property may not exist in context object
+          func = context[property.node.name];
+        } else if (state.functions.memberExpressions[object.node.name] && state.functions.memberExpressions[object.node.name][property.node.name]) {
+          context = state.functions.memberExpressions[object.node.name];
+          func = context[property.node.name];
+        }
+      }
+      if (object.isIdentifier() && property.isStringLiteral() && state.functions.memberExpressions[object.node.name] && state.functions.memberExpressions[object.node.name][property.node.value]) {
+        context = state.functions.memberExpressions[object.node.name];
+        func = context[property.node.value];
+      }
+
+      // "abc".charCodeAt(4)
+      if (object.isLiteral() && property.isIdentifier()) {
+        // @ts-expect-error todo(flow->ts): consider checking ast node type instead of value type (StringLiteral and NumberLiteral)
+        const type = typeof object.node.value;
+        if (type === 'string' || type === 'number') {
+          // @ts-expect-error todo(flow->ts): consider checking ast node type instead of value type
+          context = object.node.value;
+          func = context[property.node.name];
+        }
+      }
+    }
+    if (func) {
+      if (func.takesPath) {
+        const args = path.get('arguments');
+        return func.fn(...args);
+      } else {
+        const args = path.get('arguments').map(arg => evaluateCached(arg, state));
+        if (!state.confident) return;
+        if (func.fn) {
+          return func.fn.apply(context, args);
+        } else {
+          return func.apply(context, args);
+        }
+      }
+    }
+  }
+  deopt(path, state);
+}
+function evaluateQuasis(path, quasis, state) {
+  let raw = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  let str = '';
+  let i = 0;
+  const exprs = path.get('expressions');
+  for (const elem of quasis) {
+    // not confident, evaluated an expression we don't like
+    if (!state.confident) break;
+
+    // add on element
+    str += raw ? elem.value.raw : elem.value.cooked;
+
+    // add on interpolated expression if it's present
+    const expr = exprs[i++];
+    if (expr) str += String(evaluateCached(expr, state));
+  }
+  if (!state.confident) return;
+  return str;
+}
+
+/**
+ * Walk the input `node` and statically evaluate it.
+ *
+ * Returns an object in the form `{ confident, value, deopt }`. `confident`
+ * indicates whether or not we had to drop out of evaluating the expression
+ * because of hitting an unknown node that we couldn't confidently find the
+ * value of, in which case `deopt` is the path of said node.
+ *
+ * Example:
+ *
+ *   evaluate(parse("5 + 5")) // { confident: true, value: 10 }
+ *   evaluate(parse("!true")) // { confident: true, value: false }
+ *   evaluate(parse("foo + foo")) // { confident: false, value: undefined, deopt: NodePath }
+ *
+ */
+
+function evaluate(path) {
+  let functions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    identifiers: {},
+    memberExpressions: {}
+  };
+  const state = {
+    confident: true,
+    deoptPath: null,
+    seen: new Map(),
+    functions
+  };
+  let value = evaluateCached(path, state);
+  if (!state.confident) value = undefined;
+  return {
+    confident: state.confident,
+    deopt: state.deoptPath,
+    value: value
+  };
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/// This function looks for `stylex.create` calls and transforms them.
+//. 1. It finds the first argument to `stylex.create` and validates it.
+/// 2. It pre-processes valid-dynamic parts of style object such as custom presets (spreads)
+/// 3. It envalues the style object to get a JS object. This also handles local constants automatically.
+/// 4. It uses the `stylexCreate` from `@stylexjs/shared` to transform the JS
+///    object and to get a list of injected styles.
+/// 5. It converts the resulting Object back into an AST and replaces the call with it.
+/// 6. It also inserts `stylex.inject` calls above the current statement as needed.
+function transformStyleXCreate(path, state) {
+  const {
+    node
+  } = path;
+  if (node.type !== 'CallExpression') {
+    return;
+  }
+  if (node.callee.type === 'Identifier' && state.stylexCreateImport.has(node.callee.name) || node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.property.type === 'Identifier' && state.stylexImport.has(node.callee.object.name) && node.callee.property.name === 'create') {
+    validateStyleXCreate(path);
+    const args = path.get('arguments');
+    const firstArg = args[0];
+    if (firstArg == null || !firstArg.isObjectExpression()) {
+      throw new Error(messages_1.ILLEGAL_ARGUMENT_LENGTH);
+    }
+    const processingState = preProcessStyleArg(firstArg);
+    const injectedKeyframes = {};
+    function keyframes(animation) {
+      const [animationName, injectedStyle] = keyframes_1(animation, state.options);
+      injectedKeyframes[animationName] = injectedStyle;
+      return animationName;
+    }
+    const identifiers = {};
+    const memberExpressions = {};
+    state.stylexIncludeImport.forEach(name => {
+      identifiers[name] = {
+        fn: include_1,
+        takesPath: true
+      };
+    });
+    state.stylexFirstThatWorksImport.forEach(name => {
+      identifiers[name] = {
+        fn: firstThatWorks_1
+      };
+    });
+    state.stylexKeyframesImport.forEach(name => {
+      identifiers[name] = {
+        fn: keyframes
+      };
+    });
+    state.stylexImport.forEach(name => {
+      if (memberExpressions[name] == null) {
+        memberExpressions[name] = {};
+      }
+      memberExpressions[name].include = {
+        fn: include_1,
+        takesPath: true
+      };
+      memberExpressions[name].firstThatWorks = {
+        fn: firstThatWorks_1
+      };
+      memberExpressions[name].keyframes = {
+        fn: keyframes
+      };
+    });
+    const {
+      confident,
+      value
+    } = evaluate(firstArg, {
+      identifiers,
+      memberExpressions
+    });
+    if (!confident) {
+      throw new Error(messages_1.NON_STATIC_VALUE);
+    }
+    const plainObject = value;
+    let [compiledStyles, injectedStylesSansKeyframes] = create_1(plainObject, state.options);
+    const injectedStyles = {
+      ...injectedKeyframes,
+      ...injectedStylesSansKeyframes
+    };
+    let varName = null;
+    if (path.parentPath.isVariableDeclarator()) {
+      const idNode = path.parentPath.node.id;
+      if (idNode.type === 'Identifier') {
+        varName = idNode.name;
+      }
+    }
+    if (state.isTest) {
+      compiledStyles = convertToTestStyles(compiledStyles, varName, state);
+    } else if (state.isDev) {
+      compiledStyles = injectDevClassNames(compiledStyles, varName, state);
+    }
+    if (varName != null) {
+      state.styleMap.set(varName, compiledStyles);
+      state.styleVars.set(varName, path.parentPath);
+    }
+    path.replaceWith(convertObjectToAST(compiledStyles));
+    postProcessStyles(path, processingState);
+    if (Object.keys(injectedStyles).length === 0) {
+      return;
+    }
+    if (state.isDev || state.stylexSheetName == null) {
+      const statementPath = findNearestStatementAncestor(path);
+      let stylexName;
+      state.stylexImport.forEach(importName => {
+        stylexName = importName;
+      });
+      if (stylexName == null) {
+        stylexName = '__stylex__';
+        statementPath.insertBefore(t__namespace.importDeclaration([t__namespace.importDefaultSpecifier(t__namespace.identifier(stylexName))], t__namespace.stringLiteral('stylex')));
+      }
+      for (const [key, {
+        ltr,
+        priority,
+        rtl
+      }] of Object.entries(injectedStyles)) {
+        statementPath.insertBefore(t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.memberExpression(t__namespace.identifier(stylexName), t__namespace.identifier('inject')), [t__namespace.stringLiteral(ltr), t__namespace.numericLiteral(priority), ...(rtl != null ? [t__namespace.stringLiteral(rtl)] : [])])));
+      }
+    }
+    for (const [key, {
+      priority,
+      ...rest
+    }] of Object.entries(injectedStyles)) {
+      state.addStyle([key, rest, priority]);
+    }
+  }
+}
+
+// Validates the first argument to `stylex.create`.
+function validateStyleXCreate(path) {
+  if (path.parentPath == null || path.parentPath.isExpressionStatement()) {
+    throw new Error(messages_1.UNBOUND_STYLEX_CALL_VALUE);
+  }
+  const nearestStatement = findNearestStatementAncestor(path);
+  if (!nearestStatement.parentPath.isProgram() && !nearestStatement.parentPath.isExportNamedDeclaration()) {
+    throw new Error(messages_1.ONLY_TOP_LEVEL);
+  }
+  if (path.node.arguments.length !== 1) {
+    throw new Error(messages_1.ILLEGAL_ARGUMENT_LENGTH);
+  }
+  if (path.node.arguments[0].type !== 'ObjectExpression') {
+    throw new Error(messages_1.NON_OBJECT_FOR_STYLEX_CALL);
+  }
+}
+
+// Find the nearest statement ancestor of a given path.
+function findNearestStatementAncestor(path) {
+  if (path.isStatement()) {
+    return path;
+  }
+  if (path.parentPath == null) {
+    throw new Error('Unexpected Path found that is not part of the AST.');
+  }
+  return findNearestStatementAncestor(path.parentPath);
+}
+
+// These functions are for special handling of dynamic parts of the style object
+// Currently they handle spreading pre-defined style objects with stylex.create calls.
+//
+// It converts the spreads into a special string and remembers the original value in an object...
+
+function preProcessStyleArg(objPath) {
+  const state = {};
+  objPath.traverse({
+    SpreadElement(path) {
+      const argument = path.get('argument');
+      if (!argument.isTypeCastExpression()) {
+        return;
+      }
+      const expression = argument.get('expression');
+      if (!expression.isIdentifier() && !expression.isMemberExpression()) {
+        throw new Error(messages_1.ILLEGAL_NAMESPACE_VALUE);
+      }
+      if (!(path.parentPath.isObjectExpression() &&
+      // namespaceObject
+      path.parentPath.parentPath.isObjectProperty() &&
+      // namespaceProperty
+      path.parentPath.parentPath.parentPath.isObjectExpression() &&
+      // stylex.create argument
+      path.parentPath.parentPath.parentPath.parentPath.isCallExpression()
+      // stylex.create
+      )) {
+        // Disallow spreads within pseudo or media query objects
+        throw new Error(messages_1.ILLEGAL_NESTED_PSEUDO);
+      }
+      const key = `include(${toString(expression)})`;
+      path.replaceWith(t__namespace.objectProperty(t__namespace.stringLiteral(key), t__namespace.stringLiteral(key)));
+      state[key] = expression.node;
+    }
+  });
+  return state;
+}
+
+// Later, it finds those strings and replaces them back with their original values.
+function postProcessStyles(objPath, state) {
+  objPath.traverse({
+    ObjectProperty(path) {
+      const node = path.node.key;
+      if (node.type === 'StringLiteral' && state[node.value] != null) {
+        path.replaceWith(t__namespace.spreadElement(state[node.value]));
+      }
+    }
+  });
+}
+
+// A function to deterministicly convert a spreadded expression to a string.
+function toString(path) {
+  if (path.isIdentifier()) {
+    return path.node.name;
+  } else if (path.isStringLiteral() || path.isNumericLiteral()) {
+    return String(path.node.value);
+  } else if (path.isMemberExpression()) {
+    return `${toString(path.get('object'))}.${toString(path.get('property'))}`;
+  }
+  throw new Error(path.node.type);
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/// This function looks for `stylex.keyframes` calls and transforms them.
+//. 1. It finds the first argument to `stylex.keyframes` and validates it.
+/// 2. It envalues the style object to get a JS object. This also handles local constants automatically.
+/// 4. It uses the `stylexKeyframes` from `@stylexjs/shared` to transform the JS
+///    object and to get a list of injected styles.
+/// 5. It converts the resulting Object back into an AST and replaces the call with it.
+/// 6. It also inserts `stylex.inject` calls above the current statement as needed.
+function transformStyleXKeyframes(path, state) {
+  var _node$init;
+  const {
+    node
+  } = path;
+  if (((_node$init = node.init) === null || _node$init === void 0 ? void 0 : _node$init.type) !== 'CallExpression') {
+    return;
+  }
+  if (node.id.type !== 'Identifier') {
+    return;
+  }
+  if (node.init.callee.type === 'Identifier' && state.stylexKeyframesImport.has(node.init.callee.name) || node.init.callee.type === 'MemberExpression' && node.init.callee.object.type === 'Identifier' && node.init.callee.property.type === 'Identifier' && state.stylexImport.has(node.init.callee.object.name) && node.init.callee.property.name === 'keyframes') {
+    if (node.init.arguments.length !== 1) {
+      throw new Error(messages_1.ILLEGAL_ARGUMENT_LENGTH);
+    }
+    if (node.init.arguments[0].type !== 'ObjectExpression') {
+      throw new Error(messages_1.NON_OBJECT_FOR_STYLEX_CALL);
+    }
+    const init = path.get('init');
+    const args = init.get('arguments');
+    const firstArg = args[0];
+
+    // TODO: This doesn't support nested function calls.
+    // So when we add those, we'll need to replace this with an
+    // expanded fork of `evaluate` from `@babel/traverse.
+    const {
+      confident,
+      value
+    } = firstArg.evaluate();
+    if (!confident) {
+      throw new Error(messages_1.NON_STATIC_VALUE);
+    }
+    const plainObject = value;
+    assertValidKeyframes(plainObject);
+    let [animationName, injectedStyle] = keyframes_1(plainObject, state.options);
+
+    // This should be a string
+    path.get('init').replaceWith(t__namespace.stringLiteral(animationName));
+    const {
+      ltr,
+      priority,
+      rtl
+    } = injectedStyle;
+    if (state.isDev || state.stylexSheetName == null) {
+      // We know that the parent path is a variable declaration
+      const statementPath = path.parentPath;
+      let stylexName;
+      state.stylexImport.forEach(importName => {
+        stylexName = importName;
+      });
+      if (stylexName == null) {
+        stylexName = '__stylex__';
+        statementPath.insertBefore(t__namespace.importDeclaration([t__namespace.importDefaultSpecifier(t__namespace.identifier(stylexName))], t__namespace.stringLiteral('stylex')));
+      }
+      statementPath.insertBefore(t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.memberExpression(t__namespace.identifier(stylexName), t__namespace.identifier('inject')), [t__namespace.stringLiteral(ltr), t__namespace.numericLiteral(priority), ...(rtl != null ? [t__namespace.stringLiteral(rtl)] : [])])));
+    }
+    state.addStyle([animationName, {
+      ltr,
+      rtl
+    }, priority]);
+  }
+}
+// Validation of `stylex.keyframes` function call.
+function assertValidKeyframes(obj) {
+  if (typeof obj !== 'object' || Array.isArray(obj) || obj == null) {
+    throw new Error(messages_1.NON_OBJECT_FOR_STYLEX_CALL);
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value !== 'object' || Array.isArray(value)) {
+      throw new Error(messages_1.ILLEGAL_NAMESPACE_VALUE);
+    }
+  }
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function skipStylexMergeChildren(path, state) {
+  const {
+    node
+  } = path;
+  if (node == null || node.callee.type !== 'Identifier' || !state.stylexImport.has(node.callee.name)) {
+    return;
+  }
+  path.skip();
+}
+
+// If a `stylex()` call uses styles that are all locally defined,
+// This function is able to pre-compute that into a single string or
+// a single expression of strings and ternary expressions.
+function transformStyleXMerge(path, state) {
+  const {
+    node
+  } = path;
+  if (node == null || node.callee.type !== 'Identifier' || !state.stylexImport.has(node.callee.name)) {
+    return;
+  }
+  let bailOut = false;
+  const resolvedStyles = {};
+  for (const arg of node.arguments) {
+    switch (arg.type) {
+      case 'MemberExpression':
+        const {
+          property,
+          object,
+          computed
+        } = arg;
+        let objName = null;
+        let propName = null;
+        if (object.type === 'Identifier' && state.styleMap.has(object.name) && property.type === 'Identifier' && !computed) {
+          objName = object.name;
+          propName = property.name;
+        }
+        if (object.type === 'Identifier' && state.styleMap.has(object.name) && (property.type === 'StringLiteral' || property.type === 'NumericLiteral') && computed) {
+          objName = object.name;
+          propName = property.value;
+        }
+        if (objName != null && propName != null) {
+          const style = state.styleMap.get(objName);
+          if (style == null || style[propName] == null) {
+            throw new Error(`Unknown style ${objName}.${propName}. The defined style ${objName}, contains the following keys: ${Object.keys(style ?? {}).join(', ')}`);
+          }
+          const namespace = flattenObject(style[propName]);
+          Object.assign(resolvedStyles, namespace);
+        } else {
+          // Unknown style found. bail out.
+          bailOut = true;
+        }
+        break;
+      case 'ConditionalExpression':
+        const {
+          test,
+          consequent,
+          alternate
+        } = arg;
+        const primary = parseNullableStyle(consequent, state);
+        const fallback = parseNullableStyle(alternate, state);
+        if (primary === 'other' || fallback === 'other') {
+          bailOut = true;
+          break;
+        }
+        if (primary === null && fallback === null) {
+          // A no-op
+          break;
+        }
+        const allKeys = new Set([...Object.keys(primary ?? {}), ...Object.keys(fallback ?? {})]);
+        for (const key of allKeys) {
+          if (resolvedStyles[key] == null) {
+            const primaryValue = (primary === null || primary === void 0 ? void 0 : primary[key]) ?? resolvedStyles[key] ?? '';
+            const fallbackValue = (fallback === null || fallback === void 0 ? void 0 : fallback[key]) ?? resolvedStyles[key] ?? '';
+            resolvedStyles[key] = [test, primaryValue, fallbackValue];
+          }
+        }
+        break;
+      case 'LogicalExpression':
+        if (arg.operator !== '&&') {
+          bailOut = true;
+          break;
+        }
+        const {
+          left,
+          right
+        } = arg;
+        if (left.type === 'MemberExpression' && left.object.type === 'Identifier' && state.styleMap.has(left.object.name)) {
+          // We don't support `a && b` in stylex calls where `a` is a style namespace.
+          bailOut = true;
+          break;
+        }
+        const value = parseNullableStyle(right, state);
+        if (value === 'other') {
+          bailOut = true;
+          break;
+        }
+        if (value === null) {
+          // A no-op??
+          break;
+        }
+        for (const [key, val] of Object.entries(value)) {
+          resolvedStyles[key] = [left, val, resolvedStyles[key] ?? ''];
+        }
+        break;
+      default:
+        bailOut = true;
+        break;
+    }
+  }
+  if (bailOut) {
+    path.traverse({
+      MemberExpression(path) {
+        const object = path.get('object').node;
+        const property = path.get('property').node;
+        const computed = path.node.computed;
+        let objName = null;
+        let propName = null;
+        if (object.type === 'Identifier' && state.styleMap.has(object.name)) {
+          objName = object.name;
+          if (property.type === 'Identifier' && !computed) {
+            propName = property.name;
+          }
+          if ((property.type === 'StringLiteral' || property.type === 'NumericLiteral') && computed) {
+            propName = property.value;
+          }
+        }
+        if (objName != null) {
+          state.styleVarsToKeep.add([objName, propName != null ? String(propName) : null]);
+        }
+      }
+    });
+  } else {
+    path.skip();
+    // convert resolvedStyles to a string + ternary expressions
+    // We no longer need the keys, so we can just use the values.
+    const stringExpression = makeStringExpression(Object.values(resolvedStyles));
+    path.replaceWith(stringExpression);
+  }
+}
+
+// This function takes nested objects with styles collapses them to a single level deep.
+// `':hover': {color: 'red'}` becomes `':hover.color': 'red'`
+function flattenObject(object) {
+  const result = {};
+  for (const [key, value] of Object.entries(object)) {
+    if (typeof value === 'string') {
+      result[key] = value;
+    } else if (typeof value === 'object') {
+      for (const [subKey, subValue] of Object.entries(value)) {
+        result[`${key}.${subKey}`] = subValue;
+      }
+    }
+  }
+  return result;
+}
+
+// Looks for Null or locally defined style namespaces.
+// Otherwise it returns the string "other"
+// Which is used as an indicator to bail out of this optimization.
+function parseNullableStyle(node, state) {
+  if (t__namespace.isNullLiteral(node) || t__namespace.isIdentifier(node) && node.name === 'undefined') {
+    return null;
+  }
+  if (t__namespace.isMemberExpression(node)) {
+    const {
+      object: obj,
+      property: prop,
+      computed: computed
+    } = node;
+    if (obj.type !== 'Identifier' || !state.styleMap.has(obj.name) || prop.type !== 'Identifier' || computed) {
+      return 'other';
+    }
+    const namespace1 = state.styleMap.get(obj.name);
+    if (namespace1 == null) {
+      return 'other';
+    }
+    const style = namespace1[prop.name];
+    if (style == null) {
+      return 'other';
+    }
+    return flattenObject(style);
+  } else {
+    return 'other';
+  }
+}
+function makeStringExpression(values) {
+  let inTernary = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  // To start let's split the plain strings and everything else.
+  let strings = values.filter(value => typeof value === 'string').join(' ').trim();
+  if (inTernary && strings !== '') {
+    strings = ' ' + strings;
+  }
+  const nonStrings = values.filter(value => typeof value !== 'string');
+  const groupedByTest = groupBy(nonStrings, _ref => {
+    let [test, _a, _b] = _ref;
+    return test;
+  });
+  const eachTernary = [...groupedByTest.entries()].map(_ref2 => {
+    let [test, value] = _ref2;
+    const consequents = makeStringExpression(value.map(_ref3 => {
+      let [_a, a, _b] = _ref3;
+      return a;
+    }), true);
+    const fallbacks = makeStringExpression(value.map(_ref4 => {
+      let [_a, _b, b] = _ref4;
+      return b;
+    }), true);
+    return t__namespace.conditionalExpression(test, consequents, fallbacks);
+  });
+  return addAll([t__namespace.stringLiteral(strings), ...eachTernary]);
+}
+function addAll(_ref5) {
+  let [first, ...nodes] = _ref5;
+  if (nodes.length === 0) {
+    return first;
+  }
+  return t__namespace.binaryExpression('+', first, addAll(nodes));
+}
+
+// Array groupBy function
+function groupBy(array, key) {
+  const result = new Map();
+  for (const item of array) {
+    const k = key(item);
+    const array = result.get(k) ?? [];
+    array.push(item);
+    result.set(k, array);
+  }
+  return result;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const NAME = 'stylex';
+
+/**
+ * Entry point for the StyleX babel plugin.
+ */
+function styleXTransform() {
+  // To simplify state management, we use a StateManager object to abstract
+  // away some of the details.
+  let state;
+
+  /**
+   * Babel plugins will run the `visitor` on "enter" by default.
+   *
+   * This visitor object can be read mostly top-down, except, Program.exit runs
+   * after all other visitors.
+   */
+  return {
+    name: NAME,
+    visitor: {
+      Program: {
+        // First we reads all relevant imports and requires.
+        // Store them in the StateManager object.
+        enter: (path, s) => {
+          state = new StateManager(s);
+          for (const block of path.get('body')) {
+            if (block.isImportDeclaration()) {
+              // Read and remember 'stylex' Imports
+              // Consider user `path.referencesImport`
+              // But what about `requires`?
+              readImportDeclarations(block, state);
+            }
+            if (block.isVariableDeclaration()) {
+              for (const decl of block.get('declarations')) {
+                // Read and remember 'stylex' requires
+                readRequires(decl, state);
+              }
+            }
+          }
+          path.traverse({
+            // Look for stylex-related function calls and transform them.
+            // e.g.
+            //   stylex.create(...)
+            //   stylex.keyframes(...)
+            CallExpression(path) {
+              if (path.parentPath.isVariableDeclarator()) {
+                // # Look for `stylex.keyframes` calls
+                //   Needs to be handled *before* `stylex.create` as the `create` call
+                //   may use the generated animation name.
+                transformStyleXKeyframes(path.parentPath, state);
+              }
+              transformStyleXCreate(path, state);
+            }
+          });
+        },
+        // After all other visitors are done, we can remove `styles=stylex.create(...)`
+        // variables entirely if they're not needed.
+        exit: path => {
+          path.traverse({
+            CallExpression(path) {
+              transformStyleXMerge(path, state);
+            }
+          });
+          const varsToKeep = new Set([...state.styleVarsToKeep.values()].map(_ref => {
+            let [varName, _namespaceName] = _ref;
+            return varName;
+          }));
+          state.styleVars.forEach((path, varName) => {
+            if (!varsToKeep.has(varName) && !isExported(path)) {
+              path.remove();
+            }
+          });
+        }
+      },
+      CallExpression(path) {
+        // Don't traverse the children of `stylex(...)` calls.
+        // This is important for detecting which `stylex.create()` calls
+        // should be kept.
+        skipStylexMergeChildren(path, state);
+      },
+      Identifier(path) {
+        // Look for variables bound to `stylex.create` calls that are used
+        // outside of `stylex(...)` calls
+        if (path.isReferencedIdentifier()) {
+          const {
+            name
+          } = path.node;
+          if (state.styleMap.has(name)) {
+            if (path.parentPath.isMemberExpression()) {
+              const {
+                property,
+                computed
+              } = path.parentPath.node;
+              if (property.type === 'Identifier' && !computed) {
+                state.markComposedNamespace([name, property.name]);
+              }
+              if (property.type === 'StringLiteral' && computed) {
+                state.markComposedNamespace([name, property.value]);
+              }
+              state.markComposedNamespace([name, null]);
+            } else {
+              state.markComposedNamespace([name, null]);
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function isExported(path) {
+  if (path == null || path.isProgram()) {
+    return false;
+  }
+  if (path.isExportNamedDeclaration() || path.isExportDefaultDeclaration()) {
+    return true;
+  }
+  return isExported(path.parentPath);
+}
+
+/**
+ *
+ * @param rules An array of CSS rules that has been generated and collected from all JS files
+ * in a project
+ * @returns A string that represets the final CSS file.
+ *
+ * This function take an Array of CSS rules, de-duplicates them, sorts them priority and generates
+ * a final CSS file.
+ *
+ * When Stylex is correctly configured, the babel plugin will return an array of CSS rule objects.
+ * You're expected to concatenate all the Rules into a single Array and use this function to convert
+ * that into the final CSS file.
+ *
+ * End-users can choose to not use this function and use their own logic instead.
+ */
+const processStylexRules = function processStylexRules(rules) {
+  if (rules.length === 0) {
+    return '';
+  }
+  const sortedRules = rules.sort((_ref2, _ref3) => {
+    let [firstSelector,, firstPriority] = _ref2;
+    let [secondSelector,, secondPriority] = _ref3;
+    const priorityComparison = firstPriority - secondPriority;
+    if (priorityComparison !== 0) return priorityComparison;
+    return firstSelector < secondSelector ? -1 : 1;
+  });
+  const collectedCSS = Array.from(new Map(sortedRules).values()).flatMap(_ref4 => {
+    let {
+      ltr,
+      rtl
+    } = _ref4;
+    return rtl != null ? [addAncestorSelector(ltr, "html:not([dir='rtl'])"), addAncestorSelector(rtl, "html[dir='rtl']")] : [ltr];
+  }).join('\n');
+  return collectedCSS;
+};
+styleXTransform.processStylexRules = processStylexRules;
+
+/**
+ * Adds an ancestor selector in a media-query-aware way.
+ *
+ * Helper function for `processStylexRules`.
+ */
+function addAncestorSelector(selector, ancestorSelector) {
+  if (!selector.startsWith('@')) {
+    return `${ancestorSelector} ${selector}`;
+  }
+  const firstBracketIndex = selector.indexOf('{');
+  const mediaQueryPart = selector.slice(0, firstBracketIndex + 1);
+  const rest = selector.slice(firstBracketIndex + 1);
+  return `${mediaQueryPart}${ancestorSelector} ${rest}`;
+}
+
+exports.default = styleXTransform;
+exports.processStylexRules = processStylexRules;