See https://github.com/facebook/prop-types/blob/155f4cc27ae7e566bb2825edb9f4467ed1d0d2b2/factoryWithTypeCheckers.js#L459
506473
function isSymbol(t, v) {
  if (v === null) {
    return false;
  }
  // Native Symbol.
  if (t === 'symbol') {
    return true;
  }
  // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
  if (v['@@toStringTag'] === 'Symbol') {
    return true;
  }
  // Fallback for non-spec compliant Symbols which are polyfilled.
  if (typeof Symbol === 'function' && v instanceof Symbol) {
    return true;
  }
  return false;
}
205330
function factory(type) {
  point.displayName = type

  return point

  /* Get a point in `node.position` at a bound `type`. */
  function point(node) {
    var point = (node && node.position && node.position[type]) || {}

    return {
      line: point.line || null,
      column: point.column || null,
      offset: isNaN(point.offset) ? null : point.offset
    }
  }
}
962448
function(type) {
        var namespaces = emberA(Namespace.NAMESPACES), types = emberA(), self = this;
        var typeSuffixRegex = new RegExp(classify(type) + "$");

        namespaces.forEach(function(namespace) {
          if (namespace !== Ember) {
            for (var key in namespace) {
              if (!namespace.hasOwnProperty(key)) { continue; }
              if (typeSuffixRegex.test(key)) {
                var klass = namespace[key];
                if (typeOf(klass) === 'class') {
                  types.push(dasherize(key.replace(typeSuffixRegex, '')));
                }
              }
            }
          }
        });
        return types;
      }
881024
function getType(value) {

  const type = typeof value;

  if (Array.isArray(value)) {
    return 'array';
  }

  if (value instanceof RegExp) {
    // Old webkits (at least until Android 4.0) return 'function' rather than
    // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
    // passes PropTypes.object.
    return 'object';
  }

  if (isSymbol(type, value)) {
    return 'symbol';
  }

  return type;
}
781391
function createLinkTypeChecker(linkType) {
  var shapes = {
    value: linkType === undefined ? React.PropTypes.any.isRequired : linkType.isRequired,
    requestChange: React.PropTypes.func.isRequired
  };
  return React.PropTypes.shape(shapes);
}
184386
function _storageFactory(type) {
	let storage;

	if (type === 'local') {
		storage = window.localStorage;
	} else if (type === 'session') {
		storage = window.sessionStorage;
	}

	return {
		getItem(key) {
			return JSON.parse(storage.getItem(key));
		},
		setItem(key, value) {
			value = JSON.stringify(value);

			return storage.setItem(key, value);
		},
		removeItem(key) {
			return storage.removeItem(key);
		}
	};
}
270004
function _createBlob(parts, properties) {
	        parts = parts || [];
	        properties = properties || {};

	        try {
	            return new Blob(parts, properties);
	        } catch (err) {
	            if (err.name !== 'TypeError') {
	                throw err;
	            }

	            var BlobBuilder = globalObject.BlobBuilder || globalObject.MSBlobBuilder || globalObject.MozBlobBuilder || globalObject.WebKitBlobBuilder;

	            var builder = new BlobBuilder();
	            for (var i = 0; i < parts.length; i += 1) {
	                builder.append(parts[i]);
	            }

	            return builder.getBlob(properties.type);
	        }
	    }
