@zhongguo168a/yxeditor-common 0.0.8 → 0.0.9

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-import { HorizontalTextAlignment, VerticalTextAlignment, Scheduler, Prefab, Node, Component, ISchedulable, Vec2, Vec3, Vec4, AssetManager, SpriteAtlas } from 'cc';
+import { HorizontalTextAlignment, VerticalTextAlignment, Scheduler, Prefab, Node, Component, ISchedulable, AssetManager, Asset, SpriteAtlas, Vec2, Vec3, Vec4 } from 'cc';
+import { Dispatcher as Dispatcher$1 } from 'db://assets/core/libs/event';
+import { List as List$1 } from 'db://assets/core/libs/ds';
+import { AssetURI as AssetURI$1 } from 'db://assets/core/libs/loader/AssetManager';
 
 interface error {
     isCancel(): boolean;
@@ -1289,6 +1292,95 @@ declare class Dispatcher implements ISchedulable {
     protected typeToList: Dictionary<string, CallbackList<any>>;
 }
 
+declare class LoaderItem {
+    onComplete?: (err: any, asset: any) => void;
+    callHandler(err: any, asset: any): void;
+    getBundle(): AssetManager.Bundle;
+    type: string;
+    bundle: AssetManager.Bundle;
+    uri: AssetURI$1;
+    preload: boolean;
+    error: any;
+}
+/**
+ * uri格式:path, uuid://uuid, https://url
+ */
+declare class AssetLoader extends Dispatcher$1 {
+    /**
+     *
+     * @param bundleName
+     * @param otherConfig preload:是预加载-否-加载, 包中的资源
+     */
+    loadBundle(bundleName: string, otherConfig?: {
+        onComplete?: (err: any, asset: any) => void;
+        preload?: boolean;
+    }): this;
+    /**
+     * @param uri
+     * @param otherConfig
+     */
+    loadAtlas(uri: string, otherConfig?: {
+        onComplete?: (err: any, asset: any) => void;
+        preload?: boolean;
+    }): this;
+    loadPrefab(uri: string, otherConfig?: {
+        onComplete?: (err: any, asset: any) => void;
+        preload?: boolean;
+    }): this;
+    loadConfig(uri: string): this;
+    loadSpriteFrame(uri: string, otherConfig?: {
+        onComplete?: (err: any, asset: any) => void;
+        uuid?: string;
+    }): this;
+    loadImageAsset(uri: string, otherConfig?: {
+        onHandler?: (err: any, asset: any) => void;
+    }): this;
+    protected _loadSpriteFrameByBundle(uri: string, bundle: AssetManager.Bundle): void;
+    /**
+     * 等待发送的结果
+     * 如果返回 null，表示主动取消 [cancel]
+     */
+    wait(): Promise<this>;
+    start(): this;
+    onComplete(val: (loader: AssetLoader) => void): this;
+    onProgress(val: (loader: AssetLoader) => void): this;
+    isComplete(): boolean;
+    protected validComplete(): void;
+    protected parseBundleToAssetsLoader(bundle: AssetManager.Bundle, loaderItem: LoaderItem): AssetLoader;
+    protected handleAtlas(item: LoaderItem, atlasAsset: Asset): void;
+    protected _loadByItem(item: LoaderItem, type: any, onComplate: (err: any, asset: any) => void): void;
+    getLoaded(): number;
+    getTotle(): number;
+    getSucceed(): number;
+    getFail(): number;
+    getFailList(): List$1<LoaderItem>;
+    protected _handleFailList(err: any, item: any): void;
+    stop(): void;
+    protected _stop: boolean;
+    protected _onCompleteHandler: Function;
+    protected _onProgressHandler: Function;
+    protected _loaded: number;
+    protected _loaderList: any;
+    protected _failList: any;
+}
+
+declare class AssetURI {
+    name: string;
+    constructor(name: string);
+    loadType: number;
+    uuid: string;
+    path: string;
+    bundle: string;
+}
+declare class XAssetManager {
+    getAsset(uri: string): any;
+    getAssetByUUID(uuid: string): any;
+    getRoot(): AssetManager;
+}
+declare let assetx: XAssetManager;
+
+declare function parseAtlas(name: any, plist: any, texture: any): SpriteAtlas;
+
 type CreatorFunction = (...args: any[]) => {};
 /**
  * 回收的方法
@@ -1760,5 +1852,5 @@ declare const pathutil: PathUtil;
 declare function parsePlist(plist: any, texture: any): SpriteAtlas;
 declare function loadAtlas(url: any, callback: any): void;
 
-export { ArrayUtil, BitUtil, CallbackList, Controller, ControllerDict, ControllerSet, ConvertUtil, DictIterator, DictNode, DictSource, Dictionary, Dispatcher, ErrorUtil, EventItem, EventManager, EventUtil, Factory, FloatUtil, GeometryUtil, IdentUtil, LinkError, List, ListIterator, ListNode, ListSource, Listener, MapUtil, MathUtil, Model, Module, NetUtil, Page, PageController, PageEvent, PageLayer, PageList, PageRepo, PageState, PathUtil, Pool, RandUtil, Route, SamplePool, ScaleUtil, SimpleModel, StringUtil, TimeUtil, Timer, TreeIterator, TreeNode, TreeNodePlugin, TreeRoot, TreeRootPlugin, UIManager, UIObjectDict, UIPoolConfig, UISingleConfig, UIUtil, ViewController, XEvent, arrayutil, bitutil, convertutil, ctrlrepo, errorutil, eventmgr, eventutil, floatutil, formatutil, geoutil, identutil, loadAtlas, maputil, mathutil, netutil, pagerepo, parsePlist, pathutil, randutil, resutil, scaleutil, stringutil, timeutil, uidict, uimgr, uiutil };
+export { ArrayUtil, AssetLoader, AssetURI, BitUtil, CallbackList, Controller, ControllerDict, ControllerSet, ConvertUtil, DictIterator, DictNode, DictSource, Dictionary, Dispatcher, ErrorUtil, EventItem, EventManager, EventUtil, Factory, FloatUtil, GeometryUtil, IdentUtil, LinkError, List, ListIterator, ListNode, ListSource, Listener, MapUtil, MathUtil, Model, Module, NetUtil, Page, PageController, PageEvent, PageLayer, PageList, PageRepo, PageState, PathUtil, Pool, RandUtil, Route, SamplePool, ScaleUtil, SimpleModel, StringUtil, TimeUtil, Timer, TreeIterator, TreeNode, TreeNodePlugin, TreeRoot, TreeRootPlugin, UIManager, UIObjectDict, UIPoolConfig, UISingleConfig, UIUtil, ViewController, XAssetManager, XEvent, arrayutil, assetx, bitutil, convertutil, ctrlrepo, errorutil, eventmgr, eventutil, floatutil, formatutil, geoutil, identutil, loadAtlas, maputil, mathutil, netutil, pagerepo, parseAtlas, parsePlist, pathutil, randutil, resutil, scaleutil, stringutil, timeutil, uidict, uimgr, uiutil };
 export type { CreatorFunction, DisposeFunction, IController, IEventManager, IExtend, IListItem, IModel, IModule, IModuleSample, ITreeListItem, RecycleFunction, error };

package/dist/index.esm.js

@@ -1,4 +1,8 @@
-import { HorizontalTextAlignment, VerticalTextAlignment, Scheduler, macro, director, instantiate, math, Component, Vec2, Vec3, UITransform, Vec4, SpriteAtlas, SpriteFrame, path, assetManager, Texture2D, Rect, Size, resources } from 'cc';
+import { HorizontalTextAlignment, VerticalTextAlignment, Scheduler, macro, director, instantiate, math, Component, ImageAsset, SpriteFrame, SpriteAtlas, assetManager, JsonAsset, TextAsset, Asset, path, Texture2D, Size, Vec2, Rect, Vec3, UITransform, Vec4, resources } from 'cc';
+import { parseAtlas as parseAtlas$1 } from 'db://assets/core/libs/loader/ParseAtlas';
+import { Dispatcher as Dispatcher$1, Listener as Listener$1 } from 'db://assets/core/libs/event';
+import { List as List$1 } from 'db://assets/core/libs/ds';
+import { AssetURI as AssetURI$1, assetx as assetx$1 } from 'db://assets/core/libs/loader/AssetManager';
 
 class NetUtil {
     // 获取URL的参数对象
@@ -4327,6 +4331,509 @@ class Dispatcher {
     }
 }
 
+class LoaderItem {
+    constructor() {
+        this.preload = false;
+    }
+    callHandler(err, asset) {
+        if (this.onComplete) {
+            this.onComplete(err, asset);
+        }
+    }
+    getBundle() {
+        let bundle = this.bundle;
+        if (!bundle) {
+            bundle = assetManager.getBundle(this.uri.bundle);
+            this.bundle = bundle;
+        }
+        return bundle;
+    }
+}
+/**
+ * uri格式:path, uuid://uuid, https://url
+ */
+class AssetLoader extends Dispatcher$1 {
+    constructor() {
+        super(...arguments);
+        this._stop = false;
+        this._loaded = 0;
+        this._loaderList = new List$1();
+        this._failList = new List$1();
+    }
+    /**
+     *
+     * @param bundleName
+     * @param otherConfig preload:是预加载-否-加载, 包中的资源
+     */
+    loadBundle(bundleName, otherConfig) {
+        let item = new LoaderItem();
+        item.type = "Bundle";
+        item.uri = new AssetURI$1(`${bundleName}://bundle`);
+        if (otherConfig) {
+            item.preload = otherConfig.preload;
+            item.onComplete = otherConfig.onComplete;
+        }
+        this._loaderList.push(item);
+        return this;
+    }
+    /**
+     * @param uri
+     * @param otherConfig
+     */
+    loadAtlas(uri, otherConfig) {
+        let item = new LoaderItem();
+        item.type = "Atlas";
+        // 加载json文件
+        item.uri = new AssetURI$1(uri);
+        if (otherConfig) {
+            item.onComplete = otherConfig.onComplete;
+            item.preload = otherConfig.preload != undefined ? otherConfig.preload : false;
+        }
+        this._loaderList.push(item);
+        return this;
+    }
+    loadPrefab(uri, otherConfig) {
+        let item = new LoaderItem();
+        item.type = "Prefab";
+        // 加载json文件
+        item.uri = new AssetURI$1(uri);
+        if (otherConfig) {
+            item.onComplete = otherConfig.onComplete;
+            item.preload = otherConfig.preload != undefined ? otherConfig.preload : false;
+        }
+        this._loaderList.push(item);
+        return this;
+    }
+    loadConfig(uri) {
+        let item = new LoaderItem();
+        item.type = "Config";
+        item.uri = new AssetURI$1(uri);
+        this._loaderList.push(item);
+        return this;
+    }
+    loadSpriteFrame(uri, otherConfig) {
+        let item = new LoaderItem();
+        item.type = "SpriteFrame";
+        item.uri = new AssetURI$1(uri);
+        if (otherConfig) {
+            item.onComplete = otherConfig.onComplete;
+        }
+        this._loaderList.push(item);
+        return this;
+    }
+    loadImageAsset(uri, otherConfig) {
+        let item = new LoaderItem();
+        item.type = "ImageAsset";
+        item.uri = new AssetURI$1(uri);
+        if (otherConfig) {
+            item.onComplete = otherConfig.onHandler;
+        }
+        this._loaderList.push(item);
+        return this;
+    }
+    _loadSpriteFrameByBundle(uri, bundle) {
+        let item = new LoaderItem();
+        item.type = "SpriteFrame";
+        item.uri = new AssetURI$1(`${bundle.name}://${uri}`);
+        item.bundle = bundle;
+        this._loaderList.push(item);
+    }
+    /**
+     * 等待发送的结果
+     * 如果返回 null，表示主动取消 [cancel]
+     */
+    wait() {
+        return new Promise((resolve, reject) => {
+            if (this.isComplete()) {
+                resolve(this);
+            }
+            else {
+                let listener = Listener$1.create();
+                let succeed = () => {
+                    listener.off();
+                    resolve(this);
+                };
+                listener.setCaller(this).setHandler(succeed).on();
+                this.create("complete", listener);
+            }
+        });
+    }
+    start() {
+        this._loaderList.forEach((index, item) => {
+            switch (item.type) {
+                case "Bundle": {
+                    assetManager.loadBundle(item.uri.bundle, (err, bundle) => {
+                        if (err) {
+                            return;
+                        }
+                        let loader = this.parseBundleToAssetsLoader(bundle, item);
+                        loader.onComplete(() => {
+                            this._loaded++;
+                            this.validComplete();
+                        });
+                        loader.start();
+                    });
+                    break;
+                }
+                case "Config": {
+                    assetManager.loadBundle(item.uri.bundle, (err, bundle) => {
+                        if (this._stop) {
+                            return;
+                        }
+                        if (err) {
+                            return;
+                        }
+                        this._loaded++;
+                        this.validComplete();
+                    });
+                    break;
+                }
+                case "Atlas": {
+                    let asset = assetx$1.getAsset(item.uri.name);
+                    if (asset) {
+                        if (asset instanceof SpriteAtlas) {
+                            this._loaded++;
+                            item.callHandler(null, asset);
+                            this.validComplete();
+                        }
+                        else {
+                            this.handleAtlas(item, asset);
+                        }
+                    }
+                    else {
+                        // json文件
+                        this._loadByItem(item, null, (err, asset) => {
+                            if (!err) {
+                                this.handleAtlas(item, asset);
+                            }
+                            else {
+                                this._loaded++;
+                                this.validComplete();
+                            }
+                        });
+                    }
+                    break;
+                }
+                case "Prefab": {
+                    let asset = assetx$1.getAsset(item.uri.name);
+                    if (asset) {
+                        this._loaded++;
+                        item.callHandler(null, asset);
+                        this.validComplete();
+                    }
+                    else {
+                        this._loadByItem(item, null, (err, asset) => {
+                            this._loaded++;
+                            item.callHandler(err, asset);
+                            this.validComplete();
+                        });
+                    }
+                    break;
+                }
+                case "SpriteFrame": {
+                    this._loadByItem(item, SpriteFrame, (err, asset) => {
+                        this._loaded++;
+                        this.validComplete();
+                    });
+                    break;
+                }
+                case "ImageAsset": {
+                    this._loadByItem(item, ImageAsset, (err, asset) => {
+                        this._loaded++;
+                        this.validComplete();
+                    });
+                    break;
+                }
+            }
+        });
+        return this;
+    }
+    onComplete(val) {
+        this._onCompleteHandler = val;
+        return this;
+    }
+    onProgress(val) {
+        this._onProgressHandler = val;
+        return this;
+    }
+    isComplete() {
+        return this._loaded == this._loaderList.length;
+    }
+    validComplete() {
+        if (this._stop) {
+            return;
+        }
+        if (this._onProgressHandler) {
+            this._onProgressHandler(this);
+        }
+        if (this._loaded == this._loaderList.length) {
+            if (this._onCompleteHandler) {
+                this._onCompleteHandler(this);
+            }
+            this.dispatch("complete");
+        }
+    }
+    parseBundleToAssetsLoader(bundle, loaderItem) {
+        let loader = new AssetLoader();
+        // @ts-ignore
+        let map = bundle._config.assetInfos._map;
+        for (const mapKey in map) {
+            let assetInfo = map[mapKey];
+            if (!assetInfo.ctor) {
+                continue;
+            }
+            switch (assetInfo.ctor.name) {
+                case "ImageAsset":
+                    break;
+                case "Prefab":
+                    break;
+                case "SpriteFrame":
+                    loader._loadSpriteFrameByBundle(assetInfo.path, bundle);
+                    break;
+            }
+        }
+        return loader;
+    }
+    handleAtlas(item, atlasAsset) {
+        let content = (() => {
+            if (atlasAsset instanceof JsonAsset) {
+                return atlasAsset.json;
+            }
+            else if (atlasAsset instanceof TextAsset) {
+                return JSON.parse(atlasAsset.text);
+            }
+            else if (atlasAsset instanceof Asset) {
+                return JSON.parse(atlasAsset.nativeAsset);
+            }
+        })();
+        let textureUrl = "";
+        let textureItem = new LoaderItem();
+        switch (item.uri.loadType) {
+            case 2:
+                textureItem.type = "ImageAsset";
+                textureUrl = path.join(path.dirname(item.uri.name), content.meta.image);
+                break;
+            case 1:
+                textureItem.type = "ImageAsset";
+                textureUrl = atlasAsset._nativeUrl;
+                break;
+            case 0:
+                textureItem.type = "ImageAsset";
+                textureUrl = item.uri.name;
+                break;
+        }
+        textureItem.uri = new AssetURI$1(textureUrl);
+        //
+        this._loadByItem(textureItem, ImageAsset, (err, asset) => {
+            if (!err) {
+                let tex = new Texture2D();
+                tex.image = asset;
+                tex.setFilters(1, 1);
+                let atlasSprite = parseAtlas$1(item.uri, content, tex);
+                let uuid = atlasAsset.uuid;
+                assetManager.assets.remove(uuid);
+                assetManager.assets.add(uuid, atlasSprite);
+                //
+                item.callHandler(null, atlasSprite);
+            }
+            this._loaded++;
+            this.validComplete();
+        });
+    }
+    _loadByItem(item, type, onComplate) {
+        switch (item.uri.loadType) {
+            case 0: {
+                let bundle = item.getBundle();
+                if (!bundle) ;
+                else {
+                    if (item.preload) {
+                        bundle.preload(item.uri.path, type, (err, asset) => {
+                            if (this._stop) {
+                                return;
+                            }
+                            this._handleFailList(err, item);
+                            onComplate(err, asset);
+                        });
+                    }
+                    else {
+                        bundle.load(item.uri.path, type, (err, asset) => {
+                            if (this._stop) {
+                                return;
+                            }
+                            this._handleFailList(err, item);
+                            onComplate(err, asset);
+                        });
+                    }
+                }
+                break;
+            }
+            case 1: {
+                if (item.preload) {
+                    assetManager.preloadAny({ uuid: item.uri.uuid }, { type: type }, (err, asset) => {
+                        if (this._stop) {
+                            return;
+                        }
+                        this._handleFailList(err, item);
+                        onComplate(err, asset);
+                    });
+                }
+                else {
+                    assetManager.loadAny({ uuid: item.uri.uuid }, { type: type }, (err, asset) => {
+                        if (this._stop) {
+                            return;
+                        }
+                        this._handleFailList(err, item);
+                        onComplate(err, asset);
+                    });
+                }
+                break;
+            }
+            case 2: {
+                assetManager.loadRemote(item.uri.name, (err, asset) => {
+                    this._handleFailList(err, item);
+                    if (this._stop) {
+                        return;
+                    }
+                    onComplate(err, asset);
+                });
+            }
+        }
+    }
+    // 获取已经加载的数量，报错加载失败的
+    getLoaded() {
+        return this._loaded;
+    }
+    getTotle() {
+        return this._loaderList.length;
+    }
+    // 获取成功的数量
+    getSucceed() {
+        return this._loaded - this.getFail();
+    }
+    // 获取失败的数量
+    getFail() {
+        return this._failList.length;
+    }
+    getFailList() {
+        return this._failList;
+    }
+    _handleFailList(err, item) {
+        if (err) {
+            console.error(err.toString());
+            item.error = err;
+            this._failList.push(item);
+        }
+    }
+    stop() {
+        this._stop = true;
+    }
+}
+
+class AssetURI {
+    constructor(name) {
+        this.name = name;
+        // 0-bundle+path 1-uuid  2-remote
+        this.loadType = 0;
+        let arr = name.split("://");
+        if (arr.length == 2) {
+            let head = arr[0];
+            if (head == "uuid") {
+                this.loadType = 1;
+                this.uuid = arr[1];
+            }
+            else if (head == "http" || head == "https") {
+                this.loadType = 2;
+            }
+            else {
+                this.bundle = head;
+                this.path = arr[1];
+            }
+        }
+        else {
+            this.bundle = "resources";
+            this.path = name;
+        }
+    }
+}
+class XAssetManager {
+    getAsset(uri) {
+        let obj = new AssetURI(uri);
+        switch (obj.loadType) {
+            case 1:
+                return assetManager.assets.get(obj.uuid);
+            case 2:
+                return assetManager.assets.get(obj.name);
+            default:
+                let bundle = assetManager.getBundle(obj.bundle);
+                if (!bundle) {
+                    return null;
+                }
+                return bundle.get(obj.path);
+        }
+    }
+    getAssetByUUID(uuid) {
+        return assetManager.assets.get(uuid);
+    }
+    getRoot() {
+        return assetManager;
+    }
+}
+let assetx = new XAssetManager();
+
+function parseAtlas(name, plist, texture) {
+    plist.meta;
+    let frames = plist.frames;
+    let atlas = new SpriteAtlas();
+    atlas.name = name;
+    atlas._nativeAsset = plist;
+    let spriteFrames = atlas.spriteFrames;
+    // 1/1_1_0.png:{
+    //     frame: {x: 137, y: 302, w: 18, h: 24}
+    //     rotated: false
+    //     sourceSize: {w: 32, h: 32}
+    //     spriteSourceSize: {x: 7, y: 0, w: 18, h: 24}
+    //     trimmed: true
+    // }
+    let maxWidth = 0;
+    let maxHeight = 0;
+    for (let key in frames) {
+        let frame = frames[key];
+        let rotated = false, sourceSize, offset, textureRect;
+        rotated = frame.rotated;
+        {
+            let size = frame.sourceSize;
+            sourceSize = new Size(size.w, size.h);
+            maxWidth = Math.max(maxWidth, size.w);
+            maxHeight = Math.max(maxHeight, size.h);
+        }
+        { // 需要转化成以sourceSize的中心点为原点，cocos坐标系的偏移量
+            let pos = frame.spriteSourceSize;
+            offset = new Vec2(pos.x + pos.w * 0.5, pos.y + pos.h * 0.5);
+            offset.x -= sourceSize.width * 0.5;
+            offset.y -= sourceSize.height * 0.5;
+            offset.y = -offset.y; // y轴相反
+        }
+        {
+            let rect = frame.frame;
+            textureRect = new Rect(rect.x, rect.y, rect.w, rect.h);
+        }
+        var sprite = new SpriteFrame();
+        sprite.name = key;
+        sprite.reset({
+            originalSize: sourceSize,
+            rect: textureRect,
+            offset: offset,
+            isRotate: !!rotated,
+            texture: texture
+        });
+        let name = path.mainFileName(key);
+        spriteFrames[name] = sprite;
+    }
+    //
+    plist.meta.maxSize = { w: maxWidth, h: maxHeight };
+    return atlas;
+}
+
 class UIUtil {
     /**
      * 格式化节点的uuid，用于树结构
@@ -5491,5 +5998,5 @@ class PathUtil {
 }
 const pathutil = new PathUtil();
 
-export { ArrayUtil, BitUtil, CallbackList, Controller, ControllerDict, ControllerSet, ConvertUtil, DictIterator, DictNode, DictSource, Dictionary, Dispatcher, ErrorUtil, EventItem, EventManager, EventUtil, Factory, FloatUtil, GeometryUtil, IdentUtil, LinkError, List, ListIterator, ListNode, ListSource, Listener, MapUtil, MathUtil, Model, Module, NetUtil, Page, PageController, PageEvent, PageLayer, PageList, PageRepo, PageState, PathUtil, Pool, RandUtil, Route, SamplePool, ScaleUtil, SimpleModel, StringUtil, TimeUtil, Timer, TreeIterator, TreeNode, TreeNodePlugin, TreeRoot, TreeRootPlugin, UIManager, UIObjectDict, UIPoolConfig, UISingleConfig, UIUtil, ViewController, XEvent, arrayutil, bitutil, convertutil, ctrlrepo, errorutil, eventmgr, eventutil, floatutil, formatutil, geoutil, identutil, loadAtlas, maputil, mathutil, netutil, pagerepo, parsePlist, pathutil, randutil, resutil, scaleutil, stringutil, timeutil, uidict, uimgr, uiutil };
+export { ArrayUtil, AssetLoader, AssetURI, BitUtil, CallbackList, Controller, ControllerDict, ControllerSet, ConvertUtil, DictIterator, DictNode, DictSource, Dictionary, Dispatcher, ErrorUtil, EventItem, EventManager, EventUtil, Factory, FloatUtil, GeometryUtil, IdentUtil, LinkError, List, ListIterator, ListNode, ListSource, Listener, MapUtil, MathUtil, Model, Module, NetUtil, Page, PageController, PageEvent, PageLayer, PageList, PageRepo, PageState, PathUtil, Pool, RandUtil, Route, SamplePool, ScaleUtil, SimpleModel, StringUtil, TimeUtil, Timer, TreeIterator, TreeNode, TreeNodePlugin, TreeRoot, TreeRootPlugin, UIManager, UIObjectDict, UIPoolConfig, UISingleConfig, UIUtil, ViewController, XAssetManager, XEvent, arrayutil, assetx, bitutil, convertutil, ctrlrepo, errorutil, eventmgr, eventutil, floatutil, formatutil, geoutil, identutil, loadAtlas, maputil, mathutil, netutil, pagerepo, parseAtlas, parsePlist, pathutil, randutil, resutil, scaleutil, stringutil, timeutil, uidict, uimgr, uiutil };
 //# sourceMappingURL=index.esm.js.map