Implementation of _.keyBy so old versions of lodash (<2.0.0) don't cause issues
543368
function keyBy(arr, fn){
        var result = {};
        arr.forEach(function(v){
            result[fn(v)] = v;
        });
        return result;
    }
161511
function(_data,_key,_map){
            if (_u._$isArray(_data)){
                _map[_key] = JSON.stringify(_data);
            }
        }
706093
function baseKeysIn(object) {
  if (!isObject_1(object)) {
    return _nativeKeysIn(object);
  }
  var isProto = _isPrototype(object),
      result = [];

  for (var key in object) {
    if (!(key == 'constructor' && (isProto || !hasOwnProperty$11.call(object, key)))) {
      result.push(key);
    }
  }
  return result;
}
1049419
function( jsonKeys, times, values, valuePropertyName ) {

		var i = 1, key = jsonKeys[ 0 ];

		while ( key !== undefined && key[ valuePropertyName ] === undefined ) {

			key = jsonKeys[ i ++ ];

		}

		if ( key === undefined ) return; // no data

		var value = key[ valuePropertyName ];
		if ( value === undefined ) return; // no data

		if ( Array.isArray( value ) ) {

			do {

				value = key[ valuePropertyName ];

				if ( value !== undefined ) {

					times.push( key.time );
					values.push.apply( values, value ); // push all elements

				}

				key = jsonKeys[ i ++ ];

			} while ( key !== undefined );

		} else if ( value.toArray !== undefined ) {
			// ...assume THREE.Math-ish

			do {

				value = key[ valuePropertyName ];

				if ( value !== undefined ) {

					times.push( key.time );
					value.toArray( values, values.length );

				}

				key = jsonKeys[ i ++ ];

			} while ( key !== undefined );

		} else {
			// otherwise push as-is

			do {

				value = key[ valuePropertyName ];

				if ( value !== undefined ) {

					times.push( key.time );
					values.push( value );

				}

				key = jsonKeys[ i ++ ];

			} while ( key !== undefined );

		}

	}
1038195
function keysIndexes(children, startIndex, endIndex) {
  var i, keys = Object.create(null), key;
  for (i = startIndex; i <= endIndex; ++i) {
    if (children[i]) {
      key = children[i].key;
      if (key !== undefined) {
        keys[key] = i;
      }
    }
  }
  return keys;
}
1234989
function getkey(key) {
        var parsedKey = Number(key);

        return (isNaN(parsedKey) || key.indexOf('.') !== -1)? key : parsedKey;
    }
896273
function keyCompare(arr) {
  if (!_.isArray(arr)) {
    throw new Error("Failed will processing expect array: " + util.inspect(arr))
  }

  var keyArr = []

  // keeps track of the various types of mixed objects.
  var typeLists = {}

  arr.forEach(function(elmnt) {
    // want to collect types and put certains types first.
    var typeName = getConstructorName(elmnt)
    if (!typeLists[typeName]) {
      typeLists[typeName] = []
    }
    if (_.isArray(elmnt)) {
      typeLists[typeName].push(keyCompare(elmnt))
    } else if (_.isObject(elmnt)) {
      // ensure obj is sorted underneath.
      var obj = deepInspect(elmnt)

      // populate set of keys by which to sort in the near future.
      // TODO: figure out how not to prune 'undefined'?
      var modObj = {}
      Object.keys(obj).forEach(function(key) {
        keyArr.push(key)
        modObj[key] = JSON.stringify(obj[key])
      })
      typeLists[typeName].push(modObj)
    } else {
      typeLists[typeName].push(elmnt)
    }
  })

  // Sorts parents based on children by looking the the string representation
  // of the children nodes.
  if (!_.isEmpty(keyArr)) {
    keyArr = _.unique(keyArr)
    sorty(createSortyOpts(keyArr.sort()), typeLists["Object"])

    // Need to undo stringify
    typeLists["Object"].forEach(function(elmnt) {
      Object.keys(elmnt).forEach(function(key) {
        elmnt[key] = JSON.parse(elmnt[key])
      })
    })
  }

  // Put it all back together.
  var resultList = []
  Object.keys(typeLists)
    .sort()
    .forEach(function(key) {
      var result = array_sort(typeLists[key])
      resultList = resultList.concat(result)
    })
  return resultList
}
1111626
function (key, obj) {
        'use strict';
        var keysArr = key.split('.'),
            lastKeyPart = keysArr.pop(),
            len = keysArr.length,
            i, k, objNext;
        for (i = 0; i < len; i += 1) {
            k = keysArr[i];
            objNext = obj[k];
            if (!isObj(objNext)) {
                objNext = obj[k] = {};
            }
            obj = objNext;
        }
        return {
            node: obj,
            key: lastKeyPart
        };
    }
