@blueking/bk-weweb 0.0.1

package/dist/collect-source.js

@@ -0,0 +1,2139 @@
+// app status
+var AppState;
+(function (AppState) {
+    AppState["UNSET"] = "UNSET";
+    AppState["LOADING"] = "LOADING";
+    AppState["LOADED"] = "LOADED";
+    AppState["ERROR"] = "ERROR";
+    AppState["MOUNTING"] = "MOUNTING";
+    AppState["MOUNTED"] = "MOUNTED";
+    AppState["ACTIVATED"] = "ACTIVATED";
+    AppState["DEACTIVATED"] = "DEACTIVATED";
+    AppState["UNMOUNT"] = "UNMOUNT";
+})(AppState || (AppState = {}));
+
+// is function
+function isFunction(target) {
+    return typeof target === 'function';
+}
+// Promise.then might be synchronized in Zone.js context, we need to use setTimeout instead to mock next tick.
+const nextTask = typeof window.Zone === 'function' ? setTimeout : cb => Promise.resolve().then(cb);
+function addUrlProtocol(url) {
+    return url.startsWith('//') ? `${location.protocol}${url}` : url;
+}
+// Get valid address, such as https://xxx/xx/xx.html to https://xxx/xx/
+function getUrlDir(url) {
+    const { origin, pathname } = new URL(url);
+    if (/\.(\w+)$/.test(pathname)) {
+        const fullPath = `${origin}${pathname}`;
+        const pathArr = fullPath.split('/');
+        pathArr.pop();
+        return `${pathArr.join('/')}/`;
+    }
+    return `${origin}${pathname}/`.replace(/\/\/$/, '/');
+}
+// 补齐url地址
+function fillUpPath(path, baseURI) {
+    if (!path || /^((((ht|f)tps?)|file):)?\/\//.test(path) || /^(data|blob):/.test(path))
+        return path;
+    return new URL(path, getUrlDir(addUrlProtocol(baseURI))).toString();
+}
+// 获取url目录
+function getFileDir(linkpath) {
+    const pathArr = linkpath.split('/');
+    pathArr.pop();
+    return addUrlProtocol(`${pathArr.join('/')}/`);
+}
+// is ie11
+const isIE11 = typeof navigator !== 'undefined' && navigator.userAgent.indexOf('Trident') !== -1;
+// 随机url
+function randomUrl() {
+    return `inline-${random(16)}`;
+}
+// Array deduplication
+function arrayUnique(array) {
+    return Array.from(new Set(array));
+}
+// is safari browser
+function isSafari() {
+    return /Safari/.test(navigator.userAgent);
+}
+// Create pure elements
+function createElement$1(tagName, options) {
+    const element = document.createElement(tagName, options);
+    if (element.__BK_WEWEB_APP_KEY__)
+        delete element.__BK_WEWEB_APP_KEY__;
+    return element;
+}
+// bodyle element
+function isBodyElement(key) {
+    return /^(body|head|html)$/i.test(key);
+}
+// create random string
+const random = (n, str = 'abcdefghijklmnopqrstuvwxyz0123456789') => {
+    // 生成n位长度的字符串
+    let result = '';
+    for (let i = 0; i < n; i++) {
+        result += str[parseInt((Math.random() * str.length).toString(), 10)];
+    }
+    return result;
+};
+
+let currentRunningApp = null;
+function getCurrentRunningApp() {
+    return currentRunningApp;
+}
+function setCurrentRunningApp(appInstance) {
+    currentRunningApp = appInstance;
+}
+const documentClickListMap = new Map();
+const documentEventListenerMap = new Map();
+const script = document.createElement('script');
+const isSupportModuleScript = 'noModule' in script;
+const SCOPED_CSS_STYLE_ID = 'SCOPED_CSS_STYLE_ID';
+const templateStyle = document.createElement('style');
+templateStyle.setAttribute('id', SCOPED_CSS_STYLE_ID);
+document.body.appendChild(templateStyle);
+templateStyle.sheet.disabled = true;
+const disabledStyleDom = templateStyle;
+
+const { document: document$1 } = window;
+const { createElement, querySelector, querySelectorAll, getElementById, getElementsByClassName, getElementsByTagName, getElementsByName, } = Document.prototype;
+function rewriteDocumentPrototypeMethods() {
+    Document.prototype.createElement = function (tagName, options) {
+        const element = createElement.call(this, tagName, options);
+        const app = getCurrentRunningApp();
+        // img.src = '' iframe.src = '' 均不能在setAttributes上监听 但是这里所有的src都是 全地址 无法判断是否需要添加子应用域名
+        // if (tagName.toLocaleLowerCase() === 'img') {
+        //   const observer = new MutationObserver((list, observer) =>  {
+        //     observer.disconnect();
+        //     const url = new URL((element as HTMLImageElement).src)
+        //     (element as HTMLImageElement).src = `${}`
+        //   });
+        //   observer.observe(element, { attributeFilter: ['src'], subtree: false, childList: false });
+        // }
+        if (app)
+            element.__BK_WEWEB_APP_KEY__ = app.appCacheKey;
+        return element;
+    };
+    function querySelectorNew(selectors) {
+        const app = getCurrentRunningApp();
+        if (!app || !selectors || isBodyElement(selectors) || document$1 !== this) {
+            return querySelector.call(this, selectors);
+        }
+        return app?.container?.querySelector(selectors) ?? null;
+    }
+    function querySelectorAllNew(selectors) {
+        const app = getCurrentRunningApp();
+        if (!app || !selectors || isBodyElement(selectors) || document$1 !== this) {
+            return querySelectorAll.call(this, selectors);
+        }
+        return app?.container?.querySelectorAll(selectors) ?? [];
+    }
+    Document.prototype.querySelector = querySelectorNew;
+    Document.prototype.querySelectorAll = querySelectorAllNew;
+    Document.prototype.getElementById = function getElementByIdNew(key) {
+        if (!getCurrentRunningApp()) {
+            return getElementById.call(this, key);
+        }
+        try {
+            return querySelectorNew.call(this, `#${key}`);
+        }
+        catch {
+            return getElementById.call(this, key);
+        }
+    };
+    Document.prototype.getElementsByClassName = function (key) {
+        if (!getCurrentRunningApp()) {
+            return getElementsByClassName.call(this, key);
+        }
+        try {
+            return querySelectorAllNew.call(this, `.${key}`);
+        }
+        catch {
+            return getElementsByClassName.call(this, key);
+        }
+    };
+    // eslint-disable-next-line max-len
+    Document.prototype.getElementsByTagName = function (key) {
+        const app = getCurrentRunningApp();
+        if (!app
+            || isBodyElement(key)
+            || (!app?.showSourceCode && key.toLocaleLowerCase() === 'script')) {
+            return getElementsByTagName.call(this, key);
+        }
+        try {
+            return querySelectorAllNew.call(this, key);
+        }
+        catch {
+            return getElementsByTagName.call(this, key);
+        }
+    };
+    Document.prototype.getElementsByName = function (key) {
+        if (!getCurrentRunningApp()) {
+            return getElementsByName.call(this, key);
+        }
+        try {
+            return querySelectorAllNew.call(this, `[name=${key}]`);
+        }
+        catch {
+            return getElementsByName.call(this, key);
+        }
+    };
+}
+function resetDocumentPrototypeMethods() {
+    Document.prototype.createElement = createElement;
+    Document.prototype.querySelector = querySelector;
+    Document.prototype.querySelectorAll = querySelectorAll;
+    Document.prototype.getElementById = getElementById;
+    Document.prototype.getElementsByClassName = getElementsByClassName;
+    Document.prototype.getElementsByTagName = getElementsByTagName;
+    Document.prototype.getElementsByName = getElementsByName;
+}
+
+const CSS_ATTRIBUTE_KEY = 'id';
+var CSS_RULE_TYPE;
+(function (CSS_RULE_TYPE) {
+    CSS_RULE_TYPE[CSS_RULE_TYPE["STYLE_RULE"] = 1] = "STYLE_RULE";
+    CSS_RULE_TYPE[CSS_RULE_TYPE["MEDIA_RULE"] = 4] = "MEDIA_RULE";
+    CSS_RULE_TYPE[CSS_RULE_TYPE["SUPPORTS_RULE"] = 12] = "SUPPORTS_RULE";
+})(CSS_RULE_TYPE || (CSS_RULE_TYPE = {}));
+
+const commonEScapeKeyList = ['System', '__cjsWrapper', '__REACT_ERROR_OVERLAY_GLOBAL_HOOK__'];
+// 共享主应用上下文属性名
+const escapeSetterKeyList = ['location'];
+// 一定需要在子应用自身上下文获取的属性名
+const scopeWindowKeyList = ['webpackJsonp', '__POWERED_BY_BK_WEWEB__', '__BK_WEWEB_APP_KEY__', '__BK_WEWEB_DATA__'];
+// 设置了scopedLocation 后需要监听属性名
+const scopedLocationKeyList = ['location', 'history'];
+var DescriptorMapValue;
+(function (DescriptorMapValue) {
+    DescriptorMapValue["TARGET"] = "TARGET";
+    DescriptorMapValue["WINDOW"] = "WINDOW";
+})(DescriptorMapValue || (DescriptorMapValue = {}));
+const commonRawWindowKeyMap = {
+    undefined: true,
+    Array: true,
+    Object: true,
+    String: true,
+    Boolean: true,
+    Math: true,
+    Reflect: true,
+    Function: true,
+    Number: true,
+    Symbol: true,
+    parseFloat: true,
+    parseInt: true,
+    Float32Array: true,
+    Set: true,
+    Infinity: true,
+    navigator: true,
+    devicePixelRatio: true,
+    Promise: true,
+    HTMLElement: true,
+    Map: true,
+    Element: true,
+    performance: true,
+    console: true,
+    isFinite: true,
+    RegExp: true,
+    JSON: true,
+    Date: true,
+    Proxy: true,
+    isNaN: true,
+    WeakMap: true,
+    WeakSet: true,
+    Uint8Array: true,
+    // btoa: true,
+    // unescape: true,
+    // WebSocket: true,
+    // encodeURIComponent: true,
+    // decodeURIComponent: true,
+    // ArrayBuffer: true,
+    // XMLHttpRequest: true,
+    // SVGElement: true,
+    // URLSearchParams: true,
+    // URL: true,
+    // RangeError: true,
+    // TypeError: true,
+    // Uint16Array: true,
+    // Uint32Array: true,
+    // Float64Array: true,
+    // Int32Array: true,
+    // requestAnimationFrame: true,
+    // SVGRect: true,
+    // Error: true,
+    // Buffer: true,
+    // SyntaxError: true,
+    // DataView: true,
+    // Worker: true,
+    // localStorage: true,
+    // Text: true,
+    // FormData: true,
+    // ShadowRoot: true,
+    // encodeURI: true,
+    // crypto: true,
+    // HTMLAnchorElement: true,
+    // Int8Array: true,
+    // FinalizationRegistry: true,
+    // BigInt: true,
+    // Atomics: true,
+    // Uint8ClampedArray: true,
+    // WeakRef: true,
+    // getComputedStyle,
+    // innerHeight: true,
+    // innerWidth: true,
+    // getComputedStyle: true,
+};
+const commonFakeWindowKeyMap = {
+    __VUE_OPTIONS_API__: true,
+    __VUE_I18N_LEGACY_API__: true,
+    __VUE_I18N_FULL_INSTALL__: true,
+    __VUE_DEVTOOLS_GLOBAL_HOOK__: true,
+    __VUE_DEVTOOLS_HOOK_REPLAY__: true,
+    __VUE_DEVTOOLS_PLUGINS__: true,
+    __DEV__: true,
+    webpackChunktrace: true,
+    i18n: true,
+    '__core-js_shared__': true,
+};
+
+function eventHandler(event, element) {
+    Object.defineProperties(event, {
+        currentTarget: {
+            get() {
+                return element;
+            },
+        },
+        srcElement: {
+            get() {
+                return element;
+            },
+        },
+        target: {
+            get() {
+                return element;
+            },
+        },
+    });
+}
+function dispatchLinkOrScriptLoad(element) {
+    const event = new CustomEvent('load');
+    eventHandler(event, element);
+    if (isFunction(element.onload)) {
+        element.onload(event);
+    }
+    else {
+        element.dispatchEvent(event);
+    }
+}
+function dispatchLinkOrScriptError(element) {
+    const event = new CustomEvent('error');
+    eventHandler(event, element);
+    if (isFunction(element.onerror)) {
+        element.onerror(event);
+    }
+    else {
+        element.dispatchEvent(event);
+    }
+}
+
+/* eslint-disable no-param-reassign */
+class Style {
+    scopedCode = '';
+    code = '';
+    prefetch = false;
+    preload = false;
+    url;
+    scoped;
+    fromHtml;
+    initial;
+    constructor({ code, prefetch, preload, url, fromHtml, initial }) {
+        this.scoped = false;
+        this.code = code;
+        this.prefetch = prefetch ?? false;
+        this.preload = preload ?? false;
+        this.url = url;
+        this.fromHtml = fromHtml;
+        this.initial = initial ?? false;
+    }
+    async getCode(app) {
+        if (this.code.length || !this.url) {
+            return this.code;
+        }
+        let code = '';
+        if (app?.source?.styles?.has(this.url)) {
+            code = app.source.styles.get(this.url)?.code || '';
+        }
+        if (!code && appCache.getCacheStyle(this.url)) {
+            const style = appCache.getCacheStyle(this.url);
+            code = style?.code || '';
+        }
+        if (!code) {
+            code = await fetchSource(this.url).catch(() => '');
+        }
+        this.code = code;
+        return code;
+    }
+    async excuteCode(app) {
+        app.registerRunningApp();
+        let styleElement = createElement$1('style');
+        styleElement.setAttribute('type', 'text/css');
+        styleElement.textContent = this.code;
+        try {
+            if (!this.code)
+                await this.getCode(app);
+            styleElement = this.scopedStyleCSS(app, styleElement);
+            this.scoped = true;
+        }
+        catch (e) {
+            console.error('scoped style error', e);
+        }
+        return styleElement;
+    }
+    scopedStyleCSS(app, styleElement) {
+        const needKeepAlive = !!app.keepAlive && !(app.container instanceof ShadowRoot);
+        setMarkElement(styleElement, app, needKeepAlive);
+        if (this.code || styleElement.textContent) {
+            if (styleElement.textContent) {
+                styleElement.textContent = '';
+                styleElement.innerHTML = '';
+            }
+            disabledStyleDom.textContent = this.code;
+            this.commonScoped(disabledStyleDom, styleElement, app);
+            disabledStyleDom.textContent = '';
+        }
+        else {
+            const observer = new MutationObserver(() => {
+                if (!(styleElement.textContent || styleElement.sheet?.cssRules?.length))
+                    return;
+                observer.disconnect();
+                this.commonScoped(styleElement, styleElement, app);
+            });
+            observer.observe(styleElement, { attributes: false, childList: true, subtree: true, characterData: true });
+        }
+        this.url && styleElement.setAttribute('origin-src', this.url);
+        return styleElement;
+    }
+    scopedLinkCSS(app, linkElement) {
+        const styleElement = createElement$1('style');
+        styleElement.setAttribute('type', 'text/css');
+        const needKeepAlive = !!app.keepAlive && !(app.container instanceof ShadowRoot);
+        setMarkElement(styleElement, app, needKeepAlive);
+        const container = needKeepAlive ? document.head : app.container;
+        try {
+            if (this.code) {
+                disabledStyleDom.textContent = styleElement.textContent || this.code;
+                this.commonScoped(disabledStyleDom, styleElement, app);
+                container?.prepend(styleElement);
+                linkElement && dispatchLinkOrScriptLoad(linkElement);
+                disabledStyleDom.textContent = '';
+            }
+            else if (linkElement.getAttribute('href')) {
+                this.url = fillUpPath(linkElement.getAttribute('href'), app.url);
+                this.getCode(app).then(() => {
+                    this.scopedStyleCSS(app, styleElement);
+                    linkElement.remove();
+                    container?.prepend(styleElement);
+                    linkElement && dispatchLinkOrScriptLoad(linkElement);
+                    this.scoped = true;
+                });
+            }
+            else {
+                const observer = new MutationObserver(() => {
+                    if (!linkElement.href)
+                        return;
+                    observer.disconnect();
+                    this.url = fillUpPath(linkElement.getAttribute('href'), app.url);
+                    this.getCode(app).then(() => {
+                        this.scopedStyleCSS(app, styleElement);
+                        linkElement.remove();
+                        container?.prepend(styleElement);
+                        linkElement && dispatchLinkOrScriptLoad(linkElement);
+                        this.scoped = true;
+                    });
+                });
+                observer.observe(linkElement, { attributeFilter: ['href'], subtree: false, childList: false });
+            }
+        }
+        catch {
+            linkElement && dispatchLinkOrScriptError(linkElement);
+        }
+        return styleElement;
+    }
+    commonScoped(templateStyle, styleElement, app) {
+        if (app.scopeCss && !(app.container instanceof ShadowRoot)) {
+            const rules = Array.from(templateStyle.sheet?.cssRules ?? []);
+            const cssPrefix = `#${app.name}`;
+            const scopedCss = this.scopeRule(rules, cssPrefix);
+            let cssText = this.resetUrlHost(scopedCss, app.url, this.url);
+            if (isSafari()) {
+                cssText = cssText.replace(/([;{]\s*content:\s*)([^\s"][^";}]*)/gm, (all, $1, $2) => {
+                    if ($2 === 'none' || /^(url\()|(counter\()|(attr\()|(open-quote)|(close-quote)/.test($2)) {
+                        return all;
+                    }
+                    return `${$1}"${$2}"`;
+                });
+            }
+            styleElement.textContent = cssText;
+            this.scopedCode = cssText;
+        }
+        else {
+            const cssText = this.resetUrlHost(styleElement.textContent || templateStyle.textContent || '', app.url, this.url);
+            styleElement.textContent = cssText;
+        }
+        this.scoped = true;
+    }
+    scopeRule(rules, cssPrefix) {
+        let result = '';
+        for (const rule of rules) {
+            switch (rule.type) {
+                case CSS_RULE_TYPE.STYLE_RULE:
+                    result += this.scopeStyleRule(rule, cssPrefix);
+                    break;
+                case CSS_RULE_TYPE.MEDIA_RULE:
+                    result += this.resetPackRule(rule, cssPrefix, 'media');
+                    break;
+                case CSS_RULE_TYPE.SUPPORTS_RULE:
+                    result += this.resetPackRule(rule, cssPrefix, 'supports');
+                    break;
+                default:
+                    result += rule.cssText;
+                    break;
+            }
+        }
+        return result.replace(/^\s+/, '');
+    }
+    resetPackRule(rule, prefix, packName) {
+        const result = this.scopeRule(Array.from(rule.cssRules), prefix);
+        return `@${packName} ${rule.conditionText} {${result}}`;
+    }
+    resetUrlHost(cssText, baseURI, linkpath) {
+        return cssText.replace(/url\(["']?([^)"']+)["']?\)/gm, (text, $1) => {
+            if (/^(data|blob):/.test($1) || /^(https?:)?\/\//.test($1)) {
+                return text;
+            }
+            if (/^((\.\.?\/)|[^/])/.test($1) && linkpath) {
+                baseURI = getFileDir(linkpath);
+            }
+            return `url("${fillUpPath($1, baseURI)}")`;
+        });
+    }
+    scopeStyleRule(rule, prefix) {
+        const { selectorText, cssText } = rule;
+        if (/^((html[\s>~,]+body)|(html|body|:root))$/.test(selectorText)) {
+            return cssText.replace(/^((html[\s>~,]+body)|(html|body|:root))/, prefix);
+        }
+        if (selectorText === '*') {
+            return cssText.replace('*', `${prefix} *`);
+        }
+        const builtInRootSelectorRE = /(^|\s+)((html[\s>~]+body)|(html|body|:root))(?=[\s>~]+|$)/;
+        return cssText.replace(/^[\s\S]+{/, selectors => selectors.replace(/(^|,)([^,]+)/g, (all, $1, $2) => {
+            if (builtInRootSelectorRE.test($2)) {
+                return all.replace(builtInRootSelectorRE, prefix);
+            }
+            return `${$1} ${prefix} ${$2.replace(/^\s*/, '')}`;
+        }));
+    }
+}
+async function excuteAppStyles(app, container) {
+    const styleList = Array.from(app.source.styles.values());
+    const promiseList = [];
+    styleList.forEach((style) => {
+        promiseList.push(style.excuteCode(app));
+    });
+    await Promise.all(promiseList).then((styleElementList) => {
+        const parentElemnt = container || app.container;
+        if (app.keepAlive && !(parentElemnt instanceof ShadowRoot)) {
+            document.head.append(...styleElementList);
+        }
+        else {
+            parentElemnt?.prepend(...styleElementList);
+        }
+    });
+}
+
+const { appendChild: bodyAppendChild$1 } = HTMLBodyElement.prototype;
+function resetNewElement(parent, child, app) {
+    if (child instanceof HTMLStyleElement) {
+        if (child.hasAttribute('exclude')) {
+            return document.createComment('【bk-weweb】style with exclude attribute is ignored');
+        }
+        if (!child.hasAttribute('ignore')) {
+            const styleInstance = new Style({
+                code: child.textContent || '',
+                url: '',
+                fromHtml: false,
+            });
+            app.source?.setStyle(randomUrl(), styleInstance);
+            styleInstance.scopedStyleCSS(app, child);
+        }
+        return child;
+    }
+    if (child instanceof HTMLLinkElement) {
+        const result = app.source?.collectLink(child, parent, true);
+        if (!result)
+            return child;
+        if (result.style) {
+            result.style.scopedLinkCSS(app, child);
+        }
+        if (result.replace !== child) {
+            return result.replace;
+        }
+        return child;
+    }
+    if (child instanceof HTMLScriptElement) {
+        const replaceInfo = app.source.collectScript(child, parent, true);
+        if (!replaceInfo) {
+            return child;
+        }
+        if (replaceInfo.script) {
+            replaceInfo.script.excuteCode(app);
+        }
+        if (replaceInfo.replace !== child) {
+            return replaceInfo.replace;
+        }
+        if (app.scopeJs && !child.getAttribute('src') && !child.textContent) {
+            const observer = new MutationObserver(() => {
+                if (child.getAttribute('src')) {
+                    observer.disconnect();
+                    const scriptInfo = app.source.collectScript(child, parent, true);
+                    if (scriptInfo?.replace) {
+                        bodyAppendChild$1.call(app.container, scriptInfo.replace);
+                    }
+                    if (scriptInfo?.script) {
+                        scriptInfo.script.excuteCode(app);
+                    }
+                    child.remove();
+                }
+                else if (child.textContent) {
+                    observer.disconnect();
+                    const scriptInstance = new Script({
+                        code: child.textContent,
+                        async: false,
+                        defer: child.type === 'module',
+                        isModule: child.type === 'module',
+                        fromHtml: false,
+                    });
+                    app.source.scripts.set(randomUrl(), scriptInstance);
+                    try {
+                        scriptInstance.excuteCode(app);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                    finally {
+                        !scriptInstance.isModule && dispatchLinkOrScriptLoad(child);
+                        child.remove();
+                    }
+                }
+            });
+            observer.observe(child, { attributeFilter: ['src'], childList: true, subtree: false });
+            return document.createComment('【bk-weweb】dynamic script or module');
+        }
+        return child;
+    }
+    return child;
+}
+function isSepcailElement(node) {
+    return node instanceof HTMLScriptElement
+        || node instanceof HTMLStyleElement
+        || node instanceof HTMLLinkElement;
+}
+function elmentAppendHandler(parent, newChild, rawMethod) {
+    if (newChild.__BK_WEWEB_APP_KEY__) {
+        const app = appCache.getApp(newChild.__BK_WEWEB_APP_KEY__);
+        if (app?.container) {
+            const targetChild = resetNewElement(parent, newChild, app);
+            const needKeepAlive = isSepcailElement(newChild) && !!app.keepAlive && !(app.container instanceof ShadowRoot);
+            const container = needKeepAlive ? document.head : app?.container;
+            setMarkElement(targetChild, app, needKeepAlive);
+            return rawMethod.call(container, targetChild);
+        }
+    }
+    return rawMethod.call(parent, newChild);
+}
+function elementInsertHandler(parent, newChild, passiveChild, rawMethod) {
+    if (newChild.__BK_WEWEB_APP_KEY__) {
+        const app = appCache.getApp(newChild.__BK_WEWEB_APP_KEY__);
+        if (app?.container) {
+            const needKeepAlive = isSepcailElement(newChild) && app.keepAlive && !(app.container instanceof ShadowRoot);
+            const container = needKeepAlive ? document.head : app?.container;
+            const targetChild = resetNewElement(parent, newChild, app);
+            if (needKeepAlive) {
+                targetChild.__KEEP_ALIVE__ = app.appCacheKey;
+                targetChild.setAttribute('data-from', app.name);
+                targetChild.setAttribute('data-keep-alive', 'true');
+            }
+            if (passiveChild && !container.contains(passiveChild)) {
+                return bodyAppendChild$1.call(container, targetChild);
+            }
+            return rawMethod.call(container, targetChild, passiveChild);
+        }
+    }
+    return rawMethod.call(parent, newChild, passiveChild);
+}
+function setMarkElement(element, app, keepAlive) {
+    if (keepAlive) {
+        element.__KEEP_ALIVE__ = app.appCacheKey;
+        element.setAttribute('data-from', app.name);
+        element.setAttribute('data-keep-alive', 'true');
+    }
+    element.setAttribute?.('powered-by', 'bk-weweb');
+    return element;
+}
+
+const { setAttribute } = Element.prototype;
+const { appendChild: bodyAppendChild, removeChild: bodyRemoveChild, append, } = HTMLBodyElement.prototype;
+const { appendChild: headAppendChild, removeChild: headRemoveChild, insertBefore: headInsertBefore, } = HTMLHeadElement.prototype;
+const rawHead = document.head;
+function rewriteBodyAndHeaderMethods() {
+    Element.prototype.setAttribute = function (key, value) {
+        const tagName = this.tagName.toLocaleUpperCase();
+        if (((['src', 'srcset'].includes(key) && ['SCRIPT', 'IMG'].includes(tagName))
+            || (key === 'href' && ['LINK'].includes(tagName)))
+            && this.__BK_WEWEB_APP_KEY__
+            && appCache.getApp(this.__BK_WEWEB_APP_KEY__ || '')) {
+            setAttribute.call(this, key, fillUpPath(value, appCache.getApp(this.__BK_WEWEB_APP_KEY__).url));
+        }
+        else {
+            setAttribute.call(this, key, value);
+        }
+    };
+    HTMLBodyElement.prototype.appendChild = function appendChildNew(newChild) {
+        if (newChild.__KEEP_ALIVE__ && isSepcailElement(newChild))
+            return headAppendChild.call(rawHead, newChild);
+        return elmentAppendHandler(this, newChild, bodyAppendChild);
+    };
+    HTMLBodyElement.prototype.append = function (...nodes) {
+        let i = 0;
+        const { length } = nodes;
+        while (i < length) {
+            if (nodes[i].__KEEP_ALIVE__ && isSepcailElement(nodes[i])) {
+                return headAppendChild.call(rawHead, nodes[i]);
+            }
+            elmentAppendHandler(this, nodes[i], bodyAppendChild);
+            i += 1;
+        }
+    };
+    HTMLHeadElement.prototype.appendChild = HTMLBodyElement.prototype.appendChild;
+    HTMLHeadElement.prototype.insertBefore = function (newChild, refChild) {
+        return elementInsertHandler(this, newChild, refChild, headInsertBefore);
+    };
+    HTMLBodyElement.prototype.removeChild = function removeChildNew(oldChild) {
+        const app = appCache.getApp(oldChild.__BK_WEWEB_APP_KEY__);
+        if (app?.container?.contains(oldChild)) {
+            const node = bodyRemoveChild.call(app.container, oldChild);
+            return node;
+        }
+        if (this.contains(oldChild)) {
+            return bodyRemoveChild.call(this, oldChild);
+        }
+        return oldChild;
+    };
+    HTMLHeadElement.prototype.removeChild = HTMLBodyElement.prototype.removeChild;
+}
+function resetBodyAndHeaderMethods() {
+    setCurrentRunningApp(null);
+    Element.prototype.setAttribute = setAttribute;
+    HTMLBodyElement.prototype.appendChild = bodyAppendChild;
+    HTMLBodyElement.prototype.append = append;
+    HTMLBodyElement.prototype.removeChild = bodyRemoveChild;
+    HTMLHeadElement.prototype.appendChild = headAppendChild;
+    HTMLHeadElement.prototype.insertBefore = headInsertBefore;
+    HTMLHeadElement.prototype.removeChild = headRemoveChild;
+}
+
+function beforeLoad() {
+    rewriteBodyAndHeaderMethods();
+    rewriteDocumentPrototypeMethods();
+}
+
+const constructorMap = new WeakMap();
+function isConstructor(value) {
+    if (constructorMap.has(value)) {
+        return constructorMap.get(value);
+    }
+    const valueStr = value.toString();
+    const result = (value.prototype
+        && value.prototype.constructor === value
+        && Object.getOwnPropertyNames(value.prototype).length > 1)
+        || /^function\s+[A-Z]/.test(valueStr)
+        || /^class\s+/.test(valueStr);
+    constructorMap.set(value, result);
+    return result;
+}
+const rawWindowMethodMap = new WeakMap();
+function bindFunctionToRawWindow(rawWindow, value) {
+    if (rawWindowMethodMap.has(value)) {
+        return rawWindowMethodMap.get(value);
+    }
+    if (isFunction(value) && !isConstructor(value)) {
+        const bindRawWindowValue = value.bind(rawWindow);
+        Object.keys(value).forEach(key => (bindRawWindowValue[key] = value[key]));
+        // eslint-disable-next-line no-prototype-builtins
+        if (value.hasOwnProperty('prototype') && !bindRawWindowValue.hasOwnProperty('prototype')) {
+            bindRawWindowValue.prototype = value.prototype;
+        }
+        rawWindowMethodMap.set(value, bindRawWindowValue);
+        return bindRawWindowValue;
+    }
+    return value;
+}
+
+/* eslint-disable no-param-reassign */
+// rewrite document and body event listener
+function rewriteDocumentAndBodyEvent() {
+    const { addEventListener, removeEventListener } = window.document;
+    const { addEventListener: bodyAddEventListener, removeEventListener: bodyRemoveEventListener } = window.document.body;
+    document.addEventListener = function (type, listener, options) {
+        const app = getCurrentRunningApp();
+        if (app) {
+            const appListenersMap = documentEventListenerMap.get(app.appCacheKey);
+            if (appListenersMap) {
+                const appListenerList = appListenersMap.get(type);
+                if (appListenerList) {
+                    appListenerList.add(listener);
+                }
+                else {
+                    appListenersMap.set(type, new Set([listener]));
+                }
+            }
+            else {
+                documentEventListenerMap.set(app.appCacheKey, new Map([[type, new Set([listener])]]));
+            }
+        }
+        addEventListener.call(app?.container instanceof ShadowRoot ? app.container : this, type, listener, options);
+    };
+    document.body.addEventListener = document.addEventListener;
+    document.removeEventListener = function (type, listener, options) {
+        const app = getCurrentRunningApp();
+        if (app) {
+            const appListenersMap = documentEventListenerMap.get(app.appCacheKey);
+            if (appListenersMap) {
+                const appListenerList = appListenersMap.get(type);
+                if (appListenerList?.size && appListenerList.has(listener)) {
+                    appListenerList.delete(listener);
+                }
+            }
+        }
+        removeEventListener.call(app?.container instanceof ShadowRoot ? app.container : this, type, listener, options);
+    };
+    document.body.removeEventListener = document.removeEventListener;
+    function resetDocumentAndBodyEvent() {
+        document.addEventListener = addEventListener;
+        document.body.addEventListener = bodyAddEventListener;
+        document.removeEventListener = removeEventListener;
+        document.body.removeEventListener = bodyRemoveEventListener;
+    }
+    return {
+        resetDocumentAndBodyEvent,
+    };
+}
+// rewrite window funtion like settimeout setinterval ...
+function rewriteWindowFunction(fakeWindow) {
+    const app = getCurrentRunningApp();
+    const eventListenerMap = new Map();
+    const intervalIdMap = new Map();
+    const timeoutIdMap = new Map();
+    const rawWindow = window;
+    const rawDocument = window.document;
+    const { addEventListener, removeEventListener, setInterval, setTimeout, clearInterval, clearTimeout } = window;
+    const { removeEventListener: documentRemoveEventListener } = window.document;
+    // listener may be null, e.g test-passive
+    fakeWindow.addEventListener = function (type, listener, options) {
+        const listenerList = eventListenerMap.get(type);
+        if (listenerList) {
+            listenerList.add(listener);
+        }
+        else {
+            eventListenerMap.set(type, new Set([listener]));
+        }
+        addEventListener.call(rawWindow, type, listener, options);
+    };
+    fakeWindow.removeEventListener = function (type, listener, options) {
+        const listenerList = eventListenerMap.get(type);
+        if (listenerList?.size && listenerList.has(listener)) {
+            listenerList.delete(listener);
+        }
+        removeEventListener.call(rawWindow, type, listener, options);
+    };
+    fakeWindow.setInterval = function (handler, timeout, ...args) {
+        const intervalId = setInterval.call(rawWindow, handler, timeout, ...args);
+        intervalIdMap.set(intervalId, { handler, timeout, args });
+        return intervalId;
+    };
+    fakeWindow.setTimeout = function (handler, timeout, ...args) {
+        const timeoutId = setTimeout.call(rawWindow, handler, timeout, ...args);
+        timeoutIdMap.set(timeoutId, { handler, timeout, args });
+        return timeoutId;
+    };
+    fakeWindow.clearInterval = function (intervalId) {
+        intervalIdMap.delete(intervalId);
+        clearInterval.call(rawWindow, intervalId);
+    };
+    fakeWindow.clearTimeout = function (timeoutId) {
+        timeoutIdMap.delete(timeoutId);
+        clearTimeout.call(rawWindow, timeoutId);
+    };
+    // reset all event listener & interval & timeout when unmount app
+    const resetWindowFunction = () => {
+        // clear window events listener
+        if (eventListenerMap.size) {
+            eventListenerMap.forEach((listenerList, type) => {
+                for (const listener of listenerList) {
+                    removeEventListener.call(rawWindow, type, listener);
+                }
+            });
+            eventListenerMap.clear();
+        }
+        // clear settimeout timers
+        if (intervalIdMap.size) {
+            intervalIdMap.forEach((_, intervalId) => {
+                clearInterval.call(rawWindow, intervalId);
+            });
+            intervalIdMap.clear();
+        }
+        if (timeoutIdMap.size) {
+            timeoutIdMap.forEach((_, timeoutId) => {
+                clearTimeout.call(rawWindow, timeoutId);
+            });
+            timeoutIdMap.clear();
+        }
+        if (app) {
+            documentClickListMap.delete(app.appCacheKey);
+            const documentAppListenersMap = documentEventListenerMap.get(app.appCacheKey);
+            if (documentAppListenersMap) {
+                documentAppListenersMap.forEach((listenerList, type) => {
+                    for (const listener of listenerList) {
+                        documentRemoveEventListener.call(rawDocument, type, listener);
+                    }
+                });
+                documentAppListenersMap.clear();
+            }
+        }
+    };
+    return {
+        resetWindowFunction,
+    };
+}
+
+/* eslint-disable no-new-func */
+class SandBox {
+    app;
+    resetWindowFunction;
+    resetDocumentAndBodyEvent;
+    injectedKeySet = new Set();
+    escapedKeySet = new Set();
+    active = false;
+    rawWindow;
+    rawDocument;
+    proxyWindow;
+    fakeWindow = {};
+    windowSymbolKey;
+    constructor(app) {
+        this.app = app;
+        const descriptorMap = new Map();
+        const rawWindow = window;
+        const rawDocument = window.document;
+        this.fakeWindow.__POWERED_BY_BK_WEWEB__ = true;
+        this.fakeWindow.__BK_WEWEB_APP_KEY__ = app.appCacheKey;
+        this.rawWindow = rawWindow;
+        this.rawDocument = rawDocument;
+        this.fakeWindow.rawWindow = rawWindow;
+        this.fakeWindow.rawDocument = rawDocument;
+        const { resetWindowFunction } = rewriteWindowFunction(this.fakeWindow);
+        this.resetWindowFunction = resetWindowFunction;
+        this.windowSymbolKey = `__${(app.name || app.appCacheKey).replace(/(-|,|:|~|'|")/gmi, '_')}_${random(10)}__`;
+        this.proxyWindow = new Proxy(this.fakeWindow, {
+            get: (target, key) => {
+                if (commonRawWindowKeyMap[key] || key === Symbol.unscopables)
+                    return rawWindow[key];
+                if (commonFakeWindowKeyMap[key])
+                    return this.fakeWindow[key];
+                if (['window', 'self', 'globalThis'].includes(key))
+                    return this.proxyWindow;
+                if (key === 'document' || key === 'eval') {
+                    app.registerRunningApp();
+                    // eslint-disable-next-line no-eval
+                    return key === 'document' ? rawDocument : eval;
+                }
+                if (scopedLocationKeyList.includes(key)
+                    && this.app instanceof MicroAppModel
+                    && this.app.iframe
+                    && this.app.scopeLocation) {
+                    return this.app.iframe.contentWindow?.[key];
+                }
+                // if (key === Symbol.unscopables) return com;
+                if (key === 'hasOwnProperty')
+                    return (key) => this.fakeWindow.hasOwnProperty(key) || rawWindow.hasOwnProperty(key);
+                if (key === 'top' || key === 'parent') {
+                    if (rawWindow === rawWindow.parent) {
+                        return this.proxyWindow;
+                    }
+                    return Reflect.get(rawWindow, key); // iframe
+                }
+                if (Reflect.has(target, key)
+                    || scopeWindowKeyList.includes(key))
+                    return Reflect.get(target, key);
+                const rawValue = Reflect.get(rawWindow, key);
+                return bindFunctionToRawWindow(rawWindow, rawValue);
+            },
+            set: (target, key, value) => {
+                if (this.active) {
+                    if (scopedLocationKeyList.includes(key)
+                        && this.app instanceof MicroAppModel
+                        && this.app.iframe
+                        && this.app.scopeLocation) {
+                        return Reflect.set(this.app.iframe.contentWindow, key, value);
+                    }
+                    if (escapeSetterKeyList.includes(key)) {
+                        Reflect.set(rawWindow, key, value);
+                    }
+                    else if (!target.hasOwnProperty(key)
+                        && rawWindow.hasOwnProperty(key)
+                        && !scopeWindowKeyList.includes(key)) {
+                        const descriptor = Object.getOwnPropertyDescriptor(rawWindow, key);
+                        const { writable, configurable, enumerable } = descriptor;
+                        if (writable) {
+                            Object.defineProperty(target, key, {
+                                configurable,
+                                enumerable,
+                                writable,
+                                value,
+                            });
+                            this.injectedKeySet.add(key);
+                        }
+                    }
+                    else {
+                        Reflect.set(target, key, value);
+                        this.injectedKeySet.add(key);
+                    }
+                    if ((commonEScapeKeyList.includes(key) && !Reflect.has(rawWindow, key))
+                        && !scopeWindowKeyList.includes(key)) {
+                        Reflect.set(rawWindow, key, value);
+                        this.escapedKeySet.add(key);
+                    }
+                }
+                return true;
+            },
+            has: (target, key) => commonRawWindowKeyMap[key]
+                || key in target
+                || key in rawWindow,
+            getOwnPropertyDescriptor: (target, key) => {
+                if (target.hasOwnProperty(key)) {
+                    return Object.getOwnPropertyDescriptor(target, key);
+                }
+                if (rawWindow.hasOwnProperty(key)) {
+                    descriptorMap.set(key, DescriptorMapValue.WINDOW);
+                    const descriptor = Object.getOwnPropertyDescriptor(rawWindow, key);
+                    if (descriptor && !descriptor.configurable) {
+                        descriptor.configurable = true;
+                    }
+                    return descriptor;
+                }
+                return undefined;
+            },
+            // Object.defineProperty(window, key, Descriptor)
+            defineProperty: (target, key, value) => {
+                const from = descriptorMap.get(key);
+                if (from === DescriptorMapValue.WINDOW) {
+                    return Reflect.defineProperty(rawWindow, key, value);
+                }
+                return Reflect.defineProperty(target, key, value);
+            },
+            // Object.getOwnPropertyNames(window)
+            ownKeys: (target) => arrayUnique(Reflect.ownKeys(rawWindow)
+                .concat(Reflect.ownKeys(target))),
+            deleteProperty: (target, key) => {
+                if (target.hasOwnProperty(key)) {
+                    this.injectedKeySet.has(key) && this.injectedKeySet.delete(key);
+                    this.escapedKeySet.has(key) && Reflect.deleteProperty(rawWindow, key);
+                    return Reflect.deleteProperty(target, key);
+                }
+                return true;
+            },
+        });
+        if (app.showSourceCode) {
+            rawWindow[this.windowSymbolKey] = this.proxyWindow;
+        }
+    }
+    activeated(data) {
+        if (!this.active) {
+            this.active = true;
+            this.fakeWindow.__BK_WEWEB_DATA__ = data ?? {};
+            const { resetDocumentAndBodyEvent } = rewriteDocumentAndBodyEvent();
+            this.resetDocumentAndBodyEvent = resetDocumentAndBodyEvent;
+        }
+    }
+    deactivated() {
+        if (this.active) {
+            this.active = false;
+            this.resetWindowFunction();
+            // this.injectedKeySet.forEach((key: PropertyKey) => Reflect.deleteProperty(this.fakeWindow, key));
+            this.injectedKeySet.clear();
+            this.escapedKeySet.forEach((key) => Reflect.deleteProperty(window, key));
+            this.escapedKeySet.clear();
+            this.resetDocumentAndBodyEvent?.();
+        }
+    }
+}
+
+class MicroInstanceModel {
+    state = AppState.UNSET;
+    isPreLoad = false;
+    appCacheKey;
+    url;
+    container;
+    scopeJs = false;
+    source;
+    sandBox;
+    name;
+    showSourceCode = true;
+    scopeCss = true;
+    keepAlive;
+    initSource;
+    data;
+    constructor(props) {
+        this.name = props.id !== props.url ? props.id : random(5);
+        this.appCacheKey = props.id || this.name;
+        this.url = props.url;
+        this.container = props.container ?? undefined;
+        this.scopeJs = props.scopeJs ?? true;
+        this.showSourceCode = props.showSourceCode ?? true;
+        this.scopeCss = props.scopeCss ?? true;
+        this.keepAlive = props.keepAlive ?? false;
+        this.data = props.data ?? {};
+        this.initSource = props.initSource ?? [];
+        // 是否启用沙盒
+        if (this.scopeJs) {
+            this.sandBox = new SandBox(this);
+        }
+    }
+    get status() {
+        return this.state;
+    }
+    set status(v) {
+        this.state = v;
+    }
+    async start() {
+        if (!this.source || [AppState.UNSET, AppState.ERROR].includes(this.status)) {
+            this.source = new EntrySource(this.url);
+            await this.source.importEntery(this);
+        }
+    }
+    onMount() {
+        if (this.isPreLoad)
+            return;
+        this.state = AppState.LOADED;
+        this.mount();
+    }
+    onError() {
+        this.state = AppState.ERROR;
+    }
+    mount(container, callback) {
+        this.isPreLoad = false;
+        this.container = container ?? this.container;
+        this.state = AppState.MOUNTING;
+        if (this.container instanceof HTMLElement) {
+            this.container.setAttribute(CSS_ATTRIBUTE_KEY, this.name);
+        }
+        this.container.innerHTML = '';
+        const instanceWrap = document.createElement('div');
+        const wrapId = `${this.name}-wrapper`;
+        instanceWrap.setAttribute('id', wrapId);
+        if (this.source?.styles.size) {
+            excuteAppStyles(this, this.container);
+        }
+        this.container.appendChild(instanceWrap);
+        this.sandBox?.activeated();
+        execAppScripts(this).finally(() => {
+            this.state = AppState.MOUNTED;
+            const scriptInfo = this.source?.getScript(this.url);
+            if (typeof scriptInfo?.exportInstance?.render === 'function') {
+                scriptInfo.exportInstance.render(instanceWrap, this.data);
+            }
+            callback?.(this, scriptInfo?.exportInstance);
+        });
+    }
+    activated(container, callback) {
+        this.isPreLoad = false;
+        this.state = AppState.ACTIVATED;
+        if (this.container && container) {
+            if (container instanceof Element)
+                container.setAttribute(CSS_ATTRIBUTE_KEY, this.name);
+            const fragment = document.createDocumentFragment();
+            Array.from(this.container.childNodes).forEach((node) => {
+                fragment.appendChild(node);
+            });
+            container.appendChild(fragment);
+            this.container = container;
+            this.sandBox?.activeated();
+            const scriptInfo = this.source?.getScript(this.url);
+            callback?.(this, scriptInfo?.exportInstance);
+        }
+    }
+    deactivated() {
+        this.state = AppState.DEACTIVATED;
+        this.sandBox?.deactivated();
+    }
+    unmount(needDestroy) {
+        this.state = AppState.UNMOUNT;
+        this.sandBox?.deactivated();
+        needDestroy && appCache.deleteApp(this.url);
+        this.container.innerHTML = '';
+        this.container = undefined;
+    }
+    registerRunningApp() {
+        setCurrentRunningApp(this);
+        Promise.resolve().then(() => setCurrentRunningApp(null));
+    }
+}
+
+async function load(props) {
+    if (props.mode === 'app')
+        return await loadApp(props);
+    if (props.mode === 'js')
+        return await loadInstance(props);
+    return await loadApp(props);
+}
+// 加载app
+async function loadApp(props) {
+    let instance = appCache.getApp(props.id);
+    if (!instance) {
+        instance = new MicroAppModel(props);
+        appCache.setApp(instance);
+    }
+    await instance.start();
+    return instance;
+}
+// 加载instance
+function loadInstance(props) {
+    return new Promise((resolve) => {
+        let instance = appCache.getApp(props.id);
+        if (!instance) {
+            instance = new MicroInstanceModel(props);
+            appCache.setApp(instance);
+            instance.start().then(() => resolve(instance));
+        }
+        else if ([AppState.UNSET, AppState.MOUNTING].includes(instance.status)) {
+            const timer = setInterval(() => {
+                if ([AppState.ERROR, AppState.MOUNTED].includes(instance.status)) {
+                    resolve(instance);
+                    clearInterval(timer);
+                }
+            }, 300);
+        }
+        else {
+            resolve(instance);
+        }
+    });
+}
+
+function unmount(appKey) {
+    const app = appCache.getApp(appKey);
+    if (app?.status !== AppState.UNMOUNT) {
+        app?.unmount();
+    }
+    if (!appCache.hasActiveApp) {
+        resetBodyAndHeaderMethods();
+        resetDocumentPrototypeMethods();
+    }
+}
+
+function activated(appKey, container, callback) {
+    const app = appCache.getApp(appKey);
+    if (app?.status === AppState.DEACTIVATED && app.keepAlive) {
+        nextTask(() => app?.activated(container, callback));
+    }
+    else {
+        nextTask(() => app?.mount(container, callback));
+    }
+}
+
+function deactivated(appKey) {
+    const app = appCache.getApp(appKey);
+    if (app && [AppState.ACTIVATED, AppState.MOUNTED].includes(app.status)) {
+        app.keepAlive ? app.deactivated() : app.unmount();
+    }
+    if (!appCache.hasActiveApp) {
+        resetBodyAndHeaderMethods();
+        resetDocumentPrototypeMethods();
+    }
+}
+
+// bk-weweb支持的属性配置
+var ObserveAttrs;
+(function (ObserveAttrs) {
+    ObserveAttrs["URL"] = "url";
+    ObserveAttrs["showSourceCode"] = "showSourceCode";
+    ObserveAttrs["scopeLocation"] = "scopeLocation";
+    ObserveAttrs["setShodowDom"] = "setShodowDom";
+    ObserveAttrs["mode"] = "mode";
+    ObserveAttrs["data"] = "data";
+    ObserveAttrs["id"] = "id";
+    ObserveAttrs["scopeJs"] = "scopeJs";
+    ObserveAttrs["scopeCss"] = "scopeCss";
+    ObserveAttrs["keepAlive"] = "keepAlive";
+})(ObserveAttrs || (ObserveAttrs = {}));
+class BkIframeElement extends HTMLElement {
+    static get observedAttributes() {
+        return [ObserveAttrs.URL];
+    }
+    connected = false;
+    appUrl = '';
+    // 考虑到js模式下 需要js bundle的复用性 需用户设置id属性 如果单实例下则可以不用配置
+    get appKey() {
+        return this.getAttribute(ObserveAttrs.id) || this.getAttribute(ObserveAttrs.URL);
+    }
+    get appData() {
+        if (this.hasAttribute(ObserveAttrs.data)) {
+            try {
+                return JSON.parse(this.getAttribute(ObserveAttrs.data));
+            }
+            catch { }
+        }
+        return {};
+    }
+    get appProps() {
+        if (this.getAttribute('mode') === 'js') {
+            return {
+                url: this.getAttribute(ObserveAttrs.URL),
+                mode: 'js',
+                id: this.appKey,
+                data: this.appData,
+                container: this.shadowRoot ?? this,
+                showSourceCode: this.getBooleanAttr(ObserveAttrs.showSourceCode),
+                scopeCss: this.getBooleanAttr(ObserveAttrs.scopeCss) && !this.getBooleanAttr(ObserveAttrs.setShodowDom),
+                scopeJs: this.getBooleanAttr(ObserveAttrs.scopeJs),
+                keepAlive: this.getBooleanAttr(ObserveAttrs.keepAlive),
+            };
+        }
+        return {
+            url: this.getAttribute(ObserveAttrs.URL),
+            mode: 'app',
+            id: this.appKey,
+            data: this.appData,
+            container: this.shadowRoot ?? this,
+            scopeLocation: this.getBooleanAttr(ObserveAttrs.scopeLocation),
+            showSourceCode: this.getBooleanAttr(ObserveAttrs.showSourceCode),
+            scopeCss: !this.getBooleanAttr(ObserveAttrs.setShodowDom),
+            scopeJs: !this.getBooleanAttr(ObserveAttrs.scopeJs),
+            keepAlive: this.getBooleanAttr(ObserveAttrs.keepAlive),
+        };
+    }
+    async connectedCallback() {
+        beforeLoad();
+        if (this.getBooleanAttr(ObserveAttrs.setShodowDom) && !this.shadowRoot) {
+            this.attachShadow({ mode: 'open', delegatesFocus: true });
+        }
+        await load(this.appProps);
+        activated(this.appKey, this.shadowRoot ?? this);
+        this.connected = true;
+    }
+    disconnectedCallback() {
+        this.connected = false;
+        if (this.appProps.keepAlive) {
+            deactivated(this.appKey);
+        }
+        else
+            unmount(this.appKey);
+    }
+    attributeChangedCallback(attr, _oldVal, newVal) {
+        if (attr !== ObserveAttrs.URL || this[attr] === newVal)
+            return;
+        this.appUrl = newVal;
+        (this.connected || appCache.getApp(this.appKey)) && this.handleAttributeChanged();
+    }
+    async handleAttributeChanged() {
+        if (!this.appKey)
+            return;
+        if (this.getBooleanAttr(ObserveAttrs.setShodowDom)) {
+            this.attachShadow({ mode: 'open' });
+        }
+        const app = appCache.getApp(this.appKey);
+        if (app && app.url === this.appUrl && (app.isPreLoad || app.status === AppState.UNMOUNT)) {
+            activated(this.appKey, this.shadowRoot ?? this);
+            return;
+        }
+        await load(this.appProps);
+    }
+    getBooleanAttr(name) {
+        return this.hasAttribute(name) ? this.getAttribute(name) !== 'false' : undefined;
+    }
+}
+
+// 收集和辩证资源
+async function collectSource(soruceList) {
+    let source = [];
+    if (typeof soruceList === 'function') {
+        source = await soruceList();
+    }
+    else {
+        source = soruceList || [];
+    }
+    if (!source.length)
+        return {};
+    const collectScript = new Map();
+    const collectStyle = new Map();
+    source.forEach((str) => {
+        try {
+            const url = new URL(str);
+            if (url.pathname.match(/\.js$/)) {
+                const script = appCache.getCacheScript(str);
+                collectScript.set(str, new Script({
+                    code: script?.code || '',
+                    async: false,
+                    defer: false,
+                    url: str,
+                    isModule: false,
+                    initial: true,
+                    fromHtml: false,
+                }));
+            }
+            else if (url.pathname.match(/\.css$/)) {
+                const style = appCache.getCacheStyle(str);
+                collectStyle.set(str, new Style({
+                    code: style?.code || '',
+                    prefetch: false,
+                    preload: false,
+                    url: str,
+                    fromHtml: true,
+                    initial: true,
+                }));
+            }
+        }
+        catch {
+            console.error(`【bk-weweb】: ${str} is invalid URL`);
+        }
+    });
+    return {
+        collectScript,
+        collectStyle,
+    };
+}
+
+const CUSTOM_ELEMENT_TAG = 'bk-weweb';
+class IframeApp {
+    fetchSource;
+    webcomponentTag = CUSTOM_ELEMENT_TAG;
+    constructor() {
+        if (!window.customElements.get(CUSTOM_ELEMENT_TAG)) {
+            window.customElements.define(CUSTOM_ELEMENT_TAG, BkIframeElement);
+        }
+    }
+    // todo set some global start props
+    start(option) {
+        if (typeof option?.fetchSource === 'function') {
+            this.fetchSource = option.fetchSource;
+        }
+        this.webcomponentTag = option?.webcomponentTag || CUSTOM_ELEMENT_TAG;
+        this.setWebComponentTag();
+    }
+    // 设置自定义dom标签名
+    setWebComponentTag() {
+        if (!window.customElements.get(this.webcomponentTag)) {
+            window.customElements.define(this.webcomponentTag, BkIframeElement);
+        }
+    }
+}
+const iframeApp = new IframeApp();
+
+function fetchSource(url, options = {}) {
+    if (iframeApp.fetchSource) {
+        return iframeApp.fetchSource(url, options);
+    }
+    return window.fetch(url, options).then(res => res.text());
+}
+
+/* eslint-disable no-restricted-syntax */
+let firstGlobalProp;
+let secondGlobalProp;
+let lastGlobalProp;
+// Script脚本实例
+class Script {
+    code = '';
+    async = false;
+    defer = false;
+    isModule = false;
+    url;
+    exportInstance;
+    scoped;
+    fromHtml;
+    initial;
+    constructor({ code, async, defer, isModule, url, fromHtml, initial }) {
+        this.code = code;
+        this.async = async;
+        this.defer = defer;
+        this.isModule = isModule;
+        this.url = url;
+        this.scoped = false;
+        this.fromHtml = fromHtml ?? false;
+        this.initial = initial ?? false;
+    }
+    async getCode(app) {
+        if (this.code.length || !this.url) {
+            return this.code;
+        }
+        let code = '';
+        if (app?.source?.getScript(this.url)) {
+            code = app.source.getScript(this.url)?.code || '';
+        }
+        if (!code && appCache.getCacheScript(this.url)) {
+            code = appCache.getCacheScript(this.url)?.code || '';
+        }
+        if (!code) {
+            code = await fetchSource(this.url).catch((e) => {
+                console.error(`fetch script ${this.url} error`, e);
+                return '';
+            });
+        }
+        this.code = code;
+        return code;
+    }
+    async excuteCode(app, needRelaceScriptElement = false) {
+        try {
+            if (!this.code)
+                await this.getCode(app);
+            if (app instanceof MicroInstanceModel) {
+                noteGlobalProps(app.sandBox?.proxyWindow || window);
+            }
+            let scopedCode = this.code;
+            scopedCode = this.transformCode(app);
+            if (app.showSourceCode || this.isModule) {
+                const scriptElement = createElement$1('script');
+                app.registerRunningApp();
+                this.executeSourceScript(scriptElement, scopedCode);
+                if (needRelaceScriptElement)
+                    return scriptElement;
+                const needKeepAlive = !!app.keepAlive && !(app.container instanceof ShadowRoot);
+                const container = needKeepAlive ? document.head : app.container;
+                setMarkElement(scriptElement, app, needKeepAlive);
+                container.appendChild(scriptElement);
+            }
+            else {
+                this.executeMemoryScript(app, scopedCode);
+                if (needRelaceScriptElement)
+                    return document.createComment('【bk-weweb】dynamic script');
+            }
+            if (app instanceof MicroInstanceModel) {
+                const exportProp = getGlobalProp(app.sandBox?.proxyWindow || window);
+                exportProp && (this.exportInstance = (app.sandBox?.proxyWindow || window)[exportProp]);
+            }
+        }
+        catch (e) {
+            console.error('execute script code error', e);
+        }
+        return;
+    }
+    transformCode(app) {
+        if (app.sandBox) {
+            if (app.showSourceCode || this.isModule) {
+                return `;(function(window, self){
+          with(window){
+            ;${this.code}\n
+          }
+        }).call(window.${app.sandBox.windowSymbolKey},
+           window.${app.sandBox.windowSymbolKey});`;
+            }
+            return `
+          with(window) {
+              try {
+                ${this.code}
+              }
+              catch(e) {
+                console.error(e)
+              }
+            }
+      `;
+        }
+        return this.code;
+    }
+    executeSourceScript(scriptElement, scopedCode) {
+        if (this.isModule) {
+            const blob = new Blob([scopedCode], { type: 'text/javascript' });
+            scriptElement.src = URL.createObjectURL(blob);
+            scriptElement.setAttribute('type', 'module');
+        }
+        else {
+            scriptElement.textContent = scopedCode;
+        }
+        this.url && scriptElement.setAttribute('origin-src', this.url);
+    }
+    executeMemoryScript(app, scopedCode) {
+        try {
+            const isScopedLocation = app instanceof MicroAppModel && app.scopeLocation;
+            app.registerRunningApp();
+            // eslint-disable-next-line no-new-func
+            new Function('window', 'location', 'history', scopedCode)(app.sandBox.proxyWindow, isScopedLocation ? app.iframe?.contentWindow?.location : window.location, isScopedLocation ? app.iframe?.contentWindow?.history : window.history);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+}
+// 全局属性是否跳过标记
+function shouldSkipProperty(global, p) {
+    return (!global.hasOwnProperty(p)
+        || (!isNaN(p) && p < global.length)
+        || (isIE11 && global[p] && typeof window !== 'undefined' && global[p].parent === window));
+}
+// 获取instance js source code 执行后 绑定的export 实例
+function getGlobalProp(global, useFirstGlobalProp) {
+    let cnt = 0;
+    let foundLastProp;
+    let result;
+    for (const p in global) {
+        // do not check frames cause it could be removed during import
+        if (shouldSkipProperty(global, p))
+            continue;
+        if ((cnt === 0 && p !== firstGlobalProp) || (cnt === 1 && p !== secondGlobalProp))
+            return p;
+        if (foundLastProp) {
+            lastGlobalProp = p;
+            result = (useFirstGlobalProp && result) || p;
+        }
+        else {
+            foundLastProp = p === lastGlobalProp;
+        }
+        cnt += 1;
+    }
+    return result;
+}
+// 标记全局属性
+function noteGlobalProps(global) {
+    secondGlobalProp = undefined;
+    firstGlobalProp = secondGlobalProp;
+    for (const p in global) {
+        if (shouldSkipProperty(global, p))
+            continue;
+        if (!firstGlobalProp)
+            firstGlobalProp = p;
+        else if (!secondGlobalProp)
+            secondGlobalProp = p;
+        lastGlobalProp = p;
+    }
+    return lastGlobalProp;
+}
+// app初始化dom 脚本执行
+async function execAppScripts(app) {
+    const appInitialScriptList = Array.from(app.source.scripts.values()).filter(script => script.initial);
+    // 初始化脚本最先执行
+    if (appInitialScriptList.length) {
+        await Promise.all(appInitialScriptList.map(script => script.excuteCode(app)));
+    }
+    const appScriptList = Array.from(app.source.scripts.values()).filter(script => script.fromHtml && !script.initial);
+    const commomList = appScriptList.filter(script => ((!script.async && !script.defer) || script.isModule));
+    // 保证同步脚本 和 module类型 最先执行
+    await Promise.all(commomList.map(script => script.excuteCode(app)));
+    // 最后执行 defer 和 async 脚本
+    const deferScriptList = [];
+    const asyncScriptList = [];
+    // async defer 脚本执行
+    appScriptList.forEach((script) => {
+        if ((script.defer || script.async)) {
+            if (!script.code && script.defer) {
+                deferScriptList.push(script.excuteCode(app));
+            }
+            else
+                asyncScriptList.push(script.excuteCode(app));
+        }
+    });
+    await Promise.all([...asyncScriptList, ...deferScriptList])
+        .catch((e) => {
+        console.error(e);
+    });
+}
+
+class MicroAppModel {
+    state = AppState.UNSET;
+    isPreLoad = false;
+    mode = 'app';
+    name;
+    url;
+    container;
+    showSourceCode;
+    scopeCss;
+    scopeJs;
+    source;
+    sandBox;
+    scopeLocation;
+    keepAlive;
+    initSource;
+    iframe = null;
+    data;
+    constructor(props) {
+        this.name = props.id !== props.url ? props.id : random(5);
+        this.mode = props.mode ?? 'app';
+        this.container = props.container ?? undefined;
+        this.showSourceCode = props.showSourceCode ?? false;
+        this.url = props.url;
+        this.data = props.data || {};
+        this.scopeJs = props.scopeJs ?? true;
+        this.scopeCss = props.scopeCss ?? true;
+        this.scopeLocation = props.scopeLocation ?? false;
+        this.isPreLoad = props.isPreLoad ?? false;
+        this.keepAlive = props.keepAlive ?? false;
+        this.initSource = props.initSource ?? [];
+        if (this.scopeJs) {
+            this.sandBox = new SandBox(this);
+        }
+        if (this.container instanceof HTMLElement) {
+            this.container.setAttribute(CSS_ATTRIBUTE_KEY, this.name);
+        }
+    }
+    get appCacheKey() {
+        return this.url;
+    }
+    get status() {
+        return this.state;
+    }
+    set status(v) {
+        this.state = v;
+    }
+    async start() {
+        if (!this.source || [AppState.UNSET, AppState.ERROR].includes(this.status)) {
+            this.state = AppState.LOADING;
+            if (this.scopeLocation) {
+                const iframe = await this.createIframe();
+                this.iframe = iframe;
+            }
+            this.source = new EntrySource(this.url);
+            await this.source.importEntery(this);
+        }
+    }
+    onMount() {
+        if (this.isPreLoad)
+            return;
+        this.state = AppState.LOADED;
+        this.mount();
+    }
+    onError() {
+        this.state = AppState.ERROR;
+    }
+    mount(container, callback) {
+        this.isPreLoad = false;
+        this.container = container ?? this.container;
+        this.state = AppState.MOUNTING;
+        if (this.container) {
+            if (this.container instanceof Element)
+                this.container.setAttribute(CSS_ATTRIBUTE_KEY, this.name);
+            const clonedNode = this.source.html.cloneNode(true);
+            const fragment = document.createDocumentFragment();
+            Array.from(clonedNode.childNodes).forEach((node) => {
+                fragment.appendChild(node);
+            });
+            this.container.innerHTML = '';
+            this.container.appendChild(fragment);
+            this.sandBox?.activeated(this.data);
+            execAppScripts(this).finally(() => {
+                this.state = AppState.MOUNTED;
+                callback?.(this);
+            });
+        }
+    }
+    activated(container, callback) {
+        this.isPreLoad = false;
+        this.state = AppState.ACTIVATED;
+        if (container && this.container) {
+            if (container instanceof Element)
+                container.setAttribute(CSS_ATTRIBUTE_KEY, this.name);
+            const fragment = document.createDocumentFragment();
+            Array.from(this.container.childNodes).forEach((node) => {
+                fragment.appendChild(node);
+            });
+            container.innerHTML = '';
+            container.appendChild(fragment);
+            this.container = container;
+            this.sandBox?.activeated(this.data);
+            callback?.(this);
+        }
+    }
+    deactivated() {
+        this.state = AppState.DEACTIVATED;
+        this.sandBox?.deactivated();
+    }
+    unmount(needDestroy = false) {
+        this.state = AppState.UNMOUNT;
+        this.sandBox?.deactivated();
+        needDestroy && appCache.deleteApp(this.url);
+        this.container.innerHTML = '';
+        this.container = undefined;
+    }
+    createIframe() {
+        return new Promise((resolve) => {
+            const iframe = document.createElement('iframe');
+            const url = new URL(this.url);
+            iframe.setAttribute('src', `about:blank${url.pathname || '/'}${url.search}${url.hash}`);
+            iframe.style.cssText = 'position: fixed; top: -9999px; width: 100%; height: 1px;';
+            document.body.appendChild(iframe);
+            setTimeout(() => resolve(iframe), 100);
+        });
+    }
+    registerRunningApp() {
+        setCurrentRunningApp(this);
+        Promise.resolve().then(() => setCurrentRunningApp(null));
+    }
+}
+
+class EntrySource {
+    url;
+    scripts;
+    styles;
+    html = null;
+    rawHtml;
+    constructor(url) {
+        this.url = url;
+        this.scripts = new Map();
+        this.styles = new Map();
+    }
+    async importEntery(app) {
+        let importEntry;
+        if (app.initSource?.length) {
+            // 初始化配置的公共source资源
+            const { collectScript, collectStyle } = await collectSource(app.initSource);
+            if (collectScript) {
+                this.scripts = collectScript;
+            }
+            if (collectStyle) {
+                this.styles = collectStyle;
+            }
+        }
+        if (app instanceof MicroAppModel)
+            importEntry = this.importHtmlEntry(app);
+        else if (app instanceof MicroInstanceModel)
+            importEntry = this.importInstanceEntry();
+        importEntry && await importEntry;
+    }
+    async importHtmlEntry(app) {
+        let htmlStr = appCache.getCacheHtml(this.url);
+        if (!htmlStr) {
+            htmlStr = await fetchSource(this.url, { cache: 'no-cache' });
+            if (!htmlStr) {
+                console.error('load app entry error, pleace check');
+                return Promise.reject();
+            }
+        }
+        this.rawHtml = htmlStr;
+        const wrapElement = createElement$1('div');
+        wrapElement.innerHTML = htmlStr.replace(/<\/?head>/gim, '').replace(/<\/?body>/i, '');
+        this.collectScriptAndStyle(wrapElement, app);
+        await excuteAppStyles(app, wrapElement);
+        this.html = wrapElement;
+    }
+    async importInstanceEntry() {
+        let jsStr = appCache.getCacheScript(this.url)?.code;
+        if (!jsStr) {
+            jsStr = await fetchSource(this.url, { cache: 'no-cache' });
+        }
+        if (!jsStr) {
+            console.error('load app entry error, pleace check');
+            return Promise.reject();
+        }
+        this.scripts.set(this.url, new Script({
+            code: jsStr,
+            async: false,
+            defer: false,
+            url: this.url,
+            isModule: false,
+            fromHtml: true,
+        }));
+    }
+    collectScriptAndStyle(parent, app) {
+        const children = Array.from(parent.children);
+        children.length
+            && children.forEach((child) => {
+                this.collectScriptAndStyle(child, app);
+            });
+        for (const dom of children) {
+            if (dom instanceof HTMLLinkElement) {
+                this.collectLink(dom, parent);
+            }
+            else if (dom instanceof HTMLStyleElement) {
+                if (dom.hasAttribute('exclude')) ;
+                else if (!dom.hasAttribute('ignore')) {
+                    this.styles.set(randomUrl(), new Style({
+                        code: dom.textContent || '',
+                        url: '',
+                        fromHtml: true,
+                    }));
+                    dom.remove();
+                }
+            }
+            else if (dom instanceof HTMLScriptElement) {
+                this.collectScript(dom, parent);
+            }
+            else if (dom instanceof HTMLMetaElement || dom instanceof HTMLTitleElement) {
+                parent.removeChild(dom);
+            }
+            else if (dom instanceof HTMLImageElement && dom.hasAttribute('src')) {
+                dom.setAttribute('src', fillUpPath(dom.getAttribute('src'), this.url));
+            }
+        }
+    }
+    collectLink(link, parent, needReplaceELement = false) {
+        if (link.hasAttribute('exclude')) {
+            return { replace: document.createComment('【bk-weweb】style with exclude attribute is ignored') };
+        }
+        if (link.hasAttribute('ignore')) {
+            return { replace: link };
+        }
+        const rel = link.getAttribute('rel');
+        let href = link.getAttribute('href');
+        let replaceElement;
+        if (rel === 'stylesheet' && href) {
+            href = fillUpPath(href, this.url);
+            replaceElement = document.createComment(`【bk-weweb】style with href=${href}`);
+            let styleInstance = this.getStyle(href);
+            if (!styleInstance) {
+                styleInstance = new Style({
+                    code: '',
+                    url: href,
+                    prefetch: !!link.getAttribute('prefetch'),
+                    preload: !!link.getAttribute('preload'),
+                    fromHtml: !needReplaceELement,
+                });
+                this.styles.set(href, styleInstance);
+            }
+            !needReplaceELement && parent.replaceChild(replaceElement, link);
+            return { replace: replaceElement, style: styleInstance };
+        }
+        if (rel && ['prefetch', 'preload', 'prerender', 'icon', 'apple-touch-icon'].includes(rel)) {
+            // preload prefetch icon ....
+            replaceElement = document.createComment(`【bk-weweb】style with rel=${rel}${href ? ` & href=${href}` : ''}`);
+            !needReplaceELement && parent.removeChild(link);
+            return { replace: replaceElement };
+        }
+        if (href) {
+            // dns-prefetch preconnect modulepreload search ....
+            link.setAttribute('href', fillUpPath(href, this.url));
+        }
+        return { replace: link };
+    }
+    collectScript(script, parent, needReplaceELement = false) {
+        if (script.hasAttribute('ignore')
+            || (script.hasAttribute('type') && !['text/javascript', 'text/ecmascript', 'application/javascript', 'application/ecmascript', 'module'].includes(script.type))
+            || (!isSupportModuleScript && script.type === 'module')) {
+            return;
+        }
+        let replaceElement = null;
+        if (script.hasAttribute('exclude')) {
+            replaceElement = document.createComment('【bk-weweb】script element with exclude attribute is removed');
+            !needReplaceELement && parent.replaceChild(replaceElement, script);
+            return { replace: replaceElement };
+        }
+        let src = script.getAttribute('src');
+        if (src) {
+            src = fillUpPath(src, this.url);
+            let scriptInstance = this.getScript(src);
+            if (!scriptInstance) {
+                scriptInstance = new Script({
+                    code: '',
+                    async: script.hasAttribute('async'),
+                    defer: script.defer || script.type === 'module',
+                    isModule: script.type === 'module',
+                    url: src,
+                    fromHtml: !needReplaceELement,
+                });
+                this.scripts.set(src, scriptInstance);
+            }
+            replaceElement = document.createComment(`【bk-weweb】script with src='${src}'`);
+            !needReplaceELement && parent.replaceChild(replaceElement, script);
+            return { replace: replaceElement, script: scriptInstance };
+        }
+        if (script.textContent) {
+            const nonceStr = randomUrl();
+            const scriptInstance = new Script({
+                code: script.textContent,
+                async: false,
+                defer: script.type === 'module',
+                isModule: script.type === 'module',
+                url: nonceStr,
+                fromHtml: !needReplaceELement,
+            });
+            this.scripts.set(nonceStr, scriptInstance);
+            replaceElement = document.createComment('【bk-weweb】script with texcontent');
+            !needReplaceELement && parent.replaceChild(replaceElement, script);
+            return { replace: replaceElement, script: scriptInstance };
+        }
+        return { replace: script };
+    }
+    setScript(url, script) {
+        this.scripts.set(url, new Script(script));
+    }
+    getScript(url) {
+        return this.scripts.get(url);
+    }
+    setStyle(url, style) {
+        this.styles.set(url, style);
+    }
+    getStyle(url) {
+        return this.styles.get(url);
+    }
+}
+
+// 所有应用缓存
+class AppCache {
+    cache;
+    // todo 主应用共享资源包
+    baseSource;
+    constructor() {
+        this.cache = new Map();
+        this.baseSource = new EntrySource(location.href);
+        // this.baseApp = new
+    }
+    get hasActiveApp() {
+        return Array.from(this.cache.values()).some((app) => app.status !== AppState.UNMOUNT);
+    }
+    setApp(app) {
+        this.cache.set(app.appCacheKey, app);
+    }
+    getApp(name) {
+        if (!name)
+            return undefined;
+        const app = this.cache.get(name);
+        if (app)
+            return app;
+        return Array.from(this.cache.values()).find((item) => item.name === name);
+    }
+    getCacheHtml(url) {
+        const list = Array.from(this.cache.values());
+        const app = list.find(item => item.url === url);
+        if (app)
+            return app.source?.rawHtml || '';
+        return '';
+    }
+    getCacheStyle(url) {
+        let style = this.baseSource.getStyle(url);
+        if (style)
+            return;
+        const list = Array.from(this.cache.values());
+        list.some((app) => {
+            style = app.source?.getStyle(url);
+            return !!style;
+        });
+        return style;
+    }
+    getCacheScript(url) {
+        let script = this.baseSource.getScript(url);
+        if (script)
+            return;
+        const list = Array.from(this.cache.values());
+        list.some((app) => {
+            script = app.source?.getScript(url);
+            return !!script;
+        });
+        return script;
+    }
+    deleteApp(url) {
+        this.cache.delete(url);
+    }
+    setBaseAppStyle(url, style) {
+        this.baseSource.setStyle(url, style);
+    }
+    setBaseAppScript(url, script) {
+        this.baseSource.setScript(url, script);
+    }
+}
+const appCache = new AppCache();
+// 注册全局获取缓存app 或者 instance
+window.__getAppOrInstance__ = function (id) {
+    if (!id)
+        return appCache;
+    return appCache.getApp(id);
+};
+
+function getStyleSource(url, style, originLink) {
+    const replaceStyle = createElement$1('style');
+    fetchSource(url)
+        .then((data) => {
+        style.code = data;
+        appCache.setBaseAppStyle(url, style);
+        replaceStyle.textContent = data;
+        dispatchLinkOrScriptLoad(originLink);
+    })
+        .catch((err) => {
+        console.error(err);
+        dispatchLinkOrScriptError(originLink);
+    });
+    return replaceStyle;
+}
+function getScriptSource(url, script, originScript) {
+    const replaceElement = createElement$1('script');
+    fetchSource(url)
+        .then((code) => {
+        script.code = code;
+        try {
+            replaceElement.textContent = code;
+            if (!url.startsWith('inline-')) {
+                originScript.setAttribute('origin-src', url);
+            }
+        }
+        catch (e) {
+            console.error(e, url);
+        }
+        dispatchLinkOrScriptLoad(originScript);
+    })
+        .catch((err) => {
+        console.error(err);
+        dispatchLinkOrScriptError(originScript);
+    });
+    return replaceElement;
+}
+function rewriteNewNode(child) {
+    if (child instanceof HTMLLinkElement) {
+        const rel = child.getAttribute('rel');
+        let href = child.getAttribute('href');
+        if (rel === 'stylesheet' && href) {
+            href = fillUpPath(href, location.href);
+            const replaceStyle = createElement$1('style');
+            const styleInstance = new Style({
+                code: '',
+                url: href,
+                fromHtml: false,
+            });
+            getStyleSource(href, styleInstance, child);
+            return replaceStyle;
+        }
+    }
+    if (child instanceof HTMLScriptElement) {
+        let src = child.getAttribute('src');
+        if (src && child.type !== 'module') {
+            src = fillUpPath(src, location.href);
+            const script = new Script({
+                code: '',
+                async: child.hasAttribute('async'),
+                defer: child.defer || child.type === 'module',
+                isModule: false,
+                fromHtml: false,
+            });
+            appCache.setBaseAppScript(src, script);
+            const replaceElement = getScriptSource(src, script, child);
+            return replaceElement || child;
+        }
+    }
+    return child;
+}
+function baseElementHandle(parent, newChild, passiveChild, rawMethod, baseSource) {
+    if (baseSource) {
+        const targetChild = rewriteNewNode(newChild);
+        return rawMethod.call(parent, targetChild, passiveChild);
+    }
+    return rawMethod.call(parent, newChild, passiveChild);
+}
+
+(function () {
+    const rawBodyAppendChild = HTMLBodyElement.prototype.appendChild;
+    const rawHeadAppendChild = HTMLHeadElement.prototype.appendChild;
+    const rawHeadInsertBefore = HTMLHeadElement.prototype.appendChild;
+    HTMLBodyElement.prototype.appendChild = function (newChild) {
+        return baseElementHandle(this, newChild, null, rawBodyAppendChild, true);
+    };
+    HTMLHeadElement.prototype.appendChild = function (newChild) {
+        return baseElementHandle(this, newChild, null, rawHeadAppendChild, true);
+    };
+    HTMLHeadElement.prototype.insertBefore = function (newChild, refChild) {
+        return baseElementHandle(this, newChild, refChild, rawHeadInsertBefore, true);
+    };
+}());
+//# sourceMappingURL=collect-source.js.map