Check if `h` is `react.createElement`.
178609
function react(h) {
  var node = h && h('div')
  return Boolean(
    node && ('_owner' in node || '_store' in node) && node.key === null
  )
}
949159
function (selector, done) {
  this.evaluate_now((selector) => {
    let element = document.querySelector(selector)
    if (!element) {
      return null
    }

    for (let key in element) {
      if (key.startsWith('__reactInternalInstance$')) {
        const compInternals = element[key]._currentElement
        const compWrapper = compInternals._owner
        const {props, state, context} = compWrapper._instance
        return {
          props,
          state,
          context
        }
      }
    }

    return null
  }, done, selector)
}
1348343
function ensureDOMElement (input) {
  let domElement = null
  let tmp = null
  if (input instanceof Element) {
    return input
  } else if ('string' == typeof input) {
    tmp = document.createElement('div')
    tmp.innerHTML = input
    domElement = tmp.innerHTML.length ? tmp.children[0] : new Template(input)
  } else {
    domElement = document.createElement('div')
  }
  return domElement
}
1011930
function hasJavascriptHref(element) {
    if (getTagName(element) != 'a') {
        return false;
    }
    if (element.getAttribute('onclick')) {
        return false;
    }
    if (! element.href) {
        return false;
    }
    if (! /\s*javascript:/i.test(element.href)) {
        return false;
    }
    return true;
}
612941
function checkComponentDefined (el, name) {
  // Check if element contains the component.
  if (el.components[name] && el.components[name].attrValue) { return true; }

  return isComponentMixedIn(name, el.mixinEls);
}
67964
function () {
            var config   = this._conf()
              , meta     = this._meta()
              , spec     = this._spec()
              , value    = config.value
              , truthMap = getOrNull( spec, 'truthMap' )
              , checked  = truthMap 
                    ? truthMap[ "true" ] === value
                    : value;
            
            if ( meta.isHidden ) return null;

            return (
                React.createElement("input", {
                    id: config.fieldID, 
                    type: "checkbox", 
                    className: "generated-checkbox-field", 
                    name: spec.name, 
                    checked: checked, 
                    readOnly: meta.isReadOnly || meta.isDisabled, 
                    onChange: this.handleOnChange, 
                    onBlur: this.handleEvent( 'blur'), 
                    onFocus: this.handleEvent( 'focus'), 
                    onKeyPress: this.handleEvent( 'keypress')})
            );
        }
974248
function makeElement(name) {
      return name === 'svg' ? document.createElementNS(SVG_NS, name) : document.createElement(name)
    }
1314606
function def(p) {
    if (p && p.tagName && p.cls) {
        if (customElements.get(p.tagName)) {
            console.warn(p.tagName + '!!');
        }
        else {
            customElements.define(p.tagName, p.cls);
        }
    }
}
227650
function checkForCreateNode(id, name, type, props, children) {
  typeCheckInteger(id, 'id');
  typeCheckString(name, 'name');
  checkNodeType(type);
  checkProps(props);
  checkChildren(children);
}
215076
function createEl(tag, prop) {
let el = document.createElement(tag || 'div'),
    n;

for (n in prop) el[n] = prop[n];
return el;
}
415955
function _isElement(input) {

		return (typeof HTMLElement === 'function') ?

			(input instanceof HTMLElement) :

			(input && typeof input === 'object' && input.nodeType === 1 && typeof input.nodeName === 'string');

	}
823525
function TheHtmlStyle(_ref) {
  var className = _ref.className,
      id = _ref.id,
      options = _ref.options;
  return _react.default.createElement(_theStyle.TheStyle, (0, _extends2.default)({
    id: id
  }, {
    className: (0, _classnames.default)('the-html-style', className),
    styles: TheHtmlStyle.data(options)
  }));
}
354827
function check(source, file) {
  if (t.isLiteral(source)) {
    var name = source.value;
    var lower = name.toLowerCase();

    if (lower === "react" && name !== lower) {
      throw file.errorWithNode(source, messages.get("didYouMean", "react"));
    }
  }
}
800179
function isCheerioInstance(elem) {
    return elem &&
        elem.contains &&
        elem.html &&
        elem.parseHTML && true;
}
681190
def check_no_element_by_selector(self, selector):
    """"""
    elems = find_elements_by_jquery(world.browser, selector)
    if elems:
        raise AssertionError("Expected no matching elements, found {}.".format(
            len(elems)))
5370
function() {
		var defaultProps = {
			glEventHub: this._container.layoutManager.eventHub,
			glContainer: this._container,
			ref: this._gotReactComponent.bind( this )
		};
		var props = $.extend( defaultProps, this._container._config.props );
		return React.createElement( this._reactClass, props );
	}
813864
function (html) {
    this.reset();

    var containerEl = createElement('div');
    containerEl.innerHTML = '\n' + this._cleanInput(html) + '\n';

    if (this.config.createClass) {
      if (this.config.outputClassName) {
        this.output = 'var ' + this.config.outputClassName + ' = React.createClass({\n';
      } else {
        this.output = 'React.createClass({\n';
      }
      this.output += this.config.indent + 'render: function() {' + "\n";
      this.output += this.config.indent + this.config.indent + 'return (\n';
    }

    if (this._onlyOneTopLevel(containerEl)) {
      // Only one top-level element, the component can return it directly
      // No need to actually visit the container element
      this._traverse(containerEl);
    } else {
      // More than one top-level element, need to wrap the whole thing in a
      // container.
      this.output += this.config.indent + this.config.indent + this.config.indent;
      this.level++;
      this._visit(containerEl);
    }
    this.output = this.output.trim() + '\n';
    if (this.config.createClass) {
      this.output += this.config.indent + this.config.indent + ');\n';
      this.output += this.config.indent + '}\n';
      this.output += '});';
    } else {
      this.output = this._removeJSXClassIndention(this.output, this.config.indent);
    }
    return this.output;
  }