whet 0.0.1

package/bin/haxe/io/Output.js

@@ -0,0 +1,126 @@
+import {Error as Error__1} from "./Error.js"
+import {Bytes} from "./Bytes.js"
+import {NotImplementedException} from "../exceptions/NotImplementedException.js"
+import {Exception} from "../Exception.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+An Output is an abstract write. A specific output implementation will only
+have to override the `writeByte` and maybe the `write`, `flush` and `close`
+methods. See `File.write` and `String.write` for two ways of creating an
+Output.
+*/
+export const Output = Register.global("$hxClasses")["haxe.io.Output"] = 
+class Output {
+	
+	/**
+	Write one byte.
+	*/
+	writeByte(c) {
+		throw new NotImplementedException(null, null, {"fileName": "haxe/io/Output.hx", "lineNumber": 47, "className": "haxe.io.Output", "methodName": "writeByte"});
+	}
+	
+	/**
+	Write `len` bytes from `s` starting by position specified by `pos`.
+	
+	Returns the actual length of written data that can differ from `len`.
+	
+	See `writeFullBytes` that tries to write the exact amount of specified bytes.
+	*/
+	writeBytes(s, pos, len) {
+		if (pos < 0 || len < 0 || pos + len > s.length) {
+			throw Exception.thrown(Error__1.OutsideBounds);
+		};
+		var b = s.b;
+		var k = len;
+		while (k > 0) {
+			this.writeByte(b[pos]);
+			++pos;
+			--k;
+		};
+		return len;
+	}
+	
+	/**
+	Write all bytes stored in `s`.
+	*/
+	write(s) {
+		var l = s.length;
+		var p = 0;
+		while (l > 0) {
+			var k = this.writeBytes(s, p, l);
+			if (k == 0) {
+				throw Exception.thrown(Error__1.Blocked);
+			};
+			p += k;
+			l -= k;
+		};
+	}
+	
+	/**
+	Write `len` bytes from `s` starting by position specified by `pos`.
+	
+	Unlike `writeBytes`, this method tries to write the exact `len` amount of bytes.
+	*/
+	writeFullBytes(s, pos, len) {
+		while (len > 0) {
+			var k = this.writeBytes(s, pos, len);
+			pos += k;
+			len -= k;
+		};
+	}
+	
+	/**
+	Write `x` as 16-bit unsigned integer.
+	
+	Endianness is specified by the `bigEndian` property.
+	*/
+	writeUInt16(x) {
+		if (x < 0 || x >= 65536) {
+			throw Exception.thrown(Error__1.Overflow);
+		};
+		if (this.bigEndian) {
+			this.writeByte(x >> 8);
+			this.writeByte(x & 255);
+		} else {
+			this.writeByte(x & 255);
+			this.writeByte(x >> 8);
+		};
+	}
+	
+	/**
+	Write `x` as 32-bit signed integer.
+	
+	Endianness is specified by the `bigEndian` property.
+	*/
+	writeInt32(x) {
+		if (this.bigEndian) {
+			this.writeByte(x >>> 24);
+			this.writeByte(x >> 16 & 255);
+			this.writeByte(x >> 8 & 255);
+			this.writeByte(x & 255);
+		} else {
+			this.writeByte(x & 255);
+			this.writeByte(x >> 8 & 255);
+			this.writeByte(x >> 16 & 255);
+			this.writeByte(x >>> 24);
+		};
+	}
+	
+	/**
+	Write `s` string.
+	*/
+	writeString(s, encoding) {
+		var b = Bytes.ofString(s, encoding);
+		this.writeFullBytes(b, 0, b.length);
+	}
+	static get __name__() {
+		return "haxe.io.Output"
+	}
+	get __class__() {
+		return Output
+	}
+}
+

package/bin/haxe/io/Path.d.ts

