Security upgrades

node_modules/@material-ui/core/test-utils/RenderMode.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RenderContext = RenderContext;
+exports.useIsSsr = useIsSsr;
+
+var React = _interopRequireWildcard(require("react"));
+
+var PropTypes = _interopRequireWildcard(require("prop-types"));
+
+var Context = /*#__PURE__*/React.createContext();
+
+if (process.env.NODE_ENV !== 'production') {
+  Context.displayName = 'RenderContext';
+}
+/**
+ * @ignore - internal component.
+ */
+
+
+function RenderContext(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/React.createElement(Context.Provider, {
+    value: "render"
+  }, children);
+}
+
+process.env.NODE_ENV !== "production" ? RenderContext.propTypes = {
+  children: PropTypes.node.isRequired
+} : void 0;
+
+function useIsSsr() {
+  return React.useContext(Context) === 'render';
+}

node_modules/@material-ui/core/test-utils/createMount.d.ts

@@ -0,0 +1,13 @@
+import { mount } from 'enzyme';
+
+export interface MountOptions {
+  mount: typeof mount;
+  strict: boolean;
+}
+
+export default function createMount(
+  options?: Partial<MountOptions>
+): typeof mount & {
+  attachTo: HTMLElement;
+  cleanUp(): void;
+};

node_modules/@material-ui/core/test-utils/createMount.js

@@ -0,0 +1,123 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createMount;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var ReactDOM = _interopRequireWildcard(require("react-dom"));
+
+var PropTypes = _interopRequireWildcard(require("prop-types"));
+
+var _enzyme = require("enzyme");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+/**
+ * Can't just mount <React.Fragment>{node}</React.Fragment>
+ * because that swallows wrapper.setProps
+ *
+ * why class component:
+ * https://github.com/airbnb/enzyme/issues/2043
+ */
+// eslint-disable-next-line react/prefer-stateless-function
+var Mode = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2.default)(Mode, _React$Component);
+
+  var _super = _createSuper(Mode);
+
+  function Mode() {
+    (0, _classCallCheck2.default)(this, Mode);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(Mode, [{
+    key: "render",
+    value: function render() {
+      // Excess props will come from e.g. enzyme setProps
+      var _this$props = this.props,
+          __element = _this$props.__element,
+          __strict = _this$props.__strict,
+          other = (0, _objectWithoutProperties2.default)(_this$props, ["__element", "__strict"]);
+      var Component = __strict ? React.StrictMode : React.Fragment;
+      return /*#__PURE__*/React.createElement(Component, null, /*#__PURE__*/React.cloneElement(__element, other));
+    }
+  }]);
+  return Mode;
+}(React.Component); // Generate an enhanced mount function.
+
+
+process.env.NODE_ENV !== "production" ? Mode.propTypes = {
+  /**
+   * this is essentially children. However we can't use children because then
+   * using `wrapper.setProps({ children })` would work differently if this component
+   * would be the root.
+   */
+  __element: PropTypes.element.isRequired,
+  __strict: PropTypes.bool.isRequired
+} : void 0;
+
+function createMount() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$mount = options.mount,
+      mount = _options$mount === void 0 ? _enzyme.mount : _options$mount,
+      globalStrict = options.strict,
+      globalEnzymeOptions = (0, _objectWithoutProperties2.default)(options, ["mount", "strict"]);
+  var attachTo = document.createElement('div');
+  attachTo.className = 'app';
+  attachTo.setAttribute('id', 'app');
+  document.body.insertBefore(attachTo, document.body.firstChild);
+
+  var mountWithContext = function mountWithContext(node) {
+    var localOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _localOptions$disable = localOptions.disableUnnmount,
+        disableUnnmount = _localOptions$disable === void 0 ? false : _localOptions$disable,
+        _localOptions$strict = localOptions.strict,
+        strict = _localOptions$strict === void 0 ? globalStrict : _localOptions$strict,
+        localEnzymeOptions = (0, _objectWithoutProperties2.default)(localOptions, ["disableUnnmount", "strict"]);
+
+    if (!disableUnnmount) {
+      ReactDOM.unmountComponentAtNode(attachTo);
+    } // some tests require that no other components are in the tree
+    // e.g. when doing .instance(), .state() etc.
+
+
+    return mount(strict == null ? node : /*#__PURE__*/React.createElement(Mode, {
+      __element: node,
+      __strict: Boolean(strict)
+    }), (0, _extends2.default)({
+      attachTo: attachTo
+    }, globalEnzymeOptions, localEnzymeOptions));
+  };
+
+  mountWithContext.attachTo = attachTo;
+
+  mountWithContext.cleanUp = function () {
+    ReactDOM.unmountComponentAtNode(attachTo);
+    attachTo.parentElement.removeChild(attachTo);
+  };
+
+  return mountWithContext;
+}

