Transform an object
@param  {Object}    type
@return {Object}    transformed object type
@private
500071
function transformObject (type) {
  const transformed = {}

  for (let key in type) {
    transformed[key] = transformType(type[key])
  }

  return transformed
}
1091209
function transform( obj ) {
	var keys;
	var out;
	var i;
	if ( !isObject( obj ) ) {
		throw new TypeError( 'invalid input argument. Must provide an object. Value: `' + obj + '`.' );
	}
	keys = getKeys( obj );
	out = new Array( keys.length );
	for ( i = 0; i < keys.length; i++ ) {
		out[ i ] = obj[ keys[i] ];
	}
	return out;
}
84382
function asObject(type) {
		var map = gui.Object.map(type, mapObject, type);
		return {
			$object: gui.Object.extend({
				$classname: type.$classname,
				$instanceid: type.$instanceid,
				$originalid: type.$originalid
			}, map)
		};
	}
849753
function retransformValueAST(root, customProperties, withoutProperty) {
	const nextCustomProperties = Object.assign({}, customProperties);

	delete nextCustomProperties[withoutProperty];

	return transformValueAST(root, nextCustomProperties);
}
657068
function transform(value) {
	if(typeof value === 'function') value = value()
  if(value instanceof Array) {
    var el = document.createDocumentFragment()
    value.map(item => el.appendChild(transform(item)))
    value = el
  } else if(typeof value === 'object') {
		if(typeof value.then === 'function') {
			var tmp = document.createTextNode('')
			value.then(function(data) {
				tmp.parentElement.replaceChild(transform(data), tmp)
			})
			value = tmp
		} else if(typeof value.on === 'function') {
			var tmp = document.createTextNode('')
			value.on('data', function(data) {
				// need to transform? Streams are only text?
				tmp.parentElement.insertBefore(document.createTextNode(data), tmp)
			})
			value = tmp
		}
	} else value = document.createTextNode(value)
	return value
}
193521
function processObjectType(object: GraphQLObjectType) {
  return reduce(
    object._typeConfig,
    (def, value, key) => {
      return setDef(
        def,
        key,
        value,
        [
          'description',
          'interfaces',
          'fields',
          'isTypeOf',
          'astNode',
          'onConflict',
        ],
        object,
      );
    },
    { type: 'Object' },
    true,
  );
}
1166601
function morph(object, newProperties) {
  for (let key in object) {
    delete object[key];
  }

  for (let key in newProperties) {
    object[key] = newProperties[key];
  }
}
336278
function ( obj, type ) {
		var target = obj.prototype || obj;

		utility.iterate( prototypes[type], function ( v, k ) {
			if ( !target[k] ) {
				utility.property( target, k, {value: v, configurable: true, writable: true} );
			}
		});

		return obj;
	}
661912
def transformations(self, type=None, failed=False):
        
        if failed not in ["all", False, True]:
            raise ValueError("{} is not a valid transmission failed".format(failed))

        if type is None:
            type = Transformation

        if failed == "all":
            return type.query.filter_by(node_id=self.id).all()
        else:
            return type.query.filter_by(node_id=self.id, failed=failed).all()
1336713
function transform(input, process = () => undefined, finish = () => undefined) {
  if (isStream(input)) {
    return transformRaw(input, {
      async transform(value, controller) {
        try {
          const result = await process(value);
          if (result !== undefined) controller.enqueue(result);
        } catch(e) {
          controller.error(e);
        }
      },
      async flush(controller) {
        try {
          const result = await finish();
          if (result !== undefined) controller.enqueue(result);
        } catch(e) {
          controller.error(e);
        }
      }
    });
  }
  const result1 = process(input);
  const result2 = finish();
  if (result1 !== undefined && result2 !== undefined) return concat([result1, result2]);
  return result1 !== undefined ? result1 : result2;
}
730530
function transform(transform, flush) {
  const stream = new Transform({ objectMode: true });
  stream._transform = transform;
  if (typeof flush === 'function') {
    stream._flush = flush;
  }
  return stream;
}
1298017
function getTransform(options) {
  if (typeof options === 'string' || options instanceof String) {
    return options
  }

  if (typeof options === 'object' && options.engine) {
    return options.engine
  }

  throw new Error('options.engine not found.')
}
1100714
function _transform(chunk, encoding, cb) {
  if(this.raw) {
    this.emit('data', chunk, encoding);
    return cb();
  }
  /* istanbul ignore if: optional dependency */
  if(this.reader) {
    var reply;
    this.reader.feed(chunk);
    try {
      while((reply = this.reader.get()) !== undefined) {
        if(reply && reply.constructor === Error) {
          this.emit("reply", reply, null);
        }else{
          this.emit("reply", null, reply);
        }
      }
    }catch(err) {
      this.emit("error", err);
    }
  }else{
    //console.dir('decoder: ' + chunk);
    //console.dir('decoder chunk byte: ' + String.fromCharCode(chunk[0]));
    if(chunk.length) {
      var type = this._type(chunk, true);
      if(type === undefined && !this._buffer.length) {
        return this._abort(
          new Error(
            'protocol error, got "'
            + String.fromCharCode(chunk[0]) + '" as reply type byte'));
      }
      this._buffer = Buffer.concat(
        [this._buffer, chunk], this._buffer.length + chunk.length);
      this._offset = 0;
      this._parse(this._buffer);
    }
  }
  cb();
}
518873
function typographyTransform({ className, f, lh, ...ownerProps }) {
  const type = classesFor({ f: normalizeFontSizes(f), 'lh-': lh });

  return R.merge(
    { className: cx([type, className]) },
    ownerProps,
  );
}
1081809
static BindTransform getUtilTransform(TypeName type) {
		String typeName = type.toString();

		// Integer.class.getCanonicalName().equals(typeName)
		if (Date.class.getCanonicalName().equals(typeName)) {
			return new DateBindTransform();
		}
		if (Locale.class.getCanonicalName().equals(typeName)) {
			return new LocaleBindTransform();
		}
		if (Currency.class.getCanonicalName().equals(typeName)) {
			return new CurrencyBindTransform();
		}
		if (Calendar.class.getCanonicalName().equals(typeName)) {
			return new CalendarBindTransform();
		}
		if (TimeZone.class.getCanonicalName().equals(typeName)) {
			return new TimeZoneBindTransform();
		}
		return null;
	}
1198165
function JSONTransform(options) {
  // allow use without new
  if (!(this instanceof JSONTransform)) {
    return new JSONTransform(options);
  }

  this.isFirst = true;

  if (options.objectMode !== true) {
    // assume that if they're not giving us objects, this will be an array of strings
    this.isArray = true;
  } else {
    // otherwise they either tell us, or we're assuming they want the smallest form of this data, which is an object.
    this.isArray = options.isArray || false;
  }

  this.options = options;
  this.keyProperty = options.keyProperty || 'key';
  this.valueProperty = options.valueProperty || 'value';

  // init Transform
  Transform.call(this, options);
}
1348228
public static <T extends GrayF<T>, W extends ImageInterleaved>
	DiscreteFourierTransform<T,W> createTransform( ImageDataType type ) {
		switch( type ) {
			case F32: return (DiscreteFourierTransform)createTransformF32();
			case F64: return (DiscreteFourierTransform)createTransformF64();
		}
		throw new IllegalArgumentException("Unsupported image type "+type);
	}