@revues/web-sdk-core 0.0.1-beta.10

package/dist/web-sdk-core.js

@@ -0,0 +1,1999 @@
+/*!
+ * @revues/web-sdk-core 
+ * (c) 2024-2024 Alex
+ * Released under the MIT License.
+ */
+(function (factory) {
+    typeof define === 'function' && define.amd ? define(factory) :
+    factory();
+})((function () { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* 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 (Object.prototype.hasOwnProperty.call(b, 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 __awaiter(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(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 __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+
+    function getSystem() {
+        var e = window.navigator.userAgent.toLowerCase();
+        return /(iphone|ipad)/.test(e)
+            ? 'IOS'
+            : /android/.test(e)
+                ? 'Android'
+                : 'Windows For HUYA';
+    }
+    function resolveUrl(url) {
+        var _a = url.split('?'), path = _a[0], queryStr = _a[1];
+        var query = {};
+        if (queryStr != null && queryStr !== '') {
+            queryStr.split('&').reduce(function (acc, item) {
+                var kv = item.split('=');
+                acc[kv[0]] = decodeURIComponent(kv[1]);
+                return acc;
+            }, query);
+        }
+        return {
+            path: path,
+            query: query
+        };
+    }
+    function arrayBufferToBase64(buffer) {
+        var binary = '';
+        var bytes = new Uint8Array(buffer);
+        var len = bytes.byteLength;
+        for (var i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return window.btoa(binary);
+    }
+    function delay(duration) {
+        return new Promise(function (resolve) {
+            setTimeout(resolve, duration);
+        });
+    }
+    var promiseTimeout = function (ms, promise, handleTimeout) {
+        var id;
+        // Create a promise that rejects in <ms> milliseconds
+        var timeout = new Promise(function (resolve, reject) {
+            id = setTimeout(function () {
+                handleTimeout && handleTimeout(ms);
+                reject(new Error('Timed out in ' + ms + 'ms.'));
+            }, ms);
+        });
+        // Returns a race between our timeout and the passed in promise
+        return new Promise(function (resolve, reject) {
+            Promise.race([
+                promise,
+                timeout
+            ]).then(function (res) {
+                clearTimeout(id);
+                resolve(res);
+            }).catch(reject);
+        });
+    };
+    function formatPagePath(v) {
+        return v.replace(/\.html$/, '');
+    }
+
+    var basePath = location.protocol + '//' + location.host + location.pathname.replace(/index\.html$/, '');
+    // 视图层逻辑模版
+    var viewTemplatePath = basePath + 'view.html';
+    // 先开着
+    var debug = window.__debug != null ? window.__debug : true;
+    var Terminal = {
+        Service: 'service',
+        View: 'view'
+    };
+    var packageExtConfig = window.__packageExtConfig;
+    var launchOption = {
+        path: packageExtConfig ? packageExtConfig.entryPagePath : 'index',
+        query: {},
+        referrerInfo: {},
+        scene: 1001
+    };
+    var onLoadSubPackageTaskStateChange = 'onLoadSubPackageTaskStateChange';
+    var onTaskProgressUpdate = 'onTaskProgressUpdate';
+    var onTaskHeadersReceived = 'onTaskHeadersReceived';
+    var miniGame = 'miniGame';
+    var miniProgram = 'miniProgram';
+    var localPathPerfix = 'finfile://';
+    var imgSets = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.mp4', '.mp3']);
+
+    function requestSource(url, opts, cb) {
+        var xhr = new XMLHttpRequest();
+        var asyncRequest = true;
+        if (opts.sync != null) {
+            asyncRequest = !opts.sync;
+        }
+        if (opts.responseType != null) {
+            xhr.responseType = opts.responseType;
+        }
+        xhr.open('GET', url, asyncRequest);
+        if (opts.header != null) {
+            for (var key in opts.header) {
+                xhr.setRequestHeader(key, opts.header[key]);
+            }
+        }
+        xhr.onload = function (e) {
+            cb(null, xhr.response, { e: e, xhr: xhr });
+        };
+        xhr.onerror = function (e) {
+            cb(new Error('request settings failed!'), null, { e: e, xhr: xhr });
+        };
+        xhr.send(null);
+    }
+    function processFilePath(file) {
+        // TODO: 需要判断同域同源才处理
+        if (file.endsWith('.wasm')) {
+            return file + '.txt';
+        }
+        return file;
+    }
+    var cache = {};
+    function cacheRequest(url, opts, cb) {
+        if (cache[url] != null) {
+            return cache[url];
+        }
+        requestSource(url, opts, function (err, data, eventInfo) {
+            if (err !== null) {
+                cache[url] = data;
+            }
+            cb(err, data, eventInfo);
+        });
+    }
+
+    function createCommonjsModule(fn, basedir, module) {
+    	return module = {
+    	  path: basedir,
+    	  exports: {},
+    	  require: function (path, base) {
+          return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+        }
+    	}, fn(module, module.exports), module.exports;
+    }
+
+    function commonjsRequire () {
+    	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+    }
+
+    var eventemitter3 = createCommonjsModule(function (module) {
+
+    var has = Object.prototype.hasOwnProperty
+      , prefix = '~';
+
+    /**
+     * Constructor to create a storage for our `EE` objects.
+     * An `Events` instance is a plain object whose properties are event names.
+     *
+     * @constructor
+     * @private
+     */
+    function Events() {}
+
+    //
+    // We try to not inherit from `Object.prototype`. In some engines creating an
+    // instance in this way is faster than calling `Object.create(null)` directly.
+    // If `Object.create(null)` is not supported we prefix the event names with a
+    // character to make sure that the built-in object properties are not
+    // overridden or used as an attack vector.
+    //
+    if (Object.create) {
+      Events.prototype = Object.create(null);
+
+      //
+      // This hack is needed because the `__proto__` property is still inherited in
+      // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+      //
+      if (!new Events().__proto__) prefix = false;
+    }
+
+    /**
+     * Representation of a single event listener.
+     *
+     * @param {Function} fn The listener function.
+     * @param {*} context The context to invoke the listener with.
+     * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+     * @constructor
+     * @private
+     */
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+
+    /**
+     * Add a listener for a given event.
+     *
+     * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} context The context to invoke the listener with.
+     * @param {Boolean} once Specify if the listener is a one-time listener.
+     * @returns {EventEmitter}
+     * @private
+     */
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== 'function') {
+        throw new TypeError('The listener must be a function');
+      }
+
+      var listener = new EE(fn, context || emitter, once)
+        , evt = prefix ? prefix + event : event;
+
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+
+      return emitter;
+    }
+
+    /**
+     * Clear event by name.
+     *
+     * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+     * @param {(String|Symbol)} evt The Event name.
+     * @private
+     */
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+
+    /**
+     * Minimal `EventEmitter` interface that is molded against the Node.js
+     * `EventEmitter` interface.
+     *
+     * @constructor
+     * @public
+     */
+    function EventEmitter() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+
+    /**
+     * Return an array listing the events for which the emitter has registered
+     * listeners.
+     *
+     * @returns {Array}
+     * @public
+     */
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = []
+        , events
+        , name;
+
+      if (this._eventsCount === 0) return names;
+
+      for (name in (events = this._events)) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+
+      return names;
+    };
+
+    /**
+     * Return the listeners registered for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Array} The registered listeners.
+     * @public
+     */
+    EventEmitter.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event
+        , handlers = this._events[evt];
+
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+
+      return ee;
+    };
+
+    /**
+     * Return the number of listeners listening to a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Number} The number of listeners.
+     * @public
+     */
+    EventEmitter.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event
+        , listeners = this._events[evt];
+
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+
+    /**
+     * Calls each of the listeners registered for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Boolean} `true` if the event had listeners, else `false`.
+     * @public
+     */
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+
+      if (!this._events[evt]) return false;
+
+      var listeners = this._events[evt]
+        , len = arguments.length
+        , args
+        , i;
+
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+        switch (len) {
+          case 1: return listeners.fn.call(listeners.context), true;
+          case 2: return listeners.fn.call(listeners.context, a1), true;
+          case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+
+        for (i = 1, args = new Array(len -1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length
+          , j;
+
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+          switch (len) {
+            case 1: listeners[i].fn.call(listeners[i].context); break;
+            case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+            case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+            case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+            default:
+              if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+
+      return true;
+    };
+
+    /**
+     * Add a listener for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} [context=this] The context to invoke the listener with.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+
+    /**
+     * Add a one-time listener for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} [context=this] The context to invoke the listener with.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+
+    /**
+     * Remove the listeners of a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn Only remove the listeners that match this function.
+     * @param {*} context Only remove the listeners that have this context.
+     * @param {Boolean} once Only remove one-time listeners.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+
+      var listeners = this._events[evt];
+
+      if (listeners.fn) {
+        if (
+          listeners.fn === fn &&
+          (!once || listeners.once) &&
+          (!context || listeners.context === context)
+        ) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (
+            listeners[i].fn !== fn ||
+            (once && !listeners[i].once) ||
+            (context && listeners[i].context !== context)
+          ) {
+            events.push(listeners[i]);
+          }
+        }
+
+        //
+        // Reset the array, or remove it completely if we have no more listeners.
+        //
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+
+      return this;
+    };
+
+    /**
+     * Remove all listeners, or those of the specified event.
+     *
+     * @param {(String|Symbol)} [event] The event name.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+
+      return this;
+    };
+
+    //
+    // Alias methods names because people roll like that.
+    //
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+    //
+    // Expose the prefix.
+    //
+    EventEmitter.prefixed = prefix;
+
+    //
+    // Allow `EventEmitter` to be imported as module namespace.
+    //
+    EventEmitter.EventEmitter = EventEmitter;
+
+    //
+    // Expose the module.
+    //
+    {
+      module.exports = EventEmitter;
+    }
+    });
+
+    var IframeManager = /** @class */ (function () {
+        function IframeManager(el) {
+            this.sync = false;
+            this.events = new eventemitter3();
+            this.el = el;
+            this.isReady = false;
+        }
+        IframeManager.prototype.getWindow = function () {
+            return this.el.contentWindow;
+        };
+        IframeManager.prototype.getBridge = function () { };
+        IframeManager.prototype.emitSync = function (event) {
+            var _a;
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            this.sync = true;
+            (_a = this.events).emit.apply(_a, __spreadArrays([event], args));
+            this.sync = false;
+        };
+        return IframeManager;
+    }());
+
+    var ViewIframeManager = /** @class */ (function (_super) {
+        __extends(ViewIframeManager, _super);
+        function ViewIframeManager(e) {
+            var _this = _super.call(this, e) || this;
+            _this.webviewId = null;
+            _this.pagePath = '';
+            _this.wrapper = null;
+            _this.isDestoryed = false;
+            _this.active = false;
+            _this.isTabView = false;
+            return _this;
+        }
+        ViewIframeManager.prototype.appendContainer = function () {
+            var el = this.el;
+            el.className = 'webview';
+            el.setAttribute('frameborder', '0');
+            this.hide();
+            var wrapper = document.getElementById('webview-container');
+            this.wrapper = wrapper;
+            if (wrapper != null) {
+                wrapper.appendChild(el);
+            }
+        };
+        ViewIframeManager.prototype.show = function () {
+            var el = this.el;
+            el.style.zIndex = '2';
+            el.style.opacity = '1';
+            this.active = true;
+        };
+        ViewIframeManager.prototype.hide = function () {
+            var el = this.el;
+            el.style.zIndex = '1';
+            el.style.opacity = '0';
+            this.active = false;
+        };
+        ViewIframeManager.prototype.updateWebviewId = function (v) {
+            this.webviewId = v;
+            this.updateId();
+        };
+        ViewIframeManager.prototype.updateId = function () {
+            this.el.id = "webview-" + this.webviewId;
+        };
+        ViewIframeManager.prototype.updateSrc = function (pagePath) {
+            this.el.src = viewTemplatePath;
+            this.pagePath = pagePath;
+        };
+        ViewIframeManager.prototype.injectScript = function () {
+            var _this = this;
+            var innerWindow = this.getWindow();
+            if (innerWindow != null && this.pagePath != '') {
+                var pagePath = this.pagePath.endsWith('.html')
+                    ? this.pagePath
+                    : this.pagePath + '.html';
+                var reqUrl_1 = basePath + pagePath;
+                cacheRequest(reqUrl_1, { sync: true }, function (err, data) {
+                    if (err != null) {
+                        console.error("init page fail in " + _this.pagePath + ", req: " + reqUrl_1 + " \n " + err);
+                    }
+                    else {
+                        // @ts-ignore
+                        innerWindow.injectHtml(innerWindow.document.body, {
+                            content: data
+                        });
+                    }
+                });
+            }
+        };
+        ViewIframeManager.prototype.getBridge = function () {
+            // @ts-ignore
+            return this.getWindow().FinChatJSBridge;
+        };
+        ViewIframeManager.prototype.sendToView = function (event, data) {
+            var _this = this;
+            if (this.sync) {
+                debug && console.log("%c " + event, "color: green;", data, this.webviewId);
+                this.getBridge().subscribeHandler(event, data, this.webviewId);
+            }
+            else {
+                // 事件交互 必须异步发送到视图层，不然可能会成闭塞环引发 bug
+                setTimeout(function () {
+                    debug &&
+                        console.log("%c " + event, "color: green;", data, _this.webviewId);
+                    _this.getBridge().subscribeHandler(event, data, _this.webviewId);
+                });
+            }
+        };
+        ViewIframeManager.prototype.destory = function () {
+            if (this.wrapper !== null) {
+                this.wrapper.removeChild(this.el);
+                // @ts-ignore
+                this.el = null;
+                this.wrapper = null;
+                this.isDestoryed = true;
+                this.active = false;
+            }
+        };
+        return ViewIframeManager;
+    }(IframeManager));
+
+    var Router = /** @class */ (function () {
+        function Router() {
+            this._slotStack = [];
+            this._extraStack = [];
+            this._slots = [];
+            this._webviewId = 0;
+            this.rootIndex = 0;
+        }
+        Object.defineProperty(Router.prototype, "pagePath", {
+            get: function () {
+                var _a;
+                return ((_a = this.currPage) === null || _a === void 0 ? void 0 : _a.pagePath) || null;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Router.prototype, "currPage", {
+            get: function () {
+                return this.stack[this.stack.length - 2] || null;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Router.prototype, "top", {
+            get: function () {
+                return this.stack[this.stack.length - 1];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Router.prototype, "stack", {
+            get: function () {
+                var root = this._slotStack[this.rootIndex];
+                if (root == null)
+                    return [];
+                return __spreadArrays([root], this._extraStack);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Router.prototype, "allPages", {
+            get: function () {
+                var root = this._slotStack[this.rootIndex];
+                if (root == null)
+                    return [];
+                return __spreadArrays([root], this._extraStack.slice(0, this._extraStack.length - 1));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Router.prototype.initFirstPage = function (slots, pagePath) {
+            if (!Array.isArray(slots) || slots.length === 0) {
+                throw new Error('slots must exist.');
+            }
+            var targetIndex = findSlotIndex(this, pagePath);
+            this._slots = slots;
+            for (var i = 0; i < slots.length; i++) {
+                var iframe = document.createElement('iframe');
+                var viewIfameManager = new ViewIframeManager(iframe);
+                viewIfameManager.appendContainer();
+                this._slotStack.push(viewIfameManager);
+            }
+            if (targetIndex > -1) {
+                this.rootIndex = targetIndex;
+            }
+            var first = this._slotStack[this.rootIndex];
+            first.updateSrc(pagePath);
+            this.initEmptyPage();
+        };
+        Router.prototype.reinitPages = function (pagePath) {
+            var slotStack = this._slotStack;
+            var extraStack = this._extraStack;
+            slotStack.forEach(function (page) {
+                page.destory();
+            });
+            extraStack.forEach(function (page) {
+                page.destory();
+            });
+            this._slotStack = [];
+            this._extraStack = [];
+            this.initFirstPage(this._slots, pagePath);
+            this.currPage.updateWebviewId(this._webviewId++);
+        };
+        Router.prototype.reLaunch = function (pagePath) {
+            this.reinitPages(pagePath);
+        };
+        Router.prototype.redirectTo = function (pagePath) {
+            var targetIndex = findSlotIndex(this, pagePath);
+            if (targetIndex > -1) {
+                throw new Error('不允许跳转到 tabbar 页面:' + pagePath);
+            }
+            var extraStack = this._extraStack;
+            if (extraStack.length > 1) {
+                var pendingPage = extraStack.pop();
+                var currPage = extraStack.pop();
+                currPage.destory();
+                pendingPage.updateSrc(pagePath);
+                pendingPage.updateWebviewId(this._webviewId++);
+                extraStack.push(pendingPage);
+                this.initEmptyPage();
+            }
+            else {
+                // TODO: 可以优化的方案是 单个replace，而不是全销毁
+                var pendingPage = extraStack.pop();
+                pendingPage === null || pendingPage === void 0 ? void 0 : pendingPage.destory();
+                this._slotStack.forEach(function (page) {
+                    page.destory();
+                });
+                this.reinitPages(pagePath);
+            }
+        };
+        Router.prototype.initSlotWebviewId = function (id) {
+            this._webviewId = id;
+            this._slotStack[this.rootIndex].updateWebviewId(this._webviewId++);
+        };
+        Router.prototype.initEmptyPage = function () {
+            var iframe = document.createElement('iframe');
+            var viewIfameManager = new ViewIframeManager(iframe);
+            viewIfameManager.appendContainer();
+            this._extraStack.push(viewIfameManager);
+        };
+        Router.prototype.initNextPage = function (page) {
+            var curr = this.currPage;
+            var pendingPage = this.top;
+            curr.hide();
+            pendingPage.updateSrc(page);
+            pendingPage.updateWebviewId(this._webviewId++);
+            this.initEmptyPage();
+            return pendingPage;
+        };
+        Router.prototype.switch = function (page, index) {
+            index = index != null ? index : findSlotIndex(this, page);
+            var stack = this._slotStack;
+            var view = stack[index];
+            if (view == null) {
+                throw new Error("switchTab url is invalid: " + page);
+            }
+            this.resetExtraStack();
+            stack.forEach(function (page) {
+                if (page.isReady) {
+                    page.hide();
+                }
+            });
+            this.rootIndex = index;
+            if (view.isReady) {
+                view.show();
+            }
+            else {
+                view.updateWebviewId(this._webviewId++);
+                view.updateSrc(page);
+            }
+            return view;
+        };
+        Router.prototype.go = function (page) {
+            var targetIndex = findSlotIndex(this, page);
+            if (targetIndex > -1) {
+                return this.switch(page, targetIndex);
+            }
+            else {
+                return this.initNextPage(page);
+            }
+        };
+        Router.prototype.back = function (delta) {
+            var _a;
+            var extraStack = this._extraStack.slice();
+            var pending = extraStack.pop();
+            var len = extraStack.length;
+            if (delta <= 0) {
+                throw new Error('delta 不能 <= 0');
+            }
+            if (len < delta) {
+                throw new Error('delta 不能超过总栈长度：' + (len + 1));
+            }
+            var gapIndex = len - delta;
+            var reaminList = extraStack.slice(0, gapIndex);
+            var removeList = extraStack.slice(gapIndex, len);
+            removeList.forEach(function (item) {
+                item.destory();
+            });
+            if (reaminList.length > 0) {
+                var nestedPage = reaminList[reaminList.length - 1];
+                nestedPage.show();
+            }
+            else {
+                (_a = this._slotStack[this.rootIndex]) === null || _a === void 0 ? void 0 : _a.show();
+            }
+            pending && reaminList.push(pending);
+            this._extraStack = reaminList;
+        };
+        Router.prototype.resetExtraStack = function () {
+            if (this._extraStack.length === 0)
+                return;
+            var pendingPage = this.top;
+            this._extraStack.slice(0, this._extraStack.length - 1).forEach(function (page) {
+                page.destory();
+            });
+            this._extraStack = [pendingPage];
+        };
+        return Router;
+    }());
+    function findSlotIndex(router, pagePath) {
+        var slots = router._slots;
+        return slots.findIndex(function (a) { return a === formatPagePath(pagePath); });
+    }
+    var router = new Router;
+
+    var ServiceIframeManagerEventNames = {
+        'onViewDOMContentLoaded': 'onViewDOMContentLoaded',
+        'onInjectHTMLCallback': 'onInjectHTMLCallback',
+    };
+    var loadedMap = {};
+    function isLoadedPackage(root) {
+        return loadedMap[root];
+    }
+    var ServiceIframeManager = /** @class */ (function (_super) {
+        __extends(ServiceIframeManager, _super);
+        function ServiceIframeManager(e) {
+            return _super.call(this, e) || this;
+        }
+        ServiceIframeManager.prototype.sendToSerivce = function (event, data, webviewId) {
+            debug && console.log("%c " + event, "color: blue;", data, webviewId);
+            this.getBridge().subscribeHandler(event, data, webviewId);
+        };
+        // 加载子包
+        ServiceIframeManager.prototype.loadSubBundle = function (root, bundlePath) {
+            if (loadedMap[root] === true)
+                return;
+            var innerWindow = this.getWindow();
+            if (innerWindow != null) {
+                // @ts-ignore
+                innerWindow.injectHtml(innerWindow.document.body, {
+                    content: "<script charset=\"utf-8\" src=\"" + bundlePath + "\"></script>"
+                });
+                loadedMap[root] = true;
+            }
+        };
+        ServiceIframeManager.prototype.invokeCallbackHandler = function (cbId, data, apiName) {
+            debug &&
+                console.log("%c " + (apiName || 'API') + " call callback", "color: blue;", cbId, data);
+            this.getBridge().invokeCallbackHandler(cbId, data);
+        };
+        ServiceIframeManager.prototype.getBridge = function () {
+            // @ts-ignore
+            return this.getWindow().ServiceJSBridge;
+        };
+        return ServiceIframeManager;
+    }(IframeManager));
+
+    var serviceIframeId = 'webview-service';
+    var iframeManagerMap = new Map();
+    function getIframeManager(id) {
+        var target = iframeManagerMap.get(id);
+        if (target)
+            return target;
+        var iframe = document.getElementById(id);
+        if (iframe != null) {
+            var Manager = id === serviceIframeId ? ServiceIframeManager : ViewIframeManager;
+            var manager = new Manager(iframe);
+            iframeManagerMap.set(id, manager);
+            return manager;
+        }
+        throw new Error("\u83B7\u53D6IframeManager\u5931\u8D25, id: " + id);
+    }
+    function getServiceIframeManager() {
+        return getIframeManager(serviceIframeId);
+    }
+
+    function invokeServiceCallbackHandler(cbId, data, apiName) {
+        var service = getIframeManager(serviceIframeId);
+        service.invokeCallbackHandler(cbId, data, apiName);
+    }
+
+    function dispatchViewEvent(event, data, webviewIds) {
+        router.stack.forEach(function (manager) {
+            if (manager.webviewId == null)
+                return;
+            if (webviewIds.indexOf(manager.webviewId) > -1) {
+                if (manager.isReady) {
+                    manager.sendToView(event, data);
+                }
+                else {
+                    console.error("shouldn't exctute");
+                }
+            }
+        });
+    }
+    function dispatchServiceEvent(event, data, webviewId) {
+        var service = getIframeManager(serviceIframeId);
+        service.sendToSerivce(event, data, webviewId);
+    }
+
+    var AdapterTarget = null;
+    function setTarget(target) {
+        AdapterTarget = target;
+    }
+    function getTarget() {
+        return AdapterTarget;
+    }
+
+    var CoreAdapter = /** @class */ (function () {
+        function CoreAdapter() {
+            // SDK 接口调用
+            this._invokeServiceCallbackHandler = invokeServiceCallbackHandler;
+            // 往 ui/逻辑 进程发消息
+            this._dispatchViewEvent = dispatchViewEvent;
+            this._dispatchServiceEvent = dispatchServiceEvent;
+            // 获得当前页面信息，发消息 所需要的 webviewId,可以从这些接口拿
+            this._getCurrentPage = function () {
+                return router.currPage;
+            };
+            this._getAllPages = function () {
+                return router.allPages;
+            };
+        }
+        CoreAdapter.prototype.init = function () {
+            setTarget(this);
+        };
+        return CoreAdapter;
+    }());
+    window.__CoreAdapter = CoreAdapter;
+
+    function toLocalTempFilePath(url) {
+        return url.replace(/^http(s?)\:\/\//, localPathPerfix);
+    }
+
+    function headersStr2Obj(headers) {
+        var arr = headers.trim().split(/[\r\n]+/);
+        // Create a map of header names to values
+        var headerMap = {};
+        arr.forEach(function (line) {
+            var parts = line.split(": ");
+            var header = parts.shift();
+            var value = parts.join(": ");
+            headerMap[header] = value;
+        });
+        return headerMap;
+    }
+
+    function nextTick(cb) {
+        setTimeout(cb, 17);
+    }
+
+    var fsUtilApis = {
+        readFileSync: function (opts) {
+            var filePath = opts.filePath;
+            // 本地文件 不能通过http请求的，走缓存系统
+            if (filePath.startsWith(localPathPerfix)) {
+                var cache = localStorage.getItem(filePath);
+                if (cache != null) {
+                    return { data: cache, errMsg: 'readFileSync:ok' };
+                }
+                else {
+                    return { data: null, errMsg: "readFileSync:fail " + filePath + " not exist" };
+                }
+            }
+            filePath = processFilePath(filePath);
+            var rsp = null;
+            var rspErr = null;
+            requestSource(basePath + filePath, { sync: true }, function (err, data) {
+                rsp = data;
+                rspErr = err;
+            });
+            if (rsp != null) {
+                return { data: rsp, errMsg: 'readFileSync:ok' };
+            }
+            else if (rspErr != null) {
+                return {
+                    data: null,
+                    errMsg: 'readFileSync:fail ' + rspErr.message
+                };
+            }
+            return { data: null, errMsg: 'readFileSync:fail' };
+        },
+        // 异步读取
+        readFile: function (opts, callbackId) {
+            var filePath = opts.filePath, encoding = opts.encoding;
+            var isBase64 = encoding === 'base64';
+            var url = basePath + filePath;
+            if (filePath.startsWith(localPathPerfix)) {
+                nextTick(function () {
+                    var result = localStorage.getItem(filePath);
+                    if (result != null) {
+                        invokeServiceCallbackHandler(callbackId, {
+                            data: result,
+                            errMsg: 'readFile:ok'
+                        });
+                    }
+                    else {
+                        invokeServiceCallbackHandler(callbackId, {
+                            errMsg: "readFile:fail " + filePath + " is not existed"
+                        });
+                    }
+                });
+                return;
+            }
+            requestSource(url, {
+                responseType: isBase64 ? 'arraybuffer' : ''
+            }, function (err, data) {
+                if (err != null) {
+                    invokeServiceCallbackHandler(callbackId, {
+                        errMsg: 'readFile:fail ' + err.message
+                    });
+                    return;
+                }
+                invokeServiceCallbackHandler(callbackId, {
+                    data: isBase64 ? arrayBufferToBase64(data) : data,
+                    errMsg: 'readFile:ok'
+                });
+            });
+        },
+        // 文件是否存在
+        access: function () {
+            return { errMsg: 'access:ok' };
+        },
+        mkdirSync: function () {
+            return { errMsg: 'mkdirSync:ok' };
+        },
+        writeFileSync: function (_a) {
+            var filePath = _a.filePath, data = _a.data;
+            // 缓存模拟文件系统
+            localStorage.setItem(filePath, data);
+            return { errMsg: 'writeFileSync:ok' };
+        },
+        unlink: function (_a, callbackId) {
+            var filePath = _a.filePath;
+            nextTick(function () {
+                localStorage.removeItem(filePath);
+                invokeServiceCallbackHandler(callbackId, {
+                    errMsg: 'unlink:ok'
+                });
+            });
+        },
+        downloadFile: function (_a, callbackId) {
+            var url = _a.url, _b = _a.timeout, timeout = _b === void 0 ? 6000 : _b; _a.taskId; _a.header; _a.filePath;
+            promiseTimeout(timeout, doDownload({
+                url: url,
+                callbackId: callbackId
+            }), function (ms) {
+                invokeServiceCallbackHandler(callbackId, {
+                    errMsg: "downloadFile:fail timeout in " + ms + "ms."
+                });
+            });
+        }
+    };
+    function doDownload(_a) {
+        var url = _a.url, callbackId = _a.callbackId, filePath = _a.filePath, header = _a.header;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                requestSource(url, { header: header }, function (err, data, info) {
+                    var e = info.e, xhr = info.xhr;
+                    if (err != null) {
+                        invokeServiceCallbackHandler(callbackId, {
+                            errMsg: 'downloadFile:fail ' + err.message
+                        });
+                        return;
+                    }
+                    // 格式化
+                    var tempFilePath = toLocalTempFilePath(url);
+                    var usedFilePath = filePath || tempFilePath;
+                    localStorage.setItem(usedFilePath, data);
+                    var rspHeaders = xhr.getAllResponseHeaders();
+                    var headerMap = headersStr2Obj(rspHeaders);
+                    var rspCookies = (headerMap['set-cookie'] || '').split(',');
+                    // 推送两个事件
+                    dispatchServiceEvent(onTaskProgressUpdate, {
+                        cookies: [],
+                        progress: 100,
+                        totalBytesExpectedToWrite: e.loaded,
+                        totalBytesWritten: e.loaded
+                    });
+                    dispatchServiceEvent(onTaskHeadersReceived, {
+                        cookies: rspCookies,
+                        header: headerMap
+                    });
+                    var processedTempFilePath = processTempFilePath(tempFilePath, url);
+                    invokeServiceCallbackHandler(callbackId, {
+                        filePath: filePath,
+                        tempFilePath: filePath ? undefined : processedTempFilePath,
+                        profile: [],
+                        statusCode: 200,
+                        errMsg: 'downloadFile:ok'
+                    });
+                });
+                return [2 /*return*/];
+            });
+        });
+    }
+    function processTempFilePath(tempFilePath, url) {
+        var arr = tempFilePath.split('.');
+        var suffix = arr[arr.length - 1];
+        if (imgSets.has('.' + suffix)) {
+            return url;
+        }
+        return tempFilePath;
+    }
+
+    var globalApis = {
+        getGlobalVariables: function (data) {
+            var variable = data.variable;
+            if (variable === '_launchOption') {
+                // 先写死
+                return {
+                    _launchOption: launchOption
+                };
+            }
+            return null;
+        },
+        // 上报的
+        reportApmMonitor: function (data) { },
+        addPerformance: function () { },
+        // dom渲染完成
+        // 这里关闭加载遮罩
+        initReady: function () {
+            //
+        },
+        updateAppData: function () { },
+        injectHtmlCallback: function (data, cbId, from) {
+            if (from === 'service') {
+                getServiceIframeManager().events.emit(ServiceIframeManagerEventNames.onInjectHTMLCallback);
+            }
+        },
+        pageScrollTo: function (opts, callbackId) {
+            var scrollTop = opts.scrollTop; opts.duration;
+            var curPage = router.currPage;
+            var innerW = curPage.getWindow();
+            innerW === null || innerW === void 0 ? void 0 : innerW.scrollTo({
+                top: scrollTop,
+                behavior: "smooth",
+            });
+            return {
+                errMsg: 'pageScrollTo:ok'
+            };
+        }
+    };
+
+    var wxConfig = null;
+    function setWxConfig(v) {
+        wxConfig = v;
+    }
+    function getWxConfig() {
+        if (wxConfig == null) {
+            throw new Error("WxConfig is not ready.");
+        }
+        return wxConfig;
+    }
+
+    var WebFrameEventBus = new eventemitter3();
+    function emitAppDataChangeEvent(params) {
+        var payload = __assign({}, params.data);
+        var wxConfig = getWxConfig();
+        var currPath = payload.options.path;
+        var pages = wxConfig.windows.pages;
+        if (pages != null && pages[currPath]) {
+            payload.windowConfig = pages[currPath];
+        }
+        payload.pages = router.allPages;
+        WebFrameEventBus.emit('appDataChange', payload);
+    }
+    function emitUpdateAppDataEvent() {
+        var payload = {};
+        var wxConfig = getWxConfig();
+        var currPage = router.currPage;
+        var currPath = currPage.pagePath.replace(/\.html$/, '');
+        var pages = wxConfig.windows.pages;
+        if (pages != null && pages[currPath]) {
+            payload.windowConfig = pages[currPath];
+        }
+        payload.pages = router.allPages;
+        payload.currPage = currPath;
+        WebFrameEventBus.emit('updateAppData', payload);
+    }
+    function emitTabItemChangedEvent(pagePath) {
+        var payload = {};
+        var wxConfig = getWxConfig();
+        var currPath = pagePath;
+        var pages = wxConfig.windows.pages;
+        if (pages != null && pages[currPath]) {
+            payload.windowConfig = pages[currPath];
+        }
+        WebFrameEventBus.emit('tabItemChanged', payload);
+    }
+    function initWebFrame(config) {
+        if (typeof window.__initWebFrame === 'undefined')
+            return;
+        WebFrameEventBus.on('NavigatorBarTools:onMore', function () {
+            console.log('onMore');
+        });
+        WebFrameEventBus.on('NavigatorBarTools:onClose', function () {
+            console.log('onClose');
+        });
+        WebFrameEventBus.on('NavigatorBar:onBack', function () {
+            routeApis.navigateBack({ delta: 1 });
+            console.log('onBack');
+        });
+        WebFrameEventBus.on('TabBar:change', function (data) {
+            dispatchServiceEvent('onTabItemTap', {
+                index: data.index,
+                pagePath: data.item.pagePath,
+                text: data.item.text
+            });
+            routeApis.switchTab({ url: data.item.pagePath }, -1);
+            emitTabItemChangedEvent(data.item.pagePath);
+        });
+        WebFrameEventBus.on('invokeCallbackHandler', function (payload) {
+            invokeServiceCallbackHandler(payload.callbackId, payload.data);
+        });
+        //
+        window.__initWebFrame(config, WebFrameEventBus);
+    }
+
+    var interactionApis = {
+        hideToast: function (opts) {
+            WebFrameEventBus.emit('hideToast', opts);
+            return { errMsg: 'hideToast:ok' };
+        },
+        showToast: function (opts) {
+            WebFrameEventBus.emit('showToast', opts);
+            return { errMsg: 'showToast:ok' };
+        },
+        showLoading: function (opts) {
+            WebFrameEventBus.emit('showLoading', opts);
+            return { errMsg: 'showLoading:ok' };
+        },
+        hideLoading: function (opts) {
+            WebFrameEventBus.emit('hideLoading', opts);
+            return { errMsg: 'hideLoading:ok' };
+        },
+        showModal: function (opts, callbackId) {
+            WebFrameEventBus.emit('showModal', opts, callbackId);
+        },
+        showActionSheet: function (opts, callbackId) {
+            WebFrameEventBus.emit('showActionSheet', opts, callbackId);
+        }
+    };
+
+    var LoadSubPackageTaskManager = /** @class */ (function () {
+        function LoadSubPackageTaskManager(opts) {
+            this.taskId = opts.taskId;
+            this.moduleName = opts.moduleName;
+            this.projectType = opts.projectType;
+            this.status = 'none';
+        }
+        LoadSubPackageTaskManager.prototype.notifyProgressUpdate = function (state, extra) {
+            dispatchServiceEvent(onLoadSubPackageTaskStateChange, __assign({ moduleName: this.moduleName, state: state, taskId: this.taskId }, extra));
+        };
+        LoadSubPackageTaskManager.prototype.injectScript = function () { };
+        LoadSubPackageTaskManager.prototype.getEntry = function () { };
+        LoadSubPackageTaskManager.prototype.load = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            this.notifyProgressUpdate('progressUpdate', { progress: 0 });
+                            return [4 /*yield*/, delay(15)
+                                // 这部分是解压的
+                            ];
+                        case 1:
+                            _a.sent();
+                            // 这部分是解压的
+                            this.notifyProgressUpdate('progressUpdate', { progress: 50 });
+                            return [4 /*yield*/, delay(30)
+                                // 这部分是插入脚本
+                            ];
+                        case 2:
+                            _a.sent();
+                            // 这部分是插入脚本
+                            this.injectScript();
+                            this.notifyProgressUpdate('progressUpdate', { progress: 100 });
+                            return [4 /*yield*/, delay(15)
+                                // 提示完成
+                            ];
+                        case 3:
+                            _a.sent();
+                            // 提示完成
+                            this.status = 'success';
+                            this.notifyProgressUpdate('success', {
+                                entryPath: this.getEntry()
+                            });
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return LoadSubPackageTaskManager;
+    }());
+
+    function generateScriptContent(projectType, opts) {
+        if (projectType === miniGame) {
+            return "<script charset=\"utf-8\" src=\"" + opts.moduleName + "game.js\"></script>";
+        }
+        if (projectType === miniProgram) {
+            return opts.content;
+        }
+        throw Error('unsupported projectType: ' + projectType);
+    }
+    function generateEntryPath(projectType, opts) {
+        if (projectType === miniGame) {
+            return opts.moduleName + "game.js";
+        }
+        return '';
+    }
+
+    var LoadGameSubPackageTaskManager = /** @class */ (function (_super) {
+        __extends(LoadGameSubPackageTaskManager, _super);
+        function LoadGameSubPackageTaskManager(opts) {
+            return _super.call(this, __assign(__assign({}, opts), { projectType: miniGame })) || this;
+        }
+        LoadGameSubPackageTaskManager.prototype.injectScript = function () {
+            var serviceFrameManager = getIframeManager(serviceIframeId);
+            var innerWindow = serviceFrameManager.getWindow();
+            innerWindow.injectHtml(innerWindow.document.body, {
+                content: generateScriptContent(this.projectType, {
+                    moduleName: this.moduleName
+                })
+            });
+        };
+        LoadGameSubPackageTaskManager.prototype.getEntry = function () {
+            return generateEntryPath(this.projectType, {
+                moduleName: this.moduleName
+            });
+        };
+        return LoadGameSubPackageTaskManager;
+    }(LoadSubPackageTaskManager));
+
+    var taskId = 0;
+    var taskManagerMap = {};
+    var loadSubpackageApis = {
+        // 游戏分包特有的加载接口
+        createLoadSubPackageTask: function (_a) {
+            var moduleName = _a.moduleName;
+            var manager = taskManagerMap[moduleName];
+            if (manager && manager.status === 'success') {
+                return {
+                    errMsg: 'createLoadSubPackageTask:fail sub package already loaded.'
+                };
+            }
+            ++taskId;
+            var taskIdStr = String(taskId);
+            manager = new LoadGameSubPackageTaskManager({ taskId: taskIdStr, moduleName: moduleName });
+            taskManagerMap[moduleName] = manager;
+            manager.load();
+            return {
+                errMsg: 'createLoadSubPackageTask:ok',
+                loadTaskId: taskIdStr
+            };
+        }
+    };
+
+    var navApis = {
+        showNavigationBarLoading: function () {
+            WebFrameEventBus.emit('showNavigationBarLoading');
+            return {
+                errMsg: "showNavigationBarLoading:ok"
+            };
+        },
+        setNavigationBarTitle: function (opts) {
+            WebFrameEventBus.emit('setNavigationBarTitle', opts);
+            return {
+                errMsg: "setNavigationBarTitle:ok"
+            };
+        },
+        setNavigationBarColor: function (opts) {
+            WebFrameEventBus.emit('setNavigationBarColor', opts);
+            return {
+                errMsg: "setNavigationBarColor:ok"
+            };
+        },
+        hideNavigationBarLoading: function () {
+            WebFrameEventBus.emit('hideNavigationBarLoading');
+            return {
+                errMsg: "hideNavigationBarLoading:ok"
+            };
+        },
+        hideHomeButton: function () {
+        }
+    };
+
+    // TODO: 已经加载的子包 不需要加载
+    function ensureBundleLoaded(request, done) {
+        var subPackageInfo = tryFindSubPackageInfo(request);
+        if (subPackageInfo != null && !isLoadedPackage(subPackageInfo.root)) {
+            loadSubPackage(subPackageInfo, done);
+        }
+        else {
+            done();
+        }
+    }
+    function tryFindSubPackageInfo(path) {
+        path = path.replace(/\.html$/, '');
+        var wxConfig = getWxConfig();
+        var subPackages = wxConfig.subpackages;
+        if (Array.isArray(subPackages) && subPackages.length > 0) {
+            return subPackages.find(function (item) {
+                return item.pageFullPath.includes(path);
+            });
+        }
+        return null;
+    }
+    function loadSubPackage(subPackageInfo, done) {
+        var service = getIframeManager(serviceIframeId);
+        service.events.once(ServiceIframeManagerEventNames.onInjectHTMLCallback, done);
+        service.loadSubBundle(subPackageInfo.root, subPackageInfo.packageName + '.js');
+    }
+    function getSlots(wxConfig) {
+        var tabBarConfig = wxConfig.tabBar;
+        if (tabBarConfig == null) {
+            return [wxConfig.root];
+        }
+        else {
+            var tabList = tabBarConfig.list || [];
+            if (tabList.length === 0) {
+                return [wxConfig.root];
+            }
+            return tabBarConfig.list.map(function (item) { return item.pagePath; });
+        }
+    }
+    function initFirstPageByWxConfig(wxConfig) {
+        var slots = getSlots(wxConfig);
+        router.initFirstPage(slots, wxConfig.root);
+    }
+
+    var routeApis = {
+        navigateTo: function (_a, callbackId) {
+            var url = _a.url;
+            if (router.stack.length > 10) {
+                return {
+                    errMsg: 'navigateTo:fail 已到达页面栈上限:10。'
+                };
+            }
+            var _b = resolveUrl(url), path = _b.path, query = _b.query;
+            ensureBundleLoaded(path, function () {
+                var nextPage = router.go(path);
+                getServiceIframeManager().events.once(ServiceIframeManagerEventNames.onViewDOMContentLoaded, function () {
+                    dispatchServiceEvent('onAppRoute', {
+                        path: path,
+                        openType: 'navigateTo',
+                        options: undefined,
+                        pipMode: '',
+                        query: query,
+                        webviewId: nextPage.webviewId
+                    }, nextPage.webviewId);
+                });
+            });
+            return { errMsg: 'navigateTo:ok' };
+        },
+        navigateBack: function (_a) {
+            var delta = _a.delta;
+            try {
+                router.back(delta);
+            }
+            catch (error) {
+                return {
+                    errMsg: "navigateBack:fail " + error.message
+                };
+            }
+            var currPage = router.currPage;
+            dispatchServiceEvent('onAppRoute', {
+                path: currPage.pagePath,
+                openType: 'navigateBack',
+                options: { delta: delta },
+                pipMode: '',
+                query: undefined,
+                webviewId: currPage.webviewId
+            }, currPage.webviewId);
+            // 不是异步 可以直接返回结果
+            return { errMsg: 'navigateBack:ok' };
+        },
+        reLaunch: function (_a, cbId) {
+            var url = _a.url;
+            var _b = resolveUrl(url), path = _b.path, query = _b.query;
+            ensureBundleLoaded(path, function () {
+                router.reLaunch(url);
+                var currPage = router.currPage;
+                getServiceIframeManager().events.once(ServiceIframeManagerEventNames.onViewDOMContentLoaded, function () {
+                    dispatchServiceEvent('onAppRoute', {
+                        path: path,
+                        openType: 'reLaunch',
+                        options: undefined,
+                        pipMode: '',
+                        query: query,
+                        webviewId: currPage.webviewId
+                    }, currPage.webviewId);
+                    invokeServiceCallbackHandler(cbId, {
+                        errMsg: 'reLaunch:ok'
+                    });
+                });
+            });
+        },
+        redirectTo: function (_a, callbackId) {
+            var url = _a.url;
+            // 不允许跳转到 tabbar 页面
+            var _b = resolveUrl(url), path = _b.path, query = _b.query;
+            ensureBundleLoaded(path, function () {
+                try {
+                    router.redirectTo(path);
+                }
+                catch (error) {
+                    invokeServiceCallbackHandler(callbackId, {
+                        errMsg: "redirectTo:fail " + error.message
+                    });
+                    return;
+                }
+                var currPage = router.currPage;
+                getServiceIframeManager().events.once(ServiceIframeManagerEventNames.onViewDOMContentLoaded, function () {
+                    dispatchServiceEvent('onAppRoute', {
+                        path: path,
+                        openType: 'redirectTo',
+                        options: undefined,
+                        pipMode: '',
+                        query: query,
+                        webviewId: currPage.webviewId
+                    }, currPage.webviewId);
+                    invokeServiceCallbackHandler(callbackId, {
+                        errMsg: 'redirectTo:ok'
+                    });
+                });
+            });
+        },
+        switchTab: function (_a, callbackId) {
+            var url = _a.url;
+            var _b = resolveUrl(url), path = _b.path, query = _b.query;
+            ensureBundleLoaded(path, function () {
+                try {
+                    router.switch(path);
+                }
+                catch (error) {
+                    invokeServiceCallbackHandler(callbackId, {
+                        errMsg: "switchTab:fail " + error.message
+                    });
+                    return;
+                }
+                var currPage = router.currPage;
+                if (currPage.isReady) {
+                    dispatchServiceEvent('onAppRoute', {
+                        path: path,
+                        openType: 'switchTab',
+                        options: undefined,
+                        pipMode: '',
+                        query: query,
+                        webviewId: currPage.webviewId
+                    }, currPage.webviewId);
+                    invokeServiceCallbackHandler(callbackId, {
+                        errMsg: 'switchTab:ok'
+                    });
+                }
+                else {
+                    getServiceIframeManager().events.once(ServiceIframeManagerEventNames.onViewDOMContentLoaded, function () {
+                        dispatchServiceEvent('onAppRoute', {
+                            path: path,
+                            openType: 'switchTab',
+                            options: undefined,
+                            pipMode: '',
+                            query: query,
+                            webviewId: currPage.webviewId
+                        }, currPage.webviewId);
+                        invokeServiceCallbackHandler(callbackId, {
+                            errMsg: 'switchTab:ok'
+                        });
+                    });
+                }
+            });
+        }
+    };
+
+    var localStorageApis = {
+        getStorageSync: function (opts) {
+            var res = localStorage.getItem(opts.key);
+            try {
+                // @ts-expect-error
+                return JSON.parse(res);
+            }
+            catch (error) {
+                return res;
+            }
+        },
+        setStorageSync: function (opts) {
+            localStorage.setItem(opts.key, opts.data);
+            return { errMsg: 'setStorageSync:ok' };
+        },
+        removeStorageSync: function (opts) {
+            localStorage.removeItem(opts.key);
+            return { errMsg: 'removeStorageSync:ok' };
+        }
+    };
+
+    function getCurrentDeviceOrientation() {
+        var system = getSystem();
+        if (system === 'Android' || system === 'IOS') {
+            return window.matchMedia('(orientation: portrait)').matches
+                ? 'portrait'
+                : 'landscape';
+        }
+        // web
+        return 'landscape';
+    }
+
+    var system = {
+        onMemoryWarning: function () {
+            console.error('The onMemoryWarning api is not implement.');
+        },
+        showShareMenu: function () {
+            console.error('The showShareMenu api is not implement.');
+        },
+        getSystemInfoSync: function () {
+            var resolutionRatio = 750; // 这个要通过原生注入
+            var statusBarHeight = 22; // 这个要通过原生注入
+            var pixelRatio = resolutionRatio / window.innerWidth;
+            return {
+                deviceOrientation: getCurrentDeviceOrientation(),
+                devicePixelRatio: pixelRatio,
+                screenWidth: window.innerWidth,
+                screenHeight: window.innerHeight,
+                SDKVersion: '2.26.0',
+                appVersion: '2.37.0',
+                batteryLevel: 98,
+                benchmarkLevel: 1,
+                bluetoothEnabled: false,
+                brand: 'devtools',
+                cameraAuthorized: true,
+                deviceId: '11D22B6D-B5D8-4C24-AF42-8C959C95A2E6',
+                enableDebug: true,
+                errMsg: 'getSystemInfoSync:ok',
+                fontSizeSetting: 15,
+                frameworkVersion: '3.1.7',
+                inFinChat: true,
+                language: 'zh_CN',
+                locationAuthorized: true,
+                locationEnabled: true,
+                microphoneAuthorized: true,
+                mode: 'default',
+                model: 'iPhone 5',
+                notificationAuthorized: true,
+                pixelRatio: pixelRatio,
+                platform: 'devtools',
+                statusBarHeight: statusBarHeight,
+                system: getSystem(),
+                theme: undefined,
+                version: '8.0.28 ',
+                windowHeight: window.innerHeight,
+                windowWidth: window.innerWidth,
+                safeArea: {
+                    height: window.innerHeight - statusBarHeight,
+                    widows: window.innerWidth,
+                    top: statusBarHeight,
+                    left: 0,
+                    right: 0
+                }
+            };
+        },
+    };
+
+    var injectetSDK = false;
+    function injectSDKScript() {
+        if (injectetSDK)
+            return;
+        var query = resolveUrl(location.search).query;
+        var tempUrl = window.__sdkUrlTemplate;
+        if (tempUrl != null && query.extType != null) {
+            var sdkUrl = tempUrl.replace('$1', query.extType);
+            var script = document.createElement('script');
+            script.setAttribute('charset', 'utf-8');
+            script.src = sdkUrl;
+            document.body.appendChild(script);
+            console.log('inject sdk script:', sdkUrl);
+            injectetSDK = true;
+        }
+    }
+
+    var customEventHanders = {
+        // 通知 native
+        serviceStart: function (e) {
+            setWxConfig(e.params);
+            var params = e.params;
+            initFirstPageByWxConfig(params);
+            initWebFrame(params);
+        },
+        // 通知 native
+        serviceReady: function (e) {
+            injectSDKScript();
+            var params = e.params, webviewIds = e.webviewIds;
+            var manager = getServiceIframeManager();
+            var webviewId = webviewIds[0];
+            if (manager.isReady)
+                return;
+            router.initSlotWebviewId(webviewId);
+            manager.events.once(ServiceIframeManagerEventNames.onViewDOMContentLoaded, function () {
+                dispatchServiceEvent('onAppRoute', {
+                    path: params.root,
+                    openType: 'appLaunch',
+                    options: undefined,
+                    pipMode: '',
+                    query: undefined,
+                    webviewId: webviewId
+                }, webviewId);
+            });
+            dispatchServiceEvent('onServiceReadyDone', __assign(__assign({}, launchOption), { webviewId: webviewId }), webviewId);
+            manager.isReady = true;
+        },
+        // view 事件
+        DOMContentLoaded: function (e) {
+            var params = e.params, from = e.from; e.webviewIds; var event = e.event, webviewId = e.webviewId;
+            var manager = getIframeManager(serviceIframeId);
+            if (from === Terminal.View) {
+                dispatchServiceEvent(event, params, webviewId);
+                manager.events.emit(ServiceIframeManagerEventNames.onViewDOMContentLoaded);
+            }
+            else {
+                console.error('not implement for ' + from);
+            }
+        },
+        // 通知 native
+        onLaunchCalled: function (e) { },
+        // 通知 native
+        viewReady: function () {
+            var page = router.currPage;
+            if (page != null) {
+                page.isReady = true;
+                page.injectScript();
+                page.show();
+            }
+        },
+        // 通知 native
+        DOMReady: function () { },
+        // 通知 service 调 原生方法
+        INVOKE_METHOD: function (e) {
+            var params = e.params, from = e.from; e.webviewIds; var event = e.event, webviewId = e.webviewId;
+            if (from === Terminal.View) {
+                dispatchServiceEvent(event, params, webviewId);
+            }
+            else {
+                console.error('not implement for ' + from);
+            }
+        },
+        // 双向的
+        vdSync: function (e) {
+            var params = e.params, from = e.from, webviewIds = e.webviewIds, event = e.event, webviewId = e.webviewId;
+            if (from === Terminal.View) {
+                dispatchServiceEvent(event, params, webviewId);
+            }
+            else {
+                dispatchViewEvent(event, params, webviewIds);
+            }
+        },
+        // 双向的（待定）
+        vdSyncBatch: function (e) {
+            var params = e.params, from = e.from, webviewIds = e.webviewIds, event = e.event, webviewId = e.webviewId;
+            if (from === Terminal.View) {
+                dispatchServiceEvent(event, params, webviewId);
+            }
+            else {
+                dispatchViewEvent(event, params, webviewIds);
+            }
+        },
+        // 进入页面
+        appDataChange: function (e) {
+            var params = e.params, from = e.from, webviewIds = e.webviewIds, event = e.event; e.webviewId;
+            if (from === Terminal.View) {
+                console.error('not implement for ' + from);
+            }
+            else {
+                emitAppDataChangeEvent(params);
+                dispatchViewEvent(event, params, webviewIds);
+            }
+        },
+        // 退出页面
+        __updateAppData: function (e) {
+            emitUpdateAppDataEvent();
+        },
+        pageonshow: function (e) {
+            var params = e.params, from = e.from, webviewIds = e.webviewIds, event = e.event; e.webviewId;
+            if (from === Terminal.View) {
+                console.error('not implement for ' + from);
+            }
+            else {
+                dispatchViewEvent(event, params, webviewIds);
+            }
+        },
+        requestLoadFontFace: function (e) {
+            var params = e.params, from = e.from, webviewIds = e.webviewIds, event = e.event; e.webviewId;
+            if (from === Terminal.View) {
+                console.error('not implement for ' + from);
+            }
+            else {
+                dispatchViewEvent(event, params, webviewIds);
+            }
+        },
+        requestLoadGlobalFontFaces: function (e) {
+            var params = e.params, from = e.from; e.webviewIds; var event = e.event, webviewId = e.webviewId;
+            if (from === Terminal.View) {
+                dispatchServiceEvent(event, params, webviewId);
+            }
+            else {
+                console.error('not implement for ' + from);
+            }
+        },
+        responseLoadGlobalFontFaces: function (e) {
+            var params = e.params, from = e.from, webviewIds = e.webviewIds, event = e.event; e.webviewId;
+            if (from === Terminal.View) {
+                console.error('not implement for ' + from);
+            }
+            else {
+                dispatchViewEvent(event, params, webviewIds);
+            }
+        },
+        PAGE_EVENT: function (e) {
+            var params = e.params, from = e.from; e.webviewIds; var event = e.event, webviewId = e.webviewId;
+            if (from === Terminal.View) {
+                dispatchServiceEvent(event, params, webviewId);
+            }
+            else {
+                console.error('not implement for ' + from);
+            }
+        },
+        setKeyboardValue: function (e) {
+            var params = e.params, from = e.from, webviewIds = e.webviewIds, event = e.event; e.webviewId;
+            if (from === Terminal.View) {
+                console.error('not implement for ' + from);
+            }
+            else {
+                dispatchViewEvent(event, params, webviewIds);
+            }
+        },
+        SPECIAL_PAGE_EVENT: function (e) {
+            var params = e.params, from = e.from; e.webviewIds; var event = e.event, webviewId = e.webviewId;
+            if (from === Terminal.View) {
+                dispatchServiceEvent(event, params, webviewId);
+            }
+            else {
+                console.error('not implement for ' + from);
+            }
+        },
+        gameServiceReady: function () {
+            injectSDKScript();
+        },
+        gameConfigUpdate: function (config) {
+            var _a;
+            var currentDeviceOrientation = getCurrentDeviceOrientation();
+            if (config.deviceOrientation !== currentDeviceOrientation) {
+                // 切换到游戏配置的设备方向
+                (_a = getTarget()) === null || _a === void 0 ? void 0 : _a.invokeHandler('setDeviceOrientation', {
+                    value: config.deviceOrientation
+                }, -1);
+            }
+        }
+    };
+
+    var customEventPreifx = 'custom_event_';
+    var APIS = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, globalApis), fsUtilApis), loadSubpackageApis), routeApis), interactionApis), localStorageApis), system), navApis);
+    var FinChatJSCore = {
+        invokeHandler: function (data) {
+            debug && console.log('invokeHander', data);
+            var C = data.C, paramsString = data.paramsString; data.type; var from = data.from, callbackId = data.callbackId;
+            var params = JSON.parse(paramsString);
+            // @ts-expect-error
+            var api = APIS[C];
+            if (api != null) {
+                var res = api(params, callbackId, from);
+                return res;
+            }
+            else {
+                var adapter = getTarget();
+                if (adapter != null) {
+                    return adapter.invokeHandler(C, params, callbackId);
+                }
+            }
+        },
+        publishHandler: function (data) {
+            debug && console.log('publishHandler', data);
+            var event = data.event, from = data.from, paramsString = data.paramsString, webviewId = data.webviewId, webviewIds = data.webviewIds;
+            var eventWithoutPrefix = event.replace(customEventPreifx, '');
+            var params = JSON.parse(paramsString);
+            var handler = customEventHanders[eventWithoutPrefix];
+            if (handler != null) {
+                // @ts-ignore
+                handler({
+                    event: event,
+                    params: params,
+                    from: from,
+                    webviewId: webviewId,
+                    webviewIds: Terminal.Service === from && webviewIds ? JSON.parse(webviewIds) : undefined // 来自 service 事件存在
+                });
+            }
+            else {
+                var adapter = getTarget();
+                if (adapter != null) {
+                    adapter.publishHandler(eventWithoutPrefix, params, from);
+                }
+            }
+        },
+        webInvokeHandler: function (data) {
+            debug && console.log('webInvokeHander', data);
+        },
+        webPublishHandler: function (data) {
+            debug && console.log('webPublishHandler', data);
+        }
+    };
+    // @ts-ignore
+    window.FinChatJSCore = FinChatJSCore;
+
+}));