node_modules/@material-ui/core/test-utils/createRender.d.ts

@@ -0,0 +1,7 @@
+import { render } from 'enzyme';
+
+export interface RenderOptions {
+  render: typeof render;
+}
+
+export default function createRender(options?: Partial<RenderOptions>): typeof render;

node_modules/@material-ui/core/test-utils/createRender.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createRender;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _enzyme = require("enzyme");
+
+var React = _interopRequireWildcard(require("react"));
+
+var _RenderMode = require("./RenderMode");
+
+/**
+ * Generate a render to string function.
+ * @deprecated to remvoe in v5
+ */
+function createRender() {
+  var options1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options1$render = options1.render,
+      render = _options1$render === void 0 ? _enzyme.render : _options1$render,
+      other1 = (0, _objectWithoutProperties2.default)(options1, ["render"]);
+
+  var renderWithContext = function renderWithContext(node) {
+    var options2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return render( /*#__PURE__*/React.createElement(_RenderMode.RenderContext, null, node), (0, _extends2.default)({}, other1, options2));
+  };
+
+  return renderWithContext;
+}

node_modules/@material-ui/core/test-utils/createShallow.d.ts

@@ -0,0 +1,9 @@
+import { shallow, EnzymeSelector, ShallowRendererProps } from 'enzyme';
+
+export interface ShallowOptions extends ShallowRendererProps {
+  shallow: typeof shallow;
+  dive: boolean;
+  untilSelector: EnzymeSelector;
+}
+
+export default function createShallow(options?: Partial<ShallowOptions>): typeof shallow;

node_modules/@material-ui/core/test-utils/createShallow.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createShallow;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _enzyme = require("enzyme");
+
+var _until = _interopRequireDefault(require("./until"));
+
+// Generate an enhanced shallow function.
+function createShallow() {
+  var options1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options1$shallow = options1.shallow,
+      shallow = _options1$shallow === void 0 ? _enzyme.shallow : _options1$shallow,
+      _options1$dive = options1.dive,
+      dive = _options1$dive === void 0 ? false : _options1$dive,
+      _options1$untilSelect = options1.untilSelector,
+      untilSelector = _options1$untilSelect === void 0 ? false : _options1$untilSelect,
+      other1 = (0, _objectWithoutProperties2.default)(options1, ["shallow", "dive", "untilSelector"]);
+
+  var shallowWithContext = function shallowWithContext(node) {
+    var options2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var options = (0, _extends2.default)({}, other1, options2, {
+      context: (0, _extends2.default)({}, other1.context, options2.context)
+    });
+    var wrapper = shallow(node, options);
+
+    if (dive) {
+      return wrapper.dive();
+    }
+
+    if (untilSelector) {
+      return _until.default.call(wrapper, untilSelector, options);
+    }
+
+    return wrapper;
+  };
+
+  return shallowWithContext;
+}

node_modules/@material-ui/core/test-utils/describeConformance.js

