Concatenates the associative array in a pipe-delimited string
in the following form FIELD_TYPE_STRING|key|FIELD_TYPE_STRING|value.
Values are encoded as strings.

@param {Array} data an associative array
@return {String} the pipe-delimited string
@private
8718
function implodeData(data) {
	var dataArray = [], field;
	for(field in data) {
		dataArray.push(types.STRING);
		dataArray.push(encodeString(field));
		dataArray.push(types.STRING);
		dataArray.push(encodeString(data[field]));
	}
	return implodeArray(dataArray);
}
1131456
function encode(data) {
  $.checkArgument(data instanceof Array, 'Must be Array');
  var base32 = '';
  for (var i=0; i<data.length; i++) {
    var value = data[i];
    $.checkArgument(0 <= value && value < 32, 'Non-base32, value ' + value);
    base32 += CHARSET[value];
  }
  return base32;
}
483326
function createText(value, data) {
  const node = { object: 'text', data };
  const leaves = isArray(value) ? value : [{ text: value }];
  return { ...node, leaves };
}
326664
function fixdata(data) {
		var o = '',
			l = 0,
			w = 10240;
		for (; l < data.byteLength / w; ++l)
			o += String.fromCharCode.apply(null, new Uint8Array(data.slice(l * w, l * w + w)));
		o += String.fromCharCode.apply(null, new Uint8Array(data.slice(l * w)));
		return o;
	}
187168
function amf0cnvObject2Array(oData) {
    var buf = new Buffer(5);
    var o = amf0decObject(oData);
    var l = Object.keys(o).length;
    buf.writeUInt32BE(l,1);
    return Buffer.concat([buf,oData.slice(1)]);
}
357264
protected function encodeArrayValue($data, $delimeter = '|')
    {
        $newData = [];
        foreach ($data as $value) {
            if (is_array($value)) {
                $newData[] = 'Array';
            }
            else {
                $newData[] = str_replace($delimeter, '\\'.$delimeter, $value);
            }
        }

        return implode($delimeter, $newData);
    }
530598
function stringify(data){
		switch(typeof data){
			case 'string':
				return '"'+ data.replace(reg_rep, function(a){
					return rep[a];
				}) +'"';
			
			case 'object':
				if(data===null){return 'null'}
				var res = [], k, v;
				if(data instanceof Array){
					var l = data.length;
					for(k = 0; k < l; k++){
						v = stringify(data[k]);
						v===undef || res.push(v);
					}
					return '['+ res.join(',') +']';
				}else{
					for(k in data){
						if(data.hasOwnProperty(k) && k){
							v = stringify(data[k]);
							(jskw[k] || reg_d.test(k)) && (k = '"'+k+'"');
							v===undef || res.push(k +':'+ v);
						}
					}
					return '{'+ res.join(',') +'}';
				}

			case 'number':
				return isFinite(data) ? data.toString() : 'null';
			
			case 'undefined':
			case 'unknown':
				return;
			case 'function':
			case 'boolean':
			case 'regexp':
				return data.toString();
		}
	}
831293
function(data) {
      if (!data) {
        data = this.getContent();
      }
      return this.encoder.encryptAes(JSON.stringify(data), this.getSecret());
    }
146783
function addMultipartData (formData, data) {
    var key, arr, i;

    for (key in data) {
        if (data.hasOwnProperty(key) && key !== 'files') {
            if (data[key] instanceof Array) {
                arr = data[key];

                for (i = 0; i < arr.length; i += 1) {
                    formData.append(key + '[' + i + ']', exports.stringifyIfObject(arr[i]));
                }
            } else {
                formData.append(key, exports.stringifyIfObject(data[key]));
            }
        }
    }
}
312210
protected function _arrayToString($data)
    {
        $fields = array();
        foreach($data as $value)
        {
            //Implode array's
            if(is_array($value)) {
                $value = implode(',', $value);
            }

             // Escape the quote character within the field (e.g. " becomes "")
            if ($this->_quoteValue($value))
            {
                $quoted_value = str_replace($this->quote, $this->quote.$this->quote, $value);
                $fields[] 	  = $this->quote . $quoted_value . $this->quote;
            }
            else $fields[] = $value;
        }

        return  implode($this->separator, $fields);
    }
