whet 0.0.1

package/bin/whet/cache/FileCache.js

@@ -0,0 +1,295 @@
+import {BaseCache} from "./BaseCache.js"
+import {Utils} from "../Utils.js"
+import {SourceHash} from "../SourceHash.js"
+import {SourceData, Source} from "../Source.js"
+import {Log} from "../Log.js"
+import {Path} from "../../haxe/io/Path.js"
+import {StringMap} from "../../haxe/ds/StringMap.js"
+import {Register} from "../../genes/Register.js"
+import * as Fs from "fs"
+import {Reflect as Reflect__1} from "../../Reflect.js"
+import {Lambda} from "../../Lambda.js"
+import {HxOverrides} from "../../HxOverrides.js"
+
+const $global = Register.$global
+
+export const FileCache = Register.global("$hxClasses")["whet.cache.FileCache"] = 
+class FileCache extends Register.inherits(BaseCache) {
+	new(rootDir) {
+		this.flushQueued = false;
+		super.new(rootDir, new StringMap());
+		var norm = "/" + Path.normalize((".whet/cache.json".charAt(0) == "/") ? HxOverrides.substr(".whet/cache.json", 1, null) : ".whet/cache.json");
+		var this1 = (".whet/cache.json".lastIndexOf("/") == ".whet/cache.json".length - 1) ? Path.addTrailingSlash(norm) : norm;
+		this.dbFile = (rootDir.length == 1) ? this1.substring(1) : rootDir.substring(1, rootDir.length - 1) + this1;
+		try {
+			var db = JSON.parse(Fs.readFileSync(this.dbFile, {"encoding": "utf-8"}));
+			var _g_keys = Reflect__1.fields(db);
+			var _g_index = 0;
+			while (_g_index < _g_keys.length) {
+				var key = _g_keys[_g_index++];
+				var _g1_value = db[key];
+				var this1 = this.cache;
+				var _g = [];
+				var _g1 = 0;
+				while (_g1 < _g1_value.length) {
+					var val = _g1_value[_g1];
+					++_g1;
+					var tmp = SourceHash.fromHex(val.hash);
+					var val1 = val.ctime;
+					var s = val.baseDir;
+					var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+					var tmp1 = (s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm;
+					var _g2 = [];
+					var _g3 = 0;
+					var _g4 = val.files;
+					while (_g3 < _g4.length) {
+						var file = _g4[_g3];
+						++_g3;
+						var tmp2 = SourceHash.fromHex(file.fileHash);
+						var s1 = file.filePath;
+						var norm1 = "/" + Path.normalize((s1.charAt(0) == "/") ? HxOverrides.substr(s1, 1, null) : s1);
+						var tmp3 = (s1.lastIndexOf("/") == s1.length - 1) ? Path.addTrailingSlash(norm1) : norm1;
+						var s2 = file.id;
+						var norm2 = "/" + Path.normalize((s2.charAt(0) == "/") ? HxOverrides.substr(s2, 1, null) : s2);
+						_g2.push({"fileHash": tmp2, "filePath": tmp3, "id": (s2.lastIndexOf("/") == s2.length - 1) ? Path.addTrailingSlash(norm2) : norm2});
+					};
+					_g.push({"hash": tmp, "ctime": val1, "baseDir": tmp1, "files": _g2});
+				};
+				this1.inst.set(key, _g);
+			};
+		}catch (_g) {
+		};
+	}
+	key(stone) {
+		return stone.id;
+	}
+	value(source) {
+		var idOverride;
+		var _g = source.origin.cacheStrategy;
+		if (_g._hx_index == 3) {
+			if (source.data.length == 1) {
+				var s = Path.withoutDirectory(_g.path);
+				var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+				idOverride = (s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm;
+			} else {
+				idOverride = null;
+			};
+		} else {
+			idOverride = null;
+		};
+		var _g = [];
+		var _g1 = 0;
+		var _g2 = source.data;
+		while (_g1 < _g2.length) {
+			var data = [_g2[_g1]];
+			++_g1;
+			_g.push(data[0].getFilePathId(idOverride).then((function (data) {
+				return function (filePath) {
+					return {"fileHash": SourceHash.fromBytes(data[0].data), "filePath": filePath, "id": data[0].id};
+				};
+			})(data)));
+		};
+		return Promise.all(_g).then(function (files) {
+			return {"hash": source.hash, "ctime": source.ctime, "baseDir": source.getDirPath(), "ctimePretty": null, "files": files};
+		});
+	}
+	source(stone, value) {
+		var _gthis = this;
+		var _g = stone.cacheStrategy;
+		if (_g._hx_index == 3) {
+			var _g1 = _g.path;
+			var invalidPath;
+			if (value.files.length == 1) {
+				invalidPath = value.files[0].filePath != _g1;
+			} else {
+				var value1 = value.baseDir;
+				var s = Path.addTrailingSlash(Path.directory(_g1));
+				var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+				invalidPath = value1 != ((s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm);
+			};
+			if (invalidPath) {
+				return Promise.resolve(null);
+			};
+		};
+		var _g = [];
+		var _g1 = 0;
+		var _g2 = value.files;
+		while (_g1 < _g2.length) _g.push(new Promise((function (file) {
+			return function (res, rej) {
+				var this1 = file[0].filePath;
+				var root = _gthis.rootDir;
+				SourceData.fromFile(file[0].id, (root.length == 1) ? this1.substring(1) : root.substring(1, root.length - 1) + this1, file[0].filePath).then((function (file) {
+					return function (sourceData) {
+						if (sourceData == null || !stone.ignoreFileHash && !SourceHash.equals(sourceData.hash, file[0].fileHash)) {
+							rej("Wrong hash.");
+						} else {
+							res(sourceData);
+						};
+					};
+				})(file));
+			};
+		})([_g2[_g1++]])));
+		return Promise.all(_g).then(function (data) {
+			return new Source(data, value.hash, stone, value.ctime);
+		}, function (rejected) {
+			if (rejected == "Wrong hash.") {
+				return null;
+			} else {
+				throw rejected;
+				return null;
+			};
+		});
+	}
+	set(source) {
+		var _gthis = this;
+		return super.set(source).then(function (vals) {
+			_gthis.flush();
+			return vals;
+		});
+	}
+	getExistingDirs(stone) {
+		var list = this.cache.inst.get(stone.id);
+		if (list != null) {
+			var result = new Array(list.length);
+			var _g = 0;
+			var _g1 = list.length;
+			while (_g < _g1) {
+				var i = _g++;
+				result[i] = list[i].baseDir;
+			};
+			return result;
+		} else {
+			return null;
+		};
+	}
+	remove(stone, value) {
+		var _gthis = this;
+		Log.log(20, ...["Removing stone from file cache.", {"stone": stone, "valueHash": SourceHash.toHex(value.hash)}]);
+		var isAlone = Lambda.count(this.cache.inst.get(stone.id), function (v) {
+			return v.baseDir == value.baseDir;
+		}) == 1;
+		return super.remove(stone, value).then(function (_) {
+			_gthis.flush();
+			if (!isAlone) {
+				return Promise.resolve(null);
+			} else {
+				var _g = [];
+				var _g1 = 0;
+				var _g2 = value.files;
+				while (_g1 < _g2.length) _g.push(new Promise((function (file) {
+					return function (res, rej) {
+						var this1 = file[0].filePath;
+						var root = _gthis.rootDir;
+						Log.log(20, ...["Deleting file.", {"path": (root.length == 1) ? this1.substring(1) : root.substring(1, root.length - 1) + this1}]);
+						var this1 = file[0].filePath;
+						var root = _gthis.rootDir;
+						Fs.unlink((root.length == 1) ? this1.substring(1) : root.substring(1, root.length - 1) + this1, (function () {
+							return function (err) {
+								if (err != null) {
+									Log.log(50, ...[err]);
+								};
+								res(null);
+							};
+						})());
+					};
+				})([_g2[_g1++]])));
+				return Promise.all(_g);
+			};
+		}).then(function (_) {
+			return new Promise(function (res, rej) {
+				var this1 = value.baseDir;
+				var root = _gthis.rootDir;
+				Fs.readdir((root.length == 1) ? this1.substring(1) : root.substring(1, root.length - 1) + this1, function (err, files) {
+					if (err != null) {
+						Log.log(50, ...[err]);
+						res(null);
+					} else if (files.length == 0) {
+						var this1 = value.baseDir;
+						var root = _gthis.rootDir;
+						Fs.rmdir((root.length == 1) ? this1.substring(1) : root.substring(1, root.length - 1) + this1, function (err) {
+							if (err != null) {
+								Log.log(50, ...[err]);
+							};
+							res(null);
+						});
+					} else {
+						res(null);
+					};
+				});
+			});
+		});
+	}
+	setRecentUseOrder(values, value) {
+		var changed = super.setRecentUseOrder(values, value);
+		if (changed) {
+			this.flush();
+		};
+		return changed;
+	}
+	getDirFor(value) {
+		return value.baseDir;
+	}
+	flush() {
+		var _gthis = this;
+		if (this.flushQueued) {
+			return;
+		};
+		this.flushQueued = true;
+		global.setTimeout(function () {
+			_gthis.flushQueued = false;
+			var db = {};
+			var this1 = _gthis.cache;
+			var _g_keys = this1.keys();
+			while (_g_keys.hasNext()) {
+				var key = _g_keys.next();
+				var _g1_value = this1.get(key);
+				var _g = [];
+				var _g1 = 0;
+				while (_g1 < _g1_value.length) {
+					var val = _g1_value[_g1];
+					++_g1;
+					var tmp = SourceHash.toHex(val.hash);
+					var val1 = val.ctime;
+					var tmp1 = HxOverrides.dateStr(new Date(val.ctime * 1000));
+					var this2 = val.baseDir;
+					var norm = "/" + Path.normalize(("/".charAt(0) == "/") ? HxOverrides.substr("/", 1, null) : "/");
+					var root = ("/".lastIndexOf("/") == "/".length - 1) ? Path.addTrailingSlash(norm) : norm;
+					var tmp2 = (root.length == 1) ? this2.substring(1) : root.substring(1, root.length - 1) + this2;
+					var _g2 = [];
+					var _g3 = 0;
+					var _g4 = val.files;
+					while (_g3 < _g4.length) {
+						var file = _g4[_g3];
+						++_g3;
+						var tmp3 = SourceHash.toHex(file.fileHash);
+						var this3 = file.filePath;
+						var norm1 = "/" + Path.normalize(("/".charAt(0) == "/") ? HxOverrides.substr("/", 1, null) : "/");
+						var root1 = ("/".lastIndexOf("/") == "/".length - 1) ? Path.addTrailingSlash(norm1) : norm1;
+						var tmp4 = (root1.length == 1) ? this3.substring(1) : root1.substring(1, root1.length - 1) + this3;
+						var this4 = file.id;
+						var norm2 = "/" + Path.normalize(("/".charAt(0) == "/") ? HxOverrides.substr("/", 1, null) : "/");
+						var root2 = ("/".lastIndexOf("/") == "/".length - 1) ? Path.addTrailingSlash(norm2) : norm2;
+						_g2.push({"fileHash": tmp3, "filePath": tmp4, "id": (root2.length == 1) ? this4.substring(1) : root2.substring(1, root2.length - 1) + this4});
+					};
+					_g.push({"hash": tmp, "ctime": val1, "ctimePretty": tmp1, "baseDir": tmp2, "files": _g2});
+				};
+				db[key] = _g;
+			};
+			Utils.saveContent(_gthis.dbFile, JSON.stringify(db, null, "\t")).then(function (_) {
+				Log.log(10, ...["FileCache DB saved."]);
+			}, function (err) {
+				Log.log(50, ...["FileCache DB save error.", err]);
+			});
+		}, 100);
+	}
+	static get __name__() {
+		return "whet.cache.FileCache"
+	}
+	static get __super__() {
+		return BaseCache
+	}
+	get __class__() {
+		return FileCache
+	}
+}
+

package/bin/whet/cache/MemoryCache.d.ts

@@ -0,0 +1,12 @@
+import {BaseCache} from "./BaseCache"
+import {AnyStone} from "../Stone"
+import {Source} from "../Source"
+
+export declare class MemoryCache extends BaseCache<AnyStone, Source> {
+	constructor(rootDir: string)
+	protected key(stone: AnyStone): AnyStone
+	protected value(source: Source): Promise<Source>
+	protected source(stone: AnyStone, value: Source): Promise<Source>
+	protected getExistingDirs(stone: AnyStone): string[]
+	protected getDirFor(value: Source): string
+}

package/bin/whet/cache/MemoryCache.js

@@ -0,0 +1,58 @@
+import {BaseCache} from "./BaseCache.js"
+import {ObjectMap} from "../../haxe/ds/ObjectMap.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const MemoryCache = Register.global("$hxClasses")["whet.cache.MemoryCache"] = 
+class MemoryCache extends Register.inherits(BaseCache) {
+	new(rootDir) {
+		super.new(rootDir, new ObjectMap());
+	}
+	key(stone) {
+		return stone;
+	}
+	value(source) {
+		return Promise.resolve(source);
+	}
+	source(stone, value) {
+		return Promise.resolve(value);
+	}
+	getExistingDirs(stone) {
+		var list = this.cache.inst.get(stone);
+		if (list != null) {
+			var result = new Array(list.length);
+			var _g = 0;
+			var _g1 = list.length;
+			while (_g < _g1) {
+				var i = _g++;
+				result[i] = list[i].tryDirPath();
+			};
+			var _g = [];
+			var _g1 = 0;
+			while (_g1 < result.length) {
+				var v = result[_g1];
+				++_g1;
+				if (v != null) {
+					_g.push(v);
+				};
+			};
+			return _g;
+		} else {
+			return null;
+		};
+	}
+	getDirFor(value) {
+		return value.tryDirPath();
+	}
+	static get __name__() {
+		return "whet.cache.MemoryCache"
+	}
+	static get __super__() {
+		return BaseCache
+	}
+	get __class__() {
+		return MemoryCache
+	}
+}
+

package/bin/whet/magic/MaybeArray.d.ts

@@ -0,0 +1,4 @@
+
+export type MaybeArray<T> = T | T[]
+
+export const makeArray: <T>(maybe: MaybeArray<T>) => T[]

package/bin/whet/magic/MaybeArray.js

@@ -0,0 +1,25 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const MaybeArray_Fields_ = Register.global("$hxClasses")["whet.magic._MaybeArray.MaybeArray_Fields_"] = 
+class MaybeArray_Fields_ {
+	static makeArray(maybe) {
+		if (((maybe) instanceof Array)) {
+			return maybe;
+		} else if (maybe == null) {
+			return [];
+		} else {
+			return [maybe];
+		};
+	}
+	static get __name__() {
+		return "whet.magic._MaybeArray.MaybeArray_Fields_"
+	}
+	get __class__() {
+		return MaybeArray_Fields_
+	}
+}
+
+
+export const makeArray = MaybeArray_Fields_.makeArray

package/bin/whet/magic/RoutePathType.d.ts

@@ -0,0 +1,9 @@
+import {Router, RoutePath} from "../route/Router"
+import {BaseRouteType} from "./RouteType"
+
+/**
+* Anything that can be transformed into `Route`.
+*/
+export type RoutePathType = Router | BaseRouteType[][]
+
+export const makeRoutePath: (routerPathType: RoutePathType) => RoutePath[]

package/bin/whet/magic/RoutePathType.js

@@ -0,0 +1,48 @@
+import {Router} from "../route/Router.js"
+import {RouteType_Fields_} from "./RouteType.js"
+import {Path} from "../../haxe/io/Path.js"
+import {Register} from "../../genes/Register.js"
+import {HxOverrides} from "../../HxOverrides.js"
+
+const $global = Register.$global
+
+export const RoutePathType_Fields_ = Register.global("$hxClasses")["whet.magic._RoutePathType.RoutePathType_Fields_"] = 
+class RoutePathType_Fields_ {
+	static makeRoutePath(routerPathType) {
+		if (((routerPathType) instanceof Router)) {
+			return routerPathType.routes;
+		};
+		if (!((routerPathType) instanceof Array)) {
+			throw new Error("RoutePath should be an array.");
+		};
+		var _g = [];
+		var _g1 = 0;
+		var _g2 = routerPathType;
+		while (_g1 < _g2.length) {
+			var item = _g2[_g1];
+			++_g1;
+			if (!((item) instanceof Array)) {
+				throw new Error("RoutePath element should be an array.");
+			};
+			if (item.length < 2) {
+				throw new Error("RoutePath element should have at least 2 entries `[serveId, route]`.");
+			};
+			if (item.length > 3) {
+				throw new Error("RoutePath element should have at most 3 entries `[serveId, route, serveAs]`.");
+			};
+			var s = item[0];
+			var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+			_g.push({"routeUnder": (s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm, "route": RouteType_Fields_.makeRoute([item.slice(1)])});
+		};
+		return _g;
+	}
+	static get __name__() {
+		return "whet.magic._RoutePathType.RoutePathType_Fields_"
+	}
+	get __class__() {
+		return RoutePathType_Fields_
+	}
+}
+
+
+export const makeRoutePath = RoutePathType_Fields_.makeRoutePath

package/bin/whet/magic/RouteType.d.ts

@@ -0,0 +1,12 @@
+import {Route} from "../route/Route"
+import {MaybeArray} from "./MaybeArray"
+import {AnyStone} from "../Stone"
+
+/**
+* Anything that can be transformed into `Route`.
+*/
+export type RouteType = MaybeArray<MaybeArray<BaseRouteType>>
+
+export type BaseRouteType = string | AnyStone
+
+export const makeRoute: (routeType: RouteType) => Route

package/bin/whet/magic/RouteType.js

@@ -0,0 +1,70 @@
+import {Files} from "../stones/Files.js"
+import {Route} from "../route/Route.js"
+import {MaybeArray_Fields_} from "./MaybeArray.js"
+import {Stone} from "../Stone.js"
+import {SourceId} from "../SourceId.js"
+import {Path} from "../../haxe/io/Path.js"
+import {Register} from "../../genes/Register.js"
+import {HxOverrides} from "../../HxOverrides.js"
+
+const $global = Register.$global
+
+export const RouteType_Fields_ = Register.global("$hxClasses")["whet.magic._RouteType.RouteType_Fields_"] = 
+class RouteType_Fields_ {
+	static makeRoute(routeType) {
+		var _g = [];
+		var _g1 = 0;
+		var _g2 = MaybeArray_Fields_.makeArray(routeType);
+		while (_g1 < _g2.length) {
+			var tinner = MaybeArray_Fields_.makeArray(_g2[_g1++]);
+			if (tinner.length == 1) {
+				_g.push(RouteType_Fields_.getRoute(tinner[0]));
+			} else if (tinner.length == 2) {
+				if (typeof(tinner[1]) != "string") {
+					throw new Error("Array-defined route's second element should be path (a string).");
+				};
+				var tinner1 = tinner[0];
+				var s = tinner[1];
+				var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+				_g.push(RouteType_Fields_.getRoute(tinner1, (s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm));
+			};
+		};
+		return new Route(_g);
+	}
+	static getRoute(t, path) {
+		if (typeof(t) == "string") {
+			var tmp = new Files({"paths": [t]});
+			var tmp1;
+			if (path != null) {
+				tmp1 = path;
+			} else {
+				var norm = "/" + Path.normalize((t.charAt(0) == "/") ? HxOverrides.substr(t, 1, null) : t);
+				var p = (t.lastIndexOf("/") == t.length - 1) ? Path.addTrailingSlash(norm) : norm;
+				var s = Path.addTrailingSlash(Path.directory(p));
+				var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+				tmp1 = SourceId.relativeTo(p, (s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm);
+			};
+			return {"stone": tmp, "path": tmp1};
+		} else if (((t) instanceof Stone)) {
+			var tmp;
+			if (path != null) {
+				tmp = path;
+			} else {
+				var norm = "/" + Path.normalize(("/".charAt(0) == "/") ? HxOverrides.substr("/", 1, null) : "/");
+				tmp = ("/".lastIndexOf("/") == "/".length - 1) ? Path.addTrailingSlash(norm) : norm;
+			};
+			return {"stone": t, "path": tmp};
+		} else {
+			throw new Error("Unsupported type for Route.");
+		};
+	}
+	static get __name__() {
+		return "whet.magic._RouteType.RouteType_Fields_"
+	}
+	get __class__() {
+		return RouteType_Fields_
+	}
+}
+
+
+export const makeRoute = RouteType_Fields_.makeRoute

package/bin/whet/magic/StoneId.d.ts

@@ -0,0 +1,5 @@
+import {AnyStone} from "../Stone"
+
+export type StoneIdType = string | any | AnyStone
+
+export const makeStoneId: (id: StoneIdType) => string

package/bin/whet/magic/StoneId.js

@@ -0,0 +1,32 @@
+import {Stone} from "../Stone.js"
+import {Boot} from "../../js/Boot.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const StoneId_Fields_ = Register.global("$hxClasses")["whet.magic._StoneId.StoneId_Fields_"] = 
+class StoneId_Fields_ {
+	static makeStoneId(id) {
+		if (typeof(id) == "string") {
+			return id;
+		} else if (Boot.__instanceof(id, "$hxCoreType__Class")) {
+			return StoneId_Fields_.makeStoneIdFromClass(id);
+		} else if (((id) instanceof Stone)) {
+			return StoneId_Fields_.makeStoneIdFromClass(Boot.getClass(id));
+		} else {
+			throw new Error("Unsupported type for StoneId.");
+		};
+	}
+	static makeStoneIdFromClass(c) {
+		return c.__name__.split(".").pop();
+	}
+	static get __name__() {
+		return "whet.magic._StoneId.StoneId_Fields_"
+	}
+	get __class__() {
+		return StoneId_Fields_
+	}
+}
+
+
+export const makeStoneId = StoneId_Fields_.makeStoneId

package/bin/whet/route/Route.d.ts

@@ -0,0 +1,15 @@
+import {RouteResult} from "./RouteResult"
+import {AnyStone} from "../Stone"
+import {SourceData} from "../Source"
+
+export declare class Route {
+	constructor(routes: RouteData[])
+	protected routes: RouteData[]
+	list(): Promise<RouteResult[]>
+	getData(): Promise<SourceData[]>
+}
+
+export type RouteData = {
+	path: string, 
+	stone: AnyStone
+}

package/bin/whet/route/Route.js

@@ -0,0 +1,81 @@
+import {RouteResult} from "./RouteResult.js"
+import {Path} from "../../haxe/io/Path.js"
+import {Register} from "../../genes/Register.js"
+import {HxOverrides} from "../../HxOverrides.js"
+
+const $global = Register.$global
+
+export const Route = Register.global("$hxClasses")["whet.route.Route"] = 
+class Route extends Register.inherits() {
+	new(routes) {
+		this.routes = routes;
+	}
+	list() {
+		var _g = [];
+		var _g1 = 0;
+		var _g2 = this.routes;
+		while (_g1 < _g2.length) {
+			var r = [_g2[_g1]];
+			++_g1;
+			_g.push(r[0].stone.list().then((function (r) {
+				return function (list) {
+					var arr = [];
+					var this1 = r[0].path;
+					var norm = "/" + Path.normalize((this1.charAt(0) == "/") ? HxOverrides.substr(this1, 1, null) : this1);
+					var tmp = (this1.lastIndexOf("/") == this1.length - 1) ? Path.addTrailingSlash(norm) : norm;
+					var s = Path.addTrailingSlash(Path.directory(this1));
+					var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+					if (tmp == ((s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm)) {
+						var _g = 0;
+						while (_g < list.length) {
+							var path = list[_g];
+							++_g;
+							arr.push(new RouteResult(path, path, r[0].stone));
+						};
+					} else {
+						var _g = 0;
+						while (_g < list.length) {
+							var path = list[_g];
+							++_g;
+							if (path == r[0].path) {
+								var _g1 = r[0].stone;
+								var s = Path.withoutDirectory(path);
+								var norm = "/" + Path.normalize((s.charAt(0) == "/") ? HxOverrides.substr(s, 1, null) : s);
+								arr.push(new RouteResult((s.lastIndexOf("/") == s.length - 1) ? Path.addTrailingSlash(norm) : norm, path, _g1));
+							};
+						};
+					};
+					return arr;
+				};
+			})(r)));
+		};
+		return Promise.all(_g).then(function (data) {
+			var _g = [];
+			var _g_current = 0;
+			while (_g_current < data.length) {
+				var x = Register.iter(data[_g_current++]);
+				while (x.hasNext()) _g.push(x.next());
+			};
+			return _g;
+		});
+	}
+	getData() {
+		return this.list().then(function (l) {
+			var result = new Array(l.length);
+			var _g = 0;
+			var _g1 = l.length;
+			while (_g < _g1) {
+				var i = _g++;
+				result[i] = l[i].get();
+			};
+			return Promise.all(result);
+		});
+	}
+	static get __name__() {
+		return "whet.route.Route"
+	}
+	get __class__() {
+		return Route
+	}
+}
+