@zeewain/3d-avatar-sdk 1.0.7

package/dist/index.esm.js

@@ -0,0 +1,753 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+class UnityLoader {
+    constructor(config) {
+        this.config = Object.assign(Object.assign({}, config), { containerId: config.containerId || 'unity-container' });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                // 创建容器
+                const container = this.createContainer();
+                // 加载UnityLoader脚本
+                this.loadUnityLoader().then(() => {
+                    // 创建Unity实例
+                    this.createUnityInstance(container, resolve, reject);
+                }).catch(reject);
+            });
+        });
+    }
+    createContainer() {
+        const container = document.getElementById('unity-container') || document.createElement('div');
+        container.style.width = '100%';
+        container.style.height = '100%';
+        container.style.position = 'relative';
+        const containertip = document.getElementById('unity-container-tip');
+        if (containertip) {
+            containertip.remove();
+        }
+        return container;
+    }
+    loadUnityLoader() {
+        return new Promise((resolve, reject) => {
+            if (window.createUnityInstance) {
+                return resolve();
+            }
+            const script = document.createElement('script');
+            script.src = this.config.loaderUrl;
+            script.async = true;
+            script.crossOrigin = 'anonymous';
+            script.onload = () => {
+                if (typeof window.createUnityInstance === 'function') {
+                    resolve();
+                }
+                else {
+                    reject(new Error('createUnityInstance function not found'));
+                }
+            };
+            script.onerror = (error) => {
+                reject(new Error(`Failed to load UnityLoader: ${error}`));
+            };
+            document.head.appendChild(script);
+        });
+    }
+    createUnityInstance(container, resolve, reject) {
+        const canvas = document.createElement('canvas');
+        canvas.id = 'unity-canvas';
+        canvas.width = 640;
+        canvas.height = 960;
+        canvas.style.width = '100%';
+        canvas.style.height = '100%';
+        canvas.style.background = '#ffffff';
+        container.appendChild(canvas);
+        // 移动设备适配
+        if (/iPhone|iPad|iPod|Android/i.test(navigator.userAgent)) {
+            const meta = document.createElement('meta');
+            meta.name = 'viewport';
+            meta.content = 'width=device-width, height=device-height, initial-scale=1.0, user-scalable=no, shrink-to-fit=yes';
+            document.head.appendChild(meta);
+            canvas.style.width = '100%';
+            canvas.style.height = '100%';
+            canvas.style.position = 'fixed';
+        }
+        if (typeof window.createUnityInstance === 'function') {
+            window.createUnityInstance(canvas, {
+                dataUrl: this.config.dataUrl,
+                frameworkUrl: this.config.frameworkUrl,
+                codeUrl: this.config.codeUrl,
+                companyName: '广州紫为云科技有限公司',
+                productName: '数字人SDK',
+                productVersion: '1.0'
+            }, (progress) => {
+                if (this.config.onProgress) {
+                    this.config.onProgress(progress);
+                }
+            }).then((instance) => {
+                resolve(instance);
+            }).catch((error) => {
+                reject(error);
+            });
+        }
+        else {
+            reject(new Error('createUnityInstance is not defined on window.'));
+        }
+    }
+}
+
+class AvatarAPI {
+    constructor(unityInstance, containerId) {
+        this.unityInstance = null;
+        this.avatarSDK = 'AvatarSDK';
+        // 存储待处理的 Promise 解析函数
+        this.pendingCallbacks = new Map();
+        this.unityInstance = unityInstance;
+        this.containerId = containerId;
+        // 注册单一全局回调函数
+        window.uniAvatarCallback = (operation, code, message, motionId, motionRemainingTime) => {
+            this.handleUnityCallback(operation, code, message, motionId, motionRemainingTime);
+        };
+    }
+    // 统一的回调处理
+    handleUnityCallback(operation, code, message, motionId, motionRemainingTime) {
+        const callback = this.pendingCallbacks.get(operation);
+        if (!callback) {
+            console.warn(`No pending callback for operation: ${operation}`);
+            return;
+        }
+        const response = {
+            success: code === 0,
+            message,
+            motionId,
+            motionRemainingTime
+        };
+        if (code === 0) {
+            callback.resolve(response);
+        }
+        else {
+            callback.reject(new Error(`Operation failed: ${message}`));
+        }
+        this.pendingCallbacks.delete(operation);
+    }
+    // 发送消息到 Unity 的辅助方法
+    sendUnityMessage(methodName, parameter) {
+        if (!this.unityInstance || typeof this.unityInstance.SendMessage !== 'function') {
+            throw new Error('Unity instance not initialized');
+        }
+        try {
+            const paramString = parameter !== undefined ? JSON.stringify(parameter) : '';
+            this.unityInstance.SendMessage(this.avatarSDK, methodName, paramString);
+        }
+        catch (error) {
+            console.error('Failed to send message to Unity:', error);
+            throw error;
+        }
+    }
+    // 检查并设置回调
+    setupCallback(operation) {
+        return new Promise((resolve, reject) => {
+            this.pendingCallbacks.set(operation, { resolve, reject });
+        });
+    }
+    // 公共 API 方法
+    initializeAvatar(token, avatarCode) {
+        const promise = this.setupCallback('initializeAvatar');
+        this.sendUnityMessage('InitializeAvatar', {
+            token,
+            avatarCode,
+            callbackFun: 'uniAvatarCallback',
+            operationType: 'initializeAvatar'
+        });
+        return promise;
+    }
+    playMotion(token, clipCode) {
+        const promise = this.setupCallback('playMotion');
+        console.log();
+        this.sendUnityMessage('PlayMotion', {
+            token,
+            clipCode,
+            callbackFun: 'uniAvatarCallback',
+            operationType: 'playMotion'
+        });
+        return promise;
+    }
+    getCurrentMotion(getRemainingTime) {
+        if (!this.unityInstance) {
+            return Promise.reject(new Error('Unity instance not initialized'));
+        }
+        const promise = this.setupCallback('getCurrentMotion');
+        this.sendUnityMessage('GetCurrentMotion', {
+            getRemainingTime,
+            callbackFun: 'uniAvatarCallback',
+            operationType: 'getCurrentMotion'
+        });
+        return promise;
+    }
+    unloadAvatar(token) {
+        const promise = this.setupCallback('unloadAvatar');
+        this.sendUnityMessage('UnloadAvatar', {
+            token,
+            callbackFun: 'uniAvatarCallback',
+            operationType: 'unloadAvatar'
+        });
+        return promise;
+    }
+}
+
+async function getBytes(stream, onChunk) {
+    const reader = stream.getReader();
+    let result;
+    while (!(result = await reader.read()).done) {
+        onChunk(result.value);
+    }
+}
+function getLines(onLine) {
+    let buffer;
+    let position;
+    let fieldLength;
+    let discardTrailingNewline = false;
+    return function onChunk(arr) {
+        if (buffer === undefined) {
+            buffer = arr;
+            position = 0;
+            fieldLength = -1;
+        }
+        else {
+            buffer = concat(buffer, arr);
+        }
+        const bufLength = buffer.length;
+        let lineStart = 0;
+        while (position < bufLength) {
+            if (discardTrailingNewline) {
+                if (buffer[position] === 10) {
+                    lineStart = ++position;
+                }
+                discardTrailingNewline = false;
+            }
+            let lineEnd = -1;
+            for (; position < bufLength && lineEnd === -1; ++position) {
+                switch (buffer[position]) {
+                    case 58:
+                        if (fieldLength === -1) {
+                            fieldLength = position - lineStart;
+                        }
+                        break;
+                    case 13:
+                        discardTrailingNewline = true;
+                    case 10:
+                        lineEnd = position;
+                        break;
+                }
+            }
+            if (lineEnd === -1) {
+                break;
+            }
+            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+            lineStart = position;
+            fieldLength = -1;
+        }
+        if (lineStart === bufLength) {
+            buffer = undefined;
+        }
+        else if (lineStart !== 0) {
+            buffer = buffer.subarray(lineStart);
+            position -= lineStart;
+        }
+    };
+}
+function getMessages(onId, onRetry, onMessage) {
+    let message = newMessage();
+    const decoder = new TextDecoder();
+    return function onLine(line, fieldLength) {
+        if (line.length === 0) {
+            onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+            message = newMessage();
+        }
+        else if (fieldLength > 0) {
+            const field = decoder.decode(line.subarray(0, fieldLength));
+            const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+            const value = decoder.decode(line.subarray(valueOffset));
+            switch (field) {
+                case 'data':
+                    message.data = message.data
+                        ? message.data + '\n' + value
+                        : value;
+                    break;
+                case 'event':
+                    message.event = value;
+                    break;
+                case 'id':
+                    onId(message.id = value);
+                    break;
+                case 'retry':
+                    const retry = parseInt(value, 10);
+                    if (!isNaN(retry)) {
+                        onRetry(message.retry = retry);
+                    }
+                    break;
+            }
+        }
+    };
+}
+function concat(a, b) {
+    const res = new Uint8Array(a.length + b.length);
+    res.set(a);
+    res.set(b, a.length);
+    return res;
+}
+function newMessage() {
+    return {
+        data: '',
+        event: '',
+        id: '',
+        retry: undefined,
+    };
+}
+
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+const EventStreamContentType = 'text/event-stream';
+const DefaultRetryInterval = 1000;
+const LastEventId = 'last-event-id';
+function fetchEventSource(input, _a) {
+    var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a, rest = __rest(_a, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+    return new Promise((resolve, reject) => {
+        const headers = Object.assign({}, inputHeaders);
+        if (!headers.accept) {
+            headers.accept = EventStreamContentType;
+        }
+        let curRequestController;
+        function onVisibilityChange() {
+            curRequestController.abort();
+            if (!document.hidden) {
+                create();
+            }
+        }
+        if (!openWhenHidden) {
+            document.addEventListener('visibilitychange', onVisibilityChange);
+        }
+        let retryInterval = DefaultRetryInterval;
+        let retryTimer = 0;
+        function dispose() {
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+            window.clearTimeout(retryTimer);
+            curRequestController.abort();
+        }
+        inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener('abort', () => {
+            dispose();
+            resolve();
+        });
+        const fetch = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+        const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+        async function create() {
+            var _a;
+            curRequestController = new AbortController();
+            try {
+                const response = await fetch(input, Object.assign(Object.assign({}, rest), { headers, signal: curRequestController.signal }));
+                await onopen(response);
+                await getBytes(response.body, getLines(getMessages(id => {
+                    if (id) {
+                        headers[LastEventId] = id;
+                    }
+                    else {
+                        delete headers[LastEventId];
+                    }
+                }, retry => {
+                    retryInterval = retry;
+                }, onmessage)));
+                onclose === null || onclose === void 0 ? void 0 : onclose();
+                dispose();
+                resolve();
+            }
+            catch (err) {
+                if (!curRequestController.signal.aborted) {
+                    try {
+                        const interval = (_a = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a !== void 0 ? _a : retryInterval;
+                        window.clearTimeout(retryTimer);
+                        retryTimer = window.setTimeout(create, interval);
+                    }
+                    catch (innerErr) {
+                        dispose();
+                        reject(innerErr);
+                    }
+                }
+            }
+        }
+        create();
+    });
+}
+function defaultOnOpen(response) {
+    const contentType = response.headers.get('content-type');
+    if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+        throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
+    }
+}
+
+// src/core/config/env.ts
+/**
+ * 环境配置映射
+ */
+const ENV_MAP = {
+    dev: {
+        apiBaseUrl: 'https://dev.local.zeewain.com/api/dh-talker'
+    },
+    test: {
+        apiBaseUrl: 'https://test.local.zeewain.com/api/dh-talker'
+    },
+    prod: {
+        apiBaseUrl: 'https://aiip.zeewain.com/api/dh-talker'
+    }
+};
+/**
+ * 获取当前环境配置
+ * @param env 环境类型
+ * @returns 环境配置对象
+ */
+function getEnvConfig(env = 'dev') {
+    return ENV_MAP[env] || ENV_MAP.dev;
+}
+
+// src/core/interfaces/broadcast.ts
+/**
+* 流式播报服务接口定义
+*/
+// 播报类型枚举
+var BroadcastType;
+(function (BroadcastType) {
+    BroadcastType["TEXT"] = "text";
+    BroadcastType["CUSTOM_AUDIO"] = "customAudio"; // 自定义音频智能体播报
+})(BroadcastType || (BroadcastType = {}));
+
+/**
+ * 流式播报服务类
+ */
+class BroadcastService {
+    constructor(env = 'prod', getToken, unityInstance, instanceId, callbacks) {
+        this.env = env;
+        this.getToken = getToken;
+        this.unityInstance = unityInstance;
+        this.controller = null;
+        this.avatarSDK = 'AvatarSDK';
+        // 存储待处理的 Promise 解析函数
+        this.pendingCallbacks = new Map();
+        // 事件回调
+        this.callbacks = {};
+        this.instanceId = instanceId;
+        if (callbacks) {
+            this.callbacks = callbacks;
+        }
+        // 注册统一全局回调函数
+        window.uniBroadcastCallback = (operation, code, message) => {
+            this.handleUnityCallback(operation, code, message);
+        };
+    }
+    // 统一的回调处理
+    handleUnityCallback(operation, code, message) {
+        var _a, _b, _c, _d, _e, _f;
+        const callback = this.pendingCallbacks.get(operation);
+        if (!callback) {
+            console.warn(`No pending callback for operation: ${operation}`);
+            return;
+        }
+        const response = {
+            success: code === 0,
+            message
+        };
+        if (code === 0) {
+            callback.resolve(response);
+        }
+        else {
+            callback.reject(new Error(`Operation failed: ${message}`));
+        }
+        this.pendingCallbacks.delete(operation);
+        // 触发事件回调
+        switch (operation) {
+            case 'pauseBroadcast':
+                if (code === 0) {
+                    (_b = (_a = this.callbacks).onPause) === null || _b === void 0 ? void 0 : _b.call(_a);
+                }
+                break;
+            case 'resumeBroadcast':
+                if (code === 0) {
+                    (_d = (_c = this.callbacks).onResume) === null || _d === void 0 ? void 0 : _d.call(_c);
+                }
+                break;
+            case 'stopBroadcast':
+                if (code === 0) {
+                    (_f = (_e = this.callbacks).onStop) === null || _f === void 0 ? void 0 : _f.call(_e);
+                }
+                break;
+        }
+    }
+    // 设置回调的公共方法
+    setupCallback(operation) {
+        return new Promise((resolve, reject) => {
+            this.pendingCallbacks.set(operation, { resolve, reject });
+        });
+    }
+    /**
+     * 获取API基础URL
+     */
+    getApiBaseUrl() {
+        return getEnvConfig(this.env).apiBaseUrl;
+    }
+    /**
+     * 获取播报API路径
+     * @param type 播报类型
+     */
+    getBroadcastApiPath(type) {
+        switch (type) {
+            case BroadcastType.TEXT:
+                return '/user/agent/broadcast/text';
+            case BroadcastType.CUSTOM_AUDIO:
+                return '/user/agent/broadcast/customAudio';
+            default:
+                throw new Error(`未知的播报类型: ${type}`);
+        }
+    }
+    /**
+     * 设置回调
+     * @param callbacks 回调对象
+     */
+    setCallbacks(callbacks) {
+        this.callbacks = Object.assign(Object.assign({}, this.callbacks), callbacks);
+    }
+    /**
+     * 开始播报
+     * @param params 播报参数
+     */
+    startBroadcast(token, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            yield this.stopBroadcast(token);
+            this.controller = new AbortController();
+            (_b = (_a = this.callbacks).onStart) === null || _b === void 0 ? void 0 : _b.call(_a);
+            // 通知Unity开始新任务（清空队列）
+            this.sendUnityMessage('StartBroadcast', {
+                token,
+                callbackFun: 'uniBroadcastCallback',
+                operationType: 'startBroadcast'
+            });
+            try {
+                const apiUrl = `${this.getApiBaseUrl()}${this.getBroadcastApiPath(params.type)}`;
+                const requestBody = {
+                    humanCode: params.humanCode,
+                    speed: params.speed,
+                    volume: params.volume,
+                    isSubtitle: params.isSubtitle
+                };
+                // 根据播报类型
+                if (params.type === BroadcastType.TEXT) {
+                    if (!params.text || !params.voiceCode) {
+                        throw new Error('文本播报需要提供text和voiceCode参数');
+                    }
+                    requestBody.text = params.text;
+                    requestBody.voiceCode = params.voiceCode;
+                }
+                else if (params.type === BroadcastType.CUSTOM_AUDIO) {
+                    if (!params.audioUrl) {
+                        throw new Error('自定义音频播报需要提供audioUrl参数');
+                    }
+                    requestBody.text = params.text;
+                    requestBody.audioUrl = params.audioUrl;
+                }
+                console.log('请求参数:', requestBody);
+                yield fetchEventSource(apiUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x_auth_token': this.getToken()
+                    },
+                    body: JSON.stringify(requestBody),
+                    signal: this.controller.signal,
+                    openWhenHidden: true,
+                    onmessage: (event) => {
+                        try {
+                            const response = JSON.parse(event.data);
+                            console.log('收到播报数据:', response);
+                            if (params.type === BroadcastType.CUSTOM_AUDIO && params.audioUrl && !response.data.voiceUrl) {
+                                response.data.voiceUrl = params.audioUrl;
+                            }
+                            // 错误处理
+                            if (response.code !== 0) {
+                                throw new Error(response.message || 'Unknown server error');
+                            }
+                            if (response.data.voiceUrl) {
+                                console.log('发送数据到Unity:', response);
+                                this.sendUnityMessage('AppendBroadcast', {
+                                    token,
+                                    response,
+                                    callbackFun: 'uniBroadcastCallback',
+                                    operationType: 'appendBroadcast'
+                                });
+                            }
+                        }
+                        catch (error) {
+                            this.handleError(error);
+                        }
+                    },
+                    onclose: () => {
+                        var _a, _b;
+                        // 流结束时调用完成回调
+                        (_b = (_a = this.callbacks).onFinish) === null || _b === void 0 ? void 0 : _b.call(_a);
+                    }
+                });
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        });
+    }
+    /**
+     * 暂停播报
+     */
+    pauseBroadcast(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promise = this.setupCallback('pauseBroadcast');
+            // 发送暂停消息到Unity
+            this.sendUnityMessage('PauseBroadcast', {
+                token,
+                callbackFun: 'uniBroadcastCallback',
+                operationType: 'pauseBroadcast'
+            });
+            yield promise;
+        });
+    }
+    /**
+     * 继续播报
+     */
+    resumeBroadcast(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promise = this.setupCallback('resumeBroadcast');
+            // 发送继续消息到Unity
+            this.sendUnityMessage('ResumeBroadcast', {
+                token,
+                callbackFun: 'uniBroadcastCallback',
+                operationType: 'resumeBroadcast'
+            });
+            // 等待Unity确认
+            yield promise;
+        });
+    }
+    /**
+     * 中断播报
+     */
+    stopBroadcast(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 如果已有停止操作在进行，直接返回
+            const promise = this.setupCallback('stopBroadcast');
+            // 中止请求
+            if (this.controller) {
+                this.controller.abort();
+            }
+            // 发送停止消息到Unity
+            this.sendUnityMessage('StopBroadcast', {
+                token,
+                callbackFun: 'uniBroadcastCallback',
+                operationType: 'stopBroadcast'
+            });
+            this.controller = null;
+            yield promise;
+        });
+    }
+    /**
+     * 错误处理
+     * @param error 错误对象
+     */
+    handleError(error) {
+        var _a, _b;
+        (_b = (_a = this.callbacks).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+        console.error('播报错误:', error);
+    }
+    // 发送消息到 Unity 的辅助方法
+    sendUnityMessage(methodName, parameter) {
+        if (!this.unityInstance || typeof this.unityInstance.SendMessage !== 'function') {
+            throw new Error('Unity instance not initialized');
+        }
+        try {
+            const paramString = parameter !== undefined ? JSON.stringify(parameter) : '';
+            this.unityInstance.SendMessage(this.avatarSDK, methodName, paramString);
+        }
+        catch (error) {
+            console.error('Failed to send message to Unity:', error);
+            throw error;
+        }
+    }
+}
+
+class ZEEAvatarLoader {
+    constructor(config) {
+        this.api = null;
+        this.unityInstance = null;
+        this.loader = new UnityLoader(config);
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.unityInstance = yield this.loader.init();
+            this.api = new AvatarAPI(this.unityInstance, this.loader.config.containerId || 'unity-container');
+            return this.api;
+        });
+    }
+    getAPI() {
+        return this.api;
+    }
+    getInstance() {
+        return this.unityInstance;
+    }
+    getContainerId() {
+        return this.loader.config.containerId || 'unity-container';
+    }
+    destroy() {
+        if (this.unityInstance) {
+            const container = document.getElementById(this.loader.config.containerId || 'unity-container');
+            if (container) {
+                container.remove();
+            }
+            if (typeof this.unityInstance.Quit === 'function') {
+                this.unityInstance.Quit();
+            }
+            this.unityInstance = null;
+            this.api = null;
+        }
+    }
+}
+
+export { AvatarAPI, BroadcastService, ZEEAvatarLoader };