@@ -0,0 +1,255 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = describeConformance;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _chai = require("chai");
+
+var React = _interopRequireWildcard(require("react"));
+
+var _findOutermostIntrinsic = _interopRequireDefault(require("./findOutermostIntrinsic"));
+
+var _reactTestRenderer = _interopRequireDefault(require("react-test-renderer"));
+
+var _testRef = _interopRequireDefault(require("./testRef"));
+
+/**
+ * Glossary
+ * - root component:
+ *   - renders the outermost host component
+ *   - has the `root` class if the component has one
+ *   - excess props are spread to this component
+ *   - has the type of `inheritComponent`
+ */
+
+/**
+ * Returns the component with the same constructor as `component` that renders
+ * the outermost host
+ *
+ * @param {import('enzyme').ReactWrapper} wrapper
+ * @param {object} options
+ * @param {import('react').ElementType} component
+ */
+function findRootComponent(wrapper, _ref) {
+  var component = _ref.component;
+  var outermostHostElement = (0, _findOutermostIntrinsic.default)(wrapper).getElement();
+  return wrapper.find(component).filterWhere(function (componentWrapper) {
+    return componentWrapper.contains(outermostHostElement);
+  });
+}
+
+function randomStringValue() {
+  return Math.random().toString(36).slice(2);
+}
+/**
+ * Material-UI components have a `className` prop. The `className` is applied to
+ * the root component.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function testClassName(element, getOptions) {
+  it('applies the className to the root component', function () {
+    var _getOptions = getOptions(),
+        mount = _getOptions.mount;
+
+    var className = randomStringValue();
+    var wrapper = mount( /*#__PURE__*/React.cloneElement(element, {
+      className: className
+    }));
+    (0, _chai.expect)((0, _findOutermostIntrinsic.default)(wrapper).hasClass(className)).to.equal(true, 'does have a custom `className`');
+  });
+}
+/**
+ * Material-UI components have a `component` prop that allows rendering a different
+ * Component from @inheritComponent
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function testComponentProp(element, getOptions) {
+  describe('prop: component', function () {
+    it('can render another root component with the `component` prop', function () {
+      var _getOptions2 = getOptions(),
+          classes = _getOptions2.classes,
+          mount = _getOptions2.mount,
+          _getOptions2$testComp = _getOptions2.testComponentPropWith,
+          component = _getOptions2$testComp === void 0 ? 'em' : _getOptions2$testComp;
+
+      var wrapper = mount( /*#__PURE__*/React.cloneElement(element, {
+        component: component
+      }));
+      (0, _chai.expect)(findRootComponent(wrapper, {
+        classes: classes,
+        component: component
+      }).exists()).to.equal(true);
+    });
+  });
+}
+/**
+ * Material-UI components can spread additional props to a documented component.
+ * It's set via @inheritComponent in the source.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function testPropsSpread(element, getOptions) {
+  it("spreads props to the root component", function () {
+    // type def in ConformanceOptions
+    var _getOptions3 = getOptions(),
+        classes = _getOptions3.classes,
+        inheritComponent = _getOptions3.inheritComponent,
+        mount = _getOptions3.mount;
+
+    var testProp = 'data-test-props-spread';
+    var value = randomStringValue();
+    var wrapper = mount( /*#__PURE__*/React.cloneElement(element, (0, _defineProperty2.default)({}, testProp, value)));
+    var root = findRootComponent(wrapper, {
+      classes: classes,
+      component: inheritComponent
+    });
+    (0, _chai.expect)(root.props()[testProp]).to.equal(value);
+  });
+}
+/**
+ * Tests that the `ref` of a component will return the correct instance
+ *
+ * This is determined by a given constructor i.e. a React.Component or HTMLElement for
+ * components that forward their ref and attach it to a host component.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function describeRef(element, getOptions) {
+  describe('ref', function () {
+    it("attaches the ref", function () {
+      // type def in ConformanceOptions
+      var _getOptions4 = getOptions(),
+          inheritComponent = _getOptions4.inheritComponent,
+          mount = _getOptions4.mount,
+          refInstanceof = _getOptions4.refInstanceof;
+
+      (0, _testRef.default)(element, mount, function (instance, wrapper) {
+        (0, _chai.expect)(instance).to.be.instanceof(refInstanceof);
+
+        if (inheritComponent && instance.nodeType === 1) {
+          var rootHost = (0, _findOutermostIntrinsic.default)(wrapper);
+          (0, _chai.expect)(instance).to.equal(rootHost.instance());
+        }
+      });
+    });
+  });
+}
+/**
+ * Tests that the root component has the root class
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+
+
+function testRootClass(element, getOptions) {
+  it('applies the root class to the root component if it has this class', function () {
+    var _getOptions5 = getOptions(),
+        classes = _getOptions5.classes,
+        mount = _getOptions5.mount;
+
+    if (classes.root == null) {
+      return;
+    }
+
+    var className = randomStringValue();
+    var wrapper = mount( /*#__PURE__*/React.cloneElement(element, {
+      className: className
+    })); // we established that the root component renders the outermost host previously. We immediately
+    // jump to the host component because some components pass the `root` class
+    // to the `classes` prop of the root component.
+    // https://github.com/mui-org/material-ui/blob/f9896bcd129a1209153106296b3d2487547ba205/packages/material-ui/src/OutlinedInput/OutlinedInput.js#L101
+
+    (0, _chai.expect)((0, _findOutermostIntrinsic.default)(wrapper).hasClass(classes.root)).to.equal(true);
+    (0, _chai.expect)((0, _findOutermostIntrinsic.default)(wrapper).hasClass(className)).to.equal(true);
+  });
+}
+/**
+ * Tests that the component can be rendered with react-test-renderer.
+ * This is important for snapshot testing with Jest (even if we don't encourage it).
+ *
+ * @param {React.ReactElement} element
+ */
+
+
+function testReactTestRenderer(element) {
+  it('should render without errors in ReactTestRenderer', function () {
+    _reactTestRenderer.default.act(function () {
+      _reactTestRenderer.default.create(element, {
+        createNodeMock: function createNodeMock(node) {
+          return document.createElement(node.type);
+        }
+      });
+    });
+  });
+}
+
+var fullSuite = {
+  componentProp: testComponentProp,
+  mergeClassName: testClassName,
+  propsSpread: testPropsSpread,
+  refForwarding: describeRef,
+  rootClass: testRootClass,
+  reactTestRenderer: testReactTestRenderer
+};
+/**
+ * @typedef {Object} ConformanceOptions
+ * @property {Record<string, string>} classes - `classes` of the component provided by `@material-ui/styles`
+ * @property {string} inheritComponent - The element type that receives spread props.
+ * @property {function} mount - Should be a return value from createMount
+ * @property {(keyof typeof fullSuite)[]} [only] - If specified only run the tests listed
+ * @property {any} refInstanceof - `ref` will be an instanceof this constructor.
+ * @property {keyof typeof fullSuite[]} [skip] - Skip the specified tests
+ * @property {string} [testComponentPropWith] - The host component that should be rendered instead.
+ */
+
+/**
+ * Tests various aspects of a component that should be equal across Material-UI
+ * components.
+ *
+ * @param {React.ReactElement} minimalElement - the component with it's minimal required props
+ * @param {() => ConformanceOptions} getOptions
+ *
+ */
+
+function describeConformance(minimalElement, getOptions) {
+  var _getOptions6 = getOptions(),
+      _getOptions6$after = _getOptions6.after,
+      runAfterHook = _getOptions6$after === void 0 ? function () {} : _getOptions6$after,
+      _getOptions6$only = _getOptions6.only,
+      only = _getOptions6$only === void 0 ? Object.keys(fullSuite) : _getOptions6$only,
+      _getOptions6$skip = _getOptions6.skip,
+      skip = _getOptions6$skip === void 0 ? [] : _getOptions6$skip;
+
+  describe('Material-UI component API', function () {
+    after(runAfterHook);
+    Object.keys(fullSuite).filter(function (testKey) {
+      return only.indexOf(testKey) !== -1 && skip.indexOf(testKey) === -1;
+    }).forEach(function (testKey) {
+      var test = fullSuite[testKey];
+      test(minimalElement, getOptions);
+    });
+  });
+}

