@litert/typeguard 1.0.0 → 1.2.0

package/dist/typeguard.amd.js

@@ -1,2063 +0,0 @@
-/*
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("Common", ["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("Internal", ["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.MAP_SUFFIX = "{}";
-    exports.LIST_SUFFIX = "[]";
-    exports.MODIFIER_PREFIX = "$.";
-    exports.FILTER_PREFIX = "|";
-    exports.IMPLICIT_SYMBOL = "?";
-    exports.PREDEF_TYPE_SYMBOL = "@";
-    exports.NEGATIVE_SYMBOL = "!";
-    exports.KEY_MAP_SUFFIX = `->${exports.MAP_SUFFIX}`;
-    exports.KEY_LIST_SUFFIX = `->${exports.LIST_SUFFIX}`;
-    exports.KEY_ARRAY_SUFFIX = /->\[\s*(\d+)(\s*,\s*(\d+)?)?\s*\]$/;
-    exports.KEY_STRICT_SUFFIX = "->()";
-    exports.KEY_EQUAL_SUFFIX = "->(=)";
-    var EFlags;
-    (function (EFlags) {
-        EFlags[EFlags["FROM_STRING"] = 0] = "FROM_STRING";
-        EFlags[EFlags["STRICT"] = 1] = "STRICT";
-        EFlags[EFlags["OPTIONAL"] = 2] = "OPTIONAL";
-        EFlags[EFlags["REQUIRED"] = 3] = "REQUIRED";
-        EFlags[EFlags["ARRAY"] = 4] = "ARRAY";
-    })(EFlags = exports.EFlags || (exports.EFlags = {}));
-    var EFlagValue;
-    (function (EFlagValue) {
-        /**
-         * Disabled.
-         */
-        EFlagValue[EFlagValue["NO"] = 0] = "NO";
-        /**
-         * Enabled but not inheritable.
-         */
-        EFlagValue[EFlagValue["YES"] = 1] = "YES";
-        /**
-         * Enabled and inheritable if not deep into sub element.
-         */
-        EFlagValue[EFlagValue["INHERIT"] = 2] = "INHERIT";
-        /**
-         * Enabled and inheritable even deep into sub element.
-         */
-        EFlagValue[EFlagValue["ELEMENT_INHERIT"] = 3] = "ELEMENT_INHERIT";
-    })(EFlagValue = exports.EFlagValue || (exports.EFlagValue = {}));
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("BuiltInTypes", ["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.STRING = "string";
-    exports.ASCII_STRING = "ascii_string";
-    exports.HEX_STRING = "hex_string";
-    exports.LATIN_STRING = "latin_string";
-    exports.NUMERIC = "numeric";
-    exports.SAFE_INT = "safe_int";
-    exports.INT = "int";
-    exports.INT8 = "int8";
-    exports.INT16 = "int16";
-    exports.INT32 = "int32";
-    exports.INT64 = "int64";
-    exports.SAFE_UINT = "safe_uint";
-    exports.UINT = "uint";
-    exports.UINT8 = "uint8";
-    exports.UINT16 = "uint16";
-    exports.UINT32 = "uint32";
-    exports.UINT64 = "uint64";
-    exports.BOOLEAN = "boolean";
-    exports.ARRAY = "array";
-    exports.ANY = "any";
-    exports.STRUCT = "struct";
-    exports.NULL = "null";
-    exports.UNDEFINED = "undefined";
-    exports.VOID = "void";
-    exports.FALSE = "false";
-    exports.TRUE = "true";
-    exports.FALSE_VALUE = "false_value";
-    exports.TRUE_VALUE = "true_value";
-    exports.OPTIONAL = "optional";
-    exports.REQUIRED = "required";
-    exports.DECIMAL = "decimal";
-    exports.NUMBER = "number";
-    exports.FLOAT = "float";
-    exports.UDECIMAL = "udecimal";
-    exports.UFLOAT = "ufloat";
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("BuiltInTypeCompiler", ["require", "exports", "Internal", "BuiltInTypes"], function (require, exports, I, B) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const BUILT_IN_TYPES = {
-        [B.STRING]: {
-            "kind": "string",
-            "string": true,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.ASCII_STRING]: {
-            "kind": "string",
-            "string": true,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.HEX_STRING]: {
-            "kind": "string",
-            "string": true,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.LATIN_STRING]: {
-            "kind": "string",
-            "string": true,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.NUMERIC]: {
-            "kind": "number",
-            "string": true,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.SAFE_INT]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.INT]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.INT8]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.INT16]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.INT32]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.INT64]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.SAFE_UINT]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.UINT]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.UINT8]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.UINT16]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.UINT32]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.UINT64]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.BOOLEAN]: {
-            "kind": "boolean",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.ARRAY]: {
-            "kind": "array",
-            "string": false,
-            "constructed": true,
-            "elemental": false
-        },
-        [B.ANY]: {
-            "kind": "unknown",
-            "string": false,
-            "constructed": false,
-            "elemental": false
-        },
-        [B.STRUCT]: {
-            "kind": "struct",
-            "string": false,
-            "constructed": true,
-            "elemental": false
-        },
-        [B.NULL]: {
-            "kind": "null",
-            "string": false,
-            "constructed": false,
-            "elemental": false
-        },
-        [B.UNDEFINED]: {
-            "kind": "void",
-            "string": false,
-            "constructed": false,
-            "elemental": false
-        },
-        [B.VOID]: {
-            "kind": "void",
-            "string": false,
-            "constructed": false,
-            "elemental": false
-        },
-        [B.FALSE]: {
-            "kind": "boolean",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.TRUE]: {
-            "kind": "boolean",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.FALSE_VALUE]: {
-            "kind": "unknown",
-            "string": false,
-            "constructed": false,
-            "elemental": false
-        },
-        [B.TRUE_VALUE]: {
-            "kind": "unknown",
-            "string": false,
-            "constructed": false,
-            "elemental": false
-        },
-        [B.OPTIONAL]: {
-            "kind": "void",
-            "string": false,
-            "constructed": false,
-            "elemental": false
-        },
-        [B.REQUIRED]: {
-            "kind": "unknown",
-            "string": false,
-            "constructed": false,
-            "elemental": false
-        },
-        [B.DECIMAL]: {
-            "kind": "number",
-            "string": true,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.NUMBER]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.FLOAT]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.UDECIMAL]: {
-            "kind": "number",
-            "string": true,
-            "constructed": false,
-            "elemental": true
-        },
-        [B.UFLOAT]: {
-            "kind": "number",
-            "string": false,
-            "constructed": false,
-            "elemental": true
-        }
-    };
-    class BuiltInTypeCompiler {
-        constructor(_lang) {
-            this._lang = _lang;
-        }
-        isStringType(type) {
-            return this.isBuiltInType(type) && BUILT_IN_TYPES[type].string;
-        }
-        isConstructed(type) {
-            return this.isBuiltInType(type) && BUILT_IN_TYPES[type].constructed;
-        }
-        isElemental(type) {
-            return this.isBuiltInType(type) && BUILT_IN_TYPES[type].elemental;
-        }
-        isBuiltInType(type) {
-            return BUILT_IN_TYPES[type] !== undefined;
-        }
-        compile(type, ctx, args) {
-            const fromString = !!(ctx.flags[I.EFlags.FROM_STRING] &&
-                this.isBuiltInType(type) && (BUILT_IN_TYPES[type].kind === "number" ||
-                BUILT_IN_TYPES[type].kind === "boolean" ||
-                BUILT_IN_TYPES[type].kind === "null"));
-            switch (type) {
-                case B.NULL: {
-                    if (fromString) {
-                        return this._lang.or([
-                            this._lang.isNull(ctx.vName, true),
-                            this._lang.eq(ctx.vName, this._lang.literal("null"))
-                        ]);
-                    }
-                    return this._lang.isNull(ctx.vName, true);
-                }
-                case B.ANY: {
-                    return this._lang.literal(true);
-                }
-                case B.ARRAY: {
-                    return this._isArray(ctx, args);
-                }
-                case B.STRING: {
-                    return this._isString(ctx, args);
-                }
-                case B.ASCII_STRING: {
-                    return this._isString(ctx, args, "[\\u0000-\\u007F]");
-                }
-                case B.LATIN_STRING: {
-                    return this._isString(ctx, args, "[\\u0000-\\u024F\\u2C60-\\u2C7F]");
-                }
-                case B.HEX_STRING: {
-                    return this._isString(ctx, args, "[0-9A-Fa-f]");
-                }
-                case B.UFLOAT: {
-                    return this._isNumber(ctx, [0, NaN], fromString);
-                }
-                case B.FLOAT:
-                case B.NUMBER: {
-                    return this._isNumber(ctx, args, fromString);
-                }
-                case B.INT: {
-                    return this._isInteger(ctx, args, fromString);
-                }
-                case B.INT64: {
-                    return this._isInteger(ctx, [], fromString);
-                }
-                case B.INT8: {
-                    return this._isInteger(ctx, [-0x80, 0x7F], fromString);
-                }
-                case B.INT16: {
-                    return this._isInteger(ctx, [-0x8000, 0x7FFF], fromString);
-                }
-                case B.INT32: {
-                    return this._isInteger(ctx, [-0x80000000, 0x7FFFFFFF], fromString);
-                }
-                case B.SAFE_INT: {
-                    return this._isInteger(ctx, [this._lang.minSafeInteger, this._lang.maxSafeInteger], fromString);
-                }
-                case B.UINT:
-                case B.UINT64: {
-                    return this._isInteger(ctx, [0, NaN], fromString);
-                }
-                case B.UINT8: {
-                    return this._isInteger(ctx, [0, 0xFF], fromString);
-                }
-                case B.UINT16: {
-                    return this._isInteger(ctx, [0, 0xFFFF], fromString);
-                }
-                case B.UINT32: {
-                    return this._isInteger(ctx, [0, 0xFFFFFFFF], fromString);
-                }
-                case B.SAFE_UINT: {
-                    return this._isInteger(ctx, [0, this._lang.maxSafeInteger], fromString);
-                }
-                case B.BOOLEAN: {
-                    if (fromString) {
-                        return this._lang.or([
-                            this._lang.isBoolean(ctx.vName, true),
-                            this._lang.isBoolean(this._lang.str2Bool(ctx.vName), true)
-                        ]);
-                    }
-                    return this._lang.isBoolean(ctx.vName, true);
-                }
-                case B.TRUE: {
-                    if (fromString) {
-                        return this._lang.or([
-                            this._lang.eq(ctx.vName, this._lang.literal(true)),
-                            this._lang.eq(this._lang.str2Bool(ctx.vName), this._lang.literal(true))
-                        ]);
-                    }
-                    return this._lang.eq(ctx.vName, this._lang.literal(true));
-                }
-                case B.FALSE: {
-                    if (fromString) {
-                        return this._lang.or([
-                            this._lang.eq(ctx.vName, this._lang.literal(false)),
-                            this._lang.eq(this._lang.str2Bool(ctx.vName), this._lang.literal(false))
-                        ]);
-                    }
-                    return this._lang.eq(ctx.vName, this._lang.literal(false));
-                }
-                case B.TRUE_VALUE: {
-                    return this._lang.isTrueValue(ctx.vName);
-                }
-                case B.FALSE_VALUE: {
-                    return this._lang.isFalseValue(ctx.vName);
-                }
-                case B.VOID:
-                case B.OPTIONAL:
-                case B.UNDEFINED: {
-                    if (ctx.flags[I.EFlags.REQUIRED]) {
-                        throw new Error(`Conflicted: Can not use "optional" with "required" type.`);
-                    }
-                    if (ctx.flags[I.EFlags.OPTIONAL]) {
-                        return this._lang.literal(true);
-                    }
-                    ctx.flags[I.EFlags.OPTIONAL] = I.EFlagValue.YES;
-                    return this._lang.isUndefined(ctx.vName, true);
-                }
-                case B.REQUIRED: {
-                    if (ctx.flags[I.EFlags.OPTIONAL]) {
-                        throw new Error(`Conflicted: Can not use "required" with "optional" type.`);
-                    }
-                    if (ctx.flags[I.EFlags.REQUIRED]) {
-                        return this._lang.literal(true);
-                    }
-                    ctx.flags[I.EFlags.REQUIRED] = I.EFlagValue.YES;
-                    return this._lang.isUndefined(ctx.vName, false);
-                }
-                case B.STRUCT: {
-                    return this._lang.isStrucutre(ctx.vName, true);
-                }
-                case B.NUMERIC: {
-                    if (args.length) {
-                        return this._isNumber(ctx, args, true);
-                    }
-                    return this._lang.isNumeric(ctx.vName, true);
-                }
-                case B.DECIMAL: {
-                    return this._isDecimal(ctx, args);
-                }
-                case B.UDECIMAL: {
-                    return this._isDecimal(ctx, args, true);
-                }
-            }
-            throw new TypeError(`Unknown type ${type}.`);
-        }
-        _isDecimal(ctx, params, unsigned = false) {
-            if (params[0] <= 0) {
-                throw new RangeError(`Arg 0 can not be zero for decimal.`);
-            }
-            const sign = unsigned ? "" : "[-+]?";
-            switch (params.length) {
-                default:
-                case 0: {
-                    return this._lang.and([
-                        this._lang.isString(ctx.vName, true),
-                        this._lang.matchRegExp(ctx.vName, `^${sign}([1-9]\\d*|0)(\\.\\d+)?$`)
-                    ]);
-                }
-                case 1: {
-                    return this._lang.and([
-                        this._lang.isString(ctx.vName, true),
-                        this._lang.matchRegExp(ctx.vName, `^${sign}([1-9]\\d*|0)(\\.\\d+)?$`),
-                        this._lang.ifElseOp(this._lang.instr(ctx.vName, this._lang.literal(".")), this._lang.lte(this._lang.stringLength(ctx.vName), params[0] + 1), this._lang.lte(this._lang.stringLength(ctx.vName), params[0]))
-                    ]);
-                }
-                case 2: {
-                    if (params[0] < params[1]) {
-                        throw new RangeError(`Arg 0 should not be larger than arg 1 for decimal.`);
-                    }
-                    if (params[1] === 0) {
-                        return this._lang.and([
-                            this._lang.isString(ctx.vName, true),
-                            this._lang.matchRegExp(ctx.vName, `^${sign}([1-9]\\d{0,${params[0] - 1}}|0)$`)
-                        ]);
-                    }
-                    if (params[0] === params[1]) {
-                        return this._lang.and([
-                            this._lang.isString(ctx.vName, true),
-                            this._lang.matchRegExp(ctx.vName, `^${sign}0\\.\\d{${params[1]}}$`)
-                        ]);
-                    }
-                    return this._lang.matchRegExp(ctx.vName, `^${sign}([1-9]\\d{0,${params[0] - params[1] - 1}}|0)\\.\\d{${params[1]}}$`);
-                }
-            }
-        }
-        _isArray(ctx, params) {
-            switch (params.length) {
-                default:
-                case 0: {
-                    return this._lang.isArray(ctx.vName, true);
-                }
-                case 1: {
-                    if (!Number.isInteger(params[0]) || params[0] < 0) {
-                        throw new Error(`Invalid argument "${params[0]}" for array.`);
-                    }
-                    return this._lang.and([
-                        this._lang.isArray(ctx.vName, true),
-                        this._lang.eq(this._lang.arrayLength(ctx.vName), params[0])
-                    ]);
-                }
-                case 2: {
-                    if (!Number.isInteger(params[0]) || params[0] < 0) {
-                        throw new Error(`Invalid argument "${params[0]}" for array.`);
-                    }
-                    const result = [
-                        this._lang.isArray(ctx.vName, true),
-                        this._lang.gte(this._lang.arrayLength(ctx.vName), params[0])
-                    ];
-                    if (this._checkValidUInteger(params[1], `Invalid argument "${params[1]}" for array.`)) {
-                        if (params[0] > params[1]) {
-                            throw new RangeError(`Arg 0 should not be larger than arg 1 for array.`);
-                        }
-                        result.push(this._lang.lte(this._lang.arrayLength(ctx.vName), params[1]));
-                    }
-                    return this._lang.and(result);
-                }
-            }
-        }
-        _isNumber(ctx, params, fromString) {
-            const result = [
-                this._lang.isNumber(ctx.vName, true)
-            ];
-            switch (params.length) {
-                default:
-                case 0: {
-                    if (fromString) {
-                        result.push(this._lang.and([
-                            this._lang.isString(ctx.vName, true),
-                            this._lang.matchRegExp(ctx.vName, "^[-+]?\\d+(\\.\\d+)?$")
-                        ]));
-                    }
-                    return this._lang.or(result);
-                }
-                case 2: {
-                    let vName = ctx.vName;
-                    if (fromString) {
-                        ctx.trap(true);
-                        vName = this._lang.varName(ctx.vCursor++);
-                    }
-                    if (this._checkValidNumber(params[0], `Invalid argument "${params[0]}".`)) {
-                        result.push(this._lang.gte(vName, params[0]));
-                    }
-                    if (this._checkValidNumber(params[1], `Invalid argument "${params[1]}".`)) {
-                        if (params[0] > params[1]) {
-                            throw new RangeError(`Arg 0 should not be larger than arg 1 for number.`);
-                        }
-                        result.push(this._lang.lte(vName, params[1]));
-                    }
-                    if (result.length === 1) {
-                        throw new SyntaxError(`Invalid syntax of integer.`);
-                    }
-                    if (fromString) {
-                        ctx.untrap();
-                        return this._lang.and([
-                            this._lang.or([
-                                result[0],
-                                this._lang.and([
-                                    this._lang.isString(ctx.vName, true),
-                                    this._lang.matchRegExp(ctx.vName, "^[-+]?\\d+(\\.\\d+)?$")
-                                ])
-                            ]),
-                            result.length === 3 ? this._lang.closure([vName], [this._lang.str2Float(ctx.vName)], this._lang.returnValue(this._lang.and(result.slice(1)))) : result[1].replace(vName, this._lang.str2Float(ctx.vName))
-                        ]);
-                    }
-                    return this._lang.and(result);
-                }
-            }
-        }
-        _checkValidNumber(v, msg) {
-            if (Number.isNaN(v)) {
-                return false;
-            }
-            if (Number.isFinite(v)) {
-                return true;
-            }
-            throw new TypeError(msg);
-        }
-        _checkValidInteger(v, msg) {
-            if (typeof v === "string") {
-                v = parseFloat(v);
-            }
-            if (Number.isNaN(v)) {
-                return false;
-            }
-            if (Number.isInteger(v)) {
-                return true;
-            }
-            throw new TypeError(msg);
-        }
-        _checkValidUInteger(v, msg) {
-            if (Number.isNaN(v)) {
-                return false;
-            }
-            if (Number.isInteger(v) && v > -1) {
-                return true;
-            }
-            throw new TypeError(msg);
-        }
-        _isInteger(ctx, params, fromString) {
-            const result = [
-                this._lang.isInteger(ctx.vName, true)
-            ];
-            switch (params.length) {
-                default:
-                case 0: {
-                    if (fromString) {
-                        result.push(this._lang.and([
-                            this._lang.isString(ctx.vName, true),
-                            this._lang.matchRegExp(ctx.vName, "^[-+]?\\d+$")
-                        ]));
-                    }
-                    return this._lang.or(result);
-                }
-                case 2: {
-                    let vName = ctx.vName;
-                    if (fromString) {
-                        ctx.trap(true);
-                        vName = this._lang.varName(ctx.vCursor++);
-                    }
-                    if (this._checkValidInteger(params[0], `Invalid argument "${params[0]}" for integer.`)) {
-                        result.push(this._lang.gte(vName, params[0]));
-                    }
-                    if (this._checkValidInteger(params[1], `Invalid argument "${params[1]}" for integer.`)) {
-                        if (params[0] > params[1]) {
-                            throw new RangeError(`Arg 0 should not be larger than arg 1 for number.`);
-                        }
-                        result.push(this._lang.lte(vName, params[1]));
-                    }
-                    if (result.length === 1) {
-                        throw new SyntaxError(`Invalid syntax of integer.`);
-                    }
-                    if (fromString) {
-                        ctx.untrap();
-                        return this._lang.and([
-                            this._lang.or([
-                                result[0],
-                                this._lang.and([
-                                    this._lang.isString(ctx.vName, true),
-                                    this._lang.matchRegExp(ctx.vName, "^[-+]?\\d+$")
-                                ])
-                            ]),
-                            result.length === 3 ? this._lang.closure([vName], [this._lang.str2Int(ctx.vName)], this._lang.returnValue(this._lang.and(result.slice(1)))) : result[1].replace(vName, this._lang.str2Int(ctx.vName))
-                        ]);
-                    }
-                    return this._lang.and(result);
-                }
-            }
-        }
-        _isString(ctx, params, elementRegExp) {
-            switch (params.length) {
-                default:
-                case 0: {
-                    return elementRegExp ? this._lang.and([
-                        this._lang.isString(ctx.vName, true),
-                        this._lang.matchRegExp(ctx.vName, `^${elementRegExp}*$`)
-                    ]) : this._lang.isString(ctx.vName, true);
-                }
-                case 1: {
-                    if (!Number.isInteger(params[0]) || params[0] < 0) {
-                        throw new Error(`Invalid argument "${params[0]}" for string.`);
-                    }
-                    return this._lang.and([
-                        this._lang.isString(ctx.vName, true),
-                        elementRegExp ? this._lang.matchRegExp(ctx.vName, `^${elementRegExp}{${params[0]}}$`) : this._lang.eq(this._lang.stringLength(ctx.vName), params[0])
-                    ]);
-                }
-                case 2: {
-                    if (!Number.isInteger(params[0]) || params[0] < 0) {
-                        throw new Error(`Invalid argument "${params[0]}" for string.`);
-                    }
-                    const result = [
-                        this._lang.isString(ctx.vName, true)
-                    ];
-                    if (elementRegExp) {
-                        if (this._checkValidUInteger(params[1], `Invalid argument "${params[1]}" for string.`)) {
-                            if (params[0] > params[1]) {
-                                throw new RangeError(`Arg 0 should not be larger than arg 1 for string.`);
-                            }
-                            result.push(this._lang.matchRegExp(ctx.vName, `^${elementRegExp}{${params[0]},${params[1]}}$`));
-                        }
-                        else {
-                            result.push(this._lang.matchRegExp(ctx.vName, `^${elementRegExp}{${params[0]},}}$`));
-                        }
-                    }
-                    else {
-                        if (this._checkValidUInteger(params[1], `Invalid argument "${params[1]}" for string.`)) {
-                            if (params[0] > params[1]) {
-                                throw new RangeError(`Arg 0 should not be larger than arg 1 for string.`);
-                            }
-                            result.push(this._lang.gte(this._lang.stringLength(ctx.vName), params[0]), this._lang.lte(this._lang.stringLength(ctx.vName), params[1]));
-                        }
-                        else {
-                            result.push(this._lang.gte(this._lang.stringLength(ctx.vName), this._lang.literal(params[0])));
-                        }
-                    }
-                    return this._lang.and(result);
-                }
-            }
-        }
-    }
-    exports.BuiltInTypeCompiler = BuiltInTypeCompiler;
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("Modifiers", ["require", "exports", "Internal"], function (require, exports, I) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.PREFIX = I.MODIFIER_PREFIX;
-    exports.NOT = `${I.MODIFIER_PREFIX}not`;
-    exports.OR = `${I.MODIFIER_PREFIX}or`;
-    exports.AND = `${I.MODIFIER_PREFIX}and`;
-    exports.MAP = `${I.MODIFIER_PREFIX}map`;
-    exports.LIST = `${I.MODIFIER_PREFIX}list`;
-    exports.ARRAY = `${I.MODIFIER_PREFIX}array`;
-    exports.DICT = `${I.MODIFIER_PREFIX}dict`;
-    exports.STRICT = `${I.MODIFIER_PREFIX}strict`;
-    exports.STRING = `${I.MODIFIER_PREFIX}string`;
-    exports.TUPLE = `${I.MODIFIER_PREFIX}tuple`;
-    exports.EQUAL = `${I.MODIFIER_PREFIX}equal`;
-    exports.TAG = `${I.MODIFIER_PREFIX}tag`;
-    exports.TYPE = `${I.MODIFIER_PREFIX}type`;
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("Context", ["require", "exports", "Internal"], function (require, exports, i) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    class Context {
-        constructor(vName, typeSlotName, referredTypes) {
-            this.vName = vName;
-            this.typeSlotName = typeSlotName;
-            this.referredTypes = referredTypes;
-            this.stack = [];
-            this.vCursor = 0;
-            this.flags = {};
-            this.tracePoint = 0;
-            this.trace = false;
-        }
-        trap(subjChanged = false) {
-            this.stack.push({
-                vName: this.vName,
-                flags: this.flags
-            });
-            const prevFlags = this.flags;
-            this.flags = {};
-            for (const key in prevFlags) {
-                if (subjChanged) {
-                    if (prevFlags[key] === i.EFlagValue.ELEMENT_INHERIT) {
-                        this.flags[key] = prevFlags[key];
-                    }
-                }
-                else if (prevFlags[key] === i.EFlagValue.INHERIT ||
-                    prevFlags[key] === i.EFlagValue.ELEMENT_INHERIT) {
-                    this.flags[key] = prevFlags[key];
-                }
-            }
-        }
-        untrap() {
-            const prev = this.stack.pop();
-            if (!prev) {
-                throw new Error("Failed to pop stack.");
-            }
-            this.vName = prev.vName;
-            this.flags = prev.flags;
-        }
-    }
-    exports.Context = Context;
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("FilterCompiler", ["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    class FilterCompiler {
-        constructor(_lang, _bitc) {
-            this._lang = _lang;
-            this._bitc = _bitc;
-        }
-        compile(rule, ctx) {
-            let vName = ctx.vName;
-            const filter = rule.slice(1).split(" ");
-            if (filter.slice(2).length !== filter.slice(2).filter((x) => /^\d+(\.\d+)?$/.test(x)).length) {
-                throw new TypeError("Only number is allowed as filter arguments.");
-            }
-            let ret = [];
-            switch (filter[0]) {
-                case "array.length":
-                    ret.push(this._lang.isArray(vName, true));
-                    vName = this._lang.arrayLength(vName);
-                    break;
-                case "string.length":
-                    ret.push(this._lang.isString(vName, true));
-                    vName = this._lang.stringLength(vName);
-                    break;
-                case "value":
-                    ret.push(this._lang.isNumber(vName, true));
-                    break;
-                default:
-                    ret.push(this._bitc.compile(filter[0], ctx, []));
-                    break;
-            }
-            switch (filter[1]) {
-                case "between":
-                    if (filter.length !== 4) {
-                        throw new TypeError(`Filter ${filter[1]} require 2 arguments.`);
-                    }
-                    ret.push(this._lang.gte(vName, filter[2]));
-                    ret.push(this._lang.lte(vName, filter[3]));
-                    break;
-                case "gt":
-                case ">":
-                    if (filter.length !== 3) {
-                        throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-                    }
-                    ret.push(this._lang.gt(vName, filter[2]));
-                    break;
-                case "ge":
-                case "gte":
-                case ">=":
-                    if (filter.length !== 3) {
-                        throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-                    }
-                    ret.push(this._lang.gte(vName, filter[2]));
-                    break;
-                case "lt":
-                case "<":
-                    if (filter.length !== 3) {
-                        throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-                    }
-                    ret.push(this._lang.lt(vName, filter[2]));
-                    break;
-                case "le":
-                case "lte":
-                case "<=":
-                    if (filter.length !== 3) {
-                        throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-                    }
-                    ret.push(this._lang.lte(vName, filter[2]));
-                    break;
-                case "eq":
-                case "==":
-                    if (filter.length !== 3) {
-                        throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-                    }
-                    ret.push(this._lang.eq(vName, filter[2]));
-                    break;
-                case "ne":
-                case "!=":
-                    if (filter.length !== 3) {
-                        throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-                    }
-                    ret.push(this._lang.ne(vName, filter[2]));
-                    break;
-                case "timesof":
-                    if (filter.length !== 3) {
-                        throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-                    }
-                    ret.push(this._lang.eq(this._lang.modOf(vName, filter[2]), "0"));
-                    break;
-                default:
-                    throw new TypeError(`Unknown filter type "${filter[1]}".`);
-            }
-            return this._lang.and(ret);
-        }
-    }
-    exports.FilterCompiler = FilterCompiler;
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("Compiler", ["require", "exports", "Internal", "Modifiers", "Context", "BuiltInTypes", "BuiltInTypeCompiler", "FilterCompiler"], function (require, exports, I, M, Context_1, B, BuiltInTypeCompiler_1, FilterCompiler_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    class Compiler {
-        constructor(_lang, _builtInTypes, _filters) {
-            this._lang = _lang;
-            this._builtInTypes = _builtInTypes;
-            this._filters = _filters;
-            this._defTypes = {};
-        }
-        getPredefinedType(name) {
-            if (this._defTypes[name]) {
-                return this._defTypes[name];
-            }
-            return null;
-        }
-        compile(options) {
-            const referredTypes = {};
-            const ctx = new Context_1.Context(this._lang.varName("entry"), this._lang.varName("types"), referredTypes);
-            if (options.name) {
-                this._compile(ctx, [M.TYPE, options.name, options.rule]);
-                return this._defTypes[options.name];
-            }
-            else {
-                const ret = {
-                    source: "",
-                    arguments: [{
-                            "name": ctx.vName,
-                            "type": "unknown"
-                        }],
-                    typeSlotName: ctx.typeSlotName,
-                    referredTypes: []
-                };
-                ret.source = this._compile(ctx, options.rule);
-                ret.referredTypes = Object.keys(ctx.referredTypes);
-                return ret;
-            }
-        }
-        _compile(ctx, rules) {
-            switch (typeof rules) {
-                case "string":
-                    return this._compileStringRule(ctx, rules);
-                case "boolean":
-                    if (ctx.flags[I.EFlags.FROM_STRING]) {
-                        return this._lang.or([
-                            this._lang.eq(ctx.vName, this._lang.literal(rules)),
-                            this._lang.eq(this._lang.str2Bool(ctx.vName), this._lang.literal(rules))
-                        ]);
-                    }
-                    return this._lang.eq(ctx.vName, this._lang.literal(rules));
-                case "number":
-                    if (ctx.flags[I.EFlags.FROM_STRING]) {
-                        return this._lang.or([
-                            this._lang.eq(ctx.vName, this._lang.literal(rules)),
-                            this._lang.eq(this._lang.str2Float(ctx.vName), this._lang.literal(rules))
-                        ]);
-                    }
-                    return this._lang.eq(ctx.vName, this._lang.literal(rules));
-                case "object":
-                    if (Array.isArray(rules)) {
-                        return this._compileModifiedRule(ctx, rules);
-                    }
-                    else if (rules === null) {
-                        if (ctx.flags[I.EFlags.FROM_STRING]) {
-                            return this._lang.or([
-                                this._lang.isNull(ctx.vName, true),
-                                this._lang.eq(ctx.vName, this._lang.literal("null"))
-                            ]);
-                        }
-                        return this._lang.isNull(ctx.vName, true);
-                    }
-                    return this._compileStructuredRule(ctx, rules);
-                case "undefined":
-                    return this._lang.isUndefined(ctx.vName, true);
-            }
-            throw new TypeError("Unknwn rules.");
-        }
-        _compileStringRule(ctx, rule) {
-            const strAssert = this._useStringAssert(ctx, rule);
-            if (strAssert !== false) {
-                return this._lang.and([
-                    this._lang.isString(ctx.vName, true),
-                    strAssert
-                ]);
-            }
-            if (rule[0] === I.IMPLICIT_SYMBOL) {
-                return this._lang.or([
-                    this._builtInTypes.compile(B.VOID, ctx, []),
-                    this._compileStringRule(ctx, rule.slice(1))
-                ]);
-            }
-            if (rule[0] === I.NEGATIVE_SYMBOL) {
-                return this._lang.not(this._compileStringRule(ctx, rule.slice(1)));
-            }
-            let regResult;
-            /**
-             * For rules like `xxx[123]` or `xxx[1,5]`.
-             */
-            if (regResult = rule.match(/\[\s*(\d*|\d+\s*,\s*\d*)\s*\]$/)) {
-                if (regResult[1]) {
-                    let range = regResult[1].split(",").map((x) => parseInt(x.trim()));
-                    if (range.length === 1) {
-                        return this._compileModifiedRule(ctx, [
-                            M.ARRAY,
-                            range[0],
-                            rule.substr(0, regResult.index)
-                        ]);
-                    }
-                    else if (Number.isNaN(range[1])) {
-                        return this._compileModifiedRule(ctx, [
-                            M.ARRAY,
-                            [range[0]],
-                            rule.substr(0, regResult.index)
-                        ]);
-                    }
-                    else {
-                        return this._compileModifiedRule(ctx, [
-                            M.ARRAY,
-                            range,
-                            rule.substr(0, regResult.index)
-                        ]);
-                    }
-                }
-                else {
-                    return this._compileModifiedRule(ctx, [
-                        M.LIST,
-                        rule.substr(0, regResult.index)
-                    ]);
-                }
-            }
-            /**
-             * For rules like `xxx{}`.
-             */
-            if (rule.endsWith(I.MAP_SUFFIX)) {
-                return this._lang.and([
-                    this._compileModifiedRule(ctx, [
-                        M.MAP,
-                        rule.slice(0, -2)
-                    ])
-                ]);
-            }
-            if (rule[0] === I.PREDEF_TYPE_SYMBOL) {
-                return this._usePredefinedType(ctx, rule.slice(1));
-            }
-            /**
-             * For built-in-type rules like:
-             *
-             * - `string(20)`
-             * - `string(20, 30)`
-             * - `string`
-             * - `int(12, 34)`
-             */
-            if (regResult = rule.match(/^(\w+)(\(\s*(-?\d+(\.\d+)?)?\s*,?\s*(-?\d+(\.\d+)?)?\s*\))?$/)) {
-                if (regResult[2]) {
-                    const args = regResult[2].slice(1, -1).trim().split(",").map((x) => parseFloat(x.trim()));
-                    return this._builtInTypes.compile(regResult[1], ctx, args);
-                }
-                return this._builtInTypes.compile(regResult[1], ctx, []);
-            }
-            if (rule[0] === I.FILTER_PREFIX) {
-                return this._filters.compile(rule, ctx);
-            }
-            throw new TypeError(`Unknown type "${rule}".`);
-        }
-        _usePredefinedType(ctx, typeName) {
-            this._validateTypeName(typeName);
-            ctx.referredTypes[typeName] = true;
-            return this._lang.call(this._lang.fieldIndex(ctx.typeSlotName, this._lang.literal(typeName)), ctx.vName);
-        }
-        _useStringAssert(ctx, rule) {
-            const assertRule = rule.match(/^:([-\w]+):/);
-            const offset = assertRule ? assertRule[1].length + 2 : 2;
-            switch ((assertRule && assertRule[1]) || rule.substr(0, 2)) {
-                case "==":
-                case "equal":
-                    return this._lang.eq(ctx.vName, this._lang.literal(rule.slice(offset)));
-                case "%=":
-                case "equal-i":
-                    return this._lang.eq(this._lang.lowerCase(ctx.vName), this._lang.literal(rule.slice(offset).toLowerCase()));
-                case "!=":
-                case "not-equal":
-                    return this._lang.ne(ctx.vName, this._lang.literal(rule.slice(offset)));
-                case "%!":
-                case "not-equal-i":
-                    return this._lang.ne(this._lang.lowerCase(ctx.vName), this._lang.literal(rule.slice(offset).toLowerCase()));
-                case "~=":
-                case "match":
-                    return this._lang.matchRegExp(ctx.vName, rule.slice(offset));
-                case "~!":
-                case "not-match":
-                    return this._lang.not(this._lang.matchRegExp(ctx.vName, rule.slice(offset)));
-                case "?=":
-                case "include":
-                    return this._lang.instr(ctx.vName, this._lang.literal(rule.slice(offset)));
-                case "?!":
-                case "not-include":
-                    return this._lang.not(this._lang.instr(ctx.vName, this._lang.literal(rule.slice(offset))));
-                case "*=":
-                case "include-i":
-                    return this._lang.instr(this._lang.lowerCase(ctx.vName), this._lang.literal(rule.slice(offset).toLowerCase()));
-                case "*!":
-                case "not-include-i":
-                    return this._lang.not(this._lang.instr(this._lang.lowerCase(ctx.vName), this._lang.literal(rule.slice(offset).toLowerCase())));
-                case "^=":
-                case "start-with":
-                    return this._lang.startsWith(ctx.vName, this._lang.literal(rule.slice(offset)));
-                case "start-with-i":
-                    return this._lang.startsWith(this._lang.lowerCase(ctx.vName), this._lang.literal(rule.slice(offset).toLowerCase()));
-                case "^!":
-                case "not-start-with":
-                    return this._lang.not(this._lang.startsWith(ctx.vName, this._lang.literal(rule.slice(offset))));
-                case "not-start-with-i":
-                    return this._lang.not(this._lang.startsWith(this._lang.lowerCase(ctx.vName), this._lang.literal(rule.slice(offset).toLowerCase())));
-                case "$=":
-                case "end-with":
-                    return this._lang.endsWith(ctx.vName, this._lang.literal(rule.slice(offset)));
-                case "end-with-i":
-                    return this._lang.endsWith(this._lang.lowerCase(ctx.vName), this._lang.literal(rule.slice(offset).toLowerCase()));
-                case "$!":
-                case "not-end-with":
-                    return this._lang.not(this._lang.endsWith(ctx.vName, this._lang.literal(rule.slice(offset))));
-                case "not-end-with-i":
-                    return this._lang.not(this._lang.endsWith(this._lang.lowerCase(ctx.vName), this._lang.literal(rule.slice(offset).toLowerCase())));
-                default:
-                    if (rule.startsWith("=")) {
-                        return this._lang.eq(ctx.vName, this._lang.literal(rule.slice(1)));
-                    }
-                    if (rule.startsWith("~")) {
-                        return this._lang.matchRegExp(ctx.vName, rule.slice(1));
-                    }
-            }
-            return false;
-        }
-        _compileModifiedRule(ctx, rules) {
-            if (!rules.length) {
-                throw new TypeError(`Unknwon type "[]".`);
-            }
-            /**
-             * By default, use OR modifier.
-             */
-            if (typeof rules[0] !== "string" ||
-                !rules[0].startsWith(I.MODIFIER_PREFIX)) {
-                if (rules.length === 1) {
-                    return this._compile(ctx, rules[0]);
-                }
-                rules.unshift(M.OR);
-            }
-            switch (rules[0]) {
-                case M.NOT: {
-                    return this._lang.not(this._compileModifiedRule(ctx, rules.slice(1)));
-                }
-                case M.OR: {
-                    return this._compileModifierOR(ctx, rules.slice(1));
-                }
-                case M.AND: {
-                    return this._compileModifierAND(ctx, rules.slice(1));
-                }
-                case M.LIST: {
-                    return this._compileModifierLIST(ctx, rules.slice(1));
-                }
-                case M.ARRAY: {
-                    return this._compileModifierARRAY(ctx, rules.slice(1));
-                }
-                case M.DICT: {
-                    return this._compileModifierDICT(ctx, rules.slice(1));
-                }
-                case M.MAP: {
-                    return this._compileModifierMAP(ctx, rules.slice(1));
-                }
-                case M.TUPLE: {
-                    return this._compileModifierTUPLE(ctx, rules.slice(1));
-                }
-                case M.EQUAL: {
-                    return this._compileModifierEQUAL(ctx, rules.slice(1));
-                }
-                case M.STRICT: {
-                    return this._compileModifierSTRICT(ctx, rules.slice(1));
-                }
-                case M.STRING: {
-                    return this._compileModifierSTRING(ctx, rules.slice(1));
-                }
-                case M.TYPE: {
-                    return this._compileModifierTYPE(ctx, rules.slice(1));
-                }
-            }
-            throw new TypeError(`Unknown modifier "${rules[0]}".`);
-        }
-        _compileModifierSTRING(ctx, rules) {
-            ctx.trap();
-            ctx.flags[I.EFlags.FROM_STRING] = I.EFlagValue.ELEMENT_INHERIT;
-            const result = this._compileModifiedRule(ctx, rules);
-            ctx.untrap();
-            return result;
-        }
-        _compileModifierOR(ctx, rules) {
-            let result = [];
-            for (const r of rules) {
-                ctx.trap();
-                result.push(this._compile(ctx, r));
-                ctx.untrap();
-            }
-            return this._lang.or(result);
-        }
-        _compileModifierAND(ctx, rules) {
-            return this._lang.and(rules.map((rule) => this._compile(ctx, rule)));
-        }
-        _compileModifierLIST(ctx, rules) {
-            const result = [];
-            if (!ctx.flags[I.EFlags.ARRAY]) {
-                result.push(this._lang.isArray(ctx.vName, true));
-                ctx.flags[I.EFlags.ARRAY] = I.EFlagValue.INHERIT;
-            }
-            ctx.trap(true);
-            const CLOSURE_ARG = ctx.vName;
-            const CLOSURE_PARAM = this._lang.varName(ctx.vCursor++);
-            ctx.vName = this._lang.varName(ctx.vCursor++);
-            if (rules[0] !== B.ANY) {
-                result.push(this._lang.closure([CLOSURE_PARAM], [CLOSURE_ARG], this._lang.series([
-                    this._lang.forEach(CLOSURE_PARAM, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules)), this._lang.returnValue(this._lang.literal(false)))),
-                    this._lang.returnValue(this._lang.literal(true))
-                ])));
-            }
-            ctx.untrap();
-            return this._lang.and(result);
-        }
-        _compileModifierARRAY(ctx, rules) {
-            let a = 0;
-            let b = -1;
-            if (Number.isInteger(rules[0]) && rules[0] >= 0) {
-                a = rules[0];
-            }
-            else if (Array.isArray(rules[0])) {
-                switch (rules[0].length) {
-                    default:
-                    case 0: {
-                        throw new TypeError(`Invalid arguments "${JSON.stringify(rules[0])}" for array.`);
-                    }
-                    case 1: {
-                        a = rules[0][0];
-                        b = 0xFFFFFFFF;
-                        if (!Number.isInteger(a) || a < 0) {
-                            throw new TypeError(`Invalid arguments "${JSON.stringify(rules[0])}" for array.`);
-                        }
-                        break;
-                    }
-                    case 2: {
-                        a = rules[0][0];
-                        b = rules[0][1];
-                        if ((!Number.isInteger(a) || a < 0) ||
-                            (!Number.isInteger(b) || b < 0) ||
-                            a > b) {
-                            throw new TypeError(`Invalid arguments "${JSON.stringify(rules[0])}" for array.`);
-                        }
-                        if (a === b) {
-                            b = -1;
-                        }
-                    }
-                }
-            }
-            else {
-                throw new TypeError(`Invalid arguments "${JSON.stringify(rules[0])}" for array.`);
-            }
-            const result = [];
-            if (!ctx.flags[I.EFlags.ARRAY]) {
-                result.push(this._lang.isArray(ctx.vName, true));
-                ctx.flags[I.EFlags.ARRAY] = I.EFlagValue.INHERIT;
-            }
-            ctx.trap(true);
-            const CLOSURE_ARG = ctx.vName;
-            const CLOSURE_PARAM = this._lang.varName(ctx.vCursor++);
-            ctx.vName = this._lang.varName(ctx.vCursor++);
-            switch (b) {
-                case -1: {
-                    result.push(this._lang.eq(this._lang.arrayLength(CLOSURE_ARG), a));
-                    break;
-                }
-                case 0xFFFFFFFF: {
-                    result.push(this._lang.gte(this._lang.arrayLength(CLOSURE_ARG), a));
-                    break;
-                }
-                default: {
-                    result.push(this._lang.gte(this._lang.arrayLength(CLOSURE_ARG), a), this._lang.lte(this._lang.arrayLength(CLOSURE_ARG), b));
-                    break;
-                }
-            }
-            if (rules[1] !== B.ANY) {
-                result.push(this._lang.closure([CLOSURE_PARAM], [CLOSURE_ARG], this._lang.series([
-                    this._lang.forEach(CLOSURE_PARAM, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules.slice(1))), this._lang.returnValue(this._lang.literal(false)))),
-                    this._lang.returnValue(this._lang.literal(true))
-                ])));
-            }
-            ctx.untrap();
-            return this._lang.and(result);
-        }
-        _compileModifierTUPLE(ctx, rules) {
-            const result = [];
-            if (!ctx.flags[I.EFlags.ARRAY]) {
-                result.push(this._lang.isArray(ctx.vName, true));
-                ctx.flags[I.EFlags.ARRAY] = I.EFlagValue.INHERIT;
-            }
-            let type;
-            let dots;
-            let i = 0;
-            const types = rules.slice();
-            let tupleLength = 0;
-            while (1) {
-                type = types.shift();
-                if (type === undefined) {
-                    break;
-                }
-                if (typeof type === "string" && type.startsWith("...")) {
-                    throw new TypeError(`Invalid syntax for tuple: ${JSON.stringify(rules)}`);
-                }
-                if (typeof types[0] === "string" && types[0].startsWith("...")) {
-                    ctx.trap();
-                    dots = types.shift();
-                    if (dots === "...") {
-                        /**
-                         * No more elements because "..." means all rest elements.
-                         */
-                        if (types.length) {
-                            throw new TypeError(`Invalid syntax for tuple: ${JSON.stringify(rules)}`);
-                        }
-                        ctx.vName = this._lang.arraySlice(ctx.vName, i);
-                        if (type !== "any") {
-                            result.push(this._compileModifierLIST(ctx, type));
-                        }
-                        tupleLength = -1;
-                    }
-                    else if (!/^\d+$/.test(dots.slice(3))) {
-                        throw new TypeError(`Invalid syntax for tuple: ${dots}`);
-                    }
-                    else {
-                        const length = parseInt(dots.slice(3));
-                        if (length <= 3) {
-                            const vName = ctx.vName;
-                            for (let j = 0; j < length; j++) {
-                                ctx.vName = this._lang.arrayIndex(vName, i++);
-                                result.push(this._compile(ctx, type));
-                            }
-                        }
-                        else {
-                            ctx.vName = this._lang.arraySlice(ctx.vName, i, i + length);
-                            result.push(this._compileModifierARRAY(ctx, [length, type]));
-                            i += length;
-                        }
-                        tupleLength += length;
-                    }
-                }
-                else {
-                    ctx.trap(true);
-                    ctx.vName = this._lang.arrayIndex(ctx.vName, i++);
-                    result.push(this._compile(ctx, type));
-                    tupleLength++;
-                }
-                ctx.untrap();
-            }
-            if (tupleLength >= 0) {
-                result.splice(1, -1, this._lang.eq(this._lang.arrayLength(ctx.vName), tupleLength));
-            }
-            return this._lang.and(result);
-        }
-        _validateTypeName(name) {
-            if (typeof name !== "string" || !/^\w+$/.test(name)) {
-                throw new TypeError(`Invalid name ${JSON.stringify(name)} for a pre-defined type.`);
-            }
-        }
-        _compileModifierTYPE(ctx, rules) {
-            this._validateTypeName(rules[0]);
-            if (this._defTypes[rules[0]]) {
-                throw new Error(`Dplicated name ${JSON.stringify(rules[0])} for a pre-defined type.`);
-            }
-            this._defTypes[rules[0]] = this.compile({
-                rule: rules.slice(1)
-            });
-            return this._usePredefinedType(ctx, rules[0]);
-        }
-        _compileModifierSTRICT(ctx, rules) {
-            ctx.trap();
-            if (rules.length === 1) {
-                rules = rules[0];
-            }
-            ctx.flags[I.EFlags.STRICT] = I.EFlagValue.INHERIT;
-            const ret = this._compile(ctx, rules);
-            ctx.untrap();
-            return ret;
-        }
-        _compileModifierEQUAL(ctx, rules) {
-            ctx.trap();
-            if (rules.length === 1) {
-                rules = rules[0];
-            }
-            ctx.flags[I.EFlags.STRICT] = I.EFlagValue.ELEMENT_INHERIT;
-            const ret = this._compile(ctx, rules);
-            ctx.untrap();
-            return ret;
-        }
-        _compileModifierMAP(ctx, rules) {
-            if (rules.length === 1) {
-                rules = rules[0];
-            }
-            ctx.trap(true);
-            const CLOSURE_ARG = ctx.vName;
-            const CLOSURE_PARAM = this._lang.varName(ctx.vCursor++);
-            const FOR_IN_KEY = this._lang.varName(ctx.vCursor++);
-            ctx.vName = this._lang.varName(ctx.vCursor++);
-            const result = this._lang.and([
-                this._lang.isStrucutre(CLOSURE_ARG, true),
-                this._lang.closure([CLOSURE_PARAM], [CLOSURE_ARG], this._lang.series([
-                    this._lang.forIn(CLOSURE_PARAM, FOR_IN_KEY, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules)), this._lang.returnValue(this._lang.literal(false)))),
-                    this._lang.returnValue(this._lang.literal(true))
-                ]))
-            ]);
-            ctx.untrap();
-            return result;
-        }
-        _compileModifierDICT(ctx, rules) {
-            if (rules.length < 2 || !Array.isArray(rules[0])) {
-                throw new SyntaxError(`Invalid dict ${JSON.stringify(rules)}.`);
-            }
-            let tmp = {};
-            const id = `${Date.now()}${Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)}`;
-            this._compileModifierTYPE(ctx, [
-                this._lang.varName(id),
-                rules.slice(1)
-            ]);
-            const type = `${I.PREDEF_TYPE_SYMBOL}${this._lang.varName(id)}`;
-            for (let key of rules[0]) {
-                if (typeof key !== "string") {
-                    throw new SyntaxError(`Invalid key ${JSON.stringify(key)} for dict.`);
-                }
-                tmp[key] = type;
-            }
-            return this._compileStructuredRule(ctx, tmp);
-        }
-        _compileSimpleStructure(ctx, rules) {
-            const strict = !!ctx.flags[I.EFlags.STRICT];
-            const result = [
-                this._lang.isStrucutre(ctx.vName, true)
-            ];
-            const keys = [];
-            for (let k in rules) {
-                let rule = rules[k];
-                let optional = false;
-                if (k.endsWith(I.IMPLICIT_SYMBOL)) {
-                    optional = true;
-                    k = k.slice(0, -1);
-                }
-                ctx.trap(true);
-                if (k.endsWith(I.KEY_LIST_SUFFIX)) {
-                    k = k.slice(0, -I.KEY_LIST_SUFFIX.length);
-                    rule = [M.LIST, rule];
-                }
-                else if (k.endsWith(I.KEY_MAP_SUFFIX)) {
-                    k = k.slice(0, -I.KEY_MAP_SUFFIX.length);
-                    rule = [M.MAP, rule];
-                }
-                else if (k.endsWith(I.KEY_STRICT_SUFFIX)) {
-                    k = k.slice(0, -I.KEY_STRICT_SUFFIX.length);
-                    rule = [M.STRICT, rule];
-                }
-                else if (k.endsWith(I.KEY_EQUAL_SUFFIX)) {
-                    k = k.slice(0, -I.KEY_STRICT_SUFFIX.length);
-                    rule = [M.EQUAL, rule];
-                }
-                else {
-                    const matchResult = k.match(I.KEY_ARRAY_SUFFIX);
-                    if (matchResult) {
-                        k = k.slice(0, matchResult.index);
-                        if (matchResult[3]) {
-                            rule = [
-                                M.ARRAY,
-                                [
-                                    parseInt(matchResult[1]),
-                                    parseInt(matchResult[3])
-                                ],
-                                rule
-                            ];
-                        }
-                        else if (matchResult[2]) {
-                            rule = [M.ARRAY, [parseInt(matchResult[1])], rule];
-                        }
-                        else {
-                            rule = [M.ARRAY, parseInt(matchResult[1]), rule];
-                        }
-                    }
-                }
-                if (optional) {
-                    if (this._isOrRule(rule)) {
-                        rule.push(B.VOID);
-                    }
-                    else {
-                        rule = [B.VOID, rule];
-                    }
-                }
-                keys.push(k);
-                ctx.vName = this._lang.fieldIndex(ctx.vName, this._lang.literal(k));
-                result.push(this._compile(ctx, rule));
-                ctx.untrap();
-            }
-            if (strict && keys.length) {
-                result.splice(1, -1, this._lang.arrayInSet(this._lang.keys(ctx.vName), this._lang.array(keys)));
-            }
-            return this._lang.and(result);
-        }
-        _compileStructuredRule(ctx, rules) {
-            const mapSymbol = Object.keys(rules).filter((x) => x.startsWith(M.MAP));
-            if (mapSymbol.length > 1) {
-                throw new SyntaxError("Only one '$.map' is allowed as rest-mapping.");
-            }
-            else if (mapSymbol.length === 0) {
-                return this._compileSimpleStructure(ctx, rules);
-            }
-            const result = [
-                this._lang.isStrucutre(ctx.vName, true)
-            ];
-            ctx.trap();
-            const CLOSURE_ARG = ctx.vName;
-            const CLOSURE_PARAM = this._lang.varName(ctx.vCursor++);
-            const FOR_KEY = this._lang.varName(ctx.vCursor++);
-            ctx.vName = this._lang.varName(ctx.vCursor++);
-            const CASES = [];
-            const keys = [];
-            for (let k in rules) {
-                ctx.trap(true);
-                let rule = rules[k];
-                let optional = false;
-                if (k.endsWith(I.IMPLICIT_SYMBOL)) {
-                    optional = true;
-                    k = k.slice(0, -1);
-                }
-                if (k.endsWith(I.KEY_LIST_SUFFIX)) {
-                    k = k.slice(0, -I.KEY_LIST_SUFFIX.length);
-                    rule = [M.LIST, rule];
-                }
-                else if (k.endsWith(I.KEY_MAP_SUFFIX)) {
-                    k = k.slice(0, -I.KEY_MAP_SUFFIX.length);
-                    rule = [M.MAP, rule];
-                }
-                else if (k.endsWith(I.KEY_STRICT_SUFFIX)) {
-                    k = k.slice(0, -I.KEY_STRICT_SUFFIX.length);
-                    rule = [M.STRICT, rule];
-                }
-                else if (k.endsWith(I.KEY_EQUAL_SUFFIX)) {
-                    k = k.slice(0, -I.KEY_STRICT_SUFFIX.length);
-                    rule = [M.EQUAL, rule];
-                }
-                else {
-                    const matchResult = k.match(I.KEY_ARRAY_SUFFIX);
-                    if (matchResult) {
-                        k = k.slice(0, matchResult.index);
-                        if (matchResult[3]) {
-                            rule = [
-                                M.ARRAY,
-                                [
-                                    parseInt(matchResult[1]),
-                                    parseInt(matchResult[3])
-                                ],
-                                rule
-                            ];
-                        }
-                        else if (matchResult[2]) {
-                            rule = [M.ARRAY, [parseInt(matchResult[1])], rule];
-                        }
-                        else {
-                            rule = [M.ARRAY, parseInt(matchResult[1]), rule];
-                        }
-                    }
-                }
-                if (k === M.MAP) {
-                    CASES.push(this._lang.caseDefault(this._lang.ifThen(this._lang.not(this._compile(ctx, rule)), this._lang.returnValue(this._lang.literal(false)))));
-                }
-                else {
-                    if (optional) {
-                        if (this._isOrRule(rule)) {
-                            rule.push(B.VOID);
-                        }
-                        else {
-                            rule = [B.VOID, rule];
-                        }
-                    }
-                    else {
-                        keys.push(k);
-                    }
-                    CASES.push(this._lang.caseIf([this._lang.literal(k)], this._lang.ifThen(this._lang.not(this._compile(ctx, rule)), this._lang.returnValue(this._lang.literal(false)))));
-                }
-                ctx.untrap();
-            }
-            if (keys.length) {
-                result.push(this._lang.arrayInSet(this._lang.array(keys), this._lang.keys(CLOSURE_ARG)));
-            }
-            result.push(this._lang.closure([CLOSURE_PARAM], [CLOSURE_ARG], this._lang.series([
-                this._lang.forIn(CLOSURE_PARAM, FOR_KEY, ctx.vName, this._lang.switchCase(FOR_KEY, CASES)),
-                this._lang.returnValue(this._lang.literal(true))
-            ])));
-            ctx.untrap();
-            return this._lang.and(result);
-        }
-        _isOrRule(rule) {
-            return Array.isArray(rule) && (rule[0] === M.OR ||
-                typeof rule[0] !== "string" ||
-                !rule[0].startsWith(I.MODIFIER_PREFIX));
-        }
-    }
-    /**
-     * Create a compiler object.
-     *
-     * @param lang The language builder.
-     */
-    function createCompiler(lang) {
-        const bitc = new BuiltInTypeCompiler_1.BuiltInTypeCompiler(lang);
-        return new Compiler(lang, bitc, new FilterCompiler_1.FilterCompiler(lang, bitc));
-    }
-    exports.createCompiler = createCompiler;
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("langs/JavaScript", ["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    class JavaScriptLanguage {
-        switchCase(expr, cases) {
-            return `switch (${expr}) { ${cases.join("")} }`;
-        }
-        caseIf(cond, expr) {
-            return `${cond.map((x) => `case ${x}:`).join(" ")} { ${expr} break; }`;
-        }
-        caseDefault(expr) {
-            return `default: { ${expr} break; }`;
-        }
-        lowerCase(a) {
-            return `${a}.toLowerCase()`;
-        }
-        array(v) {
-            return JSON.stringify(v);
-        }
-        arrayInSet(a, b) {
-            return `(function(a, b) {
-            return Array.from(new Set(a.concat(b))).length === b.length;
-        })(${a}, ${b})`;
-        }
-        instr(expr, match) {
-            return `${expr}.includes(${match})`;
-        }
-        call(fnName, ...args) {
-            return `${fnName}(${args.join(",")})`;
-        }
-        startsWith(expr, match) {
-            return `${expr}.startsWith(${match})`;
-        }
-        endsWith(expr, match) {
-            return `${expr}.endsWith(${match})`;
-        }
-        varName(index) {
-            return `v_${index}`;
-        }
-        _dereplicate(conds) {
-            return Array.from(new Set(conds));
-        }
-        ifElseOp(cond, a, b) {
-            return `(${cond}) ? ${a} : ${b}`;
-        }
-        or(conditions) {
-            if (conditions.length === 1) {
-                return conditions[0];
-            }
-            conditions = this._dereplicate(conditions.filter((x) => x !== "true"));
-            if (!conditions.length) {
-                return "true";
-            }
-            return `${conditions.map((x) => `(${x})`).join(" || ")}`;
-        }
-        and(conditions) {
-            if (conditions.length === 1) {
-                return conditions[0];
-            }
-            conditions = this._dereplicate(conditions.filter((x) => x !== "true"));
-            if (!conditions.length) {
-                return "true";
-            }
-            return `${conditions.map((x) => `(${x})`).join(" && ")}`;
-        }
-        eq(a, b) {
-            return `${a} === ${b}`;
-        }
-        ne(a, b) {
-            return `${a} !== ${b}`;
-        }
-        gt(a, b) {
-            return `${a} > ${b}`;
-        }
-        gte(a, b) {
-            return `${a} >= ${b}`;
-        }
-        lt(a, b) {
-            return `${a} < ${b}`;
-        }
-        lte(a, b) {
-            return `${a} <= ${b}`;
-        }
-        not(a) {
-            return `!(${a})`;
-        }
-        literal(val) {
-            return JSON.stringify(val);
-        }
-        modOf(a, b) {
-            return `${a} % ${b}`;
-        }
-        matchRegExp(expr, regExp) {
-            let m = regExp.match(/^\/(.+)\/([a-z]*)$/i);
-            if (m) {
-                return `/${m[1]}/${m[2] || ""}.test(${expr})`;
-            }
-            return `/${regExp}/.test(${expr})`;
-        }
-        isNull(vn, positive = true) {
-            return `${vn} ${this._equal(positive)} null`;
-        }
-        isUndefined(vn, positive = true) {
-            return `${vn} ${this._equal(positive)} undefined`;
-        }
-        _equal(positive = true) {
-            return positive ? "===" : "!==";
-        }
-        _not(positive = true) {
-            return positive ? "" : "!";
-        }
-        isString(vn, positive = true) {
-            return `typeof ${vn} ${this._equal(positive)} "string"`;
-        }
-        isStrucutre(vn, positive = true) {
-            return positive ?
-                `(typeof ${vn} === "object" && ${vn} !== null && !Array.isArray(${vn}))` :
-                `(typeof ${vn} !== "object" || ${vn} === null || Array.isArray(${vn}))`;
-        }
-        isInteger(vn, positive = true) {
-            return `${this._not(positive)}Number.isInteger(${vn})`;
-        }
-        isNumber(vn, positive = true) {
-            return positive ?
-                `typeof ${vn} === "number" && Number.isFinite(${vn}) && !Number.isNaN(${vn})` :
-                `typeof ${vn} !== "number" || !Number.isFinite(${vn}) || Number.isNaN(${vn})`;
-        }
-        isNumeric(vn, positive = true) {
-            return positive ? this.or([
-                this.isNumber(vn, true),
-                this.and([
-                    this.isString(vn, true),
-                    this.matchRegExp(vn, "^[+-]?\\d+(\\.\\d+)?$")
-                ])
-            ]) : this.and([
-                this.isNumber(vn, false),
-                this.or([
-                    this.isString(vn, false),
-                    this.not(this.matchRegExp(vn, "^[+-]?\\d+(\\.\\d+)?$"))
-                ])
-            ]);
-        }
-        isArray(vn, positive = true) {
-            return `${this._not(positive)}Array.isArray(${vn})`;
-        }
-        isBoolean(vn, positive = true) {
-            return `typeof ${vn} ${this._equal(positive)} "boolean"`;
-        }
-        arrayLength(vn) {
-            return `${vn}.length`;
-        }
-        stringLength(vn) {
-            return `${vn}.length`;
-        }
-        keys(vn) {
-            return `Object.keys(${vn})`;
-        }
-        forEach(an, it, body) {
-            return `for (const ${it} of ${an}) {
-            ${body}
-        }`;
-        }
-        series(statements) {
-            return statements.map((s) => s.endsWith(";") ? s : `${s};`).join("");
-        }
-        ifThen(condition, ifBody, elseBody) {
-            if (elseBody) {
-                return `if (${condition}) {
-                ${ifBody}
-            } else {
-                ${elseBody}
-            }`;
-            }
-            return `if (${condition}) { ${ifBody} }`;
-        }
-        forIn(o, k, i, body) {
-            return `for (const ${k} in ${o}) { const ${i} = ${o}[${k}]; ${body} }`;
-        }
-        fieldIndex(o, k) {
-            return `${o}[${k}]`;
-        }
-        str2Int(expr) {
-            return `parseInt(${expr})`;
-        }
-        str2Float(expr) {
-            return `parseFloat(${expr})`;
-        }
-        str2Bool(expr) {
-            return `(${expr} === "true" ? true : (${expr} === "false" ? false : null))`;
-        }
-        arraySlice(arrayName, start, end) {
-            if (end !== undefined) {
-                return `${arrayName}.slice(${start}, ${end})`;
-            }
-            return `${arrayName}.slice(${start})`;
-        }
-        arrayIndex(a, i) {
-            return `${a}[${i}]`;
-        }
-        get literalFalse() {
-            return `false`;
-        }
-        get literalTrue() {
-            return `true`;
-        }
-        get maxSafeInteger() {
-            return "0X1FFFFFFFFFFFFF";
-        }
-        get minSafeInteger() {
-            return "-0X1FFFFFFFFFFFFF";
-        }
-        isTrueValue(vn) {
-            return `!!${vn}`;
-        }
-        isFalseValue(vn) {
-            return `!${vn}`;
-        }
-        returnValue(vn) {
-            return `return ${vn};`;
-        }
-        closure(params, args, body) {
-            return `(function(${params.join(", ")}) {
-            ${body}
-        })(${args.join(", ")})`;
-        }
-    }
-    /**
-     * Create a language builder object for JavaScript.
-     */
-    function createJavaScriptLanguageBuilder() {
-        return new JavaScriptLanguage();
-    }
-    exports.createJavaScriptLanguageBuilder = createJavaScriptLanguageBuilder;
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("InlineCompiler", ["require", "exports", "Compiler", "langs/JavaScript"], function (require, exports, Compiler_1, JavaScript_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    class InlineCompiler {
-        constructor() {
-            this._defTypes = {};
-            this._missingTypes = {};
-            const lang = JavaScript_1.createJavaScriptLanguageBuilder();
-            this._compiler = Compiler_1.createCompiler(lang);
-        }
-        compile(options) {
-            const result = this._compiler.compile(options);
-            this._preapreDefinedTypes(result.referredTypes, options.stopOnEntry);
-            return this._wrapCheckerCode(result, options.stopOnEntry);
-        }
-        _preapreDefinedTypes(types, stopOnEntry) {
-            for (let x of types) {
-                if (this._defTypes[x]) {
-                    continue;
-                }
-                const info = this._compiler.getPredefinedType(x);
-                if (!info) {
-                    this._missingTypes[x] = true;
-                    continue;
-                }
-                this._defTypes[x] = this._wrapCheckerCode(info, stopOnEntry);
-                this._preapreDefinedTypes(info.referredTypes);
-                delete this._missingTypes[x];
-            }
-        }
-        detectUndefinedTypes() {
-            return Object.keys(this._missingTypes);
-        }
-        hasPredefinedType(name) {
-            return !!this._defTypes[name];
-        }
-        getPredefinedType(name) {
-            if (!this._defTypes[name]) {
-                throw new Error(`Pre-defined type "${name}" doesn't exist.`);
-            }
-            return this._defTypes[name];
-        }
-        _wrapCheckerCode(info, stopOnEntry = false) {
-            const soe = stopOnEntry ? "debugger;" : "";
-            return (new Function(info.typeSlotName, `return function(${info.arguments[0].name}) {${soe}
-
-                return ${info.source};
-            };`))(this._defTypes);
-        }
-    }
-    /**
-     * Create a compiler object that compiles the rule into JavaScript lambda code.
-     */
-    function createInlineCompiler() {
-        return new InlineCompiler();
-    }
-    exports.createInlineCompiler = createInlineCompiler;
-});
-/**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-define("index", ["require", "exports", "InlineCompiler", "langs/JavaScript", "Compiler"], function (require, exports, InlineCompiler_1, JavaScript_2, Compiler_2) {
-    "use strict";
-    function __export(m) {
-        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-    }
-    Object.defineProperty(exports, "__esModule", { value: true });
-    __export(InlineCompiler_1);
-    __export(JavaScript_2);
-    __export(Compiler_2);
-});
-//# sourceMappingURL=typeguard.amd.js.map