@worktile/planet 11.0.0 → 12.1.2

package/bundles/worktile-planet.umd.js

@@ -60,14 +60,14 @@
     }
     function getTagNameByTemplate(template) {
         var element = createElementByTemplate(template);
-        return element ? element.nodeName : null;
+        return element ? element.nodeName : '';
     }
     function createElementByTemplate(template) {
         if (!template) {
             return null;
         }
         var element = document.createRange().createContextualFragment(template).firstChild;
-        if (element.nodeType === ELEMENT_NODE_TYPE) {
+        if (element && element.nodeType === ELEMENT_NODE_TYPE) {
             return element;
         }
         else {
@@ -89,6 +89,9 @@
         var type = typeof value;
         return !!value && type === 'function';
     }
+    function isObject(val) {
+        return val && typeof val === 'object';
+    }
     /**
      * Get file name from path
      * 1. "main.js" => "main.js"
@@ -176,6 +179,8 @@
         return extendStatics(d, b);
     };
     function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
         extendStatics(d, b);
         function __() { this.constructor = d; }
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
@@ -361,11 +366,13 @@
         }
         return ar;
     }
+    /** @deprecated */
     function __spread() {
         for (var ar = [], i = 0; i < arguments.length; i++)
             ar = ar.concat(__read(arguments[i]));
         return ar;
     }
+    /** @deprecated */
     function __spreadArrays() {
         for (var s = 0, i = 0, il = arguments.length; i < il; i++)
             s += arguments[i].length;
@@ -374,7 +381,17 @@
                 r[k] = a[j];
         return r;
     }
-    ;
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2)
+            for (var i = 0, l = from.length, ar; i < l; i++) {
+                if (ar || !(i in from)) {
+                    if (!ar)
+                        ar = Array.prototype.slice.call(from, 0, i);
+                    ar[i] = from[i];
+                }
+            }
+        return to.concat(ar || from);
+    }
     function __await(v) {
         return this instanceof __await ? (this.v = v, this) : new __await(v);
     }
@@ -439,18 +456,719 @@
     function __importDefault(mod) {
         return (mod && mod.__esModule) ? mod : { default: mod };
     }