1293442
function getKeys(container) {
  function arrayIndex(value, i) {
    return i;
  }
  if (typeof container === 'object') {
    return Array.isArray(container) ? container.map(arrayIndex) : Object.keys(container);
  } else {
    return [];
  }
}
26001
function shimKeys(object) {
      var keyIndex,
          index = -1,
          props = keysIn(object),
          length = props.length,
          objLength = length && object.length,
          maxIndex = objLength - 1,
          result = [];

      var allowIndexes = typeof objLength == 'number' && objLength > 0 &&
        (isArray(object) || (support.nonEnumArgs && isArguments(object)));

      while (++index < length) {
        var key = props[index];
        if ((allowIndexes && (keyIndex = +key, keyIndex > -1 && keyIndex <= maxIndex && keyIndex % 1 == 0)) ||
            hasOwnProperty.call(object, key)) {
          result.push(key);
        }
      }
      return result;
    }
677486
function hasKey (obj, keys) {
    let o = obj;
    keys.slice(0,-1).forEach(function (key) {
        o = (o[key] || {});
    });

    let key = keys[keys.length - 1];
    return key in o;
}
579406
function buildLoadKey (blueprintMeta, originalKey, json) {
  const keyParts = [
    blueprintMeta.namespace,
    originalKey
  ]

  if (json.version) {
    keyParts.push(json.version.replace('.', '_'))
  }

  return keyParts.join('_')
}
608794
function renameKey(obj, oldKey, newKey) {
    var retObject = {};
    var index, ptr;

    if (typeof obj != "object") {
        return retObject;
    }

    var oldKeyType = typeof oldKey;
    var newKeyType = typeof newKey;
    if (oldKeyType == "string"
        && newKeyType == "string") {
        for (index in obj) {
            if (obj.hasOwnProperty(index)) {
                if (index == oldKey) {
                    retObject[newKey] = obj[index];
                } else {
                    retObject[index] = obj[index];
                }
            }
        }
    } else if (oldKeyType == "object"
        && newKeyType == "object"
        && oldKey.hasOwnProperty("length")
        && newKey.hasOwnProperty("length")
        && oldKey.length <= newKey.length
        ) {
        for (index in obj) {
            if (obj.hasOwnProperty(index)) {
                ptr = oldKey.indexOf(index);
                if (ptr >= 0) {
                    retObject[newKey[ptr]] = obj[index];
                } else {
                    retObject[index] = obj[index];
                }
            }
        }
    }

    return retObject;
}
145373
function equalForKeys(a, b, keys) {
        if (!angular.isArray(keys) && angular.isObject(keys)) {
          keys = protoKeys(keys, ["$$keys", "$$values", "$$equals", "$$validates", "$$new", "$$parent"]);
        }
        if (!keys) {
          keys = [];
          for (var n in a) keys.push(n); // Used instead of Object.keys() for IE8 compatibility
        }

        for (var i = 0; i < keys.length; i++) {
          var k = keys[i];
          if (a[k] != b[k]) return false; // Not '===', values aren't necessarily normalized
        }
        return true;
      }
942778
function(obj, keys, caseSensitive /* default: false */) {
            var key, keyLower, newObj = {};

            if (!$.isArray(keys) || !keys.length) {
                return newObj;
            }

            for (var i = 0; i < keys.length; i++) {
                key = keys[i];
                if (obj.hasOwnProperty(key)) {
                    newObj[key] = obj[key];
                }

                if(caseSensitive === true) {
                    continue;
                }

                //when getting data-* attributes via $.data() it's converted to lowercase.
                //details: http://stackoverflow.com/questions/7602565/using-data-attributes-with-jquery
                //workaround is code below.
                keyLower = key.toLowerCase();
                if (obj.hasOwnProperty(keyLower)) {
                    newObj[key] = obj[keyLower];
                }
            }

            return newObj;
        }
788639
function validatePropertyKey(name, element, parentType) {
  if (!NUMERIC_PROPERTY_REGEX.test(name)) {
    return;
  }
  warnAndMonitorForKeyUse(
    'Child objects should have non-numeric keys so ordering is preserved.',
    element,
    parentType
  );
}
640093
function( version ) {

    var propName = (this.group ? this.group + '.' : '') + capitalDashCase( this._field )
    var keys = Object.keys( this )
    var params = []

    for( var i = 0; i < keys.length; i++ ) {
      if (keys[i] === 'group') continue
      params.push( capitalDashCase( keys[i] ) + '=' + this[ keys[i] ] )
    }

    return propName +
      ( params.length ? ';' + params.join( ';' ) : params ) + ':' +
      ( Array.isArray( this._data ) ? this._data.join( ';' ) : this._data )

  }