Update Files

Kha/Tools/linux_arm64/std/hl/_std/haxe/Exception.hx

@@ -0,0 +1,83 @@
+package haxe;
+
+@:coreApi
+class Exception {
+	public var message(get,never):String;
+	public var stack(get,never):CallStack;
+	public var previous(get,never):Null<Exception>;
+	public var native(get,never):Any;
+
+	@:noCompletion var __exceptionMessage:String;
+	@:noCompletion var __exceptionStack:Null<CallStack>;
+	@:noCompletion var __nativeStack:hl.NativeArray<hl.Bytes>;
+	@:noCompletion @:ifFeature("haxe.Exception.get_stack") var __skipStack:Int = 0;
+	@:noCompletion var __nativeException:Any;
+	@:noCompletion var __previousException:Null<Exception>;
+
+	static function caught(value:Any):Exception {
+		if(Std.isOfType(value, Exception)) {
+			return value;
+		} else {
+			return new ValueException(value, null, value);
+		}
+	}
+
+	static function thrown(value:Any):Any {
+		if(Std.isOfType(value, Exception)) {
+			return (value:Exception).native;
+		} else {
+			var e = new ValueException(value);
+			e.__shiftStack();
+			return e;
+		}
+	}
+
+	public function new(message:String, ?previous:Exception, ?native:Any) {
+		__exceptionMessage = message;
+		__previousException = previous;
+		if(native != null) {
+			__nativeStack = NativeStackTrace.exceptionStack();
+			__nativeException = native;
+		} else {
+			__nativeStack = NativeStackTrace.callStack();
+			__nativeException = this;
+		}
+	}
+
+	function unwrap():Any {
+		return __nativeException;
+	}
+
+	public function toString():String {
+		return message;
+	}
+
+	public function details():String {
+		return inline CallStack.exceptionToString(this);
+	}
+
+	@:noCompletion
+	@:ifFeature("haxe.Exception.get_stack")
+	inline function __shiftStack():Void {
+		__skipStack++;
+	}
+
+	function get_message():String {
+		return __exceptionMessage;
+	}
+
+	function get_previous():Null<Exception> {
+		return __previousException;
+	}
+
+	final function get_native():Any {
+		return __nativeException;
+	}
+
+	function get_stack():CallStack {
+		return switch __exceptionStack {
+			case null: __exceptionStack = NativeStackTrace.toHaxe(__nativeStack, __skipStack);
+			case s: s;
+		}
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/NativeStackTrace.hx

@@ -0,0 +1,58 @@
+package haxe;
+
+import hl.NativeArray;
+import hl.Bytes;
+import haxe.CallStack.StackItem;
+
+/**
+	Do not use manually.
+**/
+@:dox(hide)
+@:noCompletion
+class NativeStackTrace {
+	@:ifFeature('haxe.NativeStackTrace.exceptionStack')
+	static public inline function saveStack(exception:Any):Void {
+	}
+
+	@:hlNative("std", "exception_stack")
+	static public function exceptionStack():NativeArray<Bytes> {
+		return null;
+	}
+
+	//TODO: implement in hashlink like `exceptionStack`
+	static public function callStack():NativeArray<Bytes> {
+		var stack:NativeArray<Bytes> = try {
+			throw new Exception('', null, 'stack');
+		} catch (e:Exception) {
+			exceptionStack();
+		}
+		var skip = 1;
+		for(i in 0...stack.length - 1) {
+			var s = @:privateAccess String.fromUCS2(stack[i]);
+			if(s.indexOf('NativeStackTrace.callStack') < 0) {
+				break;
+			}
+			skip++;
+		}
+		return skip < stack.length ? stack.sub(skip, stack.length - skip) : stack;
+	}
+
+	static public function toHaxe(native:NativeArray<Bytes>, skip:Int = 0):Array<StackItem> {
+		var stack = [];
+		var r = ~/^([A-Za-z0-9.$_]+)\.([~A-Za-z0-9_]+(\.[0-9]+)?)\((.+):([0-9]+)\)$/;
+		var r_fun = ~/^fun\$([0-9]+)\((.+):([0-9]+)\)$/;
+		for (i in 0...native.length - 1) {
+			if(skip > i) {
+				continue;
+			}
+			var str = @:privateAccess String.fromUCS2(native[i]);
+			if (r.match(str))
+				stack.push(FilePos(Method(r.matched(1), r.matched(2)), r.matched(4), Std.parseInt(r.matched(5))));
+			else if (r_fun.match(str))
+				stack.push(FilePos(LocalFunction(Std.parseInt(r_fun.matched(1))), r_fun.matched(2), Std.parseInt(r_fun.matched(3))));
+			else
+				stack.push(Module(str));
+		}
+		return stack;
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/Resource.hx

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe;
+
+private class ResourceContent {
+	public var name:hl.Bytes;
+	public var data:hl.Bytes;
+	public var dataLen:Int;
+}
+
+@:coreApi
+class Resource {
+	static var content:hl.NativeArray<ResourceContent>;
+
+	public static function listNames():Array<String> {
+		return [for (x in content) @:privateAccess String.fromUCS2(x.name)];
+	}
+
+	public static function getString(name:String):String {
+		for (x in content)
+			if (x.name.compare(0, @:privateAccess name.bytes, 0, (name.length + 1) << 1) == 0)
+				return @:privateAccess String.fromUTF8(x.data);
+		return null;
+	}
+
+	public static function getBytes(name:String):haxe.io.Bytes {
+		for (x in content)
+			if (x.name.compare(0, @:privateAccess name.bytes, 0, (name.length + 1) << 1) == 0)
+				return @:privateAccess new haxe.io.Bytes(x.data, x.dataLen);
+		return null;
+	}
+
+	static function __init__():Void {
+		content = untyped $resources();
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/crypto/Md5.hx

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.crypto;
+
+class Md5 {
+	public static function encode(s:String):String {
+		var out = haxe.io.Bytes.alloc(16);
+		@:privateAccess hl.Format.digest(out.b, s.bytes, s.length, 256);
+		return out.toHex();
+	}
+
+	public static function make(b:haxe.io.Bytes):haxe.io.Bytes {
+		var out = haxe.io.Bytes.alloc(16);
+		@:privateAccess hl.Format.digest(out.b, b.b, b.length, 0);
+		return out;
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/crypto/Sha1.hx

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.crypto;
+
+class Sha1 {
+	public static function encode(s:String):String {
+		var out = haxe.io.Bytes.alloc(20);
+		@:privateAccess hl.Format.digest(out.b, s.bytes, s.length, 256 | 1);
+		return out.toHex();
+	}
+
+	public static function make(b:haxe.io.Bytes):haxe.io.Bytes {
+		var out = haxe.io.Bytes.alloc(20);
+		@:privateAccess hl.Format.digest(out.b, b.b, b.length, 1);
+		return out;
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/ds/IntMap.hx

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.ds;
+
+@:coreApi
+class IntMap<T> implements haxe.Constraints.IMap<Int, T> {
+	var h:hl.types.IntMap;
+
+	public function new():Void {
+		h = new hl.types.IntMap();
+	}
+
+	public function set(key:Int, value:T):Void {
+		@:privateAccess h.set(key, value);
+	}
+
+	public function get(key:Int):Null<T> {
+		return @:privateAccess h.get(key);
+	}
+
+	public function exists(key:Int):Bool {
+		return @:privateAccess h.exists(key);
+	}
+
+	public function remove(key:Int):Bool {
+		return @:privateAccess h.remove(key);
+	}
+
+	public function keys():Iterator<Int> {
+		return new hl.NativeArray.NativeArrayIterator<Int>(h.keysArray());
+	}
+
+	public function iterator():Iterator<T> {
+		return h.iterator();
+	}
+
+	@:runtime public inline function keyValueIterator():KeyValueIterator<Int, T> {
+		return new haxe.iterators.MapKeyValueIterator(this);
+	}
+
+	public function copy():IntMap<T> {
+		var copied = new IntMap();
+		for (key in keys())
+			copied.set(key, get(key));
+		return copied;
+	}
+
+	public function toString():String {
+		var s = new StringBuf();
+		var keys = h.keysArray();
+		var values = h.valuesArray();
+		s.addChar('{'.code);
+		for (i in 0...keys.length) {
+			if (i > 0)
+				s.add(", ");
+			s.add(keys[i]);
+			s.add(" => ");
+			s.add(values[i]);
+		}
+		s.addChar('}'.code);
+		return s.toString();
+	}
+
+	public function clear():Void {
+		#if (hl_ver >= version("1.11.0"))
+		@:privateAccess h.clear();
+		#else
+		h = new hl.types.IntMap();
+		#end
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/ds/ObjectMap.hx

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.ds;
+
+@:coreApi
+class ObjectMap<K:{}, T> implements haxe.Constraints.IMap<K, T> {
+	var h:hl.types.ObjectMap;
+
+	public function new():Void {
+		h = new hl.types.ObjectMap();
+	}
+
+	public function set(key:K, value:T):Void {
+		@:privateAccess h.set(key, value);
+	}
+
+	public function get(key:K):Null<T> {
+		return @:privateAccess h.get(key);
+	}
+
+	public function exists(key:K):Bool {
+		return @:privateAccess h.exists(key);
+	}
+
+	public function remove(key:K):Bool {
+		return @:privateAccess h.remove(key);
+	}
+
+	public function keys():Iterator<K> {
+		return new hl.NativeArray.NativeArrayIterator<K>(cast h.keysArray());
+	}
+
+	public function iterator():Iterator<T> {
+		return h.iterator();
+	}
+
+	@:runtime public inline function keyValueIterator():KeyValueIterator<K, T> {
+		return new haxe.iterators.MapKeyValueIterator(this);
+	}
+
+	public function copy():ObjectMap<K, T> {
+		var copied = new ObjectMap();
+		for (key in keys())
+			copied.set(key, get(key));
+		return copied;
+	}
+
+	public function toString():String {
+		var s = new StringBuf();
+		var keys = h.keysArray();
+		var values = h.valuesArray();
+		s.addChar('{'.code);
+		for (i in 0...keys.length) {
+			if (i > 0)
+				s.add(", ");
+			s.add(keys[i]);
+			s.add(" => ");
+			s.add(values[i]);
+		}
+		s.addChar('}'.code);
+		return s.toString();
+	}
+
+	public function clear():Void {
+		#if (hl_ver >= version("1.11.0"))
+		@:privateAccess h.clear();
+		#else
+		h = new hl.types.ObjectMap();
+		#end
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/ds/StringMap.hx

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.ds;
+
+private class StringMapKeysIterator {
+	var arr:hl.NativeArray<hl.Bytes>;
+	var pos:Int;
+	var length:Int;
+
+	public inline function new(h:hl.types.BytesMap) {
+		this.arr = h.keysArray();
+		pos = 0;
+		length = arr.length;
+	}
+
+	public inline function hasNext() {
+		return pos < length;
+	}
+
+	public inline function next() @:privateAccess {
+		var b = arr[pos++];
+		return String.fromUCS2(b);
+	}
+}
+
+@:coreApi
+class StringMap<T> implements haxe.Constraints.IMap<String, T> {
+	var h:hl.types.BytesMap;
+
+	public function new():Void {
+		h = new hl.types.BytesMap();
+	}
+
+	public function set(key:String, value:T):Void {
+		@:privateAccess h.set(key.bytes, value);
+	}
+
+	public function get(key:String):Null<T> {
+		if (key == null)
+			return null;
+		return @:privateAccess h.get(key.bytes);
+	}
+
+	public function exists(key:String):Bool {
+		if (key == null)
+			return false;
+		return @:privateAccess h.exists(key.bytes);
+	}
+
+	public function remove(key:String):Bool {
+		if (key == null)
+			return false;
+		return @:privateAccess h.remove(key.bytes);
+	}
+
+	public function keys():Iterator<String> {
+		return new StringMapKeysIterator(h);
+	}
+
+	public function iterator():Iterator<T> {
+		return h.iterator();
+	}
+
+	@:runtime public inline function keyValueIterator():KeyValueIterator<String, T> {
+		return new haxe.iterators.MapKeyValueIterator(this);
+	}
+
+	public function copy():StringMap<T> {
+		var copied = new StringMap();
+		for (key in keys())
+			copied.set(key, get(key));
+		return copied;
+	}
+
+	public function toString():String {
+		var s = new StringBuf();
+		var keys = h.keysArray();
+		var values = h.valuesArray();
+		s.addChar('{'.code);
+		for (i in 0...keys.length) {
+			if (i > 0)
+				s.add(", ");
+			var k = keys[i];
+			@:privateAccess s.__add(k, 0, (@:privateAccess k.ucs2Length(0)) << 1);
+			s.add(" => ");
+			s.add(values[i]);
+		}
+		s.addChar('}'.code);
+		return s.toString();
+	}
+
+	public function clear():Void {
+		#if (hl_ver >= version("1.11.0"))
+		@:privateAccess h.clear();
+		#else
+		h = new hl.types.BytesMap();
+		#end
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/ds/Vector.hx

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.ds;
+
+private typedef VectorData<T> = Array<T>
+
+@:coreApi
+abstract Vector<T>(VectorData<T>) {
+	public inline function new(length:Int) {
+		this = [];
+		if (length > 0)
+			this[length - 1] = cast null;
+	}
+
+	@:op([]) public inline function get(index:Int):T {
+		return this[index];
+	}
+
+	@:op([]) public inline function set(index:Int, val:T):T {
+		return this[index] = val;
+	}
+
+	public var length(get, never):Int;
+
+	inline function get_length():Int {
+		return this.length;
+	}
+
+	public static inline function blit<T>(src:Vector<T>, srcPos:Int, dest:Vector<T>, destPos:Int, len:Int):Void {
+		(cast dest : hl.types.ArrayBase.ArrayAccess).blit(destPos, (cast src : hl.types.ArrayBase.ArrayAccess), srcPos, len);
+	}
+
+	public inline function toArray():Array<T> {
+		return this.copy();
+	}
+
+	public inline function toData():VectorData<T>
+		return this;
+
+	static public inline function fromData<T>(data:VectorData<T>):Vector<T>
+		return cast data;
+
+	static public inline function fromArrayCopy<T>(array:Array<T>):Vector<T> {
+		return cast array.copy();
+	}
+
+	public inline function copy<T>():Vector<T> {
+		return cast this.copy();
+	}
+
+	public inline function join<T>(sep:String):String {
+		return this.join(sep);
+	}
+
+	public inline function sort(f:T->T->Int):Void {
+		this.sort(f);
+	}
+
+	public inline function map<S>(f:T->S):Vector<S> {
+		var length = length;
+		var r = new Vector<S>(length);
+		var i = 0;
+		var len = length;
+		for (i in 0...len) {
+			var v = f(get(i));
+			r.set(i, v);
+		}
+		return r;
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/io/Bytes.hx

@@ -0,0 +1,253 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.io;
+
+@:coreApi
+class Bytes {
+	public var length(default, null):Int;
+
+	var b:hl.Bytes;
+
+	function new(b:hl.Bytes, length:Int):Void {
+		this.b = b;
+		this.length = length;
+	}
+
+	inline function out(pos:Int):Bool {
+		return (pos : UInt) >= (length : UInt);
+	}
+
+	inline function outRange(pos:Int, len:Int):Bool {
+		return pos < 0 || len < 0 || ((pos + len) : UInt) > (length : UInt);
+	}
+
+	public function get(pos:Int):Int {
+		return if (out(pos)) 0 else b[pos];
+	}
+
+	public function set(pos:Int, v:Int):Void {
+		if (out(pos))
+			throw Error.OutsideBounds;
+		b[pos] = v;
+	}
+
+	public function blit(pos:Int, src:Bytes, srcpos:Int, len:Int):Void {
+		if (outRange(pos, len) || src.outRange(srcpos, len))
+			throw Error.OutsideBounds;
+		b.blit(pos, src.b, srcpos, len);
+	}
+
+	public function fill(pos:Int, len:Int, value:Int):Void {
+		if (outRange(pos, len))
+			throw Error.OutsideBounds;
+		b.fill(pos, len, value);
+	}
+
+	public function sub(pos:Int, len:Int):Bytes {
+		if (outRange(pos, len))
+			throw Error.OutsideBounds;
+		return new Bytes(b.sub(pos, len), len);
+	}
+
+	public function compare(other:Bytes):Int {
+		var len = length < other.length ? length : other.length;
+		var r = b.compare(0, other.b, 0, len);
+		if (r == 0)
+			r = length - other.length;
+		return r;
+	}
+
+	#if hl_check_align
+	static var alignBuffer:hl.Bytes = new hl.Bytes(8);
+	#end
+
+	public function getDouble(pos:Int):Float {
+		if (out(pos + 7))
+			return 0.;
+		#if hl_check_align
+		return if (pos & 3 == 0) b.getF64(pos) else {
+			alignBuffer.blit(0, b, pos, 8);
+			alignBuffer.getF64(0);
+		}
+		#else
+		return b.getF64(pos);
+		#end
+	}
+
+	public function getFloat(pos:Int):Float {
+		if (out(pos + 3))
+			return 0.;
+		#if hl_check_align
+		return if (pos & 3 == 0) b.getF32(pos) else {
+			alignBuffer.blit(0, b, pos, 4);
+			alignBuffer.getF32(0);
+		}
+		#else
+		return b.getF32(pos);
+		#end
+	}
+
+	public function setDouble(pos:Int, v:Float):Void {
+		if (out(pos + 7))
+			throw Error.OutsideBounds;
+		#if hl_check_align
+		if (pos & 7 == 0)
+			b.setF64(pos, v);
+		else {
+			alignBuffer.setF64(0, v);
+			b.blit(pos, alignBuffer, 0, 8);
+		}
+		#else
+		b.setF64(pos, v);
+		#end
+	}
+
+	public function setFloat(pos:Int, v:Float):Void {
+		if (out(pos + 3))
+			throw Error.OutsideBounds;
+		#if hl_check_align
+		if (pos & 3 == 0)
+			b.setF32(pos, v);
+		else {
+			alignBuffer.setF32(0, v);
+			b.blit(pos, alignBuffer, 0, 4);
+		}
+		#else
+		b.setF32(pos, v);
+		#end
+	}
+
+	public inline function getUInt16(pos:Int):Int {
+		return if (out(pos + 1)) 0 else b.getUI16(pos);
+	}
+
+	public inline function setUInt16(pos:Int, v:Int):Void {
+		if (out(pos + 1))
+			throw Error.OutsideBounds;
+		b.setUI16(pos, v);
+	}
+
+	public function getInt32(pos:Int):Int {
+		return if (out(pos + 3)) 0 else b.getI32(pos);
+	}
+
+	public function getInt64(pos:Int):haxe.Int64 {
+		if (out(pos + 7))
+			return haxe.Int64.ofInt(0);
+		return haxe.Int64.make(b.getI32(pos + 4), b.getI32(pos));
+	}
+
+	public function setInt32(pos:Int, v:Int):Void {
+		if (out(pos + 3))
+			throw Error.OutsideBounds;
+		b.setI32(pos, v);
+	}
+
+	public inline function setInt64(pos:Int, v:haxe.Int64):Void {
+		setInt32(pos + 4, v.high);
+		setInt32(pos, v.low);
+	}
+
+	public function getString(pos:Int, len:Int, ?encoding:Encoding):String {
+		if (outRange(pos, len))
+			throw Error.OutsideBounds;
+
+		var b = new hl.Bytes(len + 2);
+		b.blit(0, this.b, pos, len);
+		b[len] = 0;
+		b[len + 1] = 0;
+		return @:privateAccess (encoding == RawNative ? String.fromUCS2(b) : String.fromUTF8(b));
+	}
+
+	@:deprecated("readString is deprecated, use getString instead")
+	@:noCompletion
+	public inline function readString(pos:Int, len:Int):String {
+		return getString(pos, len);
+	}
+
+	public function toString():String {
+		return getString(0, length);
+	}
+
+	public function toHex():String {
+		var s = new StringBuf();
+		var chars = [];
+		var str = "0123456789abcdef";
+		for (i in 0...str.length)
+			chars.push(str.charCodeAt(i));
+		for (i in 0...length) {
+			var c = get(i);
+			s.addChar(chars[c >> 4]);
+			s.addChar(chars[c & 15]);
+		}
+		return s.toString();
+	}
+
+	public inline function getData():BytesData {
+		return new haxe.io.BytesData(b, length);
+	}
+
+	public static function alloc(length:Int):Bytes {
+		var b = new hl.Bytes(length);
+		b.fill(0, length, 0);
+		return new Bytes(b, length);
+	}
+
+	public static function ofString(s:String, ?encoding:Encoding):Bytes@:privateAccess {
+		if (encoding == null)
+			encoding = UTF8;
+		return switch (encoding) {
+			case RawNative:
+				return new Bytes(s.bytes.sub(0, s.length << 1), s.length << 1);
+			case UTF8:
+				var size = 0;
+				var b = s.bytes.utf16ToUtf8(s.length, size);
+				return new Bytes(b, size);
+		}
+	}
+
+	public static function ofData(b:BytesData):Bytes {
+		return new Bytes(b.bytes, b.length);
+	}
+
+	public static function ofHex(s:String):Bytes {
+		var len = s.length;
+		if ((len & 1) != 0)
+			throw "Not a hex string (odd number of digits)";
+		var l = len >> 1;
+		var b = new hl.Bytes(l);
+		for (i in 0...l) {
+			var high = s.charCodeAt(i * 2);
+			var low = s.charCodeAt(i * 2 + 1);
+			high = (high & 0xf) + ((high & 0x40) >> 6) * 9;
+			low = (low & 0xf) + ((low & 0x40) >> 6) * 9;
+			b.setUI8(i, ((high << 4) | low) & 0xff);
+		}
+
+		return new Bytes(b, l);
+	}
+
+	public inline static function fastGet(b:BytesData, pos:Int):Int {
+		return b[pos];
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/io/BytesBuffer.hx

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.io;
+
+@:coreApi
+class BytesBuffer {
+	var b:hl.Bytes;
+	var pos:Int;
+	var size:Int;
+
+	public var length(get, never):Int;
+
+	public function new() {
+		pos = 0;
+		size = 16; // ensure increment of 8
+		b = new hl.Bytes(size);
+	}
+
+	inline function get_length():Int {
+		return pos;
+	}
+
+	public inline function addByte(byte:Int):Void {
+		if (pos == size)
+			__expand(0);
+		b[pos++] = byte;
+	}
+
+	function __expand(req:Int):Void {
+		var nsize = (size * 3) >> 1;
+		if (nsize < req)
+			nsize = req;
+		var b2 = new hl.Bytes(nsize);
+		b2.blit(0, b, 0, pos);
+		b = b2;
+		size = nsize;
+	}
+
+	function __add(b:hl.Bytes, bpos:Int, blen:Int):Void {
+		if (pos + blen > size)
+			__expand(pos + blen);
+		this.b.blit(pos, b, bpos, blen);
+		pos += blen;
+	}
+
+	public inline function add(src:Bytes):Void {
+		__add(@:privateAccess src.b, 0, src.length);
+	}
+
+	public inline function addString(v:String, ?encoding:Encoding):Void {
+		var len = 0;
+		@:privateAccess (encoding == RawNative ? __add(v.bytes, 0, v.length << 1) : __add(v.bytes.utf16ToUtf8(0, len), 0, len));
+	}
+
+	public inline function addInt32(v:Int):Void {
+		if (pos + 4 > size)
+			__expand(0);
+		b.setI32(pos, v);
+		pos += 4;
+	}
+
+	public inline function addInt64(v:haxe.Int64):Void {
+		if (pos + 8 > size)
+			__expand(0);
+		b.setI32(pos, v.low);
+		b.setI32(pos + 4, v.high);
+		pos += 8;
+	}
+
+	public inline function addFloat(v:Float):Void {
+		if (pos + 4 > size)
+			__expand(0);
+		#if hl_check_align
+		if (pos & 3 == 0)
+			b.setF32(pos, v);
+		else @:privateAccess {
+			haxe.io.Bytes.alignBuffer.setF32(0, v);
+			b.blit(pos, haxe.io.Bytes.alignBuffer, 0, 4);
+		}
+		#else
+		b.setF32(pos, v);
+		#end
+		pos += 4;
+	}
+
+	public inline function addDouble(v:Float):Void {
+		if (pos + 8 > size)
+			__expand(0);
+		#if hl_check_align
+		if (pos & 7 == 0)
+			b.setF64(pos, v);
+		else @:privateAccess {
+			haxe.io.Bytes.alignBuffer.setF64(0, v);
+			b.blit(pos, haxe.io.Bytes.alignBuffer, 0, 8);
+		}
+		#else
+		b.setF64(pos, v);
+		#end
+		pos += 8;
+	}
+
+	public inline function addBytes(src:Bytes, pos:Int, len:Int):Void {
+		if (pos < 0 || len < 0 || pos + len > src.length)
+			throw Error.OutsideBounds;
+		__add(@:privateAccess src.b, pos, len);
+	}
+
+	public function getBytes():Bytes {
+		return @:privateAccess new haxe.io.Bytes(b, pos);
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/io/FPHelper.hx

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.io;
+
+class FPHelper {
+	// note : this is not thread safe, use TLS when available
+	static var i64tmp = Int64.ofInt(0);
+	static var helper = new hl.Bytes(8);
+
+	public static function i32ToFloat(i:Int):Single {
+		helper.setI32(0, i);
+		return helper.getF32(0);
+	}
+
+	public static function floatToI32(f:Single):Int {
+		helper.setF32(0, f);
+		return helper.getI32(0);
+	}
+
+	public static function i64ToDouble(low:Int, high:Int):Float {
+		helper.setI32(0, low);
+		helper.setI32(4, high);
+		return helper.getF64(0);
+	}
+
+	public static function doubleToI64(v:Float):Int64 {
+		helper.setF64(0, v);
+		var i64 = i64tmp;
+		@:privateAccess {
+			i64.set_low(helper.getI32(0));
+			i64.set_high(helper.getI32(4));
+		}
+		return i64;
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/zip/Compress.hx

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.zip;
+
+private typedef Deflater = hl.Abstract<"fmt_zip">;
+
+@:coreApi @:hlNative("fmt")
+class Compress {
+	var s:Deflater;
+
+	public function new(level:Int):Void {
+		s = deflate_init(level);
+	}
+
+	public function execute(src:haxe.io.Bytes, srcPos:Int, dst:haxe.io.Bytes, dstPos:Int):{done:Bool, read:Int, write:Int} {
+		var read = 0, write = 0;
+		var done = deflate_buffer(s, src.getData(), srcPos, src.length, dst.getData(), dstPos, dst.length, read, write);
+		return {done: done, read: read, write: write};
+	}
+
+	public function setFlushMode(f:FlushMode):Void {
+		@:privateAccess Uncompress.zip_flush_mode(cast s, f.getIndex());
+	}
+
+	public function close():Void {
+		@:privateAccess Uncompress.zip_end(cast s);
+	}
+
+	public static function run(s:haxe.io.Bytes, level:Int):haxe.io.Bytes {
+		var c = new Compress(level);
+		c.setFlushMode(FlushMode.FINISH);
+		var out = haxe.io.Bytes.alloc(deflate_bound(c.s, s.length));
+		var r = c.execute(s, 0, out, 0);
+		c.close();
+		if (!r.done || r.read != s.length)
+			throw "Compression failed";
+		if (r.write < out.length * 0.66)
+			return out.sub(0, r.write);
+		@:privateAccess out.length = r.write;
+		return out;
+	}
+
+	static function deflate_init(level:Int):Deflater {
+		return null;
+	}
+
+	static function deflate_buffer(i:Deflater, bytes:hl.Bytes, bytesPos:Int, bytesLen:Int, dst:hl.Bytes, dstPos:Int, dstLen:Int, read:hl.Ref<Int>,
+			write:hl.Ref<Int>):Bool {
+		return false;
+	}
+
+	static function deflate_bound(i:Deflater, length:Int):Int {
+		return 0;
+	}
+}

Kha/Tools/linux_arm64/std/hl/_std/haxe/zip/Uncompress.hx

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C)2005-2019 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package haxe.zip;
+
+private typedef Inflater = hl.Abstract<"fmt_zip">;
+
+@:coreApi @:hlNative("fmt")
+class Uncompress {
+	var s:Inflater;
+
+	public function new(?windowBits:Int):Void {
+		s = inflate_init(windowBits);
+	}
+
+	public function execute(src:haxe.io.Bytes, srcPos:Int, dst:haxe.io.Bytes, dstPos:Int):{done:Bool, read:Int, write:Int} {
+		var read = 0, write = 0;
+		var done = inflate_buffer(s, src.getData(), srcPos, src.length, dst.getData(), dstPos, dst.length, read, write);
+		return {done: done, read: read, write: write};
+	}
+
+	public function setFlushMode(f:FlushMode):Void {
+		zip_flush_mode(s, f.getIndex());
+	}
+
+	public function close():Void {
+		zip_end(s);
+	}
+
+	public static function run(src:haxe.io.Bytes, ?bufsize:Int):haxe.io.Bytes {
+		var u = new Uncompress(null);
+		if (bufsize == null)
+			bufsize = 1 << 16; // 64K
+		var tmp = haxe.io.Bytes.alloc(bufsize);
+		var b = new haxe.io.BytesBuffer();
+		var pos = 0;
+		u.setFlushMode(FlushMode.SYNC);
+		while (true) {
+			var r = u.execute(src, pos, tmp, 0);
+			b.addBytes(tmp, 0, r.write);
+			pos += r.read;
+			if (r.done)
+				break;
+		}
+		u.close();
+		return b.getBytes();
+	}
+
+	static function inflate_init(bits:Int):Inflater {
+		return null;
+	}
+
+	static function inflate_buffer(i:Inflater, bytes:hl.Bytes, bytesPos:Int, bytesLen:Int, dst:hl.Bytes, dstPos:Int, dstLen:Int, read:hl.Ref<Int>,
+			write:hl.Ref<Int>):Bool {
+		return false;
+	}
+
+	static function zip_end(i:Inflater):Void {}
+
+	static function zip_flush_mode(i:Inflater, flush:Int):Void {}
+}