670158
function scriptToString(data) {
  var script = [];

  data.forEach(function dataEach(step) {
    var key, value;

    if (typeof step === 'string') {
      script.push(step);
    } else if (typeof step === 'object') {
      key = [Object.keys(step)[0]];
      value = step[key];
      if (value !== undefined && value !== null && value !== '') {
        key = key.concat(value);
      }
      script.push(key.join(TAB));
    }
  });

  return script.join(NEWLINE);
}
1170932
public boolean buildData(String[] data) {
        final int length = data.length;

        for (int i = 0; i < length; i++) {
            addAddressToList(data[i]);
        }

        return true;
    }
614292
function amf0encUString(s) {
    var data = new Buffer(s,'utf8');
    var sLen = new Buffer(2);
    sLen.writeUInt16BE(data.length,0);
    return Buffer.concat([sLen,data]);
}
759511
public static function arrayToString(array $data, $level = 1, $content = '', $assoc = false, $space = '    ')
    {
        $content   .= "[\n";
        $maxLength = 1;
        $index     = 0;
        $inAssoc = false;
        foreach($data as $key => $item){
            if($key !== $index){
                $inAssoc = true;
            }else{
                $index++;
            }
            $maxLength = max($maxLength, strlen($key));
        }

        $index = count($data);
        foreach($data as $key => $item){
            $index--;
            $content .= str_repeat($space, $level);
            if(!is_int($key) || $assoc || $inAssoc){
                if(is_int($key)){
                    $content .= "$key".str_repeat(' ', $maxLength - strlen($key) + 1)."=> ";
                }else{
                    $content .= "'$key'".str_repeat(' ', $maxLength - strlen($key) + 1)."=> ";
                }
            }
            if(is_array($item)){
                $content .= self::arrayToString($item, $level + 1, '', $assoc, $space);
            }elseif(is_null($item)){
                $content .= "null";
            }else{
                $content .= var_export($item, true);
            }
            $content .= ($index? ',': '')."\n";
        }
        $content .= str_repeat($space, $level - 1)."]";

        return $content;
    }
636023
function parseInputData(data) {
			var keyValRegExPattern = /[a-zA-Z]*:/g;
			var keys = data.match(keyValRegExPattern),
				values = data.split(keyValRegExPattern),
				parsedObject = {};

			// Pop the first blank one off the top
			values.shift();


			for(var i=values.length-1; i >=0; i--) {
				var value = values[i],
					key = keys[i];

				// Trim whitespace
				value = value.trim();

				// Trim any trailing commas
				if(value[value.length-1] === ",") {
					value = value.substring(0, value.length-1);
				}

				// Add to object and trim trailing : from key
				parsedObject[ key.substring(0,key.length-1) ] = value;
			}

			return parsedObject;

		}
471847
function ( arg ) {
		var result;

		if ( !arg ) {
			return;
		}

		arg = string.trim( arg );

		if ( arg.indexOf( "," ) === -1 ) {
			result = utility.dom( arg );
		}
		else {
			result = [];

			array.each( string.explode( arg ), function ( query ) {
				var obj = utility.dom( query );

				if ( obj instanceof Array ) {
					result = result.concat( obj );
				}
				else if ( obj ) {
					result.push( obj );
				}
			});
		}

		return result;
	}
86193
function __serializeArray(data, options=DEFAULT_OPTIONS) {
	let dataBuffers = [];
	// ignore undefined value
	for (let key in data) {
		let subData = data[key];
		let subType = __getType(subData, options);
		let subTypeBuffer = __serializeType(subType);
		let subDataBuffers = __serializeData(subType, subData, options);
		dataBuffers.push(subTypeBuffer, ...subDataBuffers);
	}
	let length = __getLengthByArrayBuffers(dataBuffers);
	let lengthData = new Uint32Array([length]);
	return [lengthData.buffer, ...dataBuffers];
}