-    function __classPrivateFieldGet(receiver, privateMap) {
-        if (!privateMap.has(receiver)) {
-            throw new TypeError("attempted to get private field on non-instance");
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    var PLANET_SANDBOX_WINDOW_WHITELIST = window['___PLANET_SANDBOX_WINDOW_WHITELIST___'];
+    var PLANET_SANDBOX_DOCUMENT_WHITELIST = window['___PLANET_SANDBOX_DOCUMENT_WHITELIST___'];
+    var SANDBOX_INSTANCE = Symbol.for('PLANET_SANDBOX_INSTANCE');
+    var RAW_NODE = Symbol.for('PLANET_RAW_NODE');
+    var WINDOW_BIND_FN = Symbol.for('PLANET_WINDOW_BIND_FN');
+    var DOCUMENT_BIND_FN = Symbol.for('PLANET_DOCUMENT_BIND_FN');
+
+    var rawHasOwnProperty = Object.prototype.hasOwnProperty;
+    function hasOwnProp(obj, key) {
+        return rawHasOwnProperty.call(obj, key);
+    }
+    function isValueDescriptor(desc) {
+        if (desc === undefined) {
+            return false;
+        }
+        return 'value' in desc || 'writable' in desc;
+    }
+    function isAccessorDescriptor(desc) {
+        if (desc === undefined) {
+            return false;
+        }
+        return 'get' in desc || 'set' in desc;
+    }
+    function isNonWriteableValue(desc) {
+        return desc && desc.configurable === false && 'value' in desc && desc.writable === false;
+    }
+    function isInvalidSetAccessor(desc) {
+        if (desc && desc.configurable === false && 'set' in desc && desc.set === undefined) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    function isInvalidGetAccessor(desc) {
+        if (desc && desc.configurable === false && 'get' in desc && desc.get === undefined) {
+            return true;
+        }
+        else {
+            return false;
         }
-        return privateMap.get(receiver);
     }
-    function __classPrivateFieldSet(receiver, privateMap, value) {
-        if (!privateMap.has(receiver)) {
-            throw new TypeError("attempted to set private field on non-instance");
+    function transferParams(args) {
+        args = Array.isArray(args) ? args : Array.from(args);
+        return args.map(function (arg) {
+            return arg[RAW_NODE] ? arg[RAW_NODE] : arg;
+        });
+    }
+    var buildInProps = ['length', 'caller', 'callee', 'arguments', 'prototype', Symbol.hasInstance];
+    function transferProps(o, n) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(Reflect.ownKeys(o)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                if (buildInProps.includes(key)) {
+                    continue;
+                }
+                var desc = Object.getOwnPropertyDescriptor(n, key);
+                if (desc && desc.writable) {
+                    n[key] = o[key];
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    function bind(fn, context) {
+        var fNOP = function () { };
+        function bound() {
+            var args = transferParams(arguments);
+            if (this instanceof bound) {
+                var obj = new (fn.bind.apply(fn, __spreadArray([void 0], __read(args))))();
+                Object.setPrototypeOf(obj, bound.prototype);
+                return obj;
+            }
+            else {
+                return fn.apply(context, args);
+            }
+        }
+        bound.$native = fn;
+        transferProps(fn, bound);
+        if (fn.prototype) {
+            fNOP.prototype = fn.prototype;
+        }
+        bound.prototype = new fNOP();
+        if (Symbol.hasInstance) {
+            Object.defineProperty(bound, Symbol.hasInstance, {
+                configurable: true,
+                value: function (instance) {
+                    var op = fn.prototype;
+                    return isObject(op) || typeof op === 'function' ? instance instanceof fn : false;
+                }
+            });
+        }
+        return bound;
+    }
+    function createFakeObject(target, writableKeys) {
+        var fakeObject = {};
+        var propertyMap = {};
+        var storageBox = Object.create(null);
+        var propertyNames = Object.getOwnPropertyNames(target);
+        var def = function (p) {
+            var descriptor = Object.getOwnPropertyDescriptor(target, p);
+            if (descriptor === null || descriptor === void 0 ? void 0 : descriptor.configurable) {
+                var hasGetter = hasOwnProp(descriptor, 'get');
+                var hasSetter = hasOwnProp(descriptor, 'set');
+                var canWritable = writableKeys && writableKeys.length > 0 && writableKeys.includes(p);
+                if (hasGetter) {
+                    descriptor.get = function () { return (hasOwnProp(storageBox, p) ? storageBox[p] : target[p]); };
+                }
+                if (hasSetter) {
+                    descriptor.set = function (val) {
+                        storageBox[p] = val;
+                        return true;
+                    };
+                }
+                if (canWritable) {
+                    if (descriptor.writable === false) {
+                        descriptor.writable = true;
+                    }
+                    else if (hasGetter) {
+                        descriptor.set = function (val) {
+                            storageBox[p] = val;
+                            return true;
+                        };
+                    }
+                }
+                Object.defineProperty(fakeObject, p, Object.freeze(descriptor));
+            }
+        };
+        propertyNames.forEach(function (p) {
+            propertyMap[p] = true;
+            def(p);
+        });
+        // 再次循环是为了处理原型链中的属性
+        for (var prop in target) {
+            if (!propertyMap[prop]) {
+                def(prop);
+            }
+        }
+        return fakeObject;
+    }
+
+    var esGlobalFunctions = ('eval,isFinite,isNaN,parseFloat,parseInt,' +
+        // URL handling functions
+        'decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        // Constructor properties of the global object
+        'Array,ArrayBuffer,BigInt,BigInt64Array,BigUint64Array,Boolean,DataView,Date,Error,EvalError,' +
+        'FinalizationRegistry,Float32Array,Float64Array,Function,Int8Array,Int16Array,Int32Array,Map,Number,' +
+        'Object,Promise,Proxy,RangeError,ReferenceError,RegExp,Set,SharedArrayBuffer,String,Symbol,SyntaxError,' +
+        'TypeError,Uint8Array,Uint8ClampedArray,Uint16Array,Uint32Array,URIError,WeakMap,WeakRef,WeakSet,' +
+        // Other Properties of the Global Object
+        'Atomics,JSON,Math,Reflect').split(',');
+    var whitelistVariables = PLANET_SANDBOX_WINDOW_WHITELIST || [];
+    function isConstructor(fn) {
+        var fp = fn.prototype;
+        var hasConstructor = fp && fp.constructor === fn && Object.getOwnPropertyNames(fp).length > 1;
+        var functionStr = !hasConstructor && fn.toString();
+        return hasConstructor || /^function\s+[A-Z]/.test(functionStr) || /^class\b/.test(functionStr);
+    }
+    var unscopables = {
+        undefined: true,
+        Array: true,
+        Object: true,
+        String: true,
+        Boolean: true,
+        Math: true,
+        Number: true,
+        Symbol: true,
+        parseFloat: true,
+        Float32Array: true
+    };
+    var ProxyWindow = /** @class */ (function () {
+        function ProxyWindow(sandbox) {
+            this.sandbox = sandbox;
+            this.definedVariables = new Set();
+        }
+        ProxyWindow.prototype.createGetter = function () {
+            var _this = this;
+            return function (target, key, receiver) {
+                if (key === Symbol.unscopables) {
+                    return unscopables;
+                }
+                if (key === SANDBOX_INSTANCE) {
+                    return _this.sandbox;
+                }
+                var value = null;
+                if (whitelistVariables.includes(key)) {
+                    return Reflect.get(window, key);
+                }
+                else {
+                    value = hasOwnProp(target, key) ? Reflect.get(target, key, receiver) : Reflect.get(window, key);
+                }
+                if (isFunction(value)) {
+                    if (esGlobalFunctions.includes(key) ||
+                        whitelistVariables.includes(key) ||
+                        _this.sandbox.rewriteVariables.includes(key) ||
+                        _this.definedVariables.has(key) ||
+                        isConstructor(value)) {
+                        return value;
+                    }
+                    else {
+                        var newValue = hasOwnProp(value, WINDOW_BIND_FN) ? value[WINDOW_BIND_FN] : bind(value, window);
+                        var desc = Object.getOwnPropertyDescriptor(target, key);
+                        if (isNonWriteableValue(desc)) {
+                            return value;
+                        }
+                        if (isInvalidGetAccessor(desc)) {
+                            return undefined;
+                        }
+                        value[WINDOW_BIND_FN] = newValue;
+                        return newValue;
+                    }
+                }
+                else {
+                    return value;
+                }
+            };
+        };
+        ProxyWindow.prototype.createSetter = function () {
+            var _this = this;
+            return function (target, key, value, receiver) {
+                var desc = Object.getOwnPropertyDescriptor(whitelistVariables.includes(key) ? window : receiver ? receiver : target, key);
+                if (desc && isNonWriteableValue(desc)) {
+                    if (!Object.is(value, desc.value)) {
+                        return false;
+                    }
+                    else {
+                        return true;
+                    }
+                }
+                if (isInvalidSetAccessor(desc)) {
+                    return false;
+                }
+                if (whitelistVariables.includes(key)) {
+                    return Reflect.set(window, key, value);
+                }
+                else {
+                    var success = Reflect.set(target, key, value, receiver);
+                    if (success) {
+                        if (_this.sandbox.running) {
+                            _this.definedVariables.add(key);
+                        }
+                    }
+                    return success;
+                }
+            };
+        };
+        ProxyWindow.prototype.createDefineProperty = function () {
+            var _this = this;
+            return function (target, p, descriptor) {
+                if (whitelistVariables.includes(p)) {
+                    return Reflect.defineProperty(window, p, descriptor);
+                }
+                else {
+                    var success = Reflect.defineProperty(target, p, descriptor);
+                    if (_this.sandbox.running && success) {
+                        _this.definedVariables.add(p);
+                    }
+                    return success;
+                }
+            };
+        };
+        ProxyWindow.prototype.createDeleteProperty = function () {
+            var _this = this;
+            return function (target, p) {
+                if (hasOwnProp(target, p)) {
+                    delete target[p];
+                    if (_this.sandbox.running && _this.definedVariables.has(p)) {
+                        _this.definedVariables.delete(p);
+                    }
+                }
+                return true;
+            };
+        };
+        ProxyWindow.prototype.createHas = function () {
+            return function (_target, key) {
+                return !whitelistVariables.includes(key);
+            };
+        };
+        ProxyWindow.prototype.create = function () {
+            var fakeWindow = createFakeObject(window, this.sandbox.rewriteVariables);
+            var baseHandlers = {
+                get: this.createGetter(),
+                set: this.createSetter(),
+                defineProperty: this.createDefineProperty(),
+                deleteProperty: this.createDeleteProperty()
+            };
+            var proxy = new Proxy(fakeWindow, Object.assign(Object.assign({}, baseHandlers), { has: this.createHas() }));
+            var subProxy = new Proxy(fakeWindow, baseHandlers);
+            proxy.self = subProxy;
+            proxy.window = subProxy;
+            proxy.globalThis = subProxy;
+            proxy.top = window.top === window ? subProxy : window.top;
+            proxy.parent = window.parent === window ? subProxy : window.top;
+            return proxy;
+        };
+        return ProxyWindow;
+    }());
+
+    function eventListenerPatch(sandbox) {
+        var rawAddEventListener = window.addEventListener;
+        var rawRemoveEventListener = window.removeEventListener;
+        var listenerSubscriptions = new Map();
+        function addEventListener(type, listener, options) {
+            var _this = this;
+            var observable = new rxjs.Observable(function () {
+                rawAddEventListener.call(_this, type, listener, options);
+                return function () {
+                    rawRemoveEventListener.call(_this, type, listener, options);
+                };
+            });
+            var subscription = observable.subscribe(function () { });
+            listenerSubscriptions.set(listener, subscription);
+        }
+        function removeEventListener(type, listener) {
+            var subscription = listenerSubscriptions.get(listener);
+            if (subscription) {
+                subscription.unsubscribe();
+                listenerSubscriptions.delete(listener);
+            }
         }
-        privateMap.set(receiver, value);
-        return value;
+        return {
+            rewrite: {
+                addEventListener: addEventListener.bind(window),
+                removeEventListener: removeEventListener.bind(window)
+            },
+            init: function () {
+                var fakeDocument = sandbox.global.document;
+                if (fakeDocument) {
+                    fakeDocument.addEventListener = addEventListener.bind(document);
+                    fakeDocument.removeEventListener = removeEventListener.bind(document);
+                }
+            },
+            destroy: function () {
+                listenerSubscriptions.forEach(function (subscription) { return subscription.unsubscribe(); });
+                listenerSubscriptions.clear();
+            }
+        };
+    }
+
+    var rawDocument = Document;
+    var whitelist = __spreadArray(['cookie', 'title', 'location'], __read((PLANET_SANDBOX_DOCUMENT_WHITELIST || [])));
+    var ProxyDocument = /** @class */ (function () {
+        function ProxyDocument() {
+        }
+        ProxyDocument.prototype.createGetter = function () {
+            return function (target, p, receiver) {
+                var value = hasOwnProp(target, p) ? Reflect.get(target, p, receiver) : Reflect.get(document, p);
+                if (p === 'activeElement') {
+                    return Reflect.get(document, p);
+                }
+                // TODO: 处理动态节点
+                // if (p === 'createElement') {
+                //     return function(tagName: string, options: ElementCreationOptions) {
+                //         const created = value.call(document, tagName, options);
+                //         if (isObject(created)) {
+                //             created[SANDBOX_INSTANCE] = sandbox;
+                //         }
+                //         return created;
+                //     };
+                // }
+                if (isFunction(value)) {
+                    var newValue = hasOwnProp(value, DOCUMENT_BIND_FN) ? value[DOCUMENT_BIND_FN] : null;
+                    if (!newValue) {
+                        newValue = bind(value, document);
+                    }
+                    var desc = Object.getOwnPropertyDescriptor(target, p);
+                    if (desc && isNonWriteableValue(desc)) {
+                        if (!Object.is(newValue, desc.value)) {
+                            return value;
+                        }
+                    }
+                    if (isInvalidGetAccessor(desc)) {
+                        return undefined;
+                    }
+                    value[DOCUMENT_BIND_FN] = newValue;
+                    return newValue;
+                }
+                return value;
+            };
+        };
+        ProxyDocument.prototype.createSetter = function () {
+            return function (target, p, value, receiver) {
+                var desc = Object.getOwnPropertyDescriptor(whitelist.includes(p) ? document : receiver || target, p);
+                if (desc && isNonWriteableValue(desc)) {
+                    if (Object.is(value, desc.value)) {
+                        return true;
+                    }
+                    else {
+                        return false;
+                    }
+                }
+                if (isInvalidSetAccessor(desc)) {
+                    return false;
+                }
+                return whitelist.includes(p) ? Reflect.set(document, p, value) : Reflect.set(target, p, value, receiver);
+            };
+        };
+        ProxyDocument.prototype.createDefineProperty = function () {
+            return function (target, p, descriptor) {
+                return whitelist.includes(p)
+                    ? Reflect.defineProperty(document, p, descriptor)
+                    : Reflect.defineProperty(target, p, descriptor);
+            };
+        };
+        ProxyDocument.prototype.create = function () {
+            var _a;
+            var proxyDocument = null;
+            var fakeDocument = createFakeObject(document);
+            var getter = this.createGetter();
+            var fakeDocumentProto = new Proxy(fakeDocument, {
+                get: function () {
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    return getter.apply(void 0, __spreadArray([], __read(args)));
+                }
+            });
+            var fakeDocumentCtor = function Document() {
+                if (!(this instanceof fakeDocumentCtor)) {
+                    throw new TypeError("Failed to construct 'Document': Please use the 'new' operator.");
+                }
+                var docInstance = new rawDocument();
+                Object.setPrototypeOf(docInstance, fakeDocument);
+                return docInstance;
+            };
+            fakeDocumentCtor.prototype = fakeDocumentProto;
+            fakeDocumentCtor.prototype.constructor = fakeDocumentCtor;
+            if (Symbol.hasInstance) {
+                Object.defineProperty(fakeDocumentCtor, Symbol.hasInstance, {
+                    configurable: true,
+                    value: function (value) {
+                        var proto = value;
+                        if (proto === document) {
+                            return true;
+                        }
+                        while ((proto = Object.getPrototypeOf(proto))) {
+                            if (proto === fakeDocumentProto) {
+                                return true;
+                            }
+                        }
+                        var cloned = function () { };
+                        cloned.prototype = fakeDocument;
+                        return value instanceof cloned;
+                    }
+                });
+            }
+            proxyDocument = new Proxy(Object.create(fakeDocumentProto, (_a = {
+                    currentScript: {
+                        value: null,
+                        writable: true
+                    }
+                },
+                _a[RAW_NODE] = {
+                    writable: false,
+                    configurable: false,
+                    value: document
+                },
+                _a)), {
+                set: this.createSetter(),
+                defineProperty: this.createDefineProperty()
+            });
+            return {
+                document: proxyDocument,
+                Document: fakeDocumentCtor
+            };
+        };
+        return ProxyDocument;
+    }());
+
+    function documentPatch() {
+        var proxyDocument = new ProxyDocument();
+        var _a = proxyDocument.create(), document = _a.document, Document = _a.Document;
+        return {
+            rewrite: {
+                document: document,
+                Document: Document
+            }
+        };
+    }
+
+    var rawSetTimeout = window.setTimeout;
+    var rawClearTimeout = window.clearTimeout;
+    var rawSetInterval = window.setInterval;
+    var rawClearInterval = window.clearInterval;
+    function timerPatch() {
+        var timeout = new Set();
+        var interval = new Set();
+        function rewriteSetTimeout(handler, ms) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            var timeoutId = rawSetTimeout.apply(void 0, __spreadArray([handler, ms], __read(args)));
+            timeout.add(timeoutId);
+            return timeoutId;
+        }
+        function rewriteClearTimeout(timeoutId) {
+            timeout.delete(timeoutId);
+            rawClearTimeout(timeoutId);
+        }
+        function rewriteSetInterval(handler, ms) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            var intervalId = rawSetInterval.apply(void 0, __spreadArray([handler, ms], __read(args)));
+            interval.add(intervalId);
+            return intervalId;
+        }
+        function rewriteClearInterval(intervalId) {
+            interval.delete(intervalId);
+            rawClearInterval(intervalId);
+        }
+        return {
+            rewrite: {
+                setTimeout: rewriteSetTimeout,
+                clearTimeout: rewriteClearTimeout,
+                setInterval: rewriteSetInterval,
+                clearInterval: rewriteClearInterval
+            },
+            destroy: function () {
+                timeout.forEach(function (timeoutId) {
+                    rawClearTimeout(timeoutId);
+                });
+                interval.forEach(function (intervalId) {
+                    rawClearInterval(intervalId);
+                });
+            }
+        };
+    }
+
+    var PLANET_STORAGE_PREFIX = '__planet-storage-';
+    var RewriteStorage = /** @class */ (function () {
+        function RewriteStorage(app, rawStorage) {
+            this.rawStorage = rawStorage;
+            this.prefix = "" + PLANET_STORAGE_PREFIX + app + "__:";
+        }
+        Object.defineProperty(RewriteStorage.prototype, "length", {
+            get: function () {
+                return this.getKeys().length;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        RewriteStorage.prototype.getKeys = function () {
+            var _this = this;
+            return Object.keys(this.rawStorage).filter(function (key) { return key.startsWith(_this.prefix); });
+        };
+        RewriteStorage.prototype.key = function (n) {
+            var key = this.getKeys()[n];
+            return key ? key.substring(this.prefix.length) : null;
+        };
+        RewriteStorage.prototype.getItem = function (key) {
+            return this.rawStorage.getItem("" + (this.prefix + key));
+        };
+        RewriteStorage.prototype.setItem = function (key, value) {
+            this.rawStorage.setItem("" + (this.prefix + key), value);
+        };
+        RewriteStorage.prototype.removeItem = function (key) {
+            this.rawStorage.removeItem("" + (this.prefix + key));
+        };
+        RewriteStorage.prototype.clear = function () {
+            var _this = this;
+            this.getKeys().forEach(function (key) {
+                _this.rawStorage.removeItem(key);
+            });
+        };
+        return RewriteStorage;
+    }());
+    function storagePatch(sandbox) {
+        return {
+            rewrite: {
+                localStorage: new RewriteStorage(sandbox.app, localStorage),
+                sessionStorage: new RewriteStorage(sandbox.app, sessionStorage)
+            }
+        };
+    }
+
+    var sandboxPatches = [documentPatch, eventListenerPatch, timerPatch, storagePatch];
+    function getSandboxPatchHandlers(sandbox) {
+        return sandboxPatches.map(function (patch) {
+            return patch(sandbox);
+        });
+    }
+
+    function execScript(code, url, global, strictGlobal) {
+        var sourceUrl = '//# sourceURL='.concat(url, '\n');
+        var window = (0, eval)('window');
+        window.tempGlobal = global;
+        code = strictGlobal
+            ? ';(function(window, self, globalThis){with(window){;'
+                .concat(code, '\n')
+                .concat(sourceUrl, '}}).bind(window.tempGlobal)(window.tempGlobal, window.tempGlobal, window.tempGlobal);')
+            : ';(function(window, self, globalThis){;'
+                .concat(code, '\n')
+                .concat(sourceUrl, '}).bind(window.tempGlobal)(window.tempGlobal, window.tempGlobal, window.tempGlobal);');
+        (0, eval)(code);
+        delete window.tempGlobal;
+    }
+
+    var Sandbox = /** @class */ (function () {
+        function Sandbox() {
+        }
+        Sandbox.prototype.execScript = function (code, url) {
+            if (url === void 0) { url = ''; }
+            execScript(code, url, this.global, !!this.options.strictGlobal);
+        };
+        return Sandbox;
+    }());
+
+    var ProxySandbox = /** @class */ (function (_super) {
+        __extends(ProxySandbox, _super);
+        function ProxySandbox(app, options) {
+            var _this = _super.call(this) || this;
+            _this.app = app;
+            _this.options = options;
+            _this.running = false;
+            _this.patchHandlers = [];
+            _this.patchHandlers = getSandboxPatchHandlers(_this);
+            _this.start();
+            return _this;
+        }
+        ProxySandbox.prototype.start = function () {
+            this.running = true;
+            this.rewriteVariables = this.getPatchRewriteVariables();
+            var proxyWindow = new ProxyWindow(this);
+            this.global = proxyWindow.create();
+            this.execPatchHandlers();
+        };
+        ProxySandbox.prototype.destroy = function () {
+            this.running = false;
+            this.patchHandlers.forEach(function (handler) {
+                if (handler.destroy) {
+                    handler.destroy();
+                }
+            });
+        };
+        ProxySandbox.prototype.getPatchRewriteVariables = function () {
+            return this.patchHandlers.reduce(function (pre, cur) {
+                return __spreadArray(__spreadArray([], __read(pre)), __read((cur.rewrite ? Object.keys(cur.rewrite) : [])));
+            }, []);
+        };
+        ProxySandbox.prototype.execPatchHandlers = function () {
+            var _this = this;
+            this.patchHandlers.forEach(function (handler) {
+                if (handler.rewrite) {
+                    for (var key in handler.rewrite) {
+                        if (handler.rewrite[key]) {
+                            _this.global[key] = handler.rewrite[key];
+                        }
+                    }
+                }
+                if (handler.init) {
+                    handler === null || handler === void 0 ? void 0 : handler.init();
+                }
+            });
+        };
+        return ProxySandbox;
+    }(Sandbox));
+
+    var SnapshotSandbox = /** @class */ (function (_super) {
+        __extends(SnapshotSandbox, _super);
+        function SnapshotSandbox(app, options) {
+            var _this = _super.call(this) || this;
+            _this.app = app;
+            _this.options = options;
+            _this.start();
+            return _this;
+        }
+        SnapshotSandbox.prototype.start = function () { };
+        SnapshotSandbox.prototype.destroy = function () { };
+        return SnapshotSandbox;
+    }(Sandbox));
+
+    var defaultOptions = {
+        strictGlobal: false
+    };
+    function createSandbox(app, options) {
+        options = Object.assign({}, defaultOptions, options || {});
+        if (window.Proxy) {
+            return new ProxySandbox(app, options);
+        }
+        else {
+            return new SnapshotSandbox(app, options);
+        }
+    }
+    function getSandboxInstance() {
+        return window[SANDBOX_INSTANCE];
     }
 
     var AssetsLoader = /** @class */ (function () {
@@ -516,6 +1234,41 @@
                 document.body.appendChild(script);
             });
         };
+        AssetsLoader.prototype.loadScriptWithSandbox = function (app, src) {
+            var _this = this;
+            var id = hashCode(src);
+            if (this.loadedSources.includes(id)) {
+                return rxjs.of({
+                    src: src,
+                    hashCode: id,
+                    loaded: true,
+                    status: 'Loaded'
+                });
+            }
+            return new rxjs.Observable(function (observer) {
+                _this.http.get(src, { responseType: 'text' }).subscribe(function (code) {
+                    _this.loadedSources.push(id);
+                    var sandbox = createSandbox(app);
+                    sandbox.execScript(code, src);
+                    observer.next({
+                        src: src,
+                        hashCode: id,
+                        loaded: true,
+                        status: 'Loaded'
+                    });
+                    observer.complete();
+                }, function (error) {
+                    observer.error({
+                        src: src,
+                        hashCode: id,
+                        loaded: false,
+                        status: 'Error',
+                        error: error
+                    });
+                    observer.complete();
+                });
+            });
+        };
         AssetsLoader.prototype.loadStyle = function (src) {
             var _this = this;
             var id = hashCode(src);
@@ -557,17 +1310,26 @@
                 head.appendChild(link);
             });
         };
-        AssetsLoader.prototype.loadScripts = function (sources, serial) {
+        AssetsLoader.prototype.loadScripts = function (sources, options) {
             var _this = this;
-            if (serial === void 0) { serial = false; }
+            if (options === void 0) { options = {
+                serial: false,
+                sandbox: false
+            }; }
             if (isEmpty(sources)) {
                 return rxjs.of(null);
             }
             var observables = sources.map(function (src) {
-                return _this.loadScript(src);
+                // TODO: 暂时只支持Proxy沙箱
+                if (options.sandbox && window.Proxy) {
+                    return _this.loadScriptWithSandbox(options.app, src);
+                }
+                else {
+                    return _this.loadScript(src);
+                }
             });
-            if (serial) {
-                var a = rxjs.concat.apply(void 0, __spread(observables)).pipe(operators.map(function (item) {
+            if (options.serial) {
+                var a = rxjs.concat.apply(void 0, __spreadArray([], __read(observables))).pipe(operators.map(function (item) {
                     return rxjs.of([item]);
                 }), operators.concatAll());
                 return a;
@@ -585,23 +1347,30 @@
                 return _this.loadStyle(src);
             }));
         };
-        AssetsLoader.prototype.loadScriptsAndStyles = function (scripts, styles, serial) {
+        AssetsLoader.prototype.loadScriptsAndStyles = function (scripts, styles, options) {
             if (scripts === void 0) { scripts = []; }
             if (styles === void 0) { styles = []; }
-            if (serial === void 0) { serial = false; }
-            return rxjs.forkJoin([this.loadScripts(scripts, serial), this.loadStyles(styles)]);
+            return rxjs.forkJoin([this.loadScripts(scripts, options), this.loadStyles(styles)]);
         };
         AssetsLoader.prototype.loadAppAssets = function (app) {
             var _this = this;
             if (app.manifest) {
                 return this.loadManifest(app.manifest + "?t=" + new Date().getTime()).pipe(operators.switchMap(function (manifestResult) {
                     var _a = getScriptsAndStylesFullPaths(app, manifestResult), scripts = _a.scripts, styles = _a.styles;
-                    return _this.loadScriptsAndStyles(scripts, styles, app.loadSerial);
+                    return _this.loadScriptsAndStyles(scripts, styles, {
+                        app: app.name,
+                        sandbox: app.sandbox,
+                        serial: app.loadSerial
+                    });
                 }));
             }
             else {
                 var _a = getScriptsAndStylesFullPaths(app), scripts = _a.scripts, styles = _a.styles;
-                return this.loadScriptsAndStyles(scripts, styles, app.loadSerial);
+                return this.loadScriptsAndStyles(scripts, styles, {
+                    app: app.name,
+                    sandbox: app.sandbox,
+                    serial: app.loadSerial
+                });
             }
         };
         AssetsLoader.prototype.loadManifest = function (url) {
@@ -626,15 +1395,15 @@
             this.name = name;
             if (options) {
                 this.template = options.template;
-                this.innerSelector = this.template ? getTagNameByTemplate(this.template) : null;
+                this.innerSelector = this.template ? getTagNameByTemplate(this.template) : '';
                 this.appModuleBootstrap = options.bootstrap;
             }
             // This is a hack, since NgZone doesn't allow you to configure the property that identifies your zone.
             // See https://github.com/PlaceMe-SAS/single-spa-angular-cli/issues/33,
-            // NgZone.isInAngularZone = () => {
-            //     // @ts-ignore
-            //     return window.Zone.current._properties[`ngx-planet-${name}`] === true;
-            // };
+            i0.NgZone.isInAngularZone = function () {
+                // @ts-ignore
+                return window.Zone.current._properties["ngx-planet-" + name] === true;
+            };
         }
         Object.defineProperty(PlanetApplicationRef.prototype, "selector", {
             get: function () {
@@ -650,18 +1419,31 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(PlanetApplicationRef.prototype, "ngZone", {
+            get: function () {
+                var _a;
+                return (_a = this.appModuleRef) === null || _a === void 0 ? void 0 : _a.injector.get(i0.NgZone);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(PlanetApplicationRef.prototype, "sandbox", {
+            get: function () {
+                return getSandboxInstance();
+            },
+            enumerable: false,
+            configurable: true
+        });
         // 子应用路由变化后同步修改 portal 的 Route
         PlanetApplicationRef.prototype.syncPortalRouteWhenNavigationEnd = function () {
             var _this = this;
-            var router = this.appModuleRef.injector.get(i3.Router);
-            var ngZone = this.appModuleRef.injector.get(i0.NgZone);
+            var _a;
+            var router = (_a = this.appModuleRef) === null || _a === void 0 ? void 0 : _a.injector.get(i3.Router);
             if (router) {
                 router.events.subscribe(function (event) {
+                    var _a;
                     if (event instanceof i3.NavigationEnd) {
-                        ngZone.onStable
-                            .asObservable()
-                            .pipe(operators.take(1))
-                            .subscribe(function () {
+                        (_a = _this.ngZone) === null || _a === void 0 ? void 0 : _a.onStable.asObservable().pipe(operators.take(1)).subscribe(function () {
                             _this.portalApp.router.navigateByUrl(event.url);
                         });
                     }
@@ -682,16 +1464,18 @@
             }));
         };
         PlanetApplicationRef.prototype.getRouter = function () {
-            return this.appModuleRef.injector.get(i3.Router);
+            var _a;
+            return (_a = this.appModuleRef) === null || _a === void 0 ? void 0 : _a.injector.get(i3.Router);
         };
         PlanetApplicationRef.prototype.getCurrentRouterStateUrl = function () {
-            return this.getRouter().routerState.snapshot.url;
+            var _a;
+            return (_a = this.getRouter()) === null || _a === void 0 ? void 0 : _a.routerState.snapshot.url;
         };
         PlanetApplicationRef.prototype.navigateByUrl = function (url) {
-            var ngZone = this.appModuleRef.injector.get(i0.NgZone);
+            var _a;
             var router = this.getRouter();
-            ngZone.run(function () {
-                router.navigateByUrl(url);
+            (_a = this.ngZone) === null || _a === void 0 ? void 0 : _a.run(function () {
+                router === null || router === void 0 ? void 0 : router.navigateByUrl(url);
             });
         };
         PlanetApplicationRef.prototype.getComponentFactory = function () {
@@ -706,8 +1490,11 @@
                 if (router) {
                     router.dispose();
                 }
+                if (this.sandbox) {
+                    this.sandbox.destroy();
+                }
                 this.appModuleRef.destroy();
-                delete this.appModuleRef;
+                this.appModuleRef = undefined;
             }
         };
         return PlanetApplicationRef;
@@ -738,10 +1525,13 @@
         }
     }
     function setPortalApplicationData(data) {
-        globalPlanet.portalApplication.data = data;
+        if (globalPlanet.portalApplication) {
+            globalPlanet.portalApplication.data = data;
+        }
     }
     function getPortalApplicationData() {
-        return globalPlanet.portalApplication.data;
+        var _a;
+        return (_a = globalPlanet.portalApplication) === null || _a === void 0 ? void 0 : _a.data;
     }
     function setApplicationLoader(loader) {
         globalPlanet.applicationLoader = loader;
@@ -962,7 +1752,7 @@
         _debugFactory = debug;
     }
     function clearDebugFactory() {
-        setDebugFactory(undefined);
+        _debugFactory = undefined;
         _debuggerMap = {};
     }
     function getDebugFactory() {
@@ -1128,7 +1918,7 @@
                                 debug("[routeChange] app(" + app.name + ") status is bootstrapped, show app and active");
                                 _this.showApp(app);
                                 var appRef = getPlanetApplicationRef(app.name);
-                                appRef.navigateByUrl(event.url);
+                                appRef === null || appRef === void 0 ? void 0 : appRef.navigateByUrl(event.url);
                                 _this.setAppStatus(app, exports.ApplicationStatus.active);
                                 _this.setLoadingDone();
                                 return rxjs.of(app);
@@ -1146,11 +1936,11 @@
                                 debug("[routeChange] app(" + app.name + ") is active, do nothings");
                                 var appRef = getPlanetApplicationRef(app.name);
                                 // Backwards compatibility sub app use old version which has not getCurrentRouterStateUrl
-                                var currentUrl = appRef.getCurrentRouterStateUrl
+                                var currentUrl = (appRef === null || appRef === void 0 ? void 0 : appRef.getCurrentRouterStateUrl)
                                     ? appRef.getCurrentRouterStateUrl()
                                     : '';
                                 if (currentUrl !== event.url) {
-                                    appRef.navigateByUrl(event.url);
+                                    appRef === null || appRef === void 0 ? void 0 : appRef.navigateByUrl(event.url);
                                 }
                                 return rxjs.of(app);
                             }
@@ -1222,14 +2012,14 @@
         };
         PlanetApplicationLoader.prototype.hideApp = function (planetApp) {
             var appRef = getPlanetApplicationRef(planetApp.name);
-            var appRootElement = document.querySelector(appRef.selector || planetApp.selector);
+            var appRootElement = document.querySelector((appRef === null || appRef === void 0 ? void 0 : appRef.selector) || planetApp.selector);
             if (appRootElement) {
                 appRootElement.setAttribute('style', 'display:none;');
             }
         };
         PlanetApplicationLoader.prototype.showApp = function (planetApp) {
             var appRef = getPlanetApplicationRef(planetApp.name);
-            var appRootElement = document.querySelector(appRef.selector || planetApp.selector);
+            var appRootElement = document.querySelector((appRef === null || appRef === void 0 ? void 0 : appRef.selector) || planetApp.selector);
             if (appRootElement) {
                 appRootElement.setAttribute('style', '');
             }
@@ -1240,9 +2030,9 @@
                 appRef.destroy();
             }
             var container = getHTMLElement(planetApp.hostParent);
-            var appRootElement = container.querySelector((appRef && appRef.selector) || planetApp.selector);
+            var appRootElement = container === null || container === void 0 ? void 0 : container.querySelector((appRef && appRef.selector) || planetApp.selector);
             if (appRootElement) {
-                container.removeChild(appRootElement);
+                container === null || container === void 0 ? void 0 : container.removeChild(appRootElement);
             }
         };
         PlanetApplicationLoader.prototype.bootstrapApp = function (app, defaultStatus) {
@@ -1266,10 +2056,10 @@
                         }
                         appRootElement_1.setAttribute('style', 'display:none;');
                         if (app.hostClass) {
-                            (_a = appRootElement_1.classList).add.apply(_a, __spread(coerceArray(app.hostClass)));
+                            (_a = appRootElement_1.classList).add.apply(_a, __spreadArray([], __read(coerceArray(app.hostClass))));
                         }
                         if (app.stylePrefix) {
-                            (_b = appRootElement_1.classList).add.apply(_b, __spread(coerceArray(app.stylePrefix)));
+                            (_b = appRootElement_1.classList).add.apply(_b, __spreadArray([], __read(coerceArray(app.stylePrefix))));
                         }
                         container.appendChild(appRootElement_1);
                     }
@@ -1341,13 +2131,15 @@
         PlanetApplicationLoader.prototype.preloadApps = function (activeApps) {
             var _this = this;
             setTimeout(function () {
-                var toPreloadApps = _this.planetApplicationService.getAppsToPreload(activeApps ? activeApps.map(function (item) { return item.name; }) : null);
+                var toPreloadApps = _this.planetApplicationService.getAppsToPreload(activeApps ? activeApps.map(function (item) { return item.name; }) : undefined);
                 debug("start preload apps: " + _this.getAppNames(toPreloadApps));
                 var loadApps$ = toPreloadApps.map(function (preloadApp) {
                     return _this.preloadInternal(preloadApp);
                 });
                 rxjs.forkJoin(loadApps$).subscribe({
-                    error: function (error) { return _this.errorHandler(error); }
+                    error: function (error) {
+                        _this.errorHandler(error);
+                    }
                 });
             });
         };
@@ -1383,6 +2175,9 @@
                             return _this.bootstrapApp(app, 'hidden');
                         });
                     }
+                }), operators.catchError(function (error) {
+                    _this.errorHandler(error);
+                    return rxjs.of(null);
                 }), operators.map(function () {
                     return getPlanetApplicationRef(app.name);
                 }));
@@ -1511,7 +2306,8 @@
             });
         };
         Planet.prototype.stop = function () {
-            this.subscription.unsubscribe();
+            var _a;
+            (_a = this.subscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
         };
         return Planet;
     }());
@@ -1693,10 +2489,9 @@
             });
         };
         PlanetComponentLoader.prototype.load = function (app, componentName, config) {
-            var _this = this;
             var result = this.getPlantAppRef(app).pipe(operators.delayWhen(function (appRef) {
                 if (appRef.getComponentFactory()) {
-                    return rxjs.of();
+                    return rxjs.of('');
                 }
                 else {
                     // Because register use 'setTimeout',so timer 20
@@ -1710,8 +2505,6 @@
                 else {
                     throw new Error(app + "'s component(" + componentName + ") is not registered");
                 }
-            }), operators.finalize(function () {
-                _this.applicationRef.tick();
             }), operators.shareReplay());
             result.subscribe();
             return result;