init

mc_test/node_modules/@emotion/react/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Emotion team and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mc_test/node_modules/@emotion/react/README.md

@@ -0,0 +1,48 @@
+# @emotion/react
+
+> Simple styling in React.
+
+## Install
+
+```bash
+yarn add @emotion/react
+```
+
+## Usage
+
+```jsx
+/** @jsx jsx */
+import { jsx, css, Global, ClassNames } from '@emotion/react'
+
+render(
+  <div css={{ color: 'hotpink' }}>
+    <div
+      css={css`
+        color: green;
+      `}
+    />
+    <Global
+      styles={{
+        body: {
+          margin: 0,
+          padding: 0
+        }
+      }}
+    />
+    <ClassNames>
+      {({ css, cx }) => (
+        <div
+          className={cx(
+            'some-class',
+            css`
+              color: yellow;
+            `
+          )}
+        />
+      )}
+    </ClassNames>
+  </div>
+)
+```
+
+More documentation is available at [https://emotion.sh](https://emotion.sh).

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js

@@ -0,0 +1,11 @@
+import hoistNonReactStatics$1 from 'hoist-non-react-statics';
+
+// this file isolates this package that is not tree-shakeable
+// and if this module doesn't actually contain any logic of its own
+// then Rollup just use 'hoist-non-react-statics' directly in other chunks
+
+var hoistNonReactStatics = (function (targetComponent, sourceComponent) {
+  return hoistNonReactStatics$1(targetComponent, sourceComponent);
+});
+
+export { hoistNonReactStatics as default };

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.d.mts

@@ -0,0 +1,3 @@
+export * from "../../dist/declarations/src/_isolated-hnrs.js";
+export { _default as default } from "./emotion-react-_isolated-hnrs.cjs.default.js";
+//# sourceMappingURL=emotion-react-_isolated-hnrs.cjs.d.mts.map

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotion-react-_isolated-hnrs.cjs.d.mts","sourceRoot":"","sources":["../../dist/declarations/src/_isolated-hnrs.d.ts"],"names":[],"mappings":"AAAA"}

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.d.ts

@@ -0,0 +1,3 @@
+export * from "../../dist/declarations/src/_isolated-hnrs";
+export { default } from "../../dist/declarations/src/_isolated-hnrs";
+//# sourceMappingURL=emotion-react-_isolated-hnrs.cjs.d.ts.map

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotion-react-_isolated-hnrs.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/_isolated-hnrs.d.ts"],"names":[],"mappings":"AAAA"}

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.default.d.ts

@@ -0,0 +1 @@
+export { default as _default } from "../../dist/declarations/src/_isolated-hnrs.js"

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require("./emotion-react-_isolated-hnrs.cjs.js").default;

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.dev.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hoistNonReactStatics$1 = require('hoist-non-react-statics');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var hoistNonReactStatics__default = /*#__PURE__*/_interopDefault(hoistNonReactStatics$1);
+
+// this file isolates this package that is not tree-shakeable
+// and if this module doesn't actually contain any logic of its own
+// then Rollup just use 'hoist-non-react-statics' directly in other chunks
+
+var hoistNonReactStatics = (function (targetComponent, sourceComponent) {
+  return hoistNonReactStatics__default["default"](targetComponent, sourceComponent);
+});
+
+exports["default"] = hoistNonReactStatics;

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./emotion-react-_isolated-hnrs.cjs.prod.js");
+} else {
+  module.exports = require("./emotion-react-_isolated-hnrs.cjs.dev.js");
+}

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs

@@ -0,0 +1,4 @@
+export {
+  
+} from "./emotion-react-_isolated-hnrs.cjs.js";
+export { _default as default } from "./emotion-react-_isolated-hnrs.cjs.default.js";

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.prod.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hoistNonReactStatics$1 = require('hoist-non-react-statics');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var hoistNonReactStatics__default = /*#__PURE__*/_interopDefault(hoistNonReactStatics$1);
+
+// this file isolates this package that is not tree-shakeable
+// and if this module doesn't actually contain any logic of its own
+// then Rollup just use 'hoist-non-react-statics' directly in other chunks
+
+var hoistNonReactStatics = (function (targetComponent, sourceComponent) {
+  return hoistNonReactStatics__default["default"](targetComponent, sourceComponent);
+});
+
+exports["default"] = hoistNonReactStatics;

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js

@@ -0,0 +1,11 @@
+import hoistNonReactStatics$1 from 'hoist-non-react-statics';
+
+// this file isolates this package that is not tree-shakeable
+// and if this module doesn't actually contain any logic of its own
+// then Rollup just use 'hoist-non-react-statics' directly in other chunks
+
+var hoistNonReactStatics = (function (targetComponent, sourceComponent) {
+  return hoistNonReactStatics$1(targetComponent, sourceComponent);
+});
+
+export { hoistNonReactStatics as default };

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.umd.min.js

@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).emotionHoistNonReactStatics=t()}(this,(function(){"use strict";function e(e,t,r){return e(r={path:t,exports:{},require:function(e,t){return function(){throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs")}(null==t&&r.path)}},r.exports),r.exports}var t=e((function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var r="function"==typeof Symbol&&Symbol.for,o=r?Symbol.for("react.element"):60103,n=r?Symbol.for("react.portal"):60106,f=r?Symbol.for("react.fragment"):60107,c=r?Symbol.for("react.strict_mode"):60108,i=r?Symbol.for("react.profiler"):60114,a=r?Symbol.for("react.provider"):60109,s=r?Symbol.for("react.context"):60110,u=r?Symbol.for("react.async_mode"):60111,p=r?Symbol.for("react.concurrent_mode"):60111,y=r?Symbol.for("react.forward_ref"):60112,l=r?Symbol.for("react.suspense"):60113,m=r?Symbol.for("react.suspense_list"):60120,d=r?Symbol.for("react.memo"):60115,b=r?Symbol.for("react.lazy"):60116,$=r?Symbol.for("react.fundamental"):60117,S=r?Symbol.for("react.responder"):60118,g=r?Symbol.for("react.scope"):60119;function v(e){if("object"==typeof e&&null!==e){var t=e.$$typeof;switch(t){case o:switch(e=e.type){case u:case p:case f:case i:case c:case l:return e;default:switch(e=e&&e.$$typeof){case s:case y:case b:case d:case a:return e;default:return t}}case n:return t}}}function P(e){return v(e)===p}t.typeOf=v,t.AsyncMode=u,t.ConcurrentMode=p,t.ContextConsumer=s,t.ContextProvider=a,t.Element=o,t.ForwardRef=y,t.Fragment=f,t.Lazy=b,t.Memo=d,t.Portal=n,t.Profiler=i,t.StrictMode=c,t.Suspense=l,t.isValidElementType=function(e){return"string"==typeof e||"function"==typeof e||e===f||e===p||e===i||e===c||e===l||e===m||"object"==typeof e&&null!==e&&(e.$$typeof===b||e.$$typeof===d||e.$$typeof===a||e.$$typeof===s||e.$$typeof===y||e.$$typeof===$||e.$$typeof===S||e.$$typeof===g)},t.isAsyncMode=function(e){return P(e)||v(e)===u},t.isConcurrentMode=P,t.isContextConsumer=function(e){return v(e)===s},t.isContextProvider=function(e){return v(e)===a},t.isElement=function(e){return"object"==typeof e&&null!==e&&e.$$typeof===o},t.isForwardRef=function(e){return v(e)===y},t.isFragment=function(e){return v(e)===f},t.isLazy=function(e){return v(e)===b},t.isMemo=function(e){return v(e)===d},t.isPortal=function(e){return v(e)===n},t.isProfiler=function(e){return v(e)===i},t.isStrictMode=function(e){return v(e)===c},t.isSuspense=function(e){return v(e)===l}}));e((function(e,t){}));var r=e((function(e){e.exports=t})),o={childContextTypes:!0,contextType:!0,contextTypes:!0,defaultProps:!0,displayName:!0,getDefaultProps:!0,getDerivedStateFromError:!0,getDerivedStateFromProps:!0,mixins:!0,propTypes:!0,type:!0},n={name:!0,length:!0,prototype:!0,caller:!0,callee:!0,arguments:!0,arity:!0},f={$$typeof:!0,compare:!0,defaultProps:!0,displayName:!0,propTypes:!0,type:!0},c={};function i(e){return r.isMemo(e)?f:c[e.$$typeof]||o}c[r.ForwardRef]={$$typeof:!0,render:!0,defaultProps:!0,displayName:!0,propTypes:!0};var a=Object.defineProperty,s=Object.getOwnPropertyNames,u=Object.getOwnPropertySymbols,p=Object.getOwnPropertyDescriptor,y=Object.getPrototypeOf,l=Object.prototype;var m=function e(t,r,o){if("string"!=typeof r){if(l){var f=y(r);f&&f!==l&&e(t,f,o)}var c=s(r);u&&(c=c.concat(u(r)));for(var m=i(t),d=i(r),b=0;b<c.length;++b){var $=c[b];if(!(n[$]||o&&o[$]||d&&d[$]||m&&m[$])){var S=p(r,$);try{a(t,$,S)}catch(e){}}}}return t};return function(e,t){return m(e,t)}}));
+//# sourceMappingURL=emotion-react-_isolated-hnrs.umd.min.js.map

mc_test/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js

@@ -0,0 +1,11 @@
+import hoistNonReactStatics$1 from 'hoist-non-react-statics';
+
+// this file isolates this package that is not tree-shakeable
+// and if this module doesn't actually contain any logic of its own
+// then Rollup just use 'hoist-non-react-statics' directly in other chunks
+
+var hoistNonReactStatics = (function (targetComponent, sourceComponent) {
+  return hoistNonReactStatics$1(targetComponent, sourceComponent);
+});
+
+export { hoistNonReactStatics as default };

mc_test/node_modules/@emotion/react/_isolated-hnrs/package.json

@@ -0,0 +1,12 @@
+{
+  "main": "dist/emotion-react-_isolated-hnrs.cjs.js",
+  "module": "dist/emotion-react-_isolated-hnrs.esm.js",
+  "umd:main": "dist/emotion-react-_isolated-hnrs.umd.min.js",
+  "browser": {
+    "./dist/emotion-react-_isolated-hnrs.esm.js": "./dist/emotion-react-_isolated-hnrs.browser.esm.js"
+  },
+  "sideEffects": false,
+  "preconstruct": {
+    "umdName": "emotionHoistNonReactStatics"
+  }
+}

mc_test/node_modules/@emotion/react/dist/declarations/src/_isolated-hnrs.d.ts

@@ -0,0 +1,3 @@
+// this entry point is not publicly available so we don't need to expose any types here
+// we need to define a definition file for each entrypoint though, otherwise Preconstruct might get confused
+export {}

mc_test/node_modules/@emotion/react/dist/declarations/src/index.d.ts

@@ -0,0 +1 @@
+export * from '../types/index'

mc_test/node_modules/@emotion/react/dist/declarations/src/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export * from '../types/jsx-dev-runtime'

mc_test/node_modules/@emotion/react/dist/declarations/src/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export * from '../types/jsx-runtime'

mc_test/node_modules/@emotion/react/dist/declarations/types/helper.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react'
+
+/**
+ * @desc Utility type for getting props type of React component.
+ * It takes `defaultProps` into an account - making props with defaults optional.
+ */
+export type PropsOf<
+  C extends keyof JSX.IntrinsicElements | React.JSXElementConstructor<any>
+> = JSX.LibraryManagedAttributes<C, React.ComponentProps<C>>
+
+// We need to use this version of Omit as it's distributive (Will preserve unions)
+export type DistributiveOmit<T, U> = T extends any
+  ? Pick<T, Exclude<keyof T, U>>
+  : never

mc_test/node_modules/@emotion/react/dist/declarations/types/index.d.ts

@@ -0,0 +1,115 @@
+// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
+// TypeScript Version: 3.4
+
+import { EmotionCache } from '@emotion/cache'
+import {
+  ArrayInterpolation,
+  ComponentSelector,
+  CSSInterpolation,
+  CSSObject,
+  FunctionInterpolation,
+  Interpolation,
+  Keyframes,
+  SerializedStyles
+} from '@emotion/serialize'
+import {
+  ClassAttributes,
+  Context,
+  Provider,
+  FC,
+  ReactElement,
+  ReactNode,
+  Ref,
+  createElement
+} from 'react'
+import { EmotionJSX } from './jsx-namespace'
+
+export {
+  ArrayInterpolation,
+  ComponentSelector,
+  CSSObject,
+  EmotionCache,
+  FunctionInterpolation,
+  Interpolation,
+  Keyframes,
+  SerializedStyles
+}
+
+export * from './theming'
+export * from './helper'
+
+// tslint:disable-next-line: no-empty-interface
+export interface Theme {}
+
+export const ThemeContext: Context<object>
+export const CacheProvider: Provider<EmotionCache>
+export function withEmotionCache<Props, RefType = any>(
+  func: (props: Props, context: EmotionCache, ref: Ref<RefType>) => ReactNode
+): FC<Props & ClassAttributes<RefType>>
+
+export function css(
+  template: TemplateStringsArray,
+  ...args: Array<CSSInterpolation>
+): SerializedStyles
+export function css(...args: Array<CSSInterpolation>): SerializedStyles
+
+export interface GlobalProps {
+  styles: Interpolation<Theme>
+}
+
+/**
+ * @desc
+ * JSX generic are supported only after TS@2.9
+ */
+export function Global(props: GlobalProps): ReactElement
+
+export function keyframes(
+  template: TemplateStringsArray,
+  ...args: Array<CSSInterpolation>
+): Keyframes
+export function keyframes(...args: Array<CSSInterpolation>): Keyframes
+
+export interface ArrayClassNamesArg extends Array<ClassNamesArg> {}
+export type ClassNamesArg =
+  | undefined
+  | null
+  | string
+  | boolean
+  | { [className: string]: boolean | null | undefined }
+  | ArrayClassNamesArg
+
+export interface ClassNamesContent {
+  css(template: TemplateStringsArray, ...args: Array<CSSInterpolation>): string
+  css(...args: Array<CSSInterpolation>): string
+  cx(...args: Array<ClassNamesArg>): string
+  theme: Theme
+}
+export interface ClassNamesProps {
+  children(content: ClassNamesContent): ReactNode
+}
+/**
+ * @desc
+ * JSX generic are supported only after TS@2.9
+ */
+export function ClassNames(props: ClassNamesProps): ReactElement
+
+export const jsx: typeof createElement
+export namespace jsx {
+  namespace JSX {
+    type ElementType = EmotionJSX.ElementType
+    interface Element extends EmotionJSX.Element {}
+    interface ElementClass extends EmotionJSX.ElementClass {}
+    interface ElementAttributesProperty
+      extends EmotionJSX.ElementAttributesProperty {}
+    interface ElementChildrenAttribute
+      extends EmotionJSX.ElementChildrenAttribute {}
+    type LibraryManagedAttributes<C, P> = EmotionJSX.LibraryManagedAttributes<
+      C,
+      P
+    >
+    interface IntrinsicAttributes extends EmotionJSX.IntrinsicAttributes {}
+    interface IntrinsicClassAttributes<T>
+      extends EmotionJSX.IntrinsicClassAttributes<T> {}
+    type IntrinsicElements = EmotionJSX.IntrinsicElements
+  }
+}

mc_test/node_modules/@emotion/react/dist/declarations/types/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export { EmotionJSX as JSX } from './jsx-namespace'

mc_test/node_modules/@emotion/react/dist/declarations/types/jsx-namespace.d.ts

@@ -0,0 +1,45 @@
+import 'react'
+import { Interpolation } from '@emotion/serialize'
+import { Theme } from './index'
+
+type WithConditionalCSSProp<P> = 'className' extends keyof P
+  ? string extends P['className' & keyof P]
+    ? { css?: Interpolation<Theme> }
+    : {}
+  : {}
+
+// unpack all here to avoid infinite self-referencing when defining our own JSX namespace
+type ReactJSXElement = JSX.Element
+type ReactJSXElementClass = JSX.ElementClass
+type ReactJSXElementAttributesProperty = JSX.ElementAttributesProperty
+type ReactJSXElementChildrenAttribute = JSX.ElementChildrenAttribute
+type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
+type ReactJSXIntrinsicAttributes = JSX.IntrinsicAttributes
+type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
+type ReactJSXIntrinsicElements = JSX.IntrinsicElements
+
+// based on the code from @types/react@18.2.8
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/3197efc097d522c4bf02b94e1a0766d007d6cdeb/types/react/index.d.ts#LL3204C13-L3204C13
+type ReactJSXElementType = string | React.JSXElementConstructor<any>
+
+export namespace EmotionJSX {
+  type ElementType = ReactJSXElementType
+  interface Element extends ReactJSXElement {}
+  interface ElementClass extends ReactJSXElementClass {}
+  interface ElementAttributesProperty
+    extends ReactJSXElementAttributesProperty {}
+  interface ElementChildrenAttribute extends ReactJSXElementChildrenAttribute {}
+
+  type LibraryManagedAttributes<C, P> = WithConditionalCSSProp<P> &
+    ReactJSXLibraryManagedAttributes<C, P>
+
+  interface IntrinsicAttributes extends ReactJSXIntrinsicAttributes {}
+  interface IntrinsicClassAttributes<T>
+    extends ReactJSXIntrinsicClassAttributes<T> {}
+
+  type IntrinsicElements = {
+    [K in keyof ReactJSXIntrinsicElements]: ReactJSXIntrinsicElements[K] & {
+      css?: Interpolation<Theme>
+    }
+  }
+}

mc_test/node_modules/@emotion/react/dist/declarations/types/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export { EmotionJSX as JSX } from './jsx-namespace'

mc_test/node_modules/@emotion/react/dist/declarations/types/theming.d.ts

@@ -0,0 +1,31 @@
+// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
+// TypeScript Version: 3.1
+
+import * as React from 'react'
+import { Theme } from '@emotion/react'
+import { DistributiveOmit, PropsOf } from './helper'
+
+export interface ThemeProviderProps {
+  theme: Partial<Theme> | ((outerTheme: Theme) => Theme)
+  children: React.ReactNode
+}
+
+export interface ThemeProvider {
+  (props: ThemeProviderProps): React.ReactElement
+}
+
+export type withTheme = <
+  C extends React.ComponentType<React.ComponentProps<C>>
+>(
+  component: C
+) => React.FC<DistributiveOmit<PropsOf<C>, 'theme'> & { theme?: Theme }>
+
+export function useTheme(): Theme
+
+export const ThemeProvider: ThemeProvider
+
+export const withTheme: withTheme
+
+export type WithTheme<P, T> = P extends { theme: infer Theme }
+  ? P & { theme: Exclude<Theme, undefined> }
+  : P & { theme: T }

mc_test/node_modules/@emotion/react/dist/emotion-element-2408c5fb.worker.esm.js

@@ -0,0 +1,278 @@
+import * as React from 'react';
+import { useContext, forwardRef } from 'react';
+import createCache from '@emotion/cache';
+import _extends from '@babel/runtime/helpers/esm/extends';
+import weakMemoize from '@emotion/weak-memoize';
+import hoistNonReactStatics from '../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js';
+import { getRegisteredStyles, registerStyles, insertStyles } from '@emotion/utils';
+import { serializeStyles } from '@emotion/serialize';
+import { useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';
+
+var isBrowser = "undefined" !== 'undefined';
+var hasOwnProperty = {}.hasOwnProperty;
+
+var EmotionCacheContext = /* #__PURE__ */React.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
+// because this module is primarily intended for the browser and node
+// but it's also required in react native and similar environments sometimes
+// and we could have a special build just for that
+// but this is much easier and the native packages
+// might use a different theme context in the future anyway
+typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache({
+  key: 'css'
+}) : null);
+
+if (process.env.NODE_ENV !== 'production') {
+  EmotionCacheContext.displayName = 'EmotionCacheContext';
+}
+
+var CacheProvider = EmotionCacheContext.Provider;
+var __unsafe_useEmotionCache = function useEmotionCache() {
+  return useContext(EmotionCacheContext);
+};
+
+var withEmotionCache = function withEmotionCache(func) {
+  // $FlowFixMe
+  return /*#__PURE__*/forwardRef(function (props, ref) {
+    // the cache will never be null in the browser
+    var cache = useContext(EmotionCacheContext);
+    return func(props, cache, ref);
+  });
+};
+
+if (!isBrowser) {
+  withEmotionCache = function withEmotionCache(func) {
+    return function (props) {
+      var cache = useContext(EmotionCacheContext);
+
+      if (cache === null) {
+        // yes, we're potentially creating this on every render
+        // it doesn't actually matter though since it's only on the server
+        // so there will only every be a single render
+        // that could change in the future because of suspense and etc. but for now,
+        // this works and i don't want to optimise for a future thing that we aren't sure about
+        cache = createCache({
+          key: 'css'
+        });
+        return /*#__PURE__*/React.createElement(EmotionCacheContext.Provider, {
+          value: cache
+        }, func(props, cache));
+      } else {
+        return func(props, cache);
+      }
+    };
+  };
+}
+
+var ThemeContext = /* #__PURE__ */React.createContext({});
+
+if (process.env.NODE_ENV !== 'production') {
+  ThemeContext.displayName = 'EmotionThemeContext';
+}
+
+var useTheme = function useTheme() {
+  return React.useContext(ThemeContext);
+};
+
+var getTheme = function getTheme(outerTheme, theme) {
+  if (typeof theme === 'function') {
+    var mergedTheme = theme(outerTheme);
+
+    if (process.env.NODE_ENV !== 'production' && (mergedTheme == null || typeof mergedTheme !== 'object' || Array.isArray(mergedTheme))) {
+      throw new Error('[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!');
+    }
+
+    return mergedTheme;
+  }
+
+  if (process.env.NODE_ENV !== 'production' && (theme == null || typeof theme !== 'object' || Array.isArray(theme))) {
+    throw new Error('[ThemeProvider] Please make your theme prop a plain object');
+  }
+
+  return _extends({}, outerTheme, theme);
+};
+
+var createCacheWithTheme = /* #__PURE__ */weakMemoize(function (outerTheme) {
+  return weakMemoize(function (theme) {
+    return getTheme(outerTheme, theme);
+  });
+});
+var ThemeProvider = function ThemeProvider(props) {
+  var theme = React.useContext(ThemeContext);
+
+  if (props.theme !== theme) {
+    theme = createCacheWithTheme(theme)(props.theme);
+  }
+
+  return /*#__PURE__*/React.createElement(ThemeContext.Provider, {
+    value: theme
+  }, props.children);
+};
+function withTheme(Component) {
+  var componentName = Component.displayName || Component.name || 'Component';
+
+  var render = function render(props, ref) {
+    var theme = React.useContext(ThemeContext);
+    return /*#__PURE__*/React.createElement(Component, _extends({
+      theme: theme,
+      ref: ref
+    }, props));
+  }; // $FlowFixMe
+
+
+  var WithTheme = /*#__PURE__*/React.forwardRef(render);
+  WithTheme.displayName = "WithTheme(" + componentName + ")";
+  return hoistNonReactStatics(WithTheme, Component);
+}
+
+var getLastPart = function getLastPart(functionName) {
+  // The match may be something like 'Object.createEmotionProps' or
+  // 'Loader.prototype.render'
+  var parts = functionName.split('.');
+  return parts[parts.length - 1];
+};
+
+var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
+  // V8
+  var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
+  if (match) return getLastPart(match[1]); // Safari / Firefox
+
+  match = /^([A-Za-z0-9$.]+)@/.exec(line);
+  if (match) return getLastPart(match[1]);
+  return undefined;
+};
+
+var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS
+// identifiers, thus we only need to replace what is a valid character for JS,
+// but not for CSS.
+
+var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
+  return identifier.replace(/\$/g, '-');
+};
+
+var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
+  if (!stackTrace) return undefined;
+  var lines = stackTrace.split('\n');
+
+  for (var i = 0; i < lines.length; i++) {
+    var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error"
+
+    if (!functionName) continue; // If we reach one of these, we have gone too far and should quit
+
+    if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
+    // uppercase letter
+
+    if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
+  }
+
+  return undefined;
+};
+
+var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
+var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
+var createEmotionProps = function createEmotionProps(type, props) {
+  if (process.env.NODE_ENV !== 'production' && typeof props.css === 'string' && // check if there is a css declaration
+  props.css.indexOf(':') !== -1) {
+    throw new Error("Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/react' like this: css`" + props.css + "`");
+  }
+
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when
+  // the label hasn't already been computed
+
+  if (process.env.NODE_ENV !== 'production' && !!props.css && (typeof props.css !== 'object' || typeof props.css.name !== 'string' || props.css.name.indexOf('-') === -1)) {
+    var label = getLabelFromStackTrace(new Error().stack);
+    if (label) newProps[labelPropName] = label;
+  }
+
+  return newProps;
+};
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serialized = _ref.serialized,
+      isStringTag = _ref.isStringTag;
+  registerStyles(cache, serialized, isStringTag);
+  var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
+    return insertStyles(cache, serialized, isStringTag);
+  });
+
+  if (rules !== undefined) {
+    var _ref2;
+
+    var serializedNames = serialized.name;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      next = next.next;
+    }
+
+    return /*#__PURE__*/React.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedNames, _ref2.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref2.nonce = cache.sheet.nonce, _ref2));
+  }
+
+  return null;
+};
+
+var Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {
+  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
+  // not passing the registered cache to serializeStyles because it would
+  // make certain babel optimisations not possible
+
+  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
+    cssProp = cache.registered[cssProp];
+  }
+
+  var WrappedComponent = props[typePropName];
+  var registeredStyles = [cssProp];
+  var className = '';
+
+  if (typeof props.className === 'string') {
+    className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
+  } else if (props.className != null) {
+    className = props.className + " ";
+  }
+
+  var serialized = serializeStyles(registeredStyles, undefined, React.useContext(ThemeContext));
+
+  if (process.env.NODE_ENV !== 'production' && serialized.name.indexOf('-') === -1) {
+    var labelFromStack = props[labelPropName];
+
+    if (labelFromStack) {
+      serialized = serializeStyles([serialized, 'label:' + labelFromStack + ';']);
+    }
+  }
+
+  className += cache.key + "-" + serialized.name;
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && (process.env.NODE_ENV === 'production' || key !== labelPropName)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps.ref = ref;
+  newProps.className = className;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {
+    cache: cache,
+    serialized: serialized,
+    isStringTag: typeof WrappedComponent === 'string'
+  }), /*#__PURE__*/React.createElement(WrappedComponent, newProps));
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  Emotion.displayName = 'EmotionCssPropInternal';
+}
+
+var Emotion$1 = Emotion;
+
+export { CacheProvider as C, Emotion$1 as E, ThemeContext as T, __unsafe_useEmotionCache as _, ThemeProvider as a, withTheme as b, createEmotionProps as c, hasOwnProperty as h, isBrowser as i, useTheme as u, withEmotionCache as w };