391149
function codecFactory(injected) {

/* eslint-disable indent */
const sha256 = injected.sha256;

class AddressCodec {
  /* eslint-enable indent */

  constructor(alphabet) {
    this.alphabet = alphabet;
    this.codec = baseCodec(alphabet);
    this.base = alphabet.length;
  }

  encode(bytes, opts = {}) {
    const {version} = opts;
    return isSet(version) ?
              this.encodeVersioned(bytes, version, opts.expectedLength) :
           opts.checked ?
              this.encodeChecked(bytes) :
              this.encodeRaw(bytes);
  }

  decode(string, opts = {}) {
    const {version, versions} = opts;
    return isSet(versions) ?
              this.decodeMultiVersioned(
                  string, versions, opts.expectedLength, opts.versionTypes) :
           isSet(version) ?
              this.decodeVersioned(string, version, opts.expectedLength) :
           opts.checked ?
              this.decodeChecked(string) :
              this.decodeRaw(string);
  }

  encodeRaw(bytes) {
    return this.codec.encode(bytes);
  }

  decodeRaw(string) {
    return this.codec.decode(string);
  }

  encodeChecked(buffer) {
    const check = sha256(sha256(buffer)).slice(0, 4);
    return this.encodeRaw(concatArgs(buffer, check));
  }

  decodeChecked(encoded) {
    const buf = this.decodeRaw(encoded);
    if (buf.length < 5) {
      throw new Error('invalid_input_size');
    }
    if (!this.verifyCheckSum(buf)) {
      throw new Error('checksum_invalid');
    }
    return buf.slice(0, -4);
  }

  encodeVersioned(bytes, version, expectedLength) {
    if (expectedLength && bytes.length !== expectedLength) {
      throw new Error('unexpected_payload_length');
    }
    return this.encodeChecked(concatArgs(version, bytes));
  }

  decodeVersioned(string, version, expectedLength) {
    return this.decodeMultiVersioned(string, [version], expectedLength).bytes;
  }

  /**
  * @param {String} encoded - base58 checksum encoded data string
  * @param {Array} possibleVersions - array of possible versions.
  *                                   Each element could be a single byte or an
  *                                   array of bytes.
  * @param {Number} [expectedLength] - of decoded bytes minus checksum
  *
  * @param {Array} [types] - parrallel array of names matching possibleVersions
  *
  * @return {Object} -
  */
  decodeMultiVersioned(encoded, possibleVersions, expectedLength, types) {
    const withoutSum = this.decodeChecked(encoded);
    const ret = {version: null, bytes: null};

    if (possibleVersions.length > 1 && !expectedLength) {
      throw new Error('must pass expectedLengthgth > 1 possibleVersions');
    }

    const versionLenGuess = possibleVersions[0].length || 1; // Number.length
    const payloadLength = expectedLength ||
                                (withoutSum.length - versionLenGuess);
    const versionBytes = withoutSum.slice(0, -payloadLength);
    const payload = withoutSum.slice(-payloadLength);

    const foundVersion = possibleVersions.some(function(version, i) {
      const asArray = Array.isArray(version) ? version : [version];
      if (seqEqual(versionBytes, asArray)) {
        ret.version = version;
        ret.bytes = payload;
        if (types) {
          ret.type = types[i];
        }
        return true;
      }
    });

    if (!foundVersion) {
      throw new Error('version_invalid');
    }
    if (expectedLength && ret.bytes.length !== expectedLength) {
      throw new Error('unexpected_payload_length');
    }

    return ret;
  }

  verifyCheckSum(bytes) {
    const computed = sha256(sha256(bytes.slice(0, -4))).slice(0, 4);
    const checksum = bytes.slice(-4);
    return seqEqual(computed, checksum);
  }

  /**
  * @param {String} desiredPrefix - desired prefix when base58 encoded with
  *                                 checksum
  * @param {Number} payloadLength - number of bytes encoded not incl checksum
  * @return {Array} version
  */
  findPrefix(desiredPrefix, payloadLength) {
    if (this.base !== 58) {
      throw new Error('Only works for base58');
    }
    const totalLength = payloadLength + 4; // for checksum
    const chars = (Math.log(Math.pow(256, totalLength)) / Math.log(this.base));
     // (x, x.8] -> x+1, (x.8, x+1) -> x+2
    const requiredChars = Math.ceil(chars + 0.2);
    const padding = this.alphabet[Math.floor((this.alphabet.length) / 2) - 1];
    const template = desiredPrefix + new Array(requiredChars + 1).join(padding);
    const bytes = this.decodeRaw(template);
    const version = bytes.slice(0, -totalLength);
    return version;
  }
}

/* eslint-disable indent */
return AddressCodec;
/* eslint-enable indent */
}
416862
function isObjectLiteralType(type) {
            return type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */)) !== 0 &&
                getSignaturesOfType(type, 0 /* Call */).length === 0 &&
                getSignaturesOfType(type, 1 /* Construct */).length === 0;
        }
