https://missdream.org/wp-includes/js/dist/vendor/react-dom.js

332037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
333  /* eslint-enable max-len */
334
335  var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
336  var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');
337  var illegalAttributeNameCache = {};
338  var validatedAttributeNameCache = {};
339  function isAttributeNameSafe(attributeName) {
340    if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
341      return true;
342    }
343
344    if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
345      return false;
346    }
347
348    if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
349      validatedAttributeNameCache[attributeName] = true;
350      return true;
351    }
352
353    illegalAttributeNameCache[attributeName] = true;
354
355    {
356      error('Invalid attribute name: `%s`', attributeName);
357    }
358
359    return false;
360  }
361  function shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) {
362    if (propertyInfo !== null) {
363      return propertyInfo.type === RESERVED;
364    }
365
366    if (isCustomComponentTag) {
367      return false;
368    }
369
370    if (name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
371      return true;
372    }
373
374    return false;
375  }
376  function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) {
377    if (propertyInfo !== null && propertyInfo.type === RESERVED) {
378      return false;
379    }
380
381    switch (typeof value) {
382      case 'function': // $FlowIssue symbol is perfectly valid here
383
384      case 'symbol':
385        // eslint-disable-line
386        return true;
387
388      case 'boolean':
389        {
390          if (isCustomComponentTag) {
391            return false;
392          }
393
394          if (propertyInfo !== null) {
395            return !propertyInfo.acceptsBooleans;
396          } else {
397            var prefix = name.toLowerCase().slice(0, 5);
398            return prefix !== 'data-' && prefix !== 'aria-';
399          }
400        }
401
402      default:
403        return false;
404    }
405  }
406  function shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) {
407    if (value === null || typeof value === 'undefined') {
408      return true;
409    }
410
411    if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag)) {
412      return true;
413    }
414
415    if (isCustomComponentTag) {
416
417      return false;
418    }
419
420    if (propertyInfo !== null) {
421
422      switch (propertyInfo.type) {
423        case BOOLEAN:
424          return !value;
425
426        case OVERLOADED_BOOLEAN:
427          return value === false;
428
429        case NUMERIC:
430          return isNaN(value);
431
432        case POSITIVE_NUMERIC:
433          return isNaN(value) || value < 1;
434      }
435    }
436
437    return false;
438  }
439  function getPropertyInfo(name) {
440    return properties.hasOwnProperty(name) ? properties[name] : null;
441  }
442
443  function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL, removeEmptyString) {
444    this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN;
445    this.attributeName = attributeName;
446    this.attributeNamespace = attributeNamespace;
447    this.mustUseProperty = mustUseProperty;
448    this.propertyName = name;
449    this.type = type;
450    this.sanitizeURL = sanitizeURL;
451    this.removeEmptyString = removeEmptyString;
452  } // When adding attributes to this list, be sure to also add them to
453  // the `possibleStandardNames` module to ensure casing and incorrect
454  // name warnings.
455
456
457  var properties = {}; // These props are reserved by React. They shouldn't be written to the DOM.
458
459  var reservedProps = ['children', 'dangerouslySetInnerHTML', // TODO: This prevents the assignment of defaultValue to regular
460  // elements (not just inputs). Now that ReactDOMInput assigns to the
461  // defaultValue property -- do we need this?
462  'defaultValue', 'defaultChecked', 'innerHTML', 'suppressContentEditableWarning', 'suppressHydrationWarning', 'style'];
463
464  reservedProps.forEach(function (name) {
465    properties[name] = new PropertyInfoRecord(name, RESERVED, false, // mustUseProperty
466    name, // attributeName
467    null, // attributeNamespace
468    false, // sanitizeURL
469    false);
470  }); // A few React string attributes have a different name.
471  // This is a mapping from React prop names to the attribute names.
472
473  [['acceptCharset', 'accept-charset'], ['className', 'class'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv']].forEach(function (_ref) {
474    var name = _ref[0],
475        attributeName = _ref[1];
476    properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty
477    attributeName, // attributeName
478    null, // attributeNamespace
479    false, // sanitizeURL
480    false);
481  }); // These are "enumerated" HTML attributes that accept "true" and "false".
482  // In React, we let users pass `true` and `false` even though technically
483  // these aren't boolean attributes (they are coerced to strings).
484
485  ['contentEditable', 'draggable', 'spellCheck', 'value'].forEach(function (name) {
486    properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, // mustUseProperty
487    name.toLowerCase(), // attributeName
488    null, // attributeNamespace
489    false, // sanitizeURL
490    false);
491  }); // These are "enumerated" SVG attributes that accept "true" and "false".
492  // In React, we let users pass `true` and `false` even though technically
493  // these aren't boolean attributes (they are coerced to strings).
494  // Since these are SVG attributes, their attribute names are case-sensitive.
495
496  ['autoReverse', 'externalResourcesRequired', 'focusable', 'preserveAlpha'].forEach(function (name) {
497    properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, // mustUseProperty
498    name, // attributeName
499    null, // attributeNamespace
500    false, // sanitizeURL
501    false);
502  }); // These are HTML boolean attributes.
503
504  ['allowFullScreen', 'async', // Note: there is a special case that prevents it from being written to the DOM
505  // on the client side because the browsers are inconsistent. Instead we call focus().
506  'autoFocus', 'autoPlay', 'controls', 'default', 'defer', 'disabled', 'disablePictureInPicture', 'disableRemotePlayback', 'formNoValidate', 'hidden', 'loop', 'noModule', 'noValidate', 'open', 'playsInline', 'readOnly', 'required', 'reversed', 'scoped', 'seamless', // Microdata
507  'itemScope'].forEach(function (name) {
508    properties[name] = new PropertyInfoRecord(name, BOOLEAN, false, // mustUseProperty
509    name.toLowerCase(), // attributeName
510    null, // attributeNamespace
511    false, // sanitizeURL
512    false);
513  }); // These are the few React props that we set as DOM properties
514  // rather than attributes. These are all booleans.
515
516  ['checked', // Note: `option.selected` is not updated if `select.multiple` is
517  // disabled with `removeAttribute`. We have special logic for handling this.
518  'multiple', 'muted', 'selected' // NOTE: if you add a camelCased prop to this list,
519  // you'll need to set attributeName to name.toLowerCase()
520  // instead in the assignment below.
521  ].forEach(function (name) {
522    properties[name] = new PropertyInfoRecord(name, BOOLEAN, true, // mustUseProperty
523    name, // attributeName
524    null, // attributeNamespace
525    false, // sanitizeURL
526    false);
527  }); // These are HTML attributes that are "overloaded booleans": they behave like
528  // booleans, but can also accept a string value.
529
530  ['capture', 'download' // NOTE: if you add a camelCased prop to this list,
531  // you'll need to set attributeName to name.toLowerCase()
532  // instead in the assignment below.
533  ].forEach(function (name) {
534    properties[name] = new PropertyInfoRecord(name, OVERLOADED_BOOLEAN, false, // mustUseProperty
535    name, // attributeName
536    null, // attributeNamespace
537    false, // sanitizeURL
538    false);
539  }); // These are HTML attributes that must be positive numbers.
540
541  ['cols', 'rows', 'size', 'span' // NOTE: if you add a camelCased prop to this list,
542  // you'll need to set attributeName to name.toLowerCase()
543  // instead in the assignment below.
544  ].forEach(function (name) {
545    properties[name] = new PropertyInfoRecord(name, POSITIVE_NUMERIC, false, // mustUseProperty
546    name, // attributeName
547    null, // attributeNamespace
548    false, // sanitizeURL
549    false);
550  }); // These are HTML attributes that must be numbers.
551
552  ['rowSpan', 'start'].forEach(function (name) {
553    properties[name] = new PropertyInfoRecord(name, NUMERIC, false, // mustUseProperty
554    name.toLowerCase(), // attributeName
555    null, // attributeNamespace
556    false, // sanitizeURL
557    false);
558  });
559  var CAMELIZE = /[\-\:]([a-z])/g;
560
561  var capitalize = function (token) {
562    return token[1].toUpperCase();
563  }; // This is a list of all SVG attributes that need special casing, namespacing,
564  // or boolean value assignment. Regular attributes that just accept strings
565  // and have the same names are omitted, just like in the HTML attribute filter.
566  // Some of these attributes can be hard to find. This list was created by
567  // scraping the MDN documentation.
568
569
570  ['accent-height', 'alignment-baseline', 'arabic-form', 'baseline-shift', 'cap-height', 'clip-path', 'clip-rule', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'dominant-baseline', 'enable-background', 'fill-opacity', 'fill-rule', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'glyph-name', 'glyph-orientation-horizontal', 'glyph-orientation-vertical', 'horiz-adv-x', 'horiz-origin-x', 'image-rendering', 'letter-spacing', 'lighting-color', 'marker-end', 'marker-mid', 'marker-start', 'overline-position', 'overline-thickness', 'paint-order', 'panose-1', 'pointer-events', 'rendering-intent', 'shape-rendering', 'stop-color', 'stop-opacity', 'strikethrough-position', 'strikethrough-thickness', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'text-anchor', 'text-decoration', 'text-rendering', 'underline-position', 'underline-thickness', 'unicode

712          stringValue = node.getAttribute(attributeName);
713        }
714
715        if (shouldRemoveAttribute(name, expected, propertyInfo, false)) {
716          return stringValue === null ? expected : stringValue; // eslint-disable-next-line react-internal/safe-string-coercion
717        } else if (stringValue === '' + expected) {
718          return expected;
719        } else {
720          return stringValue;
721        }
722      }
723    }
724  }
725  /**
726   * Get the value for a attribute on a node. Only used in DEV for SSR validation.
727   * The third argument is used as a hint of what the expected value is. Some
728   * attributes have multiple equivalent values.
729   */
730
731  function getValueForAttribute(node, name, expected, isCustomComponentTag) {
732    {
733      if (!isAttributeNameSafe(name)) {
734        return;
735      }
736
737      if (!node.hasAttribute(name)) {
738        return expected === undefined ? undefined : null;
739      }
740
741      var value = node.getAttribute(name);
742
743      {
744        checkAttributeStringCoercion(expected, name);
745      }
746
747      if (value === '' + expected) {
748        return expected;
749      }
750
751      return value;
752    }
753  }
754  /**
755   * Sets the value for a property on a node.
756   *
757   * @param {DOMElement} node
758   * @param {string} name
759   * @param {*} value
760   */
761
762  function setValueForProperty(node, name, value, isCustomComponentTag) {
763    var propertyInfo = getPropertyInfo(name);
764
765    if (shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) {
766      return;
767    }
768
769    if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) {
770      value = null;
771    }
772
773
774    if (isCustomComponentTag || propertyInfo === null) {
775      if (isAttributeNameSafe(name)) {
776        var _attributeName = name;
777
778        if (value === null) {
779          node.removeAttribute(_attributeName);
780        } else {
781          {
782            checkAttributeStringCoercion(value, name);
783          }
784
785          node.setAttribute(_attributeName,  '' + value);
786        }
787      }
788
789      return;
790    }
791
792    var mustUseProperty = propertyInfo.mustUseProperty;
793
794    if (mustUseProperty) {
795      var propertyName = propertyInfo.propertyName;
796
797      if (value === null) {
798        var type = propertyInfo.type;
799        node[propertyName] = type === BOOLEAN ? false : '';
800      } else {
801        // Contrary to `setAttribute`, object properties are properly
802        // `toString`ed by IE8/9.
803        node[propertyName] = value;
804      }
805
806      return;
807    } // The rest are treated as attributes with special cases.
808
809
810    var attributeName = propertyInfo.attributeName,
811        attributeNamespace = propertyInfo.attributeNamespace;
812
813    if (value === null) {
814      node.removeAttribute(attributeName);
815    } else {
816      var _type = propertyInfo.type;
817      var attributeValue;
818
819      if (_type === BOOLEAN || _type === OVERLOADED_BOOLEAN && value === true) {
820        // If attribute type is boolean, we know for sure it won't be an execution sink
821        // and we won't require Trusted Type here.
822        attributeValue = '';
823      } else {
824        // `setAttribute` with objects becomes only `[object]` in IE8/9,
825        // ('' + value) makes it output the correct toString()-value.
826        {
827          {
828            checkAttributeStringCoercion(value, attributeName);
829          }
830
831          attributeValue = '' + value;
832        }
833
834        if (propertyInfo.sanitizeURL) {
835          sanitizeURL(attributeValue.toString());
836        }
837      }
838
839      if (attributeNamespace) {
840        node.setAttributeNS(attributeNamespace, attributeName, attributeValue);
841      } else {
842        node.setAttribute(attributeName, attributeValue);
843      }
844    }
845  }
846
847  // ATTENTION
848  // When adding new symbols to this file,
849  // Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
850  // The Symbol used to tag the ReactElement-like types.
851  var REACT_ELEMENT_TYPE = Symbol.for('react.element');
852  var REACT_PORTAL_TYPE = Symbol.for('react.portal');
853  var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
854  var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
855  var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
856  var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
857  var REACT_CONTEXT_TYPE = Symbol.for('react.context');
858  var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
859  var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
860  var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
861  var REACT_MEMO_TYPE = Symbol.for('react.memo');
862  var REACT_LAZY_TYPE = Symbol.for('react.lazy');
863  var REACT_SCOPE_TYPE = Symbol.for('react.scope');
864  var REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');
865  var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
866  var REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
867  var REACT_CACHE_TYPE = Symbol.for('react.cache');
868  var REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');
869  var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
870  var FAUX_ITERATOR_SYMBOL = '@@iterator';
871  function getIteratorFn(maybeIterable) {
872    if (maybeIterable === null || typeof maybeIterable !== 'object') {
873      return null;
874    }
875
876    var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
877
878    if (typeof maybeIterator === 'function') {
879      return maybeIterator;
880    }
881
882    return null;
883  }
884
885  var assign = Object.assign;
886
887  // Helpers to patch console.logs to avoid logging during side-effect free
888  // replaying on render function. This currently only patches the object