mc_test/node_modules/@emotion/react/dist/emotion-element-4300ad44.cjs.prod.js

@@ -0,0 +1,230 @@
+'use strict';
+
+var React = require('react');
+var createCache = require('@emotion/cache');
+var _extends = require('@babel/runtime/helpers/extends');
+var weakMemoize = require('@emotion/weak-memoize');
+var _isolatedHnrs_dist_emotionReact_isolatedHnrs = require('../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.prod.js');
+var utils = require('@emotion/utils');
+var serialize = require('@emotion/serialize');
+var useInsertionEffectWithFallbacks = require('@emotion/use-insertion-effect-with-fallbacks');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+var createCache__default = /*#__PURE__*/_interopDefault(createCache);
+var weakMemoize__default = /*#__PURE__*/_interopDefault(weakMemoize);
+
+var isBrowser = typeof document !== 'undefined';
+var hasOwnProperty = {}.hasOwnProperty;
+
+var EmotionCacheContext = /* #__PURE__ */React__namespace.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
+// because this module is primarily intended for the browser and node
+// but it's also required in react native and similar environments sometimes
+// and we could have a special build just for that
+// but this is much easier and the native packages
+// might use a different theme context in the future anyway
+typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache__default["default"]({
+  key: 'css'
+}) : null);
+
+var CacheProvider = EmotionCacheContext.Provider;
+var __unsafe_useEmotionCache = function useEmotionCache() {
+  return React.useContext(EmotionCacheContext);
+};
+
+exports.withEmotionCache = function withEmotionCache(func) {
+  // $FlowFixMe
+  return /*#__PURE__*/React.forwardRef(function (props, ref) {
+    // the cache will never be null in the browser
+    var cache = React.useContext(EmotionCacheContext);
+    return func(props, cache, ref);
+  });
+};
+
+if (!isBrowser) {
+  exports.withEmotionCache = function withEmotionCache(func) {
+    return function (props) {
+      var cache = React.useContext(EmotionCacheContext);
+
+      if (cache === null) {
+        // yes, we're potentially creating this on every render
+        // it doesn't actually matter though since it's only on the server
+        // so there will only every be a single render
+        // that could change in the future because of suspense and etc. but for now,
+        // this works and i don't want to optimise for a future thing that we aren't sure about
+        cache = createCache__default["default"]({
+          key: 'css'
+        });
+        return /*#__PURE__*/React__namespace.createElement(EmotionCacheContext.Provider, {
+          value: cache
+        }, func(props, cache));
+      } else {
+        return func(props, cache);
+      }
+    };
+  };
+}
+
+var ThemeContext = /* #__PURE__ */React__namespace.createContext({});
+
+var useTheme = function useTheme() {
+  return React__namespace.useContext(ThemeContext);
+};
+
+var getTheme = function getTheme(outerTheme, theme) {
+  if (typeof theme === 'function') {
+    var mergedTheme = theme(outerTheme);
+
+    return mergedTheme;
+  }
+
+  return _extends({}, outerTheme, theme);
+};
+
+var createCacheWithTheme = /* #__PURE__ */weakMemoize__default["default"](function (outerTheme) {
+  return weakMemoize__default["default"](function (theme) {
+    return getTheme(outerTheme, theme);
+  });
+});
+var ThemeProvider = function ThemeProvider(props) {
+  var theme = React__namespace.useContext(ThemeContext);
+
+  if (props.theme !== theme) {
+    theme = createCacheWithTheme(theme)(props.theme);
+  }
+
+  return /*#__PURE__*/React__namespace.createElement(ThemeContext.Provider, {
+    value: theme
+  }, props.children);
+};
+function withTheme(Component) {
+  var componentName = Component.displayName || Component.name || 'Component';
+
+  var render = function render(props, ref) {
+    var theme = React__namespace.useContext(ThemeContext);
+    return /*#__PURE__*/React__namespace.createElement(Component, _extends({
+      theme: theme,
+      ref: ref
+    }, props));
+  }; // $FlowFixMe
+
+
+  var WithTheme = /*#__PURE__*/React__namespace.forwardRef(render);
+  WithTheme.displayName = "WithTheme(" + componentName + ")";
+  return _isolatedHnrs_dist_emotionReact_isolatedHnrs["default"](WithTheme, Component);
+}
+
+var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
+var createEmotionProps = function createEmotionProps(type, props) {
+
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when
+
+  return newProps;
+};
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serialized = _ref.serialized,
+      isStringTag = _ref.isStringTag;
+  utils.registerStyles(cache, serialized, isStringTag);
+  var rules = useInsertionEffectWithFallbacks.useInsertionEffectAlwaysWithSyncFallback(function () {
+    return utils.insertStyles(cache, serialized, isStringTag);
+  });
+
+  if (!isBrowser && rules !== undefined) {
+    var _ref2;
+
+    var serializedNames = serialized.name;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      next = next.next;
+    }
+
+    return /*#__PURE__*/React__namespace.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedNames, _ref2.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref2.nonce = cache.sheet.nonce, _ref2));
+  }
+
+  return null;
+};
+
+var Emotion = /* #__PURE__ */exports.withEmotionCache(function (props, cache, ref) {
+  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
+  // not passing the registered cache to serializeStyles because it would
+  // make certain babel optimisations not possible
+
+  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
+    cssProp = cache.registered[cssProp];
+  }
+
+  var WrappedComponent = props[typePropName];
+  var registeredStyles = [cssProp];
+  var className = '';
+
+  if (typeof props.className === 'string') {
+    className = utils.getRegisteredStyles(cache.registered, registeredStyles, props.className);
+  } else if (props.className != null) {
+    className = props.className + " ";
+  }
+
+  var serialized = serialize.serializeStyles(registeredStyles, undefined, React__namespace.useContext(ThemeContext));
+
+  className += cache.key + "-" + serialized.name;
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && (        "production" === 'production' )) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps.ref = ref;
+  newProps.className = className;
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(Insertion, {
+    cache: cache,
+    serialized: serialized,
+    isStringTag: typeof WrappedComponent === 'string'
+  }), /*#__PURE__*/React__namespace.createElement(WrappedComponent, newProps));
+});
+
+var Emotion$1 = Emotion;
+
+exports.CacheProvider = CacheProvider;
+exports.Emotion = Emotion$1;
+exports.ThemeContext = ThemeContext;
+exports.ThemeProvider = ThemeProvider;
+exports.__unsafe_useEmotionCache = __unsafe_useEmotionCache;
+exports.createEmotionProps = createEmotionProps;
+exports.hasOwnProperty = hasOwnProperty;
+exports.isBrowser = isBrowser;
+exports.useTheme = useTheme;
+exports.withTheme = withTheme;

mc_test/node_modules/@emotion/react/dist/emotion-element-48d2c2e4.cjs.dev.js

@@ -0,0 +1,312 @@
+'use strict';
+
+var React = require('react');
+var createCache = require('@emotion/cache');
+var _extends = require('@babel/runtime/helpers/extends');
+var weakMemoize = require('@emotion/weak-memoize');
+var _isolatedHnrs_dist_emotionReact_isolatedHnrs = require('../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.dev.js');
+var utils = require('@emotion/utils');
+var serialize = require('@emotion/serialize');
+var useInsertionEffectWithFallbacks = require('@emotion/use-insertion-effect-with-fallbacks');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+var createCache__default = /*#__PURE__*/_interopDefault(createCache);
+var weakMemoize__default = /*#__PURE__*/_interopDefault(weakMemoize);
+
+var isBrowser = typeof document !== 'undefined';
+var hasOwnProperty = {}.hasOwnProperty;
+
+var EmotionCacheContext = /* #__PURE__ */React__namespace.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
+// because this module is primarily intended for the browser and node
+// but it's also required in react native and similar environments sometimes
+// and we could have a special build just for that
+// but this is much easier and the native packages
+// might use a different theme context in the future anyway
+typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache__default["default"]({
+  key: 'css'
+}) : null);
+
+if (process.env.NODE_ENV !== 'production') {
+  EmotionCacheContext.displayName = 'EmotionCacheContext';
+}
+
+var CacheProvider = EmotionCacheContext.Provider;
+var __unsafe_useEmotionCache = function useEmotionCache() {
+  return React.useContext(EmotionCacheContext);
+};
+
+exports.withEmotionCache = function withEmotionCache(func) {
+  // $FlowFixMe
+  return /*#__PURE__*/React.forwardRef(function (props, ref) {
+    // the cache will never be null in the browser
+    var cache = React.useContext(EmotionCacheContext);
+    return func(props, cache, ref);
+  });
+};
+
+if (!isBrowser) {
+  exports.withEmotionCache = function withEmotionCache(func) {
+    return function (props) {
+      var cache = React.useContext(EmotionCacheContext);
+
+      if (cache === null) {
+        // yes, we're potentially creating this on every render
+        // it doesn't actually matter though since it's only on the server
+        // so there will only every be a single render
+        // that could change in the future because of suspense and etc. but for now,
+        // this works and i don't want to optimise for a future thing that we aren't sure about
+        cache = createCache__default["default"]({
+          key: 'css'
+        });
+        return /*#__PURE__*/React__namespace.createElement(EmotionCacheContext.Provider, {
+          value: cache
+        }, func(props, cache));
+      } else {
+        return func(props, cache);
+      }
+    };
+  };
+}
+
+var ThemeContext = /* #__PURE__ */React__namespace.createContext({});
+
+if (process.env.NODE_ENV !== 'production') {
+  ThemeContext.displayName = 'EmotionThemeContext';
+}
+
+var useTheme = function useTheme() {
+  return React__namespace.useContext(ThemeContext);
+};
+
+var getTheme = function getTheme(outerTheme, theme) {
+  if (typeof theme === 'function') {
+    var mergedTheme = theme(outerTheme);
+
+    if (process.env.NODE_ENV !== 'production' && (mergedTheme == null || typeof mergedTheme !== 'object' || Array.isArray(mergedTheme))) {
+      throw new Error('[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!');
+    }
+
+    return mergedTheme;
+  }
+
+  if (process.env.NODE_ENV !== 'production' && (theme == null || typeof theme !== 'object' || Array.isArray(theme))) {
+    throw new Error('[ThemeProvider] Please make your theme prop a plain object');
+  }
+
+  return _extends({}, outerTheme, theme);
+};
+
+var createCacheWithTheme = /* #__PURE__ */weakMemoize__default["default"](function (outerTheme) {
+  return weakMemoize__default["default"](function (theme) {
+    return getTheme(outerTheme, theme);
+  });
+});
+var ThemeProvider = function ThemeProvider(props) {
+  var theme = React__namespace.useContext(ThemeContext);
+
+  if (props.theme !== theme) {
+    theme = createCacheWithTheme(theme)(props.theme);
+  }
+
+  return /*#__PURE__*/React__namespace.createElement(ThemeContext.Provider, {
+    value: theme
+  }, props.children);
+};
+function withTheme(Component) {
+  var componentName = Component.displayName || Component.name || 'Component';
+
+  var render = function render(props, ref) {
+    var theme = React__namespace.useContext(ThemeContext);
+    return /*#__PURE__*/React__namespace.createElement(Component, _extends({
+      theme: theme,
+      ref: ref
+    }, props));
+  }; // $FlowFixMe
+
+
+  var WithTheme = /*#__PURE__*/React__namespace.forwardRef(render);
+  WithTheme.displayName = "WithTheme(" + componentName + ")";
+  return _isolatedHnrs_dist_emotionReact_isolatedHnrs["default"](WithTheme, Component);
+}
+
+var getLastPart = function getLastPart(functionName) {
+  // The match may be something like 'Object.createEmotionProps' or
+  // 'Loader.prototype.render'
+  var parts = functionName.split('.');
+  return parts[parts.length - 1];
+};
+
+var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
+  // V8
+  var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
+  if (match) return getLastPart(match[1]); // Safari / Firefox
+
+  match = /^([A-Za-z0-9$.]+)@/.exec(line);
+  if (match) return getLastPart(match[1]);
+  return undefined;
+};
+
+var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS
+// identifiers, thus we only need to replace what is a valid character for JS,
+// but not for CSS.
+
+var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
+  return identifier.replace(/\$/g, '-');
+};
+
+var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
+  if (!stackTrace) return undefined;
+  var lines = stackTrace.split('\n');
+
+  for (var i = 0; i < lines.length; i++) {
+    var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error"
+
+    if (!functionName) continue; // If we reach one of these, we have gone too far and should quit
+
+    if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
+    // uppercase letter
+
+    if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
+  }
+
+  return undefined;
+};
+
+var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
+var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
+var createEmotionProps = function createEmotionProps(type, props) {
+  if (process.env.NODE_ENV !== 'production' && typeof props.css === 'string' && // check if there is a css declaration
+  props.css.indexOf(':') !== -1) {
+    throw new Error("Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/react' like this: css`" + props.css + "`");
+  }
+
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when
+  // the label hasn't already been computed
+
+  if (process.env.NODE_ENV !== 'production' && !!props.css && (typeof props.css !== 'object' || typeof props.css.name !== 'string' || props.css.name.indexOf('-') === -1)) {
+    var label = getLabelFromStackTrace(new Error().stack);
+    if (label) newProps[labelPropName] = label;
+  }
+
+  return newProps;
+};
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serialized = _ref.serialized,
+      isStringTag = _ref.isStringTag;
+  utils.registerStyles(cache, serialized, isStringTag);
+  var rules = useInsertionEffectWithFallbacks.useInsertionEffectAlwaysWithSyncFallback(function () {
+    return utils.insertStyles(cache, serialized, isStringTag);
+  });
+
+  if (!isBrowser && rules !== undefined) {
+    var _ref2;
+
+    var serializedNames = serialized.name;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      next = next.next;
+    }
+
+    return /*#__PURE__*/React__namespace.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedNames, _ref2.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref2.nonce = cache.sheet.nonce, _ref2));
+  }
+
+  return null;
+};
+
+var Emotion = /* #__PURE__ */exports.withEmotionCache(function (props, cache, ref) {
+  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
+  // not passing the registered cache to serializeStyles because it would
+  // make certain babel optimisations not possible
+
+  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
+    cssProp = cache.registered[cssProp];
+  }
+
+  var WrappedComponent = props[typePropName];
+  var registeredStyles = [cssProp];
+  var className = '';
+
+  if (typeof props.className === 'string') {
+    className = utils.getRegisteredStyles(cache.registered, registeredStyles, props.className);
+  } else if (props.className != null) {
+    className = props.className + " ";
+  }
+
+  var serialized = serialize.serializeStyles(registeredStyles, undefined, React__namespace.useContext(ThemeContext));
+
+  if (process.env.NODE_ENV !== 'production' && serialized.name.indexOf('-') === -1) {
+    var labelFromStack = props[labelPropName];
+
+    if (labelFromStack) {
+      serialized = serialize.serializeStyles([serialized, 'label:' + labelFromStack + ';']);
+    }
+  }
+
+  className += cache.key + "-" + serialized.name;
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && (process.env.NODE_ENV === 'production' || key !== labelPropName)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps.ref = ref;
+  newProps.className = className;
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(Insertion, {
+    cache: cache,
+    serialized: serialized,
+    isStringTag: typeof WrappedComponent === 'string'
+  }), /*#__PURE__*/React__namespace.createElement(WrappedComponent, newProps));
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  Emotion.displayName = 'EmotionCssPropInternal';
+}
+
+var Emotion$1 = Emotion;
+
+exports.CacheProvider = CacheProvider;
+exports.Emotion = Emotion$1;
+exports.ThemeContext = ThemeContext;
+exports.ThemeProvider = ThemeProvider;
+exports.__unsafe_useEmotionCache = __unsafe_useEmotionCache;
+exports.createEmotionProps = createEmotionProps;
+exports.hasOwnProperty = hasOwnProperty;
+exports.isBrowser = isBrowser;
+exports.useTheme = useTheme;
+exports.withTheme = withTheme;

