A Dictionary Type
@param {Object} obj (Optional) An initial object literal with values
191271
function Dictionary(obj) {
  /**
   * Validate Arguments
   */
  common.arg({ name: 'obj', value: obj, type: Object, required: false });

  /**
   * Variable Declarations
   */
  var self = this
    , innerDictionary = {};

  /**
   * On Item Added Event
   */
  this.onItemAdded = new Event();
  /**
   * On Item Removed Event
   */
  this.onItemRemoved = new Event();
  /**
   * On Item Changed Event
   */
  this.onItemChanged = new Event();

  /**
   * Number of obj in the dictionary
   * @returns {Number} Number of obj in the dictionary
   */
  this.count = 0;

  /**
   * Are there any obj in the dictionary
   * @returns {Boolean} True if there are obj else False
   */
  this.hasAny = false;

  /**
   * Get a value by key
   * @param {String} key The key of the value to get
   * @returns {Object} The value or undefined
   */
  this.get = function (key) {
    common.arg({ name: 'key', value: key, type: String, required: true });
    return innerDictionary[key];
  };

  /**
   * Convert dictionary into an object literal
   * @returns {Object} Object literal of the dictionary
   */
  this.toObject = function () {
    return objects.clone(innerDictionary);
  };

  /**
   * Loop over the dictionary
   * @param {Function} fn Pass in a function with the arguments value, key and
   * @returns {Dictionary} The dictionary itself
   */
  this.forEach = function (fn) {
    objects.forEach(innerDictionary, function (value, key, innerDict) {
      fn(value, key);
    });
    return self;
  };

  /**
   * Remove all the obj in the dictionary
   * @returns {Dictionary} The dictionary itself
   */
  this.clear = function () {
    self.forEach(function (item, key) {
      self.remove(key, item);
    });
    return self;
  };

  /**
   * Get all the keys
   * @returns {Array} An array with all the keys
   */
  this.getKeys = function () {
    return Object.keys(innerDictionary);
  };

  /**
   * Check if the dictionary contains a specific key
   * @param {String} key The key to check for
   * @returns {Boolean} True if the keys exists else False
   */
  this.containsKey = function (key) {
    common.arg({ name: 'key', value: key, type: String, required: true });
    return arrays.contains(self.getKeys(), key);
  };

  /**
   * Remove an item from the dictionary by using the key
   * @param {String} key The key to remove
   * @returns {Dictionary} The dictionary itself
   */
  this.remove = function (key) {
    common.arg({ name: 'key', value: key, type: String, required: true });

    var item;

    if (self.containsKey(key)) {
      item = self.get(key);

      delete innerDictionary[key];

      self.count -= 1;
      self.hasAny = self.count > 0;

      self.onItemRemoved.raise(item, key);
    }
    return self;
  };

  /**
   * Set a value of an existing key
   * @param {String} key The key of the value to set
   * @param {Object} value The value to set
   * @returns {Dictionary} The dictionary itself
   */
  this.set = function (key, value) {
    common.arg({ name: 'key', value: key, type: String, required: true });
    common.arg({ name: 'value', value: value, required: true });

    if (!self.containsKey(key)) {
      throw new common.Exception("Key '" + key + "' does not exist");
    }
    innerDictionary[key] = value;
    self.onItemChanged.raise(value, key);
    return self;
  };

  /**
   * Add a new key and value to the dictionary
   * @param {String} key The key to add
   * @param {Object} value The value to add
   * @returns {Dictionary} The dictionary itself
   */
  this.add = function (key, value) {
    common.arg({ name: 'key', value: key, type: String, required: true });
    common.arg({ name: 'value', value: value });
    if (self.containsKey(key)) {
      throw new common.Exception("Key '" + key + "' already exists");
    }
    innerDictionary[key] = value;
    self.count += 1;
    self.hasAny = true;
    self.onItemAdded.raise(value, key);
    return self;
  };

  /**
   * Add an object literal's keys and values
   * @param {Object} obj The value to add
   * @returns {Dictionary} The dictionary itself
   */
  this.addMany = function (obj) {
    common.arg({ name: 'obj', value: obj, type: Object, required: true });
    self.clear();
    objects.forEach(obj, function (item, key) {
      self.add(key, item);
    });
    return self;
  };

  if (obj) {
    self.addMany(obj);
  }
}
303127
function(obj) {
		if (arguments.length < 2) throw new Error('cannot call _.get() without specifying at least one key');

		for (var i = 1; i < arguments.length; i++) {
			if (obj === undefined || obj === null) return;

			obj = obj[arguments[i]];
		}

		return obj;
	}
736146
function(object) {
		var name, value, desc, obj = object,
			result = [];
		for (name in object) {
			// make sure that we don't poke any getter type properties...
			while (!(desc = Object.getOwnPropertyDescriptor(obj, name))) {
				obj = Object.getPrototypeOf(obj);
			}
			if (typeof desc.value === 'function') {
				value = object[name];
				if (gui.Type.isMethod(value)) {
					result.push(name);
				}
			}
		}
		return result;
	}
