smoothly 1.0.0-alpha.191 → 1.0.0-alpha.192

package/dist/cjs/Tuple-0ed9d0da.js

@@ -0,0 +1,2895 @@
+'use strict';
+
+class Rule {
+    filter(value) {
+        return value.filter(element => this.is(element));
+    }
+    stringify(precedence = 0) {
+        let result = this.toString();
+        if (this.precedence < precedence)
+            result = "(" + result + ")";
+        return result;
+    }
+}
+const creators = [
+    criteria => (criteria instanceof Rule ? criteria : undefined),
+];
+function add$1(create) {
+    creators.push(create);
+}
+let always;
+function setFallback(fallback) {
+    always = fallback;
+}
+function create(criteria) {
+    let result;
+    for (const c of creators) {
+        result = c(criteria);
+        if (result)
+            break;
+    }
+    return result || always;
+}
+
+class Always extends Rule {
+    constructor() {
+        super();
+        this.precedence = Number.MAX_SAFE_INTEGER;
+        this.class = "Always";
+    }
+    is(value) {
+        return true;
+    }
+    toString() {
+        return "";
+    }
+}
+setFallback(new Always());
+
+class Any extends Rule {
+    constructor(criteria) {
+        super();
+        this.criteria = criteria;
+        this.precedence = 50;
+        this.class = "Any";
+    }
+    is(value) {
+        return (value &&
+            typeof value == "object" &&
+            Object.getOwnPropertyNames(value).some(property => this.criteria.is(value[property]) || this.is(value[property])));
+    }
+    toString() {
+        return this.criteria.stringify(this.precedence);
+    }
+}
+
+class And extends Rule {
+    constructor(rules) {
+        super();
+        this.precedence = 40;
+        this.class = "And";
+        this.rules = rules.reduce((r, e) => (e instanceof And ? [...r, ...e.rules] : [...r, e]), []);
+    }
+    is(value) {
+        return this.rules.every(c => c.is(value));
+    }
+    toString() {
+        return this.rules.map(c => c.stringify(this.precedence)).join(" ");
+    }
+    generalize() {
+        return new And(this.rules.map(r => (r.class == "Property" ? r : new Any(r))));
+    }
+}
+function and(...criterias) {
+    return new And(criterias.map(create));
+}
+
+var Criteria;
+(function (Criteria) {
+    Criteria.is = isCriteria;
+})(Criteria || (Criteria = {}));
+function isCriteria(value, recursive = false) {
+    return (typeof value == "number" ||
+        typeof value == "string" ||
+        value instanceof Rule ||
+        (recursive &&
+            typeof value == "object" &&
+            value &&
+            Object.values(value).every(value => Array.isArray(value) ? value.every(value => isCriteria(value, true)) : isCriteria(value, true))));
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+var Level_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+(function (Level) {
+    Level[Level["Logging"] = 0] = "Logging";
+    Level[Level["Debug"] = 1] = "Debug";
+    Level[Level["Warning"] = 2] = "Warning";
+    Level[Level["Recoverable"] = 3] = "Recoverable";
+    Level[Level["Critical"] = 4] = "Critical";
+})(exports.Level || (exports.Level = {}));
+//# sourceMappingURL=Level.js.map
+});
+
+var Message_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class Message {
+    constructor(description, level = Level_1.Level.Recoverable, type = "unknown", region) {
+        this.description = description;
+        this.level = level;
+        this.type = type;
+        this.region = region;
+    }
+    toString() {
+        return Level_1.Level[this.level] + ": " + this.type + " error. " + this.description + (this.region ? " @ " + this.region.toString() : "");
+    }
+}
+exports.Message = Message;
+//# sourceMappingURL=Message.js.map
+});
+
+var ConsoleHandler_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class ConsoleHandler {
+    raise(message, level, type, region) {
+        if (!(message instanceof Message_1.Message))
+            message = new Message_1.Message(message, level, type, region);
+        console.error(message.toString());
+    }
+}
+exports.ConsoleHandler = ConsoleHandler;
+//# sourceMappingURL=ConsoleHandler.js.map
+});
+
+var Position_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+class Position {
+    constructor(line, column) {
+        this.line = line;
+        this.column = column;
+    }
+    toString() {
+        return "Ln " + this.line + ", Col " + this.column;
+    }
+}
+exports.Position = Position;
+//# sourceMappingURL=Position.js.map
+});
+
+var Location_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class Location extends Position_1.Position {
+    constructor(resource, line, column) {
+        super(line, column);
+        this.resource = resource;
+    }
+    toString() {
+        return this.resource.toString() + " @ " + super.toString();
+    }
+}
+exports.Location = Location;
+//# sourceMappingURL=Location.js.map
+});
+
+var Region_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+class Region {
+    constructor(resource, start, end, content) {
+        this.resource = resource;
+        this.start = start;
+        this.end = end;
+        this.content = content;
+    }
+    merge(other) { return other ? new Region(this.resource, this.start, other.end, this.content ? this.content : "" + other.content ? other.content : "") : this; }
+    toString() {
+        let result = this.resource.toString();
+        if (this.start && this.end)
+            result += " (" + this.start.toString() + " - " + this.end.toString() + ") ";
+        if (this.content)
+            result += this.content;
+        return result;
+    }
+}
+exports.Region = Region;
+//# sourceMappingURL=Region.js.map
+});
+
+var _Error = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+exports.ConsoleHandler = ConsoleHandler_1.ConsoleHandler;
+
+exports.Level = Level_1.Level;
+
+exports.Location = Location_1.Location;
+
+exports.Message = Message_1.Message;
+
+exports.Position = Position_1.Position;
+
+exports.Region = Region_1.Region;
+//# sourceMappingURL=index.js.map
+});
+
+var User_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+class User {
+    constructor(name, password) {
+        this.name = name;
+        this.password = password;
+    }
+    get isEmpty() {
+        return !this.name && !this.password;
+    }
+    toString() {
+        let result = "";
+        if (this.name)
+            result = this.name;
+        if (this.password)
+            result += ":" + this.password;
+        return result;
+    }
+    static parse(data) {
+        let result;
+        if (data) {
+            const splitted = data.split(":", 2);
+            result = new User(splitted[0], splitted[1]);
+        }
+        else
+            result = new User();
+        return result;
+    }
+}
+exports.User = User;
+//# sourceMappingURL=User.js.map
+});
+
+var Endpoint_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+class Endpoint {
+    constructor(host = [], port) {
+        this.host = host;
+        this.port = port;
+    }
+    get isEmpty() {
+        return this.host.length == 0 && !this.port;
+    }
+    toString() {
+        let result = this.host.join(".");
+        if (this.port)
+            result += ":" + this.port.toString();
+        return result;
+    }
+    static parse(data) {
+        let result;
+        if (data) {
+            const splitted = data.split(":", 2);
+            result = new Endpoint(splitted[0].split("."), splitted.length > 1 ? parseInt(splitted[1]) : undefined);
+        }
+        else
+            result = new Endpoint();
+        return result;
+    }
+}
+exports.Endpoint = Endpoint;
+//# sourceMappingURL=Endpoint.js.map
+});
+
+var Authority_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+class Authority {
+    constructor(user = new User_1.User(), endpoint = new Endpoint_1.Endpoint()) {
+        this.user = user;
+        this.endpoint = endpoint;
+    }
+    get isEmpty() {
+        return this.user.isEmpty && this.endpoint.isEmpty;
+    }
+    toString() {
+        let result = "";
+        if (!this.user.isEmpty)
+            result = this.user.toString() + "@";
+        if (!this.endpoint.isEmpty)
+            result = result + this.endpoint.toString();
+        return result;
+    }
+    static parse(data) {
+        let result;
+        if (data) {
+            const splitted = data.split("@", 2);
+            result = new Authority(User_1.User.parse(splitted.length == 2 ? splitted.pop() : undefined), Endpoint_1.Endpoint.parse(splitted.pop()));
+        }
+        return result;
+    }
+}
+exports.Authority = Authority;
+//# sourceMappingURL=Authority.js.map
+});
+
+var Locator_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class Locator {
+    constructor(scheme = [], authority = new Authority_1.Authority(), path = [], query = {}, fragment) {
+        this.scheme = scheme;
+        this.authority = authority;
+        this.path = path;
+        this.query = query;
+        this.fragment = fragment;
+    }
+    get isRelative() {
+        return this.path[0] == "." || this.path[0] == "..";
+    }
+    get isFolder() {
+        return this.path[this.path.length - 1] == "";
+    }
+    get folder() {
+        return this.isFolder ? this : new Locator(this.scheme, this.authority, this.path.filter((value, index) => index < this.path.length - 1), this.query, this.fragment);
+    }
+    get name() {
+        return this.path[this.path.length - 1];
+    }
+    get extension() {
+        const splitted = this.name.split(".");
+        return splitted.length > 1 ? splitted[splitted.length - 1] : "";
+    }
+    createArray(value, count) {
+        const result = [];
+        while (count-- > 0)
+            result.push(value);
+        return result;
+    }
+    normalize() {
+        let skip = 0;
+        const path = this.path.reverse().filter((item, index) => {
+            let r = false;
+            if ((item == "" || item == ".") && index < this.path.length - 1)
+                r = false;
+            else if (item == "..")
+                skip++;
+            else if (skip > 0)
+                skip--;
+            else
+                r = true;
+            return r;
+        }).concat(this.createArray("..", skip)).reverse();
+        return new Locator(this.scheme, this.authority, path, this.query, this.fragment);
+    }
+    resolve(absolute) {
+        return !absolute ? this : new Locator(this.scheme.length > 0 ? this.scheme : absolute.scheme, !this.authority.isEmpty ? this.authority : absolute.authority, this.isRelative ? absolute.folder.path.concat(this.path) : this.path, this.query, this.fragment).normalize();
+    }
+    appendPath(path) {
+        return new Locator(this.scheme, this.authority, path instanceof Array ? [...this.path, ...path] : [...this.path, path], this.query, this.fragment);
+    }
+    toString() {
+        let result = "";
+        if (this.scheme.length > 0)
+            result += this.scheme.join("+") + ":";
+        if (!this.authority.isEmpty)
+            result += "//" + this.authority.toString();
+        else if (this.scheme.length > 0)
+            result += "//";
+        if (this.path) {
+            let path = this.path.join("/");
+            if (path[0] != "." || result.length > 0)
+                path = "/" + path;
+            result += path;
+        }
+        if (Object.keys(this.query).length > 0)
+            result += "?" + this.query.toString();
+        if (this.fragment)
+            result += "#" + this.fragment;
+        return result;
+    }
+    static parse(data) {
+        let result;
+        switch (data) {
+            case "":
+            case null:
+            case undefined:
+                break;
+            default:
+                let hasAuthority = true;
+                let scheme = [];
+                let splitted = data.split("://", 2);
+                if (splitted.length > 1) {
+                    scheme = (splitted.shift() || "").split("+");
+                    data = splitted.shift();
+                }
+                else if (data.slice(0, 2) == "//")
+                    data = data.slice(2);
+                else
+                    hasAuthority = false;
+                let index;
+                let fragment;
+                if (data && (index = data.lastIndexOf("#")) > -1) {
+                    fragment = data.slice(index + 1);
+                    data = data.slice(0, index);
+                }
+                let query = {};
+                if (data && (index = data.lastIndexOf("?")) > -1) {
+                    query = new Object();
+                    data.slice(index + 1).split(";").forEach(element => {
+                        splitted = element.split("=");
+                        const key = splitted.shift();
+                        const value = splitted.shift();
+                        if (key && value)
+                            query[key] = value;
+                    });
+                    data = data.slice(0, index);
+                }
+                let authority;
+                let path = [];
+                if (data) {
+                    splitted = data.split("/");
+                    if (splitted.length > 0) {
+                        switch (splitted[0]) {
+                            case ".":
+                            case "..":
+                                break;
+                            case "":
+                                splitted.shift();
+                                break;
+                            default:
+                                if (hasAuthority)
+                                    authority = Authority_1.Authority.parse(splitted.shift());
+                                else
+                                    splitted.unshift(".");
+                                break;
+                        }
+                        path = splitted;
+                    }
+                }
+                result = new Locator(scheme, authority, path, query, fragment);
+                break;
+        }
+        return result;
+    }
+}
+exports.Locator = Locator;
+Locator.empty = new Locator(undefined, undefined, undefined, undefined, undefined);
+//# sourceMappingURL=Locator.js.map
+});
+
+var Uri = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+exports.Authority = Authority_1.Authority;
+
+exports.Endpoint = Endpoint_1.Endpoint;
+
+exports.Locator = Locator_1.Locator;
+
+exports.User = User_1.User;
+//# sourceMappingURL=index.js.map
+});
+
+var Device_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+class Device {
+}
+exports.Device = Device;
+//# sourceMappingURL=Device.js.map
+});
+
+var InDevice_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class InDevice extends Device_1.Device {
+}
+exports.InDevice = InDevice;
+//# sourceMappingURL=InDevice.js.map
+});
+
+var Reader_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class Reader extends InDevice_1.InDevice {
+    static addOpener(open, priority) {
+        if (!priority)
+            priority = 0;
+        Reader.openers.push({ open, priority });
+        Reader.openers = Reader.openers.sort((left, right) => right.priority - left.priority);
+    }
+    static open(locator) {
+        let result;
+        let i = 0;
+        do
+            result = Reader.openers[i++].open(locator);
+        while (!result && i < Reader.openers.length);
+        return result;
+    }
+}
+exports.Reader = Reader;
+Reader.openers = [];
+//# sourceMappingURL=Reader.js.map
+});
+
+var BufferedReader_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+
+var Reader_2 = Reader_1;
+exports.Reader = Reader_2.Reader;
+class BufferedReader extends Reader_1.Reader {
+    constructor(backend) {
+        super();
+        this.backend = backend;
+        this.buffer = [];
+        this.lastContent = "";
+        this.lastMark = this.locationValue = this.backend.location;
+    }
+    get tabSize() { return this.backend.tabSize; }
+    set tabSize(size) { this.backend.tabSize = size; }
+    get readable() { return !!this.backend; }
+    get opened() { return !!this.backend; }
+    get isEmpty() { return (this.buffer.length == 0 || this.buffer[0].data == "\0") && this.backend.isEmpty; }
+    get resource() {
+        const location = this.location;
+        return location ? location.resource : Uri.Locator.empty;
+    }
+    get location() {
+        return this.locationValue;
+    }
+    get region() {
+        return new _Error.Region(this.resource, this.lastMark, this.location, this.lastContent);
+    }
+    close() {
+        return this.backend.close();
+    }
+    peek(length) {
+        if (!length)
+            length = 1;
+        let next;
+        while (length > this.buffer.length && (next = this.backend.read()))
+            this.buffer.push({ data: next, location: this.backend.location });
+        return this.buffer.length == 0 ? undefined : this.buffer.slice(0, length > this.buffer.length ? this.buffer.length : length).map(value => value.data).join("");
+    }
+    read(length) {
+        if (!length)
+            length = 1;
+        const result = this.peek(length);
+        if (result && result.length > 0) {
+            this.locationValue = this.buffer[result.length - 1].location;
+            this.buffer.splice(0, result.length);
+            this.lastContent += result;
+        }
+        return result;
+    }
+    peekIs(value, count) {
+        let result;
+        if (value)
+            if (typeof (value) == "string") {
+                const v = value;
+                while (count && count-- > 0)
+                    value += v;
+                result = this.peek(value.length) == value ? value : undefined;
+            }
+            else if (value.length > 0 && !(result = this.peekIs(value[0])) && value.length)
+                result = this.peekIs(value.slice(1));
+        return result;
+    }
+    readIf(value) {
+        let result;
+        if (value)
+            if (typeof (value) == "string")
+                result = this.peek(value.length) == value && this.read(value.length) || undefined;
+            else if (value.length > 0 && !(result = this.readIf(value[0])) && value.length)
+                result = this.readIf(value.slice(1));
+        return result;
+    }
+    readAll() {
+        let result = "";
+        while (this.peek())
+            result += this.read();
+        return result != "" ? result : undefined;
+    }
+    mark() {
+        const result = this.region;
+        this.lastMark = this.location;
+        this.lastContent = "";
+        return result;
+    }
+    static create(backend) {
+        return backend ? new BufferedReader(backend) : undefined;
+    }
+}
+exports.BufferedReader = BufferedReader;
+//# sourceMappingURL=BufferedReader.js.map
+});
+
+var fs_browser = createCommonjsModule(function (module, exports) {
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function close(fd) {
+    return __awaiter(this, void 0, void 0, function* () { });
+}
+exports.close = close;
+function fsync(fd) {
+    return __awaiter(this, void 0, void 0, function* () { });
+}
+exports.fsync = fsync;
+function open(path, flags, mode) {
+    return __awaiter(this, void 0, void 0, function* () { return 0; });
+}
+exports.open = open;
+function write(fd, buffer, offset, encoding) {
+    return __awaiter(this, void 0, void 0, function* () { return { bytesWritten: 0 }; });
+}
+exports.write = write;
+function lstatSync(path, options) { return { isDirectory: () => false }; }
+exports.lstatSync = lstatSync;
+function readdirSync(path) { return []; }
+exports.readdirSync = readdirSync;
+function readFileSync(path, encoding) { return ""; }
+exports.readFileSync = readFileSync;
+//# sourceMappingURL=fs.browser.js.map
+});
+
+var path_browser = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+const sep = "/";
+exports.sep = sep;
+//# sourceMappingURL=path.browser.js.map
+});
+
+var StringReader_1 = createCommonjsModule(function (module, exports) {
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+
+class StringReader extends Reader_1.Reader {
+    constructor(content, resource) {
+        super();
+        this.content = content;
+        this.resource = resource;
+        this.tabSize = 2;
+        this.count = 0;
+        this.line = 1;
+        this.column = 1;
+        this.lastContent = "";
+        this.readable = true;
+        this.content += "\0";
+        this.lastPosition = this.location;
+    }
+    get opened() { return this.count + 1 >= this.content.length; }
+    get isEmpty() { return this.opened; }
+    get location() { return new _Error.Location(this.resource, this.line, this.column); }
+    get region() { return new _Error.Region(this.resource, this.lastPosition, this.location, this.lastContent); }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = !(yield this.isEmpty);
+            if (result)
+                this.count = this.content.length;
+            return result;
+        });
+    }
+    read() {
+        let result;
+        if (this.count < this.content.length)
+            result = this.content.charAt(this.count);
+        else if (this.count == this.content.length)
+            result = undefined;
+        this.count++;
+        if (result) {
+            switch (result) {
+                case "\n":
+                    this.line++;
+                    this.column = 1;
+                    break;
+                case "\t":
+                    this.column += this.tabSize;
+                    break;
+                default:
+                    this.column++;
+                    break;
+            }
+            this.lastContent += result;
+        }
+        return result;
+    }
+    mark() {
+        const result = this.region;
+        this.lastPosition = this.location;
+        this.lastContent = "";
+        return result;
+    }
+    static create(content, resource) {
+        return content != undefined ? new StringReader(content, resource || Uri.Locator.empty) : undefined;
+    }
+}
+exports.StringReader = StringReader;
+//# sourceMappingURL=StringReader.js.map
+});
+
+var FileReader_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+
+
+
+class FileReader extends Reader_1.Reader {
+    constructor(backend) {
+        super();
+        this.backend = backend;
+    }
+    get tabSize() { return this.backend.tabSize; }
+    set tabSize(size) { this.backend.tabSize = size; }
+    get readable() { return this.backend.readable; }
+    get opened() { return this.backend.opened; }
+    get isEmpty() { return this.backend.isEmpty; }
+    get resource() { return this.backend ? this.backend.resource : Uri.Locator.empty; }
+    get location() { return this.backend.location; }
+    get region() { return this.backend.region; }
+    close() {
+        return this.backend.close();
+    }
+    read() { return this.backend.read(); }
+    mark() { return this.backend.mark(); }
+    static open(resource) {
+        let backend;
+        if (resource && (resource.scheme.length == 0 || resource.scheme.length == 1 && resource.scheme[0] == "file"))
+            try {
+                backend = StringReader_1.StringReader.create(fs_browser.readFileSync((resource.isRelative ? "" : path_browser.sep) + resource.path.join(path_browser.sep), "utf-8"), resource);
+            }
+            catch (error) {
+                console.log(`Failed to open file: ${resource.toString()}`);
+            }
+        return backend ? new FileReader(backend) : undefined;
+    }
+}
+exports.FileReader = FileReader;
+Reader_1.Reader.addOpener(p => FileReader.open(p), 10);
+//# sourceMappingURL=FileReader.js.map
+});
+
+var FolderReader_1 = createCommonjsModule(function (module, exports) {
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+
+
+
+
+class FolderReader extends Reader_1.Reader {
+    constructor(files) {
+        super();
+        this.files = files;
+        this.tabSizeValue = 2;
+        this.lastLocation = new _Error.Location(Uri.Locator.empty, 0, 0);
+    }
+    get tabSize() { return this.tabSizeValue; }
+    set tabSize(size) {
+        this.tabSizeValue = size;
+        if (this.current)
+            this.current.tabSize = size;
+    }
+    get readable() { return this.current != undefined && this.current.readable || this.files.length > 0; }
+    get opened() { return this.current != undefined || this.files.length > 0; }
+    get isEmpty() { return this.files.length == 0 && (!this.current || this.current.isEmpty); }
+    get resource() { return this.current ? this.current.resource : this.lastLocation.resource; }
+    get location() { return this.current ? this.current.location : this.lastLocation; }
+    get region() { return this.current ? this.current.region : new _Error.Region(this.resource); }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.current != undefined && (yield this.current.close());
+        });
+    }
+    read() {
+        let result;
+        if (!this.current && this.files.length > 0) {
+            this.current = FileReader_1.FileReader.open(this.files.shift());
+            this.current.tabSize = this.tabSize;
+        }
+        if (this.current) {
+            result = this.current.read();
+            if (result == undefined || result == "\0") {
+                this.current.close();
+                this.current = undefined;
+            }
+        }
+        this.lastLocation = this.location;
+        return result;
+    }
+    mark() { return this.current ? this.current.mark() : new _Error.Region(this.resource); }
+    static getFiles(folder, filetype, ignoreFiles = []) {
+        let result = [];
+        const files = fs_browser.readdirSync(folder);
+        files.forEach(file => {
+            const filename = folder + path_browser.sep + file;
+            if (ignoreFiles.indexOf(filename) == -1) {
+                if (fs_browser.lstatSync(filename).isDirectory())
+                    result = result.concat(FolderReader.getFiles(filename, filetype, ignoreFiles));
+                else if (file.length > filetype.length && file.lastIndexOf(filetype, file.length - filetype.length) === file.length - filetype.length)
+                    result.push(filename);
+            }
+        });
+        return result;
+    }
+    static open(resource) {
+        let files;
+        try {
+            if (resource && (resource.scheme.length == 0 || resource.scheme.length == 1 && resource.scheme[0] == "file") && resource.isFolder || resource.name.match("*"))
+                files = FolderReader.getFiles((resource.isRelative ? "" : path_browser.sep) + resource.folder.path.join(path_browser.sep), resource.extension);
+        }
+        catch (error) {
+        }
+        return files ? new FolderReader(files.map(f => new Uri.Locator(["file"], undefined, f.split(path_browser.sep)))) : undefined;
+    }
+}
+exports.FolderReader = FolderReader;
+Reader_1.Reader.addOpener((resource) => FolderReader.open(resource), 0);
+//# sourceMappingURL=FolderReader.js.map
+});
+
+var Enumerator_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+function* generate(next) {
+    let result;
+    while ((result = next()) != undefined)
+        yield result;
+}
+function isIterator(item) {
+    return item.next instanceof Function;
+}
+function* merge(left, right) {
+    let result;
+    while (!(result = left.next()).done)
+        yield result.value;
+    if (isIterator(right))
+        while (!(result = right.next()).done)
+            yield result.value;
+    else
+        yield right;
+}
+class Enumerator {
+    constructor(backend) {
+        this.iterator = backend instanceof Function ? generate(backend) : backend;
+    }
+    get length() {
+        let result = 0;
+        while (!this.next().done)
+            result++;
+        return result;
+    }
+    get last() {
+        return this.nextValue && !this.nextValue.done ? this.nextValue.value : undefined;
+    }
+    fetch() {
+        const result = this.next();
+        return result.done ? undefined : result.value;
+    }
+    next(value) {
+        return this.nextValue = this.iterator.next(value);
+    }
+    append(item) {
+        return new Enumerator(merge(this, item));
+    }
+    map(mapping) {
+        return new Enumerator(() => {
+            const item = this.fetch();
+            return (item != undefined) ? mapping(item) : undefined;
+        });
+    }
+    reduce(reduce, result) {
+        const item = this.fetch();
+        return item ? this.reduce(reduce, reduce(result, item)) : result;
+    }
+    apply(apply) {
+        const item = this.fetch();
+        if (item) {
+            apply(item);
+            this.apply(apply);
+        }
+    }
+    filter(filter) {
+        return new Enumerator(() => {
+            let item;
+            do
+                item = this.fetch();
+            while (item != undefined && !filter(item));
+            return item;
+        });
+    }
+    toArray() {
+        const item = this.fetch();
+        let result;
+        if (!item)
+            result = [];
+        else {
+            result = this.toArray();
+            result.unshift(item);
+        }
+        return result;
+    }
+    static from(backend) {
+        return new Enumerator(backend);
+    }
+}
+exports.Enumerator = Enumerator;
+Enumerator.empty = Enumerator.from(() => undefined);
+//# sourceMappingURL=Enumerator.js.map
+});
+
+var Enumerable_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+function isIterable(other) {
+    return other == null ? false : typeof other[Symbol.iterator] === "function";
+}
+class Enumerable {
+    constructor(get) {
+        this.get = get;
+    }
+    get length() {
+        return this.get().length;
+    }
+    get first() {
+        return this.get().fetch();
+    }
+    get last() {
+        return this.get().last;
+    }
+    getEnumerator() {
+        return new Enumerator_1.Enumerator(this.get());
+    }
+    [Symbol.iterator]() {
+        return this.getEnumerator();
+    }
+    append(item) {
+        return new Enumerable(() => this.get().append(item));
+    }
+    map(mapping) {
+        return new Enumerable(() => this.get().map(mapping));
+    }
+    reduce(reduce, result) {
+        return this.get().reduce(reduce, result);
+    }
+    apply(apply) {
+        this.get().apply(apply);
+    }
+    filter(filter) {
+        return new Enumerable(() => this.get().filter(filter));
+    }
+    toArray() {
+        return this.getEnumerator().toArray();
+    }
+    static from(get) {
+        return isIterable(get) ? new Enumerable(() => new Enumerator_1.Enumerator(get[Symbol.iterator]())) : new Enumerable(() => {
+            const r = get();
+            return r instanceof Enumerator_1.Enumerator ? r : new Enumerator_1.Enumerator(r);
+        });
+    }
+}
+exports.Enumerable = Enumerable;
+Enumerable.empty = Enumerable.from([]);
+//# sourceMappingURL=Enumerable.js.map
+});
+
+var ArrayEnumerator_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class ArrayEnumerator extends Enumerator_1.Enumerator {
+    constructor(backend) {
+        super(() => this.position < this.backend.length ? this.backend[this.position++] : undefined);
+        this.backend = backend;
+        this.position = 0;
+    }
+}
+exports.ArrayEnumerator = ArrayEnumerator;
+//# sourceMappingURL=ArrayEnumerator.js.map
+});
+
+var BufferedEnumerator_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class BufferedEnumerator extends Enumerator_1.Enumerator {
+    constructor(backend) {
+        super(() => {
+            const result = this.peek(0);
+            if (this.buffer.length > 0)
+                this.buffer.shift();
+            return result;
+        });
+        this.backend = backend;
+        this.buffer = [];
+    }
+    peek(position) {
+        if (!position)
+            position = 0;
+        let next;
+        while (position > this.buffer.length - 1 && (next = this.backend.fetch()))
+            this.buffer.push(next);
+        return position > this.buffer.length - 1 ? undefined : this.buffer[position];
+    }
+}
+exports.BufferedEnumerator = BufferedEnumerator;
+//# sourceMappingURL=BufferedEnumerator.js.map
+});
+
+var _String = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+class String {
+    static padLeft(value, paddingCharacter, width) {
+        return String.pad(value, paddingCharacter, width, true);
+    }
+    static padRight(value, paddingCharacter, width) {
+        return String.pad(value, paddingCharacter, width, false);
+    }
+    static pad(value, paddingCharacter, width, padLeft) {
+        let padding = "";
+        const count = width - value.length;
+        for (let i = 0; i < count; i++)
+            padding += paddingCharacter;
+        return padLeft ? padding + value : value + padding;
+    }
+}
+exports.String = String;
+//# sourceMappingURL=String.js.map
+});
+
+var Utilities = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+exports.Enumerator = Enumerator_1.Enumerator;
+
+exports.Enumerable = Enumerable_1.Enumerable;
+
+exports.ArrayEnumerator = ArrayEnumerator_1.ArrayEnumerator;
+
+exports.BufferedEnumerator = BufferedEnumerator_1.BufferedEnumerator;
+
+exports.String = _String.String;
+//# sourceMappingURL=index.js.map
+});
+
+var OutDevice_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class OutDevice extends Device_1.Device {
+}
+exports.OutDevice = OutDevice;
+//# sourceMappingURL=OutDevice.js.map
+});
+
+var Writer_1 = createCommonjsModule(function (module, exports) {
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+
+class Writer extends OutDevice_1.OutDevice {
+    constructor() {
+        super(...arguments);
+        this.newLineSymbol = "\n";
+    }
+    write(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return message instanceof Utilities.Enumerator ? this.writeImplementation(message) :
+                message instanceof Array ? this.writeImplementation(new Utilities.ArrayEnumerator(message)) :
+                    this.writeImplementation(new Utilities.ArrayEnumerator([message]));
+        });
+    }
+    writeLine(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return message instanceof Utilities.Enumerator ? this.writeImplementation(message.append(this.newLineSymbol)) :
+                message instanceof Array ? this.writeImplementation(new Utilities.ArrayEnumerator([...message, this.newLineSymbol])) :
+                    message ? this.writeImplementation(new Utilities.ArrayEnumerator([message, this.newLineSymbol])) :
+                        this.writeImplementation(new Utilities.ArrayEnumerator([this.newLineSymbol]));
+        });
+    }
+    static addOpener(open, priority) {
+        if (!priority)
+            priority = 0;
+        Writer.openers.push({ open, priority });
+        Writer.openers = Writer.openers.sort((left, right) => right.priority - left.priority);
+    }
+    static open(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result;
+            if (typeof (resource) == "string") {
+                const r = Uri.Locator.parse(resource);
+                result = r ? yield Writer.open(r) : undefined;
+            }
+            else {
+                let i = 0;
+                do
+                    result = yield Writer.openers[i++].open(resource);
+                while (!result && i < Writer.openers.length);
+            }
+            return result;
+        });
+    }
+}
+exports.Writer = Writer;
+Writer.openers = [];
+//# sourceMappingURL=Writer.js.map
+});
+
+var Indenter_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+class Indenter extends Writer_1.Writer {
+    constructor(backend) {
+        super();
+        this.backend = backend;
+        this.autoFlush = true;
+        this.indentionSymbol = "\t";
+        this.indentionCount = 0;
+        this.indentNext = false;
+    }
+    get resource() { return this.backend.resource; }
+    get opened() { return this.backend.opened; }
+    get writable() { return this.backend.writable; }
+    flush() {
+        return this.backend.flush();
+    }
+    close() {
+        return this.backend.close();
+    }
+    increase() {
+        this.indentionCount++;
+        return true;
+    }
+    decrease() {
+        this.indentionCount--;
+        return this.indentionCount >= 0;
+    }
+    getIndention() {
+        return this.indentionSymbol.repeat(this.indentionCount);
+    }
+    writeImplementation(buffer) {
+        const result = [];
+        let item;
+        let next = buffer.fetch();
+        if (next)
+            do {
+                item = next;
+                next = buffer.fetch();
+                if (this.indentNext)
+                    item = this.getIndention() + item;
+                this.indentNext = item.endsWith(this.newLineSymbol);
+                item = item.replace(this.newLineSymbol, this.newLineSymbol + this.getIndention());
+                if (this.indentNext)
+                    item = item.substring(0, item.length - this.indentionCount * this.indentionSymbol.length);
+                result.push(this.backend.write(item));
+            } while (next);
+        return Promise.all(result).then(r => r.reduce((previous, current) => previous && current, true));
+    }
+}
+exports.Indenter = Indenter;
+//# sourceMappingURL=Indenter.js.map
+});
+
+var PrefixReader_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+class PrefixReader extends Reader_1.Reader {
+    constructor(backend, prefix) {
+        super();
+        this.prefix = prefix;
+        this.done = false;
+        this.backend = backend instanceof BufferedReader_1.BufferedReader ? backend : BufferedReader_1.BufferedReader.create(backend);
+    }
+    get tabSize() { return this.backend.tabSize; }
+    set tabSize(size) { this.backend.tabSize = size; }
+    get readable() { return this.backend.readable; }
+    get opened() { return this.backend.opened; }
+    get isEmpty() { return this.done || this.backend.isEmpty; }
+    get resource() { return this.backend.resource; }
+    get location() { return this.backend.location; }
+    get region() { return this.backend.region; }
+    close() {
+        return this.backend.close();
+    }
+    read() {
+        let result;
+        if (!this.done) {
+            result = this.backend.read();
+            this.done = result == "\n" && !this.backend.readIf(this.prefix) && !this.backend.peekIs("\n");
+        }
+        return result;
+    }
+    mark() { return this.backend.mark(); }
+    static create(backend, prefix) {
+        return backend && prefix ? new PrefixReader(backend, prefix) : backend;
+    }
+}
+exports.PrefixReader = PrefixReader;
+//# sourceMappingURL=PrefixReader.js.map
+});
+
+var FileWriter_1 = createCommonjsModule(function (module, exports) {
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+
+class FileWriter extends Writer_1.Writer {
+    constructor(resource, descriptor) {
+        super();
+        this.resource = resource;
+        this.descriptor = descriptor;
+        this.autoFlush = false;
+    }
+    get opened() { return this.descriptor > 0; }
+    get writable() { return this.descriptor > 0; }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = true;
+            try {
+                yield fs_browser.fsync(this.descriptor);
+            }
+            catch (error) {
+                result = false;
+            }
+            return result;
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = this.opened;
+            if (result) {
+                try {
+                    yield fs_browser.close(this.descriptor);
+                }
+                catch (error) {
+                    result = false;
+                }
+                this.descriptor = 0;
+            }
+            return result;
+        });
+    }
+    writeImplementation(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = true;
+            const content = Buffer.from(buffer.reduce((r, item) => r + item, ""));
+            try {
+                const r = yield fs_browser.write(this.descriptor, content, 0, "utf8");
+                result = r.bytesWritten == content.length;
+            }
+            catch (error) {
+                result = false;
+            }
+            return result && (!this.autoFlush || (yield this.flush()));
+        });
+    }
+    static open(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let backend;
+            if (resource && (resource.scheme.length == 0 || resource.scheme.length == 1 && resource.scheme[0] == "file"))
+                try {
+                    backend = yield fs_browser.open((resource.isRelative ? "" : path_browser.sep) + resource.path.join(path_browser.sep), "w");
+                }
+                catch (error) {
+                    backend = undefined;
+                }
+            return backend ? new FileWriter(resource, backend) : undefined;
+        });
+    }
+}
+exports.FileWriter = FileWriter;
+Writer_1.Writer.addOpener(FileWriter.open);
+//# sourceMappingURL=FileWriter.js.map
+});
+
+var TillReader_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+class TillReader extends Reader_1.Reader {
+    constructor(backend, endMark) {
+        super();
+        this.endMark = endMark;
+        this.done = false;
+        this.backend = backend instanceof BufferedReader_1.BufferedReader ? backend : BufferedReader_1.BufferedReader.create(backend);
+        this.done = this.backend.peekIs(this.endMark) != undefined;
+    }
+    get tabSize() { return this.backend.tabSize; }
+    set tabSize(size) { this.backend.tabSize = size; }
+    get readable() { return this.backend.readable; }
+    get opened() { return !this.done && this.backend.opened; }
+    get isEmpty() { return this.done || this.backend.isEmpty; }
+    get resource() { return this.backend.resource; }
+    get location() { return this.backend.location; }
+    get region() { return this.backend.region; }
+    close() {
+        const result = !this.done;
+        if (result)
+            this.done = true;
+        return Promise.resolve(result);
+    }
+    read() {
+        let result;
+        if (!this.done) {
+            result = this.backend.read();
+            this.done = this.backend.peekIs(this.endMark) != undefined;
+        }
+        return result;
+    }
+    mark() { return this.backend.mark(); }
+    static create(backend, endMark) {
+        return backend && endMark ? new TillReader(backend, endMark) : backend;
+    }
+}
+exports.TillReader = TillReader;
+//# sourceMappingURL=TillReader.js.map
+});
+
+var UntilReader_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+class UntilReader extends Reader_1.Reader {
+    constructor(backend, endMark) {
+        super();
+        this.endMark = endMark;
+        this.done = -1;
+        this.backend = backend instanceof BufferedReader_1.BufferedReader ? backend : BufferedReader_1.BufferedReader.create(backend);
+        const peeked = this.backend.peekIs(this.endMark);
+        if (peeked)
+            this.done = peeked.length;
+    }
+    get tabSize() { return this.backend.tabSize; }
+    set tabSize(size) { this.backend.tabSize = size; }
+    get readable() { return this.backend.readable; }
+    get opened() { return !this.done && this.backend.opened; }
+    get isEmpty() { return this.done == 0 || this.backend.isEmpty; }
+    get resource() { return this.backend.resource; }
+    get location() { return this.backend.location; }
+    get region() { return this.backend.region; }
+    close() {
+        const result = this.done > 0;
+        if (result)
+            this.done = 0;
+        return Promise.resolve(result);
+    }
+    read() {
+        let result;
+        if (this.done != 0) {
+            result = this.backend.read();
+            let peeked;
+            if (this.done > 0)
+                this.done--;
+            else if (peeked = this.backend.peekIs(this.endMark))
+                this.done = peeked.length;
+        }
+        return result;
+    }
+    mark() { return this.backend.mark(); }
+    static create(backend, endMark) {
+        return backend && endMark ? new UntilReader(backend, endMark) : backend;
+    }
+}
+exports.UntilReader = UntilReader;
+//# sourceMappingURL=UntilReader.js.map
+});
+
+var IO = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+exports.BufferedReader = BufferedReader_1.BufferedReader;
+
+exports.Device = Device_1.Device;
+
+exports.FileReader = FileReader_1.FileReader;
+
+exports.FolderReader = FolderReader_1.FolderReader;
+
+exports.Indenter = Indenter_1.Indenter;
+
+exports.InDevice = InDevice_1.InDevice;
+
+exports.OutDevice = OutDevice_1.OutDevice;
+
+exports.PrefixReader = PrefixReader_1.PrefixReader;
+
+exports.Reader = Reader_1.Reader;
+
+exports.StringReader = StringReader_1.StringReader;
+
+exports.FileWriter = FileWriter_1.FileWriter;
+
+exports.TillReader = TillReader_1.TillReader;
+
+exports.UntilReader = UntilReader_1.UntilReader;
+
+exports.Writer = Writer_1.Writer;
+//# sourceMappingURL=index.js.map
+});
+
+var build = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+
+exports.Error = _Error;
+
+exports.IO = IO;
+
+exports.Uri = Uri;
+
+exports.Utilities = Utilities;
+//# sourceMappingURL=index.js.map
+});
+
+class Source$1 extends build.IO.BufferedReader {
+    constructor(reader, errorHandler) {
+        super(typeof reader == "string" ? build.IO.StringReader.create(reader) : reader);
+        this.errorHandler = errorHandler;
+    }
+    raise(message, level, type = "lexical", region) {
+        if (!(message instanceof build.Error.Message)) {
+            if (!level)
+                level = build.Error.Level.Critical;
+            if (!region)
+                region = this.region;
+            message = new build.Error.Message(message, level, type, region);
+        }
+        if (this.errorHandler)
+            this.errorHandler.raise(message);
+    }
+    requirePrefix(prefix) {
+        return new Source$1(new build.IO.PrefixReader(this, prefix), this.errorHandler);
+    }
+    till(endMark) {
+        return new Source$1(build.IO.TillReader.create(this, endMark), this.errorHandler);
+    }
+    until(endMark) {
+        return new Source$1(build.IO.UntilReader.create(this, endMark), this.errorHandler);
+    }
+    peekIsSymbol(symbols) {
+        return (this.peekIs(symbols ?? ["!", "(", ")", "[", "]", "|", "*", ":", ".", "<=", ">=", "<", ">", " * ", " + ", " - ", " / ", ","])?.length ?? false);
+    }
+    peekIsWhitespace() {
+        return !!this.peekIs([" ", "\n", "\t"]);
+    }
+}
+
+function tokenize(reader, errorHandler, symbols) {
+    const source = new Source$1(reader, errorHandler);
+    return new build.Utilities.Enumerator(() => {
+        let result;
+        let peekSymbolLength = 1;
+        if (!source.isEmpty) {
+            while (source.peekIsWhitespace() && !source.peekIsSymbol(symbols))
+                source.read();
+            if ((peekSymbolLength = source.peekIsSymbol(symbols)))
+                result = { value: source.read(peekSymbolLength) || "", region: source.mark() };
+            else {
+                let value = "";
+                while (!source.isEmpty && !source.peekIsWhitespace() && !source.peekIsSymbol(symbols))
+                    value += source.read();
+                if (value)
+                    result = { value, region: source.mark() };
+            }
+        }
+        return result;
+    });
+}
+
+class Base {
+    tokenize(input) {
+        return tokenize(input, undefined, [
+            "!",
+            "(",
+            ")",
+            "[",
+            "]",
+            "|",
+            " | ",
+            "*",
+            ":",
+            ".",
+            "<=",
+            ">=",
+            "<",
+            ">",
+            " * ",
+            " + ",
+            "+",
+            " - ",
+            "-",
+            " / ",
+        ])
+            .map(t => ({ value: t.value }))
+            .toArray();
+    }
+}
+
+class Array$1 extends Base {
+    constructor(input) {
+        super();
+        this.class = "array";
+        this.array = input;
+    }
+    complete(input, baseObject, type) {
+        const tokens = typeof input == "string" ? this.tokenize(input) : input;
+        return Array$1.completor
+            .flatMap(p => p(tokens, this, baseObject))
+            .reduce((result, element) => result.some(p => p.value == element.value && p.cursor == element.cursor) ? result : [...result, element], []);
+    }
+    isType(value) {
+        return global.Array.isArray(value);
+    }
+    static add(...pattern) {
+        this.completor.push(...pattern);
+    }
+    static is(value) {
+        return value instanceof Array$1;
+    }
+}
+Array$1.completor = [];
+
+var Cursor;
+(function (Cursor) {
+    function is(value) {
+        return typeof value == "object" && typeof value.start == "number" && typeof value.end == "number";
+    }
+    Cursor.is = is;
+})(Cursor || (Cursor = {}));
+
+var Completion;
+(function (Completion) {
+    function stringify(completions) {
+        return completions.map(c => typeof c.cursor == "number"
+            ? c.value.slice(0, c.cursor) + "_" + c.value.slice(c.cursor, c.value.length)
+            : c.value + "_");
+    }
+    Completion.stringify = stringify;
+    function prepend(prefix, completion, suffix) {
+        return Array.isArray(completion)
+            ? completion.map(c => prepend(prefix, c, suffix))
+            : {
+                value: prefix + completion.value + (suffix ?? ""),
+                cursor: typeof completion?.cursor == "number"
+                    ? completion?.cursor + prefix.length
+                    : Cursor.is(completion.cursor)
+                        ? { start: completion.cursor.start + prefix.length, end: completion.cursor.end + prefix.length }
+                        : completion.value.length + prefix.length,
+                suggestion: completion.suggestion,
+            };
+    }
+    Completion.prepend = prepend;
+})(Completion || (Completion = {}));
+
+class Boolean extends Base {
+    constructor() {
+        super();
+        this.class = "boolean";
+    }
+    complete(input, baseObject, type) {
+        const tokens = typeof input == "string" ? this.tokenize(input) : input;
+        const result = type
+            ? Boolean.literals.filter(c => c.value.startsWith(tokens[0]?.value ?? ""))
+            : tokens[0]?.value == ":"
+                ? Completion.prepend(":", Boolean.literals.filter(c => c.value.startsWith(tokens[1]?.value ?? "")))
+                : [];
+        return [
+            ...(result ?? []),
+            ...(type ? [] : Boolean.completor)
+                .flatMap(p => p(tokens, this, baseObject))
+                .reduce((result, element) => result.some(p => p.value == element.value && p.cursor == element.cursor) ? result : [...result, element], []),
+        ];
+    }
+    isType(value) {
+        return typeof value == "boolean";
+    }
+    static add(...pattern) {
+        this.completor.push(...pattern);
+    }
+}
+Boolean.literals = [
+    { value: "true", suggestion: { value: "true" } },
+    { value: "false", suggestion: { value: "false" } },
+];
+Boolean.completor = [];
+
+var Completor;
+(function (Completor) {
+    function functions(tokens, argument, completion) {
+        return tokens.length == 0
+            ? [{ value: ":", suggestion: { value: ":" } }]
+            : tokens.length <= 3 &&
+                tokens[0].value == ":" &&
+                completion.value.startsWith(tokens[1]?.value ?? "") &&
+                (tokens[2]?.value ?? "(") == "("
+                ? Completion.prepend(":", [completion])
+                : tokens.length <= 4 &&
+                    tokens.slice(0, 4).reduce((string, token) => string + token.value, "") == ":" + completion.value
+                    ? Completion.prepend(":" + completion.value.substring(0, completion.value.length - 1), argument(), ")")
+                    : tokens.length == 5 &&
+                        tokens.slice(0, 3).reduce((string, token) => string + token.value, "") + tokens[4].value ==
+                            ":" + completion.value
+                        ? Completion.prepend(":" + completion.value.substring(0, completion.value.length - 1), argument(tokens.slice(3, tokens.length - 1)), ")")
+                        : tokens.length > 5 &&
+                            tokens.slice(0, 3).reduce((string, token) => string + token.value, "") + tokens[tokens.length - 1].value ==
+                                ":" + completion.value
+                            ? Completion.prepend(":" + completion.value.substring(0, completion.value.length - 1), argument(tokens.slice(3, tokens.length - 1)), ")")
+                            : [];
+    }
+    Completor.functions = functions;
+    function expressions(tokens, argument, completion) {
+        return tokens.length == 0
+            ? [{ value: ":", suggestion: { value: ":" } }]
+            : tokens[0].value != ":"
+                ? []
+                : tokens.length == 1
+                    ? Completion.prepend(":", [completion])
+                    : Completion.prepend(":", argument(tokens.slice(1)));
+    }
+    Completor.expressions = expressions;
+    function operators(tokens, argument, completion) {
+        return tokens.length >= 1 && tokens[0].value == completion.value
+            ? Completion.prepend(completion.value, argument(tokens.slice(1)))
+            : tokens.length == 0 ||
+                (tokens.length == 1 && completion.value.startsWith(tokens[0].value)) ||
+                tokens[0].value == completion.value.replace(/ /g, "")
+                ? [completion]
+                : [];
+    }
+    Completor.operators = operators;
+})(Completor || (Completor = {}));
+
+class Number$1 extends Base {
+    constructor(input) {
+        super();
+        this.input = input;
+        this.class = "number";
+        if (input)
+            this.value = input;
+    }
+    complete(input, baseObject, type) {
+        const tokens = typeof input == "string" ? this.tokenize(input) : input;
+        return [
+            ...(tokens.length > 0 && tokens[0].value == ":" && baseObject
+                ? Completion.prepend(":", baseObject.complete(tokens.slice(1), undefined, this))
+                : baseObject && tokens.length >= 0 && type
+                    ? Completion.prepend(" ", baseObject?.complete(tokens, undefined, undefined))
+                    : []),
+            ...(type ? Number$1.completorArgument : Number$1.completor)
+                .flatMap(p => p(tokens, this, baseObject))
+                .reduce((result, element) => result.some(p => p.value == element.value && p.cursor == element.cursor) ? result : [...result, element], []),
+        ];
+    }
+    isType(value) {
+        return isNaN(+value) ? false : true;
+    }
+    static add(...pattern) {
+        this.completor.push(...pattern);
+    }
+    static addArgument(...pattern) {
+        this.completorArgument.push(...pattern);
+    }
+    static is(value) {
+        return value instanceof Number$1 || !global.Number.isNaN(value);
+    }
+}
+Number$1.completor = [];
+Number$1.completorArgument = [];
+
+class TObject extends Base {
+    constructor(properties) {
+        super();
+        this.properties = properties;
+        this.class = "object";
+        this.completions = Object.keys(this.properties).map(p => ({ value: p, suggestion: { value: p } }));
+    }
+    complete(input, baseObject, type) {
+        const tokens = typeof input == "string" ? this.tokenize(input) : input;
+        let result;
+        const filtered = this.filterByType(type);
+        if (!baseObject) {
+            const matched = tokens.length > 0 ? this.match(tokens[0], filtered) : undefined;
+            if (matched)
+                result =
+                    tokens.length >= 1
+                        ? Completion.prepend(matched.value, this.properties[matched.value].complete(tokens.slice(1), this, type))
+                        : [];
+            else if (type && tokens.length > 2 && type.isType(tokens[0].value + tokens[1].value + tokens[2].value))
+                result = Completion.prepend(tokens[0].value + tokens[1].value + tokens[2].value, type.complete(tokens.slice(3), this, type));
+            else if (type && tokens.length > 0 && type.isType(tokens[0].value))
+                result = Completion.prepend(tokens[0].value, type.complete(tokens.slice(1), this, type));
+            else {
+                let found;
+                result =
+                    tokens.length == 0
+                        ? [...this.addDot(filtered, type), ...(type?.class == "number" ? [] : TObject.wildcard)]
+                        : tokens.length == 1 && (found = TObject.wildcard.find(w => w.value == tokens[0].value))
+                            ? Completion.prepend(found.value, this.completions, type ? "." : "")
+                            : tokens.length >= 1 && (found = TObject.wildcard.find(w => w.value == tokens[0].value))
+                                ? Completion.prepend(found.value, this.complete(tokens.slice(1)))
+                                : this.addDot(this.partial(tokens[0], filtered), type);
+            }
+        }
+        else
+            result =
+                tokens.length == 0
+                    ? [{ value: ".", suggestion: { value: "." } }]
+                    : tokens[0].value != "."
+                        ? []
+                        : tokens.length == 1
+                            ? Completion.prepend(".", this.addDot(filtered, type))
+                            : this.properties[tokens[1].value]
+                                ? Completion.prepend("." + tokens[1].value, this.properties[tokens[1].value].complete(tokens.slice(2), baseObject, type))
+                                : Completion.prepend(".", this.addDot(this.partial(tokens[1], filtered), type));
+        return [
+            ...result.reduce((result, element) => result.some(p => p.value == element.value && p.cursor == element.cursor) ? result : [...result, element], []),
+            ...TObject.completor.flatMap(p => p(tokens, this, baseObject)),
+        ];
+    }
+    filterByType(type) {
+        return type
+            ? this.completions.filter(c => this.properties[c.value].class == type.class ||
+                (this.properties[c.value].class == "object"
+                    ? this.properties[c.value].filterByType(type).length > 0
+                    : false))
+            : this.completions;
+    }
+    addDot(completions, type) {
+        return !completions
+            ? []
+            : type
+                ? completions.map(c => this.properties[c.value].class == "object"
+                    ? { value: c.value + ".", suggestion: { value: c.suggestion?.value + "." } }
+                    : c)
+                : completions;
+    }
+    partial(token, completions) {
+        const result = completions.filter(c => c.value.startsWith(token.value));
+        return result && result.length > 0 ? result : undefined;
+    }
+    match(token, completions) {
+        const result = completions.filter(c => c.value == token.value);
+        return result && result.length > 0 ? result[0] : undefined;
+    }
+    isType(value) {
+        return false;
+    }
+    static add(...completor) {
+        this.completor.push(...completor);
+    }
+}
+TObject.wildcard = [
+    { value: "!", cursor: 1, suggestion: { value: "!", description: "not" } },
+];
+TObject.completor = [];
+
+class String extends Base {
+    constructor(input) {
+        super();
+        this.class = "string";
+        if (input)
+            this.value = input;
+    }
+    complete(input, baseObject, type) {
+        const tokens = typeof input == "string" ? this.tokenize(input) : input;
+        let result;
+        if (type)
+            result = this.value?.startsWith(tokens[0]?.value ?? "")
+                ? [{ value: this.value, suggestion: { value: this.value } }]
+                : undefined;
+        else
+            result =
+                tokens.length == 0 || tokens[0].value != ":"
+                    ? undefined
+                    : this.value?.startsWith(tokens[1]?.value ?? "")
+                        ? [Completion.prepend(":", { value: this.value, suggestion: { value: this.value } })]
+                        : undefined;
+        return [
+            ...(result ?? []),
+            ...(type ? [] : String.completor)
+                .flatMap(p => p(tokens, this, baseObject))
+                .reduce((result, element) => result.some(p => p.value == element.value && p.cursor == element.cursor) ? result : [...result, element], []),
+        ];
+    }
+    isType(value) {
+        return typeof value.value == "string";
+    }
+    static add(...pattern) {
+        this.completor.push(...pattern);
+    }
+    static is(value) {
+        return value instanceof String;
+    }
+}
+String.completor = [];
+
+class Union extends Base {
+    constructor(type) {
+        super();
+        this.type = type;
+        this.class = "union";
+    }
+    complete(input, baseObject, type) {
+        const tokens = typeof input == "string" ? this.tokenize(input) : input;
+        return this.type ? this.type?.flatMap(t => t?.complete(tokens, baseObject, type) ?? []) : [];
+    }
+    isType(value) {
+        return value instanceof Union;
+    }
+    static is(value) {
+        return value instanceof Union;
+    }
+}
+
+var Type;
+(function (Type) {
+    function complete(template, input) {
+        const completions = template.complete(input);
+        return completions
+            .filter(c => !input.includes(c.value) && c.suggestion?.value)
+            .map(c => ({
+            full: c.value,
+            cursor: c?.cursor ?? c.value.length,
+            addon: c?.suggestion?.value,
+            description: c?.suggestion?.description,
+        }));
+    }
+    Type.complete = complete;
+    function convert(value) {
+        let result;
+        switch (typeof value) {
+            case "object":
+                result = global.Array.isArray(value)
+                    ? new Array$1(value.map(e => convert(e)))
+                    : new TObject(global.Object.entries(value).reduce((r, c) => {
+                        return { ...r, [c[0]]: convert(c[1]) };
+                    }, {}));
+                break;
+            case "string":
+                result = new String(value);
+                break;
+            default:
+                result = new Number$1(value);
+                break;
+        }
+        return result;
+    }
+    Type.convert = convert;
+    Type.Array = Array$1;
+    Type.Boolean = Boolean;
+    Type.Completion = Completion;
+    Type.Object = TObject;
+    Type.String = String;
+    Type.Number = Number$1;
+    Type.Union = Union;
+    Type.Completor = Completor;
+})(Type || (Type = {}));
+
+class EndsWith extends Rule {
+    constructor(needle) {
+        super();
+        this.needle = needle;
+        this.precedence = Number.MAX_SAFE_INTEGER;
+        this.class = "EndsWith";
+    }
+    is(value) {
+        return typeof value == "string" && value.endsWith(this.needle);
+    }
+    toString() {
+        return `*${this.needle}`;
+    }
+}
+function endsWith(needle, value) {
+    const result = new EndsWith(needle);
+    return value ? result.is(value) : result;
+}
+function complete$e(tokens, string) {
+    return Completor.expressions(tokens, (tokens) => {
+        return !tokens || (tokens[0].value == "*" && string.value && string.value.endsWith(tokens[1]?.value ?? ""))
+            ? [Type.Completion.prepend("*", { value: string?.value ?? "", suggestion: { value: string?.value ?? "" } })]
+            : [];
+    }, { value: "*", suggestion: { value: "*", description: "endswith" } });
+}
+Type.String.add(complete$e);
+
+class Every extends Rule {
+    constructor(criteria) {
+        super();
+        this.criteria = criteria;
+        this.precedence = 100;
+        this.class = "Every";
+    }
+    is(value) {
+        return Array.isArray(value) && value.every(v => this.criteria.is(v));
+    }
+    toString() {
+        return `every(${this.criteria.toString()})`;
+    }
+}
+function complete$d(tokens, type) {
+    const arrayArgumentor = (tokens) => type.array.some(Type.String.is) && tokens
+        ? type.array
+            .filter(Type.String.is)
+            .map(p => p.complete([{ value: ":" }, ...tokens]))
+            .reduce((result, element) => Array.isArray(element) ? result.concat(element) : element ? [...result, element] : result, [])
+        : !tokens && type.array.some(Type.String.is)
+            ? type.array.filter(Type.String.is).map(e => ({ value: e?.value ?? "" }))
+            : type.array.some(Type.Number.is) && tokens
+                ? type.array
+                    .filter(Type.Number.is)
+                    .map(e => e.complete(tokens))
+                    .reduce((result, element) => Array.isArray(element) ? result.concat(element) : element ? [...result, element] : result, [])
+                : !tokens && type.array.some(Type.Number.is)
+                    ? type.array.filter(Type.Number.is).map(e => ({ value: (e?.value ?? "").toString() }))
+                    : [];
+    return Completor.functions(tokens, arrayArgumentor, {
+        value: "every()",
+        cursor: 6,
+        suggestion: { value: "every()" },
+    });
+}
+Type.Array.add(complete$d);
+
+class FunctionCall extends Rule {
+    constructor(identifier, argument, definition) {
+        super();
+        this.identifier = identifier;
+        this.argument = argument;
+        this.definition = definition;
+        this.precedence = 85;
+        this.class = "FunctionCall";
+    }
+    is(value) {
+        return this.definition?.is(value) ?? true;
+    }
+    toString() {
+        return `${this.identifier}(${this.argument.join(", ")})`;
+    }
+}
+
+class Expression {
+    stringify(precedence = 0) {
+        let result = this.toString();
+        if (this.precedence < precedence)
+            result = "(" + result + ")";
+        return result;
+    }
+}
+
+class Value extends Expression {
+    constructor(value, name) {
+        super();
+        this.name = name;
+        this.precedence = Value.precedence;
+        this.class = "Value";
+        if (typeof value == "string")
+            this.value = isNaN(+value.replace(",", ".")) ? value : +value.replace(",", ".");
+        else
+            this.value = value;
+    }
+    toString() {
+        return this.name ? `${this.name?.toString()}.` + this.value.toString() : this.value.toString();
+    }
+    evaluate(variable) {
+        return variable ? this.get(variable) : +this.value;
+    }
+    get(variable) {
+        return typeof this.value == "string"
+            ? +variable[this.value]
+            : this.name && typeof this.value == "object"
+                ? this.value.get(variable[this.name])
+                : +this.value;
+    }
+    static create(value, name) {
+        return new Value(value, name);
+    }
+}
+Value.precedence = 19;
+
+class GreaterThan extends Rule {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.precedence = 85;
+        this.class = "GreaterThan";
+        this.symbol = ">";
+    }
+    is(value, object) {
+        return ((isNaN(+value) ? value : +value) >
+            ((this.value instanceof Value && typeof this.value.value == "string" && this.value.value.includes("-")) ||
+                typeof this.value != "object"
+                ? this.value
+                : this.value.evaluate(object)));
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+function greaterThan(criteria, value) {
+    const result = new GreaterThan(criteria);
+    return value ? result.is(value) : result;
+}
+function complete$c(tokens, type, baseObject) {
+    return Type.Completor.operators(tokens, (tokens) => (tokens && baseObject ? baseObject?.complete(tokens, undefined, type) : []), {
+        value: ">",
+        suggestion: { value: ">" },
+    });
+}
+Type.Number.add(complete$c);
+Type.String.add(complete$c);
+
+class GreaterThanOrEqual extends Rule {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.precedence = 85;
+        this.class = "GreaterThanOrEqual";
+        this.symbol = ">=";
+    }
+    is(value, object) {
+        return ((isNaN(+value) ? value : +value) >=
+            ((this.value instanceof Value && typeof this.value.value == "string" && this.value.value.includes("-")) ||
+                typeof this.value != "object"
+                ? this.value
+                : this.value.evaluate(object)));
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+function complete$b(tokens, type, baseObject) {
+    return Type.Completor.operators(tokens, (tokens) => (tokens && baseObject ? baseObject?.complete(tokens, undefined, type) : []), {
+        value: ">=",
+        suggestion: { value: ">=" },
+    });
+}
+Type.Number.add(complete$b);
+Type.String.add(complete$b);
+
+class Has extends Rule {
+    constructor(property) {
+        super();
+        this.property = property;
+        this.precedence = 85;
+        this.class = "Has";
+    }
+    is(value, property) {
+        return typeof value == "object" && value
+            ? Object.entries(value).some(e => {
+                property = typeof property == "string" ? property : this.property;
+                return e[0] == property
+                    ? true
+                    : typeof e[1] == "object" && e[1]
+                        ? this.is(e[1], property.includes(".") && property.split(".")[0] == e[0] ? property.split(".")[1] : undefined)
+                        : false;
+            })
+            : false;
+    }
+    toString() {
+        return `has(${this.property})`;
+    }
+}
+function complete$a(tokens, type, baseObject) {
+    return baseObject && type?.class == "object"
+        ? Completor.functions(tokens, (tokens) => type.completions.filter(c => c.value.startsWith(tokens ? tokens[0].value : "")), {
+            value: "has()",
+            cursor: 4,
+            suggestion: { value: "has()" },
+        })
+        : [];
+}
+Type.Object.add(complete$a);
+
+class Includes extends Rule {
+    constructor(needle) {
+        super();
+        this.needle = needle;
+        this.precedence = Number.MAX_SAFE_INTEGER;
+        this.class = "Includes";
+    }
+    is(value) {
+        return typeof value == "string" && value.includes(this.needle);
+    }
+    toString() {
+        return `*${this.needle}*`;
+    }
+}
+function includes(needle, value) {
+    const result = new Includes(needle);
+    return value ? result.is(value) : result;
+}
+function complete$9(tokens, string) {
+    return Completor.expressions(tokens, (tokens) => {
+        return !tokens ||
+            (tokens.length == 3 && string.value?.includes(tokens[1].value) && string.value != tokens[1].value) ||
+            (tokens.length == 2 && tokens[0].value + tokens[1].value == "**")
+            ? [
+                Type.Completion.prepend("*", { value: string?.value ?? "", suggestion: { value: string?.value ?? "" } }, "*"),
+            ]
+            : tokens.length == 1 && tokens[0].value == "*"
+                ? [{ value: "**", suggestion: { value: "**", description: "includes" } }]
+                : [];
+    }, { value: "**", cursor: 1, suggestion: { value: "**", description: "includes" } });
+}
+Type.String.add(complete$9);
+
+class Some extends Rule {
+    constructor(criteria) {
+        super();
+        this.criteria = criteria;
+        this.precedence = 100;
+        this.class = "Some";
+    }
+    is(value, object) {
+        return Array.isArray(value) && value.some(v => this.criteria.is(v, object));
+    }
+    toString() {
+        return `some(${this.criteria.toString()})`;
+    }
+}
+function some(criteria, value) {
+    const result = new Some(create(criteria));
+    return value ? result.is(value) : result;
+}
+function complete$8(tokens, type, baseObject) {
+    return tokens.length == 0
+        ? [{ value: ":", suggestion: { value: ":" } }]
+        : tokens[0].value != ":"
+            ? []
+            : tokens.length == 1 && tokens[0].value == ":"
+                ? Type.Completion.prepend(":", type.array
+                    .filter(Type.String.is)
+                    .filter(e => e.value && e.value != "string")
+                    .map(e => ({ value: e?.value ?? "", suggestion: { value: e?.value ?? "" } })))
+                : tokens.length == 2 && tokens[0].value == ":"
+                    ? Type.Completion.prepend(":", type.array
+                        .filter(Type.String.is)
+                        .filter(e => e.value && e.value != "string" && e.value.startsWith(tokens[1].value))
+                        .map(e => ({ value: e?.value ?? "", suggestion: { value: e?.value ?? "" } })))
+                    : [];
+}
+Type.Array.add(complete$8);
+
+class Is extends Rule {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.precedence = Number.MAX_SAFE_INTEGER;
+        this.class = "Is";
+        this.symbol = ":";
+    }
+    is(value, object) {
+        return Array.isArray(value) && isCriteria(this.value)
+            ? some(this.value, value)
+            : (typeof value == "boolean" ? value.toString() : isNaN(+value) ? value : +value) ==
+                (typeof this.value == "object" ? this.value.evaluate(object) : this.value);
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+add$1(criteria => typeof criteria == "bigint" ||
+    typeof criteria == "boolean" ||
+    typeof criteria == "number" ||
+    typeof criteria == "string"
+    ? new Is(criteria)
+    : undefined);
+
+class LesserThan extends Rule {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.precedence = 85;
+        this.class = "LesserThan";
+        this.symbol = "<";
+    }
+    is(value, object) {
+        return ((isNaN(+value) ? value : +value) <
+            ((this.value instanceof Value && typeof this.value.value == "string" && this.value.value.includes("-")) ||
+                typeof this.value != "object"
+                ? this.value
+                : this.value.evaluate(object)));
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+function lesserThan(criteria, value) {
+    const result = new LesserThan(criteria);
+    return value ? result.is(value) : result;
+}
+function complete$7(tokens, type, baseObject) {
+    return Type.Completor.operators(tokens, (tokens) => (tokens && baseObject ? baseObject?.complete(tokens, undefined, type) : []), {
+        value: "<",
+        suggestion: { value: "<" },
+    });
+}
+Type.Number.add(complete$7);
+Type.String.add(complete$7);
+
+class LesserThanOrEqual extends Rule {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.precedence = 85;
+        this.class = "LesserThanOrEqual";
+        this.symbol = "<=";
+    }
+    is(value, object) {
+        return ((isNaN(+value) ? value : +value) <=
+            ((this.value instanceof Value && typeof this.value.value == "string" && this.value.value.includes("-")) ||
+                typeof this.value != "object"
+                ? this.value
+                : this.value.evaluate(object)));
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+function complete$6(tokens, type, baseObject) {
+    return Type.Completor.operators(tokens, (tokens) => (tokens && baseObject ? baseObject?.complete(tokens, undefined, type) : []), {
+        value: "<=",
+        suggestion: { value: "<=" },
+    });
+}
+Type.Number.add(complete$6);
+Type.String.add(complete$6);
+
+function complete$5(tokens, string) {
+    return Completor.expressions(tokens, (tokens) => {
+        return tokens && tokens?.length == 1 && tokens[0].value == "/" ? [{ value: "//", cursor: 1 }] : [];
+    }, { value: "//", cursor: 1, suggestion: { value: "//", description: "match" } });
+}
+Type.String.add(complete$5);
+
+class Not extends Rule {
+    constructor(criteria) {
+        super();
+        this.criteria = criteria;
+        this.precedence = Not.precedence;
+        this.class = "Not";
+    }
+    is(value) {
+        return !this.criteria.is(value);
+    }
+    toString() {
+        return `!${this.criteria.stringify(this.precedence)}`;
+    }
+}
+Not.precedence = 90;
+function complete$4(tokens, type, baseObject) {
+    return type && type.class != "object" && baseObject
+        ? Completor.expressions(tokens, (tokens) => {
+            return tokens[0].value != "!"
+                ? []
+                : Type.Completion.prepend("!", type.complete(tokens.slice(1), baseObject, type));
+        }, { value: "!", cursor: 1, suggestion: { value: "!", description: "not" } })
+        : [];
+}
+Type.String.add(complete$4);
+Type.Number.add(complete$4);
+Type.Boolean.add(complete$4);
+Type.Object.add(complete$4);
+
+class Or extends Rule {
+    constructor(criterias) {
+        super();
+        this.precedence = Or.precedence;
+        this.class = "Or";
+        this.criteria = criterias.reduce((r, c) => (c instanceof Or ? [...r, ...c.criteria] : [...r, c]), []);
+    }
+    is(value) {
+        return this.criteria.some(c => c.is(value));
+    }
+    toString() {
+        return this.criteria.map(c => c.stringify(this.precedence)).join(" | ");
+    }
+}
+Or.precedence = 30;
+function complete$3(tokens, type, baseObject) {
+    return Type.Completor.operators(tokens, (tokens) => (tokens && baseObject ? baseObject?.complete(tokens, undefined, undefined) : []), {
+        value: " | ",
+        suggestion: { value: "|", description: "or" },
+    });
+}
+Type.Number.addArgument(complete$3);
+
+class Source extends build.Utilities.BufferedEnumerator {
+    constructor(tokens, errorHandler) {
+        super(Array.isArray(tokens) ? new build.Utilities.ArrayEnumerator(tokens) : tokens);
+        this.errorHandler = errorHandler;
+    }
+    clone(start = "(", end = ")") {
+        let nestingCount = 0;
+        return new Source(new build.Utilities.Enumerator(() => {
+            let result;
+            if (this.peekIs(start))
+                nestingCount++;
+            else if (this.peekIs(end))
+                nestingCount--;
+            if (nestingCount >= 0)
+                result = this.fetch();
+            return result;
+        }), this);
+    }
+    peekIs(...needles) {
+        return needles.every((needle, index) => {
+            const peeked = this.peek(index);
+            return peeked && peeked.value && Source.is(needle, peeked.value);
+        });
+    }
+    fetchIf(...needles) {
+        const result = [];
+        if (this.peekIs(...needles))
+            needles.forEach(_ => result.push(this.fetch()));
+        return needles.length == 1
+            ? result.length == 1
+                ? result[0]
+                : undefined
+            : needles.length == result.length
+                ? result
+                : undefined;
+    }
+    mark() {
+        return build.Utilities.Enumerable.from(build.Utilities.Enumerable.empty);
+    }
+    raise(message, level = build.Error.Level.Critical, type = "grammatical", region) {
+        if (typeof message == "string") {
+            if (!region && this.last)
+                region = this.last.region;
+            message = new build.Error.Message(message, level, type, region);
+        }
+        this.errorHandler.raise(message);
+    }
+    static is(needle, value) {
+        return Array.isArray(needle)
+            ? needle.some(n => Source.is(n, value))
+            : typeof needle != "string"
+                ? needle.test(value)
+                : needle.startsWith("!") && needle != "!"
+                    ? !Source.is(needle.substring(1), value)
+                    : needle == "any"
+                        ? Source.symbol.every(s => s != value)
+                        : needle == "symbol"
+                            ? Source.symbol.some(s => s == value)
+                            : needle == "identifier"
+                                ? /[A-Za-z][A-Za-z0-9_]*/.test(value)
+                                : needle == value;
+    }
+}
+Source.wildcard = ["*", "?"];
+Source.separator = ["(", ")", "."];
+Source.operator = ["!", "|"];
+Source.comparator = ["<", "<=", ">", ">=", ":"];
+Source.binaryOperator = [" * ", " + ", " - "];
+Source.symbol = [...Source.wildcard, ...Source.separator, ...Source.operator, ...Source.comparator];
+
+function parse(source, handler) {
+    if (typeof source == "string") {
+        handler = handler || new build.Error.ConsoleHandler();
+        const tokens = tokenize(source, handler).toArray();
+        source = new Source(tokens, handler);
+    }
+    handler = handler instanceof Rule ? handler : undefined;
+    const result = [];
+    while (source.peek()) {
+        if (source.fetchIf("|"))
+            result[result.length - 1] = new Or([result[result.length - 1], parseNext(0, source)]);
+        else
+            result.push(parseNext(0, source));
+    }
+    return result.length == 1 ? result[0] : new And(result);
+}
+function parseNext(previous, source) {
+    let result;
+    const precedenceTest = typeof previous == "number" ? p => previous < p : p => previous.precedence > p;
+    const left = typeof previous == "number" ? undefined : previous;
+    for (const parser of parsers)
+        if (precedenceTest(parser[1] || Number.MAX_SAFE_INTEGER)) {
+            const r = parser[0](source, left);
+            if (r) {
+                result = parseNext(r, source);
+                break;
+            }
+        }
+    return result || left || new And([]);
+}
+const parsers = [];
+function add(parser, precedence) {
+    parsers.push([parser, precedence]);
+}
+
+function parseExpression(source, handler) {
+    if (typeof source == "string") {
+        handler = handler || new build.Error.ConsoleHandler();
+        const tokens = tokenize(source, handler).toArray();
+        source = new Source(tokens, handler);
+    }
+    handler = handler instanceof Expression ? handler : undefined;
+    let result;
+    let algebra = false;
+    let comparator = false;
+    while (!result != algebra && !comparator && source.peek()) {
+        let i = 1;
+        algebra = false;
+        comparator = false;
+        while (!algebra && !comparator && source.peek(i)) {
+            algebra = Source.binaryOperator.some(c => source.peek(i)?.value == c);
+            comparator = Source.comparator.some(c => source.peek(i)?.value == c);
+            i++;
+        }
+        result = parseNextExpression(result ?? Number.MAX_SAFE_INTEGER, source);
+    }
+    if (!result)
+        source.raise("Missing Expression");
+    return result ?? new Value(NaN);
+}
+function parseNextExpression(previous, source) {
+    let result;
+    const left = typeof previous == "number" ? undefined : previous;
+    for (const expressionParser of expressionParsers) {
+        const r = expressionParser[0](source, previous);
+        if (r) {
+            result = r;
+            break;
+        }
+    }
+    return result || left;
+}
+const expressionParsers = [];
+function addExpression(expressionParser, precedence) {
+    expressionParsers.push([expressionParser, precedence]);
+}
+
+add(source => {
+    const result = source.fetchIf(":", "every", "(") && new Every(parse(source.clone()));
+    if (result && !source.fetchIf(")"))
+        source.raise("Missing end of parenthesis.");
+    return result;
+});
+
+add(source => {
+    const result = source.fetchIf(":", "some", "(") && new Some(parse(source.clone()));
+    if (result && !source.fetchIf(")"))
+        source.raise("Missing end of parenthesis.");
+    return result;
+});
+
+add(getAdder(parse));
+addExpression(getAdder(parseExpression));
+function getAdder(parser) {
+    return (source) => {
+        const result = source.fetchIf("(") && parser(source.clone());
+        if (result && !source.fetchIf(")"))
+            source.raise("Missing end of parenthesis.");
+        return result;
+    };
+}
+
+add(source => {
+    return source.fetchIf(">") && new GreaterThan(parseExpression(source));
+});
+
+add(source => {
+    return source.fetchIf(">=") && new GreaterThanOrEqual(parseExpression(source));
+});
+
+add(source => {
+    return source.fetchIf("<") && new LesserThan(parseExpression(source));
+});
+
+add(source => {
+    return source.fetchIf("<=") && new LesserThanOrEqual(parseExpression(source));
+});
+
+add(source => source.fetchIf("!") && new Not(parseNext(Not.precedence, source)));
+
+add(source => {
+    const fetched = source.fetchIf("has", "(", "any", ")") || source.fetchIf(":", "has", "(", "any", ")");
+    return fetched && new Has(fetched.length == 4 ? fetched[2].value : fetched[3].value);
+});
+
+class Within extends Rule {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.precedence = 85;
+        this.class = "Within";
+    }
+    is(value) {
+        return this.value.includes(value);
+    }
+    toString() {
+        return `within(${this.value.join(", ")})`;
+    }
+}
+function complete$2(tokens, type, baseObject) {
+    return baseObject && type?.class
+        ? Completor.functions(tokens, (tokens) => [], {
+            value: "within()",
+            cursor: 7,
+            suggestion: { value: "within()" },
+        })
+        : [];
+}
+Type.String.add(complete$2);
+Type.Number.add(complete$2);
+
+add(source => {
+    const fetched = source.fetchIf(":", "within", "(");
+    let parameters;
+    if (fetched && source.peek()) {
+        parameters = [source.fetch()?.value ?? ""];
+        while (source.fetchIf(","))
+            parameters.push(source.fetchIf("any")?.value ?? "");
+        if (!source.fetchIf(")"))
+            source.raise("Missing end of parenthesis.");
+    }
+    return fetched && parameters ? new Within(parameters) : undefined;
+});
+
+add(source => {
+    const peek = source.peek(3)?.value;
+    const fetched = [")", ",", "("].find(s => s == peek) || source.peek(2)?.value == ")" ? source.fetchIf("identifier", "(") : undefined;
+    let parameters;
+    if (fetched && source.peek()) {
+        parameters = [source.fetchIf(/[A-Za-z0-9_\.\-]+/)?.value ?? ""];
+        while (source.fetchIf(","))
+            parameters.push(source.fetchIf(/[A-Za-z0-9_\.\-]+/)?.value ?? "");
+        if (!source.fetchIf(")"))
+            source.raise("Missing end of parenthesis.");
+    }
+    return fetched && parameters ? new FunctionCall(fetched[0].value, parameters) : undefined;
+});
+
+class Property extends Rule {
+    constructor(name, criteria) {
+        super();
+        this.name = name;
+        this.criteria = criteria;
+        this.precedence = Property.precedence;
+        this.class = "Property";
+        this.symbol = ".";
+    }
+    is(value, object) {
+        return !this.criteria
+            ? value == object?.[this.name]
+            : typeof value == "object"
+                ? this.criteria.is(value[this.name], object ?? value)
+                : this.criteria.is(value, object?.[this.name]);
+    }
+    toString() {
+        return `${this.name}${this.criteria ? this.criteria.symbol ?? ":" : ""}${this.criteria?.stringify(this.precedence) ?? ""}`;
+    }
+}
+Property.precedence = 80;
+function property(name, criteria, value) {
+    const result = (Array.isArray(name) ? name : [name]).reduceRight((r, p) => new Property(p, r), create(criteria));
+    return value ? result.is(value) : result;
+}
+add$1(criteria => typeof criteria == "object" && !(criteria instanceof Rule) && !Array.isArray(criteria)
+    ? and(...Object.getOwnPropertyNames(criteria).map(p => property(p, criteria[p])))
+    : undefined);
+
+add(source => {
+    const result = [];
+    let fetched;
+    while ((fetched = source.fetchIf("identifier", ".")))
+        result.push(fetched[0].value);
+    if (source.peekIs("identifier", Source.comparator) && (fetched = source.fetchIf("identifier")))
+        result.push(fetched.value);
+    return result.length > 0
+        ? result.reduceRight((r, name) => new Property(name, r), source.peekIs("identifier") && (fetched = source.fetchIf("identifier"))
+            ? new Property(fetched.value)
+            : parseNext(Property.precedence, source))
+        : undefined;
+});
+
+add(source => {
+    const fetched = source.fetchIf(":", "*", "any", "*") || source.fetchIf("*", "any", "*");
+    return fetched && new Includes(fetched.length == 4 ? fetched[2].value : fetched[1].value);
+});
+
+class StartsWith extends Rule {
+    constructor(needle) {
+        super();
+        this.needle = needle;
+        this.precedence = Number.MAX_SAFE_INTEGER;
+        this.class = "StartsWith";
+    }
+    is(value) {
+        return typeof value == "string" && value.startsWith(this.needle);
+    }
+    toString() {
+        return `${this.needle}*`;
+    }
+}
+function startsWith(needle, value) {
+    const result = new StartsWith(needle);
+    return value ? result.is(value) : result;
+}
+function complete$1(tokens, string) {
+    return Completor.expressions(tokens, (tokens) => {
+        return !tokens ||
+            (tokens.length == 1 && tokens[0].value == "*") ||
+            (tokens.length == 2 &&
+                tokens[1].value == "*" &&
+                string.value &&
+                string.value.startsWith(tokens[0]?.value ?? ""))
+            ? [Type.Completion.prepend("", { value: string?.value ?? "", suggestion: { value: string?.value ?? "" } }, "*")]
+            : [];
+    }, { value: "*", cursor: 0, suggestion: { value: "*", description: "startswith" } });
+}
+Type.String.add(complete$1);
+
+add(source => {
+    const fetched = source.fetchIf(":", "any", "*") || source.fetchIf("any", "*");
+    return fetched && new StartsWith(fetched?.length == 3 ? fetched[1].value : fetched[0].value);
+});
+
+add(source => {
+    const fetched = source.fetchIf(":", "*", "any") || source.fetchIf("*", "any");
+    return fetched && new EndsWith(fetched?.length == 3 ? fetched[2].value : fetched[1].value);
+});
+
+class InfixOperator extends Expression {
+    toString() {
+        const symbol = this.symbol;
+        return (this.left.stringify(InfixOperator.getPrecedence(symbol)) +
+            ` ${symbol} ` +
+            this.right.stringify(InfixOperator.getPrecedence(symbol)));
+    }
+    constructor(symbol, precedence, left, right) {
+        super();
+        this.precedence = precedence;
+        this.left = left;
+        this.right = right;
+        this.class = "InfixOperator";
+        this.symbol = symbol.replace(/ /g, "");
+    }
+    evaluate(criteria) {
+        let result;
+        switch (this.getSymbol()) {
+            case "+":
+                result = this.left.evaluate(criteria) + this.right.evaluate(criteria);
+                break;
+            case "-":
+                result = this.left.evaluate(criteria) - this.right.evaluate(criteria);
+                break;
+            case "*":
+                result = this.left.evaluate(criteria) * this.right.evaluate(criteria);
+                break;
+            default:
+                result = NaN;
+                break;
+        }
+        return result;
+    }
+    getSymbol() {
+        return this.symbol;
+    }
+    stringify(precedence = 0) {
+        let result = this.toString();
+        if (this.precedence < precedence)
+            result = "(" + result + ")";
+        return result;
+    }
+    static getPrecedence(symbol) {
+        let result;
+        symbol = symbol?.replace(/ /g, "");
+        switch (symbol) {
+            case "+":
+                result = 14;
+                break;
+            case "-":
+                result = 15;
+                break;
+            case "*":
+                result = 16;
+                break;
+            default:
+                result = undefined;
+                break;
+        }
+        return result;
+    }
+    static create(symbol, left, right) {
+        let result;
+        const fallback = new InfixOperator("+", 14, left, right);
+        const precedence = InfixOperator.getPrecedence(symbol);
+        if (precedence)
+            result = new InfixOperator(symbol, precedence, left, right);
+        return result || fallback;
+    }
+}
+function complete(tokens, type, baseObject) {
+    return [" + ", " - ", " * "]
+        .map(s => ({ value: s, suggestion: { value: s } }))
+        .map(c => Type.Completor.operators(tokens, (tokens) => (tokens ? baseObject.complete(tokens, undefined, type) : []), c))
+        .reduce((result, element) => result.concat(element), []);
+}
+Type.Number.addArgument(complete);
+
+addExpression((source, previous) => {
+    let result;
+    const symbol = source.peekIs(Source.binaryOperator) && source.fetch().value;
+    let precedence;
+    if (symbol && typeof previous == "object") {
+        let right;
+        let nextPrecedence;
+        let i = 0;
+        precedence = InfixOperator.getPrecedence(symbol);
+        while (!nextPrecedence && source.peek(i)) {
+            nextPrecedence =
+                source.peek(i)?.value == "(" ? Number.MAX_SAFE_INTEGER : InfixOperator.getPrecedence(source.peek(i)?.value);
+            i++;
+        }
+        if (nextPrecedence && precedence < nextPrecedence) {
+            right = parseNextExpression(precedence, source);
+            if (!right) {
+                source.raise("Missing right hand side of " + symbol);
+            }
+        }
+        else
+            right = parseNextExpression(NaN, source);
+        if ((nextPrecedence && precedence == nextPrecedence) || nextPrecedence == Number.MAX_SAFE_INTEGER) {
+            result = parseNextExpression(new InfixOperator(symbol, precedence, previous, right), source);
+        }
+        else
+            result = new InfixOperator(symbol, precedence, previous, right);
+    }
+    return result;
+});
+
+addExpression((source, previous) => {
+    const fetchedArray = [];
+    let fetched;
+    while ((fetched = source.fetchIf("identifier", ".")))
+        fetchedArray.push(fetched[0].value);
+    let result;
+    if (fetchedArray.length == 0) {
+        fetched = source.fetchIf("any", ".", "any") || source.fetchIf("any", ",", "any") || source.fetchIf("any");
+        result =
+            fetched &&
+                (Array.isArray(fetched)
+                    ? new Value(+fetched.map(t => t.value.replace(",", ".")).join(""))
+                    : new Value(fetched.value));
+    }
+    else {
+        fetched = source.fetchIf("identifier");
+        const fetchedValue = new Value(fetched ? fetched.value : 0);
+        result =
+            fetchedArray.length > 0
+                ? fetchedArray.reduceRight((r, name) => new Value(isNaN(+r) ? r : +r, name), fetchedValue)
+                : undefined;
+    }
+    if (result && typeof previous == "number" && !isNaN(previous) && previous != Number.MAX_SAFE_INTEGER)
+        result = parseNextExpression(result, source);
+    return result;
+});
+
+add(source => {
+    let expression;
+    if (source.fetchIf(":")) {
+        let algebra = false;
+        let comparator = false;
+        let i = 1;
+        while (!algebra && !comparator && source.peek(i)) {
+            algebra = Source.binaryOperator.some(c => source.peek(i)?.value == c);
+            comparator = Source.comparator.some(c => source.peek(i)?.value == c);
+            i++;
+        }
+        if (algebra)
+            expression = parseExpression(source);
+    }
+    const fetched = source.fetchIf("any");
+    return expression ? new Is(expression) : fetched && new Is(fetched.value);
+});
+
+add(source => {
+    source.raise(`Ignoring unknown token "${source.fetch()}"`);
+    return undefined;
+});
+
+var replace;
+(function (replace) {
+    function argument(value, argument) {
+        let result = undefined;
+        let index;
+        const parameter = typeof value == "string" ? value : value.toString();
+        if (argument &&
+            argument.input &&
+            argument.identifier &&
+            argument?.input?.length > 0 &&
+            argument?.identifier?.length > 0 &&
+            argument.identifier.includes(parameter)) {
+            index = argument.identifier.indexOf(parameter);
+            result = isNaN(+argument.input[index]) ? argument.input[index] : +argument.input[index];
+        }
+        return result;
+    }
+    replace.argument = argument;
+})(replace || (replace = {}));
+
+class Tuple extends Rule {
+    constructor(criteria) {
+        super();
+        this.criteria = criteria;
+        this.precedence = Number.MAX_SAFE_INTEGER;
+        this.class = "Tuple";
+    }
+    is(value) {
+        return this.criteria.length == value.length && this.criteria.every((c, index) => c.is(value[index]));
+    }
+    toString() {
+        return `[${this.criteria.map(c => c.toString()).join(", ")}]`;
+    }
+}
+add$1(criteria => (Array.isArray(criteria) ? new Tuple(criteria.map(create)) : undefined));
+
+exports.and = and;
+exports.create = create;
+exports.endsWith = endsWith;
+exports.greaterThan = greaterThan;
+exports.includes = includes;
+exports.lesserThan = lesserThan;
+exports.parse = parse;
+exports.startsWith = startsWith;
+
+//# sourceMappingURL=Tuple-0ed9d0da.js.map