1. import React, {useState} from 'react';
    3. function FunctionComponent(props) {
    4.   const [text, setText] = useState('Hello')
    5.   const {message} = props
    6.   return <div>{text} {message}</div>
    7. }
    1. "use strict";
    3. function _typeof(obj) {
    4.   "@babel/helpers - typeof";
    5.   if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    6.     _typeof = function _typeof(obj) {
    7.       return typeof obj;
    8.     };
    9.   } else {
    10.     _typeof = function _typeof(obj) {
    11.       return obj &&
    12.         typeof Symbol === "function" &&
    13.         obj.constructor === Symbol &&
    14.         obj !== Symbol.prototype
    15.         ? "symbol"
    16.         : typeof obj;
    17.     };
    18.   }
    19.   return _typeof(obj);
    20. }
    22. require("core-js/modules/es.symbol.js");
    24. require("core-js/modules/es.symbol.description.js");
    26. require("core-js/modules/es.object.to-string.js");
    28. require("core-js/modules/es.symbol.iterator.js");
    30. require("core-js/modules/es.string.iterator.js");
    32. require("core-js/modules/es.array.iterator.js");
    34. require("core-js/modules/web.dom-collections.iterator.js");
    36. require("core-js/modules/es.array.slice.js");
    38. require("core-js/modules/es.function.name.js");
    40. require("core-js/modules/es.array.from.js");
    42. require("core-js/modules/es.weak-map.js");
    44. require("core-js/modules/es.object.define-property.js");
    46. require("core-js/modules/es.object.get-own-property-descriptor.js");
    48. require("core-js/modules/es.array.is-array.js");
    50. var _react = _interopRequireWildcard(require("react"));
    52. function _getRequireWildcardCache() {
    53.   if (typeof WeakMap !== "function") return null;
    54.   var cache = new WeakMap();
    55.   _getRequireWildcardCache = function _getRequireWildcardCache() {
    56.     return cache;
    57.   };
    58.   return cache;
    59. }
    61. function _interopRequireWildcard(obj) {
    62.   if (obj && obj.__esModule) {
    63.     return obj;
    64.   }
    65.   if (
    66.     obj === null ||
    67.     (_typeof(obj) !== "object" && typeof obj !== "function")
    68.   ) {
    69.     return { default: obj };
    70.   }
    71.   var cache = _getRequireWildcardCache();
    72.   if (cache && cache.has(obj)) {
    73.     return cache.get(obj);
    74.   }
    75.   var newObj = {};
    76.   var hasPropertyDescriptor =
    77.     Object.defineProperty && Object.getOwnPropertyDescriptor;
    78.   for (var key in obj) {
    79.     if (Object.prototype.hasOwnProperty.call(obj, key)) {
    80.       var desc = hasPropertyDescriptor
    81.         ? Object.getOwnPropertyDescriptor(obj, key)
    82.         : null;
    83.       if (desc && (desc.get || desc.set)) {
    84.         Object.defineProperty(newObj, key, desc);
    85.       } else {
    86.         newObj[key] = obj[key];
    87.       }
    88.     }
    89.   }
    90.   newObj["default"] = obj;
    91.   if (cache) {
    92.     cache.set(obj, newObj);
    93.   }
    94.   return newObj;
    95. }
    97. function _slicedToArray(arr, i) {
    98.   return (
    99.     _arrayWithHoles(arr) ||
    100.     _iterableToArrayLimit(arr, i) ||
    101.     _unsupportedIterableToArray(arr, i) ||
    102.     _nonIterableRest()
    103.   );
    104. }
    106. function _nonIterableRest() {
    107.   throw new TypeError(
    108.     "Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
    109.   );
    110. }
    112. function _unsupportedIterableToArray(o, minLen) {
    113.   if (!o) return;
    114.   if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    115.   var n = Object.prototype.toString.call(o).slice(8, -1);
    116.   if (n === "Object" && o.constructor) n = o.constructor.name;
    117.   if (n === "Map" || n === "Set") return Array.from(o);
    118.   if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
    119.     return _arrayLikeToArray(o, minLen);
    120. }
    122. function _arrayLikeToArray(arr, len) {
    123.   if (len == null || len > arr.length) len = arr.length;
    124.   for (var i = 0, arr2 = new Array(len); i < len; i++) {
    125.     arr2[i] = arr[i];
    126.   }
    127.   return arr2;
    128. }
    130. function _iterableToArrayLimit(arr, i) {
    131.   if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr)))
    132.     return;
    133.   var _arr = [];
    134.   var _n = true;
    135.   var _d = false;
    136.   var _e = undefined;
    137.   try {
    138.     for (
    139.       var _i = arr[Symbol.iterator](), _s;
    140.       !(_n = (_s = _i.next()).done);
    141.       _n = true
    142.     ) {
    143.       _arr.push(_s.value);
    144.       if (i && _arr.length === i) break;
    145.     }
    146.   } catch (err) {
    147.     _d = true;
    148.     _e = err;
    149.   } finally {
    150.     try {
    151.       if (!_n && _i["return"] != null) _i["return"]();
    152.     } finally {
    153.       if (_d) throw _e;
    154.     }
    155.   }
    156.   return _arr;
    157. }
    159. function _arrayWithHoles(arr) {
    160.   if (Array.isArray(arr)) return arr;
    161. }
    163. function FunctionComponent(props) {
    164.   var _useState = (0, _react.useState)("Hello"),
    165.     _useState2 = _slicedToArray(_useState, 2),
    166.     text = _useState2[0],
    167.     setText = _useState2[1];
    169.   var message = props.message;
    170.   return /*#__PURE__*/ _react["default"].createElement(
    171.     "div",
    172.     null,
    173.     text,
    174.     " ",
    175.     message
    176.   );
    177. }
    1. import React, {Component} from 'react';
    3. class ClassComponent extends Component {
    4.   state = {
    5.     text: 'Hello'
    6.   }
    8.   render() {
    9.     const {message} = this.props
    10.     const {text} = this.state
    11.     return <div>{text} {message}</div>
    12.   }
    13. }
    1. "use strict";
    3. function _typeof(obj) {
    4.   "@babel/helpers - typeof";
    5.   if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    6.     _typeof = function _typeof(obj) {
    7.       return typeof obj;
    8.     };
    9.   } else {
    10.     _typeof = function _typeof(obj) {
    11.       return obj &&
    12.         typeof Symbol === "function" &&
    13.         obj.constructor === Symbol &&
    14.         obj !== Symbol.prototype
    15.         ? "symbol"
    16.         : typeof obj;
    17.     };
    18.   }
    19.   return _typeof(obj);
    20. }
    22. require("core-js/modules/es.object.set-prototype-of.js");
    24. require("core-js/modules/es.object.get-prototype-of.js");
    26. require("core-js/modules/es.reflect.construct.js");
    28. require("core-js/modules/es.object.create.js");
    30. require("core-js/modules/es.weak-map.js");
    32. require("core-js/modules/es.object.to-string.js");
    34. require("core-js/modules/es.string.iterator.js");
    36. require("core-js/modules/es.array.iterator.js");
    38. require("core-js/modules/web.dom-collections.iterator.js");
    40. require("core-js/modules/es.object.get-own-property-descriptor.js");
    42. require("core-js/modules/es.symbol.js");
    44. require("core-js/modules/es.symbol.description.js");
    46. require("core-js/modules/es.symbol.iterator.js");
    48. require("core-js/modules/es.array.concat.js");
    50. require("core-js/modules/es.object.define-property.js");
    52. var _react = _interopRequireWildcard(require("react"));
    54. function _getRequireWildcardCache() {
    55.   if (typeof WeakMap !== "function") return null;
    56.   var cache = new WeakMap();
    57.   _getRequireWildcardCache = function _getRequireWildcardCache() {
    58.     return cache;
    59.   };
    60.   return cache;
    61. }
    63. function _interopRequireWildcard(obj) {
    64.   if (obj && obj.__esModule) {
    65.     return obj;
    66.   }
    67.   if (
    68.     obj === null ||
    69.     (_typeof(obj) !== "object" && typeof obj !== "function")
    70.   ) {
    71.     return { default: obj };
    72.   }
    73.   var cache = _getRequireWildcardCache();
    74.   if (cache && cache.has(obj)) {
    75.     return cache.get(obj);
    76.   }
    77.   var newObj = {};
    78.   var hasPropertyDescriptor =
    79.     Object.defineProperty && Object.getOwnPropertyDescriptor;
    80.   for (var key in obj) {
    81.     if (Object.prototype.hasOwnProperty.call(obj, key)) {
    82.       var desc = hasPropertyDescriptor
    83.         ? Object.getOwnPropertyDescriptor(obj, key)
    84.         : null;
    85.       if (desc && (desc.get || desc.set)) {
    86.         Object.defineProperty(newObj, key, desc);
    87.       } else {
    88.         newObj[key] = obj[key];
    89.       }
    90.     }
    91.   }
    92.   newObj["default"] = obj;
    93.   if (cache) {
    94.     cache.set(obj, newObj);
    95.   }
    96.   return newObj;
    97. }
    99. function _classCallCheck(instance, Constructor) {
    100.   if (!(instance instanceof Constructor)) {
    101.     throw new TypeError("Cannot call a class as a function");
    102.   }
    103. }
    105. function _defineProperties(target, props) {
    106.   for (var i = 0; i < props.length; i++) {
    107.     var descriptor = props[i];
    108.     descriptor.enumerable = descriptor.enumerable || false;
    109.     descriptor.configurable = true;
    110.     if ("value" in descriptor) descriptor.writable = true;
    111.     Object.defineProperty(target, descriptor.key, descriptor);
    112.   }
    113. }
    115. function _createClass(Constructor, protoProps, staticProps) {
    116.   if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    117.   if (staticProps) _defineProperties(Constructor, staticProps);
    118.   return Constructor;
    119. }
    121. function _inherits(subClass, superClass) {
    122.   if (typeof superClass !== "function" && superClass !== null) {
    123.     throw new TypeError("Super expression must either be null or a function");
    124.   }
    125.   subClass.prototype = Object.create(superClass && superClass.prototype, {
    126.     constructor: { value: subClass, writable: true, configurable: true }
    127.   });
    128.   if (superClass) _setPrototypeOf(subClass, superClass);
    129. }
    131. function _setPrototypeOf(o, p) {
    132.   _setPrototypeOf =
    133.     Object.setPrototypeOf ||
    134.     function _setPrototypeOf(o, p) {
    135.       o.__proto__ = p;
    136.       return o;
    137.     };
    138.   return _setPrototypeOf(o, p);
    139. }
    141. function _createSuper(Derived) {
    142.   var hasNativeReflectConstruct = _isNativeReflectConstruct();
    143.   return function _createSuperInternal() {
    144.     var Super = _getPrototypeOf(Derived),
    145.       result;
    146.     if (hasNativeReflectConstruct) {
    147.       var NewTarget = _getPrototypeOf(this).constructor;
    148.       result = Reflect.construct(Super, arguments, NewTarget);
    149.     } else {
    150.       result = Super.apply(this, arguments);
    151.     }
    152.     return _possibleConstructorReturn(this, result);
    153.   };
    154. }
    156. function _possibleConstructorReturn(self, call) {
    157.   if (call && (_typeof(call) === "object" || typeof call === "function")) {
    158.     return call;
    159.   }
    160.   return _assertThisInitialized(self);
    161. }
    163. function _assertThisInitialized(self) {
    164.   if (self === void 0) {
    165.     throw new ReferenceError(
    166.       "this hasn't been initialised - super() hasn't been called"
    167.     );
    168.   }
    169.   return self;
    170. }
    172. function _isNativeReflectConstruct() {
    173.   if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    174.   if (Reflect.construct.sham) return false;
    175.   if (typeof Proxy === "function") return true;
    176.   try {
    177.     Boolean.prototype.valueOf.call(
    178.       Reflect.construct(Boolean, [], function () {})
    179.     );
    180.     return true;
    181.   } catch (e) {
    182.     return false;
    183.   }
    184. }
    186. function _getPrototypeOf(o) {
    187.   _getPrototypeOf = Object.setPrototypeOf
    188.     ? Object.getPrototypeOf
    189.     : function _getPrototypeOf(o) {
    190.         return o.__proto__ || Object.getPrototypeOf(o);
    191.       };
    192.   return _getPrototypeOf(o);
    193. }
    195. function _defineProperty(obj, key, value) {
    196.   if (key in obj) {
    197.     Object.defineProperty(obj, key, {
    198.       value: value,
    199.       enumerable: true,
    200.       configurable: true,
    201.       writable: true
    202.     });
    203.   } else {
    204.     obj[key] = value;
    205.   }
    206.   return obj;
    207. }
    209. var ClassComponent = /*#__PURE__*/ (function (_Component) {
    210.   _inherits(ClassComponent, _Component);
    212.   var _super = _createSuper(ClassComponent);
    214.   function ClassComponent() {
    215.     var _this;
    217.     _classCallCheck(this, ClassComponent);
    219.     for (
    220.       var _len = arguments.length, args = new Array(_len), _key = 0;
    221.       _key < _len;
    222.       _key++
    223.     ) {
    224.       args[_key] = arguments[_key];
    225.     }
    227.     _this = _super.call.apply(_super, [this].concat(args));
    229.     _defineProperty(_assertThisInitialized(_this), "state", {
    230.       text: "Hello"
    231.     });
    233.     return _this;
    234.   }
    236.   _createClass(ClassComponent, [
    237.     {
    238.       key: "render",
    239.       value: function render() {
    240.         var message = this.props.message;
    241.         var text = this.state.text;
    242.         return /*#__PURE__*/ _react["default"].createElement(
    243.           "div",
    244.           null,
    245.           text,
    246.           " ",
    247.           message
    248.         );
    249.       }
    250.     }
    251.   ]);
    253.   return ClassComponent;
    254. })(_react.Component);