380805
function getType (obj) {
  var str = Object.prototype.toString.call(obj);
  if (natives[str]) return natives[str];
  if (obj === null) return 'null';
  if (obj === undefined) return 'undefined';
  if (obj === Object(obj)) return 'object';
  return typeof obj;
}
781361
function(obj) {
        var key, value;
        for (key in obj) {
            value = obj[key];
            if (_isFunction(value)) obj[key] = cat(value);
        }
        return obj;
    }
673809
function(obj, key, value, index) {
		// extract values after index position
		var temp = {};
		if (index === undefined) index = 0;

		var i = 0;
		for (var thisKey in obj) {
			if (i >= index) {
				temp[thisKey] = obj[thisKey];
				delete obj[thisKey];
			}
			i++;
		}

		// insert new key/value
		obj[key] = value;

		// return values back to obj
		for (thisKey in temp) {
			obj[thisKey] = temp[thisKey];
		}

		// done
		return obj;
	}
318159
function type(obj) {
	return obj === undefined ? 'undefined' :
		Object.prototype.toString.call(obj)
			.replace(/^\[object (.+)]$/, '$1')
			.toLowerCase();
}
661261
function(self, obj)
{
   self.stack = '';
   for(var key in obj)
   {
      self[key] = obj[key];
   }
}
204272
function objectToFunction(obj) {
  var match = {};
  for (var key in obj) {
    match[key] = typeof obj[key] === 'string'
      ? defaultToFunction(obj[key])
      : toFunction(obj[key]);
  }
  return function(val){
    if (typeof val !== 'object') return false;
    for (var key in match) {
      if (!(key in val)) return false;
      if (!match[key](val[key])) return false;
    }
    return true;
  };
}
261044
function toObject (obj, keyValuePair) {
        var _keyValuePair = slicedToArray(keyValuePair, 2),
            key = _keyValuePair[0],
            value = _keyValuePair[1];

        obj[key] = value;

        return obj;
    }
1291976
function(index, obj){
    // if obj is not an object just return it nothing to do
    if(typeof obj !== 'object'){
      return obj;
    }

    // if object already is an array return the value at given index
    if(typeof obj[index] !== 'undefined'){
      return obj[index];
    }

    return _.values(obj)[index];
  }
1000369
def _get_dict_default(obj, key):
    
    try:
        return obj[key]
    except Exception as f:
        pass

    try:
        if float(key) == round(float(key), 0):
            return obj[int(key)]
    except Exception as f:
        pass

    return NullType(obj, key)
532020
def object_to_dict(cls, obj):
        
        dict_obj = dict()
        if obj is not None:
            if type(obj) == list:
                dict_list = []
                for inst in obj:
                    dict_list.append(cls.object_to_dict(inst))
                dict_obj["list"] = dict_list

            elif not cls.is_primitive(obj):
                for key in obj.__dict__:
                    # is an object
                    if type(obj.__dict__[key]) == list:
                        dict_list = []
                        for inst in obj.__dict__[key]:
                            dict_list.append(cls.object_to_dict(inst))
                        dict_obj[key] = dict_list
                    elif not cls.is_primitive(obj.__dict__[key]):
                        temp_dict = cls.object_to_dict(obj.__dict__[key])
                        dict_obj[key] = temp_dict
                    else:
                        dict_obj[key] = obj.__dict__[key]
            elif cls.is_primitive(obj):
                return obj
        return dict_obj
1243148
function( obj, objType, stack ) {
				stack = stack || [];
				var res, parser, parserType,
					inStack = inArray( obj, stack );

				if ( inStack !== -1 ) {
					return "recursion(" + ( inStack - stack.length ) + ")";
				}

				objType = objType || this.typeOf( obj  );
				parser = this.parsers[ objType ];
				parserType = typeof parser;

				if ( parserType === "function" ) {
					stack.push( obj );
					res = parser.call( this, obj, stack );
					stack.pop();
					return res;
				}
				return ( parserType === "string" ) ? parser : this.parsers.error;
			}
445592
def _default(self, obj: object):
        
        return None if obj is JSGNull else obj.val if type(obj) is AnyType else \
            JSGObject._strip_nones(obj.__dict__) if isinstance(obj, JsonObj) \
            else cast(JSGString, obj).val if issubclass(type(obj), JSGString) else str(obj)
466538
function DictionaryItem(key, value) {
    this.key = ko.observable(key);
	this.options = [];
    if(value instanceof Array){
		this.options = value;
		value = value[0];
    }
    this.value = (typeof(value)==='function')? value : ko.observable(value);
}
867768
function map (obj) {
  var key, val, arr = []
  for (key in obj) {
    val = obj[key]
    if (Array.isArray(val))
      for (var i = 0; i < val.length; i++)
        arr.push([key, val[i]])
    else if (typeof val === 'object')
      for (var prop in val)
        arr.push([key + '[' + prop + ']', val[prop]])
    else
      arr.push([key, val])
  }
  return arr
}