mc_test/node_modules/@emotion/react/dist/emotion-element-6bdfffb2.esm.js

@@ -0,0 +1,278 @@
+import * as React from 'react';
+import { useContext, forwardRef } from 'react';
+import createCache from '@emotion/cache';
+import _extends from '@babel/runtime/helpers/esm/extends';
+import weakMemoize from '@emotion/weak-memoize';
+import hoistNonReactStatics from '../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js';
+import { getRegisteredStyles, registerStyles, insertStyles } from '@emotion/utils';
+import { serializeStyles } from '@emotion/serialize';
+import { useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';
+
+var isBrowser = typeof document !== 'undefined';
+var hasOwnProperty = {}.hasOwnProperty;
+
+var EmotionCacheContext = /* #__PURE__ */React.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
+// because this module is primarily intended for the browser and node
+// but it's also required in react native and similar environments sometimes
+// and we could have a special build just for that
+// but this is much easier and the native packages
+// might use a different theme context in the future anyway
+typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache({
+  key: 'css'
+}) : null);
+
+if (process.env.NODE_ENV !== 'production') {
+  EmotionCacheContext.displayName = 'EmotionCacheContext';
+}
+
+var CacheProvider = EmotionCacheContext.Provider;
+var __unsafe_useEmotionCache = function useEmotionCache() {
+  return useContext(EmotionCacheContext);
+};
+
+var withEmotionCache = function withEmotionCache(func) {
+  // $FlowFixMe
+  return /*#__PURE__*/forwardRef(function (props, ref) {
+    // the cache will never be null in the browser
+    var cache = useContext(EmotionCacheContext);
+    return func(props, cache, ref);
+  });
+};
+
+if (!isBrowser) {
+  withEmotionCache = function withEmotionCache(func) {
+    return function (props) {
+      var cache = useContext(EmotionCacheContext);
+
+      if (cache === null) {
+        // yes, we're potentially creating this on every render
+        // it doesn't actually matter though since it's only on the server
+        // so there will only every be a single render
+        // that could change in the future because of suspense and etc. but for now,
+        // this works and i don't want to optimise for a future thing that we aren't sure about
+        cache = createCache({
+          key: 'css'
+        });
+        return /*#__PURE__*/React.createElement(EmotionCacheContext.Provider, {
+          value: cache
+        }, func(props, cache));
+      } else {
+        return func(props, cache);
+      }
+    };
+  };
+}
+
+var ThemeContext = /* #__PURE__ */React.createContext({});
+
+if (process.env.NODE_ENV !== 'production') {
+  ThemeContext.displayName = 'EmotionThemeContext';
+}
+
+var useTheme = function useTheme() {
+  return React.useContext(ThemeContext);
+};
+
+var getTheme = function getTheme(outerTheme, theme) {
+  if (typeof theme === 'function') {
+    var mergedTheme = theme(outerTheme);
+
+    if (process.env.NODE_ENV !== 'production' && (mergedTheme == null || typeof mergedTheme !== 'object' || Array.isArray(mergedTheme))) {
+      throw new Error('[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!');
+    }
+
+    return mergedTheme;
+  }
+
+  if (process.env.NODE_ENV !== 'production' && (theme == null || typeof theme !== 'object' || Array.isArray(theme))) {
+    throw new Error('[ThemeProvider] Please make your theme prop a plain object');
+  }
+
+  return _extends({}, outerTheme, theme);
+};
+
+var createCacheWithTheme = /* #__PURE__ */weakMemoize(function (outerTheme) {
+  return weakMemoize(function (theme) {
+    return getTheme(outerTheme, theme);
+  });
+});
+var ThemeProvider = function ThemeProvider(props) {
+  var theme = React.useContext(ThemeContext);
+
+  if (props.theme !== theme) {
+    theme = createCacheWithTheme(theme)(props.theme);
+  }
+
+  return /*#__PURE__*/React.createElement(ThemeContext.Provider, {
+    value: theme
+  }, props.children);
+};
+function withTheme(Component) {
+  var componentName = Component.displayName || Component.name || 'Component';
+
+  var render = function render(props, ref) {
+    var theme = React.useContext(ThemeContext);
+    return /*#__PURE__*/React.createElement(Component, _extends({
+      theme: theme,
+      ref: ref
+    }, props));
+  }; // $FlowFixMe
+
+
+  var WithTheme = /*#__PURE__*/React.forwardRef(render);
+  WithTheme.displayName = "WithTheme(" + componentName + ")";
+  return hoistNonReactStatics(WithTheme, Component);
+}
+
+var getLastPart = function getLastPart(functionName) {
+  // The match may be something like 'Object.createEmotionProps' or
+  // 'Loader.prototype.render'
+  var parts = functionName.split('.');
+  return parts[parts.length - 1];
+};
+
+var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
+  // V8
+  var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
+  if (match) return getLastPart(match[1]); // Safari / Firefox
+
+  match = /^([A-Za-z0-9$.]+)@/.exec(line);
+  if (match) return getLastPart(match[1]);
+  return undefined;
+};
+
+var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS
+// identifiers, thus we only need to replace what is a valid character for JS,
+// but not for CSS.
+
+var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
+  return identifier.replace(/\$/g, '-');
+};
+
+var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
+  if (!stackTrace) return undefined;
+  var lines = stackTrace.split('\n');
+
+  for (var i = 0; i < lines.length; i++) {
+    var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error"
+
+    if (!functionName) continue; // If we reach one of these, we have gone too far and should quit
+
+    if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
+    // uppercase letter
+
+    if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
+  }
+
+  return undefined;
+};
+
+var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
+var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
+var createEmotionProps = function createEmotionProps(type, props) {
+  if (process.env.NODE_ENV !== 'production' && typeof props.css === 'string' && // check if there is a css declaration
+  props.css.indexOf(':') !== -1) {
+    throw new Error("Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/react' like this: css`" + props.css + "`");
+  }
+
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when
+  // the label hasn't already been computed
+
+  if (process.env.NODE_ENV !== 'production' && !!props.css && (typeof props.css !== 'object' || typeof props.css.name !== 'string' || props.css.name.indexOf('-') === -1)) {
+    var label = getLabelFromStackTrace(new Error().stack);
+    if (label) newProps[labelPropName] = label;
+  }
+
+  return newProps;
+};
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serialized = _ref.serialized,
+      isStringTag = _ref.isStringTag;
+  registerStyles(cache, serialized, isStringTag);
+  var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
+    return insertStyles(cache, serialized, isStringTag);
+  });
+
+  if (!isBrowser && rules !== undefined) {
+    var _ref2;
+
+    var serializedNames = serialized.name;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      next = next.next;
+    }
+
+    return /*#__PURE__*/React.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedNames, _ref2.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref2.nonce = cache.sheet.nonce, _ref2));
+  }
+
+  return null;
+};
+
+var Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {
+  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
+  // not passing the registered cache to serializeStyles because it would
+  // make certain babel optimisations not possible
+
+  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
+    cssProp = cache.registered[cssProp];
+  }
+
+  var WrappedComponent = props[typePropName];
+  var registeredStyles = [cssProp];
+  var className = '';
+
+  if (typeof props.className === 'string') {
+    className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
+  } else if (props.className != null) {
+    className = props.className + " ";
+  }
+
+  var serialized = serializeStyles(registeredStyles, undefined, React.useContext(ThemeContext));
+
+  if (process.env.NODE_ENV !== 'production' && serialized.name.indexOf('-') === -1) {
+    var labelFromStack = props[labelPropName];
+
+    if (labelFromStack) {
+      serialized = serializeStyles([serialized, 'label:' + labelFromStack + ';']);
+    }
+  }
+
+  className += cache.key + "-" + serialized.name;
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && (process.env.NODE_ENV === 'production' || key !== labelPropName)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps.ref = ref;
+  newProps.className = className;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {
+    cache: cache,
+    serialized: serialized,
+    isStringTag: typeof WrappedComponent === 'string'
+  }), /*#__PURE__*/React.createElement(WrappedComponent, newProps));
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  Emotion.displayName = 'EmotionCssPropInternal';
+}
+
+var Emotion$1 = Emotion;
+
+export { CacheProvider as C, Emotion$1 as E, ThemeContext as T, __unsafe_useEmotionCache as _, ThemeProvider as a, withTheme as b, createEmotionProps as c, hasOwnProperty as h, isBrowser as i, useTheme as u, withEmotionCache as w };

mc_test/node_modules/@emotion/react/dist/emotion-element-c39617d8.browser.esm.js

@@ -0,0 +1,262 @@
+import * as React from 'react';
+import { useContext, forwardRef } from 'react';
+import createCache from '@emotion/cache';
+import _extends from '@babel/runtime/helpers/esm/extends';
+import weakMemoize from '@emotion/weak-memoize';
+import hoistNonReactStatics from '../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js';
+import { getRegisteredStyles, registerStyles, insertStyles } from '@emotion/utils';
+import { serializeStyles } from '@emotion/serialize';
+import { useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';
+
+var isBrowser = "object" !== 'undefined';
+var hasOwnProperty = {}.hasOwnProperty;
+
+var EmotionCacheContext = /* #__PURE__ */React.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
+// because this module is primarily intended for the browser and node
+// but it's also required in react native and similar environments sometimes
+// and we could have a special build just for that
+// but this is much easier and the native packages
+// might use a different theme context in the future anyway
+typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache({
+  key: 'css'
+}) : null);
+
+if (process.env.NODE_ENV !== 'production') {
+  EmotionCacheContext.displayName = 'EmotionCacheContext';
+}
+
+var CacheProvider = EmotionCacheContext.Provider;
+var __unsafe_useEmotionCache = function useEmotionCache() {
+  return useContext(EmotionCacheContext);
+};
+
+var withEmotionCache = function withEmotionCache(func) {
+  // $FlowFixMe
+  return /*#__PURE__*/forwardRef(function (props, ref) {
+    // the cache will never be null in the browser
+    var cache = useContext(EmotionCacheContext);
+    return func(props, cache, ref);
+  });
+};
+
+if (!isBrowser) {
+  withEmotionCache = function withEmotionCache(func) {
+    return function (props) {
+      var cache = useContext(EmotionCacheContext);
+
+      if (cache === null) {
+        // yes, we're potentially creating this on every render
+        // it doesn't actually matter though since it's only on the server
+        // so there will only every be a single render
+        // that could change in the future because of suspense and etc. but for now,
+        // this works and i don't want to optimise for a future thing that we aren't sure about
+        cache = createCache({
+          key: 'css'
+        });
+        return /*#__PURE__*/React.createElement(EmotionCacheContext.Provider, {
+          value: cache
+        }, func(props, cache));
+      } else {
+        return func(props, cache);
+      }
+    };
+  };
+}
+
+var ThemeContext = /* #__PURE__ */React.createContext({});
+
+if (process.env.NODE_ENV !== 'production') {
+  ThemeContext.displayName = 'EmotionThemeContext';
+}
+
+var useTheme = function useTheme() {
+  return React.useContext(ThemeContext);
+};
+
+var getTheme = function getTheme(outerTheme, theme) {
+  if (typeof theme === 'function') {
+    var mergedTheme = theme(outerTheme);
+
+    if (process.env.NODE_ENV !== 'production' && (mergedTheme == null || typeof mergedTheme !== 'object' || Array.isArray(mergedTheme))) {
+      throw new Error('[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!');
+    }
+
+    return mergedTheme;
+  }
+
+  if (process.env.NODE_ENV !== 'production' && (theme == null || typeof theme !== 'object' || Array.isArray(theme))) {
+    throw new Error('[ThemeProvider] Please make your theme prop a plain object');
+  }
+
+  return _extends({}, outerTheme, theme);
+};
+
+var createCacheWithTheme = /* #__PURE__ */weakMemoize(function (outerTheme) {
+  return weakMemoize(function (theme) {
+    return getTheme(outerTheme, theme);
+  });
+});
+var ThemeProvider = function ThemeProvider(props) {
+  var theme = React.useContext(ThemeContext);
+
+  if (props.theme !== theme) {
+    theme = createCacheWithTheme(theme)(props.theme);
+  }
+
+  return /*#__PURE__*/React.createElement(ThemeContext.Provider, {
+    value: theme
+  }, props.children);
+};
+function withTheme(Component) {
+  var componentName = Component.displayName || Component.name || 'Component';
+
+  var render = function render(props, ref) {
+    var theme = React.useContext(ThemeContext);
+    return /*#__PURE__*/React.createElement(Component, _extends({
+      theme: theme,
+      ref: ref
+    }, props));
+  }; // $FlowFixMe
+
+
+  var WithTheme = /*#__PURE__*/React.forwardRef(render);
+  WithTheme.displayName = "WithTheme(" + componentName + ")";
+  return hoistNonReactStatics(WithTheme, Component);
+}
+
+var getLastPart = function getLastPart(functionName) {
+  // The match may be something like 'Object.createEmotionProps' or
+  // 'Loader.prototype.render'
+  var parts = functionName.split('.');
+  return parts[parts.length - 1];
+};
+
+var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
+  // V8
+  var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
+  if (match) return getLastPart(match[1]); // Safari / Firefox
+
+  match = /^([A-Za-z0-9$.]+)@/.exec(line);
+  if (match) return getLastPart(match[1]);
+  return undefined;
+};
+
+var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS
+// identifiers, thus we only need to replace what is a valid character for JS,
+// but not for CSS.
+
+var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
+  return identifier.replace(/\$/g, '-');
+};
+
+var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
+  if (!stackTrace) return undefined;
+  var lines = stackTrace.split('\n');
+
+  for (var i = 0; i < lines.length; i++) {
+    var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error"
+
+    if (!functionName) continue; // If we reach one of these, we have gone too far and should quit
+
+    if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
+    // uppercase letter
+
+    if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
+  }
+
+  return undefined;
+};
+
+var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
+var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
+var createEmotionProps = function createEmotionProps(type, props) {
+  if (process.env.NODE_ENV !== 'production' && typeof props.css === 'string' && // check if there is a css declaration
+  props.css.indexOf(':') !== -1) {
+    throw new Error("Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/react' like this: css`" + props.css + "`");
+  }
+
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when
+  // the label hasn't already been computed
+
+  if (process.env.NODE_ENV !== 'production' && !!props.css && (typeof props.css !== 'object' || typeof props.css.name !== 'string' || props.css.name.indexOf('-') === -1)) {
+    var label = getLabelFromStackTrace(new Error().stack);
+    if (label) newProps[labelPropName] = label;
+  }
+
+  return newProps;
+};
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serialized = _ref.serialized,
+      isStringTag = _ref.isStringTag;
+  registerStyles(cache, serialized, isStringTag);
+  useInsertionEffectAlwaysWithSyncFallback(function () {
+    return insertStyles(cache, serialized, isStringTag);
+  });
+
+  return null;
+};
+
+var Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {
+  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
+  // not passing the registered cache to serializeStyles because it would
+  // make certain babel optimisations not possible
+
+  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
+    cssProp = cache.registered[cssProp];
+  }
+
+  var WrappedComponent = props[typePropName];
+  var registeredStyles = [cssProp];
+  var className = '';
+
+  if (typeof props.className === 'string') {
+    className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
+  } else if (props.className != null) {
+    className = props.className + " ";
+  }
+
+  var serialized = serializeStyles(registeredStyles, undefined, React.useContext(ThemeContext));
+
+  if (process.env.NODE_ENV !== 'production' && serialized.name.indexOf('-') === -1) {
+    var labelFromStack = props[labelPropName];
+
+    if (labelFromStack) {
+      serialized = serializeStyles([serialized, 'label:' + labelFromStack + ';']);
+    }
+  }
+
+  className += cache.key + "-" + serialized.name;
+  var newProps = {};
+
+  for (var key in props) {
+    if (hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && (process.env.NODE_ENV === 'production' || key !== labelPropName)) {
+      newProps[key] = props[key];
+    }
+  }
+
+  newProps.ref = ref;
+  newProps.className = className;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {
+    cache: cache,
+    serialized: serialized,
+    isStringTag: typeof WrappedComponent === 'string'
+  }), /*#__PURE__*/React.createElement(WrappedComponent, newProps));
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  Emotion.displayName = 'EmotionCssPropInternal';
+}
+
+var Emotion$1 = Emotion;
+
+export { CacheProvider as C, Emotion$1 as E, ThemeContext as T, __unsafe_useEmotionCache as _, ThemeProvider as a, withTheme as b, createEmotionProps as c, hasOwnProperty as h, isBrowser as i, useTheme as u, withEmotionCache as w };

mc_test/node_modules/@emotion/react/dist/emotion-react.browser.esm.js

