@laiye_packages/uci 1.0.2 → 1.0.4

package/dist/index.js

@@ -2,9 +2,9 @@ import { openDB } from "idb";
 import events, { EventEmitter } from "events";
 import axios from "axios";
 import { cloneDeep } from "lodash";
+import { sm2, sm3, sm4 } from "sm-crypto";
 import i18next from "i18next";
 import js_sha256 from "js-sha256";
-import { sm2, sm3, sm4 } from "sm-crypto";
 import qs from "qs";
 import downloadjs from "downloadjs";
 var __webpack_modules__ = {
@@ -9959,1271 +9959,1221 @@ LYSession = session_ts_decorate([
         String
     ])
 ], LYSession);
-function i18n_ts_decorate(decorators, target, key, desc) {
+class LYBaseCrypto {
+}
+function registerCryptoImpl(name1) {
+    return function(impl) {
+        if (cryptoImpl[name1]) throw new Error(`Crypto implementation for ${name1} already registered`);
+        cryptoImpl[name1] = impl;
+        return impl;
+    };
+}
+const cryptoImpl = {
+    default: void 0,
+    sm: void 0,
+    gm: void 0
+};
+function sm_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function i18n_ts_metadata(k, v) {
-    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
-}
-var i18n_LYLangEnum = /*#__PURE__*/ function(LYLangEnum) {
-    LYLangEnum["zh-CN"] = "简体中文";
-    LYLangEnum["en-US"] = "English";
-    return LYLangEnum;
-}({});
-const i18n_langKeys = Object.keys(i18n_LYLangEnum);
-const languages = {};
-const LANG_KEY = 'lang';
-class LYi18n extends LYObject {
-    constructor(namespace){
-        super();
-        this._namespace = namespace || 'LY.';
+class LYSMCrypto extends LYBaseCrypto {
+    _paddingIv(iv) {
+        if (iv.length < 16) {
+            const padded = new Uint8Array(16);
+            padded.set(iv);
+            return padded;
+        }
+        return iv.slice(0, 16);
     }
-    get t() {
-        return (rest, options)=>{
-            if (!rest) return "<Null>";
-            if (rest.includes(':')) return rest.startsWith(`${this.namespace}:`) ? i18next.t(rest, options) : i18next.t(`${this.namespace}.${rest}`, options);
-            return i18next.t(`${this.namespace}:${rest}`, options);
-        };
+    _uint8ArrayToHex(array) {
+        return Array.from(array).map((b)=>b.toString(16).padStart(2, '0')).join('');
     }
-    get lang() {
-        return this._lang || this.resolveLanguage();
+    _hexToUint8Array(hex) {
+        if (hex.length % 2 !== 0) throw new LYCryptoError('Invalid hex string length');
+        const result = new Uint8Array(hex.length / 2);
+        for(let i = 0; i < hex.length; i += 2)result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+        return result;
     }
-    get languages() {
-        return languages;
+    _validateKey(key, expectedLength, keyType) {
+        if (key.length !== expectedLength) throw new LYCryptoError(`Invalid ${keyType} key length: expected ${expectedLength}, got ${key.length}`);
     }
-    get namespace() {
-        return this._namespace;
+    _validatePublicKey(key) {
+        if (64 !== key.length && 65 !== key.length) throw new LYCryptoError(`Invalid SM2 public key length: expected 64 or 65, got ${key.length}`);
     }
-    async initialize() {
-        if (!this._lang) this._lang = this.resolveLanguage();
-        i18next.on('languageChanged', (lang)=>{
-            if (this._lang !== lang) {
-                this._lang = lang;
-                this.emit('lang-changed', lang);
-            }
-        });
-        if (i18next.isInitialized) return;
-        const defaultVariables = {};
-        const env = LYEnv.getInstance(this._namespace);
-        for(const key in env)defaultVariables['$' + key] = env[key];
-        await i18next.init({
-            fallbackLng: 'zh-CN',
-            lng: this._lang,
-            defaultNS: this.namespace,
-            returnObjects: true,
-            interpolation: {
-                escapeValue: false,
-                defaultVariables
-            }
-        });
-        await this.changeLanguage(this._lang);
+    getSymmetricBlockSize(iv, key) {
+        return 16;
     }
-    fallbackLng(lang) {
-        if (lang.includes('en')) return 'en-US';
-        return 'zh-CN';
+    getAsymmetricBlockSize(publicKey) {
+        return 16;
     }
-    resolveLanguage() {
-        const langKeys = Object.keys(this.languages);
-        if (1 === langKeys.length) return this.fallbackLng(langKeys[0]);
-        const searchParams = new URLSearchParams(location.search);
-        let lang = searchParams.get(LANG_KEY);
-        if (lang) {
-            lang = this.fallbackLng(lang);
-            return lang;
+    encryptSymmetric(data, iv, key) {
+        try {
+            this._validateKey(key, 16, 'SM4');
+            const paddedIv = this._paddingIv(iv);
+            const keyHex = this._uint8ArrayToHex(key);
+            const ivHex = this._uint8ArrayToHex(paddedIv);
+            const dataHex = this._uint8ArrayToHex(data);
+            const encrypted = sm4.encrypt(dataHex, keyHex, {
+                iv: ivHex,
+                mode: 'cbc',
+                padding: 'pkcs#7'
+            });
+            if (!encrypted) throw new LYCryptoError('SM4 encryption failed');
+            return this._hexToUint8Array(encrypted);
+        } catch (error) {
+            if (error instanceof LYCryptoError) throw error;
+            throw new LYCryptoError(`SM4 encryption error: ${error instanceof Error ? error.message : String(error)}`);
         }
-        if (!sharedLocalStorage.getSync(LANG_KEY)) {
-            lang = this.fallbackLng(navigator.language);
-            return lang;
+    }
+    decryptSymmetric(data, iv, key) {
+        try {
+            this._validateKey(key, 16, 'SM4');
+            const paddedIv = this._paddingIv(iv);
+            const keyHex = this._uint8ArrayToHex(key);
+            const ivHex = this._uint8ArrayToHex(paddedIv);
+            const dataHex = this._uint8ArrayToHex(data);
+            const decrypted = sm4.decrypt(dataHex, keyHex, {
+                iv: ivHex,
+                mode: 'cbc',
+                padding: 'pkcs#7'
+            });
+            if (!decrypted) throw new LYCryptoError('SM4 decryption failed');
+            return this._hexToUint8Array(decrypted);
+        } catch (error) {
+            if (error instanceof LYCryptoError) throw error;
+            throw new LYCryptoError(`SM4 decryption error: ${error instanceof Error ? error.message : String(error)}`);
         }
-        lang = sharedLocalStorage.getSync(LANG_KEY) || 'zh-CN';
-        return lang;
     }
-    async loadResource(urlOrJson, lang, namespace) {
-        if ('string' == typeof urlOrJson) {
-            const res = await this.getUrlResource(urlOrJson);
-            if (!res) return;
-            urlOrJson = res;
+    signature(data, privateKey) {
+        try {
+            this._validateKey(privateKey, 32, 'SM2 private');
+            const dataHex = this._uint8ArrayToHex(data);
+            const privateKeyHex = this._uint8ArrayToHex(privateKey);
+            const signature = sm2.doSignature(dataHex, privateKeyHex);
+            if (!signature) throw new LYCryptoError('SM2 signature failed');
+            return signature;
+        } catch (error) {
+            if (error instanceof LYCryptoError) throw error;
+            throw new LYCryptoError(`SM2 signature error: ${error instanceof Error ? error.message : String(error)}`);
         }
-        if (!urlOrJson) return;
-        lang = lang || this._lang;
-        namespace = namespace ? `${this.namespace}.${namespace}` : this.namespace;
-        i18next.addResourceBundle(lang, namespace, urlOrJson);
     }
-    async getUrlResource(resourceUrl) {
+    verify(data, publicKey, signature) {
         try {
-            const res = await axios.get(resourceUrl);
-            return res.data;
+            this._validatePublicKey(publicKey);
+            const dataHex = this._uint8ArrayToHex(data);
+            const publicKeyHex = this._uint8ArrayToHex(publicKey);
+            return sm2.doVerifySignature(dataHex, signature, publicKeyHex);
         } catch (error) {
-            this.logger.error("loadUrlResource error");
-            this.logger.error(error);
+            if (error instanceof LYCryptoError) throw error;
+            throw new LYCryptoError(`SM2 verify error: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    async changeLanguage(lang) {
-        this.logger.info(`changeLanguage lang to ${lang}`);
-        this._lang = lang;
-        i18next.isInitialized && await i18next.changeLanguage(lang);
-        sharedLocalStorage.setSync(LANG_KEY, lang);
-        const url = new URL(window.location.href);
-        url.searchParams.delete(LANG_KEY);
-        window.history.replaceState(null, '', url);
-        i18next.isInitialized && this.emit('lang-changed', lang);
+    encryptAsymmetric(data, publicKey) {
+        try {
+            this._validatePublicKey(publicKey);
+            const dataHex = this._uint8ArrayToHex(data);
+            const publicKeyHex = this._uint8ArrayToHex(publicKey);
+            const encrypted = sm2.doEncrypt(dataHex, publicKeyHex);
+            if (!encrypted) throw new LYCryptoError('SM2 encryption failed');
+            return this._hexToUint8Array(encrypted);
+        } catch (error) {
+            if (error instanceof LYCryptoError) throw error;
+            throw new LYCryptoError(`SM2 encryption error: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
-    getResource(key, lang) {
-        lang = lang || this._lang;
-        let index = key.indexOf(':');
-        key = index <= 0 ? `${this.namespace}:${key}` : key.startsWith(`${this.namespace}:`) ? key : `${this.namespace}.${key}`;
-        index = key.indexOf(':');
-        const ns = key.substring(0, index);
-        const keys = key.substring(index + 1);
-        if (!ns || !keys) return {};
-        const res = i18next.getResourceBundle(lang, ns);
-        if (!res) return {};
-        const resource = keys.split('.').reduce((result, key)=>result[key], res);
-        if (!resource && keys === this.namespace) return res;
-        return resource;
+    decryptAsymmetric(data, privateKey) {
+        try {
+            this._validateKey(privateKey, 32, 'SM2 private');
+            const dataHex = this._uint8ArrayToHex(data);
+            const privateKeyHex = this._uint8ArrayToHex(privateKey);
+            const decrypted = sm2.doDecrypt(dataHex, privateKeyHex);
+            if (!decrypted) throw new LYCryptoError('SM2 decryption failed');
+            return this._hexToUint8Array(decrypted);
+        } catch (error) {
+            if (error instanceof LYCryptoError) throw error;
+            throw new LYCryptoError(`SM2 decryption error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    hash(data, key) {
+        try {
+            if (key) {
+                const hmacResult = sm3(data, {
+                    key,
+                    mode: 'hmac'
+                });
+                if (!hmacResult) throw new LYCryptoError('SM3 HMAC failed');
+                return this._hexToUint8Array(hmacResult);
+            }
+            {
+                const hashResult = sm3(data);
+                if (!hashResult) throw new LYCryptoError('SM3 hash failed');
+                return this._hexToUint8Array(hashResult);
+            }
+        } catch (error) {
+            if (error instanceof LYCryptoError) throw error;
+            throw new LYCryptoError(`SM3 hash error: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
 }
-LYi18n = i18n_ts_decorate([
-    register('LYi18n'),
-    i18n_ts_metadata("design:type", Function),
-    i18n_ts_metadata("design:paramtypes", [
-        String
-    ])
-], LYi18n);
-function app_base_ts_decorate(decorators, target, key, desc) {
+LYSMCrypto = sm_ts_decorate([
+    registerCryptoImpl("sm")
+], LYSMCrypto);
+function gm_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function base_ts_metadata(k, v) {
-    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+class LYGMCrypto extends LYSMCrypto {
 }
-const CONFIG_URL = "/uci/system_info";
-const TENANT_APP_NAME = 'tenant';
-const ORGANIZATION_APP_NAME = 'organization';
-(0, runtime.init)({
-    name: 'uci',
-    remotes: []
-});
-class LYDefaultAppProvider extends LYObject {
-    provideI18nResourcePath(app, lang) {
-        const { i18n } = app;
-        return `${app.env.baseUrl}/i18n/assets/${lang || i18n.lang}/`;
-    }
-    async provideI18nResource(app) {
-        const { i18n } = app;
-        const result = {};
-        for (const key of i18n_langKeys){
-            const lang = key;
-            const resource = await i18n.getUrlResource(`${app.env.baseUrl}/i18n/locale/${lang}.json`);
-            result[lang] = resource;
-        }
-        return result;
-    }
+LYGMCrypto = gm_ts_decorate([
+    registerCryptoImpl("gm")
+], LYGMCrypto);
+function crypto_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-LYDefaultAppProvider = app_base_ts_decorate([
-    register('LYDefaultAppProvider')
-], LYDefaultAppProvider);
-class base_LYBaseApp extends LYObject {
-    static{
-        this._apps = {};
-    }
-    static{
-        this._initLock = false;
-    }
-    static get apps() {
-        return base_LYBaseApp._apps;
+function crypto_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+const LENGTH_SIZE = 2;
+class LYCrypto extends LYObject {
+    constructor(){
+        super();
+        this._ivGetter = ()=>new Uint8Array(16);
+        this._keyGetter = ()=>new Uint8Array(16);
     }
-    static getAppClassName(appName) {
-        const camelCase = appName.replace(/_([a-z])/g, (_, letter)=>letter.toUpperCase());
-        return `LY${camelCase.charAt(0).toUpperCase() + camelCase.slice(1)}App`;
+    get impl() {
+        if (!this._impl) this._createImpl();
+        if (!this._impl) throw new LYCryptoError('Crypto implementation not available');
+        return this._impl;
     }
-    static async init(config_url = CONFIG_URL) {
-        if (this._initLock) throw new LYError('Application initialization in progress');
-        this._initLock = true;
+    _createImpl() {
         try {
-            if (0 === Object.keys(base_LYBaseApp._apps).length) {
-                const config = await LYConfig.load(config_url);
-                for (const app of config.apps)if (app.name === TENANT_APP_NAME) {
-                    const Constructor = LYObject.getClass('LYTenantApp');
-                    base_LYBaseApp._apps[app.name] = new Constructor(app.name, app.version, '');
-                } else if (app.name === ORGANIZATION_APP_NAME) {
-                    const Constructor = LYObject.getClass('LYOrganizationApp');
-                    base_LYBaseApp._apps[app.name] = new Constructor(app.name, app.version, '');
-                } else {
-                    const specificAppClassName = this.getAppClassName(app.name);
-                    let Constructor;
-                    try {
-                        Constructor = LYObject.getClass(specificAppClassName);
-                    } catch  {
-                        Constructor = LYObject.getClass('LYApp');
-                    }
-                    base_LYBaseApp._apps[app.name] = new Constructor(app.name, app.version, '');
-                }
-            }
-        } finally{
-            this._initLock = false;
+            const config = this._getCryptoConfig();
+            const implClass = cryptoImpl[config.type];
+            if (!implClass) throw new LYCryptoError(`Crypto implementation ${config.type} not found`);
+            this._impl = new implClass();
+        } catch (error) {
+            throw new LYCryptoError(`Failed to create crypto implementation: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    static getAll() {
-        return this._apps;
+    _getCryptoConfig() {
+        const config = new LYCryptoConfig();
+        config.type = 'sm';
+        return config;
     }
-    static get(name1) {
-        return this._apps[name1];
+    _uint8ArrayToHex(array) {
+        return Array.from(array).map((b)=>b.toString(16).padStart(2, '0')).join('');
     }
-    static setHeaderProvider(headerProvider) {
-        base_LYBaseApp._headerProvider = headerProvider;
+    _hexToUint8Array(hex) {
+        if (hex.length % 2 !== 0) throw new LYCryptoError('Invalid hex string length');
+        const result = new Uint8Array(hex.length / 2);
+        for(let i = 0; i < hex.length; i += 2)result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+        return result;
     }
-    static getHeaderProvider() {
-        return base_LYBaseApp._headerProvider;
+    _stringToUint8Array(str) {
+        return new TextEncoder().encode(str);
     }
-    constructor(name1, version, description){
-        super(), this._isLoaded = false;
-        this._name = name1;
-        this._version = version;
-        this._description = description;
-        this._i18n = new LYi18n(name1);
-        const prefix = `${this._name}.`;
-        this._localStore = new LYLocalStorage(prefix);
-        this._sessionStore = new LYSessionStorage(prefix);
-        this._cloudStore = new LYCloudStorage(prefix);
-        this._env = new LYEnv(this._name);
-        this._env.baseUrl = this.getBaseUrl();
-        this._httpClient = this._createHttpClient();
+    _uint8ArrayToString(array) {
+        return new TextDecoder().decode(array);
     }
-    get location() {
-        return this._name;
+    _base64ToUint8Array(base64) {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for(let i = 0; i < binaryString.length; i++)bytes[i] = binaryString.charCodeAt(i);
+        return bytes;
     }
-    get name() {
-        return this._name;
+    _uint8ArrayToBase64(array) {
+        let binaryString = '';
+        array.forEach((byte)=>{
+            binaryString += String.fromCharCode(byte);
+        });
+        return btoa(binaryString);
     }
-    get tenantName() {
-        return this._tenantName;
+    _getIvAndKey(iv, key) {
+        const actualIv = iv ? 'string' == typeof iv ? this._hexToUint8Array(iv) : iv : this._ivGetter();
+        const actualKey = key ? 'string' == typeof key ? this._hexToUint8Array(key) : key : this._keyGetter();
+        return [
+            actualIv,
+            actualKey
+        ];
     }
-    get version() {
-        return this._version;
+    _getKey(key, defaultKey) {
+        if (key) return 'string' == typeof key ? this._hexToUint8Array(key) : key;
+        if (defaultKey) return defaultKey;
+        throw new LYCryptoError('Key not provided and no default key available');
     }
-    get description() {
-        return this._description;
+    _getEncryptPublicKey(publicKey) {
+        const key = this._getKey(publicKey, this._encryptPublicKey);
+        return key;
     }
-    get httpClient() {
-        return this._httpClient;
+    _getDecryptPrivateKey(privateKey) {
+        const key = this._getKey(privateKey, this._decryptPrivateKey);
+        return key;
     }
-    get permission() {
-        const session = LYSession.get();
-        if (!session) throw new Error('session not found');
-        return session.permissions[this._name];
+    _getSignaturePrivateKey(privateKey) {
+        const key = this._getKey(privateKey, this._signaturePrivateKey);
+        return key;
     }
-    get provider() {
-        return this._provider || new LYDefaultAppProvider();
+    _getVerifyPublicKey(publicKey) {
+        const key = this._getKey(publicKey, this._verifyPublicKey);
+        return key;
     }
-    get i18n() {
-        return this._i18n;
+    async *_makeSize(data, size) {
+        let buffer = new Uint8Array(0);
+        for await (const chunk of data){
+            const newBuffer = new Uint8Array(buffer.length + chunk.length);
+            newBuffer.set(buffer);
+            newBuffer.set(chunk, buffer.length);
+            buffer = newBuffer;
+            while(buffer.length >= size){
+                yield buffer.slice(0, size);
+                buffer = buffer.slice(size);
+            }
+        }
+        if (buffer.length > 0) yield buffer;
     }
-    get localStore() {
-        return this._localStore;
+    setSymmetricKeyGetter(ivGetter, keyGetter) {
+        this._ivGetter = ivGetter;
+        this._keyGetter = keyGetter;
     }
-    get sessionStore() {
-        return this._sessionStore;
+    setEncryptPublicKey(publicKey) {
+        this._encryptPublicKey = 'string' == typeof publicKey ? this._hexToUint8Array(publicKey) : publicKey;
     }
-    get cloudStore() {
-        return this._cloudStore;
+    setDecryptPrivateKey(privateKey) {
+        this._decryptPrivateKey = 'string' == typeof privateKey ? this._hexToUint8Array(privateKey) : privateKey;
     }
-    get isLoaded() {
-        return this._isLoaded;
+    setSignaturePrivateKey(privateKey) {
+        this._signaturePrivateKey = 'string' == typeof privateKey ? this._hexToUint8Array(privateKey) : privateKey;
     }
-    get env() {
-        return this._env;
+    setVerifyPublicKey(publicKey) {
+        this._verifyPublicKey = 'string' == typeof publicKey ? this._hexToUint8Array(publicKey) : publicKey;
     }
-    _createHttpClient() {
-        return new http_LYAppHttpClient(this._name, {
-            get headers () {
-                return base_LYBaseApp.getHeaderProvider().headers;
-            }
-        });
+    encryptSymmetric(data, iv, key) {
+        if ('string' == typeof data) return this._encryptSymmetricStr(data, iv, key);
+        if (ArrayBuffer.isView(data)) return this._encryptSymmetricBytes(data, iv, key);
+        return this._encryptSymmetricStream(data, iv, key);
     }
-    async load() {
-        if (this._isLoaded) return;
-        this.logger.info(`start run ${this._name} app`);
-        await this.doLoad();
-        this._isLoaded = true;
-        this.logger.info(`run ${this._name} app completed`);
+    _encryptSymmetricBytes(data, iv, key) {
+        if (!data || 0 === data.length) return new Uint8Array(data);
+        const [actualIv, actualKey] = this._getIvAndKey(iv, key);
+        return this.impl.encryptSymmetric(data, actualIv, actualKey);
     }
-    getBaseUrl() {
-        const config = LYConfig.get();
-        const url = new URL(window.location.href);
-        let baseUrl = "";
-        for (const pattern of config.host_patterns){
-            if (!pattern.includes("{tenant_name}") && pattern.startsWith(url.origin)) {
-                const parts = url.pathname.split('/');
-                const index = parts.findIndex((part)=>'view' === part);
-                let tenantName = parts[index + 2];
-                if (!tenantName) throw new Error('tenantName not found');
-                baseUrl = `${pattern}/view/${this.name}/${tenantName}`;
-                this._tenantName = tenantName;
-                return baseUrl;
+    _encryptSymmetricStr(data, iv, key) {
+        const dataBytes = this._stringToUint8Array(data);
+        const result = this._encryptSymmetricBytes(dataBytes, iv, key);
+        return this._uint8ArrayToBase64(result);
+    }
+    async *_encryptSymmetricStream(data, iv, key) {
+        const [actualIv, actualKey] = this._getIvAndKey(iv, key);
+        const blockSize = this.impl.getSymmetricBlockSize(actualIv, actualKey);
+        for await (const chunk of this._makeSize(data, blockSize)){
+            if (!chunk || 0 === chunk.length) {
+                yield chunk;
+                continue;
             }
-            let filterhost = pattern.replace(/\./g, "\\.").replace("{tenant_name}", "([a-zA-Z0-9_\\-]+)");
-            const reg = new RegExp(`^${filterhost}(?::\\d+)?(?:/.*)?$`);
-            const matched = url.toString().match(reg);
-            if (matched && matched[1]) {
-                const tenantName = matched[1];
-                const host = pattern.replace("{tenant_name}", tenantName);
-                baseUrl = `${host}/view/${this.name}`;
-                this._tenantName = tenantName;
-                return baseUrl;
-            }
-        }
-        try {
-            baseUrl = `${window.origin}/view/${this.name}/laiye`;
-            this._tenantName = "laiye";
-            return baseUrl;
-        } catch (error) {
-            console.error('Error getting base URL:', error);
+            const buffer = this.impl.encryptSymmetric(chunk, actualIv, actualKey);
+            const lengthBytes = new Uint8Array(LENGTH_SIZE);
+            const view = new DataView(lengthBytes.buffer);
+            view.setUint16(0, buffer.length, false);
+            yield lengthBytes;
+            yield buffer;
         }
-        return window.origin;
     }
-    async doLoad() {
-        await this.initI18n();
+    decryptSymmetric(data, iv, key) {
+        if ('string' == typeof data) return this._decryptSymmetricStr(data, iv, key);
+        if (ArrayBuffer.isView(data)) return this._decryptSymmetricBytes(data, iv, key);
+        return this._decryptSymmetricStream(data, iv, key);
     }
-    async initI18n() {
-        try {
-            const resources = await this.provider.provideI18nResource(this);
-            await this._i18n.initialize();
-            for(const key in resources)this._i18n.loadResource(resources[key] || {}, key);
-        } catch (error) {
-            this.logger.error('initI18n error');
-            this.logger.error(error);
-        }
+    _decryptSymmetricBytes(data, iv, key) {
+        if (!data || 0 === data.length) return new Uint8Array(data);
+        const [actualIv, actualKey] = this._getIvAndKey(iv, key);
+        return this.impl.decryptSymmetric(data, actualIv, actualKey);
     }
-    getI18nResourceUrl(relativeUrl, lang) {
-        const baseUrl = this.provider.provideI18nResourcePath(this, lang) || '';
-        try {
-            const url = new URL(relativeUrl, baseUrl);
-            return url.toString();
-        } catch (error) {
-            return `${baseUrl}/${relativeUrl}`;
+    _decryptSymmetricStr(data, iv, key) {
+        const dataBytes = this._base64ToUint8Array(data);
+        const result = this._decryptSymmetricBytes(dataBytes, iv, key);
+        return this._uint8ArrayToString(result);
+    }
+    async *_decryptSymmetricStream(data, iv, key) {
+        const [actualIv, actualKey] = this._getIvAndKey(iv, key);
+        let buffer = new Uint8Array(0);
+        let size = -1;
+        for await (const chunk of data){
+            const newBuffer = new Uint8Array(buffer.length + chunk.length);
+            newBuffer.set(buffer);
+            newBuffer.set(chunk, buffer.length);
+            buffer = newBuffer;
+            while(true){
+                if (size <= 0 && buffer.length < LENGTH_SIZE) break;
+                if (size <= 0) {
+                    const view = new DataView(buffer.buffer, buffer.byteOffset);
+                    size = view.getUint16(0, false);
+                    buffer = buffer.slice(LENGTH_SIZE);
+                }
+                if (buffer.length < size) break;
+                const encryptedChunk = buffer.slice(0, size);
+                yield this.impl.decryptSymmetric(encryptedChunk, actualIv, actualKey);
+                buffer = buffer.slice(size);
+                size = -1;
+            }
         }
+        if (buffer.length > 0) yield this.impl.decryptSymmetric(buffer, actualIv, actualKey);
     }
-    async getComponent(componentName) {
-        if (this._remoteComponents) return this._remoteComponents[componentName];
-        await this.loadRemoteComponents();
-        return this._remoteComponents[componentName];
+    encryptAsymmetric(data, publicKey) {
+        if ('string' == typeof data) return this._encryptAsymmetricStr(data, publicKey);
+        if (data instanceof Uint8Array) return this._encryptAsymmetricBytes(data, publicKey);
+        return this._encryptAsymmetricStream(data, publicKey);
     }
-    async loadRemoteComponents() {
-        const isLoaded = this._isLoadingComponent;
-        while(this._isLoadingComponent)await wait();
-        if (isLoaded) return this._remoteComponents;
-        this._isLoadingComponent = true;
+    _encryptAsymmetricBytes(data, publicKey) {
+        if (!data || 0 === data.length) return new Uint8Array(0);
+        const key = this._getEncryptPublicKey(publicKey);
+        return this.impl.encryptAsymmetric(data, key);
+    }
+    _encryptAsymmetricStr(data, publicKey) {
+        if (!data) return '';
+        const dataBytes = this._stringToUint8Array(data);
+        const result = this._encryptAsymmetricBytes(dataBytes, publicKey);
+        return this._uint8ArrayToBase64(result);
+    }
+    async *_encryptAsymmetricStream(data, publicKey) {
         try {
-            (0, runtime.registerRemotes)([
-                {
-                    name: this.name,
-                    entry: `${this.env.baseUrl}/mf-manifest.json`
+            const key = this._getEncryptPublicKey(publicKey);
+            for await (const chunk of data){
+                if (!chunk || 0 === chunk.length) {
+                    yield new Uint8Array(0);
+                    continue;
                 }
-            ]);
-            const remoteModule = await (0, runtime.loadRemote)(`${this.name}/Index`);
-            this._remoteComponents = await remoteModule.default(this);
+                yield this.impl.encryptAsymmetric(chunk, key);
+            }
         } catch (error) {
-            this._remoteComponents = {};
-            this.logger.error("loadRemoteComponents error:", error);
-        } finally{
-            this._isLoadingComponent = false;
+            throw new LYCryptoError(`Stream asymmetric encryption failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        return this._remoteComponents;
     }
-}
-base_LYBaseApp = app_base_ts_decorate([
-    register('LYBaseApp'),
-    base_ts_metadata("design:type", Function),
-    base_ts_metadata("design:paramtypes", [
-        String,
-        String,
-        String
-    ])
-], base_LYBaseApp);
-class LYBaseTenantApp extends base_LYBaseApp {
-    _createHttpClient() {
-        const lang = this._i18n.lang;
-        return new LYTenantHttpClient(this.name, {
-            get headers () {
-                const session = LYSession.get();
-                if (!session) return;
-                return {
-                    Authorization: `Bearer ${session.token}`,
-                    'Accept-Language': lang
-                };
-            }
-        });
+    decryptAsymmetric(data, privateKey) {
+        if ('string' == typeof data) return this._decryptAsymmetricStr(data, privateKey);
+        if (data instanceof Uint8Array) return this._decryptAsymmetricBytes(data, privateKey);
+        return this._decryptAsymmetricStream(data, privateKey);
     }
-}
-LYBaseTenantApp = app_base_ts_decorate([
-    register('LYBaseTenantApp')
-], LYBaseTenantApp);
-class session_LYSessionApi {
-    constructor(httpClient){
-        this._httpClient = httpClient;
+    _decryptAsymmetricBytes(data, privateKey) {
+        if (!data || 0 === data.length) return new Uint8Array(0);
+        const key = this._getDecryptPrivateKey(privateKey);
+        return this.impl.decryptAsymmetric(data, key);
     }
-    async create(request) {
-        if (!request.name) request = {
-            ...request,
-            name: ""
-        };
-        const result = await this._httpClient.post("/session", request);
-        return result.data;
+    _decryptAsymmetricStr(data, privateKey) {
+        if (!data) return '';
+        const dataBytes = this._base64ToUint8Array(data);
+        const result = this._decryptAsymmetricBytes(dataBytes, privateKey);
+        return this._uint8ArrayToString(result);
     }
-    async update(id) {
-        const response = await this._httpClient.post(`/session/patch/${id}`);
-        return response.data;
+    async *_decryptAsymmetricStream(data, privateKey) {
+        try {
+            const key = this._getDecryptPrivateKey(privateKey);
+            for await (const chunk of data){
+                if (!chunk || 0 === chunk.length) {
+                    yield new Uint8Array(0);
+                    continue;
+                }
+                yield this.impl.decryptAsymmetric(chunk, key);
+            }
+        } catch (error) {
+            throw new LYCryptoError(`Stream asymmetric decryption failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
-    async delete(id) {
-        const response = await this._httpClient.post(`/session/delete/${id}`);
-        return response.data.count;
+    signature(data, privateKey) {
+        if ('string' == typeof data) return this._signatureStr(data, privateKey);
+        return this._signatureBytes(data, privateKey);
     }
-    async getLoginWays() {
-        const response = await this._httpClient.get("/loginways");
-        return response.data;
+    _signatureBytes(data, privateKey) {
+        if (!data || 0 === data.length) return '';
+        const key = this._getSignaturePrivateKey(privateKey);
+        return this.impl.signature(data, key);
     }
-}
-class LYUserApi {
-    constructor(httpClient){
-        this._httpClient = httpClient;
+    _signatureStr(data, privateKey) {
+        if (!data) return '';
+        const dataBytes = this._stringToUint8Array(data);
+        return this._signatureBytes(dataBytes, privateKey);
     }
-    async query(params) {
-        const response = await this._httpClient.get('/user', params);
-        return response.data;
+    verify(data, signature, publicKey) {
+        if ('string' == typeof data) return this._verifyStr(data, signature, publicKey);
+        return this._verifyBytes(data, signature, publicKey);
     }
-    async get(name1) {
-        const response = await this._httpClient.get(`/user/${name1}`);
-        return response.data;
+    _verifyBytes(data, signature, publicKey) {
+        if (!data || 0 === data.length || !signature) return false;
+        const key = this._getVerifyPublicKey(publicKey);
+        return this.impl.verify(data, key, signature);
     }
-    async add(user) {
-        const response = await this._httpClient.post("/user", {
-            ...user,
-            password: user.password
-        });
-        return response.data.id;
+    _verifyStr(data, signature, publicKey) {
+        if (!data || !signature) return false;
+        const dataBytes = this._stringToUint8Array(data);
+        return this._verifyBytes(dataBytes, signature, publicKey);
     }
-    async update(name1, user) {
-        const response = await this._httpClient.post(`/user/patch/${name1}`, {
-            ...user,
-            password: user.password
-        });
-        return response.data.count;
+    hash(data, key, iterations) {
+        if ('string' == typeof data) return this._hashStr(data, key, iterations);
+        return this._hashBytes(data, key, iterations);
     }
-    async remove(name1) {
-        const response = await this._httpClient.post(`/user/delete/${name1}`);
-        return response.data.count;
+    _hashBytes(data, key, iterations = 1) {
+        if (!data || 0 === data.length) return new Uint8Array(0);
+        const actualKey = key ? 'string' == typeof key ? this._hexToUint8Array(key) : key : void 0;
+        let result = new Uint8Array(data);
+        for(let i = 0; i < iterations; i++)result = new Uint8Array(this.impl.hash(result, actualKey));
+        return result;
     }
-    async accountCheck(request) {
-        const response = await this._httpClient.post("/user/account-check", {
-            ...request
-        });
-        return response.data.exists;
-    }
-    async register(request) {
-        const response = await this._httpClient.post("/user/registration", {
-            ...request
-        });
-        return response.data;
-    }
-    async userNameCheck(name1) {
-        const response = await this._httpClient.get(`/user/username-check/${name1}`);
-        return response.data.available;
-    }
-    async changePassword(currentPassword, newPassword) {
-        const response = await this._httpClient.post("/user/password/change", {
-            current_password: currentPassword,
-            new_password: newPassword
-        });
-        return response.data;
-    }
-    async resetPassword(request) {
-        const response = await this._httpClient.post("/user/password", {
-            ...request
-        });
-        return response.data;
-    }
-}
-const base_ORGANIZATION_APP_NAME = 'organization';
-class LYBaseAuthorizer extends LYObject {
-    constructor(app, name1){
-        super();
-        this._app = app;
-        this._name = name1;
-    }
-    get app() {
-        return this._app;
-    }
-    get name() {
-        return this._name;
-    }
-    async signin(args) {
-        await this._signin(args);
-        this.emit('status-change', 'signed-in');
-        if (args.redirect_uri) setTimeout(()=>{
-            window.location.href = args.redirect_uri;
-        }, 0);
-    }
-    async signout(args) {
-        await this._signout(args);
-        this.emit('status-change', 'signed-out');
-        setTimeout(()=>{
-            const baseUrl = new URL(this.app.env.baseUrl);
-            baseUrl.searchParams.set('returnUrl', encodeURIComponent(args.redirect_uri || window.location.href));
-            window.location.href = baseUrl.toString();
-        }, 0);
+    _hashStr(data, key, iterations = 1) {
+        if (!data) return '';
+        const dataBytes = this._stringToUint8Array(data);
+        const result = this._hashBytes(dataBytes, key, iterations);
+        return this._uint8ArrayToBase64(result);
     }
 }
-function web_ts_decorate(decorators, target, key, desc) {
+LYCrypto = crypto_ts_decorate([
+    register('LYCrypto'),
+    crypto_ts_metadata("design:type", Function),
+    crypto_ts_metadata("design:paramtypes", [])
+], LYCrypto);
+const crypto_crypto = new LYCrypto();
+function i18n_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function web_ts_metadata(k, v) {
+function i18n_ts_metadata(k, v) {
     if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
 }
-class LYWebAuthorizer extends LYBaseAuthorizer {
-    constructor(app, name1, sessionApi){
-        super(app, name1);
-        this._sessionApi = sessionApi;
-        LYSession.setRefreshCallback(this._refreshSession.bind(this));
+var i18n_LYLangEnum = /*#__PURE__*/ function(LYLangEnum) {
+    LYLangEnum["zh-CN"] = "简体中文";
+    LYLangEnum["en-US"] = "English";
+    return LYLangEnum;
+}({});
+const i18n_langKeys = Object.keys(i18n_LYLangEnum);
+const languages = {};
+const LANG_KEY = 'lang';
+class LYi18n extends LYObject {
+    constructor(namespace){
+        super();
+        this._namespace = namespace || 'LY.';
     }
-    async _signin(args) {
-        const response = await this._sessionApi.create({
-            name: args.name,
-            password: args.password,
-            email: args.email,
-            phone: args.phone,
-            country_code: args.country_code,
-            account_type: args.account_type,
-            verification_code: args.verification_code,
-            verification_code_id: args.verification_code_id
+    get t() {
+        return (rest, options)=>{
+            if (!rest) return "<Null>";
+            if (rest.includes(':')) return rest.startsWith(`${this.namespace}:`) ? i18next.t(rest, options) : i18next.t(`${this.namespace}.${rest}`, options);
+            return i18next.t(`${this.namespace}:${rest}`, options);
+        };
+    }
+    get lang() {
+        return this._lang || this.resolveLanguage();
+    }
+    get languages() {
+        return languages;
+    }
+    get namespace() {
+        return this._namespace;
+    }
+    async initialize() {
+        if (!this._lang) this._lang = this.resolveLanguage();
+        i18next.on('languageChanged', (lang)=>{
+            if (this._lang !== lang) {
+                this._lang = lang;
+                this.emit('lang-changed', lang);
+            }
         });
-        LYSession.create('web', '', response.id, response.access_token, response.user_id, response.user_name, response.expires_in, response.permission_codes, response.is_first_login, response.display_name, response.email, response.phone, response.country_code);
+        if (i18next.isInitialized) return;
+        const defaultVariables = {};
+        const env = LYEnv.getInstance(this._namespace);
+        for(const key in env)defaultVariables['$' + key] = env[key];
+        await i18next.init({
+            fallbackLng: 'zh-CN',
+            lng: this._lang,
+            defaultNS: this.namespace,
+            returnObjects: true,
+            interpolation: {
+                escapeValue: false,
+                defaultVariables
+            }
+        });
+        await this.changeLanguage(this._lang);
     }
-    async _signout(args) {
-        const session = LYSession.get();
-        if (!session) throw new Error('Session not found');
-        const count = await this._sessionApi.delete(session.id);
-        if (0 === count) throw new Error('Session not found');
-        LYSession.clear();
+    fallbackLng(lang) {
+        if (lang.includes('en')) return 'en-US';
+        return 'zh-CN';
     }
-    async _refreshSession(session) {
-        const response = await this._sessionApi.update(session.id);
-        LYSession.update(response.id, response.access_token, response.user_id, response.user_name, response.expires_in, response.permission_codes);
+    resolveLanguage() {
+        const langKeys = Object.keys(this.languages);
+        if (1 === langKeys.length) return this.fallbackLng(langKeys[0]);
+        const searchParams = new URLSearchParams(location.search);
+        let lang = searchParams.get(LANG_KEY);
+        if (lang) {
+            lang = this.fallbackLng(lang);
+            return lang;
+        }
+        if (!sharedLocalStorage.getSync(LANG_KEY)) {
+            lang = this.fallbackLng(navigator.language);
+            return lang;
+        }
+        lang = sharedLocalStorage.getSync(LANG_KEY) || 'zh-CN';
+        return lang;
+    }
+    async loadResource(urlOrJson, lang, namespace) {
+        if ('string' == typeof urlOrJson) {
+            const res = await this.getUrlResource(urlOrJson);
+            if (!res) return;
+            urlOrJson = res;
+        }
+        if (!urlOrJson) return;
+        lang = lang || this._lang;
+        namespace = namespace ? `${this.namespace}.${namespace}` : this.namespace;
+        i18next.addResourceBundle(lang, namespace, urlOrJson);
+    }
+    async getUrlResource(resourceUrl) {
+        try {
+            const res = await axios.get(resourceUrl);
+            return res.data;
+        } catch (error) {
+            this.logger.error("loadUrlResource error");
+            this.logger.error(error);
+        }
+    }
+    async changeLanguage(lang) {
+        this.logger.info(`changeLanguage lang to ${lang}`);
+        this._lang = lang;
+        i18next.isInitialized && await i18next.changeLanguage(lang);
+        sharedLocalStorage.setSync(LANG_KEY, lang);
+        const url = new URL(window.location.href);
+        url.searchParams.delete(LANG_KEY);
+        window.history.replaceState(null, '', url);
+        i18next.isInitialized && this.emit('lang-changed', lang);
+    }
+    getResource(key, lang) {
+        lang = lang || this._lang;
+        let index = key.indexOf(':');
+        key = index <= 0 ? `${this.namespace}:${key}` : key.startsWith(`${this.namespace}:`) ? key : `${this.namespace}.${key}`;
+        index = key.indexOf(':');
+        const ns = key.substring(0, index);
+        const keys = key.substring(index + 1);
+        if (!ns || !keys) return {};
+        const res = i18next.getResourceBundle(lang, ns);
+        if (!res) return {};
+        const resource = keys.split('.').reduce((result, key)=>result[key], res);
+        if (!resource && keys === this.namespace) return res;
+        return resource;
     }
 }
-LYWebAuthorizer = web_ts_decorate([
-    register('LYWebAuthorizer'),
-    web_ts_metadata("design:type", Function),
-    web_ts_metadata("design:paramtypes", [
-        "undefined" == typeof LYBaseApp ? Object : LYBaseApp,
-        String,
-        "undefined" == typeof LYSessionApi ? Object : LYSessionApi
+LYi18n = i18n_ts_decorate([
+    register('LYi18n'),
+    i18n_ts_metadata("design:type", Function),
+    i18n_ts_metadata("design:paramtypes", [
+        String
     ])
-], LYWebAuthorizer);
-function gateway_ts_decorate(decorators, target, key, desc) {
+], LYi18n);
+function app_base_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-class LYGatewayAuthorizer extends LYBaseAuthorizer {
-    async _signin(args) {
-        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
-        const response = await app.httpClient.post('sso/gateway/session');
-        LYSession.create('gateway', '', response.id, response.access_token, response.user_id, response.user_name, response.expires_in, response.permission_codes);
+function base_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+const CONFIG_URL = "/uci/system_info";
+const TENANT_APP_NAME = 'tenant';
+const ORGANIZATION_APP_NAME = 'organization';
+(0, runtime.init)({
+    name: 'uci',
+    remotes: []
+});
+class LYDefaultAppProvider extends LYObject {
+    provideI18nResourcePath(app, lang) {
+        const { i18n } = app;
+        return `${app.env.baseUrl}/i18n/assets/${lang || i18n.lang}/`;
     }
-    async _signout(args) {
-        const session = LYSession.get();
-        if (!session) throw new Error('Session not found');
-        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
-        const response = await app.httpClient.post(`sso/gateway/session/delete/${session.id}`);
-        if (0 === response.count) throw new Error('Session not found');
-        LYSession.clear();
+    async provideI18nResource(app) {
+        const { i18n } = app;
+        const result = {};
+        for (const key of i18n_langKeys){
+            const lang = key;
+            const resource = await i18n.getUrlResource(`${app.env.baseUrl}/i18n/locale/${lang}.json`);
+            result[lang] = resource;
+        }
+        return result;
     }
 }
-LYGatewayAuthorizer = gateway_ts_decorate([
-    register('LYGatewayAuthorizer')
-], LYGatewayAuthorizer);
-function direct_ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-class LYDirectAuthorizer extends LYBaseAuthorizer {
-    async _signin(args) {
-        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
-        const response = await app.httpClient.post('sso/direct/session', {
-            authentication_name: args.authentication_name,
-            user_name: args.user_name,
-            password: args.password
-        });
-        LYSession.create('direct', args.authentication_name, response.id, response.access_token, response.user_id, response.user_name, response.expires_in, response.permission_codes);
-    }
-    async _signout(args) {
-        const session = LYSession.get();
-        if (!session) throw new Error('Session not found');
-        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
-        const response = await app.httpClient.post(`sso/direct/session/delete/${session.id}`, {
-            authentication_name: session.authentication_name
-        });
-        if (0 === response.count) throw new Error('Session not found');
-        LYSession.clear();
+LYDefaultAppProvider = app_base_ts_decorate([
+    register('LYDefaultAppProvider')
+], LYDefaultAppProvider);
+class base_LYBaseApp extends LYObject {
+    static{
+        this._apps = {};
     }
-}
-LYDirectAuthorizer = direct_ts_decorate([
-    register('LYDirectAuthorizer')
-], LYDirectAuthorizer);
-function redirect_ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-const REDIRECT_STORAGE_KEY = 'sso_redirect_info';
-const REDIRECT_STORAGE_EXPIRES_IN = 600000;
-class PKCEUtils {
-    static generateCodeVerifier() {
-        const array = new Uint8Array(32);
-        crypto.getRandomValues(array);
-        return btoa(String.fromCharCode.apply(null, Array.from(array))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    static{
+        this._initLock = false;
     }
-    static async generateCodeChallenge(codeVerifier) {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(codeVerifier);
-        let digest;
-        digest = crypto.subtle ? await crypto.subtle.digest('SHA-256', data) : js_sha256.sha256.arrayBuffer(data);
-        return btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(digest)))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    static get apps() {
+        return base_LYBaseApp._apps;
     }
-    static generateState() {
-        const array = new Uint8Array(16);
-        crypto.getRandomValues(array);
-        return btoa(String.fromCharCode.apply(null, Array.from(array))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    static getAppClassName(appName) {
+        const camelCase = appName.replace(/_([a-z])/g, (_, letter)=>letter.toUpperCase());
+        return `LY${camelCase.charAt(0).toUpperCase() + camelCase.slice(1)}App`;
     }
-}
-class LYRedirectAuthorizer extends LYBaseAuthorizer {
-    async _signin(args) {
-        const redirectInfo = sharedLocalStorage.getSync(REDIRECT_STORAGE_KEY);
-        if (redirectInfo) if (redirectInfo.expires_at < new Date()) sharedLocalStorage.removeSync(REDIRECT_STORAGE_KEY);
-        else {
-            const queryParams = this._getQueryParams();
-            const code = queryParams.code;
-            const state = queryParams.state;
-            const locale = queryParams.ui_locales;
-            if (code && state) {
-                if (state !== redirectInfo.state) throw new Error('Invalid state parameter');
-                const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
-                if (locale) await app.i18n.changeLanguage(locale);
-                try {
-                    const response = await app.httpClient.post('sso/redirect/session', {
-                        authentication_name: redirectInfo.authentication_name,
-                        query_params: {
-                            code: code,
-                            code_verifier: redirectInfo.code_verifier,
-                            redirect_uri: redirectInfo.redirect_uri,
-                            state: redirectInfo.state
-                        }
-                    });
-                    if (!response || !response.data.access_token) throw new Error('Invalid SSO response: missing access token');
-                    LYSession.create('redirect', redirectInfo.authentication_name, response.data.id, response.data.access_token, response.data.user_id, response.data.user_name, response.data.expires_in, response.data.permission_codes, response.data.is_first_login, response.data.display_name, response.data.email, response.data.phone, response.data.country_code);
-                    this.emit('status-change', 'signed-in');
-                    sharedLocalStorage.removeSync(REDIRECT_STORAGE_KEY);
-                    setTimeout(()=>{
-                        window.location.href = redirectInfo.redirect_uri;
-                    }, 0);
-                    return;
-                } catch (error) {
-                    console.error('SSO login failed:', error);
-                    sharedLocalStorage.removeSync(REDIRECT_STORAGE_KEY);
+    static async init(config_url = CONFIG_URL) {
+        if (this._initLock) throw new LYError('Application initialization in progress');
+        this._initLock = true;
+        try {
+            if (0 === Object.keys(base_LYBaseApp._apps).length) {
+                const config = await LYConfig.load(config_url);
+                for (const app of config.apps)if (app.name === TENANT_APP_NAME) {
+                    const Constructor = LYObject.getClass('LYTenantApp');
+                    base_LYBaseApp._apps[app.name] = new Constructor(app.name, app.version, '');
+                } else if (app.name === ORGANIZATION_APP_NAME) {
+                    const Constructor = LYObject.getClass('LYOrganizationApp');
+                    base_LYBaseApp._apps[app.name] = new Constructor(app.name, app.version, '');
+                } else {
+                    const specificAppClassName = this.getAppClassName(app.name);
+                    let Constructor;
+                    try {
+                        Constructor = LYObject.getClass(specificAppClassName);
+                    } catch  {
+                        Constructor = LYObject.getClass('LYApp');
+                    }
+                    base_LYBaseApp._apps[app.name] = new Constructor(app.name, app.version, '');
                 }
             }
+        } finally{
+            this._initLock = false;
         }
-        if (args.sso_config) await this._jumpToSSO(args.sso_config, args.redirect_uri);
-        else throw new Error('SSO configuration not provided');
     }
-    signin(args) {
-        return this._signin(args);
+    static getAll() {
+        return this._apps;
     }
-    async _jumpToSSO(ssoConfig, redirectUri) {
-        const codeVerifier = PKCEUtils.generateCodeVerifier();
-        const codeChallenge = await PKCEUtils.generateCodeChallenge(codeVerifier);
-        const state = PKCEUtils.generateState();
-        const ssoUrl = new URL(ssoConfig.auth_url);
-        ssoUrl.searchParams.set('code_challenge', codeChallenge);
-        ssoUrl.searchParams.set('code_challenge_method', 'S256');
-        ssoUrl.searchParams.set('state', state);
-        sharedLocalStorage.setSync(REDIRECT_STORAGE_KEY, {
-            authentication_name: ssoConfig.name,
-            redirect_uri: redirectUri,
-            expires_at: new Date(Date.now() + REDIRECT_STORAGE_EXPIRES_IN),
-            code_verifier: codeVerifier,
-            state: state,
-            sso_config: ssoConfig
-        });
-        setTimeout(()=>{
-            window.location.href = ssoUrl.toString();
-        }, 0);
+    static get(name1) {
+        return this._apps[name1];
     }
-    _getQueryParams() {
-        const params = {};
-        const urlParams = new URLSearchParams(window.location.search);
-        urlParams.forEach((value, key)=>{
-            params[key] = value;
-        });
-        return params;
+    static setHeaderProvider(headerProvider) {
+        base_LYBaseApp._headerProvider = headerProvider;
     }
-    async signout(args) {
-        await this._signout();
+    static getHeaderProvider() {
+        return base_LYBaseApp._headerProvider;
     }
-    async _signout() {
-        const session = LYSession.get();
-        if (!session) throw new Error('Session not found');
-        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
-        const response = await app.httpClient.post(`sso/redirect/session/delete/${session.id}`, {
-            authentication_name: session.authentication_name
-        });
-        if (0 === response.data.count) throw new Error('Session not found');
-        LYSession.clear();
-        if (response.data.logout_url) {
-            this.emit('status-change', 'signed-out');
-            window.location.href = response.data.logout_url;
-        }
+    constructor(name1, version, description){
+        super(), this._isLoaded = false;
+        this._name = name1;
+        this._version = version;
+        this._description = description;
+        this._i18n = new LYi18n(name1);
+        const prefix = `${this._name}.`;
+        this._localStore = new LYLocalStorage(prefix);
+        this._sessionStore = new LYSessionStorage(prefix);
+        this._cloudStore = new LYCloudStorage(prefix);
+        this._env = new LYEnv(this._name);
+        this._httpClient = this._createHttpClient();
     }
-}
-LYRedirectAuthorizer = redirect_ts_decorate([
-    register('LYRedirectAuthorizer')
-], LYRedirectAuthorizer);
-class LYLicenseApi {
-    constructor(httpClient){
-        this._httpClient = httpClient;
+    get location() {
+        return this._name;
     }
-    async queryFiles() {
-        const response = await this._httpClient.get("/license/file");
-        return response.data;
+    get name() {
+        return this._name;
     }
-    async getFileContent(id) {
-        const response = await this._httpClient.get(`/license/file/content/${id}`);
-        return response.data;
+    get tenantName() {
+        return this._tenantName;
     }
-    async add(license) {
-        const response = await this._httpClient.post("/license", license);
-        return response.data.id;
+    get version() {
+        return this._version;
     }
-    async getAll() {
-        const response = await this._httpClient.get("/license");
-        return response.data;
+    get description() {
+        return this._description;
     }
-    async get(id) {
-        const response = await this._httpClient.get(`/license/${id}`);
-        return response.data;
+    get httpClient() {
+        return this._httpClient;
     }
-    async remove(id) {
-        const response = await this._httpClient.post(`/license/delete/${id}`);
-        return response.data.count;
+    get permission() {
+        const session = LYSession.get();
+        if (!session) throw new Error('session not found');
+        return session.permissions[this._name];
     }
-    async getTokens() {
-        const response = await this._httpClient.get("/license/token");
-        return response.data;
+    get provider() {
+        return this._provider || new LYDefaultAppProvider();
     }
-    async getToken(id) {
-        const response = await this._httpClient.get(`/license/token/${id}`);
-        return response.data;
+    get i18n() {
+        return this._i18n;
     }
-    async getLogs(licenseId, tokenId) {
-        const response = await this._httpClient.get("/license/log", {
-            license_id: licenseId,
-            token_id: tokenId
-        });
-        return response.data;
+    get localStore() {
+        return this._localStore;
     }
-}
-class LYBaseCrypto {
-}
-function registerCryptoImpl(name1) {
-    return function(impl) {
-        if (cryptoImpl[name1]) throw new Error(`Crypto implementation for ${name1} already registered`);
-        cryptoImpl[name1] = impl;
-        return impl;
-    };
-}
-const cryptoImpl = {
-    default: void 0,
-    sm: void 0,
-    gm: void 0
-};
-function sm_ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-class LYSMCrypto extends LYBaseCrypto {
-    _paddingIv(iv) {
-        if (iv.length < 16) {
-            const padded = new Uint8Array(16);
-            padded.set(iv);
-            return padded;
-        }
-        return iv.slice(0, 16);
-    }
-    _uint8ArrayToHex(array) {
-        return Array.from(array).map((b)=>b.toString(16).padStart(2, '0')).join('');
-    }
-    _hexToUint8Array(hex) {
-        if (hex.length % 2 !== 0) throw new LYCryptoError('Invalid hex string length');
-        const result = new Uint8Array(hex.length / 2);
-        for(let i = 0; i < hex.length; i += 2)result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
-        return result;
+    get sessionStore() {
+        return this._sessionStore;
     }
-    _validateKey(key, expectedLength, keyType) {
-        if (key.length !== expectedLength) throw new LYCryptoError(`Invalid ${keyType} key length: expected ${expectedLength}, got ${key.length}`);
+    get cloudStore() {
+        return this._cloudStore;
     }
-    _validatePublicKey(key) {
-        if (64 !== key.length && 65 !== key.length) throw new LYCryptoError(`Invalid SM2 public key length: expected 64 or 65, got ${key.length}`);
+    get isLoaded() {
+        return this._isLoaded;
     }
-    getSymmetricBlockSize(iv, key) {
-        return 16;
+    get env() {
+        return this._env;
     }
-    getAsymmetricBlockSize(publicKey) {
-        return 16;
+    get crypto() {
+        return crypto_crypto;
     }
-    encryptSymmetric(data, iv, key) {
-        try {
-            this._validateKey(key, 16, 'SM4');
-            const paddedIv = this._paddingIv(iv);
-            const keyHex = this._uint8ArrayToHex(key);
-            const ivHex = this._uint8ArrayToHex(paddedIv);
-            const dataHex = this._uint8ArrayToHex(data);
-            const encrypted = sm4.encrypt(dataHex, keyHex, {
-                iv: ivHex,
-                mode: 'cbc',
-                padding: 'pkcs#7'
-            });
-            if (!encrypted) throw new LYCryptoError('SM4 encryption failed');
-            return this._hexToUint8Array(encrypted);
-        } catch (error) {
-            if (error instanceof LYCryptoError) throw error;
-            throw new LYCryptoError(`SM4 encryption error: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    _createHttpClient() {
+        return new http_LYAppHttpClient(this._name, {
+            get headers () {
+                return base_LYBaseApp.getHeaderProvider().headers;
+            }
+        });
     }
-    decryptSymmetric(data, iv, key) {
-        try {
-            this._validateKey(key, 16, 'SM4');
-            const paddedIv = this._paddingIv(iv);
-            const keyHex = this._uint8ArrayToHex(key);
-            const ivHex = this._uint8ArrayToHex(paddedIv);
-            const dataHex = this._uint8ArrayToHex(data);
-            const decrypted = sm4.decrypt(dataHex, keyHex, {
-                iv: ivHex,
-                mode: 'cbc',
-                padding: 'pkcs#7'
-            });
-            if (!decrypted) throw new LYCryptoError('SM4 decryption failed');
-            return this._hexToUint8Array(decrypted);
-        } catch (error) {
-            if (error instanceof LYCryptoError) throw error;
-            throw new LYCryptoError(`SM4 decryption error: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    async load() {
+        if (this._isLoaded) return;
+        this.logger.info(`start run ${this._name} app`);
+        await this.doLoad();
+        this._isLoaded = true;
+        this.logger.info(`run ${this._name} app completed`);
     }
-    signature(data, privateKey) {
-        try {
-            this._validateKey(privateKey, 32, 'SM2 private');
-            const dataHex = this._uint8ArrayToHex(data);
-            const privateKeyHex = this._uint8ArrayToHex(privateKey);
-            const signature = sm2.doSignature(dataHex, privateKeyHex);
-            if (!signature) throw new LYCryptoError('SM2 signature failed');
-            return signature;
-        } catch (error) {
-            if (error instanceof LYCryptoError) throw error;
-            throw new LYCryptoError(`SM2 signature error: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    async doLoad() {
+        await this.initI18n();
     }
-    verify(data, publicKey, signature) {
+    async initI18n() {
         try {
-            this._validatePublicKey(publicKey);
-            const dataHex = this._uint8ArrayToHex(data);
-            const publicKeyHex = this._uint8ArrayToHex(publicKey);
-            return sm2.doVerifySignature(dataHex, signature, publicKeyHex);
+            const resources = await this.provider.provideI18nResource(this);
+            await this._i18n.initialize();
+            for(const key in resources)this._i18n.loadResource(resources[key] || {}, key);
         } catch (error) {
-            if (error instanceof LYCryptoError) throw error;
-            throw new LYCryptoError(`SM2 verify error: ${error instanceof Error ? error.message : String(error)}`);
+            this.logger.error('initI18n error');
+            this.logger.error(error);
         }
     }
-    encryptAsymmetric(data, publicKey) {
+    getI18nResourceUrl(relativeUrl, lang) {
+        const baseUrl = this.provider.provideI18nResourcePath(this, lang) || '';
         try {
-            this._validatePublicKey(publicKey);
-            const dataHex = this._uint8ArrayToHex(data);
-            const publicKeyHex = this._uint8ArrayToHex(publicKey);
-            const encrypted = sm2.doEncrypt(dataHex, publicKeyHex);
-            if (!encrypted) throw new LYCryptoError('SM2 encryption failed');
-            return this._hexToUint8Array(encrypted);
+            const url = new URL(relativeUrl, baseUrl);
+            return url.toString();
         } catch (error) {
-            if (error instanceof LYCryptoError) throw error;
-            throw new LYCryptoError(`SM2 encryption error: ${error instanceof Error ? error.message : String(error)}`);
+            return `${baseUrl}/${relativeUrl}`;
         }
     }
-    decryptAsymmetric(data, privateKey) {
-        try {
-            this._validateKey(privateKey, 32, 'SM2 private');
-            const dataHex = this._uint8ArrayToHex(data);
-            const privateKeyHex = this._uint8ArrayToHex(privateKey);
-            const decrypted = sm2.doDecrypt(dataHex, privateKeyHex);
-            if (!decrypted) throw new LYCryptoError('SM2 decryption failed');
-            return this._hexToUint8Array(decrypted);
-        } catch (error) {
-            if (error instanceof LYCryptoError) throw error;
-            throw new LYCryptoError(`SM2 decryption error: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    async getComponent(componentName) {
+        if (this._remoteComponents) return this._remoteComponents[componentName];
+        await this.loadRemoteComponents();
+        return this._remoteComponents[componentName];
     }
-    hash(data, key) {
+    async loadRemoteComponents() {
+        const isLoaded = this._isLoadingComponent;
+        while(this._isLoadingComponent)await wait();
+        if (isLoaded) return this._remoteComponents;
+        this._isLoadingComponent = true;
         try {
-            if (key) {
-                const hmacResult = sm3(data, {
-                    key,
-                    mode: 'hmac'
-                });
-                if (!hmacResult) throw new LYCryptoError('SM3 HMAC failed');
-                return this._hexToUint8Array(hmacResult);
-            }
-            {
-                const hashResult = sm3(data);
-                if (!hashResult) throw new LYCryptoError('SM3 hash failed');
-                return this._hexToUint8Array(hashResult);
-            }
+            (0, runtime.registerRemotes)([
+                {
+                    name: this.name,
+                    entry: `${this.env.baseUrl}/mf-manifest.json`
+                }
+            ]);
+            const remoteModule = await (0, runtime.loadRemote)(`${this.name}/Index`);
+            this._remoteComponents = await remoteModule.default(this);
         } catch (error) {
-            if (error instanceof LYCryptoError) throw error;
-            throw new LYCryptoError(`SM3 hash error: ${error instanceof Error ? error.message : String(error)}`);
+            this._remoteComponents = {};
+            this.logger.error("loadRemoteComponents error:", error);
+        } finally{
+            this._isLoadingComponent = false;
         }
+        return this._remoteComponents;
     }
 }
-LYSMCrypto = sm_ts_decorate([
-    registerCryptoImpl("sm")
-], LYSMCrypto);
-function gm_ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-class LYGMCrypto extends LYSMCrypto {
-}
-LYGMCrypto = gm_ts_decorate([
-    registerCryptoImpl("gm")
-], LYGMCrypto);
-function crypto_ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function crypto_ts_metadata(k, v) {
-    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
-}
-const LENGTH_SIZE = 2;
-class LYCrypto extends LYObject {
-    constructor(){
-        super();
-        this._ivGetter = ()=>new Uint8Array(16);
-        this._keyGetter = ()=>new Uint8Array(16);
-    }
-    get impl() {
-        if (!this._impl) this._createImpl();
-        if (!this._impl) throw new LYCryptoError('Crypto implementation not available');
-        return this._impl;
+base_LYBaseApp = app_base_ts_decorate([
+    register('LYBaseApp'),
+    base_ts_metadata("design:type", Function),
+    base_ts_metadata("design:paramtypes", [
+        String,
+        String,
+        String
+    ])
+], base_LYBaseApp);
+class session_LYSessionApi {
+    constructor(httpClient){
+        this._httpClient = httpClient;
     }
-    _createImpl() {
-        try {
-            const config = this._getCryptoConfig();
-            const implClass = cryptoImpl[config.type];
-            if (!implClass) throw new LYCryptoError(`Crypto implementation ${config.type} not found`);
-            this._impl = new implClass();
-        } catch (error) {
-            throw new LYCryptoError(`Failed to create crypto implementation: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    async create(request) {
+        if (!request.name) request = {
+            ...request,
+            name: ""
+        };
+        const result = await this._httpClient.post("/session", request);
+        return result.data;
     }
-    _getCryptoConfig() {
-        const config = new LYCryptoConfig();
-        config.type = 'sm';
-        return config;
+    async update(id) {
+        const response = await this._httpClient.post(`/session/patch/${id}`);
+        return response.data;
     }
-    _uint8ArrayToHex(array) {
-        return Array.from(array).map((b)=>b.toString(16).padStart(2, '0')).join('');
+    async delete(id) {
+        const response = await this._httpClient.post(`/session/delete/${id}`);
+        return response.data.count;
     }
-    _hexToUint8Array(hex) {
-        if (hex.length % 2 !== 0) throw new LYCryptoError('Invalid hex string length');
-        const result = new Uint8Array(hex.length / 2);
-        for(let i = 0; i < hex.length; i += 2)result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
-        return result;
+    async getLoginWays() {
+        const response = await this._httpClient.get("/loginways");
+        return response.data;
     }
-    _stringToUint8Array(str) {
-        return new TextEncoder().encode(str);
+}
+class LYUserApi {
+    constructor(httpClient){
+        this._httpClient = httpClient;
     }
-    _uint8ArrayToString(array) {
-        return new TextDecoder().decode(array);
+    async query(params) {
+        const response = await this._httpClient.get('/user', params);
+        return response.data;
     }
-    _base64ToUint8Array(base64) {
-        const binaryString = atob(base64);
-        const bytes = new Uint8Array(binaryString.length);
-        for(let i = 0; i < binaryString.length; i++)bytes[i] = binaryString.charCodeAt(i);
-        return bytes;
+    async get(name1) {
+        const response = await this._httpClient.get(`/user/${name1}`);
+        return response.data;
     }
-    _uint8ArrayToBase64(array) {
-        let binaryString = '';
-        array.forEach((byte)=>{
-            binaryString += String.fromCharCode(byte);
+    async add(user) {
+        const response = await this._httpClient.post("/user", {
+            ...user,
+            password: user.password
         });
-        return btoa(binaryString);
+        return response.data.id;
     }
-    _getIvAndKey(iv, key) {
-        const actualIv = iv ? 'string' == typeof iv ? this._hexToUint8Array(iv) : iv : this._ivGetter();
-        const actualKey = key ? 'string' == typeof key ? this._hexToUint8Array(key) : key : this._keyGetter();
-        return [
-            actualIv,
-            actualKey
-        ];
+    async update(name1, user) {
+        const response = await this._httpClient.post(`/user/patch/${name1}`, {
+            ...user,
+            password: user.password
+        });
+        return response.data.count;
     }
-    _getKey(key, defaultKey) {
-        if (key) return 'string' == typeof key ? this._hexToUint8Array(key) : key;
-        if (defaultKey) return defaultKey;
-        throw new LYCryptoError('Key not provided and no default key available');
+    async remove(name1) {
+        const response = await this._httpClient.post(`/user/delete/${name1}`);
+        return response.data.count;
     }
-    _getEncryptPublicKey(publicKey) {
-        const key = this._getKey(publicKey, this._encryptPublicKey);
-        return key;
+    async accountCheck(request) {
+        const response = await this._httpClient.post("/user/account-check", {
+            ...request
+        });
+        return response.data.exists;
     }
-    _getDecryptPrivateKey(privateKey) {
-        const key = this._getKey(privateKey, this._decryptPrivateKey);
-        return key;
+    async register(request) {
+        const response = await this._httpClient.post("/user/registration", {
+            ...request
+        });
+        return response.data;
     }
-    _getSignaturePrivateKey(privateKey) {
-        const key = this._getKey(privateKey, this._signaturePrivateKey);
-        return key;
+    async userNameCheck(name1) {
+        const response = await this._httpClient.get(`/user/username-check/${name1}`);
+        return response.data.available;
     }
-    _getVerifyPublicKey(publicKey) {
-        const key = this._getKey(publicKey, this._verifyPublicKey);
-        return key;
+    async changePassword(currentPassword, newPassword) {
+        const response = await this._httpClient.post("/user/password/change", {
+            current_password: currentPassword,
+            new_password: newPassword
+        });
+        return response.data;
     }
-    async *_makeSize(data, size) {
-        let buffer = new Uint8Array(0);
-        for await (const chunk of data){
-            const newBuffer = new Uint8Array(buffer.length + chunk.length);
-            newBuffer.set(buffer);
-            newBuffer.set(chunk, buffer.length);
-            buffer = newBuffer;
-            while(buffer.length >= size){
-                yield buffer.slice(0, size);
-                buffer = buffer.slice(size);
-            }
-        }
-        if (buffer.length > 0) yield buffer;
+    async resetPassword(request) {
+        const response = await this._httpClient.post("/user/password", {
+            ...request
+        });
+        return response.data;
     }
-    setSymmetricKeyGetter(ivGetter, keyGetter) {
-        this._ivGetter = ivGetter;
-        this._keyGetter = keyGetter;
+}
+const base_ORGANIZATION_APP_NAME = 'organization';
+class LYBaseAuthorizer extends LYObject {
+    constructor(app, name1){
+        super();
+        this._app = app;
+        this._name = name1;
     }
-    setEncryptPublicKey(publicKey) {
-        this._encryptPublicKey = 'string' == typeof publicKey ? this._hexToUint8Array(publicKey) : publicKey;
+    get app() {
+        return this._app;
     }
-    setDecryptPrivateKey(privateKey) {
-        this._decryptPrivateKey = 'string' == typeof privateKey ? this._hexToUint8Array(privateKey) : privateKey;
+    get name() {
+        return this._name;
     }
-    setSignaturePrivateKey(privateKey) {
-        this._signaturePrivateKey = 'string' == typeof privateKey ? this._hexToUint8Array(privateKey) : privateKey;
+    async signin(args) {
+        await this._signin(args);
+        this.emit('status-change', 'signed-in');
+        if (args.redirect_uri) setTimeout(()=>{
+            window.location.href = args.redirect_uri;
+        }, 0);
     }
-    setVerifyPublicKey(publicKey) {
-        this._verifyPublicKey = 'string' == typeof publicKey ? this._hexToUint8Array(publicKey) : publicKey;
+    async signout(args) {
+        await this._signout(args);
+        this.emit('status-change', 'signed-out');
+        setTimeout(()=>{
+            const baseUrl = new URL(this.app.env.baseUrl);
+            baseUrl.searchParams.set('returnUrl', encodeURIComponent(args.redirect_uri || window.location.href));
+            window.location.href = baseUrl.toString();
+        }, 0);
     }
-    encryptSymmetric(data, iv, key) {
-        if ('string' == typeof data) return this._encryptSymmetricStr(data, iv, key);
-        if (ArrayBuffer.isView(data)) return this._encryptSymmetricBytes(data, iv, key);
-        return this._encryptSymmetricStream(data, iv, key);
+}
+function web_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function web_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class LYWebAuthorizer extends LYBaseAuthorizer {
+    constructor(app, name1, sessionApi){
+        super(app, name1);
+        this._sessionApi = sessionApi;
+        LYSession.setRefreshCallback(this._refreshSession.bind(this));
     }
-    _encryptSymmetricBytes(data, iv, key) {
-        if (!data || 0 === data.length) return new Uint8Array(data);
-        const [actualIv, actualKey] = this._getIvAndKey(iv, key);
-        return this.impl.encryptSymmetric(data, actualIv, actualKey);
+    async _signin(args) {
+        const response = await this._sessionApi.create({
+            name: args.name,
+            password: args.password,
+            email: args.email,
+            phone: args.phone,
+            country_code: args.country_code,
+            account_type: args.account_type,
+            verification_code: args.verification_code,
+            verification_code_id: args.verification_code_id
+        });
+        LYSession.create('web', '', response.id, response.access_token, response.user_id, response.user_name, response.expires_in, response.permission_codes, response.is_first_login, response.display_name, response.email, response.phone, response.country_code);
     }
-    _encryptSymmetricStr(data, iv, key) {
-        const dataBytes = this._stringToUint8Array(data);
-        const result = this._encryptSymmetricBytes(dataBytes, iv, key);
-        return this._uint8ArrayToBase64(result);
+    async _signout(args) {
+        const session = LYSession.get();
+        if (!session) throw new Error('Session not found');
+        const count = await this._sessionApi.delete(session.id);
+        if (0 === count) throw new Error('Session not found');
+        LYSession.clear();
     }
-    async *_encryptSymmetricStream(data, iv, key) {
-        const [actualIv, actualKey] = this._getIvAndKey(iv, key);
-        const blockSize = this.impl.getSymmetricBlockSize(actualIv, actualKey);
-        for await (const chunk of this._makeSize(data, blockSize)){
-            if (!chunk || 0 === chunk.length) {
-                yield chunk;
-                continue;
-            }
-            const buffer = this.impl.encryptSymmetric(chunk, actualIv, actualKey);
-            const lengthBytes = new Uint8Array(LENGTH_SIZE);
-            const view = new DataView(lengthBytes.buffer);
-            view.setUint16(0, buffer.length, false);
-            yield lengthBytes;
-            yield buffer;
-        }
+    async _refreshSession(session) {
+        const response = await this._sessionApi.update(session.id);
+        LYSession.update(response.id, response.access_token, response.user_id, response.user_name, response.expires_in, response.permission_codes);
     }
-    decryptSymmetric(data, iv, key) {
-        if ('string' == typeof data) return this._decryptSymmetricStr(data, iv, key);
-        if (ArrayBuffer.isView(data)) return this._decryptSymmetricBytes(data, iv, key);
-        return this._decryptSymmetricStream(data, iv, key);
+}
+LYWebAuthorizer = web_ts_decorate([
+    register('LYWebAuthorizer'),
+    web_ts_metadata("design:type", Function),
+    web_ts_metadata("design:paramtypes", [
+        "undefined" == typeof LYBaseApp ? Object : LYBaseApp,
+        String,
+        "undefined" == typeof LYSessionApi ? Object : LYSessionApi
+    ])
+], LYWebAuthorizer);
+function gateway_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class LYGatewayAuthorizer extends LYBaseAuthorizer {
+    async _signin(args) {
+        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
+        const response = await app.httpClient.post('sso/gateway/session');
+        LYSession.create('gateway', '', response.id, response.access_token, response.user_id, response.user_name, response.expires_in, response.permission_codes);
     }
-    _decryptSymmetricBytes(data, iv, key) {
-        if (!data || 0 === data.length) return new Uint8Array(data);
-        const [actualIv, actualKey] = this._getIvAndKey(iv, key);
-        return this.impl.decryptSymmetric(data, actualIv, actualKey);
+    async _signout(args) {
+        const session = LYSession.get();
+        if (!session) throw new Error('Session not found');
+        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
+        const response = await app.httpClient.post(`sso/gateway/session/delete/${session.id}`);
+        if (0 === response.count) throw new Error('Session not found');
+        LYSession.clear();
     }
-    _decryptSymmetricStr(data, iv, key) {
-        const dataBytes = this._base64ToUint8Array(data);
-        const result = this._decryptSymmetricBytes(dataBytes, iv, key);
-        return this._uint8ArrayToString(result);
+}
+LYGatewayAuthorizer = gateway_ts_decorate([
+    register('LYGatewayAuthorizer')
+], LYGatewayAuthorizer);
+function direct_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class LYDirectAuthorizer extends LYBaseAuthorizer {
+    async _signin(args) {
+        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
+        const response = await app.httpClient.post('sso/direct/session', {
+            authentication_name: args.authentication_name,
+            user_name: args.user_name,
+            password: args.password
+        });
+        LYSession.create('direct', args.authentication_name, response.id, response.access_token, response.user_id, response.user_name, response.expires_in, response.permission_codes);
     }
-    async *_decryptSymmetricStream(data, iv, key) {
-        const [actualIv, actualKey] = this._getIvAndKey(iv, key);
-        let buffer = new Uint8Array(0);
-        let size = -1;
-        for await (const chunk of data){
-            const newBuffer = new Uint8Array(buffer.length + chunk.length);
-            newBuffer.set(buffer);
-            newBuffer.set(chunk, buffer.length);
-            buffer = newBuffer;
-            while(true){
-                if (size <= 0 && buffer.length < LENGTH_SIZE) break;
-                if (size <= 0) {
-                    const view = new DataView(buffer.buffer, buffer.byteOffset);
-                    size = view.getUint16(0, false);
-                    buffer = buffer.slice(LENGTH_SIZE);
+    async _signout(args) {
+        const session = LYSession.get();
+        if (!session) throw new Error('Session not found');
+        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
+        const response = await app.httpClient.post(`sso/direct/session/delete/${session.id}`, {
+            authentication_name: session.authentication_name
+        });
+        if (0 === response.count) throw new Error('Session not found');
+        LYSession.clear();
+    }
+}
+LYDirectAuthorizer = direct_ts_decorate([
+    register('LYDirectAuthorizer')
+], LYDirectAuthorizer);
+function redirect_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+const REDIRECT_STORAGE_KEY = 'sso_redirect_info';
+const REDIRECT_STORAGE_EXPIRES_IN = 600000;
+class PKCEUtils {
+    static generateCodeVerifier() {
+        const array = new Uint8Array(32);
+        crypto.getRandomValues(array);
+        return btoa(String.fromCharCode.apply(null, Array.from(array))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    }
+    static async generateCodeChallenge(codeVerifier) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(codeVerifier);
+        let digest;
+        digest = crypto.subtle ? await crypto.subtle.digest('SHA-256', data) : js_sha256.sha256.arrayBuffer(data);
+        return btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(digest)))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    }
+    static generateState() {
+        const array = new Uint8Array(16);
+        crypto.getRandomValues(array);
+        return btoa(String.fromCharCode.apply(null, Array.from(array))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    }
+}
+class LYRedirectAuthorizer extends LYBaseAuthorizer {
+    async _signin(args) {
+        const redirectInfo = sharedLocalStorage.getSync(REDIRECT_STORAGE_KEY);
+        if (redirectInfo) if (redirectInfo.expires_at < new Date()) sharedLocalStorage.removeSync(REDIRECT_STORAGE_KEY);
+        else {
+            const queryParams = this._getQueryParams();
+            const code = queryParams.code;
+            const state = queryParams.state;
+            const locale = queryParams.ui_locales;
+            if (code && state) {
+                if (state !== redirectInfo.state) throw new Error('Invalid state parameter');
+                const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
+                if (locale) await app.i18n.changeLanguage(locale);
+                try {
+                    const response = await app.httpClient.post('sso/redirect/session', {
+                        authentication_name: redirectInfo.authentication_name,
+                        query_params: {
+                            code: code,
+                            code_verifier: redirectInfo.code_verifier,
+                            redirect_uri: redirectInfo.redirect_uri,
+                            state: redirectInfo.state
+                        }
+                    });
+                    if (!response || !response.data.access_token) throw new Error('Invalid SSO response: missing access token');
+                    LYSession.create('redirect', redirectInfo.authentication_name, response.data.id, response.data.access_token, response.data.user_id, response.data.user_name, response.data.expires_in, response.data.permission_codes, response.data.is_first_login, response.data.display_name, response.data.email, response.data.phone, response.data.country_code);
+                    this.emit('status-change', 'signed-in');
+                    sharedLocalStorage.removeSync(REDIRECT_STORAGE_KEY);
+                    setTimeout(()=>{
+                        window.location.href = redirectInfo.redirect_uri;
+                    }, 0);
+                    return;
+                } catch (error) {
+                    console.error('SSO login failed:', error);
+                    sharedLocalStorage.removeSync(REDIRECT_STORAGE_KEY);
                 }
-                if (buffer.length < size) break;
-                const encryptedChunk = buffer.slice(0, size);
-                yield this.impl.decryptSymmetric(encryptedChunk, actualIv, actualKey);
-                buffer = buffer.slice(size);
-                size = -1;
             }
         }
-        if (buffer.length > 0) yield this.impl.decryptSymmetric(buffer, actualIv, actualKey);
-    }
-    encryptAsymmetric(data, publicKey) {
-        if ('string' == typeof data) return this._encryptAsymmetricStr(data, publicKey);
-        if (data instanceof Uint8Array) return this._encryptAsymmetricBytes(data, publicKey);
-        return this._encryptAsymmetricStream(data, publicKey);
-    }
-    _encryptAsymmetricBytes(data, publicKey) {
-        if (!data || 0 === data.length) return new Uint8Array(0);
-        const key = this._getEncryptPublicKey(publicKey);
-        return this.impl.encryptAsymmetric(data, key);
-    }
-    _encryptAsymmetricStr(data, publicKey) {
-        if (!data) return '';
-        const dataBytes = this._stringToUint8Array(data);
-        const result = this._encryptAsymmetricBytes(dataBytes, publicKey);
-        return this._uint8ArrayToBase64(result);
+        if (args.sso_config) await this._jumpToSSO(args.sso_config, args.redirect_uri);
+        else throw new Error('SSO configuration not provided');
     }
-    async *_encryptAsymmetricStream(data, publicKey) {
-        try {
-            const key = this._getEncryptPublicKey(publicKey);
-            for await (const chunk of data){
-                if (!chunk || 0 === chunk.length) {
-                    yield new Uint8Array(0);
-                    continue;
-                }
-                yield this.impl.encryptAsymmetric(chunk, key);
-            }
-        } catch (error) {
-            throw new LYCryptoError(`Stream asymmetric encryption failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    signin(args) {
+        return this._signin(args);
     }
-    decryptAsymmetric(data, privateKey) {
-        if ('string' == typeof data) return this._decryptAsymmetricStr(data, privateKey);
-        if (data instanceof Uint8Array) return this._decryptAsymmetricBytes(data, privateKey);
-        return this._decryptAsymmetricStream(data, privateKey);
+    async _jumpToSSO(ssoConfig, redirectUri) {
+        const codeVerifier = PKCEUtils.generateCodeVerifier();
+        const codeChallenge = await PKCEUtils.generateCodeChallenge(codeVerifier);
+        const state = PKCEUtils.generateState();
+        const ssoUrl = new URL(ssoConfig.auth_url);
+        ssoUrl.searchParams.set('code_challenge', codeChallenge);
+        ssoUrl.searchParams.set('code_challenge_method', 'S256');
+        ssoUrl.searchParams.set('state', state);
+        sharedLocalStorage.setSync(REDIRECT_STORAGE_KEY, {
+            authentication_name: ssoConfig.name,
+            redirect_uri: redirectUri,
+            expires_at: new Date(Date.now() + REDIRECT_STORAGE_EXPIRES_IN),
+            code_verifier: codeVerifier,
+            state: state,
+            sso_config: ssoConfig
+        });
+        setTimeout(()=>{
+            window.location.href = ssoUrl.toString();
+        }, 0);
     }
-    _decryptAsymmetricBytes(data, privateKey) {
-        if (!data || 0 === data.length) return new Uint8Array(0);
-        const key = this._getDecryptPrivateKey(privateKey);
-        return this.impl.decryptAsymmetric(data, key);
+    _getQueryParams() {
+        const params = {};
+        const urlParams = new URLSearchParams(window.location.search);
+        urlParams.forEach((value, key)=>{
+            params[key] = value;
+        });
+        return params;
     }
-    _decryptAsymmetricStr(data, privateKey) {
-        if (!data) return '';
-        const dataBytes = this._base64ToUint8Array(data);
-        const result = this._decryptAsymmetricBytes(dataBytes, privateKey);
-        return this._uint8ArrayToString(result);
+    async signout(args) {
+        await this._signout();
     }
-    async *_decryptAsymmetricStream(data, privateKey) {
-        try {
-            const key = this._getDecryptPrivateKey(privateKey);
-            for await (const chunk of data){
-                if (!chunk || 0 === chunk.length) {
-                    yield new Uint8Array(0);
-                    continue;
-                }
-                yield this.impl.decryptAsymmetric(chunk, key);
-            }
-        } catch (error) {
-            throw new LYCryptoError(`Stream asymmetric decryption failed: ${error instanceof Error ? error.message : String(error)}`);
+    async _signout() {
+        const session = LYSession.get();
+        if (!session) throw new Error('Session not found');
+        const app = base_LYBaseApp.get(base_ORGANIZATION_APP_NAME);
+        const response = await app.httpClient.post(`sso/redirect/session/delete/${session.id}`, {
+            authentication_name: session.authentication_name
+        });
+        if (0 === response.data.count) throw new Error('Session not found');
+        LYSession.clear();
+        if (response.data.logout_url) {
+            this.emit('status-change', 'signed-out');
+            window.location.href = response.data.logout_url;
         }
     }
-    signature(data, privateKey) {
-        if ('string' == typeof data) return this._signatureStr(data, privateKey);
-        return this._signatureBytes(data, privateKey);
+}
+LYRedirectAuthorizer = redirect_ts_decorate([
+    register('LYRedirectAuthorizer')
+], LYRedirectAuthorizer);
+class LYLicenseApi {
+    constructor(httpClient){
+        this._httpClient = httpClient;
     }
-    _signatureBytes(data, privateKey) {
-        if (!data || 0 === data.length) return '';
-        const key = this._getSignaturePrivateKey(privateKey);
-        return this.impl.signature(data, key);
+    async queryFiles() {
+        const response = await this._httpClient.get("/license/file");
+        return response.data;
     }
-    _signatureStr(data, privateKey) {
-        if (!data) return '';
-        const dataBytes = this._stringToUint8Array(data);
-        return this._signatureBytes(dataBytes, privateKey);
+    async getFileContent(id) {
+        const response = await this._httpClient.get(`/license/file/content/${id}`);
+        return response.data;
     }
-    verify(data, signature, publicKey) {
-        if ('string' == typeof data) return this._verifyStr(data, signature, publicKey);
-        return this._verifyBytes(data, signature, publicKey);
+    async add(license) {
+        const response = await this._httpClient.post("/license", license);
+        return response.data.id;
     }
-    _verifyBytes(data, signature, publicKey) {
-        if (!data || 0 === data.length || !signature) return false;
-        const key = this._getVerifyPublicKey(publicKey);
-        return this.impl.verify(data, key, signature);
+    async getAll() {
+        const response = await this._httpClient.get("/license");
+        return response.data;
     }
-    _verifyStr(data, signature, publicKey) {
-        if (!data || !signature) return false;
-        const dataBytes = this._stringToUint8Array(data);
-        return this._verifyBytes(dataBytes, signature, publicKey);
+    async get(id) {
+        const response = await this._httpClient.get(`/license/${id}`);
+        return response.data;
     }
-    hash(data, key, iterations) {
-        if ('string' == typeof data) return this._hashStr(data, key, iterations);
-        return this._hashBytes(data, key, iterations);
+    async remove(id) {
+        const response = await this._httpClient.post(`/license/delete/${id}`);
+        return response.data.count;
     }
-    _hashBytes(data, key, iterations = 1) {
-        if (!data || 0 === data.length) return new Uint8Array(0);
-        const actualKey = key ? 'string' == typeof key ? this._hexToUint8Array(key) : key : void 0;
-        let result = new Uint8Array(data);
-        for(let i = 0; i < iterations; i++)result = new Uint8Array(this.impl.hash(result, actualKey));
-        return result;
+    async getTokens() {
+        const response = await this._httpClient.get("/license/token");
+        return response.data;
     }
-    _hashStr(data, key, iterations = 1) {
-        if (!data) return '';
-        const dataBytes = this._stringToUint8Array(data);
-        const result = this._hashBytes(dataBytes, key, iterations);
-        return this._uint8ArrayToBase64(result);
+    async getToken(id) {
+        const response = await this._httpClient.get(`/license/token/${id}`);
+        return response.data;
+    }
+    async getLogs(licenseId, tokenId) {
+        const response = await this._httpClient.get("/license/log", {
+            license_id: licenseId,
+            token_id: tokenId
+        });
+        return response.data;
     }
 }
-LYCrypto = crypto_ts_decorate([
-    register('LYCrypto'),
-    crypto_ts_metadata("design:type", Function),
-    crypto_ts_metadata("design:paramtypes", [])
-], LYCrypto);
-const crypto_crypto = new LYCrypto();
 class LYOEMApi {
     constructor(httpClient){
         this._httpClient = httpClient;
@@ -11297,9 +11247,10 @@ function app_ts_decorate(decorators, target, key, desc) {
 function app_ts_metadata(k, v) {
     if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
 }
-class LYOrganizationApp extends LYBaseTenantApp {
+class LYOrganizationApp extends base_LYBaseApp {
     constructor(name1, version, description){
         super(name1, version, description);
+        this.env.baseUrl = this.getBaseUrl();
         LYOrganizationApp._instance = this;
         this._sessionApi = new session_LYSessionApi(this.httpClient);
         this._userApi = new LYUserApi(this.httpClient);
@@ -11317,6 +11268,19 @@ class LYOrganizationApp extends LYBaseTenantApp {
         if (!LYOrganizationApp._instance) throw new Error('LYOrganizationApp not initialized');
         return LYOrganizationApp._instance;
     }
+    _createHttpClient() {
+        const lang = this._i18n.lang;
+        return new LYOrganizationHttpClient(this.name, {
+            get headers () {
+                const session = LYSession.get();
+                if (!session) return;
+                return {
+                    Authorization: `Bearer ${session.token}`,
+                    'Accept-Language': lang
+                };
+            }
+        });
+    }
     get sessionApi() {
         return this._sessionApi;
     }
@@ -11329,9 +11293,6 @@ class LYOrganizationApp extends LYBaseTenantApp {
     get licenseApi() {
         return this._licenseApi;
     }
-    get crypto() {
-        return crypto_crypto;
-    }
     get verificationCodesApi() {
         return this._verificationCodesApi;
     }
@@ -11354,6 +11315,50 @@ class LYOrganizationApp extends LYBaseTenantApp {
         if (!this._authorizers[type]) throw new Error(`Authorizer ${type} not found`);
         return this._authorizers[type];
     }
+    getBaseUrl() {
+        const config = LYConfig.get();
+        const url = new URL(window.location.href);
+        let baseUrl = "";
+        for (const pattern of config.host_patterns){
+            if (!pattern.includes("{tenant_name}") && pattern.startsWith(url.origin)) {
+                const parts = url.pathname.split('/');
+                const index = parts.findIndex((part)=>'view' === part);
+                let tenantName = parts[index + 2];
+                if (!tenantName) throw new Error('tenantName not found');
+                baseUrl = `${pattern}/view/${this.name}/${tenantName}`;
+                this._tenantName = tenantName;
+                return baseUrl;
+            }
+            let filterhost = pattern.replace(/\./g, "\\.").replace("{tenant_name}", "([a-zA-Z0-9_\\-]+)");
+            const reg = new RegExp(`^${filterhost}(?::\\d+)?(?:/.*)?$`);
+            const matched = url.toString().match(reg);
+            if (matched && matched[1]) {
+                const tenantName = matched[1];
+                const host = pattern.replace("{tenant_name}", tenantName);
+                baseUrl = `${host}/view/${this.name}`;
+                this._tenantName = tenantName;
+                return baseUrl;
+            }
+        }
+        try {
+            if ('development' === process.env.NODE_ENV) {
+                baseUrl = `${window.origin}/view/${this.name}/laiye`;
+                this._tenantName = "laiye";
+                return baseUrl;
+            }
+            const parts = url.pathname.split('/');
+            const index = parts.findIndex((part)=>'view' === part);
+            if (-1 === index) throw new Error('view not found in URL');
+            let tenantName = parts[index + 2];
+            if (!tenantName) throw new Error('tenantName not found');
+            baseUrl = `${window.origin}/view/${this.name}/${tenantName}`;
+            this._tenantName = tenantName;
+            return baseUrl;
+        } catch (error) {
+            console.error('Error getting base URL:', error);
+        }
+        return window.origin;
+    }
 }
 LYOrganizationApp = app_ts_decorate([
     register('LYOrganizationApp'),
@@ -11716,6 +11721,19 @@ class LYTenantApp extends base_LYBaseApp {
         this._authorizer = new LYTenantAuthorizer(this.httpClient);
         LYTenantApp._instance = this;
     }
+    _createHttpClient() {
+        const lang = this._i18n.lang;
+        return new http_LYAppHttpClient(this.name, {
+            get headers () {
+                const session = LYTenantSession.get();
+                if (!session) return;
+                return {
+                    Authorization: `Bearer ${session.token}`,
+                    'Accept-Language': lang
+                };
+            }
+        });
+    }
     static get instance() {
         if (!LYTenantApp._instance) throw new Error('LYTenantApp not initialized');
         return LYTenantApp._instance;
@@ -11745,24 +11763,13 @@ LYTenantApp = tenant_app_ts_decorate([
         String
     ])
 ], LYTenantApp);
-base_LYBaseApp.setHeaderProvider({
-    get headers () {
-        const lang = LYTenantApp.instance.i18n.lang;
-        const session = LYTenantSession.get();
-        if (!session) return;
-        return {
-            Authorization: `Bearer ${session.token}`,
-            'Accept-Language': lang
-        };
-    }
-});
 function src_app_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-class LYApp extends LYBaseTenantApp {
+class LYApp extends base_LYBaseApp {
 }
 LYApp = src_app_ts_decorate([
     register('LYApp')
@@ -12165,7 +12172,7 @@ http_LYAppHttpClient = src_http_ts_decorate([
         "undefined" == typeof IHeaderProvider ? Object : IHeaderProvider
     ])
 ], http_LYAppHttpClient);
-class LYTenantHttpClient extends http_LYAppHttpClient {
+class LYOrganizationHttpClient extends http_LYAppHttpClient {
     static getTenantName() {
         const url = window.location.pathname;
         const parts = url.split('/');
@@ -12175,15 +12182,15 @@ class LYTenantHttpClient extends http_LYAppHttpClient {
     }
     _getUrl(url) {
         url = super._getUrl(url);
-        const tenantName = LYTenantHttpClient.getTenantName() || 'laiye';
+        const tenantName = LYOrganizationHttpClient.getTenantName();
         if (tenantName) url = url.startsWith('/') ? `${tenantName}${url}` : `${tenantName}/${url}`;
         return url;
     }
 }
-LYTenantHttpClient = src_http_ts_decorate([
-    register('LYTenantHttpClient')
-], LYTenantHttpClient);
+LYOrganizationHttpClient = src_http_ts_decorate([
+    register('LOrganizationHttpClient')
+], LYOrganizationHttpClient);
 var __webpack_exports__FRAMEWORK_NAME = "uci";
-export { LANG_KEY, LYApp, http_LYAppHttpClient as LYAppHttpClient, LYAppPermission, base_LYBaseApp as LYBaseApp, LYCloudStorage, LYConfig, LYCrypto, LYCryptoError, LYDefaultLogFormatter, LYDirectAuthorizer, LYEnv, LYError, LYGatewayAuthorizer, LYIndexedDBLogStorage, i18n_LYLangEnum as LYLangEnum, LYLocalStorage, logger_LYLogLevel as LYLogLevel, LYLogger, LYObject, LYObservable, LYOrganizationApp, LYOwnerObservable, LYRedirectAuthorizer, LYSession, LYSessionStorage, LYTenantApp, LYTenantAuthorizer, LYTenantHttpClient, LYTenantSession, LYWebAuthorizer, LYi18n, ORGANIZATION_APP_NAME, REMOTE_ENTRY, REMOTE_MODULE, TENANT_APP_NAME, crypto_crypto as crypto, isElectron, isIframe, i18n_langKeys as langKeys, languages, logger, observable_observe as observe, register, setCloudStorageImpl, setFormatter, setPrintToConsole, setStorage, sharedCloudStorage, sharedLocalStorage, wait, __webpack_exports__FRAMEWORK_NAME as FRAMEWORK_NAME };
+export { LANG_KEY, LYApp, http_LYAppHttpClient as LYAppHttpClient, LYAppPermission, base_LYBaseApp as LYBaseApp, LYCloudStorage, LYConfig, LYCrypto, LYCryptoError, LYDefaultLogFormatter, LYDirectAuthorizer, LYEnv, LYError, LYGatewayAuthorizer, LYIndexedDBLogStorage, i18n_LYLangEnum as LYLangEnum, LYLocalStorage, logger_LYLogLevel as LYLogLevel, LYLogger, LYObject, LYObservable, LYOrganizationApp, LYOrganizationHttpClient, LYOwnerObservable, LYRedirectAuthorizer, LYSession, LYSessionStorage, LYTenantApp, LYTenantAuthorizer, LYTenantSession, LYWebAuthorizer, LYi18n, ORGANIZATION_APP_NAME, REMOTE_ENTRY, REMOTE_MODULE, TENANT_APP_NAME, crypto_crypto as crypto, isElectron, isIframe, i18n_langKeys as langKeys, languages, logger, observable_observe as observe, register, setCloudStorageImpl, setFormatter, setPrintToConsole, setStorage, sharedCloudStorage, sharedLocalStorage, wait, __webpack_exports__FRAMEWORK_NAME as FRAMEWORK_NAME };
 
 //# sourceMappingURL=index.js.map