654453
function factory() {
        var utilx = {};

        $forEach(objectKeys($), function (key1) {
            if (!pHasOwn.call(utilx, 'methods')) {
                defineProperty(utilx, 'methods', assign({
                    value: []
                }, propNotEnumerable));
            }

            defineProperty(utilx, key1, assign({
                value: $[key1]
            }, propNotEnumerable));

            if (isPlainObject($[key1])) {
                if (!pHasOwn.call(utilx[key1], 'methods')) {
                    defineProperty(utilx[key1], 'methods', assign({
                        value: []
                    }, propNotEnumerable));
                }

                $forEach(objectKeys($[key1]), function (key2) {
                    defineProperty(utilx[key1], key2, assign({
                        value: $[key1][key2]
                    }, propNotEnumerable));

                    if (isPlainObject($[key1][key2])) {
                        if (!pHasOwn.call(utilx[key1][key2], 'methods')) {
                            defineProperty(utilx[key1][key2], 'methods', assign({
                                value: []
                            }, propNotEnumerable));
                        }

                        $forEach(objectKeys($[key1][key2]), function (key3) {
                            defineProperty(utilx[key1][key2], key3, assign({
                                value: $[key1][key2][key3]
                            }, propNotEnumerable));

                            $push(utilx[key1][key2].methods, key3);
                        });
                    } else {
                        $push(utilx[key1].methods, key2);
                    }
                });
            } else {
                $push(utilx.methods, key1);
            }
        });

        defineProperties(utilx.Number, {
            POSITIVE_ZERO: propConstant,

            NEGATIVE_ZERO: propConstant,

            UNSAFE_INTEGER: propConstant,

            WORD8: propConstant,

            UWORD8: propConstant,

            WORD16: propConstant,

            UWORD16: propConstant,

            WORD32: propConstant,

            UWORD32: propConstant,

            MAX_UINT32: propConstant,

            MAX_INT32: propConstant,

            MIN_INT32: propConstant,

            MAX_UINT16: propConstant,

            MAX_INT16: propConstant,

            MIN_INT16: propConstant,

            MAX_UINT8: propConstant,

            MAX_INT8: propConstant,

            MIN_INT8: propConstant,

            MAX_SAFE_INTEGER: propConstant,

            MIN_SAFE_INTEGER: propConstant,

            MAX_VALUE: propConstant,

            MIN_VALUE: propConstant,

            EPSILON: propConstant,

            NaN: propConstant,

            POSITIVE_INFINITY: propConstant,

            NEGATIVE_INFINITY: propConstant
        });

        return utilx;
    }
1228278
function typeFactory(test) {
  return type

  function type(node) {
    return Boolean(node && node.type === test)
  }
}
50085
function parseType (props) {
  const {
    min,
    max,
    step,
    disabled,
    value,
    backgroundColor,
    activeColor,
    blockSize,
    blockColor,
    showValue,
    onChange,
    onChanging
  } = props

  // 抛出错误信息
  const throwErrorMsg = type => {
    throw new TypeError(type)
  }

  if (min) isNumber(min) ? '' : throwErrorMsg('min')
  if (max) isNumber(max) ? '' : throwErrorMsg('max')
  if (step) isNumber(step) ? '' : throwErrorMsg('step')
  if (value) isNumber(value) ? '' : throwErrorMsg('value')
  if (blockSize) isNumber(blockSize) ? '' : throwErrorMsg('blockSize')

  if (disabled) isBoolean(disabled) ? '' : throwErrorMsg('disabled')
  if (showValue) isBoolean(showValue) ? '' : throwErrorMsg('showValue')

  if (backgroundColor) {
    isString(backgroundColor) ? '' : throwErrorMsg('backgroundColor')
  }

  if (activeColor) isString(activeColor) ? '' : throwErrorMsg('activeColor')
  if (blockColor) isString(blockColor) ? '' : throwErrorMsg('blockColor')

  if (onChange) isFunction(onChange) ? '' : throwErrorMsg('onChange')
  if (onChanging) isFunction(onChanging) ? '' : throwErrorMsg('onChanging')
}
1000430
function checkType(type,value){
             if(type){
                 if(typeof type == 'string' && type != 'any' &&
                         (type == 'null' ? value !== null : typeof value != type) &&
                         !(value instanceof Array && type == 'array') &&
                         !(value instanceof Date && type == 'date') &&
                         !(type == 'integer' && value%1===0)){
                     return [{property:path,message:(typeof value) + " value found, but a " + type + " is required"}];
                 }
                 if(type instanceof Array){
                     var unionErrors=[];
                     for(var j = 0; j < type.length; j++){ // a union type
                         if(!(unionErrors=checkType(type[j],value)).length){
                             break;
                         }
                     }
                     if(unionErrors.length){
                         return unionErrors;
                     }
                 }else if(typeof type == 'object'){
                     var priorErrors = errors;
                     errors = [];
                     checkProp(value,type,path);
                     var theseErrors = errors;
                     errors = priorErrors;
                     return theseErrors;
                 }
             }
             return [];
         }