@@ -0,0 +1,442 @@
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps, w as withEmotionCache, T as ThemeContext, i as isBrowser$1 } from './emotion-element-c39617d8.browser.esm.js';
+export { C as CacheProvider, T as ThemeContext, a as ThemeProvider, _ as __unsafe_useEmotionCache, u as useTheme, w as withEmotionCache, b as withTheme } from './emotion-element-c39617d8.browser.esm.js';
+import * as React from 'react';
+import { insertStyles, registerStyles, getRegisteredStyles } from '@emotion/utils';
+import { useInsertionEffectWithLayoutFallback, useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';
+import { serializeStyles } from '@emotion/serialize';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js';
+import 'hoist-non-react-statics';
+
+var pkg = {
+	name: "@emotion/react",
+	version: "11.11.1",
+	main: "dist/emotion-react.cjs.js",
+	module: "dist/emotion-react.esm.js",
+	browser: {
+		"./dist/emotion-react.esm.js": "./dist/emotion-react.browser.esm.js"
+	},
+	exports: {
+		".": {
+			module: {
+				worker: "./dist/emotion-react.worker.esm.js",
+				browser: "./dist/emotion-react.browser.esm.js",
+				"default": "./dist/emotion-react.esm.js"
+			},
+			"import": "./dist/emotion-react.cjs.mjs",
+			"default": "./dist/emotion-react.cjs.js"
+		},
+		"./jsx-runtime": {
+			module: {
+				worker: "./jsx-runtime/dist/emotion-react-jsx-runtime.worker.esm.js",
+				browser: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js",
+				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.esm.js"
+			},
+			"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
+			"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
+		},
+		"./_isolated-hnrs": {
+			module: {
+				worker: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js",
+				browser: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js",
+				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js"
+			},
+			"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
+			"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
+		},
+		"./jsx-dev-runtime": {
+			module: {
+				worker: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.worker.esm.js",
+				browser: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js",
+				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js"
+			},
+			"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
+			"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
+		},
+		"./package.json": "./package.json",
+		"./types/css-prop": "./types/css-prop.d.ts",
+		"./macro": {
+			types: {
+				"import": "./macro.d.mts",
+				"default": "./macro.d.ts"
+			},
+			"default": "./macro.js"
+		}
+	},
+	types: "types/index.d.ts",
+	files: [
+		"src",
+		"dist",
+		"jsx-runtime",
+		"jsx-dev-runtime",
+		"_isolated-hnrs",
+		"types/*.d.ts",
+		"macro.*"
+	],
+	sideEffects: false,
+	author: "Emotion Contributors",
+	license: "MIT",
+	scripts: {
+		"test:typescript": "dtslint types"
+	},
+	dependencies: {
+		"@babel/runtime": "^7.18.3",
+		"@emotion/babel-plugin": "^11.11.0",
+		"@emotion/cache": "^11.11.0",
+		"@emotion/serialize": "^1.1.2",
+		"@emotion/use-insertion-effect-with-fallbacks": "^1.0.1",
+		"@emotion/utils": "^1.2.1",
+		"@emotion/weak-memoize": "^0.3.1",
+		"hoist-non-react-statics": "^3.3.1"
+	},
+	peerDependencies: {
+		react: ">=16.8.0"
+	},
+	peerDependenciesMeta: {
+		"@types/react": {
+			optional: true
+		}
+	},
+	devDependencies: {
+		"@definitelytyped/dtslint": "0.0.112",
+		"@emotion/css": "11.11.0",
+		"@emotion/css-prettifier": "1.1.3",
+		"@emotion/server": "11.11.0",
+		"@emotion/styled": "11.11.0",
+		"html-tag-names": "^1.1.2",
+		react: "16.14.0",
+		"svg-tag-names": "^1.1.1",
+		typescript: "^4.5.5"
+	},
+	repository: "https://github.com/emotion-js/emotion/tree/main/packages/react",
+	publishConfig: {
+		access: "public"
+	},
+	"umd:main": "dist/emotion-react.umd.min.js",
+	preconstruct: {
+		entrypoints: [
+			"./index.js",
+			"./jsx-runtime.js",
+			"./jsx-dev-runtime.js",
+			"./_isolated-hnrs.js"
+		],
+		umdName: "emotionReact",
+		exports: {
+			envConditions: [
+				"browser",
+				"worker"
+			],
+			extra: {
+				"./types/css-prop": "./types/css-prop.d.ts",
+				"./macro": {
+					types: {
+						"import": "./macro.d.mts",
+						"default": "./macro.d.ts"
+					},
+					"default": "./macro.js"
+				}
+			}
+		}
+	}
+};
+
+var jsx = function jsx(type, props) {
+  var args = arguments;
+
+  if (props == null || !hasOwnProperty.call(props, 'css')) {
+    // $FlowFixMe
+    return React.createElement.apply(undefined, args);
+  }
+
+  var argsLength = args.length;
+  var createElementArgArray = new Array(argsLength);
+  createElementArgArray[0] = Emotion;
+  createElementArgArray[1] = createEmotionProps(type, props);
+
+  for (var i = 2; i < argsLength; i++) {
+    createElementArgArray[i] = args[i];
+  } // $FlowFixMe
+
+
+  return React.createElement.apply(null, createElementArgArray);
+};
+
+var warnedAboutCssPropForGlobal = false; // maintain place over rerenders.
+// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
+// initial client-side render from SSR, use place of hydrating tag
+
+var Global = /* #__PURE__ */withEmotionCache(function (props, cache) {
+  if (process.env.NODE_ENV !== 'production' && !warnedAboutCssPropForGlobal && ( // check for className as well since the user is
+  // probably using the custom createElement which
+  // means it will be turned into a className prop
+  // $FlowFixMe I don't really want to add it to the type since it shouldn't be used
+  props.className || props.css)) {
+    console.error("It looks like you're using the css prop on Global, did you mean to use the styles prop instead?");
+    warnedAboutCssPropForGlobal = true;
+  }
+
+  var styles = props.styles;
+  var serialized = serializeStyles([styles], undefined, React.useContext(ThemeContext));
+
+  if (!isBrowser$1) {
+    var _ref;
+
+    var serializedNames = serialized.name;
+    var serializedStyles = serialized.styles;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      serializedStyles += next.styles;
+      next = next.next;
+    }
+
+    var shouldCache = cache.compat === true;
+    var rules = cache.insert("", {
+      name: serializedNames,
+      styles: serializedStyles
+    }, cache.sheet, shouldCache);
+
+    if (shouldCache) {
+      return null;
+    }
+
+    return /*#__PURE__*/React.createElement("style", (_ref = {}, _ref["data-emotion"] = cache.key + "-global " + serializedNames, _ref.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref.nonce = cache.sheet.nonce, _ref));
+  } // yes, i know these hooks are used conditionally
+  // but it is based on a constant that will never change at runtime
+  // it's effectively like having two implementations and switching them out
+  // so it's not actually breaking anything
+
+
+  var sheetRef = React.useRef();
+  useInsertionEffectWithLayoutFallback(function () {
+    var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675
+
+    var sheet = new cache.sheet.constructor({
+      key: key,
+      nonce: cache.sheet.nonce,
+      container: cache.sheet.container,
+      speedy: cache.sheet.isSpeedy
+    });
+    var rehydrating = false; // $FlowFixMe
+
+    var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");
+
+    if (cache.sheet.tags.length) {
+      sheet.before = cache.sheet.tags[0];
+    }
+
+    if (node !== null) {
+      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
+
+      node.setAttribute('data-emotion', key);
+      sheet.hydrate([node]);
+    }
+
+    sheetRef.current = [sheet, rehydrating];
+    return function () {
+      sheet.flush();
+    };
+  }, [cache]);
+  useInsertionEffectWithLayoutFallback(function () {
+    var sheetRefCurrent = sheetRef.current;
+    var sheet = sheetRefCurrent[0],
+        rehydrating = sheetRefCurrent[1];
+
+    if (rehydrating) {
+      sheetRefCurrent[1] = false;
+      return;
+    }
+
+    if (serialized.next !== undefined) {
+      // insert keyframes
+      insertStyles(cache, serialized.next, true);
+    }
+
+    if (sheet.tags.length) {
+      // if this doesn't exist then it will be null so the style element will be appended
+      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
+      sheet.before = element;
+      sheet.flush();
+    }
+
+    cache.insert("", serialized, sheet, false);
+  }, [cache, serialized.name]);
+  return null;
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  Global.displayName = 'EmotionGlobal';
+}
+
+function css() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return serializeStyles(args);
+}
+
+var keyframes = function keyframes() {
+  var insertable = css.apply(void 0, arguments);
+  var name = "animation-" + insertable.name; // $FlowFixMe
+
+  return {
+    name: name,
+    styles: "@keyframes " + name + "{" + insertable.styles + "}",
+    anim: 1,
+    toString: function toString() {
+      return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
+    }
+  };
+};
+
+var classnames = function classnames(args) {
+  var len = args.length;
+  var i = 0;
+  var cls = '';
+
+  for (; i < len; i++) {
+    var arg = args[i];
+    if (arg == null) continue;
+    var toAdd = void 0;
+
+    switch (typeof arg) {
+      case 'boolean':
+        break;
+
+      case 'object':
+        {
+          if (Array.isArray(arg)) {
+            toAdd = classnames(arg);
+          } else {
+            if (process.env.NODE_ENV !== 'production' && arg.styles !== undefined && arg.name !== undefined) {
+              console.error('You have passed styles created with `css` from `@emotion/react` package to the `cx`.\n' + '`cx` is meant to compose class names (strings) so you should convert those styles to a class name by passing them to the `css` received from <ClassNames/> component.');
+            }
+
+            toAdd = '';
+
+            for (var k in arg) {
+              if (arg[k] && k) {
+                toAdd && (toAdd += ' ');
+                toAdd += k;
+              }
+            }
+          }
+
+          break;
+        }
+
+      default:
+        {
+          toAdd = arg;
+        }
+    }
+
+    if (toAdd) {
+      cls && (cls += ' ');
+      cls += toAdd;
+    }
+  }
+
+  return cls;
+};
+
+function merge(registered, css, className) {
+  var registeredStyles = [];
+  var rawClassName = getRegisteredStyles(registered, registeredStyles, className);
+
+  if (registeredStyles.length < 2) {
+    return className;
+  }
+
+  return rawClassName + css(registeredStyles);
+}
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serializedArr = _ref.serializedArr;
+  useInsertionEffectAlwaysWithSyncFallback(function () {
+
+    for (var i = 0; i < serializedArr.length; i++) {
+      insertStyles(cache, serializedArr[i], false);
+    }
+  });
+
+  return null;
+};
+
+var ClassNames = /* #__PURE__ */withEmotionCache(function (props, cache) {
+  var hasRendered = false;
+  var serializedArr = [];
+
+  var css = function css() {
+    if (hasRendered && process.env.NODE_ENV !== 'production') {
+      throw new Error('css can only be used during render');
+    }
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var serialized = serializeStyles(args, cache.registered);
+    serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`
+
+    registerStyles(cache, serialized, false);
+    return cache.key + "-" + serialized.name;
+  };
+
+  var cx = function cx() {
+    if (hasRendered && process.env.NODE_ENV !== 'production') {
+      throw new Error('cx can only be used during render');
+    }
+
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    return merge(cache.registered, css, classnames(args));
+  };
+
+  var content = {
+    css: css,
+    cx: cx,
+    theme: React.useContext(ThemeContext)
+  };
+  var ele = props.children(content);
+  hasRendered = true;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {
+    cache: cache,
+    serializedArr: serializedArr
+  }), ele);
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  ClassNames.displayName = 'EmotionClassNames';
+}
+
+if (process.env.NODE_ENV !== 'production') {
+  var isBrowser = "object" !== 'undefined'; // #1727, #2905 for some reason Jest and Vitest evaluate modules twice if some consuming module gets mocked
+
+  var isTestEnv = typeof jest !== 'undefined' || typeof vi !== 'undefined';
+
+  if (isBrowser && !isTestEnv) {
+    // globalThis has wide browser support - https://caniuse.com/?search=globalThis, Node.js 12 and later
+    var globalContext = // $FlowIgnore
+    typeof globalThis !== 'undefined' ? globalThis // eslint-disable-line no-undef
+    : isBrowser ? window : global;
+    var globalKey = "__EMOTION_REACT_" + pkg.version.split('.')[0] + "__";
+
+    if (globalContext[globalKey]) {
+      console.warn('You are loading @emotion/react when it is already loaded. Running ' + 'multiple instances may cause problems. This can happen if multiple ' + 'versions are used, or if multiple builds of the same version are ' + 'used.');
+    }
+
+    globalContext[globalKey] = true;
+  }
+}
+
+export { ClassNames, Global, jsx as createElement, css, jsx, keyframes };

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index.js";
+//# sourceMappingURL=emotion-react.cjs.d.mts.map

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotion-react.cjs.d.mts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index";
+//# sourceMappingURL=emotion-react.cjs.d.ts.map

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotion-react.cjs.d.ts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.dev.js

@@ -0,0 +1,499 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var emotionElement = require('./emotion-element-48d2c2e4.cjs.dev.js');
+var React = require('react');
+var utils = require('@emotion/utils');
+var useInsertionEffectWithFallbacks = require('@emotion/use-insertion-effect-with-fallbacks');
+var serialize = require('@emotion/serialize');
+require('@emotion/cache');
+require('@babel/runtime/helpers/extends');
+require('@emotion/weak-memoize');
+require('../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.dev.js');
+require('hoist-non-react-statics');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var pkg = {
+	name: "@emotion/react",
+	version: "11.11.1",
+	main: "dist/emotion-react.cjs.js",
+	module: "dist/emotion-react.esm.js",
+	browser: {
+		"./dist/emotion-react.esm.js": "./dist/emotion-react.browser.esm.js"
+	},
+	exports: {
+		".": {
+			module: {
+				worker: "./dist/emotion-react.worker.esm.js",
+				browser: "./dist/emotion-react.browser.esm.js",
+				"default": "./dist/emotion-react.esm.js"
+			},
+			"import": "./dist/emotion-react.cjs.mjs",
+			"default": "./dist/emotion-react.cjs.js"
+		},
+		"./jsx-runtime": {
+			module: {
+				worker: "./jsx-runtime/dist/emotion-react-jsx-runtime.worker.esm.js",
+				browser: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js",
+				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.esm.js"
+			},
+			"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
+			"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
+		},
+		"./_isolated-hnrs": {
+			module: {
+				worker: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js",
+				browser: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js",
+				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js"
+			},
+			"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
+			"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
+		},
+		"./jsx-dev-runtime": {
+			module: {
+				worker: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.worker.esm.js",
+				browser: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js",
+				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js"
+			},
+			"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
+			"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
+		},
+		"./package.json": "./package.json",
+		"./types/css-prop": "./types/css-prop.d.ts",
+		"./macro": {
+			types: {
+				"import": "./macro.d.mts",
+				"default": "./macro.d.ts"
+			},
+			"default": "./macro.js"
+		}
+	},
+	types: "types/index.d.ts",
+	files: [
+		"src",
+		"dist",
+		"jsx-runtime",
+		"jsx-dev-runtime",
+		"_isolated-hnrs",
+		"types/*.d.ts",
+		"macro.*"
+	],
+	sideEffects: false,
+	author: "Emotion Contributors",
+	license: "MIT",
+	scripts: {
+		"test:typescript": "dtslint types"
+	},
+	dependencies: {
+		"@babel/runtime": "^7.18.3",
+		"@emotion/babel-plugin": "^11.11.0",
+		"@emotion/cache": "^11.11.0",
+		"@emotion/serialize": "^1.1.2",
+		"@emotion/use-insertion-effect-with-fallbacks": "^1.0.1",
+		"@emotion/utils": "^1.2.1",
+		"@emotion/weak-memoize": "^0.3.1",
+		"hoist-non-react-statics": "^3.3.1"
+	},
+	peerDependencies: {
+		react: ">=16.8.0"
+	},
+	peerDependenciesMeta: {
+		"@types/react": {
+			optional: true
+		}
+	},
+	devDependencies: {
+		"@definitelytyped/dtslint": "0.0.112",
+		"@emotion/css": "11.11.0",
+		"@emotion/css-prettifier": "1.1.3",
+		"@emotion/server": "11.11.0",
+		"@emotion/styled": "11.11.0",
+		"html-tag-names": "^1.1.2",
+		react: "16.14.0",
+		"svg-tag-names": "^1.1.1",
+		typescript: "^4.5.5"
+	},
+	repository: "https://github.com/emotion-js/emotion/tree/main/packages/react",
+	publishConfig: {
+		access: "public"
+	},
+	"umd:main": "dist/emotion-react.umd.min.js",
+	preconstruct: {
+		entrypoints: [
+			"./index.js",
+			"./jsx-runtime.js",
+			"./jsx-dev-runtime.js",
+			"./_isolated-hnrs.js"
+		],
+		umdName: "emotionReact",
+		exports: {
+			envConditions: [
+				"browser",
+				"worker"
+			],
+			extra: {
+				"./types/css-prop": "./types/css-prop.d.ts",
+				"./macro": {
+					types: {
+						"import": "./macro.d.mts",
+						"default": "./macro.d.ts"
+					},
+					"default": "./macro.js"
+				}
+			}
+		}
+	}
+};
+
+var jsx = function jsx(type, props) {
+  var args = arguments;
+
+  if (props == null || !emotionElement.hasOwnProperty.call(props, 'css')) {
+    // $FlowFixMe
+    return React__namespace.createElement.apply(undefined, args);
+  }
+
+  var argsLength = args.length;
+  var createElementArgArray = new Array(argsLength);
+  createElementArgArray[0] = emotionElement.Emotion;
+  createElementArgArray[1] = emotionElement.createEmotionProps(type, props);
+
+  for (var i = 2; i < argsLength; i++) {
+    createElementArgArray[i] = args[i];
+  } // $FlowFixMe
+
+
+  return React__namespace.createElement.apply(null, createElementArgArray);
+};
+
+var warnedAboutCssPropForGlobal = false; // maintain place over rerenders.
+// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
+// initial client-side render from SSR, use place of hydrating tag
+
+var Global = /* #__PURE__ */emotionElement.withEmotionCache(function (props, cache) {
+  if (process.env.NODE_ENV !== 'production' && !warnedAboutCssPropForGlobal && ( // check for className as well since the user is
+  // probably using the custom createElement which
+  // means it will be turned into a className prop
+  // $FlowFixMe I don't really want to add it to the type since it shouldn't be used
+  props.className || props.css)) {
+    console.error("It looks like you're using the css prop on Global, did you mean to use the styles prop instead?");
+    warnedAboutCssPropForGlobal = true;
+  }
+
+  var styles = props.styles;
+  var serialized = serialize.serializeStyles([styles], undefined, React__namespace.useContext(emotionElement.ThemeContext));
+
+  if (!emotionElement.isBrowser) {
+    var _ref;
+
+    var serializedNames = serialized.name;
+    var serializedStyles = serialized.styles;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      serializedStyles += next.styles;
+      next = next.next;
+    }
+
+    var shouldCache = cache.compat === true;
+    var rules = cache.insert("", {
+      name: serializedNames,
+      styles: serializedStyles
+    }, cache.sheet, shouldCache);
+
+    if (shouldCache) {
+      return null;
+    }
+
+    return /*#__PURE__*/React__namespace.createElement("style", (_ref = {}, _ref["data-emotion"] = cache.key + "-global " + serializedNames, _ref.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref.nonce = cache.sheet.nonce, _ref));
+  } // yes, i know these hooks are used conditionally
+  // but it is based on a constant that will never change at runtime
+  // it's effectively like having two implementations and switching them out
+  // so it's not actually breaking anything
+
+
+  var sheetRef = React__namespace.useRef();
+  useInsertionEffectWithFallbacks.useInsertionEffectWithLayoutFallback(function () {
+    var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675
+
+    var sheet = new cache.sheet.constructor({
+      key: key,
+      nonce: cache.sheet.nonce,
+      container: cache.sheet.container,
+      speedy: cache.sheet.isSpeedy
+    });
+    var rehydrating = false; // $FlowFixMe
+
+    var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");
+
+    if (cache.sheet.tags.length) {
+      sheet.before = cache.sheet.tags[0];
+    }
+
+    if (node !== null) {
+      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
+
+      node.setAttribute('data-emotion', key);
+      sheet.hydrate([node]);
+    }
+
+    sheetRef.current = [sheet, rehydrating];
+    return function () {
+      sheet.flush();
+    };
+  }, [cache]);
+  useInsertionEffectWithFallbacks.useInsertionEffectWithLayoutFallback(function () {
+    var sheetRefCurrent = sheetRef.current;
+    var sheet = sheetRefCurrent[0],
+        rehydrating = sheetRefCurrent[1];
+
+    if (rehydrating) {
+      sheetRefCurrent[1] = false;
+      return;
+    }
+
+    if (serialized.next !== undefined) {
+      // insert keyframes
+      utils.insertStyles(cache, serialized.next, true);
+    }
+
+    if (sheet.tags.length) {
+      // if this doesn't exist then it will be null so the style element will be appended
+      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
+      sheet.before = element;
+      sheet.flush();
+    }
+
+    cache.insert("", serialized, sheet, false);
+  }, [cache, serialized.name]);
+  return null;
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  Global.displayName = 'EmotionGlobal';
+}
+
+function css() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return serialize.serializeStyles(args);
+}
+
+var keyframes = function keyframes() {
+  var insertable = css.apply(void 0, arguments);
+  var name = "animation-" + insertable.name; // $FlowFixMe
+
+  return {
+    name: name,
+    styles: "@keyframes " + name + "{" + insertable.styles + "}",
+    anim: 1,
+    toString: function toString() {
+      return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
+    }
+  };
+};
+
+var classnames = function classnames(args) {
+  var len = args.length;
+  var i = 0;
+  var cls = '';
+
+  for (; i < len; i++) {
+    var arg = args[i];
+    if (arg == null) continue;
+    var toAdd = void 0;
+
+    switch (typeof arg) {
+      case 'boolean':
+        break;
+
+      case 'object':
+        {
+          if (Array.isArray(arg)) {
+            toAdd = classnames(arg);
+          } else {
+            if (process.env.NODE_ENV !== 'production' && arg.styles !== undefined && arg.name !== undefined) {
+              console.error('You have passed styles created with `css` from `@emotion/react` package to the `cx`.\n' + '`cx` is meant to compose class names (strings) so you should convert those styles to a class name by passing them to the `css` received from <ClassNames/> component.');
+            }
+
+            toAdd = '';
+
+            for (var k in arg) {
+              if (arg[k] && k) {
+                toAdd && (toAdd += ' ');
+                toAdd += k;
+              }
+            }
+          }
+
+          break;
+        }
+
+      default:
+        {
+          toAdd = arg;
+        }
+    }
+
+    if (toAdd) {
+      cls && (cls += ' ');
+      cls += toAdd;
+    }
+  }
+
+  return cls;
+};
+
+function merge(registered, css, className) {
+  var registeredStyles = [];
+  var rawClassName = utils.getRegisteredStyles(registered, registeredStyles, className);
+
+  if (registeredStyles.length < 2) {
+    return className;
+  }
+
+  return rawClassName + css(registeredStyles);
+}
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serializedArr = _ref.serializedArr;
+  var rules = useInsertionEffectWithFallbacks.useInsertionEffectAlwaysWithSyncFallback(function () {
+    var rules = '';
+
+    for (var i = 0; i < serializedArr.length; i++) {
+      var res = utils.insertStyles(cache, serializedArr[i], false);
+
+      if (!emotionElement.isBrowser && res !== undefined) {
+        rules += res;
+      }
+    }
+
+    if (!emotionElement.isBrowser) {
+      return rules;
+    }
+  });
+
+  if (!emotionElement.isBrowser && rules.length !== 0) {
+    var _ref2;
+
+    return /*#__PURE__*/React__namespace.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedArr.map(function (serialized) {
+      return serialized.name;
+    }).join(' '), _ref2.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref2.nonce = cache.sheet.nonce, _ref2));
+  }
+
+  return null;
+};
+
+var ClassNames = /* #__PURE__ */emotionElement.withEmotionCache(function (props, cache) {
+  var hasRendered = false;
+  var serializedArr = [];
+
+  var css = function css() {
+    if (hasRendered && process.env.NODE_ENV !== 'production') {
+      throw new Error('css can only be used during render');
+    }
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var serialized = serialize.serializeStyles(args, cache.registered);
+    serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`
+
+    utils.registerStyles(cache, serialized, false);
+    return cache.key + "-" + serialized.name;
+  };
+
+  var cx = function cx() {
+    if (hasRendered && process.env.NODE_ENV !== 'production') {
+      throw new Error('cx can only be used during render');
+    }
+
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    return merge(cache.registered, css, classnames(args));
+  };
+
+  var content = {
+    css: css,
+    cx: cx,
+    theme: React__namespace.useContext(emotionElement.ThemeContext)
+  };
+  var ele = props.children(content);
+  hasRendered = true;
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(Insertion, {
+    cache: cache,
+    serializedArr: serializedArr
+  }), ele);
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  ClassNames.displayName = 'EmotionClassNames';
+}
+
+if (process.env.NODE_ENV !== 'production') {
+  var isBrowser = typeof document !== 'undefined'; // #1727, #2905 for some reason Jest and Vitest evaluate modules twice if some consuming module gets mocked
+
+  var isTestEnv = typeof jest !== 'undefined' || typeof vi !== 'undefined';
+
+  if (isBrowser && !isTestEnv) {
+    // globalThis has wide browser support - https://caniuse.com/?search=globalThis, Node.js 12 and later
+    var globalContext = // $FlowIgnore
+    typeof globalThis !== 'undefined' ? globalThis // eslint-disable-line no-undef
+    : isBrowser ? window : global;
+    var globalKey = "__EMOTION_REACT_" + pkg.version.split('.')[0] + "__";
+
+    if (globalContext[globalKey]) {
+      console.warn('You are loading @emotion/react when it is already loaded. Running ' + 'multiple instances may cause problems. This can happen if multiple ' + 'versions are used, or if multiple builds of the same version are ' + 'used.');
+    }
+
+    globalContext[globalKey] = true;
+  }
+}
+
+exports.CacheProvider = emotionElement.CacheProvider;
+exports.ThemeContext = emotionElement.ThemeContext;
+exports.ThemeProvider = emotionElement.ThemeProvider;
+exports.__unsafe_useEmotionCache = emotionElement.__unsafe_useEmotionCache;
+exports.useTheme = emotionElement.useTheme;
+Object.defineProperty(exports, 'withEmotionCache', {
+  enumerable: true,
+  get: function () { return emotionElement.withEmotionCache; }
+});
+exports.withTheme = emotionElement.withTheme;
+exports.ClassNames = ClassNames;
+exports.Global = Global;
+exports.createElement = jsx;
+exports.css = css;
+exports.jsx = jsx;
+exports.keyframes = keyframes;

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./emotion-react.cjs.prod.js");
+} else {
+  module.exports = require("./emotion-react.cjs.dev.js");
+}

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.js.flow

