(function () {
    'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    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 http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    var __assign = function() {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };

    function __rest(s, e) {
        var t = {};
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
            t[p] = s[p];
        if (s != null && typeof Object.getOwnPropertySymbols === "function")
            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
                t[p[i]] = s[p[i]];
        return t;
    }

    function __decorate(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    }

    function __param(paramIndex, decorator) {
        return function (target, key) { decorator(target, key, paramIndex); }
    }

    function __metadata(metadataKey, metadataValue) {
        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
    }

    function __awaiter(thisArg, _arguments, P, generator) {
        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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    }

    function __generator(thisArg, body) {
        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f) throw new TypeError("Generator is already executing.");
            while (_) try {
                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
                if (y = 0, t) op = [op[0] & 2, t.value];
                switch (op[0]) {
                    case 0: case 1: t = op; break;
                    case 4: _.label++; return { value: op[1], done: false };
                    case 5: _.label++; y = op[1]; op = [0]; continue;
                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
                    default:
                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                        if (t[2]) _.ops.pop();
                        _.trys.pop(); continue;
                }
                op = body.call(thisArg, _);
            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
        }
    }

    function __exportStar(m, exports) {
        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
    }

    function __values(o) {
        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
        if (m) return m.call(o);
        return {
            next: function () {
                if (o && i >= o.length) o = void 0;
                return { value: o && o[i++], done: !o };
            }
        };
    }

    function __read(o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m) return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
        }
        catch (error) { e = { error: error }; }
        finally {
            try {
                if (r && !r.done && (m = i["return"])) m.call(i);
            }
            finally { if (e) throw e.error; }
        }
        return ar;
    }

    function __spread() {
        for (var ar = [], i = 0; i < arguments.length; i++)
            ar = ar.concat(__read(arguments[i]));
        return ar;
    }

    function __await(v) {
        return this instanceof __await ? (this.v = v, this) : new __await(v);
    }

    function __asyncGenerator(thisArg, _arguments, generator) {
        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
        var g = generator.apply(thisArg, _arguments || []), i, q = [];
        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
        function fulfill(value) { resume("next", value); }
        function reject(value) { resume("throw", value); }
        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
    }

    function __asyncDelegator(o) {
        var i, p;
        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
    }

    function __asyncValues(o) {
        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
        var m = o[Symbol.asyncIterator], i;
        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
    }

    function __makeTemplateObject(cooked, raw) {
        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
        return cooked;
    };

    function __importStar(mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
        result.default = mod;
        return result;
    }

    function __importDefault(mod) {
        return (mod && mod.__esModule) ? mod : { default: mod };
    }

    var Scene = Laya.Scene;
    var REG = Laya.ClassUtils.regClass;
    var ui;
    (function (ui) {
        var test;
        (function (test) {
            class TestSceneUI extends Scene {
                constructor() { super(); }
                createChildren() {
                    super.createChildren();
                    this.loadScene("test/TestScene");
                }
            }
            test.TestSceneUI = TestSceneUI;
            REG("ui.test.TestSceneUI", TestSceneUI);
        })(test = ui.test || (ui.test = {}));
    })(ui || (ui = {}));

    class GameControl extends Laya.Script {
        constructor() {
            super();
            this.createBoxInterval = 1000;
            this._time = 0;
            this._started = false;
        }
        onEnable() {
            this._time = Date.now();
            this._gameBox = this.owner.getChildByName("gameBox");
        }
        onUpdate() {
            let now = Date.now();
            if (now - this._time > this.createBoxInterval && this._started) {
                this._time = now;
                this.createBox();
            }
        }
        createBox() {
            let box = Laya.Pool.getItemByCreateFun("dropBox", this.dropBox.create, this.dropBox);
            box.pos(Math.random() * (Laya.stage.width - 100), -100);
            this._gameBox.addChild(box);
        }
        onStageClick(e) {
            e.stopPropagation();
            let flyer = Laya.Pool.getItemByCreateFun("bullet", this.bullet.create, this.bullet);
            flyer.pos(Laya.stage.mouseX, Laya.stage.mouseY);
            this._gameBox.addChild(flyer);
        }
        startGame() {
            if (!this._started) {
                this._started = true;
                this.enabled = true;
            }
        }
        stopGame() {
            this._started = false;
            this.enabled = false;
            this.createBoxInterval = 1000;
            this._gameBox.removeChildren();
        }
    }

    class GameUI extends ui.test.TestSceneUI {
        constructor() {
            super();
            GameUI.instance = this;
            Laya.MouseManager.multiTouchEnabled = false;
        }
        onEnable() {
            this._control = this.getComponent(GameControl);
            this.tipLbll.on(Laya.Event.CLICK, this, this.onTipClick);
        }
        onTipClick(e) {
            this.tipLbll.visible = false;
            this._score = 0;
            this.scoreLbl.text = "";
            this._control.startGame();
        }
        addScore(value = 1) {
            this._score += value;
            this.scoreLbl.changeText("分数：" + this._score);
            if (this._control.createBoxInterval > 600 && this._score % 20 == 0)
                this._control.createBoxInterval -= 20;
        }
        stopGame() {
            this.tipLbll.visible = true;
            this.tipLbll.text = "游戏结束了，点击屏幕重新开始";
            this._control.stopGame();
        }
    }

    class Bullet extends Laya.Script {
        constructor() { super(); }
        onEnable() {
            var rig = this.owner.getComponent(Laya.RigidBody);
            rig.setVelocity({ x: 0, y: -10 });
        }
        onTriggerEnter(other, self, contact) {
            this.owner.removeSelf();
        }
        onUpdate() {
            if (this.owner.y < -10) {
                this.owner.removeSelf();
            }
        }
        onDisable() {
            Laya.Pool.recover("bullet", this.owner);
        }
    }

    class DropBox extends Laya.Script {
        constructor() {
            super();
            this.level = 1;
        }
        onEnable() {
            this._rig = this.owner.getComponent(Laya.RigidBody);
            this.level = Math.round(Math.random() * 5) + 1;
            this._text = this.owner.getChildByName("levelTxt");
            this._text.text = this.level + "";
        }
        onUpdate() {
            this.owner.rotation++;
        }
        onTriggerEnter(other, self, contact) {
            var owner = this.owner;
            if (other.label === "buttle") {
                if (this.level > 1) {
                    this.level--;
                    this._text.changeText(this.level + "");
                    owner.getComponent(Laya.RigidBody).setVelocity({ x: 0, y: -10 });
                    Laya.SoundManager.playSound("sound/hit.wav");
                }
                else {
                    if (owner.parent) {
                        let effect = Laya.Pool.getItemByCreateFun("effect", this.createEffect, this);
                        effect.pos(owner.x, owner.y);
                        owner.parent.addChild(effect);
                        effect.play(0, true);
                        owner.removeSelf();
                        Laya.SoundManager.playSound("sound/destroy.wav");
                    }
                }
                GameUI.instance.addScore(1);
            }
            else if (other.label === "ground") {
                owner.removeSelf();
                GameUI.instance.stopGame();
            }
        }
        createEffect() {
            let ani = new Laya.Animation();
            ani.loadAnimation("test/TestAni.ani");
            ani.on(Laya.Event.COMPLETE, null, recover);
            function recover() {
                ani.removeSelf();
                Laya.Pool.recover("effect", ani);
            }
            return ani;
        }
        onDisable() {
            Laya.Pool.recover("dropBox", this.owner);
        }
    }

    class GameConfig {
        constructor() {
        }
        static init() {
            var reg = Laya.ClassUtils.regClass;
            reg("script/GameUI.ts", GameUI);
            reg("script/GameControl.ts", GameControl);
            reg("script/Bullet.ts", Bullet);
            reg("script/DropBox.ts", DropBox);
        }
    }
    GameConfig.width = 640;
    GameConfig.height = 1136;
    GameConfig.scaleMode = "fixedwidth";
    GameConfig.screenMode = "none";
    GameConfig.alignV = "top";
    GameConfig.alignH = "left";
    GameConfig.startScene = "test/TestScene.scene";
    GameConfig.sceneRoot = "";
    GameConfig.debug = false;
    GameConfig.stat = false;
    GameConfig.physicsDebug = false;
    GameConfig.exportSceneToJson = true;
    GameConfig.init();

    const serviceProto = {
        "version": 1,
        "services": [
            {
                "id": 0,
                "name": "AddData",
                "type": "api"
            },
            {
                "id": 1,
                "name": "GetData",
                "type": "api"
            }
        ],
        "types": {
            "PtlAddData/ReqAddData": {
                "type": "Interface",
                "properties": [
                    {
                        "id": 0,
                        "name": "content",
                        "type": {
                            "type": "String"
                        }
                    }
                ]
            },
            "PtlAddData/ResAddData": {
                "type": "Interface",
                "properties": [
                    {
                        "id": 0,
                        "name": "time",
                        "type": {
                            "type": "Date"
                        }
                    }
                ]
            },
            "PtlGetData/ReqGetData": {
                "type": "Interface"
            },
            "PtlGetData/ResGetData": {
                "type": "Interface",
                "properties": [
                    {
                        "id": 0,
                        "name": "data",
                        "type": {
                            "type": "Array",
                            "elementType": {
                                "type": "Interface",
                                "properties": [
                                    {
                                        "id": 0,
                                        "name": "content",
                                        "type": {
                                            "type": "String"
                                        }
                                    },
                                    {
                                        "id": 1,
                                        "name": "time",
                                        "type": {
                                            "type": "Date"
                                        }
                                    }
                                ]
                            }
                        }
                    }
                ]
            }
        }
    };

    !Array.prototype.__k8w_extended && Object.defineProperties(Array.prototype, {
        remove: {
            value: function value(filter) {
                if (typeof filter == 'function') {
                    for (var i = this.length - 1; i > -1; --i) {
                        filter(this[i], i, this) && this.splice(i, 1);
                    }
                }
                else {
                    for (var i = this.length - 1; i > -1; --i) {
                        this[i] === filter && this.splice(i, 1);
                    }
                }
                return this;
            }
        },
        removeOne: {
            value: function value(filter) {
                if (typeof filter == 'function') {
                    for (var i = 0; i < this.length; ++i) {
                        if (filter(this[i], i, this)) {
                            this.splice(i, 1);
                            return this;
                        }
                    }
                }
                else {
                    for (var i = 0; i < this.length; ++i) {
                        if (this[i] === filter) {
                            this.splice(i, 1);
                            return this;
                        }
                    }
                }
                return this;
            }
        },
        first: {
            value: function value() {
                return this.length ? this[0] : null;
            }
        },
        last: {
            value: function value() {
                return this.length ? this[this.length - 1] : null;
            }
        },
        max: {
            value: function value(mapper) {
                if (!this.length) {
                    return null;
                }
                function _max(a, b) {
                    return a > b ? a : b;
                }
                if (typeof mapper == 'function') {
                    var max = mapper(this[0], 0, this);
                    for (var i = 1; i < this.length; ++i) {
                        var temp = mapper(this[i], i, this);
                        max = temp > max ? temp : max;
                    }
                    return max;
                }
                else {
                    return this.reduce(function (prev, cur) {
                        return _max(prev, cur);
                    });
                }
            }
        },
        min: {
            value: function value(mapper) {
                if (!this.length) {
                    return null;
                }
                function _min(a, b) {
                    return a < b ? a : b;
                }
                if (typeof mapper == 'function') {
                    var min = mapper(this[0], 0, this);
                    for (var i = 1; i < this.length; ++i) {
                        var temp = mapper(this[i], i, this);
                        min = temp < min ? temp : min;
                    }
                    return min;
                }
                else {
                    return this.reduce(function (prev, cur) {
                        return _min(prev, cur);
                    });
                }
            }
        },
        distinct: {
            value: function value() {
                return this.filter(function (v, i, arr) {
                    return arr.indexOf(v) === i;
                });
            }
        },
        filterIndex: {
            value: function value(filter) {
                var output = [];
                for (var i = 0; i < this.length; ++i) {
                    if (filter(this[i], i, this)) {
                        output.push(i);
                    }
                }
                return output;
            }
        },
        count: {
            value: function value(filter) {
                var result = 0;
                for (var i = 0; i < this.length; ++i) {
                    if (filter(this[i], i, this)) {
                        ++result;
                    }
                }
                return result;
            }
        },
        sum: {
            value: function value(mapper) {
                var result = 0;
                for (var i = 0; i < this.length; ++i) {
                    result += mapper ? mapper(this[i], i, this) : this[i];
                }
                return result;
            }
        },
        average: {
            value: function value(mapper) {
                return this.sum(mapper) / this.length;
            }
        },
        orderBy: {
            value: function value() {
                var mappers = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    mappers[_i] = arguments[_i];
                }
                return this.slice().sort(function (a, b) {
                    for (var i = 0; i < mappers.length; ++i) {
                        var va = mappers[i](a);
                        var vb = mappers[i](b);
                        if (va > vb) {
                            return 1;
                        }
                        else if (va < vb) {
                            return -1;
                        }
                    }
                    return 0;
                });
            }
        },
        orderByDesc: {
            value: function value() {
                var mappers = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    mappers[_i] = arguments[_i];
                }
                return this.slice().sort(function (a, b) {
                    for (var i = 0; i < mappers.length; ++i) {
                        var va = mappers[i](a);
                        var vb = mappers[i](b);
                        if (va > vb) {
                            return -1;
                        }
                        else if (va < vb) {
                            return 1;
                        }
                    }
                    return 0;
                });
            }
        },
        binarySearch: {
            value: function value(_value, keyMapper) {
                var low = 0, high = this.length - 1;
                while (low <= high) {
                    var mid = (high + low) / 2 | 0;
                    var midValue = keyMapper ? keyMapper(this[mid]) : this[mid];
                    if (_value === midValue) {
                        return mid;
                    }
                    else if (_value > midValue) {
                        low = mid + 1;
                    }
                    else if (_value < midValue) {
                        high = mid - 1;
                    }
                }
                return -1;
            }
        },
        binaryInsert: {
            value: function value(item, keyMapper, unique) {
                if (typeof keyMapper == 'boolean') {
                    unique = keyMapper;
                    keyMapper = undefined;
                }
                var low = 0, high = this.length - 1;
                var mid = NaN;
                var itemValue = keyMapper ? keyMapper(item) : item;
                while (low <= high) {
                    mid = (high + low) / 2 | 0;
                    var midValue = keyMapper ? keyMapper(this[mid]) : this[mid];
                    if (itemValue === midValue) {
                        if (unique) {
                            return mid;
                        }
                        else {
                            break;
                        }
                    }
                    else if (itemValue > midValue) {
                        low = mid + 1;
                    }
                    else if (itemValue < midValue) {
                        high = mid - 1;
                    }
                }
                var index = low > mid ? mid + 1 : mid;
                this.splice(index, 0, item);
                return index;
            }
        },
        binaryDistinct: {
            value: function value(keyMapper) {
                return this.filter(function (v, i, arr) {
                    return arr.binarySearch(v, keyMapper) === i;
                });
            }
        },
        findLast: {
            value: function value(predicate) {
                for (var i = this.length - 1; i > -1; --i) {
                    if (predicate(this[i], i, this)) {
                        return this[i];
                    }
                }
                return undefined;
            }
        },
        findLastIndex: {
            value: function value(predicate) {
                for (var i = this.length - 1; i > -1; --i) {
                    if (predicate(this[i], i, this)) {
                        return i;
                    }
                }
                return -1;
            }
        },
        groupBy: {
            value: function value(grouper) {
                var group = this.reduce(function (prev, next) {
                    var groupKey = grouper(next);
                    if (!prev[groupKey]) {
                        prev[groupKey] = [];
                    }
                    prev[groupKey].push(next);
                    return prev;
                }, {});
                return Object.keys(group).map(function (key) {
                    var arr = group[key];
                    arr.key = key;
                    return arr;
                });
            }
        },
        __k8w_extended: {
            value: true
        }
    });
    function repeat(str, times) {
        var output = '';
        for (var i = 0; i < times; ++i) {
            output += str;
        }
        return output;
    }
    Date.prototype.format = function (formatString) {
        if (formatString === void 0) {
            formatString = 'yyyy-MM-dd hh:mm:ss';
        }
        var o = {
            "M+": this.getMonth() + 1,
            "d+": this.getDate(),
            "h+": this.getHours(),
            "m+": this.getMinutes(),
            "s+": this.getSeconds(),
            "q+": Math.floor((this.getMonth() + 3) / 3),
            "S+": this.getMilliseconds()
        };
        if (/(y+)/.test(formatString))
            formatString = formatString.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
        for (var k in o) {
            if (new RegExp("(" + k + ")").test(formatString))
                formatString = formatString.replace(RegExp.$1, repeat('0', Math.max(RegExp.$1.length - ('' + o[k]).length, 0)) + o[k]);
        }
        return formatString;
    };
    Date.today = function () {
        var now = new Date();
        return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
    };
    function _typeof(obj) {
        "@babel/helpers - typeof";
        if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
            _typeof = function (obj) {
                return typeof obj;
            };
        }
        else {
            _typeof = function (obj) {
                return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
            };
        }
        return _typeof(obj);
    }
    Object.merge = function (target) {
        var sources = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            sources[_i - 1] = arguments[_i];
        }
        for (var i = 0; i < sources.length; ++i) {
            var source = sources[i];
            if (_typeof(source) != 'object' || source == null) {
                continue;
            }
            for (var skey in source) {
                if (!source.hasOwnProperty(skey)) {
                    continue;
                }
                if (source[skey] instanceof Date) {
                    target[skey] = new Date(source[skey]);
                    continue;
                }
                else if (_typeof(target[skey]) == 'object' && target[skey] != null && _typeof(source[skey]) == 'object' && source[skey] != null) {
                    Object.merge(target[skey], source[skey]);
                }
                else {
                    if (Array.isArray(source[skey])) {
                        target[skey] = Object.merge([], source[skey]);
                    }
                    else if (_typeof(source[skey]) == 'object' && source[skey] !== null) {
                        target[skey] = Object.merge({}, source[skey]);
                    }
                    else {
                        target[skey] = source[skey];
                    }
                }
            }
        }
        return target;
    };
    if (!Object.values) {
        Object.values = function (obj) {
            var output = [];
            for (var k in obj) {
                obj.hasOwnProperty(k) && output.push(obj[k]);
            }
            return output;
        };
    }
    if (!Object.entries) {
        Object.entries = function (obj) {
            var output = [];
            for (var key in obj) {
                if (!obj.hasOwnProperty(key)) {
                    continue;
                }
                output.push([key, obj[key]]);
            }
            return output;
        };
    }
    Object.forEach = function (obj, handler) {
        for (var key in obj) {
            if (!obj.hasOwnProperty(key)) {
                return;
            }
            handler(obj[key], key, obj);
        }
    };
    if (typeof window != 'undefined' && !window.console) {
        window.console = {};
        console.log = console.debug = console.info = console.warn = console.error = console.time = console.timeEnd = function () { };
    }
    if (!console.debug) {
        console.debug = console.log;
    }
    var extendStatics$1 = function (d, b) {
        extendStatics$1 = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b)
                if (Object.prototype.hasOwnProperty.call(b, p))
                    d[p] = b[p]; };
        return extendStatics$1(d, b);
    };
    function __extends$1(d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics$1(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }
    var __assign$1 = function () {
        __assign$1 = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s)
                    if (Object.prototype.hasOwnProperty.call(s, p))
                        t[p] = s[p];
            }
            return t;
        };
        return __assign$1.apply(this, arguments);
    };
    function __awaiter$1(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());
        });
    }
    function __generator$1(thisArg, body) {
        var _ = { label: 0, sent: function () { if (t[0] & 1)
                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f)
                throw new TypeError("Generator is already executing.");
            while (_)
                try {
                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
                        return t;
                    if (y = 0, t)
                        op = [op[0] & 2, t.value];
                    switch (op[0]) {
                        case 0:
                        case 1:
                            t = op;
                            break;
                        case 4:
                            _.label++;
                            return { value: op[1], done: false };
                        case 5:
                            _.label++;
                            y = op[1];
                            op = [0];
                            continue;
                        case 7:
                            op = _.ops.pop();
                            _.trys.pop();
                            continue;
                        default:
                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                                _ = 0;
                                continue;
                            }
                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
                                _.label = op[1];
                                break;
                            }
                            if (op[0] === 6 && _.label < t[1]) {
                                _.label = t[1];
                                t = op;
                                break;
                            }
                            if (t && _.label < t[2]) {
                                _.label = t[2];
                                _.ops.push(op);
                                break;
                            }
                            if (t[2])
                                _.ops.pop();
                            _.trys.pop();
                            continue;
                    }
                    op = body.call(thisArg, _);
                }
                catch (e) {
                    op = [6, e];
                    y = 0;
                }
                finally {
                    f = t = 0;
                }
            if (op[0] & 5)
                throw op[1];
            return { value: op[0] ? op[1] : void 0, done: true };
        }
    }
    var TsrpcErrorType;
    (function (TsrpcErrorType) {
        TsrpcErrorType["NetworkError"] = "NetworkError";
        TsrpcErrorType["ServerError"] = "ServerError";
        TsrpcErrorType["ClientError"] = "ClientError";
        TsrpcErrorType["ApiError"] = "ApiError";
    })(TsrpcErrorType || (TsrpcErrorType = {}));
    var TransportDataProto = {
        "ServerInputData": {
            "type": "Interface",
            "properties": [{
                    "id": 0,
                    "name": "serviceId",
                    "type": {
                        "type": "Number",
                        "scalarType": "uint"
                    }
                }, {
                    "id": 1,
                    "name": "buffer",
                    "type": {
                        "type": "Buffer",
                        "arrayType": "Uint8Array"
                    }
                }, {
                    "id": 2,
                    "name": "sn",
                    "type": {
                        "type": "Number",
                        "scalarType": "uint"
                    },
                    "optional": true
                }]
        },
        "ServerOutputData": {
            "type": "Interface",
            "properties": [{
                    "id": 0,
                    "name": "buffer",
                    "type": {
                        "type": "Buffer",
                        "arrayType": "Uint8Array"
                    },
                    "optional": true
                }, {
                    "id": 1,
                    "name": "error",
                    "type": {
                        "type": "Reference",
                        "target": "TsrpcErrorData"
                    },
                    "optional": true
                }, {
                    "id": 2,
                    "name": "serviceId",
                    "type": {
                        "type": "Number",
                        "scalarType": "uint"
                    },
                    "optional": true
                }, {
                    "id": 3,
                    "name": "sn",
                    "type": {
                        "type": "Number",
                        "scalarType": "uint"
                    },
                    "optional": true
                }]
        },
        "TsrpcErrorData": {
            "type": "Interface",
            "properties": [{
                    "id": 0,
                    "name": "message",
                    "type": {
                        "type": "String"
                    }
                }, {
                    "id": 1,
                    "name": "type",
                    "type": {
                        "type": "Reference",
                        "target": "TsrpcErrorType"
                    }
                }, {
                    "id": 2,
                    "name": "code",
                    "type": {
                        "type": "Union",
                        "members": [{
                                "id": 0,
                                "type": {
                                    "type": "String"
                                }
                            }, {
                                "id": 1,
                                "type": {
                                    "type": "Number",
                                    "scalarType": "int"
                                }
                            }]
                    },
                    "optional": true
                }],
            "indexSignature": {
                "keyType": "String",
                "type": {
                    "type": "Any"
                }
            }
        },
        "TsrpcErrorType": {
            "type": "Enum",
            "members": [{
                    "id": 0,
                    "value": "NetworkError"
                }, {
                    "id": 1,
                    "value": "ServerError"
                }, {
                    "id": 2,
                    "value": "ClientError"
                }, {
                    "id": 3,
                    "value": "ApiError"
                }]
        }
    };
    var TsrpcError = function () {
        function TsrpcError(dataOrMessage, data) {
            var _a;
            if (typeof dataOrMessage === 'string') {
                this.message = dataOrMessage;
                this.type = (_a = data === null || data === void 0 ? void 0 : data.type) !== null && _a !== void 0 ? _a : TsrpcErrorType.ApiError;
                __assign$1(this, data);
            }
            else {
                __assign$1(this, dataOrMessage);
            }
        }
        TsrpcError.prototype.toString = function () {
            return "[TSRPC " + this.type + "]: " + this.message;
        };
        TsrpcError.Type = TsrpcErrorType;
        return TsrpcError;
    }();
    var SchemaType;
    (function (SchemaType) {
        SchemaType["Boolean"] = "Boolean";
        SchemaType["Number"] = "Number";
        SchemaType["String"] = "String";
        SchemaType["Array"] = "Array";
        SchemaType["Tuple"] = "Tuple";
        SchemaType["Enum"] = "Enum";
        SchemaType["Any"] = "Any";
        SchemaType["Literal"] = "Literal";
        SchemaType["Object"] = "Object";
        SchemaType["Interface"] = "Interface";
        SchemaType["Buffer"] = "Buffer";
        SchemaType["IndexedAccess"] = "IndexedAccess";
        SchemaType["Reference"] = "Reference";
        SchemaType["Union"] = "Union";
        SchemaType["Intersection"] = "Intersection";
        SchemaType["NonNullable"] = "NonNullable";
        SchemaType["Date"] = "Date";
        SchemaType["Pick"] = "Pick";
        SchemaType["Partial"] = "Partial";
        SchemaType["Omit"] = "Omit";
        SchemaType["Overwrite"] = "Overwrite";
    })(SchemaType || (SchemaType = {}));
    var ProtoHelper = function () {
        function ProtoHelper(proto) {
            this._schemaWithUuids = [];
            this._unionPropertiesCache = {};
            this._flatInterfaceSchemaCache = {};
            this.proto = proto;
        }
        ProtoHelper.prototype.parseReference = function (schema) {
            if (schema.type === SchemaType.Reference) {
                var parsedSchema = this.proto[schema.target];
                if (!parsedSchema) {
                    throw new Error("Cannot find reference target: " + schema.target);
                }
                if (this.isTypeReference(parsedSchema)) {
                    return this.parseReference(parsedSchema);
                }
                else {
                    return parsedSchema;
                }
            }
            else if (schema.type === SchemaType.IndexedAccess) {
                if (!this.isInterface(schema.objectType)) {
                    throw new Error("Error objectType: " + schema.objectType.type);
                }
                var flat = this.getFlatInterfaceSchema(schema.objectType);
                var propItem = flat.properties.find(function (v) {
                    return v.name === schema.index;
                });
                var propType = void 0;
                if (propItem) {
                    propType = propItem.type;
                }
                else {
                    if (flat.indexSignature) {
                        propType = flat.indexSignature.type;
                    }
                    else {
                        throw new Error("Error index: " + schema.index);
                    }
                }
                if (propItem && propItem.optional && (propItem.type.type !== SchemaType.Union
                    || propItem.type.members.findIndex(function (v) {
                        return v.type.type === SchemaType.Literal && v.type.literal === undefined;
                    }) === -1)) {
                    propType = {
                        type: SchemaType.Union,
                        members: [{
                                id: 0,
                                type: propType
                            }, {
                                id: 1,
                                type: {
                                    type: SchemaType.Literal,
                                    literal: undefined
                                }
                            }]
                    };
                }
                return this.isTypeReference(propType) ? this.parseReference(propType) : propType;
            }
            else {
                return schema;
            }
        };
        ProtoHelper.prototype.isInterface = function (schema, excludeReference) {
            if (excludeReference === void 0) {
                excludeReference = false;
            }
            if (!excludeReference && this.isTypeReference(schema)) {
                var parsed = this.parseReference(schema);
                return this.isInterface(parsed, excludeReference);
            }
            else {
                return schema.type === SchemaType.Interface || schema.type === SchemaType.Pick || schema.type === SchemaType.Partial || schema.type === SchemaType.Omit || schema.type === SchemaType.Overwrite;
            }
        };
        ProtoHelper.prototype.isTypeReference = function (schema) {
            return schema.type === SchemaType.Reference || schema.type === SchemaType.IndexedAccess;
        };
        ProtoHelper.prototype._getSchemaUuid = function (schema) {
            var schemaWithUuid = schema;
            if (!schemaWithUuid.uuid) {
                schemaWithUuid.uuid = this._schemaWithUuids.push(schemaWithUuid);
            }
            return schemaWithUuid.uuid;
        };
        ProtoHelper.prototype.getUnionProperties = function (schema) {
            var uuid = this._getSchemaUuid(schema);
            if (!this._unionPropertiesCache[uuid]) {
                this._unionPropertiesCache[uuid] = this._addUnionProperties([], schema.members.map(function (v) {
                    return v.type;
                }));
            }
            return this._unionPropertiesCache[uuid];
        };
        ProtoHelper.prototype._addUnionProperties = function (unionProperties, schemas) {
            for (var i = 0, len = schemas.length; i < len; ++i) {
                var schema = this.parseReference(schemas[i]);
                if (this.isInterface(schema)) {
                    var flat = this.getFlatInterfaceSchema(schema);
                    flat.properties.forEach(function (v) {
                        unionProperties.binaryInsert(v.name, true);
                    });
                    if (flat.indexSignature) {
                        var key = "[[" + flat.indexSignature.keyType + "]]";
                        unionProperties.binaryInsert(key, true);
                    }
                }
                else if (schema.type === SchemaType.Intersection || schema.type === SchemaType.Union) {
                    this._addUnionProperties(unionProperties, schema.members.map(function (v) {
                        return v.type;
                    }));
                }
            }
            return unionProperties;
        };
        ProtoHelper.prototype.applyUnionProperties = function (schema, unionProperties) {
            var newSchema = __assign$1(__assign$1({}, schema), {
                properties: schema.properties.slice()
            });
            var _loop_1 = function _loop_1(prop) {
                if (prop === '[[String]]') {
                    newSchema.indexSignature = newSchema.indexSignature || {
                        keyType: SchemaType.String,
                        type: {
                            type: SchemaType.Any
                        }
                    };
                }
                else if (prop === '[[Number]]') {
                    newSchema.indexSignature = newSchema.indexSignature || {
                        keyType: SchemaType.Number,
                        type: {
                            type: SchemaType.Any
                        }
                    };
                }
                else if (!schema.properties.find(function (v) {
                    return v.name === prop;
                })) {
                    newSchema.properties.push({
                        id: -1,
                        name: prop,
                        optional: true,
                        type: {
                            type: SchemaType.Any
                        }
                    });
                }
            };
            for (var _i = 0, unionProperties_1 = unionProperties; _i < unionProperties_1.length; _i++) {
                var prop = unionProperties_1[_i];
                _loop_1(prop);
            }
            return newSchema;
        };
        ProtoHelper.prototype.getFlatInterfaceSchema = function (schema) {
            var uuid = this._getSchemaUuid(schema);
            if (this._flatInterfaceSchemaCache[uuid]) {
                return this._flatInterfaceSchemaCache[uuid];
            }
            if (this.isTypeReference(schema)) {
                var parsed = this.parseReference(schema);
                if (parsed.type !== SchemaType.Interface) {
                    throw new Error("Cannot flatten non interface type: " + parsed.type);
                }
                this._flatInterfaceSchemaCache[uuid] = this.getFlatInterfaceSchema(parsed);
            }
            else if (schema.type === SchemaType.Interface) {
                this._flatInterfaceSchemaCache[uuid] = this._flattenInterface(schema);
            }
            else {
                this._flatInterfaceSchemaCache[uuid] = this._flattenMappedType(schema);
            }
            return this._flatInterfaceSchemaCache[uuid];
        };
        ProtoHelper.prototype._flattenInterface = function (schema) {
            var properties = {};
            var indexSignature;
            if (schema.properties) {
                for (var _i = 0, _a = schema.properties; _i < _a.length; _i++) {
                    var prop = _a[_i];
                    properties[prop.name] = {
                        optional: prop.optional,
                        type: prop.type
                    };
                }
            }
            if (schema.indexSignature) {
                indexSignature = schema.indexSignature;
            }
            if (schema.extends) {
                for (var _b = 0, _c = schema.extends; _b < _c.length; _b++) {
                    var extend = _c[_b];
                    var parsedExtRef = this.parseReference(extend.type);
                    if (parsedExtRef.type !== SchemaType.Interface) {
                        throw new Error('SchemaError: extends must from interface but from ' + parsedExtRef.type);
                    }
                    var flatenExtendsSchema = this.getFlatInterfaceSchema(parsedExtRef);
                    if (flatenExtendsSchema.properties) {
                        for (var _d = 0, _e = flatenExtendsSchema.properties; _d < _e.length; _d++) {
                            var prop = _e[_d];
                            if (!properties[prop.name]) {
                                properties[prop.name] = {
                                    optional: prop.optional,
                                    type: prop.type
                                };
                            }
                        }
                    }
                    if (flatenExtendsSchema.indexSignature && !indexSignature) {
                        indexSignature = flatenExtendsSchema.indexSignature;
                    }
                }
            }
            return {
                type: SchemaType.Interface,
                properties: Object.entries(properties).map(function (v, i) {
                    return {
                        id: i,
                        name: v[0],
                        optional: v[1].optional,
                        type: v[1].type
                    };
                }),
                indexSignature: indexSignature
            };
        };
        ProtoHelper.prototype._flattenMappedType = function (schema) {
            var target;
            if (this.isTypeReference(schema.target)) {
                var parsed = this.parseReference(schema.target);
                target = parsed;
            }
            else {
                target = schema.target;
            }
            var flatTarget;
            if (target.type === SchemaType.Pick || target.type === SchemaType.Partial || target.type === SchemaType.Omit || target.type === SchemaType.Overwrite) {
                flatTarget = this._flattenMappedType(target);
            }
            else if (target.type === SchemaType.Interface) {
                flatTarget = this._flattenInterface(target);
            }
            else {
                throw new Error("Invalid target.type: " + target.type);
            }
            if (schema.type === SchemaType.Pick) {
                var properties = [];
                var _loop_2 = function _loop_2(key) {
                    var propItem = flatTarget.properties.find(function (v) {
                        return v.name === key;
                    });
                    if (propItem) {
                        properties.push({
                            id: properties.length,
                            name: key,
                            optional: propItem.optional,
                            type: propItem.type
                        });
                    }
                    else if (flatTarget.indexSignature) {
                        properties.push({
                            id: properties.length,
                            name: key,
                            type: flatTarget.indexSignature.type
                        });
                    }
                    else {
                        throw new Error("Cannot find pick key [" + key + "]");
                    }
                };
                for (var _i = 0, _a = schema.keys; _i < _a.length; _i++) {
                    var key = _a[_i];
                    _loop_2(key);
                }
                return {
                    type: SchemaType.Interface,
                    properties: properties
                };
            }
            else if (schema.type === SchemaType.Partial) {
                for (var _b = 0, _c = flatTarget.properties; _b < _c.length; _b++) {
                    var v = _c[_b];
                    v.optional = true;
                }
                return flatTarget;
            }
            else if (schema.type === SchemaType.Omit) {
                var _loop_3 = function _loop_3(key) {
                    flatTarget.properties.removeOne(function (v) {
                        return v.name === key;
                    });
                };
                for (var _d = 0, _e = schema.keys; _d < _e.length; _d++) {
                    var key = _e[_d];
                    _loop_3(key);
                }
                return flatTarget;
            }
            else if (schema.type === SchemaType.Overwrite) {
                var overwrite = this.getFlatInterfaceSchema(schema.overwrite);
                if (overwrite.indexSignature) {
                    flatTarget.indexSignature = overwrite.indexSignature;
                }
                var _loop_4 = function _loop_4(prop) {
                    flatTarget.properties.removeOne(function (v) {
                        return v.name === prop.name;
                    });
                    flatTarget.properties.push(prop);
                };
                for (var _f = 0, _g = overwrite.properties; _f < _g.length; _f++) {
                    var prop = _g[_f];
                    _loop_4(prop);
                }
                return flatTarget;
            }
            else {
                throw new Error("Unknown type: " + schema.type);
            }
        };
        ProtoHelper.prototype.parseMappedType = function (schema) {
            var parents = [];
            var child = schema;
            do {
                parents.push(child);
                child = this.parseReference(child.target);
            } while (child.type === SchemaType.Pick || child.type === SchemaType.Omit || child.type === SchemaType.Partial || child.type === SchemaType.Overwrite);
            if (child.type === SchemaType.Interface) {
                return child;
            }
            else if (child.type === SchemaType.Union) {
                var newSchema = {
                    type: SchemaType.Union,
                    members: child.members.map(function (v) {
                        var type = v.type;
                        for (var i = parents.length - 1; i > -1; --i) {
                            var parent_1 = parents[i];
                            type = __assign$1(__assign$1({}, parent_1), {
                                target: type
                            });
                        }
                        return {
                            id: v.id,
                            type: type
                        };
                    })
                };
                return newSchema;
            }
            else {
                throw new Error("Unsupported pattern " + schema.type + "<" + child.type + ">");
            }
        };
        return ProtoHelper;
    }();
    var _a;
    var ErrorType;
    (function (ErrorType) {
        ErrorType["TypeError"] = "TypeError";
        ErrorType["InvalidScalarType"] = "InvalidScalarType";
        ErrorType["TupleOverLength"] = "TupleOverLength";
        ErrorType["InvalidEnumValue"] = "InvalidEnumValue";
        ErrorType["InvalidLiteralValue"] = "InvalidLiteralValue";
        ErrorType["MissingRequiredProperty"] = "MissingRequiredProperty";
        ErrorType["ExcessProperty"] = "ExcessProperty";
        ErrorType["InvalidNumberKey"] = "InvalidNumberKey";
        ErrorType["UnionTypesNotMatch"] = "UnionTypesNotMatch";
        ErrorType["UnionMembersNotMatch"] = "UnionMembersNotMatch";
    })(ErrorType || (ErrorType = {}));
    var ErrorMsg = (_a = {}, _a[ErrorType.TypeError] = function (expect, actual) {
        return "Expected type to be `" + expect + "`, actually `" + actual + "`.";
    }, _a[ErrorType.InvalidScalarType] = function (value, scalarType) {
        return "`" + value + "` is not a valid `" + scalarType + "`.";
    }, _a[ErrorType.TupleOverLength] = function (valueLength, schemaLength) {
        return "Value has " + valueLength + " elements but schema allows only " + schemaLength + ".";
    }, _a[ErrorType.InvalidEnumValue] = function (value) {
        return "`" + value + "` is not a valid enum member.";
    }, _a[ErrorType.InvalidLiteralValue] = function (expected, actual) {
        return "Expected to equals `" + stringify(expected) + "`, actually `" + stringify(actual) + "`";
    }, _a[ErrorType.MissingRequiredProperty] = function (propName) {
        return "Missing required property `" + propName + "`.";
    }, _a[ErrorType.ExcessProperty] = function (propName) {
        return "Excess property `" + propName + "` should not exists.";
    }, _a[ErrorType.InvalidNumberKey] = function (key) {
        return "`" + key + "` is not a valid key, the key here should be a `number`.";
    },
        _a[ErrorType.UnionTypesNotMatch] = function (value, types) {
            return "`" + stringify(value) + "` is not matched to `" + types.join(' | ') + "`";
        }, _a[ErrorType.UnionMembersNotMatch] = function (memberErrors) {
        return "No union member matched, detail:\n" + memberErrors.map(function (v, i) {
            return "  <" + i + "> " + v.errMsg;
        }).join('\n');
    }, _a);
    function stringify(value) {
        if (typeof value === 'string') {
            var output = JSON.stringify(value);
            return "'" + output.substr(1, output.length - 2) + "'";
        }
        return JSON.stringify(value);
    }
    var ValidateResultError = function () {
        function ValidateResultError(error) {
            this.isSucc = false;
            this.error = error;
        }
        Object.defineProperty(ValidateResultError.prototype, "errMsg", {
            get: function get() {
                return ValidateResultError.getErrMsg(this.error);
            },
            enumerable: false,
            configurable: true
        });
        ValidateResultError.getErrMsg = function (error) {
            var _a;
            var errMsg = ErrorMsg[error.type].apply(ErrorMsg, error.params);
            if ((_a = error.inner) === null || _a === void 0 ? void 0 : _a.property.length) {
                return "Property `" + error.inner.property.join('.') + "`: " + errMsg;
            }
            else {
                return errMsg;
            }
        };
        return ValidateResultError;
    }();
    var ValidateResultUtil = function () {
        function ValidateResultUtil() { }
        ValidateResultUtil.error = function (type) {
            var params = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                params[_i - 1] = arguments[_i];
            }
            return new ValidateResultError({
                type: type,
                params: params
            });
        };
        ValidateResultUtil.innerError = function (property, value, schema, error) {
            var _a;
            if (error.error.inner) {
                if (typeof property === 'string') {
                    error.error.inner.property.unshift(property);
                }
                else {
                    (_a = error.error.inner.property).unshift.apply(_a, property);
                }
            }
            else {
                error.error.inner = {
                    property: typeof property === 'string' ? [property] : property,
                    value: value,
                    schema: schema
                };
            }
            return error;
        };
        ValidateResultUtil.succ = {
            isSucc: true
        };
        return ValidateResultUtil;
    }();
    var typedArrays = {
        Int8Array: Int8Array,
        Int16Array: Int16Array,
        Int32Array: Int32Array,
        BigInt64Array: typeof BigInt64Array !== 'undefined' ? BigInt64Array : undefined,
        Uint8Array: Uint8Array,
        Uint16Array: Uint16Array,
        Uint32Array: Uint32Array,
        BigUint64Array: typeof BigUint64Array !== 'undefined' ? BigUint64Array : undefined,
        Float32Array: Float32Array,
        Float64Array: Float64Array
    };
    var TSBufferValidator = function () {
        function TSBufferValidator(proto, options) {
            this.options = {
                excessPropertyChecks: true,
                strictNullChecks: true,
                cloneProto: true
            };
            if (options) {
                this.options = __assign$1(__assign$1({}, this.options), options);
            }
            this.proto = this.options.cloneProto ? Object.merge({}, proto) : proto;
            this.protoHelper = new ProtoHelper(this.proto);
        }
        TSBufferValidator.prototype.validate = function (value, schemaOrId, options) {
            var _a, _b;
            var schema;
            var schemaId;
            if (typeof schemaOrId === 'string') {
                schemaId = schemaOrId;
                schema = this.proto[schemaId];
                if (!schema) {
                    throw new Error("Cannot find schema: " + schemaId);
                }
            }
            else {
                schema = schemaOrId;
            }
            return this._validate(value, schema, __assign$1(__assign$1({}, options), {
                excessPropertyChecks: (_a = options === null || options === void 0 ? void 0 : options.excessPropertyChecks) !== null && _a !== void 0 ? _a : this.options.excessPropertyChecks,
                strictNullChecks: (_b = options === null || options === void 0 ? void 0 : options.strictNullChecks) !== null && _b !== void 0 ? _b : this.options.strictNullChecks
            }));
        };
        TSBufferValidator.prototype._validate = function (value, schema, options) {
            var _a;
            var vRes;
            switch (schema.type) {
                case SchemaType.Boolean:
                    vRes = this._validateBooleanType(value, schema);
                    break;
                case SchemaType.Number:
                    vRes = this._validateNumberType(value, schema);
                    break;
                case SchemaType.String:
                    vRes = this._validateStringType(value, schema);
                    break;
                case SchemaType.Array:
                    vRes = this._validateArrayType(value, schema, options);
                    break;
                case SchemaType.Tuple:
                    vRes = this._validateTupleType(value, schema, options);
                    break;
                case SchemaType.Enum:
                    vRes = this._validateEnumType(value, schema);
                    break;
                case SchemaType.Any:
                    vRes = this._validateAnyType(value);
                    break;
                case SchemaType.Literal:
                    vRes = this._validateLiteralType(value, schema, (_a = options === null || options === void 0 ? void 0 : options.strictNullChecks) !== null && _a !== void 0 ? _a : this.options.strictNullChecks);
                    break;
                case SchemaType.Object:
                    vRes = this._validateObjectType(value, schema);
                    break;
                case SchemaType.Interface:
                    vRes = this._validateInterfaceType(value, schema, options);
                    break;
                case SchemaType.Buffer:
                    vRes = this._validateBufferType(value, schema);
                    break;
                case SchemaType.IndexedAccess:
                case SchemaType.Reference:
                    vRes = this._validateReferenceType(value, schema, options);
                    break;
                case SchemaType.Union:
                    vRes = this._validateUnionType(value, schema, options);
                    break;
                case SchemaType.Intersection:
                    vRes = this._validateIntersectionType(value, schema, options);
                    break;
                case SchemaType.Pick:
                case SchemaType.Omit:
                case SchemaType.Partial:
                case SchemaType.Overwrite:
                    vRes = this._validateMappedType(value, schema, options);
                    break;
                case SchemaType.Date:
                    vRes = this._validateDateType(value);
                    break;
                case SchemaType.NonNullable:
                    vRes = this._validateNonNullableType(value, schema, options);
                    break;
                default:
                    throw new Error("Unsupported schema type: " + schema.type);
            }
            if (options === null || options === void 0 ? void 0 : options.prune) {
                if (options.prune.output === undefined) {
                    options.prune.output = value;
                }
                if (options.prune.parent) {
                    options.prune.parent.value[options.prune.parent.key] = options.prune.output;
                }
            }
            return vRes;
        };
        TSBufferValidator.prototype.prune = function (value, schemaOrId, options) {
            var _a;
            var schema = typeof schemaOrId === 'string' ? this.proto[schemaOrId] : schemaOrId;
            if (!schema) {
                throw new Error('Cannot find schema: ' + schemaOrId);
            }
            var prune = {};
            var vRes = this._validate(value, schema, __assign$1(__assign$1({}, options), {
                prune: prune,
                excessPropertyChecks: false,
                strictNullChecks: (_a = options === null || options === void 0 ? void 0 : options.strictNullChecks) !== null && _a !== void 0 ? _a : this.options.strictNullChecks
            }));
            if (vRes.isSucc) {
                vRes.pruneOutput = prune.output;
            }
            return vRes;
        };
        TSBufferValidator.prototype._validateBooleanType = function (value, schema) {
            var type = this._getTypeof(value);
            if (type === 'boolean') {
                return ValidateResultUtil.succ;
            }
            else {
                return ValidateResultUtil.error(ErrorType.TypeError, 'boolean', type);
            }
        };
        TSBufferValidator.prototype._validateNumberType = function (value, schema) {
            var scalarType = schema.scalarType || 'double';
            var type = this._getTypeof(value);
            var rightType = scalarType.indexOf('big') > -1 ? 'bigint' : 'number';
            if (type !== rightType) {
                return ValidateResultUtil.error(ErrorType.TypeError, rightType, type);
            }
            if (scalarType !== 'double' && type === 'number' && !Number.isInteger(value)) {
                return ValidateResultUtil.error(ErrorType.InvalidScalarType, value, scalarType);
            }
            if (scalarType.indexOf('uint') > -1 && value < 0) {
                return ValidateResultUtil.error(ErrorType.InvalidScalarType, value, scalarType);
            }
            return ValidateResultUtil.succ;
        };
        TSBufferValidator.prototype._validateStringType = function (value, schema) {
            var type = this._getTypeof(value);
            return type === 'string' ? ValidateResultUtil.succ : ValidateResultUtil.error(ErrorType.TypeError, 'string', type);
        };
        TSBufferValidator.prototype._validateArrayType = function (value, schema, options) {
            var type = this._getTypeof(value);
            if (type !== SchemaType.Array) {
                return ValidateResultUtil.error(ErrorType.TypeError, SchemaType.Array, type);
            }
            var prune = options.prune;
            if (prune) {
                prune.output = Array.from({
                    length: value.length
                });
            }
            for (var i = 0; i < value.length; ++i) {
                var elemValidateResult = this._validate(value[i], schema.elementType, __assign$1(__assign$1({}, options), {
                    prune: (prune === null || prune === void 0 ? void 0 : prune.output) ? {
                        parent: {
                            value: prune.output,
                            key: i
                        }
                    } : undefined
                }));
                if (!elemValidateResult.isSucc) {
                    return ValidateResultUtil.innerError('' + i, value[i], schema.elementType, elemValidateResult);
                }
            }
            return ValidateResultUtil.succ;
        };
        TSBufferValidator.prototype._validateTupleType = function (value, schema, options) {
            var type = this._getTypeof(value);
            if (type !== SchemaType.Array) {
                return ValidateResultUtil.error(ErrorType.TypeError, SchemaType.Array, type);
            }
            var prune = options.prune;
            if (!prune && options.excessPropertyChecks && value.length > schema.elementTypes.length) {
                return ValidateResultUtil.error(ErrorType.TupleOverLength, value.length, schema.elementTypes.length);
            }
            if (prune) {
                prune.output = Array.from({
                    length: Math.min(value.length, schema.elementTypes.length)
                });
            }
            for (var i = 0; i < schema.elementTypes.length; ++i) {
                if (value[i] === undefined || value[i] === null && !options.strictNullChecks) {
                    var isOptional = schema.optionalStartIndex !== undefined && i >= schema.optionalStartIndex || this._canBeUndefined(schema.elementTypes[i]);
                    if (isOptional) {
                        continue;
                    }
                    else {
                        return ValidateResultUtil.error(ErrorType.MissingRequiredProperty, i);
                    }
                }
                var elemValidateResult = this._validate(value[i], schema.elementTypes[i], {
                    prune: (prune === null || prune === void 0 ? void 0 : prune.output) ? {
                        parent: {
                            value: prune.output,
                            key: i
                        }
                    } : undefined,
                    strictNullChecks: options.strictNullChecks,
                    excessPropertyChecks: options.excessPropertyChecks
                });
                if (!elemValidateResult.isSucc) {
                    return ValidateResultUtil.innerError('' + i, value[i], schema.elementTypes[i], elemValidateResult);
                }
            }
            return ValidateResultUtil.succ;
        };
        TSBufferValidator.prototype._canBeUndefined = function (schema) {
            var _this = this;
            if (schema.type === SchemaType.Union) {
                return schema.members.some(function (v) {
                    return _this._canBeUndefined(v.type);
                });
            }
            if (schema.type === SchemaType.Literal && schema.literal === undefined) {
                return true;
            }
            return false;
        };
        TSBufferValidator.prototype._validateEnumType = function (value, schema) {
            var type = this._getTypeof(value);
            if (type !== 'string' && type !== 'number') {
                return ValidateResultUtil.error(ErrorType.TypeError, 'string | number', type);
            }
            if (schema.members.some(function (v) {
                return v.value === value;
            })) {
                return ValidateResultUtil.succ;
            }
            else {
                return ValidateResultUtil.error(ErrorType.InvalidEnumValue, value);
            }
        };
        TSBufferValidator.prototype._validateAnyType = function (value) {
            return ValidateResultUtil.succ;
        };
        TSBufferValidator.prototype._validateLiteralType = function (value, schema, strictNullChecks) {
            if (!strictNullChecks && (schema.literal === null || schema.literal === undefined)) {
                return value === null || value === undefined ? ValidateResultUtil.succ : ValidateResultUtil.error(ErrorType.InvalidLiteralValue, schema.literal, value);
            }
            return value === schema.literal ? ValidateResultUtil.succ : ValidateResultUtil.error(ErrorType.InvalidLiteralValue, schema.literal, value);
        };
        TSBufferValidator.prototype._validateObjectType = function (value, schema) {
            var type = this._getTypeof(value);
            return type === 'Object' || type === 'Array' ? ValidateResultUtil.succ : ValidateResultUtil.error(ErrorType.TypeError, 'Object', type);
        };
        TSBufferValidator.prototype._validateInterfaceType = function (value, schema, options) {
            var type = this._getTypeof(value);
            if (type !== 'Object') {
                return ValidateResultUtil.error(ErrorType.TypeError, 'Object', type);
            }
            var flatSchema = this.protoHelper.getFlatInterfaceSchema(schema);
            if (options.unionProperties) {
                flatSchema = this.protoHelper.applyUnionProperties(flatSchema, options.unionProperties);
            }
            return this._validateFlatInterface(value, flatSchema, options);
        };
        TSBufferValidator.prototype._validateMappedType = function (value, schema, options) {
            var parsed = this.protoHelper.parseMappedType(schema);
            if (parsed.type === SchemaType.Interface) {
                return this._validateInterfaceType(value, schema, options);
            }
            else if (parsed.type === SchemaType.Union) {
                return this._validateUnionType(value, parsed, options);
            }
            throw new Error();
        };
        TSBufferValidator.prototype._validateFlatInterface = function (value, schema, options) {
            if (schema.indexSignature && schema.indexSignature.keyType === SchemaType.Number) {
                for (var key in value) {
                    if (!this._isNumberKey(key)) {
                        return ValidateResultUtil.error(ErrorType.InvalidNumberKey, key);
                    }
                }
            }
            var prune = options.prune;
            if (prune) {
                prune.output = {};
            }
            if (!prune && options.excessPropertyChecks && !schema.indexSignature) {
                var validProperties_1 = schema.properties.map(function (v) {
                    return v.name;
                });
                var firstExcessProperty = Object.keys(value).find(function (v) {
                    return validProperties_1.indexOf(v) === -1;
                });
                if (firstExcessProperty) {
                    return ValidateResultUtil.error(ErrorType.ExcessProperty, firstExcessProperty);
                }
            }
            if (schema.properties) {
                for (var _i = 0, _a = schema.properties; _i < _a.length; _i++) {
                    var property = _a[_i];
                    if (value[property.name] === undefined || value[property.name] === null && !options.strictNullChecks) {
                        var isOptional = property.optional || this._canBeUndefined(property.type);
                        if (isOptional) {
                            continue;
                        }
                        else {
                            return ValidateResultUtil.error(ErrorType.MissingRequiredProperty, property.name);
                        }
                    }
                    var vRes = this._validate(value[property.name], property.type, {
                        prune: (prune === null || prune === void 0 ? void 0 : prune.output) && property.id > -1 ? {
                            parent: {
                                value: prune.output,
                                key: property.name
                            }
                        } : undefined,
                        strictNullChecks: options.strictNullChecks,
                        excessPropertyChecks: options.excessPropertyChecks
                    });
                    if (!vRes.isSucc) {
                        return ValidateResultUtil.innerError(property.name, value[property.name], property.type, vRes);
                    }
                }
            }
            if (schema.indexSignature) {
                for (var key in value) {
                    var vRes = this._validate(value[key], schema.indexSignature.type, {
                        prune: (prune === null || prune === void 0 ? void 0 : prune.output) ? {
                            parent: {
                                value: prune.output,
                                key: key
                            }
                        } : undefined,
                        strictNullChecks: options.strictNullChecks,
                        excessPropertyChecks: options.excessPropertyChecks
                    });
                    if (!vRes.isSucc) {
                        return ValidateResultUtil.innerError(key, value[key], schema.indexSignature.type, vRes);
                    }
                }
            }
            return ValidateResultUtil.succ;
        };
        TSBufferValidator.prototype._validateBufferType = function (value, schema) {
            var _a, _b;
            var type = this._getTypeof(value);
            if (type !== 'Object') {
                return ValidateResultUtil.error(ErrorType.TypeError, schema.arrayType || 'ArrayBuffer', type);
            }
            else if (schema.arrayType) {
                var typeArrayClass = typedArrays[schema.arrayType];
                if (!typeArrayClass) {
                    throw new Error("Error TypedArray type: " + schema.arrayType);
                }
                return value instanceof typeArrayClass ? ValidateResultUtil.succ : ValidateResultUtil.error(ErrorType.TypeError, schema.arrayType, (_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name);
            }
            else {
                return value instanceof ArrayBuffer ? ValidateResultUtil.succ : ValidateResultUtil.error(ErrorType.TypeError, 'ArrayBuffer', (_b = value === null || value === void 0 ? void 0 : value.constructor) === null || _b === void 0 ? void 0 : _b.name);
            }
        };
        TSBufferValidator.prototype._validateReferenceType = function (value, schema, options) {
            return this._validate(value, this.protoHelper.parseReference(schema), options);
        };
        TSBufferValidator.prototype._validateUnionType = function (value, schema, options) {
            var _this = this;
            options.unionProperties = options.unionProperties || this.protoHelper.getUnionProperties(schema);
            var isObjectPrune = false;
            var prune = options.prune;
            if (prune && value && Object.getPrototypeOf(value) === Object.prototype) {
                isObjectPrune = true;
                prune.output = {};
            }
            var isSomeSucc = false;
            var memberErrors = [];
            for (var i = 0; i < schema.members.length; ++i) {
                var member = schema.members[i];
                var memberType = this.protoHelper.isTypeReference(member.type) ? this.protoHelper.parseReference(member.type) : member.type;
                var memberPrune = prune ? {} : undefined;
                var vRes = this._validate(value, memberType, __assign$1(__assign$1({}, options), {
                    prune: memberPrune
                }));
                if (vRes.isSucc) {
                    isSomeSucc = true;
                    if (isObjectPrune) {
                        prune.output = __assign$1(__assign$1({}, prune.output), memberPrune.output);
                    }
                    else {
                        break;
                    }
                }
                else {
                    memberErrors.push(vRes);
                }
            }
            if (isSomeSucc) {
                return ValidateResultUtil.succ;
            }
            else {
                var msg0_1 = memberErrors[0].errMsg;
                if (memberErrors.every(function (v) {
                    return v.errMsg === msg0_1;
                })) {
                    return memberErrors[0];
                }
                var nonLiteralErrors = memberErrors.filter(function (v) {
                    return v.error.type !== ErrorType.InvalidLiteralValue;
                });
                if (nonLiteralErrors.length === 1) {
                    return nonLiteralErrors[0];
                }
                if (memberErrors.every(function (v) {
                    return !v.error.inner && (v.error.type === ErrorType.TypeError || v.error.type === ErrorType.InvalidLiteralValue);
                })) {
                    var valueType = this._getTypeof(value);
                    var expectedTypes = memberErrors.map(function (v) {
                        return v.error.type === ErrorType.TypeError ? v.error.params[0] : _this._getTypeof(v.error.params[0]);
                    }).distinct();
                    if (expectedTypes.indexOf(valueType) === -1) {
                        return ValidateResultUtil.error(ErrorType.TypeError, expectedTypes.join(' | '), this._getTypeof(value));
                    }
                    if (valueType !== 'Object' && valueType !== SchemaType.Array) {
                        var types = memberErrors.map(function (v) {
                            return v.error.type === ErrorType.TypeError ? v.error.params[0] : stringify(v.error.params[0]);
                        }).distinct();
                        return ValidateResultUtil.error(ErrorType.UnionTypesNotMatch, value, types);
                    }
                }
                return ValidateResultUtil.error(ErrorType.UnionMembersNotMatch, memberErrors);
            }
        };
        TSBufferValidator.prototype._validateIntersectionType = function (value, schema, options) {
            options.unionProperties = options.unionProperties || this.protoHelper.getUnionProperties(schema);
            var isObjectPrune = false;
            var prune = options.prune;
            if (prune && value && Object.getPrototypeOf(value) === Object.prototype) {
                prune.output = {};
                isObjectPrune = true;
            }
            for (var i = 0, len = schema.members.length; i < len; ++i) {
                var memberType = schema.members[i].type;
                memberType = this.protoHelper.isTypeReference(memberType) ? this.protoHelper.parseReference(memberType) : memberType;
                var memberPrune = prune ? {} : undefined;
                var vRes = this._validate(value, memberType, __assign$1(__assign$1({}, options), {
                    prune: memberPrune
                }));
                if (!vRes.isSucc) {
                    return vRes;
                }
                if (isObjectPrune) {
                    prune.output = __assign$1(__assign$1({}, prune.output), memberPrune.output);
                }
            }
            return ValidateResultUtil.succ;
        };
        TSBufferValidator.prototype._validateDateType = function (value) {
            if (value instanceof Date) {
                return ValidateResultUtil.succ;
            }
            else {
                return ValidateResultUtil.error(ErrorType.TypeError, 'Date', this._getTypeof(value));
            }
        };
        TSBufferValidator.prototype._validateNonNullableType = function (value, schema, options) {
            var type = this._getTypeof(value);
            if ((type === 'null' || type === 'undefined') && schema.target.type !== 'Any') {
                return ValidateResultUtil.error(ErrorType.TypeError, 'NonNullable', type);
            }
            return this._validate(value, schema.target, options);
        };
        TSBufferValidator.prototype._isNumberKey = function (key) {
            var int = parseInt(key);
            return !(isNaN(int) || '' + int !== key);
        };
        TSBufferValidator.prototype._getTypeof = function (value) {
            var type = _typeof(value);
            if (type === 'object') {
                if (value === null) {
                    return 'null';
                }
                else if (Array.isArray(value)) {
                    return SchemaType.Array;
                }
                else {
                    return 'Object';
                }
            }
            return type;
        };
        return TSBufferValidator;
    }();
    var IdBlockUtil = function () {
        function IdBlockUtil() { }
        IdBlockUtil.getPayloadLengthInfo = function (parsedSchema) {
            switch (parsedSchema.type) {
                case SchemaType.Boolean:
                case SchemaType.Enum:
                    return {
                        lengthType: LengthType.Varint
                    };
                case SchemaType.Number:
                    if (!parsedSchema.scalarType || parsedSchema.scalarType.includes('64') || parsedSchema.scalarType === 'double') {
                        return {
                            lengthType: LengthType.Bit64
                        };
                    }
                    else if (parsedSchema.scalarType && parsedSchema.scalarType.startsWith('big')) {
                        return {
                            lengthType: LengthType.LengthDelimited
                        };
                    }
                    else {
                        return {
                            lengthType: LengthType.Varint
                        };
                    }
                case SchemaType.Buffer:
                case SchemaType.String:
                case SchemaType.Any:
                case SchemaType.Object:
                    return {
                        lengthType: LengthType.LengthDelimited
                    };
                case SchemaType.Interface:
                case SchemaType.Pick:
                case SchemaType.Partial:
                case SchemaType.Omit:
                case SchemaType.Union:
                case SchemaType.Intersection:
                    return {
                        lengthType: LengthType.IdBlock
                    };
                case SchemaType.Array:
                case SchemaType.Overwrite:
                case SchemaType.Tuple:
                    return {
                        lengthType: LengthType.LengthDelimited,
                        needLengthPrefix: true
                    };
                case SchemaType.Literal:
                    return {
                        lengthType: LengthType.LengthDelimited,
                        needLengthPrefix: false
                    };
                case SchemaType.Date:
                    return {
                        lengthType: LengthType.Varint
                    };
                default:
                    throw new Error("Unrecognized schema type: " + parsedSchema.type);
            }
        };
        return IdBlockUtil;
    }();
    var LengthType;
    (function (LengthType) {
        LengthType[LengthType["LengthDelimited"] = 0] = "LengthDelimited";
        LengthType[LengthType["Varint"] = 1] = "Varint";
        LengthType[LengthType["Bit64"] = 2] = "Bit64";
        LengthType[LengthType["IdBlock"] = 3] = "IdBlock";
    })(LengthType || (LengthType = {}));
    var SchemaUtil = function () {
        function SchemaUtil() { }
        SchemaUtil.canBeLiteral = function (schema, literal) {
            var _this = this;
            if (schema.type === SchemaType.Union) {
                return schema.members.some(function (v) {
                    return _this.canBeLiteral(v.type, literal);
                });
            }
            if (schema.type === SchemaType.Any) {
                return true;
            }
            if (schema.type === SchemaType.Literal && schema.literal === literal) {
                return true;
            }
            return false;
        };
        return SchemaUtil;
    }();
    var TypedArrays = {
        Int8Array: Int8Array,
        Int16Array: Int16Array,
        Int32Array: Int32Array,
        Uint8Array: Uint8Array,
        Uint16Array: Uint16Array,
        Uint32Array: Uint32Array,
        Float32Array: Float32Array,
        Float64Array: Float64Array
    };
    var Utf8CoderJS = {
        measureLength: function measureLength(str) {
            var len = 0, c = 0;
            for (var i = 0; i < str.length; ++i) {
                c = str.charCodeAt(i);
                if (c < 128)
                    len += 1;
                else if (c < 2048)
                    len += 2;
                else if ((c & 0xFC00) === 0xD800 && (str.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
                    ++i;
                    len += 4;
                }
                else
                    len += 3;
            }
            return len;
        },
        write: function write(str, buf, pos) {
            var start = pos, c1, c2;
            for (var i = 0; i < str.length; ++i) {
                c1 = str.charCodeAt(i);
                if (c1 < 128) {
                    buf[pos++] = c1;
                }
                else if (c1 < 2048) {
                    buf[pos++] = c1 >> 6 | 192;
                    buf[pos++] = c1 & 63 | 128;
                }
                else if ((c1 & 0xFC00) === 0xD800 && ((c2 = str.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
                    c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
                    ++i;
                    buf[pos++] = c1 >> 18 | 240;
                    buf[pos++] = c1 >> 12 & 63 | 128;
                    buf[pos++] = c1 >> 6 & 63 | 128;
                    buf[pos++] = c1 & 63 | 128;
                }
                else {
                    buf[pos++] = c1 >> 12 | 224;
                    buf[pos++] = c1 >> 6 & 63 | 128;
                    buf[pos++] = c1 & 63 | 128;
                }
            }
            return pos - start;
        },
        read: function read(buf, pos, length) {
            if (length < 1)
                return "";
            var parts = undefined, chunk = [], i = 0, t;
            var end = pos + length;
            while (pos < end) {
                t = buf[pos++];
                if (t < 128)
                    chunk[i++] = t;
                else if (t > 191 && t < 224)
                    chunk[i++] = (t & 31) << 6 | buf[pos++] & 63;
                else if (t > 239 && t < 365) {
                    t = ((t & 7) << 18 | (buf[pos++] & 63) << 12 | (buf[pos++] & 63) << 6 | buf[pos++] & 63) - 0x10000;
                    chunk[i++] = 0xD800 + (t >> 10);
                    chunk[i++] = 0xDC00 + (t & 1023);
                }
                else
                    chunk[i++] = (t & 15) << 12 | (buf[pos++] & 63) << 6 | buf[pos++] & 63;
                if (i > 8191) {
                    (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
                    i = 0;
                }
            }
            if (parts) {
                if (i)
                    parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
                return parts.join("");
            }
            return String.fromCharCode.apply(String, chunk.slice(0, i));
        }
    };
    var Utf8CoderNode = {
        measureLength: function measureLength(str) {
            return Buffer.byteLength(str, 'utf-8');
        },
        write: function write(str, buf, pos) {
            return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).write(str, pos, 'utf-8');
        },
        read: function read(buf, pos, length) {
            return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString('utf-8', pos, pos + length);
        }
    };
    var Utf8Coder = typeof Buffer !== 'undefined' && Buffer.from && Buffer.prototype.write ? Utf8CoderNode : Utf8CoderJS;
    var Varint64 = function () {
        function Varint64(high, low, byteLength) {
            this.uint32s = new Uint32Array([high, low]);
            if (byteLength !== undefined) {
                this._byteLength = byteLength;
            }
        }
        Varint64.from = function (value) {
            if (value === 0) {
                return this.Zero;
            }
            var sign = value < 0;
            if (sign) {
                value = -value;
            }
            var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
            if (sign) {
                hi = ~hi >>> 0;
                lo = ~lo >>> 0;
                if (++lo > 4294967295) {
                    lo = 0;
                    if (++hi > 4294967295)
                        hi = 0;
                }
            }
            return new Varint64(hi, lo);
        };
        Varint64.prototype.toNumber = function (unsigned) {
            if (!unsigned && this.uint32s[0] >>> 31) {
                var low = ~this.uint32s[1] + 1 >>> 0, high = ~this.uint32s[0] >>> 0;
                if (!low)
                    high = high + 1 >>> 0;
                return -(low + high * 4294967296);
            }
            return this.uint32s[1] + this.uint32s[0] * 4294967296;
        };
        Varint64.prototype.zzEncode = function () {
            var mask = this.uint32s[0] >> 31;
            this.uint32s[0] = ((this.uint32s[0] << 1 | this.uint32s[1] >>> 31) ^ mask) >>> 0;
            this.uint32s[1] = (this.uint32s[1] << 1 ^ mask) >>> 0;
            return this;
        };
        Varint64.prototype.zzDecode = function () {
            var mask = -(this.uint32s[1] & 1);
            this.uint32s[1] = ((this.uint32s[1] >>> 1 | this.uint32s[0] << 31) ^ mask) >>> 0;
            this.uint32s[0] = (this.uint32s[0] >>> 1 ^ mask) >>> 0;
            return this;
        };
        Object.defineProperty(Varint64.prototype, "byteLength", {
            get: function get() {
                if (this._byteLength === undefined) {
                    var part0 = this.uint32s[1], part1 = (this.uint32s[1] >>> 28 | this.uint32s[0] << 4) >>> 0, part2 = this.uint32s[0] >>> 24;
                    this._byteLength = part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
                }
                return this._byteLength;
            },
            enumerable: false,
            configurable: true
        });
        Varint64.prototype.writeToBuffer = function (buf, pos) {
            while (this.uint32s[0]) {
                buf[pos++] = this.uint32s[1] & 127 | 128;
                this.uint32s[1] = (this.uint32s[1] >>> 7 | this.uint32s[0] << 25) >>> 0;
                this.uint32s[0] >>>= 7;
            }
            while (this.uint32s[1] > 127) {
                buf[pos++] = this.uint32s[1] & 127 | 128;
                this.uint32s[1] = this.uint32s[1] >>> 7;
            }
            buf[pos++] = this.uint32s[1];
            return pos;
        };
        Varint64.readFromBuffer = function (buf, pos) {
            var startPos = pos;
            var hi = 0, lo = 0;
            var i = 0;
            if (buf.byteLength - pos > 4) {
                for (; i < 4; ++i) {
                    lo = (lo | (buf[pos] & 127) << i * 7) >>> 0;
                    if (buf[pos++] < 128)
                        return new Varint64(hi, lo, pos - startPos);
                }
                lo = (lo | (buf[pos] & 127) << 28) >>> 0;
                hi = (hi | (buf[pos] & 127) >> 4) >>> 0;
                if (buf[pos++] < 128)
                    return new Varint64(hi, lo, pos - startPos);
                i = 0;
            }
            else {
                for (; i < 3; ++i) {
                    if (pos >= buf.byteLength)
                        throw new Error('Read varint error: index out of range');
                    lo = (lo | (buf[pos] & 127) << i * 7) >>> 0;
                    if (buf[pos++] < 128)
                        return new Varint64(hi, lo, pos - startPos);
                }
                lo = (lo | (buf[pos++] & 127) << i * 7) >>> 0;
                return new Varint64(hi, lo, pos - startPos);
            }
            if (buf.byteLength - pos > 4) {
                for (; i < 5; ++i) {
                    hi = (hi | (buf[pos] & 127) << i * 7 + 3) >>> 0;
                    if (buf[pos++] < 128)
                        return new Varint64(hi, lo, pos - startPos);
                }
            }
            else {
                for (; i < 5; ++i) {
                    if (pos >= buf.byteLength)
                        throw new Error('Read varint error: index out of range');
                    hi = (hi | (buf[pos] & 127) << i * 7 + 3) >>> 0;
                    if (buf[pos++] < 128)
                        return new Varint64(hi, lo, pos - startPos);
                }
            }
            throw Error("invalid varint encoding");
        };
        Varint64.Zero = new Varint64(0, 0);
        return Varint64;
    }();
    var BufferReader = function () {
        function BufferReader() {
            this._pos = 0;
        }
        BufferReader.prototype.load = function (buf, pos) {
            if (pos === void 0) {
                pos = 0;
            }
            this._buf = buf;
            this._pos = pos;
            this._view = new DataView(buf.buffer);
        };
        BufferReader.prototype.readVarint = function () {
            var varint = Varint64.readFromBuffer(this._buf, this._pos);
            this._pos += varint.byteLength;
            return varint;
        };
        BufferReader.prototype.readUint = function () {
            return this.readVarint().toNumber(true);
        };
        BufferReader.prototype.readInt = function () {
            return this.readVarint().zzDecode().toNumber();
        };
        BufferReader.prototype.readDouble = function () {
            var pos = this._pos;
            this._pos += 8;
            return this._view.getFloat64(this._buf.byteOffset + pos);
        };
        BufferReader.prototype.readString = function () {
            var strByteLength = this.readUint();
            var str = Utf8Coder.read(this._buf, this._pos, strByteLength);
            this._pos += strByteLength;
            return str;
        };
        BufferReader.prototype.readBuffer = function () {
            var bufByteLength = this.readUint();
            var buf = this._buf.subarray(this._pos, this._pos + bufByteLength);
            this._pos += bufByteLength;
            return buf;
        };
        BufferReader.prototype.skip = function (byteLength) {
            this._pos += byteLength;
        };
        BufferReader.prototype.skipByLengthType = function (lengthType) {
            if (lengthType === LengthType.Bit64) {
                this._pos += 8;
            }
            else if (lengthType === LengthType.Varint) {
                this.readVarint();
            }
            else if (lengthType === LengthType.LengthDelimited) {
                var bufByteLength = this.readUint();
                this._pos += bufByteLength;
            }
            else if (lengthType === LengthType.IdBlock) {
                this.skipIdBlock();
            }
            else {
                throw new Error('Unknown lengthType: ' + lengthType);
            }
        };
        BufferReader.prototype.skipIdBlock = function () {
            var idNum = this.readUint();
            for (var i = 0; i < idNum; ++i) {
                var id = this.readUint();
                var lengthType = id & 3;
                this.skipByLengthType(lengthType);
            }
        };
        BufferReader.prototype.readBoolean = function () {
            var value = this._view.getUint8(this._buf.byteOffset + this._pos++);
            if (value === 255) {
                return true;
            }
            else if (value === 0) {
                return false;
            }
            else {
                throw new Error("Invalid boolean encoding [" + value + "] at pos " + (this._pos - 1));
            }
        };
        Object.defineProperty(BufferReader.prototype, "unreadByteLength", {
            get: function get() {
                return this._buf.byteLength - this._pos;
            },
            enumerable: false,
            configurable: true
        });
        BufferReader.prototype.dispose = function () {
            this._buf = this._view = undefined;
        };
        return BufferReader;
    }();
    var Decoder = function () {
        function Decoder(options) {
            this._options = options;
            this._reader = new BufferReader();
            this._validator = options.validator;
        }
        Decoder.prototype.decode = function (buffer, schema) {
            this._reader.load(buffer);
            return this._read(schema);
        };
        Decoder.prototype._read = function (schema) {
            switch (schema.type) {
                case SchemaType.Boolean:
                    return this._reader.readBoolean();
                case SchemaType.Number:
                    return this._readNumber(schema);
                case SchemaType.String:
                    return this._reader.readString();
                case SchemaType.Array:
                    {
                        var output = [];
                        var length_1 = this._reader.readUint();
                        for (var i = 0; i < length_1; ++i) {
                            var item = this._read(schema.elementType);
                            output.push(item);
                        }
                        return output;
                    }
                case SchemaType.Tuple:
                    {
                        if (schema.elementTypes.length > 64) {
                            throw new Error('Elements oversized, maximum supported tuple elements is 64, now get ' + schema.elementTypes.length);
                        }
                        var output = [];
                        var payloadMask = this._reader.readVarint();
                        var maskIndices = [];
                        for (var i = 0; i < 32; ++i) {
                            if (payloadMask.uint32s[1] & 1 << i) {
                                maskIndices.push(i);
                            }
                        }
                        for (var i = 0; i < 32; ++i) {
                            if (payloadMask.uint32s[0] & 1 << i) {
                                maskIndices.push(i + 32);
                            }
                        }
                        if (!maskIndices.length) {
                            return [];
                        }
                        var maxIndex = maskIndices.last();
                        for (var i = 0, nextMaskIndex = 0, next = maskIndices[0]; i <= maxIndex; ++i) {
                            if (i === next) {
                                output[i] = this._read(schema.elementTypes[i]);
                                ++nextMaskIndex;
                                next = maskIndices[nextMaskIndex];
                            }
                            else {
                                output[i] = undefined;
                            }
                        }
                        for (var i = 0; i < schema.elementTypes.length; ++i) {
                            if (this._undefinedAsNull(output[i], schema.elementTypes[i], schema.optionalStartIndex !== undefined && i >= schema.optionalStartIndex)) {
                                output[i] = null;
                            }
                        }
                        return output;
                    }
                case SchemaType.Enum:
                    var enumId_1 = this._reader.readVarint().toNumber();
                    var enumItem = schema.members.find(function (v) {
                        return v.id === enumId_1;
                    });
                    if (!enumItem) {
                        throw new Error("Invalid enum encoding: unexpected id " + enumId_1);
                    }
                    return enumItem.value;
                case SchemaType.Any:
                case SchemaType.Object:
                    var jsonStr = this._reader.readString();
                    if (jsonStr === 'undefined') {
                        return undefined;
                    }
                    return JSON.parse(jsonStr);
                case SchemaType.Literal:
                    return schema.literal;
                case SchemaType.Interface:
                    return this._readInterface(schema);
                case SchemaType.Buffer:
                    var uint8Arr = this._reader.readBuffer();
                    if (schema.arrayType) {
                        if (schema.arrayType === 'BigInt64Array' || schema.arrayType === 'BigUint64Array') {
                            throw new Error('Unsupported arrayType: ' + schema.arrayType);
                        }
                        else if (schema.arrayType === 'Uint8Array') {
                            return uint8Arr;
                        }
                        else {
                            var typedArr = TypedArrays[schema.arrayType];
                            if (uint8Arr.byteOffset % typedArr.BYTES_PER_ELEMENT === 0) {
                                return new typedArr(uint8Arr.buffer, uint8Arr.byteOffset, uint8Arr.byteLength / typedArr.BYTES_PER_ELEMENT);
                            }
                            else {
                                var arrBuf = uint8Arr.buffer.slice(uint8Arr.byteOffset, uint8Arr.byteOffset + uint8Arr.byteLength);
                                return new typedArr(arrBuf);
                            }
                        }
                    }
                    else {
                        return uint8Arr.buffer.slice(uint8Arr.byteOffset, uint8Arr.byteOffset + uint8Arr.byteLength);
                    }
                case SchemaType.IndexedAccess:
                case SchemaType.Reference:
                    return this._read(this._validator.protoHelper.parseReference(schema));
                case SchemaType.Partial:
                case SchemaType.Pick:
                case SchemaType.Omit:
                case SchemaType.Overwrite:
                    var parsed = this._validator.protoHelper.parseMappedType(schema);
                    if (parsed.type === 'Interface') {
                        return this._readPureMappedType(schema);
                    }
                    else if (parsed.type === 'Union') {
                        return this._readUnionOrIntersection(parsed);
                    }
                    break;
                case SchemaType.Union:
                case SchemaType.Intersection:
                    return this._readUnionOrIntersection(schema);
                case SchemaType.Date:
                    return new Date(this._reader.readUint());
                case SchemaType.NonNullable:
                    return this._read(schema.target);
                default:
                    throw new Error("Unrecognized schema type: " + schema.type);
            }
        };
        Decoder.prototype._readPureMappedType = function (schema) {
            var output;
            var overwrite;
            if (schema.type === 'Overwrite') {
                overwrite = this._read(schema.overwrite);
            }
            var parsedTarget = this._validator.protoHelper.parseReference(schema.target);
            if (parsedTarget.type === 'Interface') {
                output = this._readInterface(parsedTarget);
            }
            else if (parsedTarget.type === 'Pick' || parsedTarget.type === 'Omit' || parsedTarget.type === 'Partial' || parsedTarget.type === 'Overwrite') {
                output = this._readPureMappedType(parsedTarget);
            }
            else {
                throw new Error('Invalid PureMappedType child: ' + schema.type);
            }
            if (schema.type === 'Pick') {
                for (var key in output) {
                    if (schema.keys.indexOf(key) === -1) {
                        delete output[key];
                    }
                }
            }
            else if (schema.type === 'Omit') {
                for (var key in output) {
                    if (schema.keys.indexOf(key) > -1) {
                        delete output[key];
                    }
                }
            }
            else if (schema.type === 'Overwrite') {
                Object.assign(output, overwrite);
            }
            return output;
        };
        Decoder.prototype._readNumber = function (schema) {
            var scalarType = schema.scalarType || 'double';
            switch (scalarType) {
                case 'double':
                    return this._reader.readDouble();
                case 'int':
                    return this._reader.readInt();
                case 'uint':
                    return this._reader.readUint();
                default:
                    throw new Error('Scalar type not support : ' + scalarType);
            }
        };
        Decoder.prototype._readInterface = function (schema) {
            var output = {};
            var flatSchema = this._validator.protoHelper.getFlatInterfaceSchema(schema);
            var blockIdNum = this._reader.readUint();
            var _loop_1 = function _loop_1(i) {
                var readBlockId = this_1._reader.readUint();
                var lengthType = readBlockId & 3;
                var blockId = readBlockId >> 2;
                if (blockId === 0) {
                    if (flatSchema.indexSignature) {
                        var type = flatSchema.indexSignature.type;
                        var fieldName = this_1._reader.readString();
                        this_1._skipIdLengthPrefix(this_1._validator.protoHelper.parseReference(type));
                        output[fieldName] = this_1._read(type);
                    }
                    else {
                        this_1._reader.skipByLengthType(LengthType.LengthDelimited);
                        this_1._reader.skipByLengthType(lengthType);
                    }
                }
                else if (blockId <= 9) {
                    var extendId_1 = blockId - 1;
                    var extend = schema.extends && schema.extends.find(function (v) {
                        return v.id === extendId_1;
                    });
                    if (extend) {
                        this_1._skipIdLengthPrefix(this_1._validator.protoHelper.parseReference(extend.type));
                        var extendValue = this_1._read(extend.type);
                        Object.assign(output, extendValue);
                    }
                    else {
                        this_1._reader.skipByLengthType(lengthType);
                    }
                }
                else {
                    var propertyId_1 = blockId - 10;
                    var property = schema.properties && schema.properties.find(function (v) {
                        return v.id === propertyId_1;
                    });
                    if (property) {
                        this_1._skipIdLengthPrefix(this_1._validator.protoHelper.parseReference(property.type));
                        output[property.name] = this_1._read(property.type);
                    }
                    else {
                        this_1._reader.skipByLengthType(lengthType);
                    }
                }
            };
            var this_1 = this;
            for (var i = 0; i < blockIdNum; ++i) {
                _loop_1();
            }
            for (var _i = 0, _a = flatSchema.properties; _i < _a.length; _i++) {
                var property = _a[_i];
                if (output.hasOwnProperty(property.name)) {
                    continue;
                }
                var parsedType = this._validator.protoHelper.parseReference(property.type);
                if (parsedType.type === 'Literal') {
                    output[property.name] = parsedType.literal;
                    continue;
                }
                if (this._undefinedAsNull(output[property.name], parsedType, property.optional)) {
                    output[property.name] = null;
                    continue;
                }
            }
            return output;
        };
        Decoder.prototype._undefinedAsNull = function (value, type, isOptional) {
            return value === undefined && this._options.undefinedAsNull && !SchemaUtil.canBeLiteral(type, undefined) && !isOptional && SchemaUtil.canBeLiteral(type, null);
        };
        Decoder.prototype._skipIdLengthPrefix = function (parsedSchema) {
            var lengthInfo = IdBlockUtil.getPayloadLengthInfo(parsedSchema);
            if (lengthInfo.needLengthPrefix) {
                this._reader.skipByLengthType(LengthType.Varint);
            }
        };
        Decoder.prototype._readUnionOrIntersection = function (schema) {
            var output;
            var idNum = this._reader.readUint();
            var _loop_2 = function _loop_2(i) {
                var readId = this_2._reader.readUint();
                var lengthType = readId & 3;
                var id = readId >> 2;
                var member = schema.members.find(function (v) {
                    return v.id === id;
                });
                if (!member) {
                    this_2._reader.skipByLengthType(lengthType);
                    return "continue";
                }
                this_2._skipIdLengthPrefix(this_2._validator.protoHelper.parseReference(member.type));
                var value = this_2._read(member.type);
                if (this_2._isObject(output) && this_2._isObject(value)) {
                    Object.assign(output, value);
                }
                else {
                    output = value;
                }
            };
            var this_2 = this;
            for (var i = 0; i < idNum; ++i) {
                _loop_2();
            }
            if (this._undefinedAsNull(output, schema)) {
                output = null;
            }
            return output;
        };
        Decoder.prototype._isObject = function (value) {
            return _typeof(value) === 'object' && value !== null;
        };
        return Decoder;
    }();
    var Config = {
        interface: {
            maxExtendsNum: 9
        }
    };
    var BufferWriter = function () {
        function BufferWriter() {
            this._ops = [];
        }
        Object.defineProperty(BufferWriter.prototype, "ops", {
            get: function get() {
                return this._ops;
            },
            enumerable: false,
            configurable: true
        });
        BufferWriter.prototype.clear = function () {
            this._ops = [];
        };
        BufferWriter.prototype.push = function (req) {
            this._ops.push(this.req2op(req));
            return this;
        };
        BufferWriter.prototype.req2op = function (req) {
            if (req.type === 'string' || req.type === 'buffer') {
                var valueLength = this.measureLength(req);
                this.push({
                    type: 'varint',
                    value: Varint64.from(valueLength)
                });
                return __assign$1(__assign$1({}, req), {
                    length: valueLength
                });
            }
            else {
                var length_1 = this.measureLength(req);
                return __assign$1(__assign$1({}, req), {
                    length: length_1
                });
            }
        };
        BufferWriter.prototype.measureLength = function (req) {
            switch (req.type) {
                case 'varint':
                    return req.value.byteLength;
                case 'string':
                    return Utf8Coder.measureLength(req.value);
                case 'buffer':
                    return req.value.byteLength;
                case 'double':
                    return 8;
                case 'boolean':
                    return 1;
                default:
                    return NaN;
            }
        };
        BufferWriter.prototype.finish = function () {
            var byteLength = this._ops.sum(function (v) {
                return v.length;
            });
            var pos = 0;
            var buf = new Uint8Array(byteLength);
            var view = new DataView(buf.buffer);
            for (var _i = 0, _a = this._ops; _i < _a.length; _i++) {
                var op = _a[_i];
                switch (op.type) {
                    case 'varint':
                        var newPos = op.value.writeToBuffer(buf, pos);
                        if (newPos !== pos + op.length) {
                            throw new Error("Error varint measuredLength " + op.length + ", actual is " + (newPos - pos) + ", value is " + op.value.toNumber());
                        }
                        break;
                    case 'double':
                        view.setFloat64(buf.byteOffset + pos, op.value);
                        break;
                    case 'string':
                        var encLen = Utf8Coder.write(op.value, buf, pos);
                        if (encLen !== op.length) {
                            throw new Error("Expect " + op.length + " bytes but encoded " + encLen + " bytes");
                        }
                        break;
                    case 'buffer':
                        buf.subarray(pos, pos + op.length).set(op.value);
                        break;
                    case 'boolean':
                        view.setUint8(buf.byteOffset + pos, op.value ? 255 : 0);
                        break;
                }
                pos += op.length;
            }
            return buf;
        };
        return BufferWriter;
    }();
    var Encoder = function () {
        function Encoder(options) {
            this._options = options;
            this._writer = new BufferWriter();
            this._validator = options.validator;
        }
        Encoder.prototype.encode = function (value, schema) {
            this._writer.clear();
            this._write(value, schema);
            return this._writer.finish();
        };
        Encoder.prototype._write = function (value, schema, options) {
            switch (schema.type) {
                case SchemaType.Boolean:
                    this._writer.push({
                        type: 'boolean',
                        value: value
                    });
                    break;
                case SchemaType.Number:
                    this._writeNumber(value, schema);
                    break;
                case SchemaType.String:
                    this._writer.push({
                        type: 'string',
                        value: value
                    });
                    break;
                case SchemaType.Array:
                    {
                        var _v = value;
                        this._writer.push({
                            type: 'varint',
                            value: Varint64.from(_v.length)
                        });
                        for (var i = 0; i < _v.length; ++i) {
                            this._write(_v[i], schema.elementType);
                        }
                        break;
                    }
                case SchemaType.Tuple:
                    {
                        if (schema.elementTypes.length > 64) {
                            throw new Error('Elements oversized, maximum supported tuple elements is 64, now get ' + schema.elementTypes.length);
                        }
                        var _v = value;
                        var maskIndices = [];
                        for (var i = 0; i < _v.length; ++i) {
                            if (_v[i] === undefined || this._nullAsUndefined(_v[i], schema.elementTypes[i])) {
                                continue;
                            }
                            maskIndices.push(i);
                        }
                        var lo = 0;
                        var hi = 0;
                        for (var _i = 0, maskIndices_1 = maskIndices; _i < maskIndices_1.length; _i++) {
                            var v = maskIndices_1[_i];
                            if (v < 32) {
                                lo |= 1 << v;
                            }
                            else {
                                hi |= 1 << v - 32;
                            }
                        }
                        this._writer.push({
                            type: 'varint',
                            value: new Varint64(hi, lo)
                        });
                        for (var _a = 0, maskIndices_2 = maskIndices; _a < maskIndices_2.length; _a++) {
                            var i = maskIndices_2[_a];
                            this._write(_v[i], schema.elementTypes[i]);
                        }
                        break;
                    }
                case SchemaType.Enum:
                    var enumItem = schema.members.find(function (v) {
                        return v.value === value;
                    });
                    if (!enumItem) {
                        throw new Error("Unexpect enum value: " + value);
                    }
                    this._writer.push({
                        type: 'varint',
                        value: Varint64.from(enumItem.id)
                    });
                    break;
                case SchemaType.Any:
                    if (value === undefined) {
                        this._writer.push({
                            type: 'string',
                            value: 'undefined'
                        });
                    }
                    else {
                        this._writer.push({
                            type: 'string',
                            value: JSON.stringify(value)
                        });
                    }
                    break;
                case SchemaType.Object:
                    this._writer.push({
                        type: 'string',
                        value: JSON.stringify(value)
                    });
                    break;
                case SchemaType.Literal:
                    break;
                case SchemaType.Interface:
                    this._writeInterface(value, schema, options);
                    break;
                case SchemaType.Buffer:
                    this._writeBuffer(value, schema);
                    break;
                case SchemaType.IndexedAccess:
                case SchemaType.Reference:
                    this._write(value, this._validator.protoHelper.parseReference(schema), options);
                    break;
                case SchemaType.Partial:
                case SchemaType.Pick:
                case SchemaType.Omit:
                case SchemaType.Overwrite:
                    var parsed = this._validator.protoHelper.parseMappedType(schema);
                    if (parsed.type === 'Interface') {
                        this._writePureMappedType(value, schema, options);
                    }
                    else {
                        this._writeUnion(value, parsed, options === null || options === void 0 ? void 0 : options.skipFields);
                    }
                    break;
                case SchemaType.Union:
                    this._writeUnion(value, schema, options === null || options === void 0 ? void 0 : options.skipFields);
                    break;
                case SchemaType.Intersection:
                    this._writeIntersection(value, schema, options === null || options === void 0 ? void 0 : options.skipFields);
                    break;
                case SchemaType.Date:
                    this._writer.push({
                        type: 'varint',
                        value: Varint64.from(value.getTime())
                    });
                    break;
                case SchemaType.NonNullable:
                    this._write(value, schema.target, options);
                    break;
                default:
                    throw new Error("Unrecognized schema type: " + schema.type);
            }
        };
        Encoder.prototype._writePureMappedType = function (value, schema, options) {
            if (!options) {
                options = {};
            }
            if (schema.type === 'Pick') {
                if (options.pickFields) {
                    var newPickFields = {};
                    for (var _i = 0, _a = schema.keys; _i < _a.length; _i++) {
                        var v = _a[_i];
                        if (options.pickFields[v]) {
                            newPickFields[v] = 1;
                        }
                    }
                    options.pickFields = newPickFields;
                }
                else {
                    options.pickFields = {};
                    for (var _b = 0, _c = schema.keys; _b < _c.length; _b++) {
                        var v = _c[_b];
                        options.pickFields[v] = 1;
                    }
                }
            }
            else if (schema.type === 'Omit') {
                if (!(options === null || options === void 0 ? void 0 : options.skipFields)) {
                    if (!options) {
                        options = {};
                    }
                    options.skipFields = {};
                }
                for (var _d = 0, _e = schema.keys; _d < _e.length; _d++) {
                    var v = _e[_d];
                    options.skipFields[v] = 1;
                }
            }
            else if (schema.type === 'Overwrite') {
                var parsed = this._parseOverwrite(value, schema);
                this._write(parsed.overwriteValue, parsed.overwrite, options);
            }
            else if (schema.type === 'Partial')
                ;
            else {
                throw new Error('Invalid PureMappedType child: ' + schema.type);
            }
            var parsedTarget = this._validator.protoHelper.parseReference(schema.target);
            if (parsedTarget.type === 'Interface') {
                this._writeInterface(value, parsedTarget, options);
            }
            else {
                this._writePureMappedType(value, parsedTarget, options);
            }
        };
        Encoder.prototype._writeNumber = function (value, schema) {
            var scalarType = schema.scalarType || 'double';
            switch (scalarType) {
                case 'double':
                    this._writer.push({
                        type: scalarType,
                        value: value
                    });
                    break;
                case 'int':
                    this._writer.push({
                        type: 'varint',
                        value: Varint64.from(value).zzEncode()
                    });
                    break;
                case 'uint':
                    this._writer.push({
                        type: 'varint',
                        value: Varint64.from(value)
                    });
                    break;
                default:
                    throw new Error('Scalar type not support : ' + scalarType);
            }
        };
        Encoder.prototype._writeInterface = function (value, schema, options) {
            if (!options) {
                options = {};
            }
            if (!options.skipFields) {
                options.skipFields = {};
            }
            var opStartOps = this._writer.ops.length;
            var blockIdCount = 0;
            if (schema.extends) {
                if (schema.extends.length > Config.interface.maxExtendsNum) {
                    throw new Error("Max support " + Config.interface.maxExtendsNum + " extends, actual: " + schema.extends.length);
                }
                for (var _i = 0, _a = schema.extends; _i < _a.length; _i++) {
                    var extend = _a[_i];
                    var blockId = extend.id + 1;
                    this._writer.push({
                        type: 'varint',
                        value: Varint64.from(blockId)
                    });
                    var blockIdPos = this._writer.ops.length - 1;
                    var opsLengthBeforeWrite = this._writer.ops.length;
                    var parsedExtend = this._validator.protoHelper.parseReference(extend.type);
                    this._writeInterface(value, parsedExtend, __assign$1(__assign$1({}, options), {
                        skipIndexSignature: !!schema.indexSignature || options.skipIndexSignature
                    }));
                    if (this._writer.ops.length === opsLengthBeforeWrite + 1) {
                        this._writer.ops.splice(this._writer.ops.length - 2, 2);
                    }
                    else {
                        ++blockIdCount;
                        this._processIdWithLengthType(blockIdPos, extend.type);
                    }
                }
            }
            if (schema.properties) {
                for (var _b = 0, _c = schema.properties; _b < _c.length; _b++) {
                    var property = _c[_b];
                    var parsedType = this._validator.protoHelper.parseReference(property.type);
                    var propValue = value[property.name];
                    if (options.pickFields && !options.pickFields[property.name]) {
                        continue;
                    }
                    if (parsedType.type === 'Literal') {
                        options.skipFields[property.name] = 1;
                        continue;
                    }
                    if (this._nullAsUndefined(propValue, property.type)) {
                        propValue = undefined;
                    }
                    if (propValue === undefined) {
                        continue;
                    }
                    if (options.skipFields[property.name]) {
                        continue;
                    }
                    options.skipFields[property.name] = 1;
                    var blockId = property.id + Config.interface.maxExtendsNum + 1;
                    this._writer.push({
                        type: 'varint',
                        value: Varint64.from(blockId)
                    });
                    var blockIdPos = this._writer.ops.length - 1;
                    this._write(propValue, parsedType);
                    ++blockIdCount;
                    this._processIdWithLengthType(blockIdPos, parsedType);
                }
            }
            if (!options.skipIndexSignature) {
                var flat = this._validator.protoHelper.getFlatInterfaceSchema(schema);
                if (flat.indexSignature) {
                    for (var key in value) {
                        if (value[key] === undefined || this._nullAsUndefined(value[key], flat.indexSignature.type)) {
                            continue;
                        }
                        if (options.pickFields && !options.pickFields[key]) {
                            continue;
                        }
                        if (options.skipFields[key]) {
                            continue;
                        }
                        options.skipFields[key] = 1;
                        this._writer.push({
                            type: 'varint',
                            value: Varint64.from(0)
                        });
                        var blockIdPos = this._writer.ops.length - 1;
                        this._writer.push({
                            type: 'string',
                            value: key
                        });
                        var lengthPrefixPos = this._writer.ops.length;
                        this._write(value[key], flat.indexSignature.type);
                        ++blockIdCount;
                        this._processIdWithLengthType(blockIdPos, flat.indexSignature.type, lengthPrefixPos);
                    }
                }
            }
            this._writer.ops.splice(opStartOps, 0, this._writer.req2op({
                type: 'varint',
                value: Varint64.from(blockIdCount)
            }));
        };
        Encoder.prototype._nullAsUndefined = function (value, type) {
            return value === null && this._options.nullAsUndefined && !SchemaUtil.canBeLiteral(type, null);
        };
        Encoder.prototype._parseOverwrite = function (value, schema) {
            var skipFields = {};
            var target = this._validator.protoHelper.parseReference(schema.target);
            var overwrite = this._validator.protoHelper.parseReference(schema.overwrite);
            var flatTarget = this._validator.protoHelper.getFlatInterfaceSchema(target);
            var flatOverwrite = this._validator.protoHelper.getFlatInterfaceSchema(overwrite);
            var overwriteValue = {};
            var targetValue = {};
            if (flatOverwrite.properties) {
                for (var _i = 0, _a = flatOverwrite.properties; _i < _a.length; _i++) {
                    var property = _a[_i];
                    if (value[property.name] !== undefined && !skipFields[property.name]) {
                        overwriteValue[property.name] = value[property.name];
                        skipFields[property.name] = 1;
                    }
                }
            }
            if (flatTarget.properties) {
                for (var _b = 0, _c = flatTarget.properties; _b < _c.length; _b++) {
                    var property = _c[_b];
                    if (value[property.name] !== undefined && !skipFields[property.name]) {
                        targetValue[property.name] = value[property.name];
                        skipFields[property.name] = 1;
                    }
                }
            }
            var indexSignatureWriteValue;
            var indexSignature;
            if (flatOverwrite.indexSignature) {
                indexSignature = flatOverwrite.indexSignature;
                indexSignatureWriteValue = overwriteValue;
            }
            else if (flatTarget.indexSignature) {
                indexSignature = flatTarget.indexSignature;
                indexSignatureWriteValue = targetValue;
            }
            if (indexSignature) {
                for (var key in value) {
                    if (skipFields[key]) {
                        continue;
                    }
                    indexSignatureWriteValue[key] = value[key];
                    skipFields[key] = 1;
                }
            }
            return {
                target: target,
                targetValue: targetValue,
                overwrite: overwrite,
                overwriteValue: overwriteValue
            };
        };
        Encoder.prototype._writeUnion = function (value, schema, skipFields, unionProperties) {
            if (skipFields === void 0) {
                skipFields = {};
            }
            var encodeStartPos = this._writer.ops.length;
            var idNum = 0;
            if (this._nullAsUndefined(value, schema)) {
                value = undefined;
            }
            for (var _i = 0, _a = schema.members; _i < _a.length; _i++) {
                var member = _a[_i];
                var vRes = this._validator.validate(value, member.type, {
                    excessPropertyChecks: false,
                    strictNullChecks: true
                });
                if (vRes.isSucc) {
                    this._writer.push({
                        type: 'varint',
                        value: Varint64.from(member.id)
                    });
                    var idPos = this._writer.ops.length - 1;
                    if (member.type.type === 'Union') {
                        this._writeUnion(value, member.type, skipFields);
                    }
                    else {
                        this._write(value, member.type, {
                            skipFields: skipFields
                        });
                    }
                    idNum++;
                    this._processIdWithLengthType(idPos, member.type);
                    if (_typeof(value) !== 'object') {
                        break;
                    }
                }
            }
            if (idNum > 0) {
                this._writer.ops.splice(encodeStartPos, 0, this._writer.req2op({
                    type: 'varint',
                    value: Varint64.from(idNum)
                }));
                return;
            }
            else {
                throw new Error('Non member is satisfied for union type');
            }
        };
        Encoder.prototype._writeIntersection = function (value, schema, skipFields) {
            if (skipFields === void 0) {
                skipFields = {};
            }
            this._writer.push({
                type: 'varint',
                value: Varint64.from(schema.members.length)
            });
            for (var _i = 0, _a = schema.members; _i < _a.length; _i++) {
                var member = _a[_i];
                this._writer.push({
                    type: 'varint',
                    value: Varint64.from(member.id)
                });
                var idPos = this._writer.ops.length - 1;
                this._write(value, member.type, {
                    skipFields: skipFields
                });
                this._processIdWithLengthType(idPos, member.type);
            }
        };
        Encoder.prototype._writeBuffer = function (value, schema) {
            if (value instanceof ArrayBuffer) {
                this._writer.push({
                    type: 'buffer',
                    value: new Uint8Array(value)
                });
            }
            else if (value instanceof Uint8Array) {
                this._writer.push({
                    type: 'buffer',
                    value: value
                });
            }
            else {
                var key = value.constructor.name;
                var arrType = TypedArrays[key];
                var uint8Arr = new Uint8Array(value.buffer, value.byteOffset, value.length * arrType.BYTES_PER_ELEMENT);
                this._writer.push({
                    type: 'buffer',
                    value: uint8Arr
                });
            }
        };
        Encoder.prototype._processIdWithLengthType = function (idPos, payloadType, lengthPrefixPos) {
            var idOp = this._writer.ops[idPos];
            if (idOp.type !== 'varint') {
                throw new Error('Error idPos: ' + idPos);
            }
            var parsedSchema = this._validator.protoHelper.parseReference(payloadType);
            var lengthInfo = IdBlockUtil.getPayloadLengthInfo(parsedSchema);
            var newId = (idOp.value.toNumber() << 2) + lengthInfo.lengthType;
            this._writer.ops[idPos] = this._writer.req2op({
                type: 'varint',
                value: Varint64.from(newId)
            });
            if (lengthInfo.needLengthPrefix) {
                var payloadByteLength = this._writer.ops.filter(function (v, i) {
                    return i > idPos;
                }).sum(function (v) {
                    return v.length;
                });
                this._writer.ops.splice(lengthPrefixPos == undefined ? idPos + 1 : lengthPrefixPos, 0, this._writer.req2op({
                    type: 'varint',
                    value: Varint64.from(payloadByteLength)
                }));
            }
        };
        return Encoder;
    }();
    var TSBuffer = function () {
        function TSBuffer(proto, options) {
            this._options = {
                excessPropertyChecks: true,
                strictNullChecks: true,
                skipEncodeValidate: false,
                skipDecodeValidate: false,
                cloneProto: true
            };
            this._options = __assign$1(__assign$1({}, this._options), options);
            this._proto = this._options.cloneProto ? Object.merge({}, proto) : proto;
            this._validator = new TSBufferValidator(this._proto, {
                excessPropertyChecks: this._options.excessPropertyChecks,
                strictNullChecks: this._options.strictNullChecks
            });
            this.validate = this._validator.validate.bind(this._validator);
            this.prune = this._validator.prune.bind(this._validator);
            this._encoder = new Encoder({
                validator: this._validator,
                nullAsUndefined: !this._options.strictNullChecks
            });
            this._decoder = new Decoder({
                validator: this._validator,
                undefinedAsNull: !this._options.strictNullChecks
            });
        }
        TSBuffer.prototype.encode = function (value, schemaOrId, options) {
            var _a;
            var schema;
            if (typeof schemaOrId === 'string') {
                schema = this._proto[schemaOrId];
                if (!schema) {
                    return {
                        isSucc: false,
                        errMsg: "Cannot find schema\uFF1A " + schemaOrId
                    };
                }
            }
            else {
                schema = schemaOrId;
            }
            if (!((_a = options === null || options === void 0 ? void 0 : options.skipValidate) !== null && _a !== void 0 ? _a : this._options.skipEncodeValidate)) {
                var vRes = this._validator.validate(value, schema, {
                    excessPropertyChecks: false
                });
                if (!vRes.isSucc) {
                    return vRes;
                }
            }
            var buf;
            try {
                buf = this._encoder.encode(value, schema);
            }
            catch (e) {
                return {
                    isSucc: false,
                    errMsg: e.message
                };
            }
            return {
                isSucc: true,
                buf: buf
            };
        };
        TSBuffer.prototype.decode = function (buf, schemaOrId, options) {
            var _a;
            var schema;
            if (typeof schemaOrId === 'string') {
                schema = this._proto[schemaOrId];
                if (!schema) {
                    return {
                        isSucc: false,
                        errMsg: "Cannot find schema\uFF1A " + schemaOrId
                    };
                }
            }
            else {
                schema = schemaOrId;
            }
            var value;
            try {
                value = this._decoder.decode(buf, schema);
            }
            catch (e) {
                return {
                    isSucc: false,
                    errMsg: e.message
                };
            }
            if (!((_a = options === null || options === void 0 ? void 0 : options.skipValidate) !== null && _a !== void 0 ? _a : this._options.skipDecodeValidate)) {
                var vRes = this._validator.validate(value, schema);
                if (!vRes.isSucc) {
                    return vRes;
                }
            }
            return {
                isSucc: true,
                value: value
            };
        };
        return TSBuffer;
    }();
    var Counter = function () {
        function Counter(min, max) {
            if (min === void 0) {
                min = 1;
            }
            if (max === void 0) {
                max = Number.MAX_SAFE_INTEGER;
            }
            this._min = min;
            this._max = max;
            this._last = max;
        }
        Counter.prototype.reset = function () {
            this._last = this._max;
        };
        Counter.prototype.getNext = function (notInc) {
            return this._last >= this._max ? this._last = this._min : notInc ? this._last : ++this._last;
        };
        Object.defineProperty(Counter.prototype, "last", {
            get: function get() {
                return this._last;
            },
            enumerable: false,
            configurable: true
        });
        return Counter;
    }();
    var Flow = function () {
        function Flow() {
            this.nodes = [];
            this.onError = function (e, last, input, logger) {
                logger === null || logger === void 0 ? void 0 : logger.error('Uncaught FlowError:', e);
            };
        }
        Flow.prototype.exec = function (input, logger) {
            return __awaiter$1(this, void 0, void 0, function () {
                var res, i, e_1;
                return __generator$1(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            res = input;
                            i = 0;
                            _a.label = 1;
                        case 1:
                            if (!(i < this.nodes.length))
                                return [3,
                                    7];
                            _a.label = 2;
                        case 2:
                            _a.trys.push([2, 4, , 5]);
                            return [4,
                                this.nodes[i](res)];
                        case 3:
                            res = _a.sent();
                            return [3,
                                5];
                        case 4:
                            e_1 = _a.sent();
                            this.onError(e_1, res, input, logger);
                            return [2,
                                undefined];
                        case 5:
                            if (res === null || res === undefined) {
                                return [2,
                                    res];
                            }
                            _a.label = 6;
                        case 6:
                            ++i;
                            return [3,
                                1];
                        case 7:
                            return [2,
                                res];
                    }
                });
            });
        };
        Flow.prototype.push = function (node) {
            this.nodes.push(node);
            return node;
        };
        Flow.prototype.remove = function (node) {
            return this.nodes.remove(function (v) {
                return v === node;
            });
        };
        return Flow;
    }();
    var MsgHandlerManager = function () {
        function MsgHandlerManager() {
            this._handlers = {};
        }
        MsgHandlerManager.prototype.forEachHandler = function (msgName, logger) {
            var args = [];
            for (var _i = 2; _i < arguments.length; _i++) {
                args[_i - 2] = arguments[_i];
            }
            var handlers = this._handlers[msgName];
            if (!handlers) {
                return [];
            }
            var output = [];
            for (var _a = 0, handlers_1 = handlers; _a < handlers_1.length; _a++) {
                var handler = handlers_1[_a];
                try {
                    output.push(handler.apply(void 0, args));
                }
                catch (e) {
                    logger === null || logger === void 0 ? void 0 : logger.error('[MsgHandlerError]', e);
                }
            }
            return output;
        };
        MsgHandlerManager.prototype.addHandler = function (msgName, handler) {
            var handlers = this._handlers[msgName];
            if (!handlers) {
                handlers = this._handlers[msgName] = [];
            }
            else if (handlers.some(function (v) {
                return v === handler;
            })) {
                return;
            }
            handlers.push(handler);
        };
        MsgHandlerManager.prototype.removeHandler = function (msgName, handler) {
            var handlers = this._handlers[msgName];
            if (!handlers) {
                return;
            }
            handlers.removeOne(function (v) {
                return v === handler;
            });
        };
        MsgHandlerManager.prototype.removeAllHandlers = function (msgName) {
            this._handlers[msgName] = undefined;
        };
        return MsgHandlerManager;
    }();
    var ServiceMapUtil = function () {
        function ServiceMapUtil() { }
        ServiceMapUtil.getServiceMap = function (proto) {
            var map = {
                id2Service: {},
                apiName2Service: {},
                msgName2Service: {}
            };
            for (var _i = 0, _a = proto.services; _i < _a.length; _i++) {
                var v = _a[_i];
                var match = v.name.match(/(.+\/)?([^\/]+)$/);
                var path = match[1] || '';
                var name_1 = match[2];
                if (v.type === 'api') {
                    var svc = __assign$1(__assign$1({}, v), {
                        reqSchemaId: path + "Ptl" + name_1 + "/Req" + name_1,
                        resSchemaId: path + "Ptl" + name_1 + "/Res" + name_1
                    });
                    map.apiName2Service[v.name] = svc;
                    map.id2Service[v.id] = svc;
                }
                else {
                    var svc = __assign$1(__assign$1({}, v), {
                        msgSchemaId: path + "Msg" + name_1 + "/Msg" + name_1
                    });
                    map.msgName2Service[v.name] = svc;
                    map.id2Service[v.id] = svc;
                }
            }
            return map;
        };
        return ServiceMapUtil;
    }();
    var TransportDataUtil = function () {
        function TransportDataUtil() { }
        Object.defineProperty(TransportDataUtil, "tsbuffer", {
            get: function get() {
                if (!this._tsbuffer) {
                    this._tsbuffer = new TSBuffer(TransportDataProto);
                }
                return this._tsbuffer;
            },
            enumerable: false,
            configurable: true
        });
        TransportDataUtil.encodeApiReturn = function (tsbuffer, service, apiReturn, sn) {
            var serverOutputData = {
                sn: sn,
                serviceId: sn !== undefined ? service.id : undefined
            };
            if (apiReturn.isSucc) {
                var op = tsbuffer.encode(apiReturn.res, service.resSchemaId);
                if (!op.isSucc) {
                    return op;
                }
                serverOutputData.buffer = op.buf;
            }
            else {
                serverOutputData.error = apiReturn.err;
            }
            return this.tsbuffer.encode(serverOutputData, 'ServerOutputData');
        };
        TransportDataUtil.encodeClientMsg = function (tsbuffer, service, msg) {
            var op = tsbuffer.encode(msg, service.msgSchemaId);
            if (!op.isSucc) {
                return op;
            }
            var serverInputData = {
                serviceId: service.id,
                buffer: op.buf
            };
            return this.tsbuffer.encode(serverInputData, 'ServerInputData');
        };
        TransportDataUtil.encodeApiReq = function (tsbuffer, service, req, sn) {
            var op = tsbuffer.encode(req, service.reqSchemaId);
            if (!op.isSucc) {
                return op;
            }
            var serverInputData = {
                serviceId: service.id,
                buffer: op.buf,
                sn: sn
            };
            return this.tsbuffer.encode(serverInputData, 'ServerInputData');
        };
        TransportDataUtil.encodeServerMsg = function (tsbuffer, service, msg) {
            var op = tsbuffer.encode(msg, service.msgSchemaId);
            if (!op.isSucc) {
                return op;
            }
            var serverOutputData = {
                serviceId: service.id,
                buffer: op.buf
            };
            return this.tsbuffer.encode(serverOutputData, 'ServerOutputData');
        };
        TransportDataUtil.parseServerInput = function (tsbuffer, serviceMap, buf) {
            var opServerInputData = this.tsbuffer.decode(buf, 'ServerInputData');
            if (!opServerInputData.isSucc) {
                return opServerInputData;
            }
            var serverInput = opServerInputData.value;
            var service = serviceMap.id2Service[serverInput.serviceId];
            if (!service) {
                return {
                    isSucc: false,
                    errMsg: "Cannot find service ID: " + serverInput.serviceId
                };
            }
            if (service.type === 'api') {
                var opReq = tsbuffer.decode(serverInput.buffer, service.reqSchemaId);
                return opReq.isSucc ? {
                    isSucc: true,
                    result: {
                        type: 'api',
                        service: service,
                        req: opReq.value,
                        sn: serverInput.sn
                    }
                } : opReq;
            }
            else {
                var opMsg = tsbuffer.decode(serverInput.buffer, service.msgSchemaId);
                return opMsg.isSucc ? {
                    isSucc: true,
                    result: {
                        type: 'msg',
                        service: service,
                        msg: opMsg.value
                    }
                } : opMsg;
            }
        };
        TransportDataUtil.parseServerOutout = function (tsbuffer, serviceMap, buf, serviceId) {
            var opServerOutputData = this.tsbuffer.decode(buf, 'ServerOutputData');
            if (!opServerOutputData.isSucc) {
                return opServerOutputData;
            }
            var serverOutputData = opServerOutputData.value;
            serviceId = serviceId !== null && serviceId !== void 0 ? serviceId : serverOutputData.serviceId;
            if (serviceId === undefined) {
                return {
                    isSucc: false,
                    errMsg: "Missing 'serviceId' in ServerOutput"
                };
            }
            var service = serviceMap.id2Service[serviceId];
            if (!service) {
                return {
                    isSucc: false,
                    errMsg: "Invalid service ID: " + serviceId + " (from ServerOutput)"
                };
            }
            if (service.type === 'msg') {
                if (!serverOutputData.buffer) {
                    return {
                        isSucc: false,
                        errMsg: 'Empty msg buffer (from ServerOutput)'
                    };
                }
                var opMsg = tsbuffer.decode(serverOutputData.buffer, service.msgSchemaId);
                if (!opMsg.isSucc) {
                    return opMsg;
                }
                return {
                    isSucc: true,
                    result: {
                        type: 'msg',
                        service: service,
                        msg: opMsg.value
                    }
                };
            }
            else {
                if (serverOutputData.error) {
                    return {
                        isSucc: true,
                        result: {
                            type: 'api',
                            service: service,
                            sn: serverOutputData.sn,
                            ret: {
                                isSucc: false,
                                err: new TsrpcError(serverOutputData.error)
                            }
                        }
                    };
                }
                else {
                    if (!serverOutputData.buffer) {
                        return {
                            isSucc: false,
                            errMsg: 'Empty API res buffer (from ServerOutput)'
                        };
                    }
                    var opRes = tsbuffer.decode(serverOutputData.buffer, service.resSchemaId);
                    if (!opRes.isSucc) {
                        return opRes;
                    }
                    return {
                        isSucc: true,
                        result: {
                            type: 'api',
                            service: service,
                            sn: serverOutputData.sn,
                            ret: {
                                isSucc: true,
                                res: opRes.value
                            }
                        }
                    };
                }
            }
        };
        return TransportDataUtil;
    }();
    var BaseClient = function () {
        function BaseClient(proto, options) {
            this._msgHandlers = new MsgHandlerManager();
            this.flows = {
                preCallApiFlow: new Flow(),
                preApiReturnFlow: new Flow(),
                postApiReturnFlow: new Flow(),
                preSendMsgFlow: new Flow(),
                postSendMsgFlow: new Flow(),
                preSendBufferFlow: new Flow(),
                preRecvBufferFlow: new Flow(),
                preConnectFlow: new Flow(),
                postConnectFlow: new Flow(),
                postDisconnectFlow: new Flow()
            };
            this._apiSnCounter = new Counter(1);
            this._pendingApis = [];
            this.options = options;
            this.serviceMap = ServiceMapUtil.getServiceMap(proto);
            this.tsbuffer = new TSBuffer(proto.types);
            this.logger = this.options.logger;
        }
        Object.defineProperty(BaseClient.prototype, "lastSN", {
            get: function get() {
                return this._apiSnCounter.last;
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(BaseClient.prototype, "nextSN", {
            get: function get() {
                return this._apiSnCounter.getNext(true);
            },
            enumerable: false,
            configurable: true
        });
        BaseClient.prototype.callApi = function (apiName, req, options) {
            if (options === void 0) {
                options = {};
            }
            return __awaiter$1(this, void 0, void 0, function () {
                var sn, pendingItem, promise;
                var _this = this;
                return __generator$1(this, function (_a) {
                    sn = this._apiSnCounter.getNext();
                    pendingItem = {
                        sn: sn,
                        abortKey: options.abortKey,
                        service: this.serviceMap.apiName2Service[apiName]
                    };
                    this._pendingApis.push(pendingItem);
                    promise = new Promise(function (rs) {
                        return __awaiter$1(_this, void 0, void 0, function () {
                            var pre, ret, preReturn;
                            return __generator$1(this, function (_a) {
                                switch (_a.label) {
                                    case 0:
                                        return [4,
                                            this.flows.preCallApiFlow.exec({
                                                apiName: apiName,
                                                req: req,
                                                options: options
                                            }, this.logger)];
                                    case 1:
                                        pre = _a.sent();
                                        if (!pre || pendingItem.isAborted) {
                                            this.abort(pendingItem.sn);
                                            return [2
                                            ];
                                        }
                                        if (!pre.return)
                                            return [3,
                                                2];
                                        ret = pre.return;
                                        return [3,
                                            4];
                                    case 2:
                                        return [4,
                                            this._doCallApi(pre.apiName, pre.req, pre.options, pendingItem)];
                                    case 3:
                                        ret = _a.sent();
                                        _a.label = 4;
                                    case 4:
                                        if (pendingItem.isAborted) {
                                            return [2
                                            ];
                                        }
                                        return [4,
                                            this.flows.preApiReturnFlow.exec(__assign$1(__assign$1({}, pre), {
                                                return: ret
                                            }), this.logger)];
                                    case 5:
                                        preReturn = _a.sent();
                                        if (!preReturn) {
                                            this.abort(pendingItem.sn);
                                            return [2
                                            ];
                                        }
                                        rs(preReturn.return);
                                        this.flows.postApiReturnFlow.exec(preReturn, this.logger);
                                        return [2
                                        ];
                                }
                            });
                        });
                    });
                    promise.catch().then(function () {
                        _this._pendingApis.removeOne(function (v) {
                            return v.sn === pendingItem.sn;
                        });
                    });
                    return [2,
                        promise];
                });
            });
        };
        BaseClient.prototype._doCallApi = function (apiName, req, options, pendingItem) {
            var _a;
            if (options === void 0) {
                options = {};
            }
            return __awaiter$1(this, void 0, void 0, function () {
                var promise;
                var _this = this;
                return __generator$1(this, function (_b) {
                    (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log("[ApiReq] #" + pendingItem.sn, apiName, req);
                    promise = new Promise(function (rs) {
                        return __awaiter$1(_this, void 0, void 0, function () {
                            var service, opEncode, promiseReturn, promiseSend, opSend, ret;
                            var _a, _b, _c;
                            return __generator$1(this, function (_d) {
                                switch (_d.label) {
                                    case 0:
                                        service = this.serviceMap.apiName2Service[apiName];
                                        if (!service) {
                                            rs({
                                                isSucc: false,
                                                err: new TsrpcError('Invalid api name: ' + apiName, {
                                                    code: 'INVALID_API_NAME',
                                                    type: TsrpcErrorType.ClientError
                                                })
                                            });
                                            return [2
                                            ];
                                        }
                                        pendingItem.service = service;
                                        opEncode = this._encodeApiReq(service, req, pendingItem);
                                        if (!opEncode.isSucc) {
                                            rs({
                                                isSucc: false,
                                                err: new TsrpcError(opEncode.errMsg, {
                                                    type: TsrpcErrorType.ClientError,
                                                    code: 'ENCODE_REQ_ERR'
                                                })
                                            });
                                            return [2
                                            ];
                                        }
                                        promiseReturn = this._waitApiReturn(pendingItem, (_a = options.timeout) !== null && _a !== void 0 ? _a : this.options.timeout);
                                        promiseSend = this._sendBuf(opEncode.buf, options, service.id, pendingItem);
                                        return [4,
                                            promiseSend];
                                    case 1:
                                        opSend = _d.sent();
                                        if (opSend.err) {
                                            rs({
                                                isSucc: false,
                                                err: opSend.err
                                            });
                                            return [2
                                            ];
                                        }
                                        return [4,
                                            promiseReturn];
                                    case 2:
                                        ret = _d.sent();
                                        if (pendingItem.isAborted) {
                                            return [2
                                            ];
                                        }
                                        if (ret.isSucc) {
                                            (_b = this.logger) === null || _b === void 0 ? void 0 : _b.log("[ApiRes] #" + pendingItem.sn + " " + apiName, ret.res);
                                        }
                                        else {
                                            (_c = this.logger) === null || _c === void 0 ? void 0 : _c.log("[ApiErr] #" + pendingItem.sn + " " + apiName, ret.err);
                                        }
                                        rs(ret);
                                        return [2
                                        ];
                                }
                            });
                        });
                    });
                    return [2,
                        promise];
                });
            });
        };
        BaseClient.prototype._encodeApiReq = function (service, req, pendingItem) {
            return TransportDataUtil.encodeApiReq(this.tsbuffer, service, req, this.type === 'LONG' ? pendingItem.sn : undefined);
        };
        BaseClient.prototype.sendMsg = function (msgName, msg, options) {
            var _this = this;
            if (options === void 0) {
                options = {};
            }
            var promise = new Promise(function (rs) {
                return __awaiter$1(_this, void 0, void 0, function () {
                    var pre, service, opEncode, promiseSend, opSend;
                    var _a, _b;
                    return __generator$1(this, function (_c) {
                        switch (_c.label) {
                            case 0:
                                return [4,
                                    this.flows.preSendMsgFlow.exec({
                                        msgName: msgName,
                                        msg: msg,
                                        options: options
                                    }, this.logger)];
                            case 1:
                                pre = _c.sent();
                                if (!pre) {
                                    return [2
                                    ];
                                }
                                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log("[SendMsg]", msgName, msg);
                                service = this.serviceMap.msgName2Service[msgName];
                                if (!service) {
                                    (_b = this.logger) === null || _b === void 0 ? void 0 : _b.error('Invalid msg name: ' + msgName);
                                    rs({
                                        isSucc: false,
                                        err: new TsrpcError('Invalid msg name: ' + msgName, {
                                            code: 'INVALID_MSG_NAME',
                                            type: TsrpcErrorType.ClientError
                                        })
                                    });
                                    return [2
                                    ];
                                }
                                opEncode = this._encodeClientMsg(service, msg);
                                if (!opEncode.isSucc) {
                                    rs({
                                        isSucc: false,
                                        err: new TsrpcError(opEncode.errMsg, {
                                            type: TsrpcErrorType.ClientError,
                                            code: 'ENCODE_MSG_ERR'
                                        })
                                    });
                                    return [2
                                    ];
                                }
                                promiseSend = this._sendBuf(opEncode.buf, options, service.id);
                                return [4,
                                    promiseSend];
                            case 2:
                                opSend = _c.sent();
                                if (opSend.err) {
                                    rs({
                                        isSucc: false,
                                        err: opSend.err
                                    });
                                    return [2
                                    ];
                                }
                                rs({
                                    isSucc: true
                                });
                                this.flows.postSendMsgFlow.exec(pre, this.logger);
                                return [2
                                ];
                        }
                    });
                });
            });
            return promise;
        };
        BaseClient.prototype._encodeClientMsg = function (service, msg) {
            return TransportDataUtil.encodeClientMsg(this.tsbuffer, service, msg);
        };
        BaseClient.prototype.listenMsg = function (msgName, handler) {
            this._msgHandlers.addHandler(msgName, handler);
            return handler;
        };
        BaseClient.prototype.unlistenMsg = function (msgName, handler) {
            this._msgHandlers.removeHandler(msgName, handler);
        };
        BaseClient.prototype.unlistenMsgAll = function (msgName) {
            this._msgHandlers.removeAllHandlers(msgName);
        };
        BaseClient.prototype.abort = function (sn) {
            var _a, _b;
            var index = this._pendingApis.findIndex(function (v) {
                return v.sn === sn;
            });
            if (index === -1) {
                return;
            }
            var pendingItem = this._pendingApis[index];
            this._pendingApis.splice(index, 1);
            pendingItem.onReturn = undefined;
            pendingItem.isAborted = true;
            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log("[ApiAbort] #" + pendingItem.sn + " " + pendingItem.service.name);
            (_b = pendingItem.onAbort) === null || _b === void 0 ? void 0 : _b.call(pendingItem);
        };
        BaseClient.prototype.abortByKey = function (abortKey) {
            var _this = this;
            this._pendingApis.filter(function (v) {
                return v.abortKey === abortKey;
            }).forEach(function (v) {
                _this.abort(v.sn);
            });
        };
        BaseClient.prototype.abortAll = function () {
            var _this = this;
            this._pendingApis.slice().forEach(function (v) {
                return _this.abort(v.sn);
            });
        };
        BaseClient.prototype._onRecvBuf = function (buf, pendingApiItem) {
            var _a, _b, _c, _d, _e, _f, _g;
            return __awaiter$1(this, void 0, void 0, function () {
                var sn, pre, opParsed, parsed;
                return __generator$1(this, function (_h) {
                    switch (_h.label) {
                        case 0:
                            sn = pendingApiItem === null || pendingApiItem === void 0 ? void 0 : pendingApiItem.sn;
                            this.options.debugBuf && ((_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug('[RecvBuf]' + (sn ? ' #' + sn : ''), 'length=' + buf.length, buf));
                            return [4,
                                this.flows.preRecvBufferFlow.exec({
                                    buf: buf,
                                    sn: sn
                                }, this.logger)];
                        case 1:
                            pre = _h.sent();
                            if (!pre) {
                                return [2
                                ];
                            }
                            buf = pre.buf;
                            opParsed = TransportDataUtil.parseServerOutout(this.tsbuffer, this.serviceMap, buf, pendingApiItem === null || pendingApiItem === void 0 ? void 0 : pendingApiItem.service.id);
                            if (opParsed.isSucc) {
                                parsed = opParsed.result;
                                if (parsed.type === 'api') {
                                    sn = sn !== null && sn !== void 0 ? sn : parsed.sn;
                                    (_c = (_b = this._pendingApis.find(function (v) {
                                        return v.sn === sn;
                                    })) === null || _b === void 0 ? void 0 : _b.onReturn) === null || _c === void 0 ? void 0 : _c.call(_b, parsed.ret);
                                }
                                else if (parsed.type === 'msg') {
                                    (_d = this.logger) === null || _d === void 0 ? void 0 : _d.log("[RecvMsg] " + parsed.service.name, parsed.msg);
                                    this._msgHandlers.forEachHandler(parsed.service.name, this.logger, parsed.msg, this);
                                }
                            }
                            else {
                                (_e = this.logger) === null || _e === void 0 ? void 0 : _e.error('ParseServerOutputError: ' + opParsed.errMsg);
                                (_f = this.logger) === null || _f === void 0 ? void 0 : _f.error('Please check whether the proto on the server is the same as that on the client');
                                if (pendingApiItem) {
                                    (_g = pendingApiItem.onReturn) === null || _g === void 0 ? void 0 : _g.call(pendingApiItem, {
                                        isSucc: false,
                                        err: new TsrpcError('Parse server output error', {
                                            type: TsrpcErrorType.ServerError
                                        })
                                    });
                                }
                            }
                            return [2
                            ];
                    }
                });
            });
        };
        BaseClient.prototype._waitApiReturn = function (pendingItem, timeout) {
            return __awaiter$1(this, void 0, void 0, function () {
                var _this = this;
                return __generator$1(this, function (_a) {
                    return [2,
                        new Promise(function (rs) {
                            var timer;
                            if (timeout) {
                                timer = setTimeout(function () {
                                    timer = undefined;
                                    _this._pendingApis.removeOne(function (v) {
                                        return v.sn === pendingItem.sn;
                                    });
                                    rs({
                                        isSucc: false,
                                        err: new TsrpcError('Request Timeout', {
                                            type: TsrpcErrorType.NetworkError,
                                            code: 'TIMEOUT'
                                        })
                                    });
                                }, timeout);
                            }
                            pendingItem.onReturn = function (ret) {
                                if (timer) {
                                    clearTimeout(timer);
                                    timer = undefined;
                                }
                                _this._pendingApis.removeOne(function (v) {
                                    return v.sn === pendingItem.sn;
                                });
                                rs(ret);
                            };
                        })];
                });
            });
        };
        return BaseClient;
    }();
    var defaultBaseClientOptions = {};
    var BaseHttpClient = function (_super) {
        __extends$1(BaseHttpClient, _super);
        function BaseHttpClient(proto, http, options) {
            var _a;
            var _this = _super.call(this, proto, __assign$1(__assign$1({}, defaultBaseHttpClientOptions), options)) || this;
            _this.type = 'SHORT';
            _this._http = http;
            _this._jsonServer = _this.options.server + (_this.options.server.endsWith('/') ? '' : '/');
            (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.log('TSRPC HTTP Client :', _this.options.server);
            return _this;
        }
        BaseHttpClient.prototype._encodeApiReq = function (service, req, pendingItem) {
            if (this.options.json) {
                if (this.options.jsonPrune) {
                    var opPrune = this.tsbuffer.prune(req, pendingItem.service.reqSchemaId);
                    if (!opPrune.isSucc) {
                        return opPrune;
                    }
                    req = opPrune.pruneOutput;
                }
                return {
                    isSucc: true,
                    buf: JSON.stringify(req)
                };
            }
            else {
                return TransportDataUtil.encodeApiReq(this.tsbuffer, service, req, undefined);
            }
        };
        BaseHttpClient.prototype._encodeClientMsg = function (service, msg) {
            if (this.options.json) {
                if (this.options.jsonPrune) {
                    var opPrune = this.tsbuffer.prune(msg, service.msgSchemaId);
                    if (!opPrune.isSucc) {
                        return opPrune;
                    }
                    msg = opPrune.pruneOutput;
                }
                return {
                    isSucc: true,
                    buf: JSON.stringify(msg)
                };
            }
            else {
                return TransportDataUtil.encodeClientMsg(this.tsbuffer, service, msg);
            }
        };
        BaseHttpClient.prototype._sendBuf = function (buf, options, serviceId, pendingApiItem) {
            return __awaiter$1(this, void 0, void 0, function () {
                var sn, promise;
                var _this = this;
                return __generator$1(this, function (_a) {
                    if (this.options.json) {
                        return [2,
                            this._sendJSON(buf, options, serviceId, pendingApiItem)];
                    }
                    sn = pendingApiItem === null || pendingApiItem === void 0 ? void 0 : pendingApiItem.sn;
                    promise = new Promise(function (rs) {
                        return __awaiter$1(_this, void 0, void 0, function () {
                            var pre, _a, fetchPromise, abort, fetchRes;
                            var _b;
                            return __generator$1(this, function (_c) {
                                switch (_c.label) {
                                    case 0:
                                        return [4,
                                            this.flows.preSendBufferFlow.exec({
                                                buf: buf,
                                                sn: pendingApiItem === null || pendingApiItem === void 0 ? void 0 : pendingApiItem.sn
                                            }, this.logger)];
                                    case 1:
                                        pre = _c.sent();
                                        if (!pre) {
                                            return [2
                                            ];
                                        }
                                        buf = pre.buf;
                                        this.options.debugBuf && ((_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug('[SendBuf]' + (sn ? ' #' + sn : ''), "length=" + buf.length, buf));
                                        _a = this._http.fetch({
                                            url: this.options.server,
                                            data: buf,
                                            method: 'POST',
                                            timeout: options.timeout || this.options.timeout,
                                            transportOptions: options,
                                            responseType: 'arraybuffer'
                                        }), fetchPromise = _a.promise, abort = _a.abort;
                                        if (pendingApiItem) {
                                            pendingApiItem.onAbort = function () {
                                                abort();
                                            };
                                        }
                                        if (pendingApiItem === null || pendingApiItem === void 0 ? void 0 : pendingApiItem.isAborted) {
                                            return [2
                                            ];
                                        }
                                        return [4,
                                            fetchPromise];
                                    case 2:
                                        fetchRes = _c.sent();
                                        if (!fetchRes.isSucc) {
                                            rs({
                                                err: fetchRes.err
                                            });
                                            return [2
                                            ];
                                        }
                                        rs({});
                                        this._onRecvBuf(fetchRes.res, pendingApiItem);
                                        return [2
                                        ];
                                }
                            });
                        });
                    });
                    promise.catch(function (e) { }).then(function () {
                        if (pendingApiItem) {
                            pendingApiItem.onAbort = undefined;
                        }
                    });
                    return [2,
                        promise];
                });
            });
        };
        BaseHttpClient.prototype._sendJSON = function (jsonStr, options, serviceId, pendingApiItem) {
            return __awaiter$1(this, void 0, void 0, function () {
                var _this = this;
                return __generator$1(this, function (_a) {
                    return [2,
                        new Promise(function (rs) {
                            return __awaiter$1(_this, void 0, void 0, function () {
                                var _a, fetchPromise, abort, fetchRes, ret, opPrune;
                                var _b;
                                return __generator$1(this, function (_c) {
                                    switch (_c.label) {
                                        case 0:
                                            _a = this._http.fetch({
                                                url: this._jsonServer + this.serviceMap.id2Service[serviceId].name,
                                                data: jsonStr,
                                                method: 'POST',
                                                timeout: options.timeout || this.options.timeout,
                                                headers: {
                                                    'Content-Type': 'application/json'
                                                },
                                                transportOptions: options,
                                                responseType: 'text'
                                            }), fetchPromise = _a.promise, abort = _a.abort;
                                            if (pendingApiItem) {
                                                pendingApiItem.onAbort = function () {
                                                    abort();
                                                };
                                            }
                                            if (pendingApiItem === null || pendingApiItem === void 0 ? void 0 : pendingApiItem.isAborted) {
                                                return [2
                                                ];
                                            }
                                            return [4,
                                                fetchPromise];
                                        case 1:
                                            fetchRes = _c.sent();
                                            if (!fetchRes.isSucc) {
                                                rs({
                                                    err: fetchRes.err
                                                });
                                                return [2
                                                ];
                                            }
                                            rs({});
                                            try {
                                                ret = JSON.parse(fetchRes.res);
                                            }
                                            catch (e) {
                                                ret = {
                                                    isSucc: false,
                                                    err: new TsrpcError({
                                                        message: e.message,
                                                        type: TsrpcError.Type.ServerError,
                                                        res: fetchRes.res
                                                    })
                                                };
                                            }
                                            if (pendingApiItem) {
                                                if (ret.isSucc) {
                                                    if (this.options.jsonPrune) {
                                                        opPrune = this.tsbuffer.prune(ret.res, pendingApiItem.service.resSchemaId);
                                                        if (opPrune.isSucc) {
                                                            ret.res = opPrune.pruneOutput;
                                                        }
                                                        else {
                                                            ret = {
                                                                isSucc: false,
                                                                err: new TsrpcError('Invalid Server Output', {
                                                                    type: TsrpcError.Type.ClientError,
                                                                    innerErr: opPrune.errMsg
                                                                })
                                                            };
                                                        }
                                                    }
                                                }
                                                else {
                                                    ret.err = new TsrpcError(ret.err);
                                                }
                                                (_b = pendingApiItem.onReturn) === null || _b === void 0 ? void 0 : _b.call(pendingApiItem, ret);
                                            }
                                            return [2
                                            ];
                                    }
                                });
                            });
                        })];
                });
            });
        };
        return BaseHttpClient;
    }(BaseClient);
    var defaultBaseHttpClientOptions = __assign$1(__assign$1({}, defaultBaseClientOptions), {
        server: 'http://localhost:3000',
        json: false,
        jsonPrune: true
    });
    var BaseWsClient = function (_super) {
        __extends$1(BaseWsClient, _super);
        function BaseWsClient(proto, wsp, options) {
            var _a;
            var _this = _super.call(this, proto, __assign$1(__assign$1({}, defaultBaseWsClientOptions), options)) || this;
            _this.type = 'LONG';
            _this._onWsOpen = function () {
                var _a;
                if (!_this._connecting) {
                    return;
                }
                _this._status = WsClientStatus.Opened;
                _this._connecting.rs({
                    isSucc: true
                });
                _this._connecting = undefined;
                (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.log('WebSocket connection to server successful');
                _this.flows.postConnectFlow.exec({}, _this.logger);
            };
            _this._onWsClose = function (code, reason) {
                var _a, _b;
                var isConnectedBefore = _this.isConnected;
                _this._status = WsClientStatus.Closed;
                if (_this._connecting) {
                    _this._connecting.rs({
                        isSucc: false,
                        errMsg: 'WebSocket connection to server failed'
                    });
                    _this._connecting = undefined;
                }
                var isManual = !!_this._rsDisconnecting;
                if (_this._rsDisconnecting) {
                    _this._rsDisconnecting();
                    _this._rsDisconnecting = undefined;
                    (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.log('Disconnected succ', "code=" + code + " reason=" + reason);
                }
                else if (isConnectedBefore) {
                    (_b = _this.logger) === null || _b === void 0 ? void 0 : _b.log("Lost connection to " + _this.options.server, "code=" + code + " reason=" + reason);
                }
                if (isConnectedBefore) {
                    _this.flows.postDisconnectFlow.exec({
                        reason: reason,
                        isManual: isManual
                    }, _this.logger);
                }
            };
            _this._onWsError = function (e) {
                var _a;
                (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.error('[WebSocket Error]', e);
            };
            _this._onWsMessage = function (data) {
                var _a;
                if (typeof data === 'string') {
                    (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.warn('[RecvText]', data);
                }
                else {
                    _this._onRecvBuf(data);
                }
            };
            _this._status = WsClientStatus.Closed;
            _this._wsp = wsp;
            wsp.options = {
                onOpen: _this._onWsOpen,
                onClose: _this._onWsClose,
                onError: _this._onWsError,
                onMessage: _this._onWsMessage,
                logger: _this.logger
            };
            (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.log('TSRPC WebSocket Client :', _this.options.server);
            return _this;
        }
        BaseWsClient.prototype._sendBuf = function (buf, options, serviceId, pendingApiItem) {
            return __awaiter$1(this, void 0, void 0, function () {
                var _this = this;
                return __generator$1(this, function (_a) {
                    return [2,
                        new Promise(function (rs) {
                            return __awaiter$1(_this, void 0, void 0, function () {
                                var pre;
                                var _a;
                                return __generator$1(this, function (_b) {
                                    switch (_b.label) {
                                        case 0:
                                            return [4,
                                                this.flows.preSendBufferFlow.exec({
                                                    buf: buf,
                                                    sn: pendingApiItem === null || pendingApiItem === void 0 ? void 0 : pendingApiItem.sn
                                                }, this.logger)];
                                        case 1:
                                            pre = _b.sent();
                                            if (!pre) {
                                                return [2
                                                ];
                                            }
                                            buf = pre.buf;
                                            if (!this.isConnected) {
                                                rs({
                                                    err: new TsrpcError('WebSocket is not connected', {
                                                        code: 'WS_NOT_OPEN',
                                                        type: TsrpcError.Type.ClientError
                                                    })
                                                });
                                                return [2
                                                ];
                                            }
                                            if (this.options.debugBuf && buf instanceof Uint8Array) {
                                                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug('[SendBuf]' + (pendingApiItem ? ' #' + pendingApiItem.sn : ''), "length=" + buf.byteLength, buf);
                                            }
                                            rs(this._wsp.send(buf));
                                            return [2
                                            ];
                                    }
                                });
                            });
                        })];
                });
            });
        };
        Object.defineProperty(BaseWsClient.prototype, "status", {
            get: function get() {
                return this._status;
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(BaseWsClient.prototype, "isConnected", {
            get: function get() {
                return this._status === WsClientStatus.Opened;
            },
            enumerable: false,
            configurable: true
        });
        BaseWsClient.prototype.connect = function () {
            var _a;
            return __awaiter$1(this, void 0, void 0, function () {
                var pre, promiseConnect;
                var _this = this;
                return __generator$1(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            if (this.isConnected) {
                                return [2,
                                    {
                                        isSucc: true
                                    }];
                            }
                            if (this._connecting) {
                                return [2,
                                    this._connecting.promise];
                            }
                            return [4,
                                this.flows.preConnectFlow.exec({}, this.logger)];
                        case 1:
                            pre = _b.sent();
                            if (pre === null || pre === void 0 ? void 0 : pre.return) {
                                return [2,
                                    pre.return];
                            }
                            if (!pre) {
                                return [2,
                                    new Promise(function (rs) { })];
                            }
                            try {
                                this._wsp.connect(this.options.server);
                            }
                            catch (e) {
                                return [2,
                                    {
                                        isSucc: false,
                                        errMsg: e.message
                                    }];
                            }
                            this._status = WsClientStatus.Opening;
                            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log("Start connecting " + this.options.server + "...");
                            this._connecting = {};
                            promiseConnect = new Promise(function (rs) {
                                _this._connecting.rs = rs;
                            });
                            this._connecting.promise = promiseConnect;
                            return [2,
                                promiseConnect];
                    }
                });
            });
        };
        BaseWsClient.prototype.disconnect = function (code, reason) {
            var _a;
            return __awaiter$1(this, void 0, void 0, function () {
                var _this = this;
                return __generator$1(this, function (_b) {
                    if (this._status === WsClientStatus.Closed) {
                        return [2
                        ];
                    }
                    this._status = WsClientStatus.Closing;
                    (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log('Start disconnecting...');
                    return [2,
                        new Promise(function (rs) {
                            _this._rsDisconnecting = rs;
                            _this._wsp.close(code, reason);
                        })];
                });
            });
        };
        return BaseWsClient;
    }(BaseClient);
    var defaultBaseWsClientOptions = __assign$1(__assign$1({}, defaultBaseClientOptions), {
        server: 'ws://localhost:3000'
    });
    var WsClientStatus;
    (function (WsClientStatus) {
        WsClientStatus["Opening"] = "OPENING";
        WsClientStatus["Opened"] = "OPENED";
        WsClientStatus["Closing"] = "CLOSING";
        WsClientStatus["Closed"] = "CLOSED";
    })(WsClientStatus || (WsClientStatus = {}));
    var HttpProxy = (function () {
        function HttpProxy() {
        }
        HttpProxy.prototype.fetch = function (options) {
            var _this = this;
            var rs;
            var promise = new Promise(function (_rs) {
                rs = _rs;
            });
            var xhr = new XMLHttpRequest();
            if (navigator.userAgent.indexOf('MSIE 8.0;') > -1) {
                xhr.onreadystatechange = function () {
                    return __awaiter$1(_this, void 0, void 0, function () {
                        return __generator$1(this, function (_a) {
                            if (xhr.readyState == 4) {
                                if (xhr.status == 0 || (xhr.response == null && xhr.responseText == null)) {
                                    rs({
                                        isSucc: false,
                                        err: new TsrpcError('Network Error', {
                                            type: TsrpcError.Type.NetworkError,
                                            httpCode: xhr.status
                                        })
                                    });
                                    return [2];
                                }
                                if (xhr.status == 12029) {
                                    rs({
                                        isSucc: false,
                                        err: new TsrpcError({
                                            message: 'Network Error',
                                            type: TsrpcError.Type.NetworkError,
                                            httpCode: xhr.status
                                        })
                                    });
                                    return [2];
                                }
                                rs({
                                    isSucc: true,
                                    res: options.responseType === 'text' ? xhr.responseText : new Uint8Array(xhr.response)
                                });
                            }
                            return [2];
                        });
                    });
                };
            }
            else {
                xhr.onerror = function () {
                    rs({
                        isSucc: false,
                        err: new TsrpcError({
                            message: 'Network Error',
                            type: TsrpcError.Type.NetworkError,
                            httpCode: xhr.status
                        })
                    });
                };
                xhr.ontimeout = function () {
                    rs({
                        isSucc: false,
                        err: new TsrpcError({
                            message: 'Request Timeout',
                            type: TsrpcError.Type.NetworkError,
                            code: 'TIMEOUT'
                        })
                    });
                };
                xhr.onload = function () {
                    return __awaiter$1(_this, void 0, void 0, function () {
                        return __generator$1(this, function (_a) {
                            rs({
                                isSucc: true,
                                res: xhr.response && (options.responseType === 'text' ? xhr.responseText : new Uint8Array(xhr.response))
                            });
                            return [2];
                        });
                    });
                };
                var transportOptions_1 = options.transportOptions;
                if (!!transportOptions_1.onProgress) {
                    xhr.upload.onprogress = function (e) {
                        var _a;
                        (_a = transportOptions_1.onProgress) === null || _a === void 0 ? void 0 : _a.call(transportOptions_1, e.loaded / e.total);
                    };
                }
            }
            xhr.open(options.method, options.url, true);
            if (options.headers) {
                for (var key in options.headers) {
                    xhr.setRequestHeader(key, options.headers[key]);
                }
            }
            xhr.responseType = options.responseType;
            var timeout = options.timeout;
            if (timeout) {
                xhr.timeout = timeout;
            }
            xhr.send(options.data);
            var abort = xhr.abort.bind(xhr);
            return {
                promise: promise,
                abort: abort
            };
        };
        return HttpProxy;
    }());
    var HttpClient = (function (_super) {
        __extends$1(HttpClient, _super);
        function HttpClient(proto, options) {
            var _this = this;
            var httpProxy = new HttpProxy;
            _this = _super.call(this, proto, httpProxy, __assign$1(__assign$1({}, defaultHttpClientOptions), options)) || this;
            return _this;
        }
        HttpClient.prototype.callApi = function (apiName, req, options) {
            if (options === void 0) {
                options = {};
            }
            return _super.prototype.callApi.call(this, apiName, req, options);
        };
        HttpClient.prototype.sendMsg = function (msgName, msg, options) {
            if (options === void 0) {
                options = {};
            }
            return _super.prototype.sendMsg.call(this, msgName, msg, options);
        };
        return HttpClient;
    }(BaseHttpClient));
    var defaultHttpClientOptions = __assign$1({}, defaultBaseHttpClientOptions);
    var WebSocketProxy = (function () {
        function WebSocketProxy() {
        }
        WebSocketProxy.prototype.connect = function (server) {
            var _this = this;
            this._ws = new WebSocket(server);
            this._ws.binaryType = 'arraybuffer';
            this._ws.onopen = this.options.onOpen;
            this._ws.onclose = function (e) {
                _this.options.onClose(e.code, e.reason);
                _this._ws = undefined;
            };
            this._ws.onmessage = function (e) {
                var _a;
                if (e.data instanceof ArrayBuffer) {
                    _this.options.onMessage(new Uint8Array(e.data));
                }
                else if (typeof e.data === 'string') {
                    _this.options.onMessage(e.data);
                }
                else {
                    (_a = _this.options.logger) === null || _a === void 0 ? void 0 : _a.warn('[Unresolved Recv]', e.data);
                }
            };
        };
        WebSocketProxy.prototype.close = function (code, reason) {
            var _a;
            (_a = this._ws) === null || _a === void 0 ? void 0 : _a.close(code, reason);
            this._ws = undefined;
        };
        WebSocketProxy.prototype.send = function (data) {
            return __awaiter$1(this, void 0, void 0, function () {
                var sendData, buf;
                return __generator$1(this, function (_a) {
                    try {
                        sendData = void 0;
                        if (typeof data === 'string') {
                            sendData = data;
                        }
                        else {
                            buf = data;
                            if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
                                sendData = buf.buffer;
                            }
                            else {
                                sendData = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
                            }
                        }
                        this._ws.send(sendData);
                        return [2, {}];
                    }
                    catch (err) {
                        return [2, {
                                err: new TsrpcError('Network Error', {
                                    code: 'SEND_BUF_ERR',
                                    type: TsrpcError.Type.NetworkError,
                                    innerErr: err
                                })
                            }];
                    }
                    return [2];
                });
            });
        };
        return WebSocketProxy;
    }());
    var WsClient = (function (_super) {
        __extends$1(WsClient, _super);
        function WsClient(proto, options) {
            var _this = this;
            var wsp = new WebSocketProxy();
            _this = _super.call(this, proto, wsp, __assign$1(__assign$1({}, defaultWsClientOptions), options)) || this;
            return _this;
        }
        return WsClient;
    }(BaseWsClient));
    var defaultWsClientOptions = __assign$1({}, defaultBaseWsClientOptions);

    let client = new HttpClient(serviceProto, {
        server: 'http://localhost:3000',
        logger: console
    });
    function test() {
        return __awaiter(this, void 0, void 0, function* () {
            yield client.callApi('AddData', {
                content: 'AAAAA'
            });
            let ret = yield client.callApi('GetData', {});
            console.log('ret', ret);
        });
    }
    test();
    class Main {
        constructor() {
            if (window["Laya3D"])
                Laya3D.init(GameConfig.width, GameConfig.height);
            else
                Laya.init(GameConfig.width, GameConfig.height, Laya["WebGL"]);
            Laya["Physics"] && Laya["Physics"].enable();
            Laya["DebugPanel"] && Laya["DebugPanel"].enable();
            Laya.stage.scaleMode = GameConfig.scaleMode;
            Laya.stage.screenMode = GameConfig.screenMode;
            Laya.stage.alignV = GameConfig.alignV;
            Laya.stage.alignH = GameConfig.alignH;
            Laya.URL.exportSceneToJson = GameConfig.exportSceneToJson;
            if (GameConfig.debug || Laya.Utils.getQueryString("debug") == "true")
                Laya.enableDebugPanel();
            if (GameConfig.physicsDebug && Laya["PhysicsDebugDraw"])
                Laya["PhysicsDebugDraw"].enable();
            if (GameConfig.stat)
                Laya.Stat.show();
            Laya.alertGlobalError(true);
            Laya.ResourceVersion.enable("version.json", Laya.Handler.create(this, this.onVersionLoaded), Laya.ResourceVersion.FILENAME_VERSION);
        }
        onVersionLoaded() {
            Laya.AtlasInfoManager.enable("fileconfig.json", Laya.Handler.create(this, this.onConfigLoaded));
        }
        onConfigLoaded() {
            GameConfig.startScene && Laya.Scene.open(GameConfig.startScene);
        }
    }
    new Main();

}());