1018603
function _nestModelFactory (model, v) {
  let attrs = v.split('?')[0]

  if (/\?/.test(v)) {
    let args = v.split('?')[1]

    if (!model.where) {
      model.where = {}
    }
    args.split('&').forEach(arg => {
      let field, value

      [field, value] = arg.split('=')

      if (field === 'as') {
        model[field] = value
        return
      }
      if (arg !== 'required') {
        _queryField2where.call(this, model.where, field, value, model.model.name)
      }

    })

    args.includes('required') ? model.required = true : model.required = false
  }

  if (attrs === '$null') {
    model.attributes = []
  } else if (attrs.startsWith('$exclude:')) {
    attrs = attrs.replace('$exclude:', '').split(',')
    model.attributes = {exclude: attrs}
  } else if (attrs !== '$all') {
    model.attributes = attrs.split(',')
  } else if (model.attributes && model.attributes.length !== 0 && attrs === '$all') {
    delete model.attributes
  }
}
192230
function UnionType(schema, opts) {
  Type.call(this);

  if (!Array.isArray(schema)) {
    throw new Error(f('non-array union schema: %j', schema));
  }
  if (!schema.length) {
    throw new Error('empty union');
  }
  this.types = Object.freeze(schema.map(function (obj) {
    return Type.forSchema(obj, opts);
  }));

  this._branchIndices = {};
  this.types.forEach(function (type, i) {
    if (Type.isType(type, 'union')) {
      throw new Error('unions cannot be directly nested');
    }
    var branch = type.branchName;
    if (this._branchIndices[branch] !== undefined) {
      throw new Error(f('duplicate union branch name: %j', branch));
    }
    this._branchIndices[branch] = i;
  }, this);
}
659669
function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) {
            var members = ts.createMap();
            var hasComputedProperties = false;
            ts.forEach(pattern.elements, function (e) {
                var name = e.propertyName || e.name;
                if (isComputedNonLiteralName(name)) {
                    // do not include computed properties in the implied type
                    hasComputedProperties = true;
                    return;
                }
                var text = getTextOfPropertyName(name);
                var flags = 4 /* Property */ | 67108864 /* Transient */ | (e.initializer ? 536870912 /* Optional */ : 0);
                var symbol = createSymbol(flags, text);
                symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors);
                symbol.bindingElement = e;
                members[symbol.name] = symbol;
            });
            var result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined);
            if (includePatternInType) {
                result.pattern = pattern;
            }
            if (hasComputedProperties) {
                result.flags |= 536870912 /* ObjectLiteralPatternWithComputedProperties */;
            }
            return result;
        }
696543
function routeTypes(routeMap) {
	var typeSet = {};

	var keys = Object.keys(routeMap);
	for (var i = 0, len = keys.length; i < len; i++) {
		var route = routeMap[keys[i]];
		var type = routeType(route);
		typeSet[type] = true;
	}

	// Use RouteTypeFields ordering
	var typeList = [];
	var fields = Object.keys(RouteTypeFields);
	for (var i = 0, len = fields.length; i < len; i++) {
		var type = RouteTypeFields[fields[i]];
		if (typeSet[type]) {
			typeList.push(type)
		}
	}

	return typeList;
}