@@ -0,0 +1,2 @@
+// @flow
+export * from "../src/index.js";

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.mjs

@@ -0,0 +1,15 @@
+export {
+  CacheProvider,
+  ClassNames,
+  Global,
+  ThemeContext,
+  ThemeProvider,
+  __unsafe_useEmotionCache,
+  createElement,
+  css,
+  jsx,
+  keyframes,
+  useTheme,
+  withEmotionCache,
+  withTheme
+} from "./emotion-react.cjs.js";

mc_test/node_modules/@emotion/react/dist/emotion-react.cjs.prod.js

@@ -0,0 +1,327 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var emotionElement = require('./emotion-element-4300ad44.cjs.prod.js');
+var React = require('react');
+var utils = require('@emotion/utils');
+var useInsertionEffectWithFallbacks = require('@emotion/use-insertion-effect-with-fallbacks');
+var serialize = require('@emotion/serialize');
+require('@emotion/cache');
+require('@babel/runtime/helpers/extends');
+require('@emotion/weak-memoize');
+require('../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.prod.js');
+require('hoist-non-react-statics');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var jsx = function jsx(type, props) {
+  var args = arguments;
+
+  if (props == null || !emotionElement.hasOwnProperty.call(props, 'css')) {
+    // $FlowFixMe
+    return React__namespace.createElement.apply(undefined, args);
+  }
+
+  var argsLength = args.length;
+  var createElementArgArray = new Array(argsLength);
+  createElementArgArray[0] = emotionElement.Emotion;
+  createElementArgArray[1] = emotionElement.createEmotionProps(type, props);
+
+  for (var i = 2; i < argsLength; i++) {
+    createElementArgArray[i] = args[i];
+  } // $FlowFixMe
+
+
+  return React__namespace.createElement.apply(null, createElementArgArray);
+};
+
+// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
+// initial client-side render from SSR, use place of hydrating tag
+
+var Global = /* #__PURE__ */emotionElement.withEmotionCache(function (props, cache) {
+
+  var styles = props.styles;
+  var serialized = serialize.serializeStyles([styles], undefined, React__namespace.useContext(emotionElement.ThemeContext));
+
+  if (!emotionElement.isBrowser) {
+    var _ref;
+
+    var serializedNames = serialized.name;
+    var serializedStyles = serialized.styles;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      serializedStyles += next.styles;
+      next = next.next;
+    }
+
+    var shouldCache = cache.compat === true;
+    var rules = cache.insert("", {
+      name: serializedNames,
+      styles: serializedStyles
+    }, cache.sheet, shouldCache);
+
+    if (shouldCache) {
+      return null;
+    }
+
+    return /*#__PURE__*/React__namespace.createElement("style", (_ref = {}, _ref["data-emotion"] = cache.key + "-global " + serializedNames, _ref.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref.nonce = cache.sheet.nonce, _ref));
+  } // yes, i know these hooks are used conditionally
+  // but it is based on a constant that will never change at runtime
+  // it's effectively like having two implementations and switching them out
+  // so it's not actually breaking anything
+
+
+  var sheetRef = React__namespace.useRef();
+  useInsertionEffectWithFallbacks.useInsertionEffectWithLayoutFallback(function () {
+    var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675
+
+    var sheet = new cache.sheet.constructor({
+      key: key,
+      nonce: cache.sheet.nonce,
+      container: cache.sheet.container,
+      speedy: cache.sheet.isSpeedy
+    });
+    var rehydrating = false; // $FlowFixMe
+
+    var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");
+
+    if (cache.sheet.tags.length) {
+      sheet.before = cache.sheet.tags[0];
+    }
+
+    if (node !== null) {
+      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
+
+      node.setAttribute('data-emotion', key);
+      sheet.hydrate([node]);
+    }
+
+    sheetRef.current = [sheet, rehydrating];
+    return function () {
+      sheet.flush();
+    };
+  }, [cache]);
+  useInsertionEffectWithFallbacks.useInsertionEffectWithLayoutFallback(function () {
+    var sheetRefCurrent = sheetRef.current;
+    var sheet = sheetRefCurrent[0],
+        rehydrating = sheetRefCurrent[1];
+
+    if (rehydrating) {
+      sheetRefCurrent[1] = false;
+      return;
+    }
+
+    if (serialized.next !== undefined) {
+      // insert keyframes
+      utils.insertStyles(cache, serialized.next, true);
+    }
+
+    if (sheet.tags.length) {
+      // if this doesn't exist then it will be null so the style element will be appended
+      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
+      sheet.before = element;
+      sheet.flush();
+    }
+
+    cache.insert("", serialized, sheet, false);
+  }, [cache, serialized.name]);
+  return null;
+});
+
+function css() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return serialize.serializeStyles(args);
+}
+
+var keyframes = function keyframes() {
+  var insertable = css.apply(void 0, arguments);
+  var name = "animation-" + insertable.name; // $FlowFixMe
+
+  return {
+    name: name,
+    styles: "@keyframes " + name + "{" + insertable.styles + "}",
+    anim: 1,
+    toString: function toString() {
+      return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
+    }
+  };
+};
+
+var classnames = function classnames(args) {
+  var len = args.length;
+  var i = 0;
+  var cls = '';
+
+  for (; i < len; i++) {
+    var arg = args[i];
+    if (arg == null) continue;
+    var toAdd = void 0;
+
+    switch (typeof arg) {
+      case 'boolean':
+        break;
+
+      case 'object':
+        {
+          if (Array.isArray(arg)) {
+            toAdd = classnames(arg);
+          } else {
+
+            toAdd = '';
+
+            for (var k in arg) {
+              if (arg[k] && k) {
+                toAdd && (toAdd += ' ');
+                toAdd += k;
+              }
+            }
+          }
+
+          break;
+        }
+
+      default:
+        {
+          toAdd = arg;
+        }
+    }
+
+    if (toAdd) {
+      cls && (cls += ' ');
+      cls += toAdd;
+    }
+  }
+
+  return cls;
+};
+
+function merge(registered, css, className) {
+  var registeredStyles = [];
+  var rawClassName = utils.getRegisteredStyles(registered, registeredStyles, className);
+
+  if (registeredStyles.length < 2) {
+    return className;
+  }
+
+  return rawClassName + css(registeredStyles);
+}
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serializedArr = _ref.serializedArr;
+  var rules = useInsertionEffectWithFallbacks.useInsertionEffectAlwaysWithSyncFallback(function () {
+    var rules = '';
+
+    for (var i = 0; i < serializedArr.length; i++) {
+      var res = utils.insertStyles(cache, serializedArr[i], false);
+
+      if (!emotionElement.isBrowser && res !== undefined) {
+        rules += res;
+      }
+    }
+
+    if (!emotionElement.isBrowser) {
+      return rules;
+    }
+  });
+
+  if (!emotionElement.isBrowser && rules.length !== 0) {
+    var _ref2;
+
+    return /*#__PURE__*/React__namespace.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedArr.map(function (serialized) {
+      return serialized.name;
+    }).join(' '), _ref2.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref2.nonce = cache.sheet.nonce, _ref2));
+  }
+
+  return null;
+};
+
+var ClassNames = /* #__PURE__ */emotionElement.withEmotionCache(function (props, cache) {
+  var hasRendered = false;
+  var serializedArr = [];
+
+  var css = function css() {
+    if (hasRendered &&         "production" !== 'production') {
+      throw new Error('css can only be used during render');
+    }
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var serialized = serialize.serializeStyles(args, cache.registered);
+    serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`
+
+    utils.registerStyles(cache, serialized, false);
+    return cache.key + "-" + serialized.name;
+  };
+
+  var cx = function cx() {
+    if (hasRendered &&         "production" !== 'production') {
+      throw new Error('cx can only be used during render');
+    }
+
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    return merge(cache.registered, css, classnames(args));
+  };
+
+  var content = {
+    css: css,
+    cx: cx,
+    theme: React__namespace.useContext(emotionElement.ThemeContext)
+  };
+  var ele = props.children(content);
+  hasRendered = true;
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(Insertion, {
+    cache: cache,
+    serializedArr: serializedArr
+  }), ele);
+});
+
+exports.CacheProvider = emotionElement.CacheProvider;
+exports.ThemeContext = emotionElement.ThemeContext;
+exports.ThemeProvider = emotionElement.ThemeProvider;
+exports.__unsafe_useEmotionCache = emotionElement.__unsafe_useEmotionCache;
+exports.useTheme = emotionElement.useTheme;
+Object.defineProperty(exports, 'withEmotionCache', {
+  enumerable: true,
+  get: function () { return emotionElement.withEmotionCache; }
+});
+exports.withTheme = emotionElement.withTheme;
+exports.ClassNames = ClassNames;
+exports.Global = Global;
+exports.createElement = jsx;
+exports.css = css;
+exports.jsx = jsx;
+exports.keyframes = keyframes;

mc_test/node_modules/@emotion/react/dist/emotion-react.esm.js

@@ -0,0 +1,461 @@
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps, w as withEmotionCache, T as ThemeContext, i as isBrowser$1 } from './emotion-element-6bdfffb2.esm.js';
+export { C as CacheProvider, T as ThemeContext, a as ThemeProvider, _ as __unsafe_useEmotionCache, u as useTheme, w as withEmotionCache, b as withTheme } from './emotion-element-6bdfffb2.esm.js';
+import * as React from 'react';
+import { insertStyles, registerStyles, getRegisteredStyles } from '@emotion/utils';
+import { useInsertionEffectWithLayoutFallback, useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';
+import { serializeStyles } from '@emotion/serialize';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js';
+import 'hoist-non-react-statics';
+
+var pkg = {
+	name: "@emotion/react",
+	version: "11.11.1",
+	main: "dist/emotion-react.cjs.js",
+	module: "dist/emotion-react.esm.js",
+	browser: {
+		"./dist/emotion-react.esm.js": "./dist/emotion-react.browser.esm.js"
+	},
+	exports: {
+		".": {
+			module: {
+				worker: "./dist/emotion-react.worker.esm.js",
+				browser: "./dist/emotion-react.browser.esm.js",
+				"default": "./dist/emotion-react.esm.js"
+			},
+			"import": "./dist/emotion-react.cjs.mjs",
+			"default": "./dist/emotion-react.cjs.js"
+		},
+		"./jsx-runtime": {
+			module: {
+				worker: "./jsx-runtime/dist/emotion-react-jsx-runtime.worker.esm.js",
+				browser: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js",
+				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.esm.js"
+			},
+			"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
+			"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
+		},
+		"./_isolated-hnrs": {
+			module: {
+				worker: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js",
+				browser: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js",
+				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js"
+			},
+			"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
+			"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
+		},
+		"./jsx-dev-runtime": {
+			module: {
+				worker: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.worker.esm.js",
+				browser: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js",
+				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js"
+			},
+			"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
+			"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
+		},
+		"./package.json": "./package.json",
+		"./types/css-prop": "./types/css-prop.d.ts",
+		"./macro": {
+			types: {
+				"import": "./macro.d.mts",
+				"default": "./macro.d.ts"
+			},
+			"default": "./macro.js"
+		}
+	},
+	types: "types/index.d.ts",
+	files: [
+		"src",
+		"dist",
+		"jsx-runtime",
+		"jsx-dev-runtime",
+		"_isolated-hnrs",
+		"types/*.d.ts",
+		"macro.*"
+	],
+	sideEffects: false,
+	author: "Emotion Contributors",
+	license: "MIT",
+	scripts: {
+		"test:typescript": "dtslint types"
+	},
+	dependencies: {
+		"@babel/runtime": "^7.18.3",
+		"@emotion/babel-plugin": "^11.11.0",
+		"@emotion/cache": "^11.11.0",
+		"@emotion/serialize": "^1.1.2",
+		"@emotion/use-insertion-effect-with-fallbacks": "^1.0.1",
+		"@emotion/utils": "^1.2.1",
+		"@emotion/weak-memoize": "^0.3.1",
+		"hoist-non-react-statics": "^3.3.1"
+	},
+	peerDependencies: {
+		react: ">=16.8.0"
+	},
+	peerDependenciesMeta: {
+		"@types/react": {
+			optional: true
+		}
+	},
+	devDependencies: {
+		"@definitelytyped/dtslint": "0.0.112",
+		"@emotion/css": "11.11.0",
+		"@emotion/css-prettifier": "1.1.3",
+		"@emotion/server": "11.11.0",
+		"@emotion/styled": "11.11.0",
+		"html-tag-names": "^1.1.2",
+		react: "16.14.0",
+		"svg-tag-names": "^1.1.1",
+		typescript: "^4.5.5"
+	},
+	repository: "https://github.com/emotion-js/emotion/tree/main/packages/react",
+	publishConfig: {
+		access: "public"
+	},
+	"umd:main": "dist/emotion-react.umd.min.js",
+	preconstruct: {
+		entrypoints: [
+			"./index.js",
+			"./jsx-runtime.js",
+			"./jsx-dev-runtime.js",
+			"./_isolated-hnrs.js"
+		],
+		umdName: "emotionReact",
+		exports: {
+			envConditions: [
+				"browser",
+				"worker"
+			],
+			extra: {
+				"./types/css-prop": "./types/css-prop.d.ts",
+				"./macro": {
+					types: {
+						"import": "./macro.d.mts",
+						"default": "./macro.d.ts"
+					},
+					"default": "./macro.js"
+				}
+			}
+		}
+	}
+};
+
+var jsx = function jsx(type, props) {
+  var args = arguments;
+
+  if (props == null || !hasOwnProperty.call(props, 'css')) {
+    // $FlowFixMe
+    return React.createElement.apply(undefined, args);
+  }
+
+  var argsLength = args.length;
+  var createElementArgArray = new Array(argsLength);
+  createElementArgArray[0] = Emotion;
+  createElementArgArray[1] = createEmotionProps(type, props);
+
+  for (var i = 2; i < argsLength; i++) {
+    createElementArgArray[i] = args[i];
+  } // $FlowFixMe
+
+
+  return React.createElement.apply(null, createElementArgArray);
+};
+
+var warnedAboutCssPropForGlobal = false; // maintain place over rerenders.
+// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
+// initial client-side render from SSR, use place of hydrating tag
+
+var Global = /* #__PURE__ */withEmotionCache(function (props, cache) {
+  if (process.env.NODE_ENV !== 'production' && !warnedAboutCssPropForGlobal && ( // check for className as well since the user is
+  // probably using the custom createElement which
+  // means it will be turned into a className prop
+  // $FlowFixMe I don't really want to add it to the type since it shouldn't be used
+  props.className || props.css)) {
+    console.error("It looks like you're using the css prop on Global, did you mean to use the styles prop instead?");
+    warnedAboutCssPropForGlobal = true;
+  }
+
+  var styles = props.styles;
+  var serialized = serializeStyles([styles], undefined, React.useContext(ThemeContext));
+
+  if (!isBrowser$1) {
+    var _ref;
+
+    var serializedNames = serialized.name;
+    var serializedStyles = serialized.styles;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      serializedStyles += next.styles;
+      next = next.next;
+    }
+
+    var shouldCache = cache.compat === true;
+    var rules = cache.insert("", {
+      name: serializedNames,
+      styles: serializedStyles
+    }, cache.sheet, shouldCache);
+
+    if (shouldCache) {
+      return null;
+    }
+
+    return /*#__PURE__*/React.createElement("style", (_ref = {}, _ref["data-emotion"] = cache.key + "-global " + serializedNames, _ref.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref.nonce = cache.sheet.nonce, _ref));
+  } // yes, i know these hooks are used conditionally
+  // but it is based on a constant that will never change at runtime
+  // it's effectively like having two implementations and switching them out
+  // so it's not actually breaking anything
+
+
+  var sheetRef = React.useRef();
+  useInsertionEffectWithLayoutFallback(function () {
+    var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675
+
+    var sheet = new cache.sheet.constructor({
+      key: key,
+      nonce: cache.sheet.nonce,
+      container: cache.sheet.container,
+      speedy: cache.sheet.isSpeedy
+    });
+    var rehydrating = false; // $FlowFixMe
+
+    var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");
+
+    if (cache.sheet.tags.length) {
+      sheet.before = cache.sheet.tags[0];
+    }
+
+    if (node !== null) {
+      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
+
+      node.setAttribute('data-emotion', key);
+      sheet.hydrate([node]);
+    }
+
+    sheetRef.current = [sheet, rehydrating];
+    return function () {
+      sheet.flush();
+    };
+  }, [cache]);
+  useInsertionEffectWithLayoutFallback(function () {
+    var sheetRefCurrent = sheetRef.current;
+    var sheet = sheetRefCurrent[0],
+        rehydrating = sheetRefCurrent[1];
+
+    if (rehydrating) {
+      sheetRefCurrent[1] = false;
+      return;
+    }
+
+    if (serialized.next !== undefined) {
+      // insert keyframes
+      insertStyles(cache, serialized.next, true);
+    }
+
+    if (sheet.tags.length) {
+      // if this doesn't exist then it will be null so the style element will be appended
+      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
+      sheet.before = element;
+      sheet.flush();
+    }
+
+    cache.insert("", serialized, sheet, false);
+  }, [cache, serialized.name]);
+  return null;
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  Global.displayName = 'EmotionGlobal';
+}
+
+function css() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return serializeStyles(args);
+}
+
+var keyframes = function keyframes() {
+  var insertable = css.apply(void 0, arguments);
+  var name = "animation-" + insertable.name; // $FlowFixMe
+
+  return {
+    name: name,
+    styles: "@keyframes " + name + "{" + insertable.styles + "}",
+    anim: 1,
+    toString: function toString() {
+      return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
+    }
+  };
+};
+
+var classnames = function classnames(args) {
+  var len = args.length;
+  var i = 0;
+  var cls = '';
+
+  for (; i < len; i++) {
+    var arg = args[i];
+    if (arg == null) continue;
+    var toAdd = void 0;
+
+    switch (typeof arg) {
+      case 'boolean':
+        break;
+
+      case 'object':
+        {
+          if (Array.isArray(arg)) {
+            toAdd = classnames(arg);
+          } else {
+            if (process.env.NODE_ENV !== 'production' && arg.styles !== undefined && arg.name !== undefined) {
+              console.error('You have passed styles created with `css` from `@emotion/react` package to the `cx`.\n' + '`cx` is meant to compose class names (strings) so you should convert those styles to a class name by passing them to the `css` received from <ClassNames/> component.');
+            }
+
+            toAdd = '';
+
+            for (var k in arg) {
+              if (arg[k] && k) {
+                toAdd && (toAdd += ' ');
+                toAdd += k;
+              }
+            }
+          }
+
+          break;
+        }
+
+      default:
+        {
+          toAdd = arg;
+        }
+    }
+
+    if (toAdd) {
+      cls && (cls += ' ');
+      cls += toAdd;
+    }
+  }
+
+  return cls;
+};
+
+function merge(registered, css, className) {
+  var registeredStyles = [];
+  var rawClassName = getRegisteredStyles(registered, registeredStyles, className);
+
+  if (registeredStyles.length < 2) {
+    return className;
+  }
+
+  return rawClassName + css(registeredStyles);
+}
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serializedArr = _ref.serializedArr;
+  var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
+    var rules = '';
+
+    for (var i = 0; i < serializedArr.length; i++) {
+      var res = insertStyles(cache, serializedArr[i], false);
+
+      if (!isBrowser$1 && res !== undefined) {
+        rules += res;
+      }
+    }
+
+    if (!isBrowser$1) {
+      return rules;
+    }
+  });
+
+  if (!isBrowser$1 && rules.length !== 0) {
+    var _ref2;
+
+    return /*#__PURE__*/React.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedArr.map(function (serialized) {
+      return serialized.name;
+    }).join(' '), _ref2.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref2.nonce = cache.sheet.nonce, _ref2));
+  }
+
+  return null;
+};
+
+var ClassNames = /* #__PURE__ */withEmotionCache(function (props, cache) {
+  var hasRendered = false;
+  var serializedArr = [];
+
+  var css = function css() {
+    if (hasRendered && process.env.NODE_ENV !== 'production') {
+      throw new Error('css can only be used during render');
+    }
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var serialized = serializeStyles(args, cache.registered);
+    serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`
+
+    registerStyles(cache, serialized, false);
+    return cache.key + "-" + serialized.name;
+  };
+
+  var cx = function cx() {
+    if (hasRendered && process.env.NODE_ENV !== 'production') {
+      throw new Error('cx can only be used during render');
+    }
+
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    return merge(cache.registered, css, classnames(args));
+  };
+
+  var content = {
+    css: css,
+    cx: cx,
+    theme: React.useContext(ThemeContext)
+  };
+  var ele = props.children(content);
+  hasRendered = true;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {
+    cache: cache,
+    serializedArr: serializedArr
+  }), ele);
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  ClassNames.displayName = 'EmotionClassNames';
+}
+
+if (process.env.NODE_ENV !== 'production') {
+  var isBrowser = typeof document !== 'undefined'; // #1727, #2905 for some reason Jest and Vitest evaluate modules twice if some consuming module gets mocked
+
+  var isTestEnv = typeof jest !== 'undefined' || typeof vi !== 'undefined';
+
+  if (isBrowser && !isTestEnv) {
+    // globalThis has wide browser support - https://caniuse.com/?search=globalThis, Node.js 12 and later
+    var globalContext = // $FlowIgnore
+    typeof globalThis !== 'undefined' ? globalThis // eslint-disable-line no-undef
+    : isBrowser ? window : global;
+    var globalKey = "__EMOTION_REACT_" + pkg.version.split('.')[0] + "__";
+
+    if (globalContext[globalKey]) {
+      console.warn('You are loading @emotion/react when it is already loaded. Running ' + 'multiple instances may cause problems. This can happen if multiple ' + 'versions are used, or if multiple builds of the same version are ' + 'used.');
+    }
+
+    globalContext[globalKey] = true;
+  }
+}
+
+export { ClassNames, Global, jsx as createElement, css, jsx, keyframes };