node_modules/@material-ui/core/test-utils/findOutermostIntrinsic.d.ts

@@ -0,0 +1,8 @@
+import { ReactWrapper } from 'enzyme';
+
+/**
+ * like ReactWrapper#getDOMNode() but returns a ReactWrapper
+ *
+ * @returns the wrapper for the outermost DOM node
+ */
+export default function findOutermostIntrinsic(reactWrapper: ReactWrapper): ReactWrapper;

node_modules/@material-ui/core/test-utils/findOutermostIntrinsic.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapsIntrinsicElement = wrapsIntrinsicElement;
+exports.default = findOutermostIntrinsic;
+
+/**
+ * checks if a given react wrapper wraps an intrinsic element i.e. a DOM node
+ *
+ * @param {import('enzyme').ReactWrapper} reactWrapper
+ * @returns {boolean} true if the given reactWrapper wraps an intrinsic element
+ */
+function wrapsIntrinsicElement(reactWrapper) {
+  return typeof reactWrapper.type() === 'string';
+}
+/**
+ * like ReactWrapper#getDOMNode() but returns a ReactWrapper
+ *
+ * @param {import('enzyme').ReactWrapper} reactWrapper
+ * @returns {import('enzyme').ReactWrapper} the wrapper for the outermost DOM node
+ */
+
+
+function findOutermostIntrinsic(reactWrapper) {
+  return reactWrapper.findWhere(function (n) {
+    return n.exists() && wrapsIntrinsicElement(n);
+  }).first();
+}

