Clean trailing whitespace from .hx files.

Besides being ugly, this was messing up the markdown parsing for some
dox comments: http://api.haxe.org/Map.html

extra/clean-whitespace

@@ -0,0 +1,6 @@
+#!/bin/sh
+#
+# Remove trailing whitespace from Haxe files
+
+# Exclude generated js.html.* for now
+find  -path ./std/js/html -prune -o -name '*.hx' -print0 | xargs -0 perl -pi -e "s/[ \t]+$//"

std/Class.hx

@@ -21,7 +21,7 @@
  */
 /**
 	An abstract type that represents a Class.
-	
+
 	See `Type` for the Haxe Reflection API.
 **/
 @:coreType @:runtimeValue abstract Class<T> {

std/Date.hx

@@ -23,14 +23,14 @@
  /**
 	The Date class provides a basic structure for date and time related
 	information. Date instances can be created by
-	
+
 	- `new Date()` for a specific date,
 	- `Date.now()` to obtain information about the current time,
 	- `Date.fromTime()` with a given timestamp or
 	- `Date.fromString()` by parsing from a String.
-	
+
 	There is some extra functions available in the `DateTools` class.
-	
+
 	In the context of haxe dates, a timestamp is defined as the number of
 	milliseconds elapsed since 1st January 1970.
 **/
@@ -38,10 +38,10 @@ extern class Date
 {
 	/**
 		Creates a new date object from the given arguments.
-		
+
 		The behaviour of a Date instance is only consistent across platforms if
 		the the arguments describe a valid date.
-		
+
 		- month: 0 to 11
 		- day: 1 to 31
 		- hour: 0 to 23
@@ -111,11 +111,11 @@ extern class Date
 	/**
 		Returns a Date from a formated string `s`, with the following accepted
 		formats:
-		
+
 		- `"YYYY-MM-DD hh:mm:ss"`
 		- `"YYYY-MM-DD"`
 		- `"hh:mm:ss"`
-		
+
 		The first two formats are expressed in local time, the third in UTC
 		Epoch.
 	**/

std/DateTools.hx

@@ -23,7 +23,7 @@
 /**
 	The DateTools class contains some extra functionalities for handling `Date`
 	instances and timestamps.
-	
+
 	In the context of haxe dates, a timestamp is defined as the number of
 	milliseconds elapsed since 1st January 1970.
 **/
@@ -123,7 +123,7 @@ class DateTools {
 
 	/**
 		Returns the result of adding timestamp `t` to Date `d`.
-		
+
 		This is a convenience function for calling
 		`Date.fromTime(d.getTime() + t)`.
 	**/
@@ -135,7 +135,7 @@ class DateTools {
 
 	/**
 		Returns the number of days in the month of Date `d`.
-		
+
 		This method handles leap years.
 	**/
 	public static function getMonthDays( d : Date ) : Int {
@@ -199,7 +199,7 @@ class DateTools {
 	public static function make( o : { ms : Float, seconds : Int, minutes : Int, hours : Int, days : Int } ) {
 		return o.ms + 1000.0 * (o.seconds + 60.0 * (o.minutes + 60.0 * (o.hours + 24.0 * o.days)));
 	}
-	
+
 	#if (js || flash || php || cpp)
 	/**
 		Retrieve Unix timestamp value from Date components. Takes same argument sequence as the Date constructor.

std/EReg.hx

@@ -22,17 +22,17 @@
 
 /**
 	The EReg class represents regular expressions.
-	
+
 	While basic usage and patterns consistently work across platforms, some more
 	complex operations may yield different results. This is a necessary trade-
 	off to retain a certain level of performance.
-	
+
 	EReg instances can be created by calling the constructor, or with the
 	special syntax ~/pattern/modifier
-	
+
 	EReg instances maintain an internal state, which is affected by several of
 	its methods.
-	
+
 	A detailed explanation of the supported operations is available at
 	http://haxe.org/doc/cross/regexp
 **/
@@ -40,9 +40,9 @@ class EReg {
 
 	/**
 		Creates a new regular expression with pattern `r` and modifiers `opt`.
-		
+
 		This is equivalent to the shorthand syntax `~/r/opt`
-		
+
 		If `r` or `opt` are null, the result is unspecified.
 	**/
 	public function new( r : String, opt : String ) {
@@ -51,9 +51,9 @@ class EReg {
 
 	/**
 		Tells if `this` regular expression matches String `s`.
-		
+
 		This method modifies the internal state.
-		
+
 		If `s` is `null`, the result is unspecified.
 	**/
 	public function match( s : String ) : Bool {
@@ -62,13 +62,13 @@ class EReg {
 
 	/**
 		Returns the matched sub-group `n` of `this` EReg.
-		
+
 		This method should only be called after `this.match` or
 		`this.matchSub`, and then operates on the String of that operation.
-		
+
 		The index `n` corresponds to the n-th set of parentheses in the pattern
 		of `this` EReg. If no such sub-group exists, an exception is thrown.
-		
+
 		If `n` equals 0, the whole matched substring is returned.
 	**/
 	public function matched( n : Int ) : String {
@@ -77,13 +77,13 @@ class EReg {
 
 	/**
 		Returns the part to the left of the last matched substring.
-		
+
 		If the most recent call to `this.match` or `this.matchSub` did not
 		match anything, the result is unspecified.
-		
+
 		If the global g modifier was in place for the matching, only the
 		substring to the left of the leftmost match is returned.
-		
+
 		The result does not include the matched part.
 	**/
 	public function matchedLeft() : String {
@@ -92,13 +92,13 @@ class EReg {
 
 	/**
 		Returns the part to the right of the last matched substring.
-		
+
 		If the most recent call to `this.match` or `this.matchSub` did not
 		match anything, the result is unspecified.
-		
+
 		If the global g modifier was in place for the matching, only the
 		substring to the right of the leftmost match is returned.
-		
+
 		The result does not include the matched part.
 	**/
 	public function matchedRight() : String {
@@ -109,10 +109,10 @@ class EReg {
 		Returns the position and length of the last matched substring, within
 		the String which was last used as argument to `this.match` or
 		`this.matchSub`.
-		
+
 		If the most recent call to `this.match` or `this.matchSub` did not
 		match anything, the result is unspecified.
-		
+
 		If the global g modifier was in place for the matching, the position and
 		length of the leftmost substring is returned.
 	**/
@@ -122,13 +122,13 @@ class EReg {
 
 	/**
 		Tells if `this` regular expression matches a substring of String `s`.
-		
+
 		This function expects `pos` and `len` to describe a valid substring of
 		`s`, or else the result is unspecified. To get more robust behavior,
 		`this.match(s.substr(pos,len))` can be used instead.
-		
+
 		This method modifies the internal state.
-		
+
 		If `s` is null, the result is unspecified.
 	**/
 	public function matchSub( s : String, pos : Int, len : Int = 0):Bool {
@@ -137,20 +137,20 @@ class EReg {
 
 	/**
 		Splits String `s` at all substrings `this` EReg matches.
-		
+
 		If a match is found at the start of `s`, the result contains a leading
 		empty String "" entry.
-		
+
 		If a match is found at the end of `s`, the result contains a trailing
 		empty String "" entry.
-		
+
 		If two matching substrings appear next to each other, the result
 		contains the empty String "" between them.
-		
+
 		By default, this method splits `s` into two parts at the first matched
 		substring. If the global g modifier is in place, `s` is split at each
 		matched substring.
-		
+
 		If `s` is null, the result is unspecified.
 	**/
 	public function split( s : String ) : Array<String> {
@@ -159,16 +159,16 @@ class EReg {
 
 	/**
 		Replaces the first substring of `s` which `this` EReg matches with `by`.
-		
+
 		If `this` EReg does not match any substring, the result is `s`.
-		
+
 		By default, this method replaces only the first matched substring. If
 		the global g modifier is in place, all matched substrings are replaced.
-		
+
 		If `by` contains `$1` to `$9`, the digit corresponds to number of a
 		matched sub-group and its value is used instead. If no such sub-group
 		exists, the replacement is unspecified. The string `$$` becomes `$`.
-		
+
 		If `s` or `by` are null, the result is unspecified.
 	**/
 	public function replace( s : String, by : String ) : String {

std/Enum.hx

@@ -22,9 +22,9 @@
 
 /**
 	An abstract type that represents an Enum type.
-	
+
 	The corresponding enum instance type is `EnumValue`.
-	
+
 	See `Type` for the Haxe Reflection API.
 **/
 @:coreType @:runtimeValue abstract Enum<T> {

std/IntIterator.hx

@@ -22,10 +22,10 @@
 
  /**
 	IntIterator is used for implementing interval iterations.
-	
+
 	It is usually not used explicitly, but through it's special syntax:
 	`min...max`
-		
+
 	While it is possible to assign an instance of IntIterator to a variable or
 	field, it is worth noting that IntIterator does not reset after being used
 	in a for-loop. Subsequent uses of the same instance will then have no
@@ -38,7 +38,7 @@ class IntIterator {
 
 	/**
 		Iterates from `min` (inclusive) to `max` (exclusive).
-		
+
 		If `max <= min`, the iterator will not act as a countdown.
 	**/
 	public function new( min : Int, max : Int ) {
@@ -55,7 +55,7 @@ class IntIterator {
 
 	/**
 		Moves to the next item of the iterator.
-		
+
 		If this is called while hasNext() is false, the result is unspecified.
 	**/
 	public function next() {

std/List.hx

@@ -43,7 +43,7 @@ class List<T> {
 
 	/**
 		Adds element `item` at the end of `this` List.
-		
+
 		`this.length` increases by 1.
 	**/
 	public function add( item : T ) {
@@ -58,7 +58,7 @@ class List<T> {
 
 	/**
 		Adds element `item` at the beginning of `this` List.
-		
+
 		`this.length` increases by 1.
 	**/
 	public function push( item : T ) {
@@ -75,7 +75,7 @@ class List<T> {
 
 	/**
 		Returns the first element of `this` List, or null if no elements exist.
-		
+
 		This function does not modify `this` List.
 	**/
 	public function first() : Null<T> {
@@ -84,7 +84,7 @@ class List<T> {
 
 	/**
 		Returns the last element of `this` List, or null if no elements exist.
-		
+
 		This function does not modify `this` List.
 	**/
 	public function last() : Null<T> {
@@ -94,7 +94,7 @@ class List<T> {
 
 	/**
 		Returns the first element of `this` List, or null if no elements exist.
-		
+
 		The element is removed from `this` List.
 	**/
 	public function pop() : Null<T> {
@@ -117,7 +117,7 @@ class List<T> {
 
 	/**
 		Empties `this` List.
-		
+
 		This function does not traverse the elements, but simply sets the
 		internal references to null and `this.length` to 0.
 	**/
@@ -129,10 +129,10 @@ class List<T> {
 
 	/**
 		Removes the first occurence of `v` in `this` List.
-		
+
 		If `v` is found by checking standard equality, it is removed from `this`
 		List and the function returns true.
-		
+
 		Otherwise, false is returned.
 	**/
 	public function remove( v : T ) : Bool {
@@ -196,7 +196,7 @@ class List<T> {
 
 	/**
 		Returns a string representation of `this` List.
-		
+
 		The result is enclosed in { } with the individual elements being
 		separated by a comma.
 	**/

std/Map.hx

@@ -30,109 +30,109 @@ import haxe.ds.EnumValueMap;
  /**
 	Map allows key to value mapping for arbitrary value types, and many key
 	types.
-		
+
 	This is a multi-type abstract, it is instantiated as one of its
 	specialization types depending on its type parameters.
-	
+
 	A Map can be instantiated without explicit type parameters. Type inference
 	will then determine the type parameters from the usage.
-	
+
 	Maps can also be created with `key1 => value1, key2 => value2` syntax.
-	
+
 	Map is an abstract type, it is not available at runtime.
 **/
 @:multiType(K)
 abstract Map<K,V>(IMap<K,V> ) {
-	
+
 	/**
 		Creates a new Map.
-		
+
 		This becomes a constructor call to one of the specialization types in
 		the output. The rules for that are as follows:
-		
+
 		1. if K is a `String`, `haxe.ds.StringMap` is used
 		2. if K is an `Int`, `haxe.ds.IntMap` is used
 		3. if K is an `EnumValue`, `haxe.ds.EnumValueMap` is used
 		4. if K is any other class or structure, `haxe.ds.ObjectMap` is used
 		5. if K is any other type, it causes a compile-time error
-			
+
 		(Cpp) Map does not use weak keys on ObjectMap by default.
 	**/
 	public function new();
 
 	/**
 		Maps `key` to `value`.
-		
+
 		If `key` already has a mapping, the previous value disappears.
-		
+
 		If `key` is null, the result is unspecified.
 	**/
 	public inline function set(key:K, value:V) this.set(key, value);
-	
+
 	/**
 		Returns the current mapping of `key`.
-		
+
 		If no such mapping exists, null is returned.
-		
+
 		Note that a check like `map.get(key) == null` can hold for two reasons:
-		
+
 		1. the map has no mapping for `key`
 		2. the map has a mapping with a value of `null`
-		
+
 		If it is important to distinguish these cases, `exists()` should be
 		used.
-		
+
 		If `key` is null, the result is unspecified.
 	**/
 	@:arrayAccess public inline function get(key:K) return this.get(key);
-	
+
 	/**
 		Returns true if `key` has a mapping, false otherwise.
-		
+
 		If `key` is null, the result is unspecified.
 	**/
 	public inline function exists(key:K) return this.exists(key);
-	
+
 	/**
 		Removes the mapping of `key` and returns true if such a mapping existed,
 		false otherwise.
-		
+
 		If `key` is null, the result is unspecified.
 	**/
 	public inline function remove(key:K) return this.remove(key);
-	
+
 	/**
 		Returns an Iterator over the keys of `this` Map.
-		
+
 		The order of keys is undefined.
 	**/
 	public inline function keys():Iterator<K> {
 		return this.keys();
 	}
-	
+
 	/**
 		Returns an Iterator over the values of `this` Map.
-		
+
 		The order of values is undefined.
 	**/
 	public inline function iterator():Iterator<V> {
 		return this.iterator();
 	}
-	
+
 	/**
 		Returns a String representation of `this` Map.
-		
+
 		The exact representation depends on the platform and key-type.
 	**/
 	public inline function toString():String {
 		return this.toString();
 	}
-	
+
 	@:arrayAccess @:noCompletion public inline function arrayWrite(k:K, v:V):V {
 		this.set(k, v);
 		return v;
 	}
-	
+
 	@:to static inline function toStringMap(t:IMap<String,V>):StringMap<V> {
 		return new StringMap<V>();
 	}
@@ -140,7 +140,7 @@ abstract Map<K,V>(IMap<K,V> ) {
 	@:to static inline function toIntMap(t:IMap<Int,V>):IntMap<V> {
 		return new IntMap<V>();
 	}
-	
+
 	@:to static inline function toEnumValueMapMap<K:EnumValue>(t:IMap<K,V>):EnumValueMap<K,V> {
 		return new EnumValueMap<K, V>();
 	}
@@ -148,11 +148,11 @@ abstract Map<K,V>(IMap<K,V> ) {
 	@:to static inline function toObjectMap<K:{ }>(t:IMap<K,V>):ObjectMap<K,V> {
 		return new ObjectMap<K, V>();
 	}
-	
+
 	@:from static inline function fromStringMap<V>(map:StringMap<V>):Map< String, V > {
 		return map;
 	}
-	
+
 	@:from static inline function fromIntMap<V>(map:IntMap<V>):Map< Int, V > {
 		return map;
 	}

std/Reflect.hx

@@ -27,25 +27,25 @@ extern class Reflect {
 
 	/**
 		Tells if structure `o` has a field named `field`.
-		
+
 		This is only guaranteed to work for anonymous structures. Refer to
 		`Type.getInstanceFields` for a function supporting class instances.
-		
+
 		If `o` or `field` are null, the result is unspecified.
 	**/
 	public static function hasField( o : Dynamic, field : String ) : Bool;
 
 	/**
 		Returns the value of the field named `field` on object `o`.
-		
+
 		If `o` is not an object or has no field named `field`, the result is
 		null.
-		
+
 		If the field is defined as a property, its accessors are ignored. Refer
 		to `Reflect.getProperty` for a function supporting property accessors.
-		
+
 		If `field` is null, the result is unspecified.
-		
+
 		(As3) If used on a property field, the getter will be invoked. It is
 		not possible to obtain the value directly.
 	**/
@@ -53,24 +53,24 @@ extern class Reflect {
 
 	/**
 		Sets the field named `field` of object `o` to value `value`.
-		
+
 		If `o` has no field named `field`, this function is only guaranteed to
 		work for anonymous structures.
-		
+
 		If `o` or `field` are null, the result is unspecified.
-		
+
 		(As3) If used on a property field, the setter will be invoked. It is
-		not possible to set the value directly.		
+		not possible to set the value directly.
 	**/
 	public static function setField( o : Dynamic, field : String, value : Dynamic ) : Void;
 
 	/**
 		Returns the value of the field named `field` on object `o`, taking
 		property getter functions into account.
-		
+
 		If the field is not a property, this function behaves like
 		`Reflect.field`, but might be slower.
-		
+
 		If `o` or `field` are null, the result is unspecified.
 	**/
 	public static function getProperty( o : Dynamic, field : String ) : Dynamic;
@@ -78,10 +78,10 @@ extern class Reflect {
 	/**
 		Sets the field named `field` of object `o` to value `value`, taking
 		property setter functions into account.
-		
+
 		If the field is not a property, this function behaves like
 		`Reflect.setField`, but might be slower.
-		
+
 		If `field` is null, the result is unspecified.
 	**/
 	public static function setProperty( o : Dynamic, field : String, value : Dynamic ) : Void;
@@ -93,39 +93,39 @@ extern class Reflect {
 
 	/**
 		Returns the fields of structure `o`.
-		
+
 		This method is only guaranteed to work on anonymous structures. Refer to
 		`Type.getInstanceFields` for a function supporting class instances.
-		
+
 		If `o` is null, the result is unspecified.
 	**/
 	public static function fields( o : Dynamic ) : Array<String>;
 
 	/**
 		Returns true if `f` is a function, false otherwise.
-		
+
 		If `f` is null, the result is false.
 	**/
 	public static function isFunction( f : Dynamic ) : Bool;
 
 	/**
 		Compares `a` and `b`.
-		
+
 		If `a` is less than `b`, the result is negative. If `b` is less than
 		`a`, the result is positive. If `a` and `b` are equal, the result is 0.
-		
+
 		This function is only defined if `a` and `b` are of the same type.
-		
+
 		If that type is a function, the result is unspecified and
 		`Reflect.compareMethods` should be used instead.
-		
+
 		For all other types, the result is 0 if `a` and `b` are equal. If they
 		are not equal, the result depends on the type and is negative if:
-		
+
 		- Numeric types: a is less than b
 		- String: a is lexicographically less than b
 		- Other: unspecified
-		
+
 		If `a` and `b` are null, the result is 0. If only one of them is null,
 		the result is unspecified.
 	**/
@@ -133,9 +133,9 @@ extern class Reflect {
 
 	/**
 		Compares the functions `f1` and `f2`.
-		
+
 		If `f1` or `f2` are not functions, the result is unspecified.
-		
+
 		Otherwise the result is true if `f1` and the `f2` are physically equal,
 		false otherwise.
 	**/
@@ -143,42 +143,42 @@ extern class Reflect {
 
 	/**
 		Tells if `v` is an object.
-		
+
 		The result is true if `v` is one of the following:
-			
+
 		- class instance
 		- structure
 		- Class<T>
 		- Enum<T>
-			
+
 		Otherwise, including if `v` is null, the result is false.
 	**/
 	public static function isObject( v : Dynamic ) : Bool;
 
 	/**
 		Tells if `v` is an enum value.
-		
+
 		The result is true if `v` is of type EnumValue, i.e. an enum
 		constructor.
-		
+
 		Otherwise, including if `v` is null, the result is false.
 	**/
 	public static function isEnumValue( v : Dynamic ) : Bool;
-	
+
 	/**
 		Removes the field named `field` from structure `o`.
-		
+
 		This method is only guaranteed to work on anonymous structures.
-		
+
 		If `o` or `field` are null, the result is unspecified.
 	**/
 	public static function deleteField( o : Dynamic, field : String ) : Bool;
 
 	/**
 		Copies the fields of structure `o`.
-		
+
 		This is only guaranteed to work on anonymous structures.
-		
+
 		If `o` is null, the result is unspecified.
 	**/
 	public static function copy<T>( o : T ) : T;

std/Std.hx

@@ -32,20 +32,20 @@ extern class Std {
 		Tells if a value v is of the type t. Returns false if v or t are null.
 	**/
 	public static function is( v : Dynamic, t : Dynamic ) : Bool;
-	
+
 	/**
 		Checks if object `value` is an instance of class `c`.
-		
+
 		Compiles only if the class specified by `c` can be assigned to the type
 		of `value`.
-		
+
 		This method checks if a downcast is possible. That is, if the runtime
 		type of `value` is assignable to the class specified by `c`, `value` is
 		returned. Otherwise null is returned.
-		
+
 		This method is not guaranteed to work with interfaces or core types such
 		as String, Array and Date.
-		
+
 		If `value` is null, the result is null. If `c` is null, the result is
 		unspecified.
 	**/

std/StdTypes.hx

@@ -28,7 +28,7 @@
 
 /**
 	The standard Float type, this is a double-precision IEEE 64bit float.
-	
+
 	On static targets, null cannot be assigned to Float. If this is necessary,
 	`Null<Float>` can be used instead.
 **/
@@ -36,7 +36,7 @@
 
 /**
 	The standard Int type. Its precision depends on the platform.
-	
+
 	On static targets, null cannot be assigned to Int. If this is necessary,
 	`Null<Int>` can be used instead.
 **/
@@ -56,7 +56,7 @@ typedef Null<T> = T
 
 /**
 	The standard Boolean type, which can either be true or false.
-	
+
 	On static targets, null cannot be assigned to Bool. If this is necessary,
 	`Null<Bool>` can be used instead.
 **/
@@ -65,7 +65,7 @@ typedef Null<T> = T
 
 /**
 	Dynamic is a special type which is compatible with all other types.
-	
+
 	Use of Dynamic should be minimized as it prevents several compiler
 	checks and optimizations.
 **/
@@ -80,25 +80,25 @@ typedef Null<T> = T
 	custom iterators.
 **/
 typedef Iterator<T> = {
-	
+
 	/**
 		Returns false if the iteration is complete, true otherwise.
-		
+
 		Usually iteration is considered to be complete if all elements of the
 		underlying data structure were handled through calls to next(). However,
 		in custom iterators any logic may be used to determine the completion
 		state.
 	**/
 	function hasNext() : Bool;
-	
+
 	/**
 		Returns the current item of the Iterator and advances to the next one.
-		
+
 		This method is not required to check hasNext() first. A call to this
 		method while hasNext() is false yields unspecified behavior.
 	**/
 	function next() : T;
-	
+
 }
 
 /**

std/String.hx

@@ -21,12 +21,12 @@
  */
 /**
 	The basic String class.
-	
+
 	A haxe String is immutable, it is not possible to modify individual
 	characters. No method of this class changes the state of `this` String.
-	
+
 	Strings can be constructed using the string literal syntax "string value".
-	
+
 	String can be concatenated by using the + operator. If an operand is not a
 	String, it is passed through Std.string() first.
 **/
@@ -44,21 +44,21 @@ extern class String {
 
 	/**
 		Returns a String where all characters of `this` String are upper case.
-		
+
 		Affects the characters `a-z`. Other characters remain unchanged.
 	**/
 	function toUpperCase() : String;
 
 	/**
 		Returns a String where all characters of `this` String are lower case.
-		
+
 		Affects the characters `A-Z`. Other characters remain unchanged.
 	**/
 	function toLowerCase() : String;
 
 	/**
 		Returns the character at position `index` of `this` String.
-		
+
 		If `index` is negative or exceeds `this.length`, the empty String ""
 		is returned.
 	**/
@@ -66,9 +66,9 @@ extern class String {
 
 	/**
 		Returns the character code at position `index` of `this` String.
-		
+
 		If `index` is negative or exceeds `this.length`, null is returned.
-		
+
 		To obtain the character code of a single character, "x".code can be used
 		instead to inline the character code at compile time. Note that this
 		only works on String literals of length 1.
@@ -78,12 +78,12 @@ extern class String {
 	/**
 		Returns the position of the leftmost occurence of `str` within `this`
 		String.
-		
+
 		If `startIndex` is given, the search is performed within the substring
 		of `this` String starting from `startIndex`. Otherwise the search is
 		performed within `this` String. In either case, the returned position
 		is relative to the beginning of `this` String.
-		
+
 		If `str` cannot be found, -1 is returned.
 	**/
 	function indexOf( str : String, ?startIndex : Int ) : Int;
@@ -91,31 +91,31 @@ extern class String {
 	/**
 		Returns the position of the rightmost occurence of `str` within `this`
 		String.
-		
+
 		If `startIndex` is given, the search is performed within the substring
 		of `this` String from 0 to `startIndex`. Otherwise the search is
 		performed within `this` String. In either case, the returned position
 		is relative to the beginning of `this` String.
-		
+
 		If `str` cannot be found, -1 is returned.
 	**/
 	function lastIndexOf( str : String, ?startIndex : Int ) : Int;
 
 	/**
 		Splits `this` String at each occurence of `delimiter`.
-		
+
 		If `this` String is the empty String "", the result is not consistent
 		across targets and may either be `[]` (on Js, Cpp) or `[""]`.
-		
+
 		If `delimiter` is the empty String "", `this` String is split into an
 		Array of `this.length` elements, where the elements correspond to the
 		characters of `this` String.
-		
+
 		If `delimiter` is not found within `this` String, the result is an Array
 		with one element, which equals `this` String.
-		
+
 		If `delimiter` is null, the result is unspecified.
-		
+
 		Otherwise, `this` String is split into parts at each occurence of
 		`delimiter`. If `this` String starts (or ends) with [delimiter}, the
 		result Array contains a leading (or trailing) empty String "" element.
@@ -125,31 +125,31 @@ extern class String {
 
 	/**
 		Returns `len` characters of `this` String, starting at position `pos`.
-		
+
 		If `len` is omitted, all characters from position `pos` to the end of
 		`this` String are included.
-		
+
 		If `pos` is negative, its value is calculated from the end of `this`
 		String by `this.length + pos`. If this yields a negative value, 0 is
 		used instead.
-		
+
 		If the calculated position + `len` exceeds `this.length`, the characters
 		from that position to the end of `this` String are returned.
-		
+
 		If `len` is negative, the result is unspecified.
 	**/
 	function substr( pos : Int, ?len : Int ) : String;
 
 	/**
 		Returns the part of `this` String from `startIndex` to `endIndex`.
-		
+
 		If `startIndex` or `endIndex` are negative, 0 is used instead.
-		
+
 		If `startIndex` exceeds `endIndex`, they are swapped.
-		
+
 		If the (possibly swapped) `endIndex` is omitted or exceeds
 		`this.length`, `this.length` is used instead.
-		
+
 		If the (possibly swapped) `startIndex` exceeds `this.length`, the empty
 		String "" is returned.
 	**/
@@ -162,7 +162,7 @@ extern class String {
 
 	/**
 		Returns the String corresponding to the character code `code`.
-		
+
 		If `code` is negative or has another invalid value, the result is
 		unspecified.
 	**/

std/StringBuf.hx

@@ -22,10 +22,10 @@
 /**
 	A String buffer is an efficient way to build a big string by appending small
 	elements together.
-	
+
 	Its cross-platform implementation uses String concatenation internally, but
 	StringBuf may be optimized for different targets.
-	
+
 	Unlike String, an instance of StringBuf is not immutable in the sense that
 	it can be passed as argument to functions which modify it by appending more
 	values. However, the internal buffer cannot be modified.
@@ -33,7 +33,7 @@
 class StringBuf {
 
 	var b:String = "";
-	
+
 	/**
 		The length of `this` StringBuf in characters.
 	**/
@@ -41,7 +41,7 @@ class StringBuf {
 
 	/**
 		Creates a new StringBuf instance.
-		
+
 		This may involve initialization of the internal buffer.
 	**/
 	public function new() {}
@@ -52,11 +52,11 @@ class StringBuf {
 
 	/**
 		Appends the representation of `x` to `this` StringBuf.
-		
+
 		The exact representation of `x` may vary per platform. To get more
 		consistent behavior, this function should be called with
 		Std.string(x).
-		
+
 		If `x` is null, the String "null" is appended.
 	**/
 	public inline function add<T>( x : T ) : Void {
@@ -65,7 +65,7 @@ class StringBuf {
 
 	/**
 		Appends the character identified by `c` to `this` StringBuf.
-		
+
 		If `c` is negative or has another invalid value, the result is
 		unspecified.
 	**/
@@ -75,13 +75,13 @@ class StringBuf {
 
 	/**
 		Appends a substring of `s` to `this` StringBuf.
-		
+
 		This function expects `pos` and `len` to describe a valid substring of
 		`s`, or else the result is unspecified. To get more robust behavior,
 		`this.add(s.substr(pos,len))` can be used instead.
-		
+
 		If `s` or `pos` are null, the result is unspecified.
-		
+
 		If `len` is omitted or null, the substring ranges from `pos` to the end
 		of `s`.
 	**/
@@ -91,7 +91,7 @@ class StringBuf {
 
 	/**
 		Returns the content of `this` StringBuf as String.
-		
+
 		The buffer is not emptied by this operation.
 	**/
 	public inline function toString() : String {

std/StringTools.hx

@@ -84,13 +84,13 @@ class StringTools {
 		Escapes HTML special characters of the string `s`.
 
 		The following replacements are made:
-			
+
 		- `&` becomes `&amp`;
 		- `<` becomes `&lt`;
 		- `>` becomes `&gt`;
-		
+
 		If `quotes` is true, the following characters are also replaced:
-		
+
 		- `"` becomes `&quot`;
 		- `'` becomes `&#039`;
 	**/
@@ -106,7 +106,7 @@ class StringTools {
 		holds: htmlUnescape(htmlEscape(s)) == s
 
 		The replacements follow:
-			
+
 		- `&amp;` becomes `&`
 		- `&lt;` becomes `<`
 		- `&gt;` becomes `>`

std/Type.hx

@@ -36,7 +36,7 @@ enum ValueType {
 
 /**
 	The haxe Reflection API allows retrieval of type information at runtime.
-	
+
 	This class complements the more lightweight Reflect class, with a focus on
 	class and enum instances.
 **/
@@ -44,21 +44,21 @@ extern class Type {
 
 	/**
 		Returns the class of `o`, if `o` is a class instance.
-		
+
 		If `o` is null or of a different type, null is returned.
-		
+
 		In general, type parameter information cannot be obtained at runtime.
 	**/
 	public static function getClass<T>( o : T ) : Class<T>;
 
 	/**
 		Returns the enum of enum instance `o`.
-		
+
 		An enum instance is the result of using an enum constructor. Given an
 		`enum Color { Red; }`, `getEnum(Red)` returns `Enum<Color>`.
-		
+
 		If `o` is null, null is returned.
-		
+
 		In general, type parameter information cannot be obtained at runtime.
 	**/
 	public static function getEnum( o : EnumValue ) : Enum<Dynamic>;
@@ -66,11 +66,11 @@ extern class Type {
 
 	/**
 		Returns the super-class of class `c`.
-		
+
 		If `c` has no super class, null is returned.
-		
+
 		If `c` is null, the result is unspecified.
-		
+
 		In general, type parameter information cannot be obtained at runtime.
 	**/
 	public static function getSuperClass( c : Class<Dynamic> ) : Class<Dynamic>;
@@ -78,63 +78,63 @@ extern class Type {
 
 	/**
 		Returns the name of class `c`, including its path.
-		
+
 		If `c` is inside a package, the package structure is returned dot-
 		separated, with another dot separating the class name:
 		`pack1.pack2.(...).packN.ClassName`
 		If `c` is a sub-type of a haxe module, that module is not part of the
 		package structure.
-			
+
 		If `c` has no package, the class name is returned.
-		
+
 		If `c` is null, the result is unspecified.
-		
+
 		The class name does not include any type parameters.
 	**/
 	public static function getClassName( c : Class<Dynamic> ) : String;
 
 	/**
 		Returns the name of enum `e`, including its path.
-		
+
 		If `e` is inside a package, the package structure is returned dot-
 		separated, with another dot separating the enum name:
 		`pack1.pack2.(...).packN.EnumName`
 		If `e` is a sub-type of a haxe module, that module is not part of the
 		package structure.
-			
+
 		If `e` has no package, the enum name is returned.
-		
+
 		If `e` is null, the result is unspecified.
-		
+
 		The enum name does not include any type parameters.
 	**/
 	public static function getEnumName( e : Enum<Dynamic> ) : String;
 
 	/**
 		Resolves a class by name.
-		
+
 		If `name` is the path of an existing class, that class is returned.
-		
+
 		Otherwise null is returned.
-		
+
 		If `name` is null or the path to a different type, the result is
 		unspecified.
-		
+
 		The class name must not include any type parameters.
 	**/
 	public static function resolveClass( name : String ) : Class<Dynamic>;
 
 	/**
 		Resolves an enum by name.
-		
+
 		If `name` is the path of an existing enum, that enum is returned.
-		
+
 		Otherwise null is returned.
-		
+
 		If `name` is null the result is unspecified.
-		
+
 		If `name` is the path to a different type, null is returned.
-		
+
 		The enum name must not include any type parameters.
 	**/
 	public static function resolveEnum( name : String ) : Enum<Dynamic>;
@@ -142,27 +142,27 @@ extern class Type {
 	/**
 		Creates an instance of class `cl`, using `args` as arguments to the
 		class constructor.
-		
+
 		This function guarantees that the class constructor is called.
-		
+
 		Default values of constructors arguments are not guaranteed to be
 		taken into account.
-		
+
 		If `cl` or `args` are null, or if the number of elements in `args` does
 		not match the expected number of constructor arguments, or if any
 		argument has an invalid type,  or if `cl` has no own constructor, the
 		result is unspecified.
-		
+
 		In particular, default values of constructor arguments are not
 		guaranteed to be taken into account.
 	**/
 	public static function createInstance<T>( cl : Class<T>, args : Array<Dynamic> ) : T;
-	
+
 	/**
 		Creates an instance of class `cl`.
-		
+
 		This function guarantees that the class constructor is not called.
-		
+
 		If `cl` is null, the result is unspecified.
 	**/
 	public static function createEmptyInstance<T>( cl : Class<T> ) : T;
@@ -170,7 +170,7 @@ extern class Type {
 	/**
 		Creates an instance of enum `e` by calling its constructor `constr` with
 		arguments `params`.
-		
+
 		If `e` or `constr` is null, or if enum `e` has no constructor named
 		`constr`, or if the number of elements in `params` does not match the
 		expected number of constructor arguments, or if any argument has an
@@ -181,10 +181,10 @@ extern class Type {
 	/**
 		Creates an instance of enum `e` by calling its constructor number
 		`index` with arguments `params`.
-		
+
 		The constructor indices are preserved from haxe syntax, so the first
 		declared is index 0, the next index 1 etc.
-		
+
 		If `e` or `constr` is null, or if enum `e` has no constructor named
 		`constr`, or if the number of elements in `params` does not match the
 		expected number of constructor arguments, or if any argument has an
@@ -194,45 +194,45 @@ extern class Type {
 
 	/**
 		Returns a list of the instance fields of class `c`.
-		
+
 		This only includes fields which are known at compile-time. In
 		particular, using getInstanceFields(getClass(obj)) will not include
 		any fields which were added to obj at runtime.
-		
+
 		The order of the fields in the returned Array is unspecified.
-		
+
 		If `c` is null, the result is unspecified.
-		
+
 		(As3) This method only returns instance fields that are public.
 	**/
 	public static function getInstanceFields( c : Class<Dynamic> ) : Array<String>;
 
 	/**
 		Returns a list of static fields of class `c`.
-		
+
 		This does not include static fields of parent classes.
-		
+
 		The order of the fields in the returned Array is unspecified.
-		
+
 		If `c` is null, the result is unspecified.
-		
+
 		(As3) This method only returns class fields that are public.
 	**/
 	public static function getClassFields( c : Class<Dynamic> ) : Array<String>;
 
 	/**
 		Returns a list of the names of all constructors of enum `e`.
-		
+
 		The order of the constructor names in the returned Array is preserved
 		from the original syntax.
-		
+
 		If `c` is null, the result is unspecified.
 	**/
 	public static function getEnumConstructs( e : Enum<Dynamic> ) : Array<String>;
 
 	/**
 		Returns the runtime type of value `v`.
-		
+
 		The result corresponds to the type `v` has at runtime, which may vary
 		per platform. Assumptions regarding this should be minimized to avoid
 		surprises.
@@ -241,41 +241,41 @@ extern class Type {
 
 	/**
 		Recursively compares two enum instances `a` and `b` by value.
-		
+
 		Unlike `a == b`, this function performs a deep equality check on the
 		arguments of the constructors, if exists.
-		
+
 		If `a` or `b` are null, the result is unspecified.
 	**/
 	public static function enumEq<T:EnumValue>( a : T, b : T ) : Bool;
 
 	/**
 		Returns the constructor name of enum instance `e`.
-		
+
 		The result String does not contain any constructor arguments.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	public static function enumConstructor( e : EnumValue ) : String;
 
 	/**
 		Returns a list of the constructor arguments of enum instance `e`.
-		
+
 		If `e` has no arguments, the result is [].
-		
+
 		Otherwise the result are the values that were used as arguments to `e`,
 		in the order of their declaration.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	public static function enumParameters( e : EnumValue ) : Array<Dynamic>;
 
 	/**
 		Returns the index of enum instance `e`.
-		
+
 		This corresponds to the original syntactic position of `e`. The index of
 		the first declared constructor is 0, the next one is 1 etc.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	public static function enumIndex( e : EnumValue ) : Int;
@@ -283,14 +283,14 @@ extern class Type {
 	/**
 		Returns a list of all constructors of enum `e` that require no
 		arguments.
-		
+
 		This may return the empty Array [] if all constructors of `e` require
 		arguments.
-		
+
 		Otherwise an instance of `e` constructed through each of its non-
 		argument constructors is returned, in the order of the constructor
 		declaration.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	public static function allEnums<T>( e : Enum<T> ) : Array<T>;

std/UInt.hx

@@ -100,7 +100,7 @@ abstract UInt(Int) from Int to Int {
 	@:op(A % B) private static inline function mod(a:UInt, b:UInt):UInt {
 		return Std.int( a.toFloat() % b.toFloat() );
 	}
-	
+
 	@:commutative @:op(A + B) private static inline function addWithFloat(a:UInt, b:Float):Float {
 		return a.toFloat() + b;
 	}

std/cpp/_std/Reflect.hx

@@ -79,7 +79,7 @@
 		return t ==  __global__.vtObject || t==__global__.vtClass || t==__global__.vtString ||
 				t==__global__.vtArray;
 	}
-	
+
 	public static function isEnumValue( v : Dynamic ) : Bool untyped {
 		return v!=null && v.__GetType() == __global__.vtEnum;
 	}

std/cpp/vm/Debugger.hx

@@ -215,7 +215,7 @@ class Debugger
     {
         return untyped __global__.__hxcpp_dbg_getClasses();
     }
-    
+
     /**
      * Returns a ThreadInfo object describing every thread that existed at the
      * moment that the call was made, except for the debugger thread.
@@ -224,7 +224,7 @@ class Debugger
     {
         return untyped __global__.__hxcpp_dbg_getThreadInfos();
     }
-    
+
     /**
      * Returns a ThreadInfo object describing a single thread, or null if
      * there is no such thread or the thread queried about was the debugger
@@ -236,18 +236,18 @@ class Debugger
         return untyped __global__.__hxcpp_dbg_getThreadInfo
             (threadNumber, unsafe);
     }
-    
+
     /**
      * Adds a new file:line breakpoint.  The breakpoint number of the newly
      * added breakpoint is returned.
      **/
-    public static function addFileLineBreakpoint(file : String, 
+    public static function addFileLineBreakpoint(file : String,
                                                  line : Int) : Int
     {
         return untyped __global__.__hxcpp_dbg_addFileLineBreakpoint
             (file, line);
     }
-    
+
     /**
      * Adds a new class:function breakpoint.  The breakpoint number of the
      * newly added breakpoint is returned.
@@ -272,7 +272,7 @@ class Debugger
                 (cast (number, Int));
         }
     }
-    
+
     /**
      * Breaks all threads except the debugger thread (which should be the same
      * as the calling thread!).
@@ -285,7 +285,7 @@ class Debugger
     {
         untyped __global__.__hxcpp_dbg_breakNow(wait);
     }
-    
+
     /**
      * Continue execution of all stopped threads.  If specialThreadNumber
      * is a valid thread number, then it will be continued past
@@ -302,14 +302,14 @@ class Debugger
     /**
      * Single steps the given thread.
      **/
-    public static function stepThread(threadNumber : Int, 
+    public static function stepThread(threadNumber : Int,
                                       stepType : Int,
                                       stepCount : Int = 1)
     {
         untyped __global__.__hxcpp_dbg_stepThread
             (threadNumber, stepType, stepCount);
     }
-    
+
     /**
      * Returns the list of local variables (including "this", function
      * arguments, and local variables) visible to the given thread at the
@@ -336,7 +336,7 @@ class Debugger
      * requested value does not exist.  If the thread is actively running
      * and unsafe is not true, returns THREAD_NOT_STOPPED.
      **/
-    public static function getStackVariableValue(threadNumber : Int, 
+    public static function getStackVariableValue(threadNumber : Int,
                                                  stackFrameNumber : Int,
                                                  name : String,
                                                  unsafe : Bool) : Dynamic

std/cpp/vm/WeakRef.hx

@@ -36,16 +36,16 @@ class WeakRef<T>
       else
 			ref = untyped __global__.__hxcpp_weak_ref_create(inObject);
 	}
-	
-	
+
+
 	public function get():T
 	{
 		if (hardRef)
 			return ref;
-		
+
 		return  untyped __global__.__hxcpp_weak_ref_get(ref);
 	}
-	
+
 	public function set(inObject:T):T
 	{
 		if (hardRef)
@@ -54,7 +54,7 @@ class WeakRef<T>
 			ref = untyped __global__.__hxcpp_weak_ref_create(inObject);
 		return inObject;
 	}
-	
+
 	public function toString():String
 	{
 		return "WeakRef(" + get() + ")";

std/cs/Out.hx

@@ -22,9 +22,9 @@
 package cs;
 
 /**
-	This type represents "out" types for C# function parameters. 
+	This type represents "out" types for C# function parameters.
 	It only has effect on function parameters, and conversion to/from the referenced type is automatic.
-	
+
 	Note: Using this type should be considered a bad practice unless overriding a native function is needed.
 **/
 typedef Out<T> = T;

std/cs/Ref.hx

@@ -22,9 +22,9 @@
 package cs;
 
 /**
-	This type represents "ref" types for C# function parameters. 
+	This type represents "ref" types for C# function parameters.
 	It only has effect on function parameters, and conversion to/from the referenced type is automatic.
-	
+
 	Note: Using this type should be considered a bad practice unless overriding a native function is needed.
 **/
 typedef Ref<T> = T;

std/cs/StringBuilder.hx

@@ -23,15 +23,15 @@ package cs;
 
 //FIXME this class is here due to seemingly a bug in type resolution inside _std packages.
 //Once this bug is fixed, it will be moved back to the cs.system.text package
-@:native('System.Text.StringBuilder') extern class StringBuilder 
+@:native('System.Text.StringBuilder') extern class StringBuilder
 {
 	var Length(default,never):Int;
 
 	function new():Void;
-	
+
 	@:overload(function(char:cs.StdTypes.Char16):cs.StringBuilder {})
 	@:overload(function(str:String, startIndex:Int, len:Int):cs.StringBuilder {})
 	function Append(obj:Dynamic):StringBuilder;
-	
+
 	function ToString():String;
 }

std/cs/_std/sys/net/Host.hx

@@ -12,11 +12,11 @@ import haxe.io.BytesInput;
 /**
 	A given IP host name.
 **/
-@:coreapi 
+@:coreapi
 class Host {
 	public var hostEntry(default, null) : IPHostEntry;
 	public var ipAddress(default, null) : IPAddress;
-	
+
 	/**
 		The actual IP corresponding to the host.
 	**/
@@ -24,7 +24,7 @@ class Host {
 	private function get_ip() : Int {
 		return new BytesInput(Bytes.ofData( ipAddress.GetAddressBytes() )).readInt32();
 	}
-	
+
 	/**
 		Creates a new Host : the name can be an IP in the form "127.0.0.1" or an host name such as "google.com", in which case
 		the corresponding IP address is resolved using DNS. An exception occur if the host name could not be found.

std/cs/_std/sys/net/Socket.hx

@@ -17,10 +17,10 @@ import haxe.io.Output;
 /**
 	A TCP socket class : allow you to both connect to a given server and exchange messages or start your own server and wait for connections.
 **/
-@:coreapi 
+@:coreapi
 class Socket {
 	private var sock : cs.system.net.sockets.Socket = null;
-	
+
 	/**
 		The stream on which you can read available data. By default the stream is blocking until the requested data is available,
 		use [setBlocking(false)] or [setTimeout] to prevent infinite waiting.
@@ -156,14 +156,14 @@ class Socket {
 			Thread.Sleep(5);
 		}
 	}
-	
+
 	/**
 		Change the blocking mode of the socket. A blocking socket is the default behavior. A non-blocking socket will abort blocking operations immediatly by throwing a haxe.io.Error.Blocking value.
 	**/
 	public function setBlocking( b : Bool ) : Void {
 		sock.Blocking = b;
 	}
-	
+
 	/**
 		Allows the socket to immediatly send the data when written to its output : this will cause less ping but might increase the number of packets / data size, especially when doing a lot of small writes.
 	**/

std/cs/internal/FieldLookup.hx

@@ -22,12 +22,12 @@
 package cs.internal;
 
 @:native('haxe.lang.FieldLookup')
-@:keep @:static private class FieldLookup 
+@:keep @:static private class FieldLookup
 {
 
 	@:private private static var fieldIds:Array<Int>;
 	@:private private static var fields:Array<String>;
-	
+
 	//s cannot be null here
 	private static inline function doHash(s:String):Int
 	{
@@ -36,17 +36,17 @@ package cs.internal;
 		{
 			acc = (( 223 * (acc >> 1) + s.charCodeAt(i) ) << 1);
 		}
-		
+
 		return acc >>> 1; //always positive
 	}
-	
+
 	public static function lookupHash(key:Int):String
 	{
 		//start of binary search algorithm
 		var ids = fieldIds;
 		var min = 0;
 		var max = ids.length;
-		
+
 		while (min < max)
 		{
 			var mid = min + Std.int((max - min) / 2);
@@ -63,18 +63,18 @@ package cs.internal;
 		//if not found, it's definately an error
 		throw "Field not found for hash " + key;
 	}
-	
+
 	public static function hash(s:String):Int
 	{
 		if (s == null) return 0;
-		
+
 		var key = doHash(s);
-		
+
 		//start of binary search algorithm
 		var ids = fieldIds;
 		var min = 0;
 		var max = ids.length;
-		
+
 		while (min < max)
 		{
 			var mid = Std.int(min + (max - min) / 2); //overflow safe
@@ -96,12 +96,12 @@ package cs.internal;
 		fields.insert(min, s);
 		return key;
 	}
-	
+
 	public static function findHash(hash:Int, hashs:Array<Int>):Int
 	{
 		var min = 0;
 		var max = hashs.length;
-		
+
 		while (min < max)
 		{
 			var mid = Std.int((max + min) / 2); //overflow safe
@@ -118,5 +118,5 @@ package cs.internal;
 		//if not found, return a negative value of where it should be inserted
 		return ~min;
 	}
-	
+
 }

std/cs/internal/Iterator.hx

@@ -23,16 +23,16 @@ package cs.internal;
 
 @:keep @:native('haxe.lang.Iterator') interface Iterator<T>
 {
-	
+
 	public function hasNext():Bool;
-	
+
 	public function next():T;
-	
+
 }
 
 @:keep @:native('haxe.lang.Iterable') interface Iterable<T>
 {
-	
+
 	public function iterator():Iterator<T>;
-	
+
 }

std/cs/io/NativeInput.hx

@@ -29,22 +29,22 @@ import haxe.io.Input;
 class NativeInput extends Input
 {
 	public var canSeek(get_canSeek, null):Bool;
-	
+
 	var stream:cs.system.io.Stream;
 	public function new(stream)
 	{
 		this.stream = stream;
 		if (!stream.CanRead) throw "Write-only stream";
 	}
-	
-	override public function readByte():Int 
+
+	override public function readByte():Int
 	{
 		var ret = stream.ReadByte();
 		if (ret == -1) throw new Eof();
 		return ret;
 	}
-	
-	override public function readBytes(s:Bytes, pos:Int, len:Int):Int 
+
+	override public function readBytes(s:Bytes, pos:Int, len:Int):Int
 	{
 		if( pos < 0 || len < 0 || pos + len > s.length )
 			throw Error.OutsideBounds;
@@ -53,17 +53,17 @@ class NativeInput extends Input
 			throw new Eof();
 		return ret;
 	}
-	
+
 	override public function close():Void
 	{
 		stream.Close();
 	}
-	
+
 	private function get_canSeek():Bool
 	{
 		return stream.CanSeek;
 	}
-	
+
 	public function seek( p : Int, pos : sys.io.FileSeek ) : Void
 	{
 		var p = switch(pos)
@@ -72,15 +72,15 @@ class NativeInput extends Input
 			case SeekCur: cs.system.io.SeekOrigin.Current;
 			case SeekEnd: cs.system.io.SeekOrigin.End;
 		};
-		
+
 		stream.Seek(cast(p, Int64), p);
 	}
-	
+
 	public function tell() : Int
 	{
 		return cast(stream.Position, Int);
 	}
-	
+
 	public function eof() : Bool
 	{
 		return stream.Position == stream.Length;

std/flash/Lib.hx

@@ -73,7 +73,7 @@ class Lib {
 	public inline static function as<T>( v : Dynamic, c : Class<T> ) : Null<T> {
 		return untyped __as__(v,c);
 	}
-	
+
 	public static function redirectTraces() {
 		if (flash.external.ExternalInterface.available)
 			haxe.Log.trace = traceToConsole;

std/flash/_std/Reflect.hx

@@ -102,7 +102,7 @@
 		}
 		return (t == "string");
 	}
-	
+
 	public static function isEnumValue( v : Dynamic ) : Bool {
 		#if as3
 		return try Type.getEnum(v) != null catch ( e: Dynamic) false;

std/flash/_std/Xml.hx

@@ -384,7 +384,7 @@ extern enum XmlType {
 		if( nodeType != Xml.Element && nodeType != Xml.Document )
 			throw "bad nodeType";
 		if (x.parent != null)
-			x.parent.removeChild(x);			
+			x.parent.removeChild(x);
 		var children:XMLList = _node.children();
 		if( pos < children.length() )
 			_node.insertChildBefore(children[pos], x._node);

std/flash/_std/haxe/ds/ObjectMap.hx

@@ -6,7 +6,7 @@ class ObjectMap<K:{},V> extends flash.utils.Dictionary implements Map.IMap<K,V>
 	public function new() {
 		super(false);
 	}
-	
+
 	public inline function get( key : K ) : Null<V> {
 		return untyped this[key];
 	}
@@ -26,7 +26,7 @@ class ObjectMap<K:{},V> extends flash.utils.Dictionary implements Map.IMap<K,V>
 	}
 
 	#if as3
-	
+
  	public function keys() : Iterator<K> {
 		return untyped __keys__(this).iterator();
  	}
@@ -38,7 +38,7 @@ class ObjectMap<K:{},V> extends flash.utils.Dictionary implements Map.IMap<K,V>
 		return ret.iterator();
  	}
 	#else
-	
+
 	public function keys() : Iterator<K> {
 		return NativePropertyIterator.iterator(this);
 	}
@@ -46,7 +46,7 @@ class ObjectMap<K:{},V> extends flash.utils.Dictionary implements Map.IMap<K,V>
 	public function iterator() : Iterator<V> {
 		return NativeValueIterator.iterator(this);
 	}
-	
+
 	#end
 
 	public function toString() : String {

std/flash/_std/haxe/ds/WeakMap.hx

@@ -6,7 +6,7 @@ class WeakMap<K:{},V> extends flash.utils.Dictionary implements Map.IMap<K,V> {
 	public function new() {
 		super(true);
 	}
-	
+
 	public inline function get( key : K ) : Null<V> {
 		return untyped this[key];
 	}
@@ -26,7 +26,7 @@ class WeakMap<K:{},V> extends flash.utils.Dictionary implements Map.IMap<K,V> {
 	}
 
 	#if as3
-	
+
  	public function keys() : Iterator<K> {
 		return untyped __keys__(this).iterator();
  	}
@@ -38,7 +38,7 @@ class WeakMap<K:{},V> extends flash.utils.Dictionary implements Map.IMap<K,V> {
 		return ret.iterator();
  	}
 	#else
-	
+
 	public function keys() : Iterator<K> {
 		return NativePropertyIterator.iterator(this);
 	}
@@ -46,7 +46,7 @@ class WeakMap<K:{},V> extends flash.utils.Dictionary implements Map.IMap<K,V> {
 	public function iterator() : Iterator<V> {
 		return NativeValueIterator.iterator(this);
 	}
-	
+
 	#end
 
 	public function toString() : String {

std/flash/_std/haxe/zip/Compress.hx

@@ -38,7 +38,7 @@ class Compress {
 	public function close() : Void {
 	}
 
-	public static function run( s : haxe.io.Bytes, level : Int ) : haxe.io.Bytes {		
+	public static function run( s : haxe.io.Bytes, level : Int ) : haxe.io.Bytes {
 		if( s.length == 0 ) {
 			// Flash returns 0 bytes for 0 length compress (which can't be decoded on other platforms...)
 			var b = haxe.io.Bytes.alloc(8);

std/flash8/_std/Reflect.hx

@@ -92,7 +92,7 @@
 		var t = __typeof__(v);
 		return (t == "string" || (t == "object" && v.__enum__ == null) || (t == "function" && v.__name__ != null));
 	}
-	
+
 	public static function isEnumValue( v : Dynamic ) : Bool {
 		return v.__enum__ != null;
 	}

std/flash8/_std/Std.hx

@@ -29,7 +29,7 @@
 	public static function instance<T:{},S:T>( value : T, c : Class<S> ) : S {
 		return Std.is(value, c) ? cast value : null;
 	}
-	
+
 	public static function string( s : Dynamic ) : String {
 		return untyped flash.Boot.__string_rec(s,"");
 	}

std/flash8/_std/haxe/ds/ObjectMap.hx

@@ -24,38 +24,38 @@ package haxe.ds;
 
 @:coreApi
 class ObjectMap <K:{ }, V> implements Map.IMap<K,V> {
-	
+
 	static var count = 0;
-	
+
 	static inline function assignId(obj: { } ):Int {
 		return untyped obj.__id__ = ++count;
 	}
-	
+
 	static inline function getId(obj: { } ):Int {
 		return untyped obj.__id__;
 	}
-	
+
 	var h: { };
-	
+
 	public function new():Void {
 		h = untyped __new__(_global["Object"]);
 		untyped h.__keys__ = untyped __new__(_global["Object"]);
 	}
-	
+
 	public function set(key:K, value:V):Void untyped {
 		var id = "$" + (key.__id__ != null ? key.__id__ : assignId(key));
 		h[id] = value;
 		h.__keys__[id] = key;
 	}
-	
+
 	public inline function get(key:K):Null<V> {
 		return untyped h["$" +getId(key)];
 	}
-	
+
 	public inline function exists(key:K):Bool {
 		return untyped h["hasOwnProperty"]("$" +getId(key));
 	}
-	
+
 	public function remove( key : K ) : Bool {
 		var key = "$" + getId(key);
 		if( untyped !h["hasOwnProperty"](key) ) return false;
@@ -63,7 +63,7 @@ class ObjectMap <K:{ }, V> implements Map.IMap<K,V> {
 		untyped __delete__(h.__keys__,key);
 		return true;
 	}
-	
+
 	public function keys() : Iterator<K> {
 		var a = [];
 		untyped {
@@ -75,7 +75,7 @@ class ObjectMap <K:{ }, V> implements Map.IMap<K,V> {
 		}
 		return a.iterator();
 	}
-	
+
 	public function iterator() : Iterator<V> {
 		return untyped {
 			ref : h,
@@ -84,7 +84,7 @@ class ObjectMap <K:{ }, V> implements Map.IMap<K,V> {
 			next : function() { var i = __this__.it[__unprotect__("next")](); return __this__.ref["$" +i]; }
 		};
 	}
-	
+
 	public function toString() : String {
 		var s = new StringBuf();
 		s.add("{");

std/haxe/Constraints.hx

@@ -24,7 +24,7 @@ package haxe;
 
 /**
 	This type unifies with any function type.
-	
+
 	It is intended to be used as a type parameter constraint. If used as a real
 	type, the underlying type will be `Dynamic`.
 **/
@@ -33,7 +33,7 @@ abstract Function(Dynamic) { }
 /**
 	This type unifies with an enum instance if all constructors of the enum
 	require no arguments.
-	
+
 	It is intended to be used as a type parameter constraint. If used as a real
 	type, the underlying type will be `Dynamic`.
 **/

std/haxe/EnumFlags.hx

@@ -25,7 +25,7 @@ package haxe;
 	A typed interface for bit flags. This is not a real object, only a typed
 	interface for an actual Int. Each flag can be tested/set with the
 	corresponding enum instance. Up to 32 flags can be stored that way.
-	
+
 	Enum constructor indices are preserved from haxe syntax, so the first
 	declared is index 0, the next index 1 etc. The methods are optimized if the
 	enum instance is passed directly, e.g. as has(EnumCtor). Otherwise
@@ -42,10 +42,10 @@ abstract EnumFlags<T:EnumValue>(Int) {
 
 	/**
 		Checks if the index of enum instance `v` is set.
-		
+
 		This method is optimized if `v` is an enum instance expression such as
 		SomeEnum.SomeCtor.
-		
+
 		If `v` is null, the result is unspecified.
 	**/
 	public inline function has( v : T ) : Bool {
@@ -54,10 +54,10 @@ abstract EnumFlags<T:EnumValue>(Int) {
 
 	/**
 		Sets the index of enum instance `v`.
-		
+
 		This method is optimized if `v` is an enum instance expression such as
 		SomeEnum.SomeCtor.
-		
+
 		If `v` is null, the result is unspecified.
 	**/
 	public inline function set( v : T ) : Void {
@@ -66,10 +66,10 @@ abstract EnumFlags<T:EnumValue>(Int) {
 
 	/**
 		Unsets the index of enum instance `v`.
-		
+
 		This method is optimized if `v` is an enum instance expression such as
 		SomeEnum.SomeCtor.
-		
+
 		If `v` is null, the result is unspecified.
 	**/
 	public inline function unset( v : T ) : Void {

std/haxe/EnumTools.hx

@@ -25,27 +25,27 @@ package haxe;
 extern class EnumTools {
 	/**
 		Returns the name of enum `e`, including its path.
-		
+
 		If `e` is inside a package, the package structure is returned dot-
 		separated, with another dot separating the enum name:
 			pack1.pack2.(...).packN.EnumName
 		If `e` is a sub-type of a haxe module, that module is not part of the
 		package structure.
-			
+
 		If `e` has no package, the enum name is returned.
-		
+
 		If `e` is null, the result is unspecified.
-		
+
 		The enum name does not include any type parameters.
 	**/
 	static public inline function getName<T>(e:Enum<T>):String {
 		return Type.getEnumName(e);
 	}
-		
+
 	/**
 		Creates an instance of enum `e` by calling its constructor `constr` with
 		arguments `params`.
-		
+
 		If `e` or `constr` is null, or if enum `e` has no constructor named
 		`constr`, or if the number of elements in `params` does not match the
 		expected number of constructor arguments, or if any argument has an
@@ -54,14 +54,14 @@ extern class EnumTools {
 	static public inline function createByName<T>(e:Enum<T>, constr:String, ?params:Array<Dynamic>):T {
 		return Type.createEnum(e, constr, params);
 	}
-	
+
 	/**
 		Creates an instance of enum `e` by calling its constructor number
 		`index` with arguments `params`.
-		
+
 		The constructor indices are preserved from haxe syntax, so the first
 		declared is index 0, the next index 1 etc.
-		
+
 		If `e` or `constr` is null, or if enum `e` has no constructor named
 		`constr`, or if the number of elements in `params` does not match the
 		expected number of constructor arguments, or if any argument has an
@@ -70,30 +70,30 @@ extern class EnumTools {
 	static public inline function createByIndex<T>(e:Enum<T>, index:Int, ?params:Array<Dynamic>):T {
 		return Type.createEnumIndex(e, index, params);
 	}
-		
+
 	/**
 		Returns a list of all constructors of enum `e` that require no
 		arguments.
-		
+
 		This may return the empty Array [] if all constructors of `e` require
 		arguments.
-		
+
 		Otherwise an instance of `e` constructed through each of its non-
 		argument constructors is returned, in the order of the constructor
 		declaration.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	static public inline function createAll<T>(e:Enum<T>):Array<T> {
 		return Type.allEnums(e);
 	}
-		
+
 	/**
 		Returns a list of the names of all constructors of enum `e`.
-		
+
 		The order of the constructor names in the returned Array is preserved
 		from the original syntax.
-		
+
 		If `c` is null, the result is unspecified.
 	**/
 	static public inline function getConstructors<T>(e:Enum<T>):Array<String> {
@@ -102,50 +102,50 @@ extern class EnumTools {
 }
 
 extern class EnumValueTools {
-	
+
 	/**
 		Recursively compares two enum instances `a` and `b` by value.
-		
+
 		Unlike `a == b`, this function performs a deep equality check on the
 		arguments of the constructors, if exists.
-		
+
 		If `a` or `b` are null, the result is unspecified.
 	**/
 	static public inline function equals<T:EnumValue>(a:T, b:T):Bool {
 		return Type.enumEq(a, b);
 	}
-		
+
 	/**
 		Returns the constructor name of enum instance `e`.
-		
+
 		The result String does not contain any constructor arguments.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	static public inline function getName(e:EnumValue):String {
 		return Type.enumConstructor(e);
 	}
-		
+
 	/**
 		Returns a list of the constructor arguments of enum instance `e`.
-		
+
 		If `e` has no arguments, the result is [].
-		
+
 		Otherwise the result are the values that were used as arguments to `e`,
 		in the order of their declaration.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	static public inline function getParameters(e:EnumValue):Array<Dynamic> {
 		return Type.enumParameters(e);
 	}
-		
+
 	/**
 		Returns the index of enum instance `e`.
-		
+
 		This corresponds to the original syntactic position of `e`. The index of
 		the first declared constructor is 0, the next one is 1 etc.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	static public inline function getIndex(e:EnumValue):Int {

std/haxe/Http.hx

@@ -41,7 +41,7 @@ private typedef AbstractSocket = {
 /**
 	This class can be used to handle Http requests consistently across
 	platforms. There are two intended usages:
-	
+
 	- call haxe.Http.requestUrl(url) and receive the result as a String (not
 	available on flash)
 	- create a new haxe.Http(url), register your callbacks for onData, onError
@@ -89,7 +89,7 @@ class Http {
 		this.url = url;
 		headers = new List<{ header:String, value:String }>();
 		params = new List<{ param:String, value:String }>();
-		
+
 		#if js
 		async = true;
 		#elseif sys
@@ -117,7 +117,7 @@ class Http {
 		headers.push({ header:header, value:value });
 		return this;
 	}
-	
+
 	/**
 		Sets the parameter identified as `param` to value `value`.
 
@@ -135,7 +135,7 @@ class Http {
 		params.push({ param:param, value:value });
 		return this;
 	}
-	
+
 	#if !flash8
 	/**
 		Sets the post data of `this` Http request to `data`.
@@ -160,9 +160,9 @@ class Http {
 	#elseif flash9
 	var req:flash.net.URLLoader;
 	#end
-	
+
 	/**
-		Cancels `this` Http request if `request` has been called and a response 
+		Cancels `this` Http request if `request` has been called and a response
 		has not yet been received.
 	**/
 	public function cancel()

std/haxe/Int64.hx

@@ -21,7 +21,7 @@
  */
 package haxe;
 
-class Int64 { 
+class Int64 {
 
 	var high : Int;
 	var low : Int;
@@ -33,10 +33,10 @@ class Int64 {
 
 	#if php
 	/*
-		private function to correctly handle 32-bit integer overflow on php 
+		private function to correctly handle 32-bit integer overflow on php
 		see: http://stackoverflow.com/questions/300840/force-php-integer-overflow
 	*/
-	private static function i32php(value:Int):Int { 
+	private static function i32php(value:Int):Int {
 			value = (value & untyped __php__("0xFFFFFFFF"));
  		    if ( (value & untyped __php__("0x80000000"))!=0 )
 		        value = -(((~value) & untyped __php__("0xFFFFFFFF")) + 1);
@@ -48,7 +48,7 @@ class Int64 {
 		private function to correctly handle 32-bit ushr on php
 		see: https://github.com/HaxeFoundation/haxe/commit/1a878aa90708040a41b0dd59f518d83b09ede209
 	*/
-	private static inline function ushr32(v:Int,n:Int):Int { 
+	private static inline function ushr32(v:Int,n:Int):Int {
 		#if php
 		 	return (v >> n) & (untyped __php__("0x7fffffff") >> (n-1));
 		#else
@@ -60,7 +60,7 @@ class Int64 {
 		#if (js || flash8)
 			return i | 0;
 		#elseif php
-			return i32php(i); // handle overflow of 32-bit integers correctly 
+			return i32php(i); // handle overflow of 32-bit integers correctly
 		#else
 			return i;
 		#end
@@ -76,7 +76,7 @@ class Int64 {
 		return a * b;
 		#end
 	}
-	
+
 	#if as3 public #end function toString() {
 		if ((high|low) == 0 )
 			return "0";
@@ -90,15 +90,15 @@ class Int64 {
 		var ten = ofInt(10);
 		while( !isZero(i) ) {
 			var r = divMod(i, ten);
-			str = r.modulus.low + str; 
-			i = r.quotient; 
+			str = r.modulus.low + str;
+			i = r.quotient;
 		}
 		if( neg ) str = "-" + str;
 		return str;
 	}
 
 	public static inline function make( high : Int, low : Int ) : Int64 {
-		return new Int64(high, low); 
+		return new Int64(high, low);
 	}
 
 	public static inline function ofInt( x : Int ) : Int64 {
@@ -111,7 +111,7 @@ class Int64 {
 				return -toInt(neg(x));
 			throw "Overflow";
 		}
-		return x.low; 
+		return x.low;
 	}
 
 	public static function getLow( x : Int64 ) : Int {
@@ -140,8 +140,8 @@ class Int64 {
 
 	public static function mul( a : Int64, b : Int64 ) : Int64 {
 		var mask = 0xFFFF;
-		var al = a.low & mask, ah = ushr32(a.low , 16); 
-		var bl = b.low & mask, bh = ushr32(b.low , 16); 
+		var al = a.low & mask, ah = ushr32(a.low , 16);
+		var bl = b.low & mask, bh = ushr32(b.low , 16);
 		var p00 = al * bl;
 		var p10 = ah * bl;
 		var p01 = al * bh;
@@ -159,35 +159,35 @@ class Int64 {
 		var quotient = new Int64(0, 0);
 		var mask = new Int64(0, 1);
 		divisor = new Int64(divisor.high, divisor.low);
-		while( divisor.high >= 0 ) { 
+		while( divisor.high >= 0 ) {
 			var cmp = ucompare(divisor, modulus);
-			divisor.high = i32( i32(divisor.high << 1) | ushr32(divisor.low , 31) ); 
-			divisor.low = i32(divisor.low << 1); 
-			mask.high = i32( i32(mask.high << 1) | ushr32(mask.low , 31) ); 
+			divisor.high = i32( i32(divisor.high << 1) | ushr32(divisor.low , 31) );
+			divisor.low = i32(divisor.low << 1);
+			mask.high = i32( i32(mask.high << 1) | ushr32(mask.low , 31) );
 			mask.low = i32(mask.low << 1);
 			if( cmp >= 0 ) break;
 		}
-		while( i32(mask.low | mask.high) != 0 ) { 
+		while( i32(mask.low | mask.high) != 0 ) {
 			if( ucompare(modulus, divisor) >= 0 ) {
-				quotient.high= i32(quotient.high | mask.high); 
-				quotient.low= i32(quotient.low | mask.low); 
+				quotient.high= i32(quotient.high | mask.high);
+				quotient.low= i32(quotient.low | mask.low);
 				modulus = sub(modulus,divisor);
 			}
-			mask.low = i32( ushr32(mask.low , 1) | i32(mask.high << 31) ); 
-			mask.high = ushr32(mask.high , 1); 
+			mask.low = i32( ushr32(mask.low , 1) | i32(mask.high << 31) );
+			mask.high = ushr32(mask.high , 1);
 
-			divisor.low = i32( ushr32(divisor.low , 1) | i32(divisor.high << 31) ); 
-			divisor.high = ushr32(divisor.high , 1); 
+			divisor.low = i32( ushr32(divisor.low , 1) | i32(divisor.high << 31) );
+			divisor.high = ushr32(divisor.high , 1);
 		}
 		return { quotient : quotient, modulus : modulus };
 	}
 
-	public static function div( a : Int64, b : Int64 ) : Int64 { 
+	public static function div( a : Int64, b : Int64 ) : Int64 {
 		if(b.high==0) // handle special cases of 0 and 1
 			switch(b.low) {
 			case 0:	throw "divide by zero";
 			case 1: return new Int64(a.high,a.low);
-			} 
+			}
 		var sign = ((a.high<0) || (b.high<0)) && (!( (a.high<0) && (b.high<0))); // make sure we get the correct sign
 		if( a.high < 0 ) a = neg(a);
 		if( b.high < 0 ) b = neg(b);
@@ -233,8 +233,8 @@ class Int64 {
 	}
 
 	public static inline function neg( a : Int64 ) : Int64 {
-		var high = i32(~a.high); 
-		var low = i32(-a.low); 
+		var high = i32(~a.high);
+		var low = i32(-a.low);
 		if( low == 0 )
 			high++;
 		return new Int64(high,low);
@@ -253,7 +253,7 @@ class Int64 {
 	}
 
 	public static inline function compare( a : Int64, b : Int64 ) : Int {
-		var v = i32(a.high - b.high); 
+		var v = i32(a.high - b.high);
 		return if( v != 0 ) v else uicompare(a.low,b.low);
 	}
 

std/haxe/Log.hx

@@ -68,7 +68,7 @@ class Log {
 				untyped __call__('_hx_trace', v + extra, infos);
 			}
 			else
-				untyped __call__('_hx_trace', v, infos);		
+				untyped __call__('_hx_trace', v, infos);
 		#elseif cpp
 			if (infos!=null && infos.customParams!=null) {
 				var extra:String = "";

std/haxe/PosInfos.hx

@@ -24,11 +24,11 @@ package haxe;
 /**
 	PosInfos is a magic type which can be used to generate position information
 	into the output for debugging use.
-	
+
 	If a function has a final optional argument of this type, i.e.
 	(..., ?pos:haxe.PosInfos), each call to that function which does not assign
 	a value to that argument has its position added as call argument.
-	
+
 	This can be used to track positions of calls in e.g. a unit testing
 	framework.
 **/

std/haxe/Serializer.hx

@@ -26,7 +26,7 @@ package haxe;
 	from which the Unserializer class can recreate the original representation.
 
 	This class can be used in two ways:
-	
+
 	- create a new Serializer() instance, call its serialize() method with
 		any argument and finally retrieve the String representation from
 		toString()

std/haxe/Timer.hx

@@ -24,14 +24,14 @@ package haxe;
 /**
 	The Timer class allows you to create asynchronous timers on platforms that
 	support events.
-	
+
 	The intended usage is to create an instance of the Timer class with a given
 	interval, set its run() method to a custom function to be invoked and
 	eventually call stop() to stop the Timer.
 
-	Note that a running Timer may or may not prevent the program to exit 
+	Note that a running Timer may or may not prevent the program to exit
 	automatically when main() returns.
-	
+
 	It is also possible to extend this class and override its run() method in
 	the child class.
 **/
@@ -47,13 +47,13 @@ class Timer {
 
 	/**
 		Creates a new timer that will run every `time_ms` milliseconds.
-		
+
 		After creating the Timer instance, it calls `this].run` repeatedly,
 		with delays of `time_ms` milliseconds, until `this.stop` is called.
-		
+
 		The first invocation occurs after `time_ms` milliseconds, not
 		immediately.
-		
+
 		The accuracy of this may be platform-dependent.
 	**/
 	public function new( time_ms : Int ){
@@ -74,10 +74,10 @@ class Timer {
 
 	/**
 		Stops `this` Timer.
-		
+
 		After calling this method, no additional invocations of `this.run`
 		will occur.
-		
+
 		It is not possible to restart `this` Timer once stopped.
 	**/
 	public function stop() {
@@ -101,12 +101,12 @@ class Timer {
 
 	/**
 		This method is invoked repeatedly on `this` Timer.
-		
+
 		It can be overridden in a subclass, or rebound directly to a custom
 		function:
 			var timer = new haxe.Timer(1000); // 1000ms delay
 			timer.run = function() { ... }
-			
+
 		Once bound, it can still be rebound to different functions until `this`
 		Timer is stopped through a call to `this.stop`.
 	**/
@@ -116,11 +116,11 @@ class Timer {
 
 	/**
 		Invokes `f` after `time_ms` milliseconds.
-		
+
 		This is a convenience function for creating a new Timer instance with
 		`time_ms` as argument, binding its run() method to `f` and then stopping
 		`this` Timer upon the first invocation.
-		
+
 		If `f` is null, the result is unspecified.
 	**/
 	public static function delay( f : Void -> Void, time_ms : Int ) {
@@ -136,13 +136,13 @@ class Timer {
 
 	/**
 		Measures the time it takes to execute `f`, in seconds with fractions.
-		
+
 		This is a convenience function for calculating the difference between
 		Timer.stamp() before and after the invocation of `f`.
-		
+
 		The difference is passed as argument to Log.trace(), with "s" appended
 		to denote the unit. The optional `pos` argument is passed through.
-		
+
 		If `f` is null, the result is unspecified.
 	**/
 	public static function measure<T>( f : Void -> T, ?pos : PosInfos ) : T {
@@ -154,7 +154,7 @@ class Timer {
 
 	/**
 		Returns a timestamp, in seconds with fractions.
-		
+
 		The value itself might differ depending on platforms, only differences
 		between two values make sense.
 	**/

std/haxe/Ucs2.hx

@@ -40,10 +40,10 @@ abstract Ucs2(String) {
 	@:extern inline function get_length() {
 		return this.length;
 	}
-	
+
 	/**
 		Returns a Ucs2 where all characters of `this` Ucs2 are upper case.
-		
+
 		Affects the characters `a-z`. Other characters remain unchanged.
 	**/
 	@:extern public inline function toUpperCase() : Ucs2 {
@@ -52,7 +52,7 @@ abstract Ucs2(String) {
 
 	/**
 		Returns a Ucs2 where all characters of `this` Ucs2 are lower case.
-		
+
 		Affects the characters `A-Z`. Other characters remain unchanged.
 	**/
 	@:extern public inline function toLowerCase() : Ucs2 {
@@ -61,7 +61,7 @@ abstract Ucs2(String) {
 
 	/**
 		Returns the character at position `index` of `this` Ucs2.
-		
+
 		If `index` is negative or exceeds `this.length`, the empty Ucs2 ""
 		is returned.
 	**/
@@ -71,9 +71,9 @@ abstract Ucs2(String) {
 
 	/**
 		Returns the character code at position `index` of `this` Ucs2.
-		
+
 		If `index` is negative or exceeds `this.length`, null is returned.
-		
+
 		To obtain the character code of a single character, "x".code can be used
 		instead to @:extern public inline the character code at compile time. Note that this
 		only works on Ucs2 literals of length 1.
@@ -85,12 +85,12 @@ abstract Ucs2(String) {
 	/**
 		Returns the position of the leftmost occurence of `str` within `this`
 		Ucs2.
-		
+
 		If `startIndex` is given, the search is performed within the substring
 		of `this` Ucs2 starting from `startIndex`. Otherwise the search is
 		performed within `this` Ucs2. In either case, the returned position
 		is relative to the beginning of `this` Ucs2.
-		
+
 		If `str` cannot be found, -1 is returned.
 	**/
 	@:extern public inline function indexOf( str : Ucs2, ?startIndex : Int ) : Int {
@@ -100,12 +100,12 @@ abstract Ucs2(String) {
 	/**
 		Returns the position of the rightmost occurence of `str` within `this`
 		Ucs2.
-		
+
 		If `startIndex` is given, the search is performed within the substring
 		of `this` Ucs2 from 0 to `startIndex`. Otherwise the search is
 		performed within `this` Ucs2. In either case, the returned position
 		is relative to the beginning of `this` Ucs2.
-		
+
 		If `str` cannot be found, -1 is returned.
 	**/
 	@:extern public inline function lastIndexOf( str : Ucs2, ?startIndex : Int ) : Int {
@@ -114,19 +114,19 @@ abstract Ucs2(String) {
 
 	/**
 		Splits `this` Ucs2 at each occurence of `delimiter`.
-		
+
 		If `this` Ucs2 is the empty Ucs2 "", the result is not consistent
 		across targets and may either be `[]` (on Js, Cpp) or `[""]`.
-		
+
 		If `delimiter` is the empty Ucs2 "", `this` Ucs2 is split into an
 		Array of `this.length` elements, where the elements correspond to the
 		characters of `this` Ucs2.
-		
+
 		If `delimiter` is not found within `this` Ucs2, the result is an Array
 		with one element, which equals `this` Ucs2.
-		
+
 		If `delimiter` is null, the result is unspecified.
-		
+
 		Otherwise, `this` Ucs2 is split into parts at each occurence of
 		`delimiter`. If `this` Ucs2 starts (or ends) with [delimiter}, the
 		result Array contains a leading (or trailing) empty Ucs2 "" element.
@@ -138,17 +138,17 @@ abstract Ucs2(String) {
 
 	/**
 		Returns `len` characters of `this` Ucs2, starting at position `pos`.
-		
+
 		If `len` is omitted, all characters from position `pos` to the end of
 		`this` Ucs2 are included.
-		
+
 		If `pos` is negative, its value is calculated from the end of `this`
 		Ucs2 by `this.length + pos`. If this yields a negative value, 0 is
 		used instead.
-		
+
 		If the calculated position + `len` exceeds `this.length`, the characters
 		from that position to the end of `this` Ucs2 are returned.
-		
+
 		If `len` is negative, the result is unspecified.
 	**/
 	@:extern public inline function substr( pos : Int, ?len : Int ) : Ucs2 {
@@ -157,14 +157,14 @@ abstract Ucs2(String) {
 
 	/**
 		Returns the part of `this` Ucs2 from `startIndex` to `endIndex`.
-		
+
 		If `startIndex` or `endIndex` are negative, 0 is used instead.
-		
+
 		If `startIndex` exceeds `endIndex`, they are swapped.
-		
+
 		If the (possibly swapped) `endIndex` is omitted or exceeds
 		`this.length`, `this.length` is used instead.
-		
+
 		If the (possibly swapped) `startIndex` exceeds `this.length`, the empty
 		Ucs2 "" is returned.
 	**/
@@ -181,12 +181,12 @@ abstract Ucs2(String) {
 
 	/**
 		Returns the Ucs2 corresponding to the character code `code`.
-		
+
 		If `code` is negative or has another invalid value, the result is
 		unspecified.
 	**/
 	@:extern public static inline function fromCharCode( code : Int ) : Ucs2 {
 		return new Ucs2(String.fromCharCode(code));
 	}
-	
+
 }

std/haxe/Unserializer.hx

@@ -32,7 +32,7 @@ typedef TypeResolver = {
 	a serialization String and creates objects from the contained data.
 
 	This class can be used in two ways:
-	
+
 	- create a new Unserializer() instance with a given serialization
 		String, then call its unserialize() method until all values are
 		extracted
@@ -48,7 +48,7 @@ class Unserializer {
 		default, the haxe Type Api is used.
 
 		A type resolver must provide two methods:
-		
+
 		1. resolveClass(name:String):Class<Dynamic> is called to determine a
 				Class from a class name
 		2. resolveEnum(name:String):Enum<Dynamic> is called to determine an

std/haxe/crypto/Adler32.hx

@@ -53,7 +53,7 @@ class Adler32 {
 	public function toString() {
 		return StringTools.hex(a2,8) + StringTools.hex(a1,8);
 	}
-	
+
 	public static function read( i : haxe.io.Input ) {
 		var a = new Adler32();
 		var a2a = i.readByte();
@@ -70,6 +70,6 @@ class Adler32 {
 		a.update(b,0,b.length);
 		return a.get();
 	}
-	
+
 
 }

std/haxe/crypto/Base64.hx

@@ -28,7 +28,7 @@ class Base64 {
 
 	public static var CHARS(default,null) = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	public static var BYTES(default,null) = haxe.io.Bytes.ofString(CHARS);
-	
+
 	public static function encode( bytes : haxe.io.Bytes, complement = true ) : String {
 		var str = new BaseCode(BYTES).encodeBytes(bytes).toString();
 		if( complement )
@@ -36,7 +36,7 @@ class Base64 {
 				str += "=";
 		return str;
 	}
-	
+
 	public static function decode( str : String, complement = true ) : haxe.io.Bytes {
 		if( complement )
 			while( str.charCodeAt(str.length-1) == "=".code )

std/haxe/crypto/Crc32.hx

@@ -24,11 +24,11 @@ package haxe.crypto;
 class Crc32 {
 
 	var crc : Int;
-	
+
 	public function new() {
 		crc = 0xFFFFFFFF;
 	}
-	
+
 	public function byte( b : Int ) {
 		var tmp = (crc ^ b) & 0xFF;
 		for( j in 0...8 ) {
@@ -39,7 +39,7 @@ class Crc32 {
 		}
 		crc = (crc >>> 8) ^ tmp;
 	}
-	
+
 	public function update( b : haxe.io.Bytes, pos, len ) {
 		var b = b.getData();
 		for( i in pos...pos+len ) {
@@ -53,11 +53,11 @@ class Crc32 {
 			crc = (crc >>> 8) ^ tmp;
 		}
 	}
-	
+
 	public function get() {
 		return crc ^ 0xFFFFFFFF;
 	}
-	
+
 	/**
 		Calculates the CRC32 of the given data bytes
 	**/

std/haxe/ds/ArraySort.hx

@@ -28,22 +28,22 @@ package haxe.ds;
 	of equal elements has to be retained on all targets.
 **/
 class ArraySort {
-	
+
 	/**
 		Sorts Array `a` according to the comparison function `cmp`, where
 		`cmp(x,y)` returns 0 if `x == y`, a positive Int if `x > y` and a
 		negative Int if `x < y`.
-		
+
 		This operation modifies Array `a` in place.
-		
+
 		This operation is stable: The order of equal elements is preserved.
-		
+
 		If `a` or `cmp` are null, the result is unspecified.
 	**/
 	static public function sort<T>(a:Array<T>, cmp:T -> T -> Int) {
 		rec(a, cmp, 0, a.length);
 	}
-	
+
 	static function rec<T>(a:Array<T>, cmp, from, to) {
 		var middle = (from + to) >> 1;
 		if (to - from < 12) {
@@ -64,7 +64,7 @@ class ArraySort {
 		rec(a, cmp, middle, to);
 		doMerge(a, cmp, from, middle, to, middle - from, to - middle);
 	}
-	
+
 	static function doMerge<T>(a:Array<T>, cmp, from, pivot, to, len1, len2) {
 		var first_cut, second_cut, len11, len22, new_mid;
 		if (len1 == 0 || len2 == 0)
@@ -90,7 +90,7 @@ class ArraySort {
 		doMerge(a, cmp, from, first_cut, new_mid, len11, len22);
 		doMerge(a, cmp, new_mid, second_cut, to, len1 - len11, len2 - len22);
 	}
-	
+
 	static function rotate<T>(a:Array<T>, cmp, from, mid, to) {
 		var n;
 		if (from == mid || mid == to) return;
@@ -108,7 +108,7 @@ class ArraySort {
 			a[p1] = val;
 		}
 	}
-	
+
 	static function gcd(m, n) {
 		while (n != 0) {
 			var t = m % n;
@@ -117,7 +117,7 @@ class ArraySort {
 		}
 		return m;
 	}
-	
+
 	static function upper<T>(a:Array<T>, cmp, from, to, val) {
 		var len = to - from, half, mid;
 		while (len > 0) {
@@ -132,7 +132,7 @@ class ArraySort {
 		}
 		return from;
 	}
-	
+
 	static function lower<T>(a:Array<T>, cmp, from, to, val) {
 		var len = to - from, half, mid;
 		while (len > 0) {
@@ -146,13 +146,13 @@ class ArraySort {
 		}
 		return from;
 	}
-	
+
 	static function swap<T>(a:Array<T>, i, j) {
 		var tmp = a[i];
 		a[i] = a[j];
 		a[j] = tmp;
 	}
-	
+
 	static inline function compare<T>(a:Array<T>, cmp, i, j) {
 		return cmp(a[i], a[j]);
 	}

std/haxe/ds/BalancedTree.hx

@@ -26,36 +26,36 @@ package haxe.ds;
 	BalancedTree allows key-value mapping with arbitrary keys, as long as they
 	can be ordered. By default, `Reflect.compare` is used in the `compare`
 	method, which can be overridden in subclasses.
-	
+
 	Operations have a logarithmic average and worst-case cost.
-	
+
 	Iteration over keys and values, using `keys` and `iterator` respectively,
 	are in-order.
 **/
 class BalancedTree<K,V> {
 	var root:TreeNode<K,V>;
-	
+
 	/**
 		Creates a new BalancedTree, which is initially empty.
 	**/
 	public function new() { }
-	
+
 	/**
 		Binds `key` to `value`.
-		
+
 		If `key` is already bound to a value, that binding disappears.
-		
+
 		If `key` is null, the result is unspecified.
 	**/
 	public function set(key:K, value:V) {
 		root = setLoop(key, value, root);
 	}
-	
+
 	/**
 		Returns the value `key` is bound to.
-		
+
 		If `key` is not bound to any value, `null` is returned.
-		
+
 		If `key` is null, the result is unspecified.
 	**/
 	public function get(key:K):Null<V> {
@@ -68,15 +68,15 @@ class BalancedTree<K,V> {
 		}
 		return null;
 	}
-	
+
 	/**
 		Removes the current binding of `key`.
-		
+
 		If `key` has no binding, `this` BalancedTree is unchanged and false is
 		returned.
-		
+
 		Otherwise the binding of `key` is removed and true is returned.
-		
+
 		If `key` is null, the result is unspecified.
 	**/
 	public function remove(key:K) {
@@ -88,12 +88,12 @@ class BalancedTree<K,V> {
 			return false;
 		}
 	}
-	
+
 	/**
 		Tells if `key` is bound to a value.
-		
+
 		This method returns true even if `key` is bound to null.
-		
+
 		If `key` is null, the result is unspecified.
 	**/
 	public function exists(key:K) {
@@ -106,10 +106,10 @@ class BalancedTree<K,V> {
 		}
 		return false;
 	}
-	
+
 	/**
 		Iterates over the bound values of `this` BalancedTree.
-		
+
 		This operation is performed in-order.
 	**/
 	public function iterator():Iterator<V> {
@@ -117,10 +117,10 @@ class BalancedTree<K,V> {
 		iteratorLoop(root, ret);
 		return ret.iterator();
 	}
-	
+
 	/**
 		Iterates over the keys of `this` BalancedTree.
-		
+
 		This operation is performed in-order.
 	**/
 	public function keys():Iterator<K> {
@@ -128,7 +128,7 @@ class BalancedTree<K,V> {
 		keysLoop(root, ret);
 		return ret.iterator();
 	}
-	
+
 	function setLoop(k:K, v:V, node:TreeNode<K,V>) {
 		if (node == null) return new TreeNode<K,V>(null, k, v, null);
 		var c = compare(k, node.key);
@@ -141,7 +141,7 @@ class BalancedTree<K,V> {
 			balance(node.left, node.key, node.value, nr);
 		}
 	}
-		
+
 	function removeLoop(k:K, node:TreeNode<K,V>) {
 		if (node == null) throw "Not_found";
 		var c = compare(k, node.key);
@@ -149,7 +149,7 @@ class BalancedTree<K,V> {
 		else if (c < 0) balance(removeLoop(k, node.left), node.key, node.value, node.right);
 		else balance(node.left, node.key, node.value, removeLoop(k, node.right));
 	}
-	
+
 	function iteratorLoop(node:TreeNode<K,V>, acc:Array<V>) {
 		if (node != null) {
 			iteratorLoop(node.left, acc);
@@ -157,7 +157,7 @@ class BalancedTree<K,V> {
 			iteratorLoop(node.right, acc);
 		}
 	}
-	
+
 	function keysLoop(node:TreeNode<K,V>, acc:Array<K>) {
 		if (node != null) {
 			keysLoop(node.left, acc);
@@ -165,25 +165,25 @@ class BalancedTree<K,V> {
 			keysLoop(node.right, acc);
 		}
 	}
-	
+
 	function merge(t1, t2) {
 		if (t1 == null) return t2;
 		if (t2 == null) return t1;
 		var t = minBinding(t2);
 		return balance(t1, t.key, t.value, removeMinBinding(t2));
 	}
-	
+
 	function minBinding(t:TreeNode<K,V>) {
 		return if (t == null) throw "Not_found";
 		else if (t.left == null) t;
 		else minBinding(t.left);
 	}
-	
+
 	function removeMinBinding(t:TreeNode<K,V>) {
 		return if (t.left == null) t.right;
 		else balance(removeMinBinding(t.left), t.key, t.value, t.right);
 	}
-		
+
 	function balance(l:TreeNode<K,V>, k:K, v:V, r:TreeNode<K,V>):TreeNode<K,V> {
 		var hl = l.get_height();
 		var hr = r.get_height();
@@ -197,11 +197,11 @@ class BalancedTree<K,V> {
 			new TreeNode<K,V>(l, k, v, r, (hl > hr ? hl : hr) + 1);
 		}
 	}
-	
+
 	function compare(k1:K, k2:K) {
 		return Reflect.compare(k1, k2);
 	}
-	
+
 	public function toString() {
 		return '{${root.toString()}}';
 	}
@@ -216,7 +216,7 @@ class TreeNode<K,V> {
 	public
 	#end
 	var _height : Int;
-	
+
 	public function new(l, k, v, r, h = -1) {
 		left = l;
 		key = k;
@@ -227,9 +227,9 @@ class TreeNode<K,V> {
 		else
 			_height = h;
 	}
-	
+
 	@:extern public inline function get_height() return this == null ? 0 : _height;
-	
+
 	public function toString() {
 		return (left == null ? "" : left.toString() + ", ") + '$key=$value' + (right == null ? "" : ", " +right.toString());
 	}

std/haxe/ds/EnumValueMap.hx

@@ -24,12 +24,12 @@ package haxe.ds;
 
 /**
 	EnumValueMap allows mapping of enum value keys to arbitrary values.
-	
+
 	Keys are compared by value and recursively over their parameters. If any
 	parameter is not an enum value, `Reflect.compare` is used to compare them.
 **/
 class EnumValueMap<K:EnumValue, V> extends haxe.ds.BalancedTree<K, V> implements Map.IMap<K,V> {
-	
+
 	override function compare(k1:EnumValue, k2:EnumValue):Int {
 		var d = k1.getIndex() - k2.getIndex();
 		if (d != 0) return d;
@@ -38,7 +38,7 @@ class EnumValueMap<K:EnumValue, V> extends haxe.ds.BalancedTree<K, V> implements
 		if (p1.length == 0 && p2.length == 0) return 0;
 		return compareArgs(p1, p2);
 	}
-	
+
 	function compareArgs(a1:Array<Dynamic>, a2:Array<Dynamic>):Int {
 		var ld = a1.length - a2.length;
 		if (ld != 0) return ld;
@@ -48,7 +48,7 @@ class EnumValueMap<K:EnumValue, V> extends haxe.ds.BalancedTree<K, V> implements
 		}
 		return 0;
 	}
-	
+
 	function compareArg(v1:Dynamic, v2:Dynamic):Int {
 		return if (Reflect.isEnumValue(v1) && Reflect.isEnumValue(v2)) {
 			compare(v1, v2);

std/haxe/ds/GenericStack.hx

@@ -44,13 +44,13 @@ private class GenericStackIterator<T> extends cpp.FastIterator<T> {
 
 /**
 	A stack of elements.
-	
+
 	This class is generic, which means one type is generated for each type
 	parameter T on static targets. For example:
-		
+
 	- `new GenericStack<Int>()` generates `GenericStack_Int`
 	- `new GenericStack<String>()` generates `GenericStack_String`
-	
+
 	The generated name is an implementation detail and should not be relied
 	upon.
 **/
@@ -76,7 +76,7 @@ class GenericStack<T> {
 
 	/**
 		Returns the topmost stack element without removing it.
-		
+
 		If the stack is empty, null is returned.
 	**/
 	public inline function first() : Null<T> {
@@ -85,7 +85,7 @@ class GenericStack<T> {
 
 	/**
 		Returns the topmost stack element and removes it.
-		
+
 		If the stack is empty, null is returned.
 	**/
 	public inline function pop() : Null<T> {
@@ -108,10 +108,10 @@ class GenericStack<T> {
 	/**
 		Removes the first element which is equal to `v` according to the `==`
 		operator.
-		
+
 		This method traverses the stack until it finds a matching element and
 		unlinks it, returning true.
-		
+
 		If no matching element is found, false is returned.
 	**/
 	public function remove( v : T ) : Bool {

std/haxe/ds/IntMap.hx

@@ -23,7 +23,7 @@ package haxe.ds;
 
 /**
 	IntMap allows mapping of Int keys to arbitrary values.
-	
+
 	See `Map` for documentation details.
 **/
 extern class IntMap<T> implements Map.IMap<Int,T> {
@@ -37,7 +37,7 @@ extern class IntMap<T> implements Map.IMap<Int,T> {
 		See `Map.set`
 	**/
 	public function set( key : Int, value : T ) : Void;
-	
+
 	/**
 		See `Map.get`
 	**/

std/haxe/ds/ListSort.hx

@@ -29,15 +29,15 @@ package haxe.ds;
 class ListSort {
 
 	// Note : we prefer [inline] over [@:generic] here since we want to inline the comparison function as well
-	
+
 	/**
 		Sorts List `lst` according to the comparison function `cmp`, where
 		`cmp(x,y)` returns 0 if `x == y`, a positive Int if `x > y` and a
 		negative Int if `x < y`.
-		
+
 		This operation modifies List `a` in place and returns its head once modified.
 		The `prev` of the head is set to the tail of the sorted list.
-		
+
 		If `list` or `cmp` are null, the result is unspecified.
 	**/
 	public static inline function sort<T:{prev:T,next:T}>(list:T, cmp : T -> T -> Int) : T {
@@ -93,7 +93,7 @@ class ListSort {
 		return list;
 	}
 
-	
+
 	/**
 		Same as [sort] but on single linked list.
 	**/
@@ -146,5 +146,5 @@ class ListSort {
 		}
 		return list;
 	}
-	
+
 }

std/haxe/ds/ObjectMap.hx

@@ -24,51 +24,51 @@ package haxe.ds;
 
 /**
 	ObjectMap allows mapping of object keys to arbitrary values.
-	
+
 	On static targets, the keys are considered to be strong references. Refer
 	to `haxe.ds.WeakMap` for a weak reference version.
-	
+
 	See `Map` for documentation details.
 **/
 extern class ObjectMap < K: { }, V > implements Map.IMap<K,V> {
-	
+
 	/**
 		Creates a new ObjectMap.
 	**/
 	public function new():Void;
-	
+
 	/**
 		See `Map.set`
 	**/
 	public function set(key:K, value:V):Void;
-	
+
 	/**
 		See `Map.get`
-	**/	
+	**/
 	public function get(key:K):Null<V>;
-	
+
 	/**
 		See `Map.exists`
-	**/	
+	**/
 	public function exists(key:K):Bool;
-	
+
 	/**
 		See `Map.remove`
-	**/	
+	**/
 	public function remove(key:K):Bool;
-	
+
 	/**
 		See `Map.keys`
-	**/	
+	**/
 	public function keys():Iterator<K>;
-	
+
 	/**
 		See `Map.iterator`
-	**/	
+	**/
 	public function iterator():Iterator<V>;
-	
+
 	/**
 		See `Map.toString`
-	**/	
+	**/
 	public function toString():String;
 }

std/haxe/ds/StringMap.hx

@@ -24,7 +24,7 @@ package haxe.ds;
 
 /**
 	StringMap allows mapping of String keys to arbitrary values.
-	
+
 	See `Map` for documentation details.
 **/
 extern class StringMap<T> implements Map.IMap<String,T> {

std/haxe/ds/Vector.hx

@@ -43,7 +43,7 @@ abstract Vector<T>(VectorData<T>) {
 		Creates a new Vector of length `length`.
 
 		Initially `this` Vector contains `length` neutral elements:
-			
+
 		- always null on dynamic targets
 		- 0, 0.0 or false for Int, Float and Bool respectively on static targets
 		- null for other types on static targets
@@ -143,7 +143,7 @@ abstract Vector<T>(VectorData<T>) {
 			a[i] = get(i);
 		return a;
 	}
-		
+
 	/**
 		Extracts the data of `this` Vector.
 

std/haxe/ds/WeakMap.hx

@@ -24,64 +24,64 @@ package haxe.ds;
 
 /**
 	WeakMap allows mapping of object keys to arbitrary values.
-	
+
 	The keys are considered to be weak references on static targets.
-	
+
 	See `Map` for documentation details.
 **/
 class WeakMap<K: { },V> implements Map.IMap<K,V> {
-	
+
 	/**
 		Creates a new WeakMap.
-	**/	
+	**/
 	public function new():Void {
 		throw "Not implemented for this platform";
 	}
-	
+
 	/**
 		See `Map.set`
-	**/	
+	**/
 	public function set(key:K, value:V):Void {
 	}
-	
+
 	/**
 		See `Map.get`
-	**/		
+	**/
 	public function get(key:K):Null<V> {
 		return null;
 	}
-	
+
 	/**
 		See `Map.exists`
-	**/		
+	**/
 	public function exists(key:K):Bool {
 		return false;
 	}
-	
+
 	/**
 		See `Map.remove`
-	**/		
+	**/
 	public function remove(key:K):Bool {
 		return false;
 	}
-	
+
 	/**
 		See `Map.keys`
-	**/		
+	**/
 	public function keys():Iterator<K> {
 		return null;
 	}
-	
+
 	/**
 		See `Map.iterator`
-	**/		
+	**/
 	public function iterator():Iterator<V> {
 		return null;
 	}
-	
+
 	/**
 		See `Map.toString`
-	**/		
+	**/
 	public function toString():String {
 		return null;
 	}

std/haxe/format/JsonPrinter.hx

@@ -10,7 +10,7 @@ class JsonPrinter {
 
 	var buf : #if flash9 flash.utils.ByteArray #else StringBuf #end;
 	var replacer : Dynamic -> Dynamic -> Dynamic;
-	
+
 	function new(replacer:Dynamic -> Dynamic -> Dynamic) {
 		this.replacer = replacer;
 

std/haxe/io/Bytes.hx

@@ -95,7 +95,7 @@ class Bytes {
 			b1[i+pos] = b2[i+srcpos];
 		#end
 	}
-	
+
 	public function fill( pos : Int, len : Int, value : Int ) {
 		#if flash9
 		var v4 = value&0xFF;
@@ -103,7 +103,7 @@ class Bytes {
 		v4 |= v4<<16;
 		b.position = pos;
 		for( i in 0...len>>2 )
-			b.writeUnsignedInt(v4);		
+			b.writeUnsignedInt(v4);
 		pos += len&~3;
 		for( i in 0...len&3 )
 			set(pos++,value);

std/haxe/io/BytesInput.hx

@@ -28,7 +28,7 @@ class BytesInput extends Input {
 	var len : Int;
 	var totlen : Int;
 	#end
-	
+
 	/** The current position in the stream in bytes. */
 	public var position(get,set) : Int;
 
@@ -56,7 +56,7 @@ class BytesInput extends Input {
 		this.totlen = len;
 		#end
 	}
-	
+
 	inline function get_position() : Int {
 		#if flash9
 		return b.position;
@@ -72,7 +72,7 @@ class BytesInput extends Input {
 		return totlen;
 		#end
 	}
-	
+
 	function set_position( p : Int ) : Int {
 		if( p < 0 ) p = 0;
 		else if( p > length ) p = length;
@@ -83,7 +83,7 @@ class BytesInput extends Input {
 		return pos = p;
 		#end
 	}
-	
+
 	public override function readByte() : Int {
 		#if flash9
 			return try b.readUnsignedByte() catch( e : Dynamic ) throw new Eof();

std/haxe/macro/Compiler.hx

@@ -26,7 +26,7 @@ import haxe.macro.Expr;
 	All these methods can be called for compiler configuration macros.
 **/
 class Compiler {
-	
+
 	macro static public function getDefine( key : String ) {
 		return macro $v{haxe.macro.Context.definedValue(key)};
 	}
@@ -39,7 +39,7 @@ class Compiler {
 	public static function allowPackage( v : String ) {
 		untyped load("allow_package", 1)(v.__s);
 	}
-	
+
 	public static function define( flag : String, ?value : String ) untyped {
 		var v = flag + (value == null ? "" : "= " + value);
 		load("define", 1)(v.__s);
@@ -233,7 +233,7 @@ class Compiler {
 
 	/**
 		Mark a class (or array of classes) with the metadata @:keep.
-		
+
 		Note that this does not imply inclusion of the class(es): If a class is
 		neither referenced nor added via [Compiler.include], it will not be part
 		of the output even if @:keep was added.

std/haxe/macro/ComplexTypeTools.hx

@@ -30,25 +30,25 @@ import haxe.macro.Expr;
 	additional methods on haxe.macro.Expr.ComplexType instances.
 **/
 class ComplexTypeTools {
-	
+
 	/**
 		Converts type [c] to a human-readable String representation.
-		
+
 		The result is guaranteed to be valid haxe code, but there may be
 		differences from the original lexical syntax.
 	**/
 	static public function toString( c : ComplexType ) : String
 		return new Printer().printComplexType(c);
-		
+
 	#if macro
-	
+
 	/**
 		Returns a type corresponding to [c].
-		
+
 		If [c] is null, the result is null.
 	**/
 	static public function toType( c : ComplexType ) : Null<Type>
 		return c == null ? null : haxe.macro.Context.typeof( { expr: ECheckType(macro null, c), pos: Context.currentPos() } );
-		
+
 	#end
 }

std/haxe/macro/ExprTools.hx

@@ -211,7 +211,7 @@ class ExprTools {
 
 	/**
 		Returns the value `e` represents.
-		
+
 		Supported expressions are:
 			- `Int`, `Float` and `String` literals
 			- identifiers `true`, `false` and `null`
@@ -219,12 +219,12 @@ class ExprTools {
 			- array declarations if all their elements are values
 			- unary operators `-`, `!` and `~` if the operand is a value
 			- binary operators except `=>`, `...` and assignments
-			
+
 		Parentheses, metadata and the `untyped` keyword are ignored.
-		
+
 		If any non-value is encountered, an exception of type `String` is
 		thrown.
-		
+
 		If `e` is null, the result is unspecified.
 	**/
 	static public function getValue(e:Expr):Dynamic {
@@ -279,7 +279,7 @@ class ExprTools {
 			case _: throw 'Unsupported expression: $e';
 		}
 	}
-	
+
 	static inline function opt(e:Null<Expr>, f : Expr -> Expr):Expr
 		return e == null ? null : f(e);
 

std/haxe/macro/MacroStringTools.hx

@@ -30,62 +30,62 @@ import haxe.macro.Expr;
 **/
 class MacroStringTools {
 	#if macro
-	
-	
+
+
 	/**
 		Formats `String` `s` using the usual interpolation rules.
-		
+
 		The returned expression is a concatenation of string parts and escaped
 		elements.
 	**/
 	static public function formatString(s:String, pos:Position) {
 		return Context.load("format_string", 2)(untyped s.__s, pos);
 	}
-	
+
 	/**
 		Tells if `e` is a format string, i.e. uses single quotes `'` as
 		delimiters.
-		
+
 		This operation depends on the position of `e`.
 	**/
 	static public function isFormatExpr(e:ExprOf<String>) {
 		return Context.load("is_fmt_string", 1)(e.pos);
 	}
-	
+
 	/**
 		Converts an array of Strings `sl` to a field expression.
-		
+
 		If `sl` has no elements, the result is null.
-		
+
 		If `sl` has one element, the result is `EConst(CIdent(sl[0])`.
-		
+
 		Otherwise the result is a chain of `EField` nodes.
-		
+
 		If `sl` is null, the result is unspecified.
 	**/
 	static public function toFieldExpr(sl:Array<String>):Expr {
 		return Lambda.fold(sl, function(s, e) return e == null ? (macro $i{s}) : (macro $e.$s), null);
 	}
-	
+
 	/**
 		Converts a path given by package `pack` and name `name` to a `String`
 		separated by dots.
-		
+
 		If `pack` has no elements, the result is `name`.
-		
+
 		If `pack` is null, the result is unspecified.
-		
+
 		Otherwise the elements of `pack` are joined with a separating dot, with
 		an appended dot separating the result from `name`.
 	**/
 	static public function toDotPath(pack:Array<String>, name:String):String {
 		return if (pack.length == 0) name else pack.join(".") + "." +name;
 	}
-	
+
 	static public function toComplex( path : String ) : ComplexType {
 		var pack = path.split(".");
 		return TPath( { pack : pack, name : pack.pop(), params : [] } );
 	}
-	
+
 	#end
 }

std/haxe/macro/Printer.hx

@@ -115,7 +115,7 @@ class Printer {
 		case ADynamic: "dynamic";
 		case AMacro: "macro";
 	}
-	
+
 	public function printField(field:Field) return
 		(field.doc != null && field.doc != "" ? "/**\n" + tabs + tabString + StringTools.replace(field.doc, "\n", "\n" + tabs + tabString) + "\n" + tabs + "**/\n" + tabs : "")
 		+ (field.meta != null && field.meta.length > 0 ? field.meta.map(printMetadata).join('\n$tabs') + '\n$tabs' : "")
@@ -211,21 +211,21 @@ class Printer {
 	public function printExprs(el:Array<Expr>, sep:String) {
 		return el.map(printExpr).join(sep);
 	}
-	
+
 	function printExtension(tpl:Array<TypePath>, fields: Array<Field>) {
 		return '{\n$tabs>' + tpl.map(printTypePath).join(',\n$tabs>') + ","
 		    + (fields.length > 0 ? ('\n$tabs' + fields.map(printField).join(';\n$tabs') + ";\n}") : ("\n}"));
 	}
-	
+
 	function printStructure(fields:Array<Field>) {
 		return fields.length == 0 ? "{ }" :
 			'{\n$tabs' + fields.map(printField).join(';\n$tabs') + ";\n}";
 	}
-	
+
 	public function printTypeDefinition(t:TypeDefinition, printPackage = true):String {
 		var old = tabs;
 		tabs = tabString;
-		
+
 		var str = t == null ? "#NULL" :
 			(printPackage && t.pack.length > 0 && t.pack[0] != "" ? "package " + t.pack.join(".") + ";\n" : "") +
 			(t.meta != null && t.meta.length > 0 ? t.meta.map(printMetadata).join(" ") + " " : "") + (t.isExtern ? "extern " : "") + switch (t.kind) {
@@ -286,7 +286,7 @@ class Printer {
 					}].join("\n")
 					+ "\n}";
 			}
-		
+
 		tabs = old;
 		return str;
 	}

std/haxe/macro/Type.hx

@@ -144,42 +144,42 @@ typedef AbstractType = {>BaseType,
 typedef MetaAccess = {
 	/**
 		Return the wrapped `Metadata` array.
-		
+
 		Modifying this array has no effect on the origin of `this` MetaAccess.
 		The `add` and `remove` methods can be used for that.
 	**/
 	function get() : Expr.Metadata;
-	
+
 	/**
 		Adds the metadata specified by `name`, `params` and `pos` to the origin
 		of `this` MetaAccess.
-		
+
 		Metadata names are not unique during compilation, so this method never
 		overwrites a previous metadata.
-		
+
 		If a `Metadata` array is obtained through a call to `get`, a subsequent
 		call to `add` has no effect on that array.
-		
+
 		If any argument is null, compilation fails with an error.
 	**/
 	function add( name : String, params : Array<Expr>, pos : Expr.Position ) : Void;
-	
+
 	/**
 		Removes all `name` metadata entries from the origin of `this`
 		MetaAccess.
-		
+
 		This method might clear several metadata entries of the same name.
-		
+
 		If a `Metadata` array is obtained through a call to `get`, a subsequent
 		call to `remove` has no effect on that array.
-		
+
 		If `name` is null, compilation fails with an error.
 	**/
 	function remove( name : String ) : Void;
-	
+
 	/**
 		Tells if the origin of `this` MetaAccess has a `name` metadata entry.
-		
+
 		If `name` is null, compilation fails with an error.
 	**/
 	function has( name : String ) : Bool;

std/haxe/macro/TypeTools.hx

@@ -35,18 +35,18 @@ using Lambda;
 **/
 class TypeTools {
 	#if macro
-	
+
 	/**
 		Follows all typedefs of `t` to reach the actual type.
-		
+
 		If `once` is true, this function does not call itself recursively,
 		otherwise it does. This can be useful in cases where intermediate
 		typedefs might be of interest.
-		
+
 		Affected types are monomorphs `TMono` and typedefs `TType(t,pl)`.
-		
+
 		If `t` is null, an internal exception is thrown.
-		
+
 		Usage example:
 			var t = Context.typeof(macro null); // TMono(<mono>)
 			var ts = Context.typeof(macro "foo"); //TInst(String,[])
@@ -56,30 +56,30 @@ class TypeTools {
 	**/
 	static public inline function follow( t : Type, ?once : Bool ) : Type
 		return Context.follow(t, once);
-		
+
 	/**
 		Returns true if `t1` and `t2` unify, false otherwise.
 	**/
 	static public inline function unify( t1 : Type, t2:Type ) : Bool
 		return Context.unify(t1, t2);
-		
+
 	/**
 		Returns a syntax-level type corresponding to Type `t`.
-		
+
 		This function is mostly inverse to `ComplexTypeTools.toType`, but may
 		lose some information on types that do not have a corresponding syntax
 		version, such as monomorphs. In these cases, the result is null.
-		
+
 		If `t` is null, an internal exception is thrown.
 	**/
 	static public inline function toComplexType( t : Type ) : ComplexType
 		return Context.toComplexType(t);
-		
+
 	/**
 		Tries to extract the class instance stored inside `t`.
-		
+
 		If `t` is a class instance `TInst(c,pl)`, c is returned.
-		
+
 		If `t` is of a different type, an exception of type String is thrown.
 
 		If `t` is null, the result is null.
@@ -88,12 +88,12 @@ class TypeTools {
 		case TInst(c, _): c.get();
 		case _: throw "Class instance expected";
 	}
-	
+
 	/**
 		Tries to extract the enum instance stored inside `t`.
-		
+
 		If `t` is an enum instance `TEnum(e,pl)`, e is returned.
-		
+
 		If `t` is of a different type, an exception of type String is thrown.
 
 		If `t` is null, the result is null.
@@ -106,16 +106,16 @@ class TypeTools {
 	/**
 		Applies the type parameters `typeParameters` to type `t` with the given
 		types `concreteTypes`.
-		
+
 		This function replaces occurences of type parameters in `t` if they are
 		part of `typeParameters`. The array index of such a type parameter is
 		then used to lookup the concrete type in `concreteTypes`.
-		
+
 		If `typeParameters.length` is not equal to `concreteTypes.length`, an
 		exception of type `String` is thrown.
-		
+
 		If `typeParameters.length` is 0, `t` is returned unchanged.
-		
+
 		If either argument is `null`, the result is unspecified.
 	**/
 	static public function applyTypeParameters(t:Type, typeParameters:Array<TypeParameter>, concreteTypes:Array<Type>):Type {
@@ -125,19 +125,19 @@ class TypeTools {
 			return t;
 		return Context.load("apply_params", 3)(typeParameters.map(function(tp) return {name:untyped tp.name.__s, t:tp.t}), concreteTypes, t);
 	}
-	
+
 	/**
 		Transforms `t` by calling `f` on each of its subtypes.
-		
+
 		If `t` is a compound type, `f` is called on each of its components.
-		
+
 		Otherwise `t` is returned unchanged.
-		
+
 		The following types are considered compound:
 			- TInst, TEnum, TType and TAbstract with type parameters
 			- TFun
 			- TAnonymous
-			
+
 		If `t` or `f` are null, the result is unspecified.
 	**/
 	static public function map(t:Type, f:Type -> Type):Type {
@@ -173,23 +173,23 @@ class TypeTools {
 				ft == ft2 ? t : ft2;
 		}
 	}
-	
+
 	/**
 		Converts type `t` to a human-readable String representation.
 	**/
 	static public function toString( t : Type ) : String return new String(Context.load("s_type", 1)(t));
 	#end
-	
+
 	/**
 		Resolves the field named `name` on class `c`.
-		
+
 		If `isStatic` is true, the classes' static fields are checked. Otherwise
 		the classes' member fields are checked.
-		
+
 		If the field is found, it is returned. Otherwise if `c` has a super
 		class, `findField` recursively checks that super class. Otherwise null
 		is returned.
-		
+
 		If any argument is null, the result is unspecified.
 	**/
 	static public function findField(c:ClassType, name:String, isStatic:Bool = false):Null<ClassField> {

std/haxe/macro/TypedExprTools.hx

@@ -27,7 +27,7 @@ import haxe.macro.Type;
 
 class TypedExprTools {
 	#if macro
-	
+
 	static function with(e:TypedExpr, ?edef:TypedExprDef, ?t:Type) {
 		return {
 			expr: edef == null ? e.expr : edef,
@@ -35,10 +35,10 @@ class TypedExprTools {
 			t: t == null ? e.t : t
 		}
 	}
-	
+
 	/**
 		Transforms the sub-expressions of [e] by calling [f] on each of them.
-		
+
 		See `haxe.macro.ExprTools.map` for details on expression mapping in
 		general. This function works the same way, but with a different data
 		structure.
@@ -71,12 +71,12 @@ class TypedExprTools {
 			case TMeta(m, e1): with(e, TMeta(m, f(e1)));
 		}
 	}
-	
+
 	/**
 		Transforms the sub-expressions of [e] by calling [f] on each of them.
 		Additionally, types are mapped using `ft` and variables are mapped using
 		`fv`.
-		
+
 		See `haxe.macro.ExprTools.map` for details on expression mapping in
 		general. This function works the same way, but with a different data
 		structure.
@@ -110,7 +110,7 @@ class TypedExprTools {
 			case TMeta(m, e1): with(e, TMeta(m, f(e1)), ft(e.t));
 		}
 	}
-	
+
 	static public function toString(t:TypedExpr, ?pretty = false):String {
 		return new String(Context.load("s_expr", 2)(t, pretty));
 	}

std/haxe/rtti/Meta.hx

@@ -40,7 +40,7 @@ class Meta {
 
 	/**
 		Returns the metadata that were declared for the given class static fields
-	**/	
+	**/
 	public static function getStatics( t : Dynamic ) : Dynamic<Dynamic<Array<Dynamic>>> {
 		#if (java || cs)
 		var meta : Dynamic = Reflect.field(t, "__meta__");

std/haxe/rtti/XmlParser.hx

@@ -333,7 +333,7 @@ class XmlParser {
 		}
 		return ml;
 	}
-	
+
 	function xoverloads( x : Fast ) : List<ClassField> {
 		var l = new List();
 		for ( m in x.elements ) {

std/haxe/xml/Parser.hx

@@ -58,14 +58,14 @@ class Parser
 		h.set("nbsp", String.fromCharCode(160));
 		h;
 	}
-	
+
 	static public function parse(str:String)
 	{
 		var doc = Xml.createDocument();
 		doParse(str, 0, doc);
 		return doc;
 	}
-	
+
 	static function doParse(str:String, p:Int = 0, ?parent:Xml):Int
 	{
 		var xml:Xml = null;
@@ -323,23 +323,23 @@ class Parser
 			}
 			c = str.fastCodeAt(++p);
 		}
-		
+
 		if (state == S.BEGIN)
 		{
 			start = p;
 			state = S.PCDATA;
 		}
-		
+
 		if (state == S.PCDATA)
 		{
 			if (p != start || nsubs == 0)
 				parent.addChild(Xml.createPCData(buf.toString() + str.substr(start, p - start)));
 			return p;
 		}
-		
+
 		throw "Unexpected end";
 	}
-	
+
 	static inline function isValidChar(c) {
 		return (c >= 'a'.code && c <= 'z'.code) || (c >= 'A'.code && c <= 'Z'.code) || (c >= '0'.code && c <= '9'.code) || c == ':'.code || c == '.'.code || c == '_'.code || c == '-'.code;
 	}

std/haxe/xml/Printer.hx

@@ -29,19 +29,19 @@
 package haxe.xml;
 
 class Printer {
-	
+
 	static public function print(xml:Xml) {
 		var printer = new Printer();
 		printer.writeNode(xml, "");
 		return printer.output.toString();
 	}
-	
+
 	var output:StringBuf;
-	
+
 	function new() {
 		output = new StringBuf();
 	}
-	
+
 	function writeNode(value:Xml, tabs:String) {
 		switch (value.nodeType) {
 			case Xml.CData:
@@ -89,15 +89,15 @@ class Printer {
 				}
 			}
 	}
-	
+
 	inline function write(input:String) {
 		output.add(input);
 	}
-	
+
 	inline function newline() {
 		output.add("\n");
 	}
-	
+
 	function hasChildren(value:Xml):Bool {
 		for (child in value) {
 			switch (child.nodeType) {

std/haxe/zip/Reader.hx

@@ -186,7 +186,7 @@ class Reader {
 		}
 		return l;
 	}
-	
+
 	public static function readZip( i : haxe.io.Input ) {
 		var r = new Reader(i);
 		return r.read();

std/java/internal/IEquatable.hx

@@ -23,9 +23,9 @@ package java.internal;
 
 @:native('haxe.lang.IEquatable')
 @:keep
-interface IEquatable 
+interface IEquatable
 {
-	
+
 	public function equals(to:Dynamic):Bool;
-	
+
 }

std/java/internal/Iterator.hx

@@ -25,18 +25,18 @@ package java.internal;
 @:keep
 interface Iterator<T>
 {
-	
+
 	public function hasNext():Bool;
-	
+
 	public function next():T;
-	
+
 }
 
 @:native('haxe.lang.Iterable')
 @:keep
 interface Iterable<T>
 {
-	
+
 	public function iterator():Iterator<T>;
-	
+
 }

std/js/Browser.hx

@@ -36,7 +36,7 @@ class Browser {
 
 	public static var navigator(get, never):js.html.Navigator;
 	inline static function get_navigator() return untyped __js__("window.navigator");
-	
+
 	/**
 	 * True if a window object exists, false otherwise.
 	 *
@@ -45,7 +45,7 @@ class Browser {
 	 */
 	public static var supported(get, never):Bool;
 	public static function get_supported() return untyped __js__("typeof window != \"undefined\"");
-	
+
 	/**
 	 * Safely gets the browser's local storage, or returns null if localStorage is unsupported or
 	 * disabled.

std/js/JQuery.hx

@@ -69,7 +69,7 @@ extern class JQueryHelper {
 	public static inline function J( html : String ) : JQuery {
 		return new JQuery(html);
 	}
-	
+
 	public static var JTHIS(get, null) : JQuery;
 
 	static inline function get_JTHIS() : JQuery {

std/js/_std/Reflect.hx

@@ -80,7 +80,7 @@
 		var t = __js__("typeof(v)");
 		return (t == "string" || (t == "object" && v.__enum__ == null)) || (t == "function" && (js.Boot.isClass(v) || js.Boot.isEnum(v)) != null);
 	}
-	
+
 	public static function isEnumValue( v : Dynamic ) : Bool {
 		return v != null && v.__enum__ != null;
 	}

std/js/_std/Std.hx

@@ -27,7 +27,7 @@ import js.Boot;
 	public static inline function is( v : Dynamic, t : Dynamic ) : Bool {
 		return untyped js.Boot.__instanceof(v,t);
 	}
-	
+
 	public static inline function instance<T:{},S:T>( value : T, c : Class<S> ) : S {
 		return untyped __instanceof__(value, c) ? cast value : null;
 	}

std/js/_std/haxe/ds/ObjectMap.hx

@@ -24,38 +24,38 @@ package haxe.ds;
 
 @:coreApi
 class ObjectMap<K:{ }, V> implements Map.IMap<K,V> {
-	
+
 	static var count = 0;
-	
+
 	static inline function assignId(obj: { } ):Int {
 		return untyped obj.__id__ = ++count;
 	}
-	
+
 	static inline function getId(obj: { } ):Int {
 		return untyped obj.__id__;
 	}
-	
+
 	var h : { };
-	
+
 	public function new() : Void {
 		h = { };
 		untyped h.__keys__ = { };
 	}
-	
+
 	public function set(key:K, value:V):Void untyped {
 		var id : Int = untyped key.__id__ || assignId(key);
 		h[id] = value;
 		h.__keys__[id] = key;
 	}
-	
+
 	public inline function get(key:K):Null<V> {
 		return untyped h[getId(key)];
 	}
-	
+
 	public inline function exists(key:K):Bool {
 		return untyped h.__keys__[getId(key)] != null;
 	}
-	
+
 	public function remove( key : K ) : Bool {
 		var id = getId(key);
 		if ( untyped h.__keys__[id] == null ) return false;
@@ -63,7 +63,7 @@ class ObjectMap<K:{ }, V> implements Map.IMap<K,V> {
 		untyped  __js__("delete")(h.__keys__[id]);
 		return true;
 	}
-	
+
 	public function keys() : Iterator<K> {
 		var a = [];
 		untyped {
@@ -74,7 +74,7 @@ class ObjectMap<K:{ }, V> implements Map.IMap<K,V> {
 		}
 		return a.iterator();
 	}
-	
+
 	public function iterator() : Iterator<V> {
 		return untyped {
 			ref : h,
@@ -83,7 +83,7 @@ class ObjectMap<K:{ }, V> implements Map.IMap<K,V> {
 			next : function() { var i = __this__.it.next(); return __this__.ref[getId(i)]; }
 		};
 	}
-	
+
 	public function toString() : String {
 		var s = new StringBuf();
 		s.add("{");

std/neko/_std/Reflect.hx

@@ -93,7 +93,7 @@
 	public static function isObject( v : Dynamic ) : Bool untyped {
 		return $typeof(v) == $tobject && v.__enum__ == null;
 	}
-	
+
 	public static function isEnumValue( v : Dynamic ) : Bool untyped {
 		return $typeof(v) == $tobject && v.__enum__ != null;
 	}

std/neko/_std/Std.hx

@@ -25,7 +25,7 @@
 	public static function is( v : Dynamic, t : Dynamic ) : Bool {
 		return untyped neko.Boot.__instanceof(v,t);
 	}
-	
+
 	public static function instance<T:{},S:T>( value : T, c : Class<S> ) : S {
 		return Std.is(value, c) ? cast value : null;
 	}

std/neko/_std/haxe/ds/ObjectMap.hx

@@ -25,20 +25,20 @@ package haxe.ds;
 class ObjectMap<K:{},V> implements Map.IMap<K,V> {
 
 	static var count = 0;
-	
+
 	static inline function assignId(obj: { } ):Int {
 		var newId = count++;
 		untyped obj.__id__ = newId;
 		return newId;
 	}
-	
+
 	static inline function getId(obj: { } ):Int {
 		return untyped obj.__id__;
 	}
-	
+
 	var h : { };
 	var k : { };
-	
+
 	public function new() : Void {
 		h = untyped __dollar__hnew(0);
 		k = untyped __dollar__hnew(0);

std/neko/_std/sys/net/UdpSocket.hx

@@ -40,7 +40,7 @@ class UdpSocket extends Socket {
 				throw Custom(e);
 		}
 	}
-	
+
 	public function readFrom( buf : haxe.io.Bytes, pos : Int, len : Int, addr : Address ) : Int {
 		var r;
 		try {
@@ -55,8 +55,8 @@ class UdpSocket extends Socket {
 			throw new haxe.io.Eof();
 		return r;
 	}
-	
+
 	static var socket_recv_from = neko.Lib.loadLazy("std", "socket_recv_from", 5);
 	static var socket_send_to = neko.Lib.loadLazy("std", "socket_send_to", 5);
-	
+
 }

std/php/Exception.hx

@@ -23,18 +23,18 @@ package php;
 
 extern class Exception {
   public function new(?message : String, ?code : Int) : Void;
-  
+
   private var message : String;
   private var code : Int;
   private var file : String;
   private var line : Int;
-  
-  public function getMessage() : String;       // message of the exception 
+
+  public function getMessage() : String;       // message of the exception
   public function getCode() : Int;             // code of the exception
   public function getFile() : String;          // source filename
   public function getLine() : Int;             // source line
   public function getTrace() : Array<String>;  // an array of the backtrace()
   public function getTraceAsString() : String; // formated string of trace
-  
+
   public function __toString() : String;       // formated string for display
 }

std/php/IteratorAggregate.hx

@@ -22,10 +22,10 @@
 package php;
 
 extern interface IteratorAggregate<T> {
-	/** 
-		This method is not public to not induce Haxe users to use it ;) 
+	/**
+		This method is not public to not induce Haxe users to use it ;)
 		Use iterator() instead.
-		The return type would be Aggregator that is unusable in Haxe 
+		The return type would be Aggregator that is unusable in Haxe
 	**/
-	private function getIterator() : Iterator<T>; // 
+	private function getIterator() : Iterator<T>; //
 }

std/php/Session.hx

@@ -37,7 +37,7 @@ class Session {
 		}
 		return null;
 	}
-	
+
 	public static function setCacheLimiter(l : CacheLimiter) {
 		if(started) throw "You can't set the cache limiter while the session is already in use";
 		switch(l) {
@@ -51,29 +51,29 @@ class Session {
 				untyped __call__("session_cache_limiter", "private_no_expire");
 		}
 	}
-	
+
 	public static function getCacheExpire() : Int {
 		return untyped __call__("session_cache_expire");
 	}
-	
+
 	public static function setCacheExpire(minutes : Int) {
 		if(started) throw "You can't set the cache expire time while the session is already in use";
 		untyped __call__("session_cache_expire", minutes);
 	}
-	
+
 	public static function setName(name : String) {
 		if(started) throw "You can't set the name while the session is already in use";
 		untyped __call__("session_name", name);
 	}
-	
+
 	public static function getName() : String {
 		return untyped __call__("session_name");
 	}
-	
+
 	public static function getId() : String {
 		return untyped __call__("session_id");
 	}
-	
+
 	public static function setId(id : String) {
 		if(started) throw "You can't set the session id while the session is already in use";
 		untyped __call__("session_id", id);
@@ -82,76 +82,76 @@ class Session {
 	public static function getSavePath() : String {
 		return untyped __call__("session_save_path");
 	}
-	
+
 	public static function setSavePath(path : String) {
 		if(started) throw "You can't set the save path while the session is already in use";
 		untyped __call__("session_save_path", path);
 	}
-	
+
 	public static function getModule() : String {
 		return untyped __call__("session_module_name");
 	}
-	
+
 	public static function setModule(module : String) {
 		if(started) throw "You can't set the module while the session is already in use";
 		untyped __call__("session_module_name", module);
 	}
-	
+
 	public static function regenerateId(?deleteold : Bool) : Bool {
 		return untyped __call__("session_regenerate_id", deleteold);
 	}
-	
+
 	public static function get(name : String) : Dynamic {
 		start();
 		if(!untyped __call__('isset', __var__("_SESSION", name))) return null;
 		return untyped __var__("_SESSION", name);
 	}
-	
+
 	public static function set(name : String, value : Dynamic) {
 		start();
 		return untyped __set__("_SESSION", name, value);
 	}
-	
+
 	public static function setCookieParams(?lifetime : Int, ?path : String, ?domain : String, ?secure : Bool, ?httponly : Bool) {
 		if(started) throw "You can't set the cookie params while the session is already in use";
 		untyped __call__("session_set_cookie_params", lifetime, path, domain, secure, httponly);
 	}
-	
+
 	public static function getCookieParams() : { lifetime : Int, path : String, domain : String, secure : Bool, httponly : Bool} {
 		return untyped __call__("_hx_anonymous", untyped __call__("session_get_cookie_params"));
 	}
-	
+
 	// TODO: completely untested
 	public static function setSaveHandler(open : String -> String -> Bool, close : Void -> Bool, read : String -> String, write : String -> String -> Bool, destroy, gc) : Bool {
 		return untyped __call__("session_set_save_handler", open, close, read, write, destroy, gc);
 	}
-	
+
 	public static function exists(name : String) {
 		start();
 		return untyped __call__("array_key_exists", name, __var__("_SESSION"));
 	}
-	
+
 	public static function remove(name : String) {
 		start();
 		untyped __call__("unset", __var__("_SESSION", name));
 	}
-	
+
 	public static var started(default, null) : Bool;
 	public static function start() {
 		if(started) return;
 		started = true;
 		untyped __call__("session_start");
 	}
-	
+
 	public static function clear() {
 		untyped __call__("session_unset");
 	}
-	
+
 	public static function close() {
 		untyped __call__("session_write_close");
 		started = false; // TODO: not sure this useful; test if a closed session can be re-opened (I doubt)
 	}
-	
+
 	static function __init__()
 	{
 		started = untyped __call__("isset", __var__("_SESSION"));

std/php/_std/Math.hx

@@ -41,7 +41,7 @@
 		else if(v == POSITIVE_INFINITY)
 			return POSITIVE_INFINITY;
 		else
-			return 0.0;	
+			return 0.0;
 	}
 	public static function log(v : Float) : Float      { return untyped __call__("log", v); }
 	public static function sqrt(v : Float) : Float     { return untyped __call__("sqrt", v); }
@@ -55,7 +55,7 @@
 	public static function random() : Float    { return untyped __call__("mt_rand") / __call__("mt_getrandmax"); }
 	public static function isNaN(f : Float) : Bool     { return untyped __call__("is_nan", f); }
 	public static function isFinite(f : Float) : Bool  { return untyped __call__("is_finite", f); }
-	
+
 	public static function fround(v : Float) : Float      { return untyped __call__("floor", v + 0.5); }
 	public static function ffloor(v : Float) : Float      { return untyped __call__("floor", v); }
 	public static function fceil(v : Float) : Float       { return untyped __call__("ceil", v); }

std/php/_std/Reflect.hx

@@ -92,11 +92,11 @@
 			return untyped __php__("$v instanceof _hx_anonymous") || Type.getClass(v) != null;
 		return untyped __php__("is_string($v) && !_hx_is_lambda($v)");
 	}
-	
+
 	public static function isEnumValue( v : Dynamic ) : Bool {
 		return untyped __php__("$v instanceof _hx_enum");
 	}
-		
+
 	public static function deleteField( o : Dynamic, field : String ) : Bool {
 		if(!hasField(o,field)) return false;
 		untyped __php__("if(isset($o->__dynamics[$field])) unset($o->__dynamics[$field]); else if($o instanceof _hx_anonymous) unset($o->$field); else $o->$field = null");

std/php/_std/Std.hx

@@ -24,7 +24,7 @@
 	public static function is( v : Dynamic, t : Dynamic ) : Bool {
 		return untyped untyped __call__("_hx_instanceof", v,t);
 	}
-	
+
 	public static function instance<T:{},S:T>( value : T, c : Class<S> ) : S {
 		return Std.is(value, c) ? cast value : null;
 	}

std/php/_std/Xml.hx

@@ -45,7 +45,7 @@ enum XmlType {
 	var _children : Array<Xml>;
 	var _parent : Xml;
 	var _fromCustomParser:Bool;
-	
+
 	private static var build : Xml;
 	private static function __start_element_handler(parser : Dynamic, name : String, attribs : ArrayAccess<String>) : Void {
 		var node = createElement(name);
@@ -142,7 +142,7 @@ enum XmlType {
 		r.set_nodeValue( data );
 		return r;
 	}
-	
+
 	public static function createElement( name : String ) : Xml {
 		var r = new Xml();
 		r.nodeType = Xml.Element;

std/php/_std/haxe/ds/ObjectMap.hx

@@ -27,21 +27,21 @@ class ObjectMap <K:{ }, V> implements Map.IMap<K,V> {
 	static function getId(key: { } ):String {
 		return untyped __php__("spl_object_hash($key)");
 	}
-	
+
 	var h : ArrayAccess<V>;
 	var hk : ArrayAccess<K>;
-	
+
 	public function new():Void {
 		h = untyped __call__('array');
 		hk = untyped __call__('array');
 	}
-	
+
 	public function set(key:K, value:V):Void untyped {
 		var id = getId(key);
 		untyped h[id] = value;
 		untyped hk[id] = key;
 	}
-	
+
 	public function get(key:K):Null<V> {
 		var id = getId(key);
 		if (untyped __call__("array_key_exists", id, h))
@@ -49,11 +49,11 @@ class ObjectMap <K:{ }, V> implements Map.IMap<K,V> {
 		else
 			return null;
 	}
-	
+
 	public function exists(key:K):Bool {
 		return untyped __call__("array_key_exists", getId(key), h);
 	}
-	
+
 	public function remove( key : K ) : Bool {
 		var id = getId(key);
 		if (untyped __call__("array_key_exists", id, h)) {
@@ -63,15 +63,15 @@ class ObjectMap <K:{ }, V> implements Map.IMap<K,V> {
 		} else
 			return false;
 	}
-	
+
 	public inline function keys() : Iterator<K> {
 		return untyped __call__("new _hx_array_iterator", __call__("array_values", hk));
 	}
-	
+
 	public inline function iterator() : Iterator<V> {
 		return untyped __call__("new _hx_array_iterator", __call__("array_values", h));
 	}
-	
+
 	public function toString() : String {
 		var s = "{";
 		var it = keys();

std/php/_std/sys/db/Mysql.hx

@@ -37,7 +37,7 @@ import sys.db.Connection;
 		if (params.socket !=null)
 			dsn+="unix_socket="+params.socket+";";
 		else{
-			dsn+="host="+params.host+";"; 
+			dsn+="host="+params.host+";";
 			if (params.port!=null)
 				dsn+='port='+params.port+";";
 		}

std/sys/db/RecordMacros.hx

@@ -1117,7 +1117,7 @@ class RecordMacros {
 			return { expr : ECall({ expr : EField(em,"unsafeGet"), pos : pos },[econd,elock]), pos : pos };
 		}
 	}
-	
+
 	static function defaultTrue( e : Expr ) {
 		return switch( e.expr ) {
 		case EConst(CIdent("null")): { expr : EConst(CIdent("true")), pos : e.pos };

std/sys/io/File.hx

@@ -23,102 +23,102 @@ package sys.io;
 
 /**
 	API for reading and writing to files.
-	
+
 	See `sys.FileSystem` for the complementary file system API.
 **/
 extern class File {
 
 	/**
 		Retrieves the content of the file specified by `path` as a String.
-		
+
 		If the file does not exist or can not be read, an exception is thrown.
-		
+
 		`sys.FileSystem.exists` can be used to check for existence.
-		
+
 		If `path` is null, the result is unspecified.
 	**/
 	static function getContent( path : String ) : String;
-	
+
 	/**
 		Stores `content` in the file specified by `path`.
-		
+
 		If the file cannot be written to, an exception is thrown.
-		
+
 		If `path` or `content` are null, the result is unspecified.
 	**/
 	static function saveContent( path : String, content : String ) : Void;
-	
+
 	/**
 		Retrieves the binary content of the file specified by `path`.
-		
+
 		If the file does not exist or can not be read, an exception is thrown.
-		
+
 		`sys.FileSystem.exists` can be used to check for existence.
-		
+
 		If `path` is null, the result is unspecified.
-	**/	
+	**/
 	static function getBytes( path : String ) : haxe.io.Bytes;
-	
+
 	/**
 		Stores `bytes` in the file specified by `path` in binary mode.
-		
+
 		If the file cannot be written to, an exception is thrown.
-		
+
 		If `path` or `bytes` are null, the result is unspecified.
-	**/	
+	**/
 	static function saveBytes( path : String, bytes : haxe.io.Bytes ) : Void;
-	
+
 	/**
 		Returns an `FileInput` handle to the file specified by `path`.
-		
+
 		If `binary` is true, the file is opened in binary mode. Otherwise it is
 		opened in non-binary mode.
-		
+
 		If the file does not exist or can not be read, an exception is thrown.
-		
+
 		Operations on the returned `FileInput` handle read on the opened file.
-		
+
 		File handles should be closed via `FileInput.close` once the operation
 		is complete.
-		
+
 		If `path` is null, the result is unspecified.
 	**/
 	static function read( path : String, binary : Bool = true ) : FileInput;
-	
+
 	/**
 		Returns an `FileOutput` handle to the file specified by `path`.
-		
+
 		If `binary` is true, the file is opened in binary mode. Otherwise it is
 		opened in non-binary mode.
-		
+
 		If the file cannot be written to, an exception is thrown.
-		
+
 		Operations on the returned `FileOutput` handle write to the opened file.
 		If the file existed, its previous content is overwritten.
-		
+
 		File handles should be closed via `FileOutput.close` once the operation
 		is complete.
-		
+
 		If `path` is null, the result is unspecified.
-	**/	
+	**/
 	static function write( path : String, binary : Bool = true ) : FileOutput;
-	
+
 	/**
 		Similar to `sys.io.File.write`, but appends to the file if it exists
 		instead of overwriting its contents.
 	**/
 	static function append( path : String, binary : Bool = true ) : FileOutput;
-	
-	
+
+
 	/**
 		Copies the contents of the file specified by `srcPath` to the file
 		specified by `dstPath`.
-		
+
 		If the `srcPath` does not exist or cannot be read, or if the `dstPath`
 		file cannot be written to, an exception is thrown.
-		
+
 		If the file at `dstPath` exists, its contents are overwritten.
-		
+
 		If `srcPath` or `dstPath` are null, the result is unspecified.
 	**/
 	static function copy( srcPath : String, dstPath : String ) : Void;

std/sys/net/Address.hx

@@ -31,13 +31,13 @@ class Address {
 		host = 0;
 		port = 0;
 	}
-	
+
 	public function getHost() {
 		var h = new Host("127.0.0.1");
 		untyped h.ip = host;
 		return h;
 	}
-	
+
 	public function compare( a : Address ) {
 		var dh = a.host - host;
 		if( dh != 0 ) return dh;
@@ -45,12 +45,12 @@ class Address {
 		if( dp != 0 ) return dp;
 		return 0;
 	}
-	
+
 	public function clone() {
 		var c = new Address();
 		c.host = host;
 		c.port = port;
 		return c;
 	}
-	
+
 }