mc_test/node_modules/@emotion/react/dist/emotion-react.worker.esm.js

@@ -0,0 +1,461 @@
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps, w as withEmotionCache, T as ThemeContext, i as isBrowser$1 } from './emotion-element-2408c5fb.worker.esm.js';
+export { C as CacheProvider, T as ThemeContext, a as ThemeProvider, _ as __unsafe_useEmotionCache, u as useTheme, w as withEmotionCache, b as withTheme } from './emotion-element-2408c5fb.worker.esm.js';
+import * as React from 'react';
+import { insertStyles, registerStyles, getRegisteredStyles } from '@emotion/utils';
+import { useInsertionEffectWithLayoutFallback, useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';
+import { serializeStyles } from '@emotion/serialize';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js';
+import 'hoist-non-react-statics';
+
+var pkg = {
+	name: "@emotion/react",
+	version: "11.11.1",
+	main: "dist/emotion-react.cjs.js",
+	module: "dist/emotion-react.esm.js",
+	browser: {
+		"./dist/emotion-react.esm.js": "./dist/emotion-react.browser.esm.js"
+	},
+	exports: {
+		".": {
+			module: {
+				worker: "./dist/emotion-react.worker.esm.js",
+				browser: "./dist/emotion-react.browser.esm.js",
+				"default": "./dist/emotion-react.esm.js"
+			},
+			"import": "./dist/emotion-react.cjs.mjs",
+			"default": "./dist/emotion-react.cjs.js"
+		},
+		"./jsx-runtime": {
+			module: {
+				worker: "./jsx-runtime/dist/emotion-react-jsx-runtime.worker.esm.js",
+				browser: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js",
+				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.esm.js"
+			},
+			"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
+			"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
+		},
+		"./_isolated-hnrs": {
+			module: {
+				worker: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js",
+				browser: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js",
+				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js"
+			},
+			"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
+			"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
+		},
+		"./jsx-dev-runtime": {
+			module: {
+				worker: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.worker.esm.js",
+				browser: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js",
+				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js"
+			},
+			"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
+			"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
+		},
+		"./package.json": "./package.json",
+		"./types/css-prop": "./types/css-prop.d.ts",
+		"./macro": {
+			types: {
+				"import": "./macro.d.mts",
+				"default": "./macro.d.ts"
+			},
+			"default": "./macro.js"
+		}
+	},
+	types: "types/index.d.ts",
+	files: [
+		"src",
+		"dist",
+		"jsx-runtime",
+		"jsx-dev-runtime",
+		"_isolated-hnrs",
+		"types/*.d.ts",
+		"macro.*"
+	],
+	sideEffects: false,
+	author: "Emotion Contributors",
+	license: "MIT",
+	scripts: {
+		"test:typescript": "dtslint types"
+	},
+	dependencies: {
+		"@babel/runtime": "^7.18.3",
+		"@emotion/babel-plugin": "^11.11.0",
+		"@emotion/cache": "^11.11.0",
+		"@emotion/serialize": "^1.1.2",
+		"@emotion/use-insertion-effect-with-fallbacks": "^1.0.1",
+		"@emotion/utils": "^1.2.1",
+		"@emotion/weak-memoize": "^0.3.1",
+		"hoist-non-react-statics": "^3.3.1"
+	},
+	peerDependencies: {
+		react: ">=16.8.0"
+	},
+	peerDependenciesMeta: {
+		"@types/react": {
+			optional: true
+		}
+	},
+	devDependencies: {
+		"@definitelytyped/dtslint": "0.0.112",
+		"@emotion/css": "11.11.0",
+		"@emotion/css-prettifier": "1.1.3",
+		"@emotion/server": "11.11.0",
+		"@emotion/styled": "11.11.0",
+		"html-tag-names": "^1.1.2",
+		react: "16.14.0",
+		"svg-tag-names": "^1.1.1",
+		typescript: "^4.5.5"
+	},
+	repository: "https://github.com/emotion-js/emotion/tree/main/packages/react",
+	publishConfig: {
+		access: "public"
+	},
+	"umd:main": "dist/emotion-react.umd.min.js",
+	preconstruct: {
+		entrypoints: [
+			"./index.js",
+			"./jsx-runtime.js",
+			"./jsx-dev-runtime.js",
+			"./_isolated-hnrs.js"
+		],
+		umdName: "emotionReact",
+		exports: {
+			envConditions: [
+				"browser",
+				"worker"
+			],
+			extra: {
+				"./types/css-prop": "./types/css-prop.d.ts",
+				"./macro": {
+					types: {
+						"import": "./macro.d.mts",
+						"default": "./macro.d.ts"
+					},
+					"default": "./macro.js"
+				}
+			}
+		}
+	}
+};
+
+var jsx = function jsx(type, props) {
+  var args = arguments;
+
+  if (props == null || !hasOwnProperty.call(props, 'css')) {
+    // $FlowFixMe
+    return React.createElement.apply(undefined, args);
+  }
+
+  var argsLength = args.length;
+  var createElementArgArray = new Array(argsLength);
+  createElementArgArray[0] = Emotion;
+  createElementArgArray[1] = createEmotionProps(type, props);
+
+  for (var i = 2; i < argsLength; i++) {
+    createElementArgArray[i] = args[i];
+  } // $FlowFixMe
+
+
+  return React.createElement.apply(null, createElementArgArray);
+};
+
+var warnedAboutCssPropForGlobal = false; // maintain place over rerenders.
+// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
+// initial client-side render from SSR, use place of hydrating tag
+
+var Global = /* #__PURE__ */withEmotionCache(function (props, cache) {
+  if (process.env.NODE_ENV !== 'production' && !warnedAboutCssPropForGlobal && ( // check for className as well since the user is
+  // probably using the custom createElement which
+  // means it will be turned into a className prop
+  // $FlowFixMe I don't really want to add it to the type since it shouldn't be used
+  props.className || props.css)) {
+    console.error("It looks like you're using the css prop on Global, did you mean to use the styles prop instead?");
+    warnedAboutCssPropForGlobal = true;
+  }
+
+  var styles = props.styles;
+  var serialized = serializeStyles([styles], undefined, React.useContext(ThemeContext));
+
+  if (!isBrowser$1) {
+    var _ref;
+
+    var serializedNames = serialized.name;
+    var serializedStyles = serialized.styles;
+    var next = serialized.next;
+
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name;
+      serializedStyles += next.styles;
+      next = next.next;
+    }
+
+    var shouldCache = cache.compat === true;
+    var rules = cache.insert("", {
+      name: serializedNames,
+      styles: serializedStyles
+    }, cache.sheet, shouldCache);
+
+    if (shouldCache) {
+      return null;
+    }
+
+    return /*#__PURE__*/React.createElement("style", (_ref = {}, _ref["data-emotion"] = cache.key + "-global " + serializedNames, _ref.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref.nonce = cache.sheet.nonce, _ref));
+  } // yes, i know these hooks are used conditionally
+  // but it is based on a constant that will never change at runtime
+  // it's effectively like having two implementations and switching them out
+  // so it's not actually breaking anything
+
+
+  var sheetRef = React.useRef();
+  useInsertionEffectWithLayoutFallback(function () {
+    var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675
+
+    var sheet = new cache.sheet.constructor({
+      key: key,
+      nonce: cache.sheet.nonce,
+      container: cache.sheet.container,
+      speedy: cache.sheet.isSpeedy
+    });
+    var rehydrating = false; // $FlowFixMe
+
+    var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");
+
+    if (cache.sheet.tags.length) {
+      sheet.before = cache.sheet.tags[0];
+    }
+
+    if (node !== null) {
+      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
+
+      node.setAttribute('data-emotion', key);
+      sheet.hydrate([node]);
+    }
+
+    sheetRef.current = [sheet, rehydrating];
+    return function () {
+      sheet.flush();
+    };
+  }, [cache]);
+  useInsertionEffectWithLayoutFallback(function () {
+    var sheetRefCurrent = sheetRef.current;
+    var sheet = sheetRefCurrent[0],
+        rehydrating = sheetRefCurrent[1];
+
+    if (rehydrating) {
+      sheetRefCurrent[1] = false;
+      return;
+    }
+
+    if (serialized.next !== undefined) {
+      // insert keyframes
+      insertStyles(cache, serialized.next, true);
+    }
+
+    if (sheet.tags.length) {
+      // if this doesn't exist then it will be null so the style element will be appended
+      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
+      sheet.before = element;
+      sheet.flush();
+    }
+
+    cache.insert("", serialized, sheet, false);
+  }, [cache, serialized.name]);
+  return null;
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  Global.displayName = 'EmotionGlobal';
+}
+
+function css() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return serializeStyles(args);
+}
+
+var keyframes = function keyframes() {
+  var insertable = css.apply(void 0, arguments);
+  var name = "animation-" + insertable.name; // $FlowFixMe
+
+  return {
+    name: name,
+    styles: "@keyframes " + name + "{" + insertable.styles + "}",
+    anim: 1,
+    toString: function toString() {
+      return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
+    }
+  };
+};
+
+var classnames = function classnames(args) {
+  var len = args.length;
+  var i = 0;
+  var cls = '';
+
+  for (; i < len; i++) {
+    var arg = args[i];
+    if (arg == null) continue;
+    var toAdd = void 0;
+
+    switch (typeof arg) {
+      case 'boolean':
+        break;
+
+      case 'object':
+        {
+          if (Array.isArray(arg)) {
+            toAdd = classnames(arg);
+          } else {
+            if (process.env.NODE_ENV !== 'production' && arg.styles !== undefined && arg.name !== undefined) {
+              console.error('You have passed styles created with `css` from `@emotion/react` package to the `cx`.\n' + '`cx` is meant to compose class names (strings) so you should convert those styles to a class name by passing them to the `css` received from <ClassNames/> component.');
+            }
+
+            toAdd = '';
+
+            for (var k in arg) {
+              if (arg[k] && k) {
+                toAdd && (toAdd += ' ');
+                toAdd += k;
+              }
+            }
+          }
+
+          break;
+        }
+
+      default:
+        {
+          toAdd = arg;
+        }
+    }
+
+    if (toAdd) {
+      cls && (cls += ' ');
+      cls += toAdd;
+    }
+  }
+
+  return cls;
+};
+
+function merge(registered, css, className) {
+  var registeredStyles = [];
+  var rawClassName = getRegisteredStyles(registered, registeredStyles, className);
+
+  if (registeredStyles.length < 2) {
+    return className;
+  }
+
+  return rawClassName + css(registeredStyles);
+}
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serializedArr = _ref.serializedArr;
+  var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
+    var rules = '';
+
+    for (var i = 0; i < serializedArr.length; i++) {
+      var res = insertStyles(cache, serializedArr[i], false);
+
+      if (res !== undefined) {
+        rules += res;
+      }
+    }
+
+    {
+      return rules;
+    }
+  });
+
+  if (rules.length !== 0) {
+    var _ref2;
+
+    return /*#__PURE__*/React.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedArr.map(function (serialized) {
+      return serialized.name;
+    }).join(' '), _ref2.dangerouslySetInnerHTML = {
+      __html: rules
+    }, _ref2.nonce = cache.sheet.nonce, _ref2));
+  }
+
+  return null;
+};
+
+var ClassNames = /* #__PURE__ */withEmotionCache(function (props, cache) {
+  var hasRendered = false;
+  var serializedArr = [];
+
+  var css = function css() {
+    if (hasRendered && process.env.NODE_ENV !== 'production') {
+      throw new Error('css can only be used during render');
+    }
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var serialized = serializeStyles(args, cache.registered);
+    serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`
+
+    registerStyles(cache, serialized, false);
+    return cache.key + "-" + serialized.name;
+  };
+
+  var cx = function cx() {
+    if (hasRendered && process.env.NODE_ENV !== 'production') {
+      throw new Error('cx can only be used during render');
+    }
+
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    return merge(cache.registered, css, classnames(args));
+  };
+
+  var content = {
+    css: css,
+    cx: cx,
+    theme: React.useContext(ThemeContext)
+  };
+  var ele = props.children(content);
+  hasRendered = true;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {
+    cache: cache,
+    serializedArr: serializedArr
+  }), ele);
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  ClassNames.displayName = 'EmotionClassNames';
+}
+
+if (process.env.NODE_ENV !== 'production') {
+  var isBrowser = "undefined" !== 'undefined'; // #1727, #2905 for some reason Jest and Vitest evaluate modules twice if some consuming module gets mocked
+
+  var isTestEnv = typeof jest !== 'undefined' || typeof vi !== 'undefined';
+
+  if (isBrowser && !isTestEnv) {
+    // globalThis has wide browser support - https://caniuse.com/?search=globalThis, Node.js 12 and later
+    var globalContext = // $FlowIgnore
+    typeof globalThis !== 'undefined' ? globalThis // eslint-disable-line no-undef
+    : isBrowser ? window : global;
+    var globalKey = "__EMOTION_REACT_" + pkg.version.split('.')[0] + "__";
+
+    if (globalContext[globalKey]) {
+      console.warn('You are loading @emotion/react when it is already loaded. Running ' + 'multiple instances may cause problems. This can happen if multiple ' + 'versions are used, or if multiple builds of the same version are ' + 'used.');
+    }
+
+    globalContext[globalKey] = true;
+  }
+}
+
+export { ClassNames, Global, jsx as createElement, css, jsx, keyframes };

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js

@@ -0,0 +1,22 @@
+import * as ReactJSXRuntimeDev from 'react/jsx-dev-runtime';
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps } from '../../dist/emotion-element-c39617d8.browser.esm.js';
+import 'react';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js';
+import 'hoist-non-react-statics';
+import '@emotion/utils';
+import '@emotion/serialize';
+import '@emotion/use-insertion-effect-with-fallbacks';
+
+var Fragment = ReactJSXRuntimeDev.Fragment;
+function jsxDEV(type, props, key, isStaticChildren, source, self) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntimeDev.jsxDEV(type, props, key, isStaticChildren, source, self);
+  }
+
+  return ReactJSXRuntimeDev.jsxDEV(Emotion, createEmotionProps(type, props), key, isStaticChildren, source, self);
+}
+
+export { Fragment, jsxDEV };

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/jsx-dev-runtime.js";
+//# sourceMappingURL=emotion-react-jsx-dev-runtime.cjs.d.mts.map

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotion-react-jsx-dev-runtime.cjs.d.mts","sourceRoot":"","sources":["../../dist/declarations/src/jsx-dev-runtime.d.ts"],"names":[],"mappings":"AAAA"}

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/jsx-dev-runtime";
+//# sourceMappingURL=emotion-react-jsx-dev-runtime.cjs.d.ts.map

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotion-react-jsx-dev-runtime.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/jsx-dev-runtime.d.ts"],"names":[],"mappings":"AAAA"}

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.dev.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ReactJSXRuntimeDev = require('react/jsx-dev-runtime');
+var emotionElement = require('../../dist/emotion-element-48d2c2e4.cjs.dev.js');
+require('react');
+require('@emotion/cache');
+require('@babel/runtime/helpers/extends');
+require('@emotion/weak-memoize');
+require('../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.dev.js');
+require('hoist-non-react-statics');
+require('@emotion/utils');
+require('@emotion/serialize');
+require('@emotion/use-insertion-effect-with-fallbacks');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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 ReactJSXRuntimeDev__namespace = /*#__PURE__*/_interopNamespace(ReactJSXRuntimeDev);
+
+var Fragment = ReactJSXRuntimeDev__namespace.Fragment;
+function jsxDEV(type, props, key, isStaticChildren, source, self) {
+  if (!emotionElement.hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntimeDev__namespace.jsxDEV(type, props, key, isStaticChildren, source, self);
+  }
+
+  return ReactJSXRuntimeDev__namespace.jsxDEV(emotionElement.Emotion, emotionElement.createEmotionProps(type, props), key, isStaticChildren, source, self);
+}
+
+exports.Fragment = Fragment;
+exports.jsxDEV = jsxDEV;

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./emotion-react-jsx-dev-runtime.cjs.prod.js");
+} else {
+  module.exports = require("./emotion-react-jsx-dev-runtime.cjs.dev.js");
+}

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js.flow

@@ -0,0 +1,2 @@
+// @flow
+export * from "../../src/jsx-dev-runtime.js";

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs

@@ -0,0 +1,4 @@
+export {
+  Fragment,
+  jsxDEV
+} from "./emotion-react-jsx-dev-runtime.cjs.js";

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.prod.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ReactJSXRuntimeDev = require('react/jsx-dev-runtime');
+var emotionElement = require('../../dist/emotion-element-4300ad44.cjs.prod.js');
+require('react');
+require('@emotion/cache');
+require('@babel/runtime/helpers/extends');
+require('@emotion/weak-memoize');
+require('../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.prod.js');
+require('hoist-non-react-statics');
+require('@emotion/utils');
+require('@emotion/serialize');
+require('@emotion/use-insertion-effect-with-fallbacks');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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 ReactJSXRuntimeDev__namespace = /*#__PURE__*/_interopNamespace(ReactJSXRuntimeDev);
+
+var Fragment = ReactJSXRuntimeDev__namespace.Fragment;
+function jsxDEV(type, props, key, isStaticChildren, source, self) {
+  if (!emotionElement.hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntimeDev__namespace.jsxDEV(type, props, key, isStaticChildren, source, self);
+  }
+
+  return ReactJSXRuntimeDev__namespace.jsxDEV(emotionElement.Emotion, emotionElement.createEmotionProps(type, props), key, isStaticChildren, source, self);
+}
+
+exports.Fragment = Fragment;
+exports.jsxDEV = jsxDEV;

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js

@@ -0,0 +1,22 @@
+import * as ReactJSXRuntimeDev from 'react/jsx-dev-runtime';
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps } from '../../dist/emotion-element-6bdfffb2.esm.js';
+import 'react';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js';
+import 'hoist-non-react-statics';
+import '@emotion/utils';
+import '@emotion/serialize';
+import '@emotion/use-insertion-effect-with-fallbacks';
+
+var Fragment = ReactJSXRuntimeDev.Fragment;
+function jsxDEV(type, props, key, isStaticChildren, source, self) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntimeDev.jsxDEV(type, props, key, isStaticChildren, source, self);
+  }
+
+  return ReactJSXRuntimeDev.jsxDEV(Emotion, createEmotionProps(type, props), key, isStaticChildren, source, self);
+}
+
+export { Fragment, jsxDEV };

mc_test/node_modules/@emotion/react/jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.worker.esm.js

@@ -0,0 +1,22 @@
+import * as ReactJSXRuntimeDev from 'react/jsx-dev-runtime';
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps } from '../../dist/emotion-element-2408c5fb.worker.esm.js';
+import 'react';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js';
+import 'hoist-non-react-statics';
+import '@emotion/utils';
+import '@emotion/serialize';
+import '@emotion/use-insertion-effect-with-fallbacks';
+
+var Fragment = ReactJSXRuntimeDev.Fragment;
+function jsxDEV(type, props, key, isStaticChildren, source, self) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntimeDev.jsxDEV(type, props, key, isStaticChildren, source, self);
+  }
+
+  return ReactJSXRuntimeDev.jsxDEV(Emotion, createEmotionProps(type, props), key, isStaticChildren, source, self);
+}
+
+export { Fragment, jsxDEV };

mc_test/node_modules/@emotion/react/jsx-dev-runtime/package.json

@@ -0,0 +1,13 @@
+{
+  "main": "dist/emotion-react-jsx-dev-runtime.cjs.js",
+  "module": "dist/emotion-react-jsx-dev-runtime.esm.js",
+  "umd:main": "dist/emotion-react-jsx-dev-runtime.umd.min.js",
+  "browser": {
+    "./dist/emotion-react-jsx-dev-runtime.esm.js": "./dist/emotion-react-jsx-dev-runtime.browser.esm.js"
+  },
+  "types": "../types/jsx-dev-runtime",
+  "sideEffects": false,
+  "preconstruct": {
+    "umdName": "emotionReactJSXDevRuntime"
+  }
+}

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js

@@ -0,0 +1,29 @@
+import * as ReactJSXRuntime from 'react/jsx-runtime';
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps } from '../../dist/emotion-element-c39617d8.browser.esm.js';
+import 'react';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js';
+import 'hoist-non-react-statics';
+import '@emotion/utils';
+import '@emotion/serialize';
+import '@emotion/use-insertion-effect-with-fallbacks';
+
+var Fragment = ReactJSXRuntime.Fragment;
+function jsx(type, props, key) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime.jsx(type, props, key);
+  }
+
+  return ReactJSXRuntime.jsx(Emotion, createEmotionProps(type, props), key);
+}
+function jsxs(type, props, key) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime.jsxs(type, props, key);
+  }
+
+  return ReactJSXRuntime.jsxs(Emotion, createEmotionProps(type, props), key);
+}
+
+export { Fragment, jsx, jsxs };

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/jsx-runtime.js";
+//# sourceMappingURL=emotion-react-jsx-runtime.cjs.d.mts.map

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotion-react-jsx-runtime.cjs.d.mts","sourceRoot":"","sources":["../../dist/declarations/src/jsx-runtime.d.ts"],"names":[],"mappings":"AAAA"}

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/jsx-runtime";
+//# sourceMappingURL=emotion-react-jsx-runtime.cjs.d.ts.map

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotion-react-jsx-runtime.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/jsx-runtime.d.ts"],"names":[],"mappings":"AAAA"}

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.dev.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ReactJSXRuntime = require('react/jsx-runtime');
+var emotionElement = require('../../dist/emotion-element-48d2c2e4.cjs.dev.js');
+require('react');
+require('@emotion/cache');
+require('@babel/runtime/helpers/extends');
+require('@emotion/weak-memoize');
+require('../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.dev.js');
+require('hoist-non-react-statics');
+require('@emotion/utils');
+require('@emotion/serialize');
+require('@emotion/use-insertion-effect-with-fallbacks');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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 ReactJSXRuntime__namespace = /*#__PURE__*/_interopNamespace(ReactJSXRuntime);
+
+var Fragment = ReactJSXRuntime__namespace.Fragment;
+function jsx(type, props, key) {
+  if (!emotionElement.hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime__namespace.jsx(type, props, key);
+  }
+
+  return ReactJSXRuntime__namespace.jsx(emotionElement.Emotion, emotionElement.createEmotionProps(type, props), key);
+}
+function jsxs(type, props, key) {
+  if (!emotionElement.hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime__namespace.jsxs(type, props, key);
+  }
+
+  return ReactJSXRuntime__namespace.jsxs(emotionElement.Emotion, emotionElement.createEmotionProps(type, props), key);
+}
+
+exports.Fragment = Fragment;
+exports.jsx = jsx;
+exports.jsxs = jsxs;

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./emotion-react-jsx-runtime.cjs.prod.js");
+} else {
+  module.exports = require("./emotion-react-jsx-runtime.cjs.dev.js");
+}

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js.flow

@@ -0,0 +1,2 @@
+// @flow
+export * from "../../src/jsx-runtime.js";

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs

@@ -0,0 +1,5 @@
+export {
+  Fragment,
+  jsx,
+  jsxs
+} from "./emotion-react-jsx-runtime.cjs.js";

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.cjs.prod.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ReactJSXRuntime = require('react/jsx-runtime');
+var emotionElement = require('../../dist/emotion-element-4300ad44.cjs.prod.js');
+require('react');
+require('@emotion/cache');
+require('@babel/runtime/helpers/extends');
+require('@emotion/weak-memoize');
+require('../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.prod.js');
+require('hoist-non-react-statics');
+require('@emotion/utils');
+require('@emotion/serialize');
+require('@emotion/use-insertion-effect-with-fallbacks');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return 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 ReactJSXRuntime__namespace = /*#__PURE__*/_interopNamespace(ReactJSXRuntime);
+
+var Fragment = ReactJSXRuntime__namespace.Fragment;
+function jsx(type, props, key) {
+  if (!emotionElement.hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime__namespace.jsx(type, props, key);
+  }
+
+  return ReactJSXRuntime__namespace.jsx(emotionElement.Emotion, emotionElement.createEmotionProps(type, props), key);
+}
+function jsxs(type, props, key) {
+  if (!emotionElement.hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime__namespace.jsxs(type, props, key);
+  }
+
+  return ReactJSXRuntime__namespace.jsxs(emotionElement.Emotion, emotionElement.createEmotionProps(type, props), key);
+}
+
+exports.Fragment = Fragment;
+exports.jsx = jsx;
+exports.jsxs = jsxs;

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.esm.js

@@ -0,0 +1,29 @@
+import * as ReactJSXRuntime from 'react/jsx-runtime';
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps } from '../../dist/emotion-element-6bdfffb2.esm.js';
+import 'react';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js';
+import 'hoist-non-react-statics';
+import '@emotion/utils';
+import '@emotion/serialize';
+import '@emotion/use-insertion-effect-with-fallbacks';
+
+var Fragment = ReactJSXRuntime.Fragment;
+function jsx(type, props, key) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime.jsx(type, props, key);
+  }
+
+  return ReactJSXRuntime.jsx(Emotion, createEmotionProps(type, props), key);
+}
+function jsxs(type, props, key) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime.jsxs(type, props, key);
+  }
+
+  return ReactJSXRuntime.jsxs(Emotion, createEmotionProps(type, props), key);
+}
+
+export { Fragment, jsx, jsxs };

mc_test/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.worker.esm.js

@@ -0,0 +1,29 @@
+import * as ReactJSXRuntime from 'react/jsx-runtime';
+import { h as hasOwnProperty, E as Emotion, c as createEmotionProps } from '../../dist/emotion-element-2408c5fb.worker.esm.js';
+import 'react';
+import '@emotion/cache';
+import '@babel/runtime/helpers/extends';
+import '@emotion/weak-memoize';
+import '../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js';
+import 'hoist-non-react-statics';
+import '@emotion/utils';
+import '@emotion/serialize';
+import '@emotion/use-insertion-effect-with-fallbacks';
+
+var Fragment = ReactJSXRuntime.Fragment;
+function jsx(type, props, key) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime.jsx(type, props, key);
+  }
+
+  return ReactJSXRuntime.jsx(Emotion, createEmotionProps(type, props), key);
+}
+function jsxs(type, props, key) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime.jsxs(type, props, key);
+  }
+
+  return ReactJSXRuntime.jsxs(Emotion, createEmotionProps(type, props), key);
+}
+
+export { Fragment, jsx, jsxs };

mc_test/node_modules/@emotion/react/jsx-runtime/package.json

@@ -0,0 +1,13 @@
+{
+  "main": "dist/emotion-react-jsx-runtime.cjs.js",
+  "module": "dist/emotion-react-jsx-runtime.esm.js",
+  "umd:main": "dist/emotion-react-jsx-runtime.umd.min.js",
+  "browser": {
+    "./dist/emotion-react-jsx-runtime.esm.js": "./dist/emotion-react-jsx-runtime.browser.esm.js"
+  },
+  "types": "../types/jsx-runtime",
+  "sideEffects": false,
+  "preconstruct": {
+    "umdName": "emotionReactJSXRuntime"
+  }
+}

mc_test/node_modules/@emotion/react/macro.d.mts

@@ -0,0 +1 @@
+export * from './macro.js'

mc_test/node_modules/@emotion/react/macro.d.ts

@@ -0,0 +1 @@
+export * from '@emotion/react'

mc_test/node_modules/@emotion/react/macro.js

@@ -0,0 +1 @@
+module.exports = require('@emotion/babel-plugin').macros.core

mc_test/node_modules/@emotion/react/macro.js.flow

@@ -0,0 +1,2 @@
+// @flow
+export * from './src/index.js'

mc_test/node_modules/@emotion/react/package.json

@@ -0,0 +1,131 @@
+{
+  "name": "@emotion/react",
+  "version": "11.11.1",
+  "main": "dist/emotion-react.cjs.js",
+  "module": "dist/emotion-react.esm.js",
+  "browser": {
+    "./dist/emotion-react.esm.js": "./dist/emotion-react.browser.esm.js"
+  },
+  "exports": {
+    ".": {
+      "module": {
+        "worker": "./dist/emotion-react.worker.esm.js",
+        "browser": "./dist/emotion-react.browser.esm.js",
+        "default": "./dist/emotion-react.esm.js"
+      },
+      "import": "./dist/emotion-react.cjs.mjs",
+      "default": "./dist/emotion-react.cjs.js"
+    },
+    "./jsx-runtime": {
+      "module": {
+        "worker": "./jsx-runtime/dist/emotion-react-jsx-runtime.worker.esm.js",
+        "browser": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js",
+        "default": "./jsx-runtime/dist/emotion-react-jsx-runtime.esm.js"
+      },
+      "import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
+      "default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
+    },
+    "./_isolated-hnrs": {
+      "module": {
+        "worker": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js",
+        "browser": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js",
+        "default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js"
+      },
+      "import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
+      "default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
+    },
+    "./jsx-dev-runtime": {
+      "module": {
+        "worker": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.worker.esm.js",
+        "browser": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js",
+        "default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js"
+      },
+      "import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
+      "default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
+    },
+    "./package.json": "./package.json",
+    "./types/css-prop": "./types/css-prop.d.ts",
+    "./macro": {
+      "types": {
+        "import": "./macro.d.mts",
+        "default": "./macro.d.ts"
+      },
+      "default": "./macro.js"
+    }
+  },
+  "types": "types/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "jsx-runtime",
+    "jsx-dev-runtime",
+    "_isolated-hnrs",
+    "types/*.d.ts",
+    "macro.*"
+  ],
+  "sideEffects": false,
+  "author": "Emotion Contributors",
+  "license": "MIT",
+  "scripts": {
+    "test:typescript": "dtslint types"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.18.3",
+    "@emotion/babel-plugin": "^11.11.0",
+    "@emotion/cache": "^11.11.0",
+    "@emotion/serialize": "^1.1.2",
+    "@emotion/use-insertion-effect-with-fallbacks": "^1.0.1",
+    "@emotion/utils": "^1.2.1",
+    "@emotion/weak-memoize": "^0.3.1",
+    "hoist-non-react-statics": "^3.3.1"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@definitelytyped/dtslint": "0.0.112",
+    "@emotion/css": "11.11.0",
+    "@emotion/css-prettifier": "1.1.3",
+    "@emotion/server": "11.11.0",
+    "@emotion/styled": "11.11.0",
+    "html-tag-names": "^1.1.2",
+    "react": "16.14.0",
+    "svg-tag-names": "^1.1.1",
+    "typescript": "^4.5.5"
+  },
+  "repository": "https://github.com/emotion-js/emotion/tree/main/packages/react",
+  "publishConfig": {
+    "access": "public"
+  },
+  "umd:main": "dist/emotion-react.umd.min.js",
+  "preconstruct": {
+    "entrypoints": [
+      "./index.js",
+      "./jsx-runtime.js",
+      "./jsx-dev-runtime.js",
+      "./_isolated-hnrs.js"
+    ],
+    "umdName": "emotionReact",
+    "exports": {
+      "envConditions": [
+        "browser",
+        "worker"
+      ],
+      "extra": {
+        "./types/css-prop": "./types/css-prop.d.ts",
+        "./macro": {
+          "types": {
+            "import": "./macro.d.mts",
+            "default": "./macro.d.ts"
+          },
+          "default": "./macro.js"
+        }
+      }
+    }
+  }
+}

mc_test/node_modules/@emotion/react/src/_isolated-hnrs.d.ts

@@ -0,0 +1,3 @@
+// this entry point is not publicly available so we don't need to expose any types here
+// we need to define a definition file for each entrypoint though, otherwise Preconstruct might get confused
+export {}

mc_test/node_modules/@emotion/react/src/_isolated-hnrs.js

@@ -0,0 +1,10 @@
+// this file isolates this package that is not tree-shakeable
+// and allows it to be dropped - if it stays unused
+// it happens thanks to sideEffects: false in our package.json
+import hoistNonReactStatics from 'hoist-non-react-statics'
+
+// have to wrap it in a proxy function because Rollup is too damn smart
+// and if this module doesn't actually contain any logic of its own
+// then Rollup just use 'hoist-non-react-statics' directly in other chunks
+export default (targetComponent, sourceComponent) =>
+  hoistNonReactStatics(targetComponent, sourceComponent)

mc_test/node_modules/@emotion/react/src/class-names.js

@@ -0,0 +1,166 @@
+// @flow
+import * as React from 'react'
+import {
+  getRegisteredStyles,
+  insertStyles,
+  registerStyles
+} from '@emotion/utils'
+import { serializeStyles } from '@emotion/serialize'
+import { withEmotionCache } from './context'
+import { ThemeContext } from './theming'
+import { useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks'
+import { isBrowser } from './utils'
+
+type ClassNameArg =
+  | string
+  | boolean
+  | { [key: string]: boolean }
+  | Array<ClassNameArg>
+  | null
+  | void
+
+let classnames = (args: Array<ClassNameArg>): string => {
+  let len = args.length
+  let i = 0
+  let cls = ''
+  for (; i < len; i++) {
+    let arg = args[i]
+    if (arg == null) continue
+
+    let toAdd
+    switch (typeof arg) {
+      case 'boolean':
+        break
+      case 'object': {
+        if (Array.isArray(arg)) {
+          toAdd = classnames(arg)
+        } else {
+          if (
+            process.env.NODE_ENV !== 'production' &&
+            arg.styles !== undefined &&
+            arg.name !== undefined
+          ) {
+            console.error(
+              'You have passed styles created with `css` from `@emotion/react` package to the `cx`.\n' +
+                '`cx` is meant to compose class names (strings) so you should convert those styles to a class name by passing them to the `css` received from <ClassNames/> component.'
+            )
+          }
+          toAdd = ''
+          for (const k in arg) {
+            if (arg[k] && k) {
+              toAdd && (toAdd += ' ')
+              toAdd += k
+            }
+          }
+        }
+        break
+      }
+      default: {
+        toAdd = arg
+      }
+    }
+    if (toAdd) {
+      cls && (cls += ' ')
+      cls += toAdd
+    }
+  }
+  return cls
+}
+function merge(
+  registered: Object,
+  css: (...args: Array<any>) => string,
+  className: string
+) {
+  const registeredStyles = []
+
+  const rawClassName = getRegisteredStyles(
+    registered,
+    registeredStyles,
+    className
+  )
+
+  if (registeredStyles.length < 2) {
+    return className
+  }
+  return rawClassName + css(registeredStyles)
+}
+
+type Props = {
+  children: ({
+    css: (...args: any) => string,
+    cx: (...args: Array<ClassNameArg>) => string,
+    theme: Object
+  }) => React.Node
+}
+
+const Insertion = ({ cache, serializedArr }) => {
+  let rules = useInsertionEffectAlwaysWithSyncFallback(() => {
+    let rules = ''
+    for (let i = 0; i < serializedArr.length; i++) {
+      let res = insertStyles(cache, serializedArr[i], false)
+      if (!isBrowser && res !== undefined) {
+        rules += res
+      }
+    }
+    if (!isBrowser) {
+      return rules
+    }
+  })
+
+  if (!isBrowser && rules.length !== 0) {
+    return (
+      <style
+        {...{
+          [`data-emotion`]: `${cache.key} ${serializedArr
+            .map(serialized => serialized.name)
+            .join(' ')}`,
+          dangerouslySetInnerHTML: { __html: rules },
+          nonce: cache.sheet.nonce
+        }}
+      />
+    )
+  }
+  return null
+}
+
+export const ClassNames: React.AbstractComponent<Props> =
+  /* #__PURE__ */ withEmotionCache((props, cache) => {
+    let hasRendered = false
+    let serializedArr = []
+
+    let css = (...args: Array<any>) => {
+      if (hasRendered && process.env.NODE_ENV !== 'production') {
+        throw new Error('css can only be used during render')
+      }
+
+      let serialized = serializeStyles(args, cache.registered)
+      serializedArr.push(serialized)
+      // registration has to happen here as the result of this might get consumed by `cx`
+      registerStyles(cache, serialized, false)
+      return `${cache.key}-${serialized.name}`
+    }
+    let cx = (...args: Array<ClassNameArg>) => {
+      if (hasRendered && process.env.NODE_ENV !== 'production') {
+        throw new Error('cx can only be used during render')
+      }
+      return merge(cache.registered, css, classnames(args))
+    }
+    let content = {
+      css,
+      cx,
+      theme: React.useContext(ThemeContext)
+    }
+    let ele = props.children(content)
+    hasRendered = true
+
+    return (
+      <>
+        <Insertion cache={cache} serializedArr={serializedArr} />
+        {ele}
+      </>
+    )
+  })
+
+if (process.env.NODE_ENV !== 'production') {
+  ClassNames.displayName = 'EmotionClassNames'
+}

mc_test/node_modules/@emotion/react/src/context.js

@@ -0,0 +1,69 @@
+// @flow
+import { type EmotionCache } from '@emotion/utils'
+import * as React from 'react'
+import { useContext, forwardRef } from 'react'
+import createCache from '@emotion/cache'
+import { isBrowser } from './utils'
+
+let EmotionCacheContext: React.Context<EmotionCache | null> =
+  /* #__PURE__ */ React.createContext(
+    // we're doing this to avoid preconstruct's dead code elimination in this one case
+    // because this module is primarily intended for the browser and node
+    // but it's also required in react native and similar environments sometimes
+    // and we could have a special build just for that
+    // but this is much easier and the native packages
+    // might use a different theme context in the future anyway
+    typeof HTMLElement !== 'undefined'
+      ? /* #__PURE__ */ createCache({ key: 'css' })
+      : null
+  )
+
+if (process.env.NODE_ENV !== 'production') {
+  EmotionCacheContext.displayName = 'EmotionCacheContext'
+}
+
+export let CacheProvider = EmotionCacheContext.Provider
+
+export let __unsafe_useEmotionCache =
+  function useEmotionCache(): EmotionCache | null {
+    return useContext(EmotionCacheContext)
+  }
+
+let withEmotionCache = function withEmotionCache<Props, Ref: React.Ref<*>>(
+  func: (props: Props, cache: EmotionCache, ref: Ref) => React.Node
+): React.AbstractComponent<Props> {
+  // $FlowFixMe
+  return forwardRef((props: Props, ref: Ref) => {
+    // the cache will never be null in the browser
+    let cache = ((useContext(EmotionCacheContext): any): EmotionCache)
+
+    return func(props, cache, ref)
+  })
+}
+
+if (!isBrowser) {
+  withEmotionCache = function withEmotionCache<Props>(
+    func: (props: Props, cache: EmotionCache) => React.Node
+  ): React.StatelessFunctionalComponent<Props> {
+    return (props: Props) => {
+      let cache = useContext(EmotionCacheContext)
+      if (cache === null) {
+        // yes, we're potentially creating this on every render
+        // it doesn't actually matter though since it's only on the server
+        // so there will only every be a single render
+        // that could change in the future because of suspense and etc. but for now,
+        // this works and i don't want to optimise for a future thing that we aren't sure about
+        cache = createCache({ key: 'css' })
+        return (
+          <EmotionCacheContext.Provider value={cache}>
+            {func(props, cache)}
+          </EmotionCacheContext.Provider>
+        )
+      } else {
+        return func(props, cache)
+      }
+    }
+  }
+}
+
+export { withEmotionCache }

mc_test/node_modules/@emotion/react/src/css.js

@@ -0,0 +1,10 @@
+// @flow
+
+import type { Interpolation, SerializedStyles } from '@emotion/utils'
+import { serializeStyles } from '@emotion/serialize'
+
+function css(...args: Array<Interpolation>): SerializedStyles {
+  return serializeStyles(args)
+}
+
+export default css

mc_test/node_modules/@emotion/react/src/emotion-element.js

@@ -0,0 +1,164 @@
+// @flow
+import * as React from 'react'
+import { withEmotionCache } from './context'
+import { ThemeContext } from './theming'
+import {
+  getRegisteredStyles,
+  insertStyles,
+  registerStyles
+} from '@emotion/utils'
+import { hasOwnProperty, isBrowser } from './utils'
+import { serializeStyles } from '@emotion/serialize'
+import { getLabelFromStackTrace } from './get-label-from-stack-trace'
+import { useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks'
+
+let typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__'
+
+let labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__'
+
+export const createEmotionProps = (type: React.ElementType, props: Object) => {
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    typeof props.css === 'string' &&
+    // check if there is a css declaration
+    props.css.indexOf(':') !== -1
+  ) {
+    throw new Error(
+      `Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/react' like this: css\`${props.css}\``
+    )
+  }
+
+  let newProps: any = {}
+
+  for (let key in props) {
+    if (hasOwnProperty.call(props, key)) {
+      newProps[key] = props[key]
+    }
+  }
+
+  newProps[typePropName] = type
+
+  // For performance, only call getLabelFromStackTrace in development and when
+  // the label hasn't already been computed
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    !!props.css &&
+    (typeof props.css !== 'object' ||
+      typeof props.css.name !== 'string' ||
+      props.css.name.indexOf('-') === -1)
+  ) {
+    const label = getLabelFromStackTrace(new Error().stack)
+    if (label) newProps[labelPropName] = label
+  }
+
+  return newProps
+}
+
+const Insertion = ({ cache, serialized, isStringTag }) => {
+  registerStyles(cache, serialized, isStringTag)
+
+  const rules = useInsertionEffectAlwaysWithSyncFallback(() =>
+    insertStyles(cache, serialized, isStringTag)
+  )
+
+  if (!isBrowser && rules !== undefined) {
+    let serializedNames = serialized.name
+    let next = serialized.next
+    while (next !== undefined) {
+      serializedNames += ' ' + next.name
+      next = next.next
+    }
+    return (
+      <style
+        {...{
+          [`data-emotion`]: `${cache.key} ${serializedNames}`,
+          dangerouslySetInnerHTML: { __html: rules },
+          nonce: cache.sheet.nonce
+        }}
+      />
+    )
+  }
+  return null
+}
+
+let Emotion = /* #__PURE__ */ withEmotionCache<any, any>(
+  (props, cache, ref) => {
+    let cssProp = props.css
+
+    // so that using `css` from `emotion` and passing the result to the css prop works
+    // not passing the registered cache to serializeStyles because it would
+    // make certain babel optimisations not possible
+    if (
+      typeof cssProp === 'string' &&
+      cache.registered[cssProp] !== undefined
+    ) {
+      cssProp = cache.registered[cssProp]
+    }
+
+    let WrappedComponent = props[typePropName]
+    let registeredStyles = [cssProp]
+    let className = ''
+
+    if (typeof props.className === 'string') {
+      className = getRegisteredStyles(
+        cache.registered,
+        registeredStyles,
+        props.className
+      )
+    } else if (props.className != null) {
+      className = `${props.className} `
+    }
+
+    let serialized = serializeStyles(
+      registeredStyles,
+      undefined,
+      React.useContext(ThemeContext)
+    )
+
+    if (
+      process.env.NODE_ENV !== 'production' &&
+      serialized.name.indexOf('-') === -1
+    ) {
+      let labelFromStack = props[labelPropName]
+      if (labelFromStack) {
+        serialized = serializeStyles([
+          serialized,
+          'label:' + labelFromStack + ';'
+        ])
+      }
+    }
+
+    className += `${cache.key}-${serialized.name}`
+
+    const newProps = {}
+    for (let key in props) {
+      if (
+        hasOwnProperty.call(props, key) &&
+        key !== 'css' &&
+        key !== typePropName &&
+        (process.env.NODE_ENV === 'production' || key !== labelPropName)
+      ) {
+        newProps[key] = props[key]
+      }
+    }
+    newProps.ref = ref
+    newProps.className = className
+
+    return (
+      <>
+        <Insertion
+          cache={cache}
+          serialized={serialized}
+          isStringTag={typeof WrappedComponent === 'string'}
+        />
+        <WrappedComponent {...newProps} />
+      </>
+    )
+  }
+)
+
+if (process.env.NODE_ENV !== 'production') {
+  Emotion.displayName = 'EmotionCssPropInternal'
+}
+
+export default Emotion