1459      // The display name for this tags come from the user-provided type:
1460
1461      case ClassComponent:
1462      case FunctionComponent:
1463      case IncompleteClassComponent:
1464      case IndeterminateComponent:
1465      case MemoComponent:
1466      case SimpleMemoComponent:
1467        if (typeof type === 'function') {
1468          return type.displayName || type.name || null;
1469        }
1470
1471        if (typeof type === 'string') {
1472          return type;
1473        }
1474
1475        break;
1476
1477    }
1478
1479    return null;
1480  }
1481
1482  var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
1483  var current = null;
1484  var isRendering = false;
1485  function getCurrentFiberOwnerNameInDevOrNull() {
1486    {
1487      if (current === null) {
1488        return null;
1489      }
1490
1491      var owner = current._debugOwner;
1492
1493      if (owner !== null && typeof owner !== 'undefined') {
1494        return getComponentNameFromFiber(owner);
1495      }
1496    }
1497
1498    return null;
1499  }
1500
1501  function getCurrentFiberStackInDev() {
1502    {
1503      if (current === null) {
1504        return '';
1505      } // Safe because if current fiber exists, we are reconciling,
1506      // and it is guaranteed to be the work-in-progress version.
1507
1508
1509      return getStackByFiberInDevAndProd(current);
1510    }
1511  }
1512
1513  function resetCurrentFiber() {
1514    {
1515      ReactDebugCurrentFrame.getCurrentStack = null;
1516      current = null;
1517      isRendering = false;
1518    }
1519  }
1520  function setCurrentFiber(fiber) {
1521    {
1522      ReactDebugCurrentFrame.getCurrentStack = fiber === null ? null : getCurrentFiberStackInDev;
1523      current = fiber;
1524      isRendering = false;
1525    }
1526  }
1527  function getCurrentFiber() {
1528    {
1529      return current;
1530    }
1531  }
1532  function setIsRendering(rendering) {
1533    {
1534      isRendering = rendering;
1535    }
1536  }
1537
1538  // Flow does not allow string concatenation of most non-string types. To work
1539  // around this limitation, we use an opaque type that can only be obtained by
1540  // passing the value through getToStringValue first.
1541  function toString(value) {
1542    // The coercion safety check is performed in getToStringValue().
1543    // eslint-disable-next-line react-internal/safe-string-coercion
1544    return '' + value;
1545  }
1546  function getToStringValue(value) {
1547    switch (typeof value) {
1548      case 'boolean':
1549      case 'number':
1550      case 'string':
1551      case 'undefined':
1552        return value;
1553
1554      case 'object':
1555        {
1556          checkFormFieldValueStringCoercion(value);
1557        }
1558
1559        return value;
1560
1561      default:
1562        // function, symbol are assigned as empty strings
1563        return '';
1564    }
1565  }
1566
1567  var hasReadOnlyValue = {
1568    button: true,
1569    checkbox: true,
1570    image: true,
1571    hidden: true,
1572    radio: true,
1573    reset: true,
1574    submit: true
1575  };
1576  function checkControlledValueProps(tagName, props) {
1577    {
1578      if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
1579        error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
1580      }
1581
1582      if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) {
1583        error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
1584      }
1585    }
1586  }
1587
1588  function isCheckable(elem) {
1589    var type = elem.type;
1590    var nodeName = elem.nodeName;
1591    return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');
1592  }
1593
1594  function getTracker(node) {
1595    return node._valueTracker;
1596  }
1597
1598  function detachTracker(node) {
1599    node._valueTracker = null;
1600  }
1601
1602  function getValueFromNode(node) {
1603    var value = '';
1604
1605    if (!node) {
1606      return value;
1607    }
1608
1609    if (isCheckable(node)) {
1610      value = node.checked ? 'true' : 'false';
1611    } else {
1612      value = node.value;
1613    }
1614
1615    return value;
1616  }
1617
1618  function trackValueOnNode(node) {
1619    var valueField = isCheckable(node) ? 'checked' : 'value';
1620    var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
1621
1622    {
1623      checkFormFieldValueStringCoercion(node[valueField]);
1624    }
1625
1626    var currentValue = '' + node[valueField]; // if someone has already defined a value or Safari, then bail
1627    // and don't track value will cause over reporting of changes,
1628    // but it's better then a hard failure
1629    // (needed for certain tests that spyOn input values and Safari)
1630
1631    if (node.hasOwnProperty(valueField) || typeof descriptor === 'undefined' || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
1632      return;
1633    }
1634
1635    var get = descriptor.get,
1636        set = descriptor.set;
1637    Object.defineProperty(node, valueField, {
1638      configurable: true,
1639      get: function () {
1640        return get.call(this);
1641      },
1642      set: function (value) {
1643        {
1644          checkFormFieldValueStringCoercion(value);
1645        }
1646
1647        currentValue = '' + value;
1648        set.call(this, value);
1649      }
1650    }); // We could've passed this the first time
1651    // but it triggers a bug in IE11 and Edge 14/15.
1652    // Calling defineProperty() again should be equivalent.
1653    // https://github.com/facebook/react/issues/11768
1654
1655    Object.defineProperty(node, valueField, {
1656      enumerable: descriptor.enumerable
1657    });
1658    var tracker = {
1659      getValue: function () {
1660        return currentValue;
1661      },
1662      setValue: function (value) {
1663        {
1664          checkFormFieldValueStringCoercion(value);
1665        }
1666
1667        currentValue = '' + value;
1668      },
1669      stopTracking: function () {
1670        detachTracker(node);
1671        delete node[valueField];
1672      }
1673    };
1674    return tracker;
1675  }
1676
1677  function track(node) {
1678    if (getTracker(node)) {
1679      return;
1680    } // TODO: Once it's just Fiber we can move this to node._wrapperState
1681
1682
1683    node._valueTracker = trackValueOnNode(node);
1684  }
1685  function updateValueIfChanged(node) {
1686    if (!node) {
1687      return false;
1688    }
1689
1690    var tracker = getTracker(node); // if there is no tracker at this point it's unlikely
1691    // that trying again will succeed
1692
1693    if (!tracker) {
1694      return true;
1695    }
1696
1697    var lastValue = tracker.getValue();
1698    var nextValue = getValueFromNode(node);
1699
1700    if (nextValue !== lastValue) {
1701      tracker.setValue(nextValue);
1702      return true;
1703    }
1704
1705    return false;
1706  }
1707
1708  function getActiveElement(doc) {
1709    doc = doc || (typeof document !== 'undefined' ? document : undefined);
1710
1711    if (typeof doc === 'undefined') {
1712      return null;
1713    }
1714
1715    try {
1716      return doc.activeElement || doc.body;
1717    } catch (e) {
1718      return doc.body;
1719    }
1720  }
1721
1722  var didWarnValueDefaultValue = false;
1723  var didWarnCheckedDefaultChecked = false;
1724  var didWarnControlledToUncontrolled = false;
1725  var didWarnUncontrolledToControlled = false;
1726
1727  function isControlled(props) {
1728    var usesChecked = props.type === 'checkbox' || props.type === 'radio';
1729    return usesChecked ? props.checked != null : props.value != null;
1730  }
1731  /**
1732   * Implements an <input> host component that allows setting these optional
1733   * props: `checked`, `value`, `defaultChecked`, and `defaultValue`.
1734   *
1735   * If `checked` or `value` are not supplied (or null/undefined), user actions
1736   * that affect the checked state or value will trigger updates to the element.
1737   *
1738   * If they are supplied (and not null/undefined), the rendered element will not
1739   * trigger updates to the element. Instead, the props must change in order for
1740   * the rendered element to be updated.
1741   *
1742   * The rendered element will be initialized as unchecked (or `defaultChecked`)
1743   * with an empty value (or `defaultValue`).
1744   *
1745   * See http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html
1746   */
1747
1748
1749  function getHostProps(element, props) {
1750    var node = element;
1751    var checked = props.checked;
1752    var hostProps = assign({}, props, {
1753      defaultChecked: undefined,
1754      defaultValue: undefined,
1755      value: undefined,
1756      checked: checked != null ? checked : node._wrapperState.initialChecked
1757    });
1758    return hostProps;
1759  }
1760  function initWrapperState(element, props) {
1761    {
1762      checkControlledValueProps('input', props);
1763
1764      if (props.checked !== undefined && props.defaultChecked !== undefined && !didWarnCheckedDefaultChecked) {
1765        error('%s contains an input of type %s with both checked and defaultChecked props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the checked prop, or the defaultChecked prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://reactjs.org/link/controlled-components', getCurrentFiberOwnerNameInDevOrNull() || 'A component', props.type);
1766
1767        didWarnCheckedDefaultChecked = true;
1768      }
1769
1770      if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {
1771        error('%s contains an input of type %s with both value and defaultValue props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://reactjs.org/link/controlled-components', getCurrentFiberOwnerNameInDevOrNull() || 'A component', props.type);
1772
1773        didWarnValueDefaultValue = true;
1774      }
1775    }
1776
1777    var node = element;
1778    var defaultValue = props.defaultValue == null ? '' : props.defaultValue;
1779    node._wrapperState = {
1780      initialChecked: props.checked != null ? props.checked : props.defaultChecked,
1781      initialValue: getToStringValue(props.value != null ? props.value : defaultValue),
1782      controlled: isControlled(props)
1783    };
1784  }
1785  function updateChecked(element, props) {
1786    var node = element;
1787    var checked = props.checked;
1788
1789    if (checked != null) {
1790      setValueForProperty(node, 'checked', checked, false);
1791    }
1792  }
1793  function updateWrapper(element, props) {
1794    var node = element;
1795
1796    {
1797      var controlled = isControlled(props);
1798
1799      if (!node._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) {
1800        error('A component is changing an uncontrolled input to be controlled. ' + 'This is likely caused by the value changing from undefined to ' + 'a defined value, which should not happen. ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components');
1801
1802        didWarnUncontrolledToControlled = true;
1803      }
1804
1805      if (node._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) {
1806        error('A component is changing a controlled input to be uncontrolled. ' + 'This is likely caused by the value changing from a defined to ' + 'undefined, which should not happen. ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components');
1807
1808        didWarnControlledToUncontrolled = true;
1809      }
1810    }
1811
1812    updateChecked(element, props);
1813    var value = getToStringValue(props.value);
1814    var type = props.type;
1815
1816    if (value != null) {
1817      if (type === 'number') {
1818        if (value === 0 && node.value === '' || // We explicitly want to coerce to number here if possible.
1819        // eslint-disable-next-line
1820        node.value != value) {
1821          node.value = toString(value);
1822        }
1823      } else if (node.value !== toString(value)) {
1824        node.value = toString(value);
1825      }
1826    } else if (type === 'submit' || type === 'reset') {
1827      // Submit/reset inputs need the attribute removed completely to avoid
1828      // blank-text buttons.
1829      node.removeAttribute('value');
1830      return;
1831    }
1832
1833    {
1834      // When syncing the value attribute, the value comes from a cascade of
1835      // properties:
1836      //  1. The value React property
1837      //  2. The defaultValue React property
1838      //  3. Otherwise there should be no change
1839      if (props.hasOwnProperty('value')) {
1840        setDefaultValue(node, props.type, value);
1841      } else if (props.hasOwnProperty('defaultValue')) {
1842        setDefaultValue(node, props.type, getToStringValue(props.defaultValue));
1843      }
1844    }
1845
1846    {
1847      // When syncing the checked attribute, it only changes when it needs
1848      // to be removed, such as transitioning from a checkbox into a text input
1849      if (props.checked == null && props.defaultChecked != null) {
1850        node.defaultChecked = !!props.defaultChecked;
1851      }
1852    }
1853  }
1854  function postMountWrapper(element, props, isHydrating) {
1855    var node = element; // Do not assign value if it is already set. This prevents user text input
1856    // from being lost during SSR hydration.
1857
1858    if (props.hasOwnProperty('value') || props.hasOwnProperty('defaultValue')) {
1859      var type = props.type;
1860      var isButton = type === 'submit' || type === 'reset'; // Avoid setting value attribute on submit/reset inputs as it overrides the
1861      // default value provided by the browser. See: #12872
1862
1863      if (isButton && (props.value === undefined || props.value === null)) {
1864        return;
1865      }
1866
1867      var initialValue = toString(node._wrapperState.initialValue); // Do not assign value if it is already set. This prevents user text input
1868      // from being lost during SSR hydration.
1869
1870      if (!isHydrating) {
1871        {
1872          // When syncing the value attribute, the value property should use
1873          // the wrapperState._initialValue property. This uses:
1874          //
1875          //   1. The value React property when present
1876          //   2. The defaultValue React property when present
1877          //   3. An empty string
1878          if (initialValue !== node.value) {
1879            node.value = initialValue;
1880          }
1881        }
1882      }
1883
1884      {
1885        // Otherwise, the value attribute is synchronized to the property,
1886        // so we assign defaultValue to the same thing as the value property
1887        // assignment step above.
1888        node.defaultValue = initialValue;
1889      }
1890    } // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
1891    // this is needed to work around a chrome bug where setting defaultChecked
1892    // will sometimes influence the value of checked (even after detachment).
1893    // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
1894    // We need to temporarily unset name to avoid disrupting radio button groups.
1895
1896
1897    var name = node.name;
1898
1899    if (name !== '') {
1900      node.name = '';
1901    }
1902
1903    {
1904      // When syncing the checked attribute, both the checked property and
1905      // attribute are assigned at the same time using defaultChecked. This uses:
1906      //
1907      //   1. The checked React property when present
1908      //   2. The defaultChecked React property when present
1909      //   3. Otherwise, false
1910      node.defaultChecked = !node.defaultChecked;
1911      node.defaultChecked = !!node._wrapperState.initialChecked;
1912    }
1913
1914    if (name !== '') {
1915      node.name = name;
1916    }
1917  }
1918  function restoreControlledState(element, props) {
1919    var node = element;
1920    updateWrapper(node, props);
1921    updateNamedCousins(node, props);
1922  }
1923
1924  function updateNamedCousins(rootNode, props) {
1925    var name = props.name;
1926
1927    if (props.type === 'radio' && name != null) {
1928      var queryRoot = rootNode;
1929
1930      while (queryRoot.parentNode) {
1931        queryRoot = queryRoot.parentNode;
1932      } // If `rootNode.form` was non-null, then we could try `form.elements`,
1933      // but that sometimes behaves strangely in IE8. We could also try using
1934      // `form.getElementsByName`, but that will only return direct children
1935      // and won't include inputs that use the HTML5 `form=` attribute. Since
1936      // the input might not even be in a form. It might not even be in the
1937      // document. Let's just use the local `querySelectorAll` to ensure we don't
1938      // miss anything.
1939
1940
1941      {
1942        checkAttributeStringCoercion(name, 'name');
1943      }
1944
1945      var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type="radio"]');
1946
1947      for (var i = 0; i < group.length; i++) {
1948        var otherNode = group[i];
1949
1950        if (otherNode === rootNode || otherNode.form !== rootNode.form) {
1951          continue;
1952        } // This will throw if radio buttons rendered by different copies of React
1953        // and the same name are rendered into the same form (same as #1939).
1954        // That's probably okay; we don't support it just as we don't support
1955        // mixing React radio buttons with non-React ones.
1956
1957
1958        var otherProps = getFiberCurrentPropsFromNode(otherNode);
1959
1960        if (!otherProps) {
1961          throw new Error('ReactDOMInput: Mixing React and non-React radio inputs with the ' + 'same `name` is not supported.');
1962        } // We need update the tracked value on the named cousin since the value
1963        // was changed but the input saw no event or value set
1964
1965
1966        updateValueIfChanged(otherNode); // If this is a controlled radio button group, forcing the input that
1967        // was previously checked to update will cause it to be come re-checked
1968        // as appropriate.
1969
1970        updateWrapper(otherNode, otherProps);
1971      }
1972    }
1973  } // In Chrome, assigning defaultValue to certain input types triggers input validation.
1974  // For number inputs, the display value loses trailing decimal points. For email inputs,
1975  // Chrome raises "The specified value <x> is not a valid email address".
1976  //
1977  // Here we check to see if the defaultValue has actually changed, avoiding these problems
1978  // when the user is inputting text
1979  //
1980  // https://github.com/facebook/react/issues/7253
1981
1982
1983  function setDefaultValue(node, type, value) {
1984    if ( // Focused number inputs synchronize on blur. See ChangeEventPlugin.js
1985    type !== 'number' || getActiveElement(node.ownerDocument) !== node) {
1986      if (value == null) {
1987        node.defaultValue = toString(node._wrapperState.initialValue);
1988      } else if (node.defaultValue !== toString(value)) {
1989        node.defaultValue = toString(value);
1990      }
1991    }
1992  }
1993
1994  var didWarnSelectedSetOnOption = false;
1995  var didWarnInvalidChild = false;
1996  var didWarnInvalidInnerHTML = false;
1997  /**
1998   * Implements an <option> host component that warns when `selected` is set.
1999   */
2000
2001  function validateProps(element, props) {
2002    {
2003      // If a value is not provided, then the children must be simple.
2004      if (props.value == null) {
2005        if (typeof props.children === 'object' && props.children !== null) {
2006          React.Children.forEach(props.children, function (child) {
2007            if (child == null) {
2008              return;
2009            }
2010
2011            if (typeof child === 'string' || typeof child === 'number') {
2012              return;
2013            }
2014
2015            if (!didWarnInvalidChild) {
2016              didWarnInvalidChild = true;
2017
2018              error('Cannot infer the option value of complex children. ' + 'Pass a `value` prop or use a plain string as children to <option>.');
2019            }
2020          });
2021        } else if (props.dangerouslySetInnerHTML != null) {
2022          if (!didWarnInvalidInnerHTML) {
2023            didWarnInvalidInnerHTML = true;
2024
2025            error('Pass a `value` prop if you set dangerouslyInnerHTML so React knows ' + 'which value should be selected.');
2026          }
2027        }
2028      } // TODO: Remove support for `selected` in <option>.
2029
2030
2031      if (props.selected != null && !didWarnSelectedSetOnOption) {
2032        error('Use the `defaultValue` or `value` props on <select> instead of ' + 'setting `selected` on <option>.');
2033
2034        didWarnSelectedSetOnOption = true;
2035      }
2036    }
2037  }
2038  function postMountWrapper$1(element, props) {
2039    // value="" should make a value attribute (#6219)
2040    if (props.value != null) {
2041      element.setAttribute('value', toString(getToStringValue(props.value)));
2042    }
2043  }
2044
2045  var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
2046
2047  function isArray(a) {
2048    return isArrayImpl(a);
2049  }
2050
2051  var didWarnValueDefaultValue$1;
2052
2053  {
2054    didWarnValueDefaultValue$1 = false;
2055  }
2056
2057  function getDeclarationErrorAddendum() {
2058    var ownerName = getCurrentFiberOwnerNameInDevOrNull();
2059
2060    if (ownerName) {
2061      return '\n\nCheck the render method of `' + ownerName + '`.';
2062    }
2063
2064    return '';
2065  }
2066
2067  var valuePropNames = ['value', 'defaultValue'];
2068  /**
2069   * Validation function for `value` and `defaultValue`.
2070   */
2071
2072  function checkSelectPropTypes(props) {
2073    {
2074      checkControlledValueProps('select', props);
2075
2076      for (var i = 0; i < valuePropNames.length; i++) {
2077        var propName = valuePropNames[i];
2078
2079        if (props[propName] == null) {
2080          continue;
2081        }
2082
2083        var propNameIsArray = isArray(props[propName]);
2084
2085        if (props.multiple && !propNameIsArray) {
2086          error('The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum());
2087        } else if (!props.multiple && propNameIsArray) {
2088          error('The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum());
2089        }
2090      }
2091    }
2092  }
2093
2094  function updateOptions(node, multiple, propValue, setDefaultSelected) {
2095    var options = node.options;
2096
2097    if (multiple) {
2098      var selectedValues = propValue;
2099      var selectedValue = {};
2100
2101      for (var i = 0; i < selectedValues.length; i++) {
2102        // Prefix to avoid chaos with special keys.
2103        selectedValue['$' + selectedValues[i]] = true;
2104      }
2105
2106      for (var _i = 0; _i < options.length; _i++) {
2107        var selected = selectedValue.hasOwnProperty('$' + options[_i].value);
2108
2109        if (options[_i].selected !== selected) {
2110          options[_i].selected = selected;
2111        }
2112
2113        if (selected && setDefaultSelected) {
2114          options[_i].defaultSelected = true;
2115        }
2116      }
2117    } else {
2118      // Do not set `select.value` as exact behavior isn't consistent across all
2119      // browsers for all cases.
2120      var _selectedValue = toString(getToStringValue(propValue));
2121
2122      var defaultSelected = null;
2123
2124      for (var _i2 = 0; _i2 < options.length; _i2++) {
2125        if (options[_i2].value === _selectedValue) {
2126          options[_i2].selected = true;
2127
2128          if (setDefaultSelected) {
2129            options[_i2].defaultSelected = true;
2130          }
2131
2132          return;
2133        }
2134
2135        if (defaultSelected === null && !options[_i2].disabled) {
2136          defaultSelected = options[_i2];
2137        }
2138      }
2139
2140      if (defaultSelected !== null) {
2141        defaultSelected.selected = true;
2142      }
2143    }
2144  }
2145  /**
2146   * Implements a <select> host component that allows optionally setting the
2147   * props `value` and `defaultValue`. If `multiple` is false, the prop must be a
2148   * stringable. If `multiple` is true, the prop must be an array of stringables.
2149   *
2150   * If `value` is not supplied (or null/undefined), user actions that change the
2151   * selected option will trigger updates to the rendered options.
2152   *
2153   * If it is supplied (and not null/undefined), the rendered options will not
2154   * update in response to user actions. Instead, the `value` prop must change in
2155   * order for the rendered options to update.
2156   *
2157   * If `defaultValue` is provided, any options with the supplied values will be
2158   * selected.
2159   */
2160
2161
2162  function getHostProps$1(element, props) {
2163    return assign({}, props, {
2164      value: undefined
2165    });
2166  }
2167  function initWrapperState$1(element, props) {
2168    var node = element;
2169
2170    {
2171      checkSelectPropTypes(props);
2172    }
2173
2174    node._wrapperState = {
2175      wasMultiple: !!props.multiple
2176    };
2177
2178    {
2179      if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue$1) {
2180        error('Select elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled select ' + 'element and remove one of these props. More info: ' + 'https://reactjs.org/link/controlled-components');
2181
2182        didWarnValueDefaultValue$1 = true;
2183      }
2184    }
2185  }
2186  function postMountWrapper$2(element, props) {
2187    var node = element;
2188    node.multiple = !!props.multiple;
2189    var value = props.value;
2190
2191    if (value != null) {
2192      updateOptions(node, !!props.multiple, value, false);
2193    } else if (props.defaultValue != null) {
2194      updateOptions(node, !!props.multiple, props.defaultValue, true);
2195    }
2196  }
2197  function postUpdateWrapper(element, props) {
2198    var node = element;
2199    var wasMultiple = node._wrapperState.wasMultiple;
2200    node._wrapperState.wasMultiple = !!props.multiple;
2201    var value = props.value;
2202
2203    if (value != null) {
2204      updateOptions(node, !!props.multiple, value, false);
2205    } else if (wasMultiple !== !!props.multiple) {
2206      // For simplicity, reapply `defaultValue` if `multiple` is toggled.
2207      if (props.defaultValue != null) {
2208        updateOptions(node, !!props.multiple, props.defaultValue, true);
2209      } else {
2210        // Revert the select back to its default unselected state.
2211        updateOptions(node, !!props.multiple, props.multiple ? [] : '', false);
2212      }
2213    }
2214  }
2215  function restoreControlledState$1(element, props) {
2216    var node = element;
2217    var value = props.value;
2218
2219    if (value != null) {
2220      updateOptions(node, !!props.multiple, value, false);
2221    }
2222  }
2223
2224  var didWarnValDefaultVal = false;
2225
2226  /**
2227   * Implements a <textarea> host component that allows setting `value`, and
2228   * `defaultValue`. This differs from the traditional DOM API because value is
2229   * usually set as PCDATA children.
2230   *
2231   * If `value` is not supplied (or null/undefined), user actions that affect the
2232   * value will trigger updates to the element.
2233   *
2234   * If `value` is supplied (and not null/undefined), the rendered element will
2235   * not trigger updates to the element. Instead, the `value` prop must change in
2236   * order for the rendered element to be updated.
2237   *
2238   * The rendered element will be initialized with an empty value, the prop
2239   * `defaultValue` if specified, or the children content (deprecated).
2240   */
2241  function getHostProps$2(element, props) {
2242    var node = element;
2243
2244    if (props.dangerouslySetInnerHTML != null) {
2245      throw new Error('`dangerouslySetInnerHTML` does not make sense on <textarea>.');
2246    } // Always set children to the same thing. In IE9, the selection range will
2247    // get reset if `textContent` is mutated.  We could add a check in setTextContent
2248    // to only set the value if/when the value differs from the node value (which would
2249    // completely solve this IE9 bug), but Sebastian+Sophie seemed to like this
2250    // solution. The value can be a boolean or object so that's why it's forced
2251    // to be a string.
2252
2253
2254    var hostProps = assign({}, props, {
2255      value: undefined,
2256      defaultValue: undefined,
2257      children: toString(node._wrapperState.initialValue)
2258    });
2259
2260    return hostProps;
2261  }
2262  function initWrapperState$2(element, props) {
2263    var node = element;
2264
2265    {
2266      checkControlledValueProps('textarea', props);
2267
2268      if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValDefaultVal) {
2269        error('%s contains a textarea with both value and defaultValue props. ' + 'Textarea elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled textarea ' + 'and remove one of these props. More info: ' + 'https://reactjs.org/link/controlled-components', getCurrentFiberOwnerNameInDevOrNull() || 'A component');
2270
2271        didWarnValDefaultVal = true;
2272      }
2273    }
2274
2275    var initialValue = props.value; // Only bother fetching default value if we're going to use it
2276
2277    if (initialValue == null) {
2278      var children = props.children,
2279          defaultValue = props.defaultValue;
2280
2281      if (children != null) {
2282        {
2283          error('Use the `defaultValue` or `value` props instead of setting ' + 'children on <textarea>.');
2284        }
2285
2286        {
2287          if (defaultValue != null) {
2288            throw new Error('If you supply `defaultValue` on a <textarea>, do not pass children.');
2289          }
2290
2291          if (isArray(children)) {
2292            if (children.length > 1) {
2293              throw new Error('<textarea> can only have at most one child.');
2294            }
2295
2296            children = children[0];
2297          }
2298
2299          defaultValue = children;
2300        }
2301      }
2302
2303      if (defaultValue == null) {
2304        defaultValue = '';
2305      }
2306
2307      initialValue = defaultValue;
2308    }
2309
2310    node._wrapperState = {
2311      initialValue: getToStringValue(initialValue)
2312    };
2313  }
2314  function updateWrapper$1(element, props) {
2315    var node = element;
2316    var value = getToStringValue(props.value);
2317    var defaultValue = getToStringValue(props.defaultValue);
2318
2319    if (value != null) {
2320      // Cast `value` to a string to ensure the value is set correctly. While
2321      // browsers typically do this as necessary, jsdom doesn't.
2322      var newValue = toString(value); // To avoid side effects (such as losing text selection), only set value if changed
2323
2324      if (newValue !== node.value) {
2325        node.value = newValue;
2326      }
2327
2328      if (props.defaultValue == null && node.defaultValue !== newValue) {
2329        node.defaultValue = newValue;
2330      }
2331    }
2332
2333    if (defaultValue != null) {
2334      node.defaultValue = toString(defaultValue);
2335    }
2336  }
2337  function postMountWrapper$3(element, props) {
2338    var node = element; // This is in postMount because we need access to the DOM node, which is not
2339    // available until after the component has mounted.
2340
2341    var textContent = node.textContent; // Only set node.value if textContent is equal to the expected
2342    // initial value. In IE10/IE11 there is a bug where the placeholder attribute
2343    // will populate textContent as well.
2344    // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/
2345
2346    if (textContent === node._wrapperState.initialValue) {
2347      if (textContent !== '' && textContent !== null) {
2348        node.value = textContent;
2349      }
2350    }
2351  }
2352  function restoreControlledState$2(element, props) {
2353    // DOM component is still mounted; update
2354    updateWrapper$1(element, props);
2355  }
2356
2357  var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
2358  var MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
2359  var SVG_NAMESPACE = 'http://www.w3.org/2000/svg'; // Assumes there is no parent namespace.
2360
2361  function getIntrinsicNamespace(type) {
2362    switch (type) {
2363      case 'svg':
2364        return SVG_NAMESPACE;
2365
2366      case 'math':
2367        return MATH_NAMESPACE;
2368
2369      default:
2370        return HTML_NAMESPACE;
2371    }
2372  }
2373  function getChildNamespace(parentNamespace, type) {
2374    if (parentNamespace == null || parentNamespace === HTML_NAMESPACE) {
2375      // No (or default) parent namespace: potential entry point.
2376      return getIntrinsicNamespace(type);
2377    }
2378
2379    if (parentNamespace === SVG_NAMESPACE && type === 'foreignObject') {
2380      // We're leaving SVG.
2381      return HTML_NAMESPACE;
2382    } // By default, pass namespace below.
2383
2384
2385    return parentNamespace;
2386  }
2387
2388  /* globals MSApp */
2389
2390  /**
2391   * Create a function which has 'unsafe' privileges (required by windows8 apps)
2392   */
2393  var createMicrosoftUnsafeLocalFunction = function (func) {
2394    if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {
2395      return function (arg0, arg1, arg2, arg3) {
2396        MSApp.execUnsafeLocalFunction(function () {
2397          return func(arg0, arg1, arg2, arg3);
2398        });
2399      };
2400    } else {
2401      return func;
2402    }
2403  };
2404
2405  var reusableSVGContainer;
2406  /**
2407   * Set the innerHTML property of a node
2408   *
2409   * @param {DOMElement} node
2410   * @param {string} html
2411   * @internal
2412   */
2413
2414  var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {
2415    if (node.namespaceURI === SVG_NAMESPACE) {
2416
2417      if (!('innerHTML' in node)) {
2418        // IE does not have innerHTML for SVG nodes, so instead we inject the
2419        // new markup in a temp node and then move the child nodes across into
2420        // the target node
2421        reusableSVGContainer = reusableSVGContainer || document.createElement('div');
2422        reusableSVGContainer.innerHTML = '<svg>' + html.valueOf().toString() + '</svg>';
2423        var svgNode = reusableSVGContainer.firstChild;
2424
2425        while (node.firstChild) {
2426          node.removeChild(node.firstChild);
2427        }
2428
2429        while (svgNode.firstChild) {
2430          node.appendChild(svgNode.firstChild);
2431        }
2432
2433        return;
2434      }
2435    }
2436
2437    node.innerHTML = html;
2438  });
2439
2440  /**
2441   * HTML nodeType values that represent the type of the node
2442   */
2443  var ELEMENT_NODE = 1;
2444  var TEXT_NODE = 3;
2445  var COMMENT_NODE = 8;
2446  var DOCUMENT_NODE = 9;
2447  var DOCUMENT_FRAGMENT_NODE = 11;
2448
2449  /**
2450   * Set the textContent property of a node. For text updates, it's faster
2451   * to set the `nodeValue` of the Text node directly instead of using
2452   * `.textContent` which will remove the existing node and create a new one.
2453   *
2454   * @param {DOMElement} node
2455   * @param {string} text
2456   * @internal
2457   */
2458
2459  var setTextContent = function (node, text) {
2460    if (text) {
2461      var firstChild = node.firstChild;
2462
2463      if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {
2464        firstChild.nodeValue = text;
2465        return;
2466      }
2467    }
2468
2469    node.textContent = text;
2470  };
2471
2472  // List derived from Gecko source code:
2473  // https://github.com/mozilla/gecko-dev/blob/4e638efc71/layout/style/test/property_database.js
2474  var shorthandToLonghand = {
2475    animation: ['animationDelay', 'animationDirection', 'animationDuration', 'animationFillMode', 'animationIterationCount', 'animationName', 'animationPlayState', 'animationTimingFunction'],
2476    background: ['backgroundAttachment', 'backgroundClip', 'backgroundColor', 'backgroundImage', 'backgroundOrigin', 'backgroundPositionX', 'backgroundPositionY', 'backgroundRepeat', 'backgroundSize'],
2477    backgroundPosition: ['backgroundPositionX', 'backgroundPositionY'],
2478    border: ['borderBottomColor', 'borderBottomStyle', 'borderBottomWidth', 'borderImageOutset', 'borderImageRepeat', 'borderImageSlice', 'borderImageSource', 'borderImageWidth', 'borderLeftColor', 'borderLeftStyle', 'borderLeftWidth', 'borderRightColor', 'borderRightStyle', 'borderRightWidth', 'borderTopColor', 'borderTopStyle', 'borderTopWidth'],
2479    borderBlockEnd: ['borderBlockEndColor', 'borderBlockEndStyle', 'borderBlockEndWidth'],
2480    borderBlockStart: ['borderBlockStartColor', 'borderBlockStartStyle', 'borderBlockStartWidth'],
2481    borderBottom: ['borderBottomColor', 'borderBottomStyle', 'borderBottomWidth'],
2482    borderColor: ['borderBottomColor', 'borderLeftColor', 'borderRightColor', 'borderTopColor'],
2483    borderImage: ['borderImageOutset', 'borderImageRepeat', 'borderImageSlice', 'borderImageSource', 'borderImageWidth'],
2484    borderInlineEnd: ['borderInlineEndColor', 'borderInlineEndStyle', 'borderInlineEndWidth'],
2485    borderInlineStart: ['borderInlineStartColor', 'borderInlineStartStyle', 'borderInlineStartWidth'],
2486    borderLeft: ['borderLeftColor', 'borderLeftStyle', 'borderLeftWidth'],
2487    borderRadius: ['borderBottomLeftRadius', 'borderBottomRightRadius', 'borderTopLeftRadius', 'borderTopRightRadius'],
2488    borderRight: ['borderRightColor', 'borderRightStyle', 'borderRightWidth'],
2489    borderStyle: ['borderBottomStyle', 'borderLeftStyle', 'borderRightStyle', 'borderTopStyle'],
2490    borderTop: ['borderTopColor', 'borderTopStyle', 'borderTopWidth'],
2491    borderWidth: ['borderBottomWidth', 'borderLeftWidth', 'borderRightWidth', 'borderTopWidth'],
2492    columnRule: ['columnRuleColor', 'columnRuleStyle', 'columnRuleWidth'],
2493    columns: ['columnCount', 'columnWidth'],
2494    flex: ['flexBasis', 'flexGrow', 'flexShrink'],
2495    flexFlow: ['flexDirection', 'flexWrap'],
2496    font: ['fontFamily', 'fontFeatureSettings', 'fontKerning', 'fontLanguageOverride', 'fontSize', 'fontSizeAdjust', 'fontStretch', 'fontStyle', 'fontVariant', 'fontVariantAlternates', 'fontVariantCaps', 'fontVariantEastAsian', 'fontVariantLigatures', 'fontVariantNumeric', 'fontVariantPosition', 'fontWeight', 'lineHeight'],
2497    fontVariant: ['fontVariantAlternates', 'fontVariantCaps', 'fontVariantEastAsian', 'fontVariantLigatures', 'fontVariantNumeric', 'fontVariantPosition'],
2498    gap: ['columnGap', 'rowGap'],
2499    grid: ['gridAutoColumns', 'gridAutoFlow', 'gridAutoRows', 'gridTemplateAreas', 'gridTemplateColumns', 'gridTemplateRows'],
2500    gridArea: ['gridColumnEnd', 'gridColumnStart', 'gridRowEnd', 'gridRowStart'],
2501    gridColumn: ['gridColumnEnd', 'gridColumnStart'],
2502    gridColumnGap: ['columnGap'],
2503    gridGap: ['columnGap', 'rowGap'],
2504    gridRow: ['gridRowEnd', 'gridRowStart'],
2505    gridRowGap: ['rowGap'],
2506    gridTemplate: ['gridTemplateAreas', 'gridTemplateColumns', 'gridTemplateRows'],
2507    listStyle: ['listStyleImage', 'listStylePosition', 'listStyleType'],
2508    margin: ['marginBottom', 'marginLeft', 'marginRight', 'marginTop'],
2509    marker: ['markerEnd', 'markerMid', 'markerStart'],
2510    mask: ['maskClip', 'maskComposite', 'maskImage', 'maskMode', 'maskOrigin', 'maskPositionX', 'maskPositionY', 'maskRepeat', 'maskSize'],
2511    maskPosition: ['maskPositionX', 'maskPositionY'],
2512    outline: ['outlineColor', 'outlineStyle', 'outlineWidth'],
2513    overflow: ['overflowX', 'overflowY'],
2514    padding: ['paddingBottom', 'paddingLeft', 'paddingRight', 'paddingTop'],
2515    placeContent: ['alignContent', 'justifyContent'],
2516    placeItems: ['alignItems', 'justifyItems'],
2517    placeSelf: ['alignSelf', 'justifySelf'],
2518    textDecoration: ['textDecorationColor', 'textDecorationLine', 'textDecorationStyle'],
2519    textEmphasis: ['textEmphasisColor', 'textEmphasisStyle'],
2520    transition: ['transitionDelay', 'transitionDuration', 'transitionProperty', 'transitionTimingFunction'],
2521    wordWrap: ['overflowWrap']
2522  };
2523
2524  /**
2525   * CSS properties which accept numbers but are not in units of "px".
2526   */
2527  var isUnitlessNumber = {
2528    animationIterationCount: true,
2529    aspectRatio: true,
2530    borderImageOutset: true,
2531    borderImageSlice: true,
2532    borderImageWidth: true,
2533    boxFlex: true,
2534    boxFlexGroup: true,
2535    boxOrdinalGroup: true,
2536    columnCount: true,
2537    columns: true,
2538    flex: true,
2539    flexGrow: true,
2540    flexPositive: true,
2541    flexShrink: true,
2542    flexNegative: true,
2543    flexOrder: true,
2544    gridArea: true,
2545    gridRow: true,
2546    gridRowEnd: true,
2547    gridRowSpan: true,
2548    gridRowStart: true,
2549    gridColumn: true,
2550    gridColumnEnd: true,
2551    gridColumnSpan: true,
2552    gridColumnStart: true,
2553    fontWeight: true,
2554    lineClamp: true,
2555    lineHeight: true,
2556    opacity: true,
2557    order: true,
2558    orphans: true,
2559    tabSize: true,
2560    widows: true,
2561    zIndex: true,
2562    zoom: true,
2563    // SVG-related properties
2564    fillOpacity: true,
2565    floodOpacity: true,
2566    stopOpacity: true,
2567    strokeDasharray: true,
2568    strokeDashoffset: true,
2569    strokeMiterlimit: true,
2570    strokeOpacity: true,
2571    strokeWidth: true
2572  };
2573  /**
2574   * @param {string} prefix vendor-specific prefix, eg: Webkit
2575   * @param {string} key style name, eg: transitionDuration
2576   * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
2577   * WebkitTransitionDuration
2578   */
2579
2580  function prefixKey(prefix, key) {
2581    return prefix + key.charAt(0).toUpperCase() + key.substring(1);
2582  }
2583  /**
2584   * Support style names that may come passed in prefixed by adding permutations
2585   * of vendor prefixes.
2586   */
2587
2588
2589  var prefixes = ['Webkit', 'ms', 'Moz', 'O']; // Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
2590  // infinite loop, because it iterates over the newly added props too.
2591
2592  Object.keys(isUnitlessNumber).forEach(function (prop) {
2593    prefixes.forEach(function (prefix) {
2594      isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
2595    });
2596  });
2597
2598  /**
2599   * Convert a value into the proper css writable value. The style name `name`
2600   * should be logical (no hyphens), as specified
2601   * in `CSSProperty.isUnitlessNumber`.
2602   *
2603   * @param {string} name CSS property name such as `topMargin`.
2604   * @param {*} value CSS property value such as `10px`.
2605   * @return {string} Normalized style value with dimensions applied.
2606   */
2607
2608  function dangerousStyleValue(name, value, isCustomProperty) {
2609    // Note that we've removed escapeTextForBrowser() calls here since the
2610    // whole string will be escaped when the attribute is injected into
2611    // the markup. If you provide unsafe user data here they can inject
2612    // arbitrary CSS which may be problematic (I couldn't repro this):
2613    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
2614    // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
2615    // This is not an XSS hole but instead a potential CSS injection issue
2616    // which has lead to a greater discussion about how we're going to
2617    // trust URLs moving forward. See #2115901
2618    var isEmpty = value == null || typeof value === 'boolean' || value === '';
2619
2620    if (isEmpty) {
2621      return '';
2622    }
2623
2624    if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) {
2625      return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers
2626    }
2627
2628    {
2629      checkCSSPropertyStringCoercion(value, name);
2630    }
2631
2632    return ('' + value).trim();
2633  }
2634
2635  var uppercasePattern = /([A-Z])/g;
2636  var msPattern = /^ms-/;
2637  /**
2638   * Hyphenates a camelcased CSS property name, for example:
2639   *
2640   *   > hyphenateStyleName('backgroundColor')
2641   *   < "background-color"
2642   *   > hyphenateStyleName('MozTransition')
2643   *   < "-moz-transition"
2644   *   > hyphenateStyleName('msTransition')
2645   *   < "-ms-transition"
2646   *
2647   * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
2648   * is converted to `-ms-`.
2649   */
2650
2651  function hyphenateStyleName(name) {
2652    return name.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');
2653  }
2654
2655  var warnValidStyle = function () {};
2656
2657  {
2658    // 'msTransform' is correct, but the other prefixes should be capitalized
2659    var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
2660    var msPattern$1 = /^-ms-/;
2661    var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
2662
2663    var badStyleValueWithSemicolonPattern = /;\s*$/;
2664    var warnedStyleNames = {};
2665    var warnedStyleValues = {};
2666    var warnedForNaNValue = false;
2667    var warnedForInfinityValue = false;
2668
2669    var camelize = function (string) {
2670      return string.replace(hyphenPattern, function (_, character) {
2671        return character.toUpperCase();
2672      });
2673    };
2674
2675    var warnHyphenatedStyleName = function (name) {
2676      if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
2677        return;
2678      }
2679
2680      warnedStyleNames[name] = true;
2681
2682      error('Unsupported style property %s. Did you mean %s?', name, // As Andi Smith suggests
2683      // (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
2684      // is converted to lowercase `ms`.
2685      camelize(name.replace(msPattern$1, 'ms-')));
2686    };
2687
2688    var warnBadVendoredStyleName = function (name) {
2689      if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
2690        return;
2691      }
2692
2693      warnedStyleNames[name] = true;
2694
2695      error('Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1));
2696    };
2697
2698    var warnStyleValueWithSemicolon = function (name, value) {
2699      if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
2700        return;
2701      }
2702
2703      warnedStyleValues[value] = true;
2704
2705      error("Style property values shouldn't contain a semicolon. " + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, ''));
2706    };
2707
2708    var warnStyleValueIsNaN = function (name, value) {
2709      if (warnedForNaNValue) {
2710        return;
2711      }
2712
2713      warnedForNaNValue = true;
2714
2715      error('`NaN` is an invalid value for the `%s` css style property.', name);
2716    };
2717
2718    var warnStyleValueIsInfinity = function (name, value) {
2719      if (warnedForInfinityValue) {
2720        return;
2721      }
2722
2723      warnedForInfinityValue = true;
2724
2725      error('`Infinity` is an invalid value for the `%s` css style property.', name);
2726    };
2727
2728    warnValidStyle = function (name, value) {
2729      if (name.indexOf('-') > -1) {
2730        warnHyphenatedStyleName(name);
2731      } else if (badVendoredStyleNamePattern.test(name)) {
2732        warnBadVendoredStyleName(name);
2733      } else if (badStyleValueWithSemicolonPattern.test(value)) {
2734        warnStyleValueWithSemicolon(name, value);
2735      }
2736
2737      if (typeof value === 'number') {
2738        if (isNaN(value)) {
2739          warnStyleValueIsNaN(name, value);
2740        } else if (!isFinite(value)) {
2741          warnStyleValueIsInfinity(name, value);
2742        }
2743      }
2744    };
2745  }
2746
2747  var warnValidStyle$1 = warnValidStyle;
2748
2749  /**
2750   * Operations for dealing with CSS properties.
2751   */
2752
2753  /**
2754   * This creates a string that is expected to be equivalent to the style
2755   * attribute generated by server-side rendering. It by-passes warnings and
2756   * security checks so it's not safe to use this value for anything other than
2757   * comparison. It is only used in DEV for SSR validation.
2758   */
2759
2760  function createDangerousStringForStyles(styles) {
2761    {
2762      var serialized = '';
2763      var delimiter = '';
2764
2765      for (var styleName in styles) {
2766        if (!styles.hasOwnProperty(styleName)) {
2767          continue;
2768        }
2769
2770        var styleValue = styles[styleName];
2771
2772        if (styleValue != null) {
2773          var isCustomProperty = styleName.indexOf('--') === 0;
2774          serialized += delimiter + (isCustomProperty ? styleName : hyphenateStyleName(styleName)) + ':';
2775          serialized += dangerousStyleValue(styleName, styleValue, isCustomProperty);
2776          delimiter = ';';
2777        }
2778      }
2779
2780      return serialized || null;
2781    }
2782  }
2783  /**
2784   * Sets the value for multiple styles on a node.  If a value is specified as
2785   * '' (empty string), the corresponding style property will be unset.
2786   *
2787   * @param {DOMElement} node
2788   * @param {object} styles
2789   */
2790
2791  function setValueForStyles(node, styles) {
2792    var style = node.style;
2793
2794    for (var styleName in styles) {
2795      if (!styles.hasOwnProperty(styleName)) {
2796        continue;
2797      }
2798
2799      var isCustomProperty = styleName.indexOf('--') === 0;
2800
2801      {
2802        if (!isCustomProperty) {
2803          warnValidStyle$1(styleName, styles[styleName]);
2804        }
2805      }
2806
2807      var styleValue = dangerousStyleValue(styleName, styles[styleName], isCustomProperty);
2808
2809      if (styleName === 'float') {
2810        styleName = 'cssFloat';
2811      }
2812
2813      if (isCustomProperty) {
2814        style.setProperty(styleName, styleValue);
2815      } else {
2816        style[styleName] = styleValue;
2817      }
2818    }
2819  }
2820
2821  function isValueEmpty(value) {
2822    return value == null || typeof value === 'boolean' || value === '';
2823  }
2824  /**
2825   * Given {color: 'red', overflow: 'hidden'} returns {
2826   *   color: 'color',
2827   *   overflowX: 'overflow',
2828   *   overflowY: 'overflow',
2829   * }. This can be read as "the overflowY property was set by the overflow
2830   * shorthand". That is, the values are the property that each was derived from.
2831   */
2832
2833
2834  function expandShorthandMap(styles) {
2835    var expanded = {};
2836
2837    for (var key in styles) {
2838      var longhands = shorthandToLonghand[key] || [key];
2839
2840      for (var i = 0; i < longhands.length; i++) {
2841        expanded[longhands[i]] = key;
2842      }
2843    }
2844
2845    return expanded;
2846  }
2847  /**
2848   * When mixing shorthand and longhand property names, we warn during updates if
2849   * we expect an incorrect result to occur. In particular, we warn for:
2850   *
2851   * Updating a shorthand property (longhand gets overwritten):
2852   *   {font: 'foo', fontVariant: 'bar'} -> {font: 'baz', fontVariant: 'bar'}
2853   *   becomes .style.font = 'baz'
2854   * Removing a shorthand property (longhand gets lost too):
2855   *   {font: 'foo', fontVariant: 'bar'} -> {fontVariant: 'bar'}
2856   *   becomes .style.font = ''
2857   * Removing a longhand property (should revert to shorthand; doesn't):
2858   *   {font: 'foo', fontVariant: 'bar'} -> {font: 'foo'}
2859   *   becomes .style.fontVariant = ''
2860   */
2861
2862
2863  function validateShorthandPropertyCollisionInDev(styleUpdates, nextStyles) {
2864    {
2865      if (!nextStyles) {
2866        return;
2867      }
2868