@@ -0,0 +1,109 @@
+
+/**
+This class provides a convenient way of working with paths. It supports the
+common path formats:
+
+- `directory1/directory2/filename.extension`
+- `directory1\directory2\filename.extension`
+*/
+export declare class Path {
+	constructor(path: string)
+	
+	/**
+	The directory.
+	
+	This is the leading part of the path that is not part of the file name
+	and the extension.
+	
+	Does not end with a `/` or `\` separator.
+	
+	If the path has no directory, the value is `null`.
+	*/
+	dir: null | string
+	
+	/**
+	The file name.
+	
+	This is the part of the part between the directory and the extension.
+	
+	If there is no file name, e.g. for `".htaccess"` or `"/dir/"`, the value
+	is the empty String `""`.
+	*/
+	file: string
+	
+	/**
+	The file extension.
+	
+	It is separated from the file name by a dot. This dot is not part of
+	the extension.
+	
+	If the path has no extension, the value is `null`.
+	*/
+	ext: null | string
+	
+	/**
+	`true` if the last directory separator is a backslash, `false` otherwise.
+	*/
+	backslash: boolean
+	
+	/**
+	Returns a String representation of `this` path.
+	
+	If `this.backslash` is `true`, backslash is used as directory separator,
+	otherwise slash is used. This only affects the separator between
+	`this.dir` and `this.file`.
+	
+	If `this.directory` or `this.extension` is `null`, their representation
+	is the empty String `""`.
+	*/
+	toString(): string
+	
+	/**
+	Returns the String representation of `path` without the directory.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static withoutDirectory(path: string): string
+	
+	/**
+	Returns the directory of `path`.
+	
+	If the directory is `null`, the empty String `""` is returned.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static directory(path: string): string
+	
+	/**
+	Returns the extension of `path`.
+	
+	If `path` has no extension, the empty String `""` is returned.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static extension(path: string): string
+	
+	/**
+	Normalize a given `path` (e.g. turn `'/usr/local/../lib'` into `'/usr/lib'`).
+	
+	Also replaces backslashes `\` with slashes `/` and afterwards turns
+	multiple slashes into a single one.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static normalize(path: string): string
+	
+	/**
+	Adds a trailing slash to `path`, if it does not have one already.
+	
+	If the last slash in `path` is a backslash, a backslash is appended to
+	`path`.
+	
+	If the last slash in `path` is a slash, or if no slash is found, a slash
+	is appended to `path`. In particular, this applies to the empty String
+	`""`.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static addTrailingSlash(path: string): string
+}

package/bin/haxe/io/Path.js

@@ -0,0 +1,217 @@
+import {Register} from "../../genes/Register.js"
+import {HxOverrides} from "../../HxOverrides.js"
+
+const $global = Register.$global
+
+/**
+This class provides a convenient way of working with paths. It supports the
+common path formats:
+
+- `directory1/directory2/filename.extension`
+- `directory1\directory2\filename.extension`
+*/
+export const Path = Register.global("$hxClasses")["haxe.io.Path"] = 
+class Path extends Register.inherits() {
+	new(path) {
+		switch (path) {
+			case ".":case "..":
+				this.dir = path;
+				this.file = "";
+				return;
+				break
+			
+		};
+		var c1 = path.lastIndexOf("/");
+		var c2 = path.lastIndexOf("\\");
+		if (c1 < c2) {
+			this.dir = HxOverrides.substr(path, 0, c2);
+			path = HxOverrides.substr(path, c2 + 1, null);
+			this.backslash = true;
+		} else if (c2 < c1) {
+			this.dir = HxOverrides.substr(path, 0, c1);
+			path = HxOverrides.substr(path, c1 + 1, null);
+		} else {
+			this.dir = null;
+		};
+		var cp = path.lastIndexOf(".");
+		if (cp != -1) {
+			this.ext = HxOverrides.substr(path, cp + 1, null);
+			this.file = HxOverrides.substr(path, 0, cp);
+		} else {
+			this.ext = null;
+			this.file = path;
+		};
+	}
+	
+	/**
+	Returns a String representation of `this` path.
+	
+	If `this.backslash` is `true`, backslash is used as directory separator,
+	otherwise slash is used. This only affects the separator between
+	`this.dir` and `this.file`.
+	
+	If `this.directory` or `this.extension` is `null`, their representation
+	is the empty String `""`.
+	*/
+	toString() {
+		return ((this.dir == null) ? "" : this.dir + ((this.backslash) ? "\\" : "/")) + this.file + ((this.ext == null) ? "" : "." + this.ext);
+	}
+	
+	/**
+	Returns the String representation of `path` without the directory.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static withoutDirectory(path) {
+		var s = new Path(path);
+		s.dir = null;
+		return s.toString();
+	}
+	
+	/**
+	Returns the directory of `path`.
+	
+	If the directory is `null`, the empty String `""` is returned.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static directory(path) {
+		var s = new Path(path);
+		if (s.dir == null) {
+			return "";
+		};
+		return s.dir;
+	}
+	
+	/**
+	Returns the extension of `path`.
+	
+	If `path` has no extension, the empty String `""` is returned.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static extension(path) {
+		var s = new Path(path);
+		if (s.ext == null) {
+			return "";
+		};
+		return s.ext;
+	}
+	
+	/**
+	Normalize a given `path` (e.g. turn `'/usr/local/../lib'` into `'/usr/lib'`).
+	
+	Also replaces backslashes `\` with slashes `/` and afterwards turns
+	multiple slashes into a single one.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static normalize(path) {
+		var slash = "/";
+		path = path.split("\\").join(slash);
+		if (path == slash) {
+			return slash;
+		};
+		var target = [];
+		var _g = 0;
+		var _g1 = path.split(slash);
+		while (_g < _g1.length) {
+			var token = _g1[_g];
+			++_g;
+			if (token == ".." && target.length > 0 && target[target.length - 1] != "..") {
+				target.pop();
+			} else if (token == "") {
+				if (target.length > 0 || HxOverrides.cca(path, 0) == 47) {
+					target.push(token);
+				};
+			} else if (token != ".") {
+				target.push(token);
+			};
+		};
+		var acc_b = "";
+		var colon = false;
+		var slashes = false;
+		var _g2_offset = 0;
+		var _g2_s = target.join(slash);
+		while (_g2_offset < _g2_s.length) {
+			var s = _g2_s;
+			var index = _g2_offset++;
+			var c = s.charCodeAt(index);
+			if (c >= 55296 && c <= 56319) {
+				c = c - 55232 << 10 | s.charCodeAt(index + 1) & 1023;
+			};
+			var c1 = c;
+			if (c1 >= 65536) {
+				++_g2_offset;
+			};
+			var c2 = c1;
+			switch (c2) {
+				case 47:
+					if (!colon) {
+						slashes = true;
+					} else {
+						var i = c2;
+						colon = false;
+						if (slashes) {
+							acc_b += "/";
+							slashes = false;
+						};
+						acc_b += String.fromCodePoint(i);
+					};
+					break
+				case 58:
+					acc_b += ":";
+					colon = true;
+					break
+				default:
+				var i1 = c2;
+				colon = false;
+				if (slashes) {
+					acc_b += "/";
+					slashes = false;
+				};
+				acc_b += String.fromCodePoint(i1);
+				
+			};
+		};
+		return acc_b;
+	}
+	
+	/**
+	Adds a trailing slash to `path`, if it does not have one already.
+	
+	If the last slash in `path` is a backslash, a backslash is appended to
+	`path`.
+	
+	If the last slash in `path` is a slash, or if no slash is found, a slash
+	is appended to `path`. In particular, this applies to the empty String
+	`""`.
+	
+	If `path` is `null`, the result is unspecified.
+	*/
+	static addTrailingSlash(path) {
+		if (path.length == 0) {
+			return "/";
+		};
+		var c1 = path.lastIndexOf("/");
+		var c2 = path.lastIndexOf("\\");
+		if (c1 < c2) {
+			if (c2 != path.length - 1) {
+				return path + "\\";
+			} else {
+				return path;
+			};
+		} else if (c1 != path.length - 1) {
+			return path + "/";
+		} else {
+			return path;
+		};
+	}
+	static get __name__() {
+		return "haxe.io.Path"
+	}
+	get __class__() {
+		return Path
+	}
+}
+

package/bin/haxe/io/UInt8Array.d.ts

@@ -0,0 +1,2 @@
+
+export type UInt8ArrayData = Uint8Array

package/bin/haxe/iterators/ArrayIterator.d.ts

@@ -0,0 +1,19 @@
+
+/**
+This iterator is used only when `Array<T>` is passed to `Iterable<T>`
+*/
+export declare class ArrayIterator<T> {
+	constructor(array: T[])
+	protected array: T[]
+	protected current: number
+	
+	/**
+	See `Iterator.hasNext`
+	*/
+	hasNext(): boolean
+	
+	/**
+	See `Iterator.next`
+	*/
+	next(): T
+}

package/bin/haxe/iterators/ArrayIterator.js

@@ -0,0 +1,35 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+This iterator is used only when `Array<T>` is passed to `Iterable<T>`
+*/
+export const ArrayIterator = Register.global("$hxClasses")["haxe.iterators.ArrayIterator"] = 
+class ArrayIterator extends Register.inherits() {
+	new(array) {
+		this.current = 0;
+		this.array = array;
+	}
+	
+	/**
+	See `Iterator.hasNext`
+	*/
+	hasNext() {
+		return this.current < this.array.length;
+	}
+	
+	/**
+	See `Iterator.next`
+	*/
+	next() {
+		return this.array[this.current++];
+	}
+	static get __name__() {
+		return "haxe.iterators.ArrayIterator"
+	}
+	get __class__() {
+		return ArrayIterator
+	}
+}
+