mc_test/node_modules/@emotion/react/src/get-label-from-stack-trace.js

@@ -0,0 +1,55 @@
+// @flow
+
+const getLastPart = (functionName: string): string => {
+  // The match may be something like 'Object.createEmotionProps' or
+  // 'Loader.prototype.render'
+  const parts = functionName.split('.')
+  return parts[parts.length - 1]
+}
+
+const getFunctionNameFromStackTraceLine = (line: string): ?string => {
+  // V8
+  let match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line)
+  if (match) return getLastPart(match[1])
+
+  // Safari / Firefox
+  match = /^([A-Za-z0-9$.]+)@/.exec(line)
+  if (match) return getLastPart(match[1])
+
+  return undefined
+}
+
+const internalReactFunctionNames = /* #__PURE__ */ new Set([
+  'renderWithHooks',
+  'processChild',
+  'finishClassComponent',
+  'renderToString'
+])
+
+// These identifiers come from error stacks, so they have to be valid JS
+// identifiers, thus we only need to replace what is a valid character for JS,
+// but not for CSS.
+const sanitizeIdentifier = (identifier: string) =>
+  identifier.replace(/\$/g, '-')
+
+export const getLabelFromStackTrace = (stackTrace: string): ?string => {
+  if (!stackTrace) return undefined
+
+  const lines = stackTrace.split('\n')
+
+  for (let i = 0; i < lines.length; i++) {
+    const functionName = getFunctionNameFromStackTraceLine(lines[i])
+
+    // The first line of V8 stack traces is just "Error"
+    if (!functionName) continue
+
+    // If we reach one of these, we have gone too far and should quit
+    if (internalReactFunctionNames.has(functionName)) break
+
+    // The component name is the first function in the stack that starts with an
+    // uppercase letter
+    if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName)
+  }
+
+  return undefined
+}

mc_test/node_modules/@emotion/react/src/global.js

@@ -0,0 +1,143 @@
+// @flow
+import * as React from 'react'
+import { withEmotionCache } from './context'
+import { ThemeContext } from './theming'
+import { insertStyles } from '@emotion/utils'
+import { isBrowser } from './utils'
+import { useInsertionEffectWithLayoutFallback } from '@emotion/use-insertion-effect-with-fallbacks'
+
+import { serializeStyles } from '@emotion/serialize'
+
+type Styles = Object | Array<Object>
+
+type GlobalProps = {
+  +styles: Styles | (Object => Styles)
+}
+
+let warnedAboutCssPropForGlobal = false
+
+// maintain place over rerenders.
+// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
+// initial client-side render from SSR, use place of hydrating tag
+
+export let Global: React.AbstractComponent<GlobalProps> =
+  /* #__PURE__ */ withEmotionCache((props: GlobalProps, cache) => {
+    if (
+      process.env.NODE_ENV !== 'production' &&
+      !warnedAboutCssPropForGlobal && // check for className as well since the user is
+      // probably using the custom createElement which
+      // means it will be turned into a className prop
+      // $FlowFixMe I don't really want to add it to the type since it shouldn't be used
+      (props.className || props.css)
+    ) {
+      console.error(
+        "It looks like you're using the css prop on Global, did you mean to use the styles prop instead?"
+      )
+      warnedAboutCssPropForGlobal = true
+    }
+    let styles = props.styles
+
+    let serialized = serializeStyles(
+      [styles],
+      undefined,
+      React.useContext(ThemeContext)
+    )
+
+    if (!isBrowser) {
+      let serializedNames = serialized.name
+      let serializedStyles = serialized.styles
+      let next = serialized.next
+      while (next !== undefined) {
+        serializedNames += ' ' + next.name
+        serializedStyles += next.styles
+        next = next.next
+      }
+
+      let shouldCache = cache.compat === true
+
+      let rules = cache.insert(
+        ``,
+        { name: serializedNames, styles: serializedStyles },
+        cache.sheet,
+        shouldCache
+      )
+
+      if (shouldCache) {
+        return null
+      }
+
+      return (
+        <style
+          {...{
+            [`data-emotion`]: `${cache.key}-global ${serializedNames}`,
+            dangerouslySetInnerHTML: { __html: rules },
+            nonce: cache.sheet.nonce
+          }}
+        />
+      )
+    }
+
+    // yes, i know these hooks are used conditionally
+    // but it is based on a constant that will never change at runtime
+    // it's effectively like having two implementations and switching them out
+    // so it's not actually breaking anything
+
+    let sheetRef = React.useRef()
+
+    useInsertionEffectWithLayoutFallback(() => {
+      const key = `${cache.key}-global`
+
+      // use case of https://github.com/emotion-js/emotion/issues/2675
+      let sheet = new cache.sheet.constructor({
+        key,
+        nonce: cache.sheet.nonce,
+        container: cache.sheet.container,
+        speedy: cache.sheet.isSpeedy
+      })
+      let rehydrating = false
+      // $FlowFixMe
+      let node: HTMLStyleElement | null = document.querySelector(
+        `style[data-emotion="${key} ${serialized.name}"]`
+      )
+      if (cache.sheet.tags.length) {
+        sheet.before = cache.sheet.tags[0]
+      }
+      if (node !== null) {
+        rehydrating = true
+        // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
+        node.setAttribute('data-emotion', key)
+        sheet.hydrate([node])
+      }
+      sheetRef.current = [sheet, rehydrating]
+      return () => {
+        sheet.flush()
+      }
+    }, [cache])
+
+    useInsertionEffectWithLayoutFallback(() => {
+      let sheetRefCurrent = (sheetRef.current: any)
+      let [sheet, rehydrating] = sheetRefCurrent
+      if (rehydrating) {
+        sheetRefCurrent[1] = false
+        return
+      }
+      if (serialized.next !== undefined) {
+        // insert keyframes
+        insertStyles(cache, serialized.next, true)
+      }
+
+      if (sheet.tags.length) {
+        // if this doesn't exist then it will be null so the style element will be appended
+        let element = sheet.tags[sheet.tags.length - 1].nextElementSibling
+        sheet.before = ((element: any): Element | null)
+        sheet.flush()
+      }
+      cache.insert(``, serialized, sheet, false)
+    }, [cache, serialized.name])
+
+    return null
+  })
+
+if (process.env.NODE_ENV !== 'production') {
+  Global.displayName = 'EmotionGlobal'
+}

mc_test/node_modules/@emotion/react/src/index.d.ts

@@ -0,0 +1 @@
+export * from '../types/index'

mc_test/node_modules/@emotion/react/src/index.js

@@ -0,0 +1,42 @@
+// @flow
+import pkg from '../package.json'
+export type { SerializedStyles } from '@emotion/utils'
+export {
+  withEmotionCache,
+  CacheProvider,
+  __unsafe_useEmotionCache
+} from './context'
+export { jsx } from './jsx'
+export { jsx as createElement } from './jsx'
+export { Global } from './global'
+export { keyframes } from './keyframes'
+export { ClassNames } from './class-names'
+export { ThemeContext, useTheme, ThemeProvider, withTheme } from './theming'
+export { default as css } from './css'
+
+if (process.env.NODE_ENV !== 'production') {
+  const isBrowser = typeof document !== 'undefined'
+  // #1727, #2905 for some reason Jest and Vitest evaluate modules twice if some consuming module gets mocked
+  const isTestEnv = typeof jest !== 'undefined' || typeof vi !== 'undefined'
+
+  if (isBrowser && !isTestEnv) {
+    // globalThis has wide browser support - https://caniuse.com/?search=globalThis, Node.js 12 and later
+    const globalContext =
+      // $FlowIgnore
+      typeof globalThis !== 'undefined'
+        ? globalThis // eslint-disable-line no-undef
+        : isBrowser
+        ? window
+        : global
+    const globalKey = `__EMOTION_REACT_${pkg.version.split('.')[0]}__`
+    if (globalContext[globalKey]) {
+      console.warn(
+        'You are loading @emotion/react when it is already loaded. Running ' +
+          'multiple instances may cause problems. This can happen if multiple ' +
+          'versions are used, or if multiple builds of the same version are ' +
+          'used.'
+      )
+    }
+    globalContext[globalKey] = true
+  }
+}

mc_test/node_modules/@emotion/react/src/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export * from '../types/jsx-dev-runtime'

mc_test/node_modules/@emotion/react/src/jsx-dev-runtime.js

@@ -0,0 +1,35 @@
+// @flow
+import * as ReactJSXRuntimeDev from 'react/jsx-dev-runtime'
+import Emotion, { createEmotionProps } from './emotion-element'
+import { hasOwnProperty } from './utils'
+
+export const Fragment = ReactJSXRuntimeDev.Fragment
+
+export function jsxDEV(
+  type: any,
+  props: any,
+  key: any,
+  isStaticChildren: any,
+  source: any,
+  self: any
+) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntimeDev.jsxDEV(
+      type,
+      props,
+      key,
+      isStaticChildren,
+      source,
+      self
+    )
+  }
+
+  return ReactJSXRuntimeDev.jsxDEV(
+    Emotion,
+    createEmotionProps(type, props),
+    key,
+    isStaticChildren,
+    source,
+    self
+  )
+}

mc_test/node_modules/@emotion/react/src/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export * from '../types/jsx-runtime'

mc_test/node_modules/@emotion/react/src/jsx-runtime.js

@@ -0,0 +1,22 @@
+// @flow
+import * as ReactJSXRuntime from 'react/jsx-runtime'
+import Emotion, { createEmotionProps } from './emotion-element'
+import { hasOwnProperty } from './utils'
+
+export const Fragment = ReactJSXRuntime.Fragment
+
+export function jsx(type: any, props: any, key: any) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime.jsx(type, props, key)
+  }
+
+  return ReactJSXRuntime.jsx(Emotion, createEmotionProps(type, props), key)
+}
+
+export function jsxs(type: any, props: any, key: any) {
+  if (!hasOwnProperty.call(props, 'css')) {
+    return ReactJSXRuntime.jsxs(type, props, key)
+  }
+
+  return ReactJSXRuntime.jsxs(Emotion, createEmotionProps(type, props), key)
+}

mc_test/node_modules/@emotion/react/src/jsx.js

@@ -0,0 +1,29 @@
+// @flow
+import * as React from 'react'
+import Emotion, { createEmotionProps } from './emotion-element'
+import { hasOwnProperty } from './utils'
+
+// $FlowFixMe
+export const jsx: typeof React.createElement = function (
+  type: React.ElementType,
+  props: Object
+) {
+  let args = arguments
+
+  if (props == null || !hasOwnProperty.call(props, 'css')) {
+    // $FlowFixMe
+    return React.createElement.apply(undefined, args)
+  }
+
+  let argsLength = args.length
+  let createElementArgArray = new Array(argsLength)
+  createElementArgArray[0] = Emotion
+  createElementArgArray[1] = createEmotionProps(type, props)
+
+  for (let i = 2; i < argsLength; i++) {
+    createElementArgArray[i] = args[i]
+  }
+
+  // $FlowFixMe
+  return React.createElement.apply(null, createElementArgArray)
+}

mc_test/node_modules/@emotion/react/src/keyframes.js

@@ -0,0 +1,23 @@
+// @flow
+import css from './css'
+
+type Keyframes = {|
+  name: string,
+  styles: string,
+  anim: 1,
+  toString: () => string
+|} & string
+
+export const keyframes = (...args: *): Keyframes => {
+  let insertable = css(...args)
+  const name = `animation-${insertable.name}`
+  // $FlowFixMe
+  return {
+    name,
+    styles: `@keyframes ${name}{${insertable.styles}}`,
+    anim: 1,
+    toString() {
+      return `_EMO_${this.name}_${this.styles}_EMO_`
+    }
+  }
+}

mc_test/node_modules/@emotion/react/src/theming.js

@@ -0,0 +1,79 @@
+// @flow
+import * as React from 'react'
+import weakMemoize from '@emotion/weak-memoize'
+import hoistNonReactStatics from './_isolated-hnrs'
+
+export const ThemeContext = /* #__PURE__ */ React.createContext<Object>({})
+if (process.env.NODE_ENV !== 'production') {
+  ThemeContext.displayName = 'EmotionThemeContext'
+}
+
+export const useTheme = () => React.useContext(ThemeContext)
+
+const getTheme = (outerTheme: Object, theme: Object | (Object => Object)) => {
+  if (typeof theme === 'function') {
+    const mergedTheme = theme(outerTheme)
+    if (
+      process.env.NODE_ENV !== 'production' &&
+      (mergedTheme == null ||
+        typeof mergedTheme !== 'object' ||
+        Array.isArray(mergedTheme))
+    ) {
+      throw new Error(
+        '[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!'
+      )
+    }
+    return mergedTheme
+  }
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    (theme == null || typeof theme !== 'object' || Array.isArray(theme))
+  ) {
+    throw new Error(
+      '[ThemeProvider] Please make your theme prop a plain object'
+    )
+  }
+
+  return { ...outerTheme, ...theme }
+}
+
+let createCacheWithTheme = /* #__PURE__ */ weakMemoize(outerTheme => {
+  return weakMemoize(theme => {
+    return getTheme(outerTheme, theme)
+  })
+})
+
+type ThemeProviderProps = {
+  theme: Object | (Object => Object),
+  children: React.Node
+}
+
+export const ThemeProvider = (props: ThemeProviderProps) => {
+  let theme = React.useContext(ThemeContext)
+
+  if (props.theme !== theme) {
+    theme = createCacheWithTheme(theme)(props.theme)
+  }
+  return (
+    <ThemeContext.Provider value={theme}>
+      {props.children}
+    </ThemeContext.Provider>
+  )
+}
+
+export function withTheme<Config: {}>(
+  Component: React.AbstractComponent<Config>
+): React.AbstractComponent<$Diff<Config, { theme: Object }>> {
+  const componentName = Component.displayName || Component.name || 'Component'
+  let render = (props, ref) => {
+    let theme = React.useContext(ThemeContext)
+
+    return <Component theme={theme} ref={ref} {...props} />
+  }
+  // $FlowFixMe
+  let WithTheme = React.forwardRef(render)
+
+  WithTheme.displayName = `WithTheme(${componentName})`
+
+  return hoistNonReactStatics(WithTheme, Component)
+}

mc_test/node_modules/@emotion/react/src/utils.js

@@ -0,0 +1,4 @@
+// @flow
+export let isBrowser = typeof document !== 'undefined'
+
+export const hasOwnProperty = {}.hasOwnProperty