node_modules/@material-ui/core/test-utils/getClasses.d.ts

@@ -0,0 +1,4 @@
+export default function getClasses<T = { [name: string]: string }>(
+  element: React.ReactElement,
+  options?: Partial<{ withTheme: boolean }>
+): T;

node_modules/@material-ui/core/test-utils/getClasses.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getClasses;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _createShallow = _interopRequireDefault(require("./createShallow"));
+
+var shallow = (0, _createShallow.default)(); // Helper function to extract the classes from a styleSheet.
+
+function getClasses(element) {
+  var useStyles = element.type.useStyles;
+  var classes;
+
+  function Listener() {
+    classes = useStyles(element.props);
+    return null;
+  }
+
+  shallow( /*#__PURE__*/React.createElement(Listener, null));
+  return classes;
+}

node_modules/@material-ui/core/test-utils/index.d.ts

@@ -0,0 +1,6 @@
+export { default as createShallow } from './createShallow';
+export { default as createMount } from './createMount';
+export { default as createRender } from './createRender';
+export { default as findOutermostIntrinsic } from './findOutermostIntrinsic';
+export { default as getClasses } from './getClasses';
+export { default as unwrap } from './unwrap';

node_modules/@material-ui/core/test-utils/index.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createShallow", {
+  enumerable: true,
+  get: function get() {
+    return _createShallow.default;
+  }
+});
+Object.defineProperty(exports, "createMount", {
+  enumerable: true,
+  get: function get() {
+    return _createMount.default;
+  }
+});
+Object.defineProperty(exports, "createRender", {
+  enumerable: true,
+  get: function get() {
+    return _createRender.default;
+  }
+});
+Object.defineProperty(exports, "findOutermostIntrinsic", {
+  enumerable: true,
+  get: function get() {
+    return _findOutermostIntrinsic.default;
+  }
+});
+Object.defineProperty(exports, "wrapsIntrinsicElement", {
+  enumerable: true,
+  get: function get() {
+    return _findOutermostIntrinsic.wrapsIntrinsicElement;
+  }
+});
+Object.defineProperty(exports, "getClasses", {
+  enumerable: true,
+  get: function get() {
+    return _getClasses.default;
+  }
+});
+Object.defineProperty(exports, "unwrap", {
+  enumerable: true,
+  get: function get() {
+    return _unwrap.default;
+  }
+});
+
+var _createShallow = _interopRequireDefault(require("./createShallow"));
+
+var _createMount = _interopRequireDefault(require("./createMount"));
+
+var _createRender = _interopRequireDefault(require("./createRender"));
+
+var _findOutermostIntrinsic = _interopRequireWildcard(require("./findOutermostIntrinsic"));
+
+var _getClasses = _interopRequireDefault(require("./getClasses"));
+
+var _unwrap = _interopRequireDefault(require("./unwrap"));

node_modules/@material-ui/core/test-utils/package.json

@@ -0,0 +1,5 @@
+{
+  "sideEffects": false,
+  "module": "../esm/test-utils/index.js",
+  "typings": "./index.d.ts"
+}

node_modules/@material-ui/core/test-utils/testRef.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = testRef;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _chai = require("chai");
+
+function assertDOMNode(node) {
+  // duck typing a DOM node
+  (0, _chai.expect)((0, _typeof2.default)(node.nodeName)).to.equal('string');
+}
+/**
+ * Utility method to make assertions about the ref on an element
+ * @param {React.ReactElement} element - The element should have a component wrapped
+ *                                       in withStyles as the root
+ * @param {function} mount - Should be returnvalue of createMount
+ * @param {function} onRef - Callback, first arg is the ref.
+ *                           Assert that the ref is a DOM node by default
+ */
+
+
+function testRef(element, mount) {
+  var onRef = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : assertDOMNode;
+  var ref = /*#__PURE__*/React.createRef();
+  var wrapper = mount( /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.cloneElement(element, {
+    ref: ref
+  })));
+  onRef(ref.current, wrapper);
+}

node_modules/@material-ui/core/test-utils/until.d.ts

@@ -0,0 +1,6 @@
+import { CommonWrapper } from 'enzyme';
+
+export default function until<P = any, S = any>(
+  selector: string,
+  options: { context: any }
+): CommonWrapper<P, S>;

node_modules/@material-ui/core/test-utils/until.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = until;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+function shallowRecursively(wrapper, selector, _ref) {
+  var context = _ref.context,
+      other = (0, _objectWithoutProperties2.default)(_ref, ["context"]);
+
+  if (wrapper.isEmptyRender() || typeof wrapper.getElement().type === 'string') {
+    return wrapper;
+  }
+
+  var newContext = context;
+  var instance = wrapper.root().instance(); // The instance can be null with a stateless functional component and react >= 16.
+
+  if (instance && instance.getChildContext) {
+    newContext = (0, _extends2.default)({}, context, instance.getChildContext());
+  }
+
+  var nextWrapper = wrapper.shallow((0, _extends2.default)({
+    context: newContext
+  }, other));
+
+  if (selector && wrapper.is(selector)) {
+    return nextWrapper;
+  }
+
+  return shallowRecursively(nextWrapper, selector, {
+    context: newContext
+  });
+}
+
+function until(selector) {
+  var _this = this;
+
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return this.single('until', function () {
+    return shallowRecursively(_this, selector, options);
+  });
+}

node_modules/@material-ui/core/test-utils/unwrap.d.ts

@@ -0,0 +1 @@
+export default function unwrap(element: React.ReactElement): React.ReactElement;

node_modules/@material-ui/core/test-utils/unwrap.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = unwrap;
+
+function unwrap(component) {